CallStack.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_CALLSTACK_H_
#define _MIRA_CALLSTACK_H_

#include <platform/Types.h>
#include <serialization/GetterSetter.h>

#include <execinfo.h>

#include <string>
#include <vector>

#ifndef Q_MOC_RUN
#include <boost/shared_array.hpp>
#endif

namespace mira {


class CallStack
{
protected:
    CallStack(void** stack, std::size_t stackSize, std::size_t stackStart) :
        mStack(stack), mStackSize(stackSize),
        mStackStart(stackStart) {}

public:

    CallStack() : mStackSize(0), mStackStart(0) {}

    CallStack(const CallStack& other) :
        mStack(other.mStack), mStackSize(other.mStackSize),
        mStackStart(other.mStackStart), mSymbols(other.mSymbols) {}

    const CallStack& operator=(const CallStack& other);

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        // mStack is only required to obtain the actual symbols,
        // no need to reflect it (luckily, as shared_array is not supported yet)
        r.property("stacksize", mStackSize, "");
        r.property("stackstart", mStackStart, "");
        r.property("symbols",
                   getter(&CallStack::getSymbols, this),
                   setter(&CallStack::setSymbols, this),
                   "");
    }

public:

    struct Symbol
    {
        Symbol() :
            address(0),
            offset(0) {}

        template<typename Reflector>
        void reflect(Reflector& r)
        {
            r.property("address", address, "");
            r.property("addressStr", addressStr, "");
            r.property("offset", offset, "");
            r.property("name", name, "");
            r.property("nameDemangled", nameDemangled, "");
            r.property("file", file, "");
        }

        int64 address;
        std::string addressStr;
        int64 offset;
        std::string name;
        std::string nameDemangled;
        std::string file;

        std::string sourceLocation() const;

        friend std::ostream& operator<<(std::ostream& os, const Symbol& s);
    };

    const Symbol& operator[](std::size_t i) const;

    std::size_t size() const { return mStackSize-mStackStart; }

    friend std::ostream& operator<<(std::ostream& os, const CallStack& stack);

public:
    static CallStack backtrace(std::size_t maxSize = 10, std::size_t stackStart = 1);

private:
    void obtainSymbols() const;

    const std::vector<Symbol>& getSymbols();
    void setSymbols(const std::vector<Symbol>& symbols);

private:
    boost::shared_array<void*> mStack;

    std::size_t mStackSize;
    std::size_t mStackStart;

    mutable std::vector<Symbol> mSymbols; // the symbols of the call stack
};


}

#endif