Changeset 3e187ba in rtems-tools


Ignore:
Timestamp:
Apr 25, 2018, 8:33:58 PM (15 months ago)
Author:
Cillian O'Donnell <cpodonnell8@…>
Branches:
master
Children:
14c7f25
Parents:
e0a52a4
git-author:
Cillian O'Donnell <cpodonnell8@…> (04/25/18 20:33:58)
git-committer:
Chris Johns <chrisj@…> (04/30/18 23:00:35)
Message:

covoar: Add symbol set reader and ELF data parser to covoar.

Add ability to organize symbol sets of libraries in INI file
and then read them with covoar and load the symbols directly from the
libraries.

rtems-tools/../testing: Add configuration files for coverage analysis.

A number of covoar options are not required and are defaulted.

Co-author: Krzysztof Miesowicz <krzysztof.miesowicz@…>
Co-author: Vijay Kumar Banerjee <vijaykumar9597@…>
Co-author: Chris Johns <chrisj@…>

Location:
tester
Files:
7 added
10 edited

Legend:

Unmodified
Added
Removed
  • tester/covoar/DesiredSymbols.cc

    re0a52a4 r3e187ba  
    1717#include <unistd.h>
    1818
     19#include <iostream>
     20
     21#include "rld.h"
     22#include <rld-config.h>
     23#include "rld-symbols.h"
     24#include "rld-files.h"
     25
    1926#include "DesiredSymbols.h"
    2027#include "app_common.h"
     
    3239  }
    3340
    34   void DesiredSymbols::load(
    35     const char* const symbolsFile
     41  bool DesiredSymbols::load(
     42    const std::string& symbolsSet,
     43    const std::string& buildTarget,
     44    const std::string& buildBSP,
     45    bool               verbose
    3646  )
    3747  {
    38     int                     cStatus;
    39     bool                    done = false;
    40     FILE*                   sFile;
    41     SymbolInformation*      symInfo;
    42     int                     line = 1;
    43     std::string             symbol;
    44 
    45     // Ensure that symbols file name is given.
    46     if ( !symbolsFile ) {
    47       fprintf(
    48         stderr,
    49         "ERROR: DesiredSymbols::load - no symbols file specified\n"
    50       );
    51       exit(-1);
    52     }
    53 
    54     // Open symbols file.
    55     sFile = fopen( symbolsFile, "r" );
    56     if ( !sFile ) {
    57       fprintf(
    58         stderr,
    59         "ERROR: DesiredSymbols::load - unable to open symbols file %s\n",
    60         symbolsFile
    61       );
    62       exit(-1);
    63     }
    64 
    65     // Process symbols file.
    66     while ( !done ) {
    67 
    68       symInfo = new SymbolInformation;
    69 
    70       // Skip blank lines between symbols
    71       do {
    72         inputBuffer[0] = '\0';
    73         inputBuffer2[0] = '\0';
    74         cStatus = fscanf( sFile, "%s %s", inputBuffer, inputBuffer2 );
    75         if ( cStatus == EOF ) {
    76           done = true;
     48    rld::files::cache cache;
     49    bool              r = true;
     50
     51    //
     52    // Load the INI file looking for a top level:
     53    //
     54    //  [symbols-sets]
     55    //  sets = A, B, C
     56    //
     57    // For each set read the libraries from the configuration file and load.
     58    //
     59    //  [A]
     60    //  libraries = @BUILD-PREFIX@/c/@BSP@/A/libA.a
     61    //
     62    //  [B]
     63    //  libraries = @BUILD-PREFIX@/c/@BSP@/B/libB.a
     64    //
     65    try {
     66      cache.open();
     67
     68      rld::config::config config;
     69
     70      if (verbose)
     71        std::cerr << "Loading symbol sets: " << symbolsSet << std::endl;
     72
     73      config.load (symbolsSet);
     74
     75      const rld::config::section& sym_section = config.get_section("symbol-sets");
     76
     77      rld::strings sets;
     78      rld::config::parse_items (sym_section, "sets", sets, true);
     79
     80      for (const std::string set : sets) {
     81        if (verbose)
     82          std::cerr << " Symbol set: " << set << std::endl;
     83        const rld::config::section& set_section = config.get_section(set);
     84        rld::strings libs;
     85        rld::config::parse_items (set_section, "libraries", libs, true);
     86        for (std::string lib : libs) {
     87          lib = rld::find_replace(lib, "@BUILD-TARGET@", buildTarget);
     88          lib = rld::find_replace(lib, "@BSP@", buildBSP);
     89          if (verbose)
     90            std::cerr << " Loading library: " << lib << std::endl;
     91          cache.add(lib);
    7792        }
    78         else {
    79           //inputBuffer[ strlen(inputBuffer) - 1] = '\0';
    80           line++;
    81         }
    82       } while ( !done && (inputBuffer[0] == '\0') );
    83 
    84       // Have we already seen this one?
    85       if ( !done ) {
    86         if (set.find( inputBuffer ) != set.end()) {
    87           fprintf(
    88             stderr,
    89             "File: %s, Line %d: Duplicate symbol: %s\n",
    90             symbolsFile,
    91             line,
    92             inputBuffer
    93           );
    94 
    95           delete symInfo;
    96         }
    97 
    98         // Add this to the set of symbols.
    99         else
    100           set[ inputBuffer ] = *symInfo;
    101       }
    102     }
     93      }
     94
     95      rld::symbols::table symbols;
     96
     97      cache.load_symbols (symbols, true);
     98
     99      for (auto& kv : symbols.globals()) {
     100        const rld::symbols::symbol& sym = *(kv.second);
     101        set[sym.name()] = *(new SymbolInformation);
     102      }
     103      for (auto& kv : symbols.weaks()) {
     104        const rld::symbols::symbol& sym = *(kv.second);
     105        set[sym.name()] = *(new SymbolInformation);
     106      }
     107      for (auto& kv : symbols.locals()) {
     108        const rld::symbols::symbol& sym = *(kv.second);
     109        set[sym.name()] = *(new SymbolInformation);
     110      }
     111
     112    } catch (rld::error re) {
     113      std::cerr << "error: "
     114                << re.where << ": " << re.what
     115                << std::endl;
     116      r = false;
     117    } catch (...) {
     118      cache.close();
     119      throw;
     120    }
     121
     122    cache.close();
     123
     124    return r;
    103125  }
    104126
  • tester/covoar/DesiredSymbols.h

    re0a52a4 r3e187ba  
    294294     *  This method creates the set of symbols to analyze from the symbols
    295295     *  listed in the specified file.
    296      */
    297     void load(
    298       const char* const symbolsFile
     296     *
     297     *  @param[in] symbolsSet An INI format file of the symbols to be loaded.
     298     *  @param[in] buildTarget The build target
     299     *  @param[in] buildBSP The BSP
     300     *  @return Returns false if the load fails.
     301     */
     302    bool load(
     303      const std::string& symbolsSet,
     304      const std::string& buildTarget,
     305      const std::string& buildBSP,
     306      bool               verbose
    299307    );
    300308
  • tester/covoar/ExecutableInfo.cc

    re0a52a4 r3e187ba  
    6868  }
    6969
    70   std::string ExecutableInfo::getFileName ( void ) const
     70  const std::string& ExecutableInfo::getFileName ( void ) const
    7171  {
    7272    return executableName;
    7373  }
    7474
    75   std::string ExecutableInfo::getLibraryName( void ) const
     75  const std::string& ExecutableInfo::getLibraryName( void ) const
    7676  {
    7777    return libraryName;
  • tester/covoar/ExecutableInfo.h

    re0a52a4 r3e187ba  
    6868     *  @return Returns the executable's file name
    6969     */
    70     std::string getFileName( void ) const;
     70    const std::string& getFileName( void ) const;
    7171
    7272    /*!
     
    7575     *  @return Returns the executable's library name
    7676     */
    77     std::string getLibraryName( void ) const;
     77    const std::string& getLibraryName( void ) const;
    7878
    7979    /*!
     
    112112     *  associated with the executable.
    113113     *
    114      *  @return Returns TRUE if 
     114     *  @return Returns TRUE if
    115115     */
    116116    bool hasDynamicLibrary( void );
  • tester/covoar/ObjdumpProcessor.cc

    re0a52a4 r3e187ba  
    248248    {
    249249      status = rld::process::execute( TargetInfo->getObjdump(),
    250                args, objdumpFile.name(), err.name() );
     250                                      args, objdumpFile.name(), err.name() );
    251251      if ( (status.type != rld::process::status::normal)
    252252           || (status.code != 0) ) {
     
    255255    } catch( rld::error& err )
    256256      {
    257         std::cout << "Error while running" << TargetInfo->getObjdump()
    258                   << "for" << fileName << std::endl;
     257        std::cout << "Error while running " << TargetInfo->getObjdump()
     258                  << " on " << fileName << std::endl;
    259259        std::cout << err.what << " in " << err.where << std::endl;
    260260        return;
  • tester/covoar/app_common.h

    re0a52a4 r3e187ba  
    11#ifndef __APP_COMMON_h
    22#define __APP_COMMON_h
     3
     4/*
     5 * This file needs to be removed and these globals removed from the
     6 * global scope. For example SymbolsToAnalyze is never destructed.
     7 */
    38
    49#include <list>
     
    2328
    2429
    25 bool FileIsNewer( const char *f1, const char *f2 ); 
    26 bool FileIsReadable( const char *f1 ); 
     30bool FileIsNewer( const char *f1, const char *f2 );
     31bool FileIsReadable( const char *f1 );
    2732bool ReadUntilFound( FILE *file, const char *line );
    2833
  • tester/covoar/covoar.cc

    re0a52a4 r3e187ba  
    3030#endif
    3131
     32typedef std::list<std::string> CoverageNames;
     33typedef std::list<Coverage::ExecutableInfo*> Executables;
     34
    3235/*
    33  *  Variables to control general behavior
     36 * Create a build path from the executable paths. Also extract the build prefix
     37 * and BSP names.
    3438 */
    35 const char*                          coverageFileExtension = NULL;
    36 std::list<std::string>               coverageFileNames;
    37 int                                  coverageExtensionLength = 0;
    38 Coverage::CoverageFormats_t          coverageFormat;
    39 Coverage::CoverageReaderBase*        coverageReader = NULL;
    40 char*                                executable = NULL;
    41 const char*                          executableExtension = NULL;
    42 int                                  executableExtensionLength = 0;
    43 std::list<Coverage::ExecutableInfo*> executablesToAnalyze;
    44 const char*                          explanations = NULL;
    45 char*                                progname;
    46 const char*                          symbolsFile = NULL;
    47 const char*                          gcnosFileName = NULL;
    48 char                                 gcnoFileName[FILE_NAME_LENGTH];
    49 char                                 gcdaFileName[FILE_NAME_LENGTH];
    50 char                                 gcovBashCommand[256];
    51 const char*                          target = NULL;
    52 const char*                          format = NULL;
    53 FILE*                                gcnosFile = NULL;
    54 Gcov::GcovData*          gcovFile;
     39static void createBuildPath(Executables& executablesToAnalyze,
     40                            std::string& buildPath,
     41                            std::string& buildPrefix,
     42                            std::string& buildBSP)
     43{
     44  for (const auto& exe : executablesToAnalyze) {
     45    rld::strings eparts;
     46    rld::split(eparts, rld::path::path_abs(exe->getFileName()), RLD_PATH_SEPARATOR);
     47    std::string fail; // empty means all is OK else an error string
     48    for (rld::path::paths::reverse_iterator pri = eparts.rbegin();
     49         pri != eparts.rend();
     50         ++pri) {
     51      if (*pri == "testsuites") {
     52        ++pri;
     53        if (pri == eparts.rend()) {
     54          fail = "invalid executable path, no BSP";
     55          break;
     56        }
     57        if (buildBSP.empty()) {
     58          buildBSP = *pri;
     59        } else {
     60          if (buildBSP != *pri) {
     61            fail = "executable BSP does not match: " + buildBSP;
     62            break;
     63          }
     64        }
     65        ++pri;
     66        if (pri == eparts.rend() || *pri != "c") {
     67          fail = "invalid executable path, no 'c'";
     68          break;
     69        }
     70        ++pri;
     71        if (pri == eparts.rend()) {
     72          fail = "invalid executable path, no arch prefix";
     73          break;
     74        }
     75        if (buildPrefix.empty()) {
     76          buildPrefix = *pri;
     77        } else {
     78          if (buildBSP != *pri) {
     79            fail = "executable build prefix does not match: " + buildPrefix;
     80            break;
     81          }
     82        }
     83        ++pri;
     84        if (pri == eparts.rend()) {
     85          fail = "invalid executable path, no build top";
     86          break;
     87        }
     88        //
     89        // The remaining parts of the path is the build path. Iterator over them
     90        // and collect into a new paths variable to join to make a path.
     91        //
     92        rld::path::paths bparts;
     93        for (; pri != eparts.rend(); ++pri)
     94          bparts.insert(bparts.begin(), *pri);
     95        std::string thisBuildPath;
     96        rld::path::path_join(thisBuildPath, bparts, thisBuildPath);
     97        if (buildPath.empty()) {
     98          buildPath = thisBuildPath;
     99        } else {
     100          if (buildBSP != *pri) {
     101            fail = "executable build path does not match: " + buildPath;
     102          }
     103        }
     104        break;
     105      }
     106    }
     107    if (!fail.empty()) {
     108      std::cerr << "ERROR: " << fail << std::endl;
     109      exit(EXIT_FAILURE);
     110    }
     111  }
     112}
    55113
    56114/*
    57115 *  Print program usage message
    58116 */
    59 void usage()
     117void usage(const std::string& progname)
    60118{
    61119  fprintf(
     
    70128           "(RTEMS, QEMU, TSIM or Skyeye)\n"
    71129    "  -E EXPLANATIONS           - name of file with explanations\n"
    72     "  -s SYMBOLS_FILE           - name of file with symbols of interest\n"
     130    "  -s SYMBOL_SET_FILE        - path to the INI format symbol sets\n"
    73131    "  -1 EXECUTABLE             - name of executable to get symbols from\n"
    74132    "  -e EXE_EXTENSION          - extension of the executables to analyze\n"
     
    77135    "  -p PROJECT_NAME           - name of the project\n"
    78136    "  -C ConfigurationFileName  - name of configuration file\n"
    79     "  -O Output_Directory       - name of output directory (default=."
     137    "  -O Output_Directory       - name of output directory (default=.\n"
     138    "  -d debug                  - disable cleaning of tempfiles."
    80139    "\n",
    81     progname,
    82     progname
     140    progname.c_str(),
     141    progname.c_str()
    83142  );
    84143}
     
    126185)
    127186{
    128   std::list<std::string>::iterator               citr;
    129   std::string                                    coverageFileName;
    130   std::list<Coverage::ExecutableInfo*>::iterator eitr;
    131   Coverage::ExecutableInfo*                      executableInfo = NULL;
    132   int                                            i;
    133   int                                            opt;
    134   const char*                                    singleExecutable = NULL;
    135   rld::process::tempfile                         objdumpFile( ".dmp" );
    136   rld::process::tempfile                         err( ".err" );
    137   bool                                           debug = false;
    138   std::string                                    option;
     187  CoverageNames                 coverageFileNames;
     188  std::string                   coverageFileName;
     189  Executables                   executablesToAnalyze;
     190  Coverage::ExecutableInfo*     executableInfo = NULL;
     191  std::string                   executableExtension = "exe";
     192  std::string                   coverageExtension = "cov";
     193  Coverage::CoverageFormats_t   coverageFormat;
     194  Coverage::CoverageReaderBase* coverageReader = NULL;
     195  char*                         executable = NULL;
     196  const char*                   explanations = NULL;
     197  const char*                   gcnosFileName = NULL;
     198  char                          gcnoFileName[FILE_NAME_LENGTH];
     199  char                          gcdaFileName[FILE_NAME_LENGTH];
     200  char                          gcovBashCommand[256];
     201  std::string                   target;
     202  const char*                   format = "html";
     203  FILE*                         gcnosFile = NULL;
     204  Gcov::GcovData*               gcovFile;
     205  const char*                   singleExecutable = NULL;
     206  rld::process::tempfile        objdumpFile( ".dmp" );
     207  rld::process::tempfile        err( ".err" );
     208  rld::process::tempfile        syms( ".syms" );
     209  bool                          debug = false;
     210  std::string                   symbolSet;
     211  std::string                   progname;
     212  std::string                   option;
     213  int                           opt;
    139214
    140215  setup_signals();
     
    143218  // Process command line options.
    144219  //
    145   progname = argv[0];
    146 
    147   while ((opt = getopt(argc, argv, "1:L:e:c:g:E:f:s:T:O:p:v:d")) != -1) {
     220  progname = rld::path::basename(argv[0]);
     221
     222  while ((opt = getopt(argc, argv, "1:L:e:c:g:E:f:s:S:T:O:p:vd")) != -1) {
    148223    switch (opt) {
    149       case '1': singleExecutable      = optarg; break;
    150       case 'L': dynamicLibrary        = optarg; break;
    151       case 'e': executableExtension   = optarg; break;
    152       case 'c': coverageFileExtension = optarg; break;
    153       case 'g': gcnosFileName         = optarg; break;
    154       case 'E': explanations          = optarg; break;
    155       case 'f': format                = optarg; break;
    156       case 's': symbolsFile           = optarg; break;
    157       case 'T': target                = optarg; break;
    158       case 'O': outputDirectory       = optarg; break;
    159       case 'v': Verbose               = true;   break;
    160       case 'p': projectName           = optarg; break;
    161       case 'd': debug                 = true;   break;
     224      case '1': singleExecutable    = optarg; break;
     225      case 'L': dynamicLibrary      = optarg; break;
     226      case 'e': executableExtension = optarg; break;
     227      case 'c': coverageExtension  = optarg; break;
     228      case 'g': gcnosFileName       = optarg; break;
     229      case 'E': explanations        = optarg; break;
     230      case 'f': format              = optarg; break;
     231      case 'S': symbolSet           = optarg; break;
     232      case 'T': target              = optarg; break;
     233      case 'O': outputDirectory     = optarg; break;
     234      case 'v': Verbose             = true;   break;
     235      case 'p': projectName         = optarg; break;
     236      case 'd': debug               = true;   break;
    162237      default: /* '?' */
    163         usage();
     238        usage(progname);
    164239        exit(EXIT_FAILURE);
    165240    }
     
    172247
    173248    /*
    174      * Target name must be set.
     249     * Validate that we have a symbols of interest file.
    175250     */
    176     if ( !target ) {
    177       option = "target -T";
    178       throw option;
    179     }
    180 
    181     /*
    182      * Validate simulator format.
    183      */
    184     if ( !format ) {
    185       option = "format -f";
     251    if ( symbolSet.empty() ) {
     252      option = "symbol set file -S";
    186253      throw option;
    187254    }
     
    196263
    197264    /*
    198      * Has coverage file extension been specified.
    199      */
    200     if ( !coverageFileExtension ) {
    201       option = "coverage extension -c";
    202       throw option;
    203     }
    204 
    205     /*
    206      * Has executable extension been specified.
    207      */
    208     if ( !executableExtension ) {
    209       option = "executable extension -e";
    210       throw option;
    211     }
    212 
    213     /*
    214265     * Check for project name.
    215266     */
     
    221272  catch( std::string option )
    222273  {
    223     std::cout << "error missing option: " + option << std::endl;
    224     usage();
     274    std::cerr << "error missing option: " + option << std::endl;
     275    usage(progname);
    225276    exit(EXIT_FAILURE);
    226277  }
     
    239290    } else {
    240291
    241       for (i=optind; i < argc; i++) {
     292      for (int i = optind; i < argc; i++) {
    242293        // Ensure that the coverage file is readable.
    243294        if (!FileIsReadable( argv[i] )) {
     
    267318    }
    268319  }
    269 
    270   // If not invoked with a single executable, process the remaining
    271   // arguments as executables and derive the coverage file names.
    272320  else {
    273     for (i = optind; i < argc; i++) {
     321    // If not invoked with a single executable, process the remaining
     322    // arguments as executables and derive the coverage file names.
     323    for (int i = optind; i < argc; i++) {
    274324
    275325      // Ensure that the executable is readable.
     
    283333        coverageFileName = argv[i];
    284334        coverageFileName.replace(
    285           coverageFileName.length() - executableExtensionLength,
    286           executableExtensionLength,
    287           coverageFileExtension
     335          coverageFileName.length() - executableExtension.size(),
     336          executableExtension.size(),
     337          coverageExtension
    288338        );
    289339
     
    309359    );
    310360    exit(EXIT_FAILURE);
     361  }
     362
     363  // The executablesToAnalyze and coverageFileNames containers need
     364  // to be the name size of some of the code below breaks. Lets
     365  // check and make sure.
     366  if (executablesToAnalyze.size() != coverageFileNames.size()) {
     367    std::cerr << "ERROR: executables and coverage name size mismatch" << std::endl;
     368    exit(EXIT_FAILURE);
     369  }
     370
     371  //
     372  // Find the top of the BSP's build tree and if we have found the top
     373  // check the executable is under the same path and BSP.
     374  //
     375  std::string buildPath;
     376  std::string buildTarget;
     377  std::string buildBSP;
     378  createBuildPath(executablesToAnalyze,
     379                  buildPath,
     380                  buildTarget,
     381                  buildBSP);
     382
     383  //
     384  // Use a command line target if provided.
     385  //
     386  if (!target.empty()) {
     387    buildTarget = target;
    311388  }
    312389
     
    324401    }
    325402    fprintf( stderr, "Coverage Format : %s\n", format );
    326     fprintf( stderr, "Target          : %s\n", PrintableString(target) );
     403    fprintf( stderr, "Target          : %s\n", buildTarget.c_str() );
    327404    fprintf( stderr, "\n" );
    328 #if 1
     405
    329406    // Process each executable/coverage file pair.
    330     eitr = executablesToAnalyze.begin();
    331     for (citr = coverageFileNames.begin();
     407    Executables::iterator eitr = executablesToAnalyze.begin();
     408    for (CoverageNames::iterator citr = coverageFileNames.begin();
    332409         citr != coverageFileNames.end();
    333410         citr++) {
     
    343420        eitr++;
    344421    }
    345 #endif
    346422  }
    347423
     
    351427
    352428  // Create data based on target.
    353   TargetInfo = Target::TargetFactory( target );
     429  TargetInfo = Target::TargetFactory( buildTarget );
    354430
    355431  // Create the set of desired symbols.
    356432  SymbolsToAnalyze = new Coverage::DesiredSymbols();
    357   SymbolsToAnalyze->load( symbolsFile );
    358   if (Verbose) {
    359     fprintf(
    360       stderr,
    361       "Analyzing %u symbols\n",
    362       (unsigned int) SymbolsToAnalyze->set.size()
    363     );
    364   }
     433
     434  //
     435  // Read symbol configuration file and load needed symbols.
     436  //
     437  if (!SymbolsToAnalyze->load( symbolSet, buildTarget, buildBSP, Verbose )) {
     438      exit(EXIT_FAILURE);
     439  }
     440
     441  if ( Verbose )
     442    std::cout << "Analyzing " << SymbolsToAnalyze->set.size()
     443              << " symbols" << std::endl;
    365444
    366445  // Create explanations.
     
    380459
    381460  // Prepare each executable for analysis.
    382   for (eitr = executablesToAnalyze.begin();
     461  for (Executables::iterator eitr = executablesToAnalyze.begin();
    383462       eitr != executablesToAnalyze.end();
    384463       eitr++) {
     
    408487
    409488  // Process each executable/coverage file pair.
    410   eitr = executablesToAnalyze.begin();
    411   for (citr = coverageFileNames.begin();
    412        citr != coverageFileNames.end();
    413        citr++) {
    414 
     489  Executables::iterator eitr = executablesToAnalyze.begin();
     490  for (const auto& cname : coverageFileNames) {
    415491    if (Verbose) {
    416492      fprintf(
    417493        stderr,
    418494        "Processing coverage file %s for executable %s\n",
    419         (*citr).c_str(),
     495        cname.c_str(),
    420496        ((*eitr)->getFileName()).c_str()
    421497      );
     
    423499
    424500    // Process its coverage file.
    425     coverageReader->processFile( (*citr).c_str(), *eitr );
     501    coverageReader->processFile( cname.c_str(), *eitr );
    426502
    427503    // Merge each symbols coverage map into a unified coverage map.
     
    525601    err.override( "objdump_exec_log" );
    526602    err.keep();
     603    syms.override( "symbols_list" );
     604    syms.keep();
    527605  }
    528606  return 0;
  • tester/covoar/wscript

    re0a52a4 r3e187ba  
    119119                use = ['ccovoar'] + modules,
    120120                cflags = ['-O2', '-g'],
     121                cxxflags = ['-std=c++11', '-O2', '-g'],
    121122                includes = ['.'] + rtl_includes)
    122123
     
    125126                use = ['ccovoar'] + modules,
    126127                cflags = ['-O2', '-g'],
     128                cxxflags = ['-std=c++11', '-O2', '-g'],
    127129                includes = ['.'] + rtl_includes)
  • tester/rtems/testing/qemu.cfg

    re0a52a4 r3e187ba  
    5555%define qemu_opts_base   -no-reboot -serial null -serial mon:stdio -nographic
    5656%define qemu_opts_no_net -net none
     57
     58#
     59# Coverage, some builds of qemu support coverage.
     60#
     61%ifn %{defined bsp_qemu_cov_opts}
     62 %define bsp_qemu_cov_opts %{nil}
     63%endif
     64
    5765#
    5866# Qemu executable
     
    6169 %define bsp_qemu_opts %{nil}
    6270%endif
     71
    6372%define qemu_cmd  qemu-system-%{bsp_arch}
    64 %define qemu_opts %{bsp_qemu_opts}
     73%define qemu_opts %{bsp_qemu_opts} %{bsp_qemu_cov_opts}
    6574
    6675#
  • tester/rtems/testing/testing.mc

    re0a52a4 r3e187ba  
    5656# Tests detected as invalid that are valid
    5757invalid_tests:        none,    none,     '''minimum.exe'''
     58
     59# Coverage defaults
     60cov_format:           none,    none,     'QEMU'
     61cov_explanations:     none,    none,     '%{_rtscripts}/coverage/Explanations.txt'
     62cov_extension:        none,    none,     'cov'
     63cov_gcnos_file:       none,    none,     '%{_rtscripts}/coverage/rtems.gcnos'
     64cov_exe_ext:          none,    none,     'exe'
     65cov_report_format:    none,    none,     'html'
Note: See TracChangeset for help on using the changeset viewer.