Changeset e7bb58a in rtems-testing


Ignore:
Timestamp:
May 25, 2010, 7:14:48 PM (9 years ago)
Author:
Jennifer Averett <Jennifer.Averett@…>
Branches:
4.11, 8895273c193787f84c4585a10f6d6aceb3b25dc4
Children:
e662966
Parents:
2b85270
Message:

2010-05-25 Jennifer Averett <Jennifer.Averett@…>

  • DesiredSymbols?.cc, Explanations.cc, ObjdumpProcessor?.cc, TraceReaderLogQEMU.cc, app_common.cc, app_common.h: Added a inputBuffer to app_common and modified all fgets calls to use this buffer. This will allow for a size increase if necessary.
Location:
covoar
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • covoar/ChangeLog

    r2b85270 re7bb58a  
     12010-05-25      Jennifer Averett <Jennifer.Averett@OARcorp.com>
     2
     3        * DesiredSymbols.cc, Explanations.cc, ObjdumpProcessor.cc,
     4        TraceReaderLogQEMU.cc, app_common.cc, app_common.h: Added a
     5        inputBuffer to app_common and modified all fgets calls to use this
     6        buffer. This will allow for a size increase if necessary.
     7
    182010-05-25      Jennifer.Averett <Jennifer.Averett@OARcorp.com>
    29
  • covoar/DesiredSymbols.cc

    r2b85270 re7bb58a  
    3535  )
    3636  {
    37     #define MAX_LINE_LENGTH 512
    38     char                    buffer[MAX_LINE_LENGTH];
    3937    char*                   cStatus;
    4038    bool                    done = false;
     
    7169      // Skip blank lines between symbols
    7270      do {
    73         buffer[0] = '\0';
    74         cStatus = fgets( buffer, MAX_LINE_LENGTH, sFile );
     71        inputBuffer[0] = '\0';
     72        cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, sFile );
    7573        if ( cStatus == NULL ) {
    7674          done = true;
    7775        }
    7876        else {
    79           buffer[ strlen(buffer) - 1] = '\0';
     77          inputBuffer[ strlen(inputBuffer) - 1] = '\0';
    8078          line++;
    8179        }
    82       } while ( !done && (buffer[0] == '\0') );
     80      } while ( !done && (inputBuffer[0] == '\0') );
    8381
    8482      // Have we already seen this one?
    8583      if ( !done ) {
    86         if (set.find( buffer ) != set.end()) {
     84        if (set.find( inputBuffer ) != set.end()) {
    8785          fprintf(
    8886            stderr,
     
    9088            symbolsFile,
    9189            line,
    92             buffer
     90            inputBuffer
    9391          );
    9492        }
     
    9694        // Add this to the set of symbols.
    9795        else {
    98           set[ buffer ] = *symInfo;
    99         }
    100       }
    101     }
    102     #undef MAX_LINE_LENGTH
     96          set[ inputBuffer ] = *symInfo;
     97        }
     98      }
     99    }
    103100  }
    104101
     
    381378  {
    382379    char*                              base;
    383     char                               buffer[512];
    384380    char*                              cStatus;
    385381    char                               command[512];
     
    456452         ritr++ ) {
    457453
    458       cStatus = fgets( buffer, 512, tmpfile );
     454      cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, tmpfile );
    459455      if ( cStatus == NULL ) {
    460456        fprintf(
     
    465461        exit( -1 );
    466462      }
    467       buffer[ strlen(buffer) - 1] = '\0';
     463      inputBuffer[ strlen(inputBuffer) - 1] = '\0';
    468464
    469465      // Use only the base filename without directory path.
    470       realpath( buffer, rpath );
     466      realpath( inputBuffer, rpath );
    471467      base = basename( rpath );
    472468
    473469      ritr->lowSourceLine = std::string( base );
    474470
    475       cStatus = fgets( buffer, 512, tmpfile );
     471      cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, tmpfile );
    476472      if ( cStatus == NULL ) {
    477473        fprintf(
     
    482478        exit( -1 );
    483479      }
    484       buffer[ strlen(buffer) - 1] = '\0';
     480      inputBuffer[ strlen(inputBuffer) - 1] = '\0';
    485481
    486482      // Use only the base filename without directory path.
    487       realpath( buffer, rpath );
     483      realpath( inputBuffer, rpath );
    488484      base = basename( rpath );
    489485
  • covoar/Explanations.cc

    r2b85270 re7bb58a  
    1616
    1717#include "Explanations.h"
     18#include "app_common.h"
    1819
    1920namespace Coverage {
     
    3334    #define MAX_LINE_LENGTH 512
    3435    FILE       *explain;
    35     char        buffer[MAX_LINE_LENGTH];
    3636    char        *cStatus;
    3737    Explanation *e;
     
    5656      // skip blank lines between
    5757      do {
    58         buffer[0] = '\0';
    59         cStatus = fgets( buffer, MAX_LINE_LENGTH, explain );
     58        inputBuffer[0] = '\0';
     59        cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, explain );
    6060        if (cStatus == NULL) {
    6161          goto done;
    6262        }
    63         buffer[ strlen(buffer) - 1] = '\0';
     63        inputBuffer[ strlen(inputBuffer) - 1] = '\0';
    6464        line++;
    65       } while ( buffer[0] == '\0' );
     65      } while ( inputBuffer[0] == '\0' );
    6666
    6767      // Have we already seen this one?
    68       if (set.find( buffer ) != set.end()) {
     68      if (set.find( inputBuffer ) != set.end()) {
    6969        fprintf(
    7070          stderr,
     
    7272          "contains a duplicate explanation (%s)\n",
    7373          line,
    74           buffer
     74          inputBuffer
    7575        );
    7676        exit( -1 );
     
    7878
    7979      // Add the starting line and file
    80       e->startingPoint = std::string(buffer);
     80      e->startingPoint = std::string(inputBuffer);
    8181      e->found = false;
    8282
    8383      // Get the classification
    84       cStatus = fgets( buffer, MAX_LINE_LENGTH, explain );
     84      cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, explain );
    8585      if (cStatus == NULL) {
    8686        fprintf(
     
    9292        exit( -1 );
    9393      }
    94       buffer[ strlen(buffer) - 1] = '\0';
    95       e->classification = buffer;
     94      inputBuffer[ strlen(inputBuffer) - 1] = '\0';
     95      e->classification = inputBuffer;
    9696      line++;
    9797
    9898      // Get the explanation
    9999      while (1) {
    100         cStatus = fgets( buffer, MAX_LINE_LENGTH, explain );
    101         // fprintf( stderr, "%d - %s\n", line, buffer );
     100        cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, explain );
     101        // fprintf( stderr, "%d - %s\n", line, inputBuffer );
    102102        if (cStatus == NULL) {
    103103          fprintf(
     
    109109          exit( -1 );
    110110        }
    111         buffer[ strlen(buffer) - 1] = '\0';
     111        inputBuffer[ strlen(inputBuffer) - 1] = '\0';
    112112        line++;
    113113
    114114        const char delimiter[4] = "+++";
    115         if (!strncmp( buffer, delimiter, 3 )) {
     115        if (!strncmp( inputBuffer, delimiter, 3 )) {
    116116          break;
    117117        }
    118118        // XXX only taking last line.  Needs to be a vector
    119         e->explanation.push_back( buffer );
     119        e->explanation.push_back( inputBuffer );
    120120      }
    121121
  • covoar/ObjdumpProcessor.cc

    r2b85270 re7bb58a  
    133133    #define METHOD "ERROR: ObjdumpProcessor::determineLoadAddress - "
    134134    FILE*        loadAddressFile = NULL;
    135     char         buffer[ 512 ];
    136135    char*        cStatus;
    137136    uint32_t     offset;
     
    141140      return 0;
    142141
    143 #if 0
    144     static FILE* gdbCommands = NULL;
    145     int          items;
    146     uint32_t     loadAddress;
    147     FILE*        objdumpFile = NULL;
    148     int          status;
    149     char         terminator;
    150 
    151 
    152     //
    153     // Invoke gdb to determine the physical load address
    154     // of the .text section.
    155     //
    156 
    157     // Create a gdb input commands file.
    158     if (!gdbCommands) {
    159 
    160       gdbCommands = fopen( "gdbCommands", "w" );
    161       if (!gdbCommands) {
    162         fprintf(
    163           stderr,
    164           "ERROR: ObjdumpProcessor::determineLoadAddress - "
    165           "unable to create gdbCommands\n"
    166         );
    167         exit( -1 );
    168       }
    169 
    170       fprintf(
    171         gdbCommands,
    172         "set pagination off\n"
    173         "b main\n"
    174         "r\n"
    175         "info sharedlibrary\n"
    176         "quit\n"
    177       );
    178 
    179       fclose( gdbCommands );
    180     }
    181 
    182     // Invoke gdb.
    183     sprintf(
    184       buffer,
    185       "gdb -x gdbCommands %s | grep %s | cut -d ' ' -f1 > %s",
    186       (theExecutable->getFileName()).c_str(),
    187       (theExecutable->getLibraryName()).c_str(),
    188       "library_addr.tmp"
    189     );
    190 
    191     status = system( buffer );
    192     if (status) {
    193       fprintf(
    194         stderr,
    195         "ERROR: ObjdumpProcessor::determineLoadAddress - "
    196         "command (%s) failed with %d\n",
    197         buffer,
    198         status
    199       );
    200       exit( -1 );
    201     }
    202 
    203     // Read load address.
    204     loadAddressFile = fopen( "library_addr.tmp", "r" );
    205     if (!loadAddressFile) {
    206       fprintf(
    207         stderr,
    208         "ERROR: ObjdumpProcessor::determineLoadAddress - "
    209         "unable to open library_addr.tmp\n"
    210       );
    211       exit( -1 );
    212     }
    213 
    214     cStatus = fgets( buffer, 512, loadAddressFile );
    215     items = sscanf(
    216       buffer, "%x", &loadAddress
    217     );
    218 
    219     fclose( loadAddressFile );
    220     unlink( "library_addr.tmp" );
    221 
    222     //
    223     // Partially process an objdump of the library to determine the first
    224     // symbol's offset from the physical load address of the library.
    225     //
    226 
    227     // Obtain the objdump file.
    228     objdumpFile = getFile( theExecutable->getLibraryName() );
    229 
    230     // Process the objdump file.
    231     while ( 1 ) {
    232 
    233       // Get a line.
    234       cStatus = fgets( buffer, 512, objdumpFile );
    235       if (cStatus == NULL) {
    236         fprintf(
    237           stderr,
    238           "ERROR: ObjdumpProcessor::determineLoadAddress - "
    239           "no symbol found in objdump file\n"
    240         );
    241         exit( -1 );
    242       }
    243 
    244       // Look for the start of a symbol's objdump and extract
    245       // address and symbol (i.e. address <symbolname>:).
    246       items = sscanf(
    247         buffer,
    248         "%x <%*[^>]>%c",
    249         &offset, &terminator
    250       );
    251 
    252       // If all items found, we have found the first symbol's objdump.
    253       if ((items == 2) && (terminator == ':')) {
    254         break;
    255       }
    256     }
    257 
    258     return (loadAddress - offset);
    259 # endif
    260 #if 1
    261142    std::string dlinfoName = theExecutable->getFileName();
    262143    uint32_t address;
     
    276157
    277158      // Get a line.
    278       cStatus = fgets( buffer, 512, loadAddressFile );
     159      cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, loadAddressFile );
    279160      if (cStatus == NULL) {
    280161        fprintf(
     
    287168        exit( -1 );
    288169      }
    289       sscanf( buffer, "%s %x", inLibName, &offset );
     170      sscanf( inputBuffer, "%s %x", inLibName, &offset );
    290171      std::string tmp = inLibName;
    291172      if ( tmp.find( Library ) != tmp.npos ) {
     
    298179    fclose( loadAddressFile );
    299180    return address;
    300 #endif
     181
    301182    #undef METHOD
    302183  }
     
    418299  )
    419300  {
    420     char               buffer[ 512 ];
    421301    char*              cStatus;
    422302    int                items;
     
    435315
    436316      // Get the line.
    437       cStatus = fgets( buffer, 512, objdumpFile );
     317      cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, objdumpFile );
    438318      if (cStatus == NULL) {
    439319        break;
    440320      }
    441       buffer[ strlen(buffer) - 1] = '\0';
     321      inputBuffer[ strlen(inputBuffer) - 1] = '\0';
    442322
    443323      // See if it is the dump of an instruction.
    444324      items = sscanf(
    445         buffer,
     325        inputBuffer,
    446326        "%x%c",
    447327        &offset, &terminator
     
    461341  )
    462342  {
    463     char               buffer[ 512 ];
    464343    char*              cStatus;
    465344    std::string        currentSymbol = "";
     
    487366
    488367      // Get the line.
    489       cStatus = fgets( buffer, 512, objdumpFile );
     368      cStatus = fgets( inputBuffer, MAX_LINE_LENGTH, objdumpFile );
    490369      if (cStatus == NULL) {
    491370
     
    512391      }
    513392
    514       buffer[ strlen(buffer) - 1] = '\0';
    515 
    516       lineInfo.line          = buffer;
     393      inputBuffer[ strlen(inputBuffer) - 1] = '\0';
     394
     395      lineInfo.line          = inputBuffer;
    517396      lineInfo.address       = 0xffffffff;
    518397      lineInfo.isInstruction = false;
     
    524403      // offset and symbol (i.e. offset <symbolname>:).
    525404      items = sscanf(
    526         buffer,
     405        inputBuffer,
    527406        "%x <%[^>]>%c",
    528407        &offset, symbol, &terminator1
     
    564443        // See if it is the dump of an instruction.
    565444        items = sscanf(
    566           buffer,
     445          inputBuffer,
    567446          "%x%c\t%*[^\t]%c",
    568447          &instructionOffset, &terminator1, &terminator2
     
    576455           executableInformation->getLoadAddress() + instructionOffset;
    577456          lineInfo.isInstruction = true;
    578           lineInfo.isNop         = isNop( buffer, lineInfo.nopSize );
    579           lineInfo.isBranch      = isBranchLine( buffer );
     457          lineInfo.isNop         = isNop( inputBuffer, lineInfo.nopSize );
     458          lineInfo.isBranch      = isBranchLine( inputBuffer );
    580459        }
    581460
  • covoar/TraceReaderLogQEMU.cc

    r2b85270 re7bb58a  
    6060    FILE*               logFile;
    6161    int                 result;
    62     char                buffer[120];
    6362
    6463    //
     
    106105    //  Read First Start Address
    107106    //
    108     fgets(buffer, 120, logFile );
     107    fgets(inputBuffer, MAX_LINE_LENGTH, logFile );
    109108    result = sscanf(
    110       buffer,
     109      inputBuffer,
    111110      "0x%08lx: %s %s\n",
    112111      &first.address,
     
    126125      // Read until we get to the last instruction in the block.
    127126      do {
    128         fgets(buffer, 120, logFile );
     127        fgets(inputBuffer, MAX_LINE_LENGTH, logFile );
    129128        result = sscanf(
    130           buffer,
     129          inputBuffer,
    131130          "0x%08lx: %s %s\n",
    132131          &last.address,
     
    142141        nextExecuted = last;
    143142      } else {
    144         fgets(buffer, 120, logFile );
     143        fgets(inputBuffer, MAX_LINE_LENGTH, logFile );
    145144        result = sscanf(
    146           buffer,
     145          inputBuffer,
    147146          "0x%08lx: %s %s\n",
    148147          &nextExecuted.address,
  • covoar/app_common.cc

    r2b85270 re7bb58a  
    3535const char*                 dynamicLibrary      = NULL;
    3636const char*                 projectName         = NULL;
     37char                        inputBuffer[MAX_LINE_LENGTH];
    3738
    3839
  • covoar/app_common.h

    r2b85270 re7bb58a  
    2222extern const char*                  projectName;
    2323
     24#define MAX_LINE_LENGTH             512
     25extern char                         inputBuffer[MAX_LINE_LENGTH];
     26
    2427
    2528bool FileIsNewer( const char *f1, const char *f2 );
Note: See TracChangeset for help on using the changeset viewer.