covoar: Merger the covoar source from rtems-testing.git.

Use waf to build covoar.

1 files changed, 399 insertions, 0 deletions

diff --git a/tester/covoar/CoverageMapBase.cc b/tester/covoar/CoverageMapBase.cc
new file mode 100644
index 0000000..407ef5f
--- /dev/null
+++ b/tester/covoar/CoverageMapBase.cc
@@ -0,0 +1,399 @@
+
+/*! @file CoverageMapBase.cc
+ *  @brief CoverageMapBase Implementation
+ *
+ *  This file contains the implementation of the functions 
+ *  which provide a base level of functionality of a CoverageMap.
+ */
+
+#include <libgen.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "CoverageMapBase.h"
+
+namespace Coverage {
+
+  CoverageMapBase::CoverageMapBase(
+    uint32_t low,
+    uint32_t high
+  )
+  {
+    uint32_t       a;
+    AddressRange_t range;
+
+    range.lowAddress  = low;
+    range.highAddress = high;
+    RangeList.push_back( range );
+
+    Size = high - low + 1;
+
+    Info = new perAddressInfo_t[ Size ];
+
+    for (a=0; a<Size; a++) {
+
+      perAddressInfo_t *i = &Info[ a ];
+
+      i->isStartOfInstruction = false;
+      i->wasExecuted          = 0;
+      i->isBranch             = false;
+      i->isNop                = false;
+      i->wasTaken             = 0;
+      i->wasNotTaken          = 0;
+    }
+  }
+
+  CoverageMapBase::~CoverageMapBase()
+  {
+    if (Info)
+      delete Info;
+  }
+ 
+  void  CoverageMapBase::Add( uint32_t low, uint32_t high )
+  {
+    AddressRange_t range;
+
+    range.lowAddress  = low;
+    range.highAddress = high;
+    RangeList.push_back( range );
+  }
+ 
+  bool CoverageMapBase::determineOffset( 
+    uint32_t  address, 
+    uint32_t *offset
+  )const
+  {
+    AddressRange::const_iterator  itr;
+
+    for ( itr = RangeList.begin(); itr != RangeList.end(); itr++ ) {
+      if ((address >= itr->lowAddress) && (address <= itr->highAddress)){
+        *offset = address - itr->lowAddress;
+        return true;
+      }
+    }
+    *offset = 0;
+    return false;
+  }
+
+
+  void CoverageMapBase::dump( void ) const {
+
+    uint32_t          a;
+    perAddressInfo_t* entry;
+
+    fprintf( stderr, "Coverage Map Contents:\n" );
+
+    /*
+     * XXX - Dump is only marking the first Address Range.
+     */
+
+    for (a = 0; a < Size; a++) {
+
+      entry = &Info[ a ];
+
+      fprintf(
+        stderr,
+        "0x%x - isStartOfInstruction = %s, wasExecuted = %s\n",
+        a + RangeList.front().lowAddress,
+        entry->isStartOfInstruction ? "TRUE" : "FALSE",
+        entry->wasExecuted ? "TRUE" : "FALSE"
+      );
+      fprintf(
+        stderr,
+        "           isBranch = %s, wasTaken = %s, wasNotTaken = %s\n",
+        entry->isBranch ? "TRUE" : "FALSE",
+        entry->wasTaken ? "TRUE" : "FALSE",
+        entry->wasNotTaken ? "TRUE" : "FALSE"
+      );
+    }
+  }
+
+  bool CoverageMapBase::getBeginningOfInstruction(
+    uint32_t  address,
+    uint32_t* beginning
+  ) const
+  {
+    bool           status = false;
+    uint32_t       start;
+    AddressRange_t range;
+
+
+    status = getRange( address, &range );
+    if ( status != true )
+      return status;
+
+    start = address;
+
+    while (start >= range.lowAddress ) {
+      if (Info[ start - range.lowAddress ].isStartOfInstruction) {
+        *beginning = start;
+        status = true;
+        break;
+      }
+      else
+        start--;
+    }
+
+    return status;
+  }
+
+  int32_t CoverageMapBase::getFirstLowAddress() const
+  {
+    return RangeList.front().lowAddress;
+  }
+
+  bool CoverageMapBase::getRange( uint32_t address, AddressRange_t *range ) const
+  {
+    AddressRange::const_iterator  itr;
+
+    for ( itr = RangeList.begin(); itr != RangeList.end(); itr++ ) {
+      if ((address >= itr->lowAddress) && (address <= itr->highAddress)){
+        range->lowAddress = itr->lowAddress;
+        range->highAddress = itr->highAddress;
+        return true;
+      }
+    }
+
+    range->lowAddress  = 0;
+    range->highAddress = 0;
+
+    return false;
+
+  }
+
+  uint32_t CoverageMapBase::getSize() const
+  {
+    return Size;
+  }
+
+  void CoverageMapBase::setIsStartOfInstruction(
+    uint32_t    address
+  )
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    Info[ offset ].isStartOfInstruction = true;
+  }
+
+  bool CoverageMapBase::isStartOfInstruction( uint32_t address ) const
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return false;
+
+    return Info[ offset ].isStartOfInstruction;
+  }
+
+  void CoverageMapBase::setWasExecuted( uint32_t address )
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    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)
+      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;	
+  }
+
+  void CoverageMapBase::setIsBranch(
+    uint32_t    address
+  )
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    Info[ offset ].isBranch = true;
+  }
+
+  bool CoverageMapBase::isNop( uint32_t address ) const
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return false;
+
+    return Info[ offset ].isNop;
+  }
+
+  void CoverageMapBase::setIsNop(
+    uint32_t    address
+  )
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    Info[ offset ].isNop = true;
+  }
+
+  bool CoverageMapBase::isBranch( uint32_t address ) const
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return false;
+
+    return Info[ offset ].isBranch;
+  }
+
+  void CoverageMapBase::setWasTaken(
+    uint32_t    address
+  )
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    Info[ offset ].wasTaken += 1;
+  }
+
+  void CoverageMapBase::setWasNotTaken(
+    uint32_t    address
+  )
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    Info[ offset ].wasNotTaken += 1;
+  }
+
+  bool CoverageMapBase::wasAlwaysTaken( uint32_t address ) const
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return false;
+
+    return (Info[ offset ].wasTaken &&
+            !Info[ offset ].wasNotTaken);
+  }
+
+  bool CoverageMapBase::wasNeverTaken( uint32_t address ) const
+  {
+    uint32_t offset;
+ 
+    if (determineOffset( address, &offset ) != true)
+      return false;
+
+    return (!Info[ offset ].wasTaken &&
+            Info[ offset ].wasNotTaken);
+  }
+
+  bool CoverageMapBase::wasNotTaken( uint32_t address ) const
+  {
+	    uint32_t offset;
+	    bool     result;
+
+	    result = true;
+
+	    if (determineOffset( address, &offset ) != true)
+	      result = false;
+
+	    if (Info[ offset ].wasNotTaken <= 0)
+	      result = false;
+
+	    return result;
+  }
+
+  void CoverageMapBase::sumWasNotTaken( uint32_t address, uint32_t addition)
+  {
+    uint32_t offset;
+
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    Info[ offset ].wasNotTaken += addition;
+  }
+
+  uint32_t CoverageMapBase::getWasNotTaken( uint32_t address ) const
+  {
+    uint32_t offset;
+
+    if (determineOffset( address, &offset ) != true)
+      return 0;
+
+    return Info[ offset ].wasNotTaken;
+  }
+
+  bool CoverageMapBase::wasTaken( uint32_t address ) const
+  {
+    uint32_t offset;
+    bool     result;
+
+    result = true;
+ 
+    if (determineOffset( address, &offset ) != true)
+      result = false;
+
+    if (Info[ offset ].wasTaken <= 0)
+      result = false;
+
+    return result;
+  }
+
+  void CoverageMapBase::sumWasTaken( uint32_t address, uint32_t addition)
+  {
+    uint32_t offset;
+
+    if (determineOffset( address, &offset ) != true)
+      return;
+
+    Info[ offset ].wasTaken += addition;
+  }
+
+  uint32_t CoverageMapBase::getWasTaken( uint32_t address ) const
+  {
+    uint32_t offset;
+
+    if (determineOffset( address, &offset ) != true)
+      return 0;
+
+    return Info[ offset ].wasTaken;
+  }
+}