Ticket #1900: covoar.patch

rtems-testing/covoar/CoverageMapBase.cc

@@ -35 +35 @@
 
     Info = new perAddressInfo_t[ Size ];
 
     for (a=0; a<Size; a++) {
 
       perAddressInfo_t *i = &Info[ a ];
 
       i->isStartOfInstruction = false;
-      i->wasExecuted          = false;
+      i->wasExecuted          = 0;
       i->isBranch             = false;
       i->isNop                = false;
       i->wasTaken             = false;
       i->wasNotTaken          = false;
     }
   }
 
   CoverageMapBase::~CoverageMapBase()
@@ -195 +195 @@
 
   void CoverageMapBase::setWasExecuted( uint32_t address )
   {
     uint32_t offset;
  
     if (determineOffset( address, &offset ) != true)
       return;
 
-    Info[ offset ].wasExecuted = true;
+    Info[ offset ].wasExecuted += 1;
   }
 
+  void CoverageMapBase::sumWasExecuted( uint32_t address, uint32_t addition)
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    Info[ offset ].wasExecuted += addition;
+   }
+
   bool CoverageMapBase::wasExecuted( uint32_t address ) const
   {
     uint32_t offset;
+    bool     result;
  
+    result = true;
+
     if (determineOffset( address, &offset ) != true)
-      return false;
+      result = false;
+
+    if (Info[ offset ].wasExecuted <= 0)
+      result = false;
+
+    return result;
+  }
+
+  uint32_t CoverageMapBase::getWasExecuted( uint32_t address ) const
+  {
+    uint32_t offset;
+
+    if (determineOffset( address, &offset ) != true)
+      return 0;
 
-   return Info[ offset ].wasExecuted;
+    return Info[ offset ].wasExecuted;  
   }
 
   void CoverageMapBase::setIsBranch(
     uint32_t    address
   )
   {
     uint32_t offset;
  

rtems-testing/covoar/CoverageMapBase.h

@@ -170 +170 @@
      *  @param[in] address specifies the address to check
      *
      *  @return Returns TRUE if the specified address is the start
      *   of an instruction and FALSE otherwise.
      */
     bool isStartOfInstruction( uint32_t address ) const;
 
     /*!
-     *  This method sets the boolean which indicates that the instruction
-     *  at the specified address was executed.
+     *  This method iterates the counter which indicates how many times
+     *  the instruction at the specified address was executed.
      *
      *  @param[in] address specifies the address which was executed
      */
     virtual void setWasExecuted( uint32_t address );
 
     /*!
      *  This method returns a boolean which indicates if the instruction
      *  at the specified address was executed.
@@ -189 +189 @@
      *  @param[in] address specifies the address to check
      *  
      *  @return Returns TRUE if the instruction at the specified
      *   address was executed and FALSE otherwise.
      */
     bool wasExecuted( uint32_t address ) const;
 
     /*!
+     *  This method increases the counter which indicates how many times
+     *  the instruction at the specified address was executed. It is used
+     *  for merging coverage maps.
+     *
+     *  @param[in] address specifies the address which was executed
+     *  @param[in] address specifies the execution count that should be
+     *             added
+     */
+    virtual void sumWasExecuted( uint32_t address, uint32_t addition);
+
+    /*!
+     *  This method returns an unsigned integer which indicates how often
+     *  the instruction at the specified address was executed.
+     *
+     *  @param[in] address specifies the address to check
+     *  
+     *  @return Returns number of executins
+     */
+    uint32_t getWasExecuted( uint32_t address ) const;
+
+    /*!
      *  This method sets the boolean which indicates if the specified
      *  address is the starting address of a branch instruction.
      *
      *  @param[in] address specifies the address of the branch instruction
      */
     void setIsBranch( uint32_t address );
 
     /*!
@@ -299 +320 @@
      */
     typedef struct {
       /*!
        *  This member indicates that the address is the start of
        *  an instruction.
        */
       bool isStartOfInstruction;
       /*!
-       *  This member indicates that the address was executed.
+       *  This member indicates how many times the address was executed.
        */
-      bool wasExecuted;
+      uint32_t wasExecuted;
       /*!
        *  This member indicates that the address is a branch instruction.
        */
       bool isBranch;
       /*!
        *  This member indicates that the address is a NOP instruction.
        */
       bool isNop;

rtems-testing/covoar/DesiredSymbols.cc

@@ -624 +624 @@
   {
     uint32_t              dAddress;
     CoverageMapBase*      destinationCoverageMap;
     uint32_t              dMapSize;
     symbolSet_t::iterator itr;
     uint32_t              sAddress;
     uint32_t              sBaseAddress;
     uint32_t              sMapSize;
+    uint32_t              executionCount;
     
     // Ensure that the symbol is a desired symbol.
     itr = set.find( symbolName );
 
     if (itr == set.end()) {
 
       fprintf(
         stderr,
@@ -668 +669 @@
 
       sAddress = dAddress + sBaseAddress;
 
       // Merge start of instruction indication.
       if (sourceCoverageMap->isStartOfInstruction( sAddress ))
         destinationCoverageMap->setIsStartOfInstruction( dAddress );
 
       // Merge the execution data.
-      if (sourceCoverageMap->wasExecuted( sAddress ))
-        destinationCoverageMap->setWasExecuted( dAddress );
+      executionCount = sourceCoverageMap->getWasExecuted( sAddress );
+      destinationCoverageMap->sumWasExecuted( dAddress, executionCount );
 
       // Merge the branch data.
       if (sourceCoverageMap->wasTaken( sAddress ))
         destinationCoverageMap->setWasTaken( dAddress );
 
       if (sourceCoverageMap->wasNotTaken( sAddress ))
         destinationCoverageMap->setWasNotTaken( dAddress );
     }

rtems-testing/covoar/covoar.cc

@@ -76 +76 @@
 #define PrintableString(_s) \
        ((!(_s)) ? "NOT SET" : (_s))
 
 /*
  *  Configuration File Support
  */
 #include "ConfigFile.h"
 Configuration::FileReader *CoverageConfiguration;
-
 Configuration::Options_t Options[] = {
   { "explanations",         NULL },
   { "format",               NULL },
   { "symbolsFile",          NULL },
   { "outputDirectory",      NULL },
   { "executableExtension",  NULL },
   { "coverageExtension",    NULL },
   { "target",               NULL },