Trying to catch on to using 'discover'

Question

I am upgrading our Solaris C++ compilation system all the way from SolStudio v6 Update 2 on Solaris 8 to SolarisStudio 12.2 on Solaris 10. (About time, huh?) Things seem to be going well enough but am struggling with the included 'discover' tool. The documentation seems a bit short and its reported "errors" seem rather dubious - but, hey, you learn something every day (especially with C++ ... ;) )
Suggestions would be appreciated.
Here is a rather abbreviate example of the type of oddity I am getting. I am writing a small application to test a class named CNCTimeStamp. The class has a fair number of features, but it can be boiled down to this
nctimestamp.h
class CNCTimeStamp {
public:
  CNCTimeStamp();
  virtual ~CNCTimeStamp();
protected:
  time_t m_timestamp;
  mutable struct tm* m_tm;
}; // class CNCTimeStampnctimestamp.cpp
CNCTimeStamp::CNCTimeStamp() :
     m_timestamp(0),
     m_tm(0)
     ::time( &m_timestamp );
} // CNCTimeStampWhen I build it, using dmake, I get
berlin{devel}528: dmake test1
dmake: defaulting to parallel mode.
See the man page dmake(1) for more information on setting up the .dmakerc file.
nervecenter --> 1 job
/opt/solstudio12.2/bin/CC -g -xO2 -I.. -c timetoy.cpp
nervecenter --> 2 jobs
/opt/solstudio12.2/bin/CC -g -xO2 -I.. -c ../nctimestamp.cpp
nervecenter --> 1 job
/opt/solstudio12.2/bin/CC -g -xO2 -o timetoy timetoy.o nctimestamp.o
/usr/bin/file timetoy
/usr/bin/ldd timetoy
nervecenter --> Job output
/opt/solstudio12.2/bin/CC -g -xO2 -o timetoy timetoy.o nctimestamp.o
/usr/bin/file timetoy
timetoy:        ELF 32-bit LSB executable 80386 Version 1 [FPU], dynamically linked, not stripped
/usr/bin/ldd timetoy
        libCstd.so.1 =>  /usr/lib/libCstd.so.1
        libCrun.so.1 =>  /usr/lib/libCrun.so.1
        libm.so.2 =>     /usr/lib/libm.so.2
        libc.so.1 =>     /usr/lib/libc.so.1
nervecenter --> 1 job
/opt/solstudio12.2/bin/discover -b /opt/firefox4/firefox -H timetoy.html -w timetoy.txt -o timetoy.disc timetoy
berlin{devel}529:All looks good so far. When I run "timetoy.disc", I get a multitude of "errors". The first is this, which shows enough in its source listing that you can see what's going on. My trouble is in grasping what an "SBR" is and how it would apply. Thoughts?
I tried this, btw, replacing the "CNCTimeStamp* start = new CNCTimeStamp();" with "CNCTimeStamp start;" to no avail. Same SBR errors. I make no claim to being an expert with C++, but all this seems over the top. Fortunately, I am wrong most of time. LOL
ERROR 1 (SBR): read from 0x8046ea0 (4 bytes) is beyond stack frame bounds at:
        CNCTimeStamp::CNCTimeStamp #Nvariant 1() + 0x36  <nctimestamp.cpp:37>
                34:    // -------------------------------------------------------------------
                35:    // Constructors
                36:
                37:=>  CNCTimeStamp::CNCTimeStamp() :
                38:     m_timestamp(0),
                39:     m_tm(0)
                40:    {
        void nap(int) + 0xfa  <timetoy.cpp:11>
                 8:
                 9:    void nap( int naptime )
                10:    {
                11:=>           CNCTimeStamp* start = new CNCTimeStamp();
                12:
                13:     std::cout << *start << ". Start time." << std::endl;
                14:
        main() + 0x86  <timetoy.cpp:48>
                45:
                46:     for ( int i = 0; i<argc; ++i )
                47:     {
                48:=>           nap( argc );
                49:     }
                50:
                51:     timeplus( argc );
        _start() + 0x7c
ERROR 2 (SBR): read from 0x8046ea0 (4 bytes) is beyond stack frame bounds at:
        CNCTimeStamp::CNCTimeStamp #Nvariant 1() + 0x5c  <nctimestamp.cpp:37>
                34:    // -------------------------------------------------------------------
                35:    // Constructors
                36:
                37:=>  CNCTimeStamp::CNCTimeStamp() :
                38:     m_timestamp(0),
                39:     m_tm(0)
                40:    {
        void nap(int) + 0xfa  <timetoy.cpp:11>
                 8:
                 9:    void nap( int naptime )
                10:    {
                11:=>           CNCTimeStamp* start = new CNCTimeStamp();
                12:
                13:     std::cout << *start << ". Start time." << std::endl;
                14:
        main() + 0x86  <timetoy.cpp:48>
                45:
                46:     for ( int i = 0; i<argc; ++i )
                47:     {
                48:=>           nap( argc );
                49:     }
                50:
                51:     timeplus( argc );
        _start() + 0x7c
ERROR 3 (SBR): read from 0x8046ea0 (4 bytes) is beyond stack frame bounds at:
        CNCTimeStamp::CNCTimeStamp #Nvariant 1() + 0x84  <nctimestamp.cpp:39>
                36:
                37:    CNCTimeStamp::CNCTimeStamp() :
                38:     m_timestamp(0),
                39:=>   m_tm(0)
                40:    {
                41:     ::time( &m_timestamp );
                42:    } // CNCTimeStamp
        void nap(int) + 0xfa  <timetoy.cpp:11>
                 8:
                 9:    void nap( int naptime )
                10:    {
                11:=>           CNCTimeStamp* start = new CNCTimeStamp();
                12:
                13:     std::cout << *start << ". Start time." << std::endl;
                14:
        main() + 0x86  <timetoy.cpp:48>
                45:
                46:     for ( int i = 0; i<argc; ++i )
                47:     {
                48:=>           nap( argc );
                49:     }
                50:
                51:     timeplus( argc );
        _start() + 0x7c
ERROR 4 (SBR): read from 0x8046ea0 (4 bytes) is beyond stack frame bounds at:
        CNCTimeStamp::CNCTimeStamp #Nvariant 1() + 0xac  <nctimestamp.cpp:39>
                36:
                37:    CNCTimeStamp::CNCTimeStamp() :
                38:     m_timestamp(0),
                39:=>   m_tm(0)
                40:    {
                41:     ::time( &m_timestamp );
                42:    } // CNCTimeStamp
        void nap(int) + 0xfa  <timetoy.cpp:11>
                 8:
                 9:    void nap( int naptime )
                10:    {
                11:=>           CNCTimeStamp* start = new CNCTimeStamp();
                12:
                13:     std::cout << *start << ". Start time." << std::endl;
                14:
        main() + 0x86  <timetoy.cpp:48>
                45:
                46:     for ( int i = 0; i<argc; ++i )
                47:     {
                48:=>           nap( argc );
                49:     }
                50:
                51:     timeplus( argc );
        _start() + 0x7c
ERROR 5 (SBR): read from 0x8046ea0 (4 bytes) is beyond stack frame bounds at:
        CNCTimeStamp::CNCTimeStamp #Nvariant 1() + 0xe4  <nctimestamp.cpp:41>
                38:     m_timestamp(0),
                39:     m_tm(0)
                40:    {
                41:=>   ::time( &m_timestamp );
                42:    } // CNCTimeStamp
                43:
                44:    CNCTimeStamp::CNCTimeStamp( time_t timestamp ) :
        void nap(int) + 0xfa  <timetoy.cpp:11>
                 8:
                 9:    void nap( int naptime )
                10:    {
                11:=>           CNCTimeStamp* start = new CNCTimeStamp();
                12:
                13:     std::cout << *start << ". Start time." << std::endl;
                14:
        main() + 0x86  <timetoy.cpp:48>
                45:
                46:     for ( int i = 0; i<argc; ++i )
                47:     {
                48:=>           nap( argc );
                49:     }
                50:
                51:     timeplus( argc );
        _start() + 0x7cThanks.

Answer 1

In the interest of helping out. I'll copy/paste here the makefile and source code. If it gets to be too long, I'll have to reply to this reply - and so on.
There are four pieces: makefile, timetoy.cpp, nctimestamp.h and nctimestamp.cpp. The goal of this exercise has been to port the code base -this C++ class, CNCTimeStamp, is merely a first piece - up to the current Solaris Studio 12.2 C++ environment. At this point I am only using the command-line interface (dmake, dbx, CC). I hope to get to solstudio and dbxtool soon -- they look great!
makefile
CCC             = /opt/solstudio12.2/bin/CC
DISCOVER        = /opt/solstudio12.2/bin/discover
FILE            = /usr/bin/file
LDD             = /usr/bin/ldd
WEBBROWSER      = /opt/firefox4/firefox
CC_OPTIMIZE     = -m32 -g -xO2
timetoy: timetoy.o nctimestamp.o
        $(CCC) $(CC_OPTIMIZE) -o $@ timetoy.o nctimestamp.o
        $(FILE) $@
        $(LDD) $@
timetoy.disc: timetoy
        $(DISCOVER) -w timetoy.txt -o $@ timetoy
timetoy.o: timetoy.cpp
        $(CCC) $(CC_OPTIMIZE) -I.. -c timetoy.cpp
nctimestamp.o: ../nctimestamp.cpp
        $(CCC) $(CC_OPTIMIZE) -I.. -c ../nctimestamp.cpp
clean:
        $(RM) timetoy
        $(RM) timetoy.disc
        $(RM) timetoy.o nctimestamp.o
test1: timetoy.disc
        ./timetoy.disc 1 1 1timetoy.cpp
#include <iostream>
#include <unistd.h>             // sleep(3C)
#include <inttypes.h>           // int32_t
#include "nctimestamp.h"
void nap( int naptime )
        CNCTimeStamp* start = new CNCTimeStamp();
        std::cout << *start << ". Start time." << std::endl;
        sleep( naptime );
        CNCTimeStamp* stop = new CNCTimeStamp();
        time_t mynap = *stop - *start;
        std::cout << *stop << ". That nap was " << mynap << " seconds long." << std::endl;
        delete start;
        start = 0;
        delete stop;
        stop = 0;
} // nap
void timeplus( time_t offset )
        CNCTimeStamp now;
        time_t zoom = now.plus( offset );
        CNCTimeStamp* future = new CNCTimeStamp( zoom );
        std::cout << now << " plus " << offset << " is " << *future << std::endl;
        delete future;
int main( int argc, const char* argv[] )
        int result = EXIT_SUCCESS;
        for ( int i = 0; i<argc; ++i )
                nap( argc );
        timeplus( argc );
        return result;
} // mainnctimestamp.h
#ifndef _NCTIMESTAMP_H_
#define _NCTIMESTAMP_H_
#include <iostream>             // std:: ostream
#include <string>               // std:: string
#include <ctime>                // std:: time_t, struct tm
#include <inttypes.h>           // int32_t
// Class CNCTimeStamp represents a single moment in time.
// Implementation:
// 1. The class has two attributes, m_timestamp and m_tm.  The first,
// m_timestamp, must always be maintained from contruction thru
// to destruction.  The second, m_tm, is brought into use only
// as needed; it is entirely secondary to m_timestamp.  The function
// tm() is called to bring it into existance or return m_tm if it
// is already created.
// 2. Reliance on system calls is intentionally limited.  time(2)
// is called only in the default constructor, which is the means
// for the client to create an instance set to the present moment
// in time.  localtime(3c) is used at the point when the m_tm
// needs to be instantiated.
class CNCTimeStamp {
public: // Construction
        CNCTimeStamp();
                // Represents the current time.
                // (The moment in time when the instance
                // is created.)
        CNCTimeStamp( time_t timestamp );
                // Represents the moment set by 'timestamp'.
        CNCTimeStamp( int year,
                      int month,
                      int day,
                      int hour = 0,
                      int minute = 0,
                      int second = 0,
                      bool* isDST = 0 );
                // Represents the moment set by the params.
        CNCTimeStamp( const struct tm& tm );
                // Represents the moment set by the tm struct.
        CNCTimeStamp( const CNCTimeStamp& other );
                // Copy constructor.
        virtual ~CNCTimeStamp();
public:
        const CNCTimeStamp& operator = ( const CNCTimeStamp& source );
        const CNCTimeStamp& operator = ( time_t time );
        const CNCTimeStamp& operator = ( const struct tm& tm );
public: // Output
        std::string YYYYMMDD_HHMMSS() const;
        std::ostream& YYYYMMDD_HHMMSS( std::ostream& os ) const;
                // Print the time as "yyyy-hh-mm hh-mm-ss"
                // ex: "2010-01-31 13:59:03"
public: // Conversion routines (public / static )
        static struct tm* tm( time_t time);
        static time_t time( struct tm* Tm );
public: // Comparison
        bool operator == ( const CNCTimeStamp& other ) const;
        bool operator == ( time_t timestamp ) const;
        bool operator != ( const CNCTimeStamp& other ) const;
        bool operator != ( time_t timestamp ) const;
        bool operator < ( const CNCTimeStamp& other ) const;
        bool operator < ( time_t timestamp ) const;
        bool operator <= ( const CNCTimeStamp& other ) const;
        bool operator <= ( time_t timestamp ) const;
        bool operator > ( const CNCTimeStamp& other ) const;
        bool operator > ( time_t timestamp ) const;
        bool operator >= ( const CNCTimeStamp& other ) const;
        bool operator >= ( time_t timestamp ) const;
public: // Comparison
        int delta( const CNCTimeStamp& other ) const;
                // The amount of time, in seconds, between this
                // instance and the 'other'. The result can be
                // positive (future) or negative (past) or
                // zero (present).
                // Ex: If both this and other are for the same
                // minute in time, but 'this' is for the 30th
                // second and 'other' is for the 44th second,
                // then the delta is -14 seconds. As in, this
                // instance is 14 seconds behind the 'other'.
        static int delta( const CNCTimeStamp& first, const CNCTimeStamp& second );
                // The amount of time, in seconds, between the
                // 'first' and 'second' instances. The result can be
                // positive (future) or negative (past) or
                // zero (present).
                // Ex: If both 'first' and 'second' are for the same
                // minute in time, but 'first' is for the 3rd
                // second and 'second' is for the 13th second,
                // then the delta is -10 seconds. As in, the
                // 'first' instance is 10 seconds behind the
                // 'second'.
public: // Operations (Addition / Subtraction)
        time_t plus( time_t timespan ) const;
        time_t operator + ( time_t timespan ) const;
        time_t subtract( time_t timespan ) const;
        time_t operator - ( time_t timespan ) const;
        time_t subtract( const CNCTimeStamp& other ) const;
        time_t operator - ( const CNCTimeStamp& other ) const;
public: // Access
        operator time_t() const;
protected:
        struct tm* tm() const;
protected:
        time_t m_timestamp;
        mutable struct tm* m_tm;
}; // class CNCTimeStamp
std::ostream& operator<<( std::ostream& os, const CNCTimeStamp& timestamp );
#endif // _NCTIMESTAMP_H_nctimestamp.cpp
#include "nctimestamp.h"
#include <iomanip>
#include <iostream>
#include <ctime>        // time_t mktime( struct std::tm* timeptr )
// Constructors
CNCTimeStamp::CNCTimeStamp() :
        m_timestamp(0),
        m_tm(0)
        ::time( &m_timestamp );
} // CNCTimeStamp
CNCTimeStamp::CNCTimeStamp( time_t timestamp ) :
        m_timestamp( timestamp ),
        m_tm(0)
CNCTimeStamp::CNCTimeStamp( int year,
                            int month,
                            int day,
                            int hour,
                            int minute,
                            int second,
                            bool* isDST ) :
        m_timestamp(0),
        m_tm(0)
        m_tm = new struct tm;
        memset( m_tm, 0, sizeof( struct tm ) );
        m_tm->tm_year = year - 1900;
        m_tm->tm_mon = month - 1;
        m_tm->tm_mday = day;
        m_tm->tm_hour = hour;
        m_tm->tm_min = minute;
        m_tm->tm_sec = second;
        m_tm->tm_wday = 0; // will be filled out by mktime()
        m_tm->tm_yday = 0; // will be filled out by mktime()
        if ( !isDST )
                m_tm->tm_isdst = -1;
        else
                m_tm->tm_isdst = ( *isDST ) ? 1 : 0;
        m_timestamp = mktime( m_tm );   // <ctime> function
CNCTimeStamp::CNCTimeStamp( const CNCTimeStamp& other ) :
        m_timestamp( other.m_timestamp ),
        m_tm(0)
CNCTimeStamp::~CNCTimeStamp()
        if ( m_tm )
                delete m_tm;
                m_tm = 0;
} // ~CNCTimeStamp
// operator =
const CNCTimeStamp& CNCTimeStamp::operator = ( const CNCTimeStamp& source )
        if ( this != &source )
                m_timestamp = source.m_timestamp;
                if ( m_tm )
                        delete m_tm;
                        m_tm = 0;
                if ( source.m_tm )
                        m_tm = new struct tm( *source.m_tm );
        return *this;
} // operator =
// operator =
const CNCTimeStamp& CNCTimeStamp::operator = ( time_t time )
        m_timestamp = time;
        if ( m_tm )
                delete m_tm;
                m_tm = 0;
        return *this;
} // operator =
// operator =
const CNCTimeStamp& CNCTimeStamp::operator = ( const struct tm& tm )
        if ( m_tm )
                delete m_tm;
                m_tm = 0;
        m_tm = new struct tm( tm );
        m_timestamp = mktime( m_tm );   // <ctime> function
        return *this;
} // operator =
// operator !=
bool CNCTimeStamp::operator != ( const CNCTimeStamp& other ) const
        return ( m_timestamp != other.m_timestamp ) ? true : false;
// operator ==
bool CNCTimeStamp::operator == ( const CNCTimeStamp& other ) const
        return ( m_timestamp == other.m_timestamp ) ? true : false;
// operator =
bool CNCTimeStamp::operator != ( time_t timestamp ) const
        return ( m_timestamp != timestamp ) ? true : false;
// operator =
bool CNCTimeStamp::operator == ( time_t timestamp ) const
        return ( m_timestamp == timestamp ) ? true : false;
// operator <
bool CNCTimeStamp::operator < ( const CNCTimeStamp& other ) const
        return ( m_timestamp < other.m_timestamp ) ? true : false;
// operator <
bool CNCTimeStamp::operator < ( time_t timestamp ) const
        return ( m_timestamp < timestamp ) ? true : false;
// operator <=
bool CNCTimeStamp::operator <= ( const CNCTimeStamp& other ) const
        return ( m_timestamp <= other.m_timestamp ) ? true : false;
// operator <=
bool CNCTimeStamp::operator <= ( time_t timestamp ) const
        return ( m_timestamp <= timestamp ) ? true : false;
// operator >
bool CNCTimeStamp::operator > ( const CNCTimeStamp& other ) const
        return ( m_timestamp > other.m_timestamp ) ? true : false;
// operator >
bool CNCTimeStamp::operator > ( time_t timestamp ) const
        return ( m_timestamp > timestamp ) ? true : false;
// operator >=
bool CNCTimeStamp::operator >= ( const CNCTimeStamp& other ) const
        return ( m_timestamp >= other.m_timestamp ) ? true : false;
// operator >=
bool CNCTimeStamp::operator >= ( time_t timestamp ) const
        return ( m_timestamp >= m_timestamp ) ? true : false;
// plus
time_t CNCTimeStamp::plus( time_t timespan ) const
        return m_timestamp + timespan;
} // plus
// operator +
time_t CNCTimeStamp::operator + ( time_t timespan ) const
        return plus( timespan );
} // operator +
// subtract
time_t CNCTimeStamp::subtract( time_t timespan ) const
        return m_timestamp - timespan;
} // subtract
// operator -
time_t CNCTimeStamp::operator - ( time_t timespan ) const
        return subtract( timespan );
} // operator -
// subtract
time_t CNCTimeStamp::subtract( const CNCTimeStamp& other ) const
        return (m_timestamp - other.m_timestamp);
} // subtract
// operator -
time_t CNCTimeStamp::operator - ( const CNCTimeStamp& other ) const
        return subtract( other );
} // operator -
// tm
struct tm* CNCTimeStamp::tm() const
        if ( !m_tm )
                m_tm = tm( m_timestamp );
        return m_tm;
} // tm
// tm
struct tm* CNCTimeStamp::tm( time_t time )
        struct tm* result = new struct tm;
        memset( result, 0, sizeof( struct tm ) );
#if defined(__unix)
        localtime_r( &time, result );
#else
        result = localtime( &time );
#endif
        return result;
} // tm
// YYYYMMDD_HHMMSS
std::string CNCTimeStamp::YYYYMMDD_HHMMSS() const
        struct tm* Tm = tm();
#if 1
        // format: "yyyy-mm-dd hh:mm:ss" which is a constant 19 chars.
        char buffer[24];
        sprintf( buffer, "%04d-%02d-%02d %02d:%02d:%02d",
                 Tm->tm_year + 1900,
                 Tm->tm_mon + 1,
                 Tm->tm_mday,
                 Tm->tm_hour,
                 Tm->tm_min,
                 Tm->tm_sec );
        std::string result( buffer );
        return result;
#else
        // This is slow at runtime. The problem is that it
        // relies heavily on the heap for building up its
        // value.
        std::ostringstream result;
        result << std::setfill('0')
               << std::setw(4) << Tm->tm_year + 1900
               << "-"
               << std::setw(2) << Tm->tm_mon + 1
               << "-"
               << std::setw(2) << Tm->tm_mday
               << " "
               << std::setw(2) << Tm->tm_hour
               << ":"
               << std::setw(2) << Tm->tm_min
               << ":"
               << std::setw(2) << Tm->tm_sec;
        return result.str();
#endif
} // YYYYMMDD_HHMMSS
// YYYYMMDD_HHMMSS
std::ostream& CNCTimeStamp::YYYYMMDD_HHMMSS( std::ostream& os ) const
        os << YYYYMMDD_HHMMSS();
        return os;
} // YYYYMMDD_HHMMSS
// time
time_t CNCTimeStamp::time( struct tm* tb )
        return mktime( tb );    // <ctime> function
// operator time_t
CNCTimeStamp::operator time_t() const
        return m_timestamp;
} // operator std::time_t
// operator<<
//      Note, there is no 'this' pointer within this function.  Also,
//      ensure the feature 'YYYYMMDD_HHMMSS' is virtual for all descendents
//      of CNCTimeStamp.
std::ostream& operator<<( std::ostream& os, const CNCTimeStamp& timestamp )
        return timestamp.YYYYMMDD_HHMMSS( os );
} // operator <<
// ###