/*
    This file is part of KCachegrind.

    SPDX-FileCopyrightText: 2002-2016 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>

    SPDX-License-Identifier: GPL-2.0-only
*/


#include "tracedata.h"

#include <errno.h>
#include <stdlib.h>
#include <vector>
#include <iterator>
#include <memory>
#include <algorithm>
#include <numeric>

#include <QFile>
#include <QDir>
#include <QFileInfo>
#include <QDebug>

#include "logger.h"
#include "loader.h"
#include "globalconfig.h"
#include "utils.h"
#include "fixcost.h"


#define TRACE_DEBUG      0
#define TRACE_ASSERTIONS 0




//---------------------------------------------------
// TraceJumpCost

TraceJumpCost::TraceJumpCost(ProfileContext* c)
    :CostItem(c)
{
    TraceJumpCost::clear();
}

TraceJumpCost::~TraceJumpCost()
{}

SubCost TraceJumpCost::executedCount()
{
    if (_dirty) update();

    return _executedCount;
}

SubCost TraceJumpCost::followedCount()
{
    if (_dirty) update();

    return _followedCount;
}

QString TraceJumpCost::costString(EventTypeSet*)
{
    if (_dirty) update();

    return QStringLiteral("%1/%2")
            .arg(_followedCount.pretty())
            .arg(_executedCount.pretty());
}

void TraceJumpCost::clear()
{
    _followedCount = 0;
    _executedCount = 0;
}

void TraceJumpCost::addCost(TraceJumpCost* item)
{
    if (item->_dirty) item->update();

    _followedCount += item->followedCount();
    _executedCount += item->executedCount();
}



//---------------------------------------------------
// TraceCallCost

TraceCallCost::TraceCallCost(ProfileContext* context)
    : ProfileCostArray(context)
{
    _callCount = 0;
}

TraceCallCost::~TraceCallCost()
{}


QString TraceCallCost::costString(EventTypeSet* m)
{
    return QStringLiteral("%1, Calls %2")
            .arg(ProfileCostArray::costString(m))
            .arg(_callCount.pretty());
}

QString TraceCallCost::prettyCallCount()
{
    return _callCount.pretty();
}

void TraceCallCost::clear()
{
    _callCount = 0;
    ProfileCostArray::clear();
}

SubCost TraceCallCost::callCount()
{
    if (_dirty) update();

    return _callCount;
}

void TraceCallCost::addCallCount(SubCost c)
{
    _callCount += c;

    invalidate();
}


//---------------------------------------------------
// TraceInclusiveCost

TraceInclusiveCost::TraceInclusiveCost(ProfileContext* context)
    : ProfileCostArray(context), _inclusive(context)
{}

TraceInclusiveCost::~TraceInclusiveCost()
{}

QString TraceInclusiveCost::costString(EventTypeSet* m)
{
    return QStringLiteral("%1, Inclusive %2")
            .arg(ProfileCostArray::costString(m))
            .arg(_inclusive.costString(m));
}

void TraceInclusiveCost::clear()
{
    _inclusive.clear();
    ProfileCostArray::clear();
}

ProfileCostArray* TraceInclusiveCost::inclusive()
{
    if (_dirty) update();

    return &_inclusive;
}

void TraceInclusiveCost::addInclusive(ProfileCostArray* c)
{
    _inclusive.addCost(c);

    invalidate();
}


//---------------------------------------------------
// TraceListCost

TraceListCost::TraceListCost(ProfileContext* context)
    : ProfileCostArray(context)
{
    _lastDep = nullptr;
}

TraceListCost::~TraceListCost()
{}

void TraceListCost::addDep(ProfileCostArray* dep)
{
#if TRACE_ASSERTIONS
    if (_deps.contains(dep)) {
        qDebug("addDep: %s already in list!",
               qPrintable(dep->fullName()));
        return;
    }
#endif

    _deps.append(dep);
    _lastDep = dep;
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(dep->fullName()),
           _deps.count());
#endif
}

ProfileCostArray* TraceListCost::findDepFromPart(TracePart* part)
{
    if (_lastDep && _lastDep->part() == part)
        return _lastDep;

    foreach(ProfileCostArray* dep, _deps) {
        if (dep->part() == part) {
            _lastDep = dep;
            return dep;
        }
    }
    return nullptr;
}


void TraceListCost::update()
{
    if (!_dirty) return;

#if TRACE_DEBUG
    qDebug("update %s (count %d)",
           qPrintable( fullName() ), _deps.count());
#endif

    clear();
    foreach(ProfileCostArray* item, _deps) {
        if (onlyActiveParts())
            if (!item->part() || !item->part()->isActive()) continue;

        addCost(item);
    }

    _dirty = false;

#if TRACE_DEBUG
    qDebug("   > %s", qPrintable(costString(0)));
#endif
}



//---------------------------------------------------
// TraceJumpListCost

TraceJumpListCost::TraceJumpListCost(ProfileContext* context)
    : TraceJumpCost(context)
{
    _lastDep = nullptr;
}

TraceJumpListCost::~TraceJumpListCost()
{}

void TraceJumpListCost::addDep(TraceJumpCost* dep)
{
#if TRACE_ASSERTIONS
    if (_deps.contains(dep)) {
        qDebug("addDep: %s already in list!",
               qPrintable(dep->fullName()));
        return;
    }
#endif

    _deps.append(dep);
    _lastDep = dep;
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(dep->fullName()),
           _deps.count());
#endif
}

TraceJumpCost* TraceJumpListCost::findDepFromPart(TracePart* part)
{
    if (_lastDep && _lastDep->part() == part)
        return _lastDep;

    foreach(TraceJumpCost* dep, _deps) {
        if (dep->part() == part) {
            _lastDep = dep;
            return dep;
        }
    }
    return nullptr;
}


void TraceJumpListCost::update()
{
    if (!_dirty) return;

#if TRACE_DEBUG
    qDebug("update %s (count %d)",
           qPrintable( fullName() ), _deps.count());
#endif

    clear();
    foreach(TraceJumpCost* item, _deps) {
        if (onlyActiveParts())
            if (!item->part() || !item->part()->isActive()) continue;

        addCost(item);
    }

    _dirty = false;

#if TRACE_DEBUG
    qDebug("   > %s", qPrintable(costString(0)));
#endif
}



//---------------------------------------------------
// TraceCallListCost

TraceCallListCost::TraceCallListCost(ProfileContext* context)
    : TraceCallCost(context)
{
    _lastDep = nullptr;
}

TraceCallListCost::~TraceCallListCost()
{}

void TraceCallListCost::addDep(TraceCallCost* dep)
{
#if TRACE_ASSERTIONS
    if (_deps.contains(dep)) {
        qDebug("addDep: %s already in list!",
               qPrintable(dep->fullName()));
        return;
    }
#endif

    _deps.append(dep);
    _lastDep = dep;
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(dep->fullName()),
           _deps.count());
#endif
}

TraceCallCost* TraceCallListCost::findDepFromPart(TracePart* part)
{
    if (_lastDep && _lastDep->part() == part)
        return _lastDep;

    foreach(TraceCallCost* dep, _deps) {
        if (dep->part() == part) {
            _lastDep = dep;
            return dep;
        }
    }
    return nullptr;
}


void TraceCallListCost::update()
{
    if (!_dirty) return;

#if TRACE_DEBUG
    qDebug("update %s (count %d)",
           qPrintable( fullName() ), _deps.count());
#endif

    /* Without dependent cost items, assume fixed costs,
     * i.e. do not change cost */
    if (_deps.count()>0) {
        clear();
        foreach(TraceCallCost* item, _deps) {
            if (onlyActiveParts())
                if (!item->part() || !item->part()->isActive()) continue;

            addCost(item);
            addCallCount(item->callCount());
        }
    }

    _dirty = false;

#if TRACE_DEBUG
    qDebug("   > %s", qPrintable(costString(0)));
#endif
}


//---------------------------------------------------
// TraceInclusiveListCost

TraceInclusiveListCost::TraceInclusiveListCost(ProfileContext* context)
    : TraceInclusiveCost(context)
{
    _lastDep = nullptr;
}

TraceInclusiveListCost::~TraceInclusiveListCost()
{}


void TraceInclusiveListCost::addDep(TraceInclusiveCost* dep)
{
#if TRACE_ASSERTIONS
    if (_deps.contains(dep)) {
        qDebug("addDep: %s already in list!",
               qPrintable(dep->fullName()));
        return;
    }
#endif

    _deps.append(dep);
    _lastDep = dep;
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(dep->fullName()),
           _deps.count());
#endif
}

TraceInclusiveCost* TraceInclusiveListCost::findDepFromPart(TracePart* part)
{
    if (_lastDep && _lastDep->part() == part)
        return _lastDep;

    foreach(TraceInclusiveCost* dep, _deps) {
        if (dep->part() == part) {
            _lastDep = dep;
            return dep;
        }
    }
    return nullptr;
}

void TraceInclusiveListCost::update()
{
    if (!_dirty) return;

#if TRACE_DEBUG
    qDebug("update %s (count %d)",
           qPrintable( fullName() ), _deps.count());
#endif

    clear();
    foreach(TraceInclusiveCost* item, _deps) {
        if (onlyActiveParts())
            if (!item->part() || !item->part()->isActive()) continue;

        addCost(item);
        addInclusive(item->inclusive());
    }

    _dirty = false;

#if TRACE_DEBUG
    qDebug("   > %s", qPrintable(costString(0)));
#endif
}



//---------------------------------------------------
// TracePartInstrJump

TracePartInstrJump::TracePartInstrJump(TraceInstrJump* instrJump,
                                       TracePartInstrJump* next)
    : TraceJumpCost(ProfileContext::context(ProfileContext::PartInstrJump))
{
    _dep = instrJump;
    _next = next;
}

TracePartInstrJump::~TracePartInstrJump()
{}


//---------------------------------------------------
// TracePartInstrCall

TracePartInstrCall::TracePartInstrCall(TraceInstrCall* instrCall)
    : TraceCallCost(ProfileContext::context(ProfileContext::PartInstrCall))
{
    _dep = instrCall;
}

TracePartInstrCall::~TracePartInstrCall()
{}



//---------------------------------------------------
// TracePartInstr

TracePartInstr::TracePartInstr(TraceInstr* instr)
    : ProfileCostArray(ProfileContext::context(ProfileContext::PartInstr))
{
    _dep = instr;
}

TracePartInstr::~TracePartInstr()
{}



//---------------------------------------------------
// TracePartLineJump

TracePartLineJump::TracePartLineJump(TraceLineJump* lineJump)
    : TraceJumpCost(ProfileContext::context(ProfileContext::PartLineJump))
{
    _dep = lineJump;
}

TracePartLineJump::~TracePartLineJump()
{}


//---------------------------------------------------
// TracePartLineCall

TracePartLineCall::TracePartLineCall(TraceLineCall* lineCall)
    : TraceCallCost(ProfileContext::context(ProfileContext::PartLineCall))
{
    _dep = lineCall;
}

TracePartLineCall::~TracePartLineCall()
{}


//---------------------------------------------------
// TracePartLine

TracePartLine::TracePartLine(TraceLine* line)
    : ProfileCostArray(ProfileContext::context(ProfileContext::PartLine))
{
    _dep = line;
}

TracePartLine::~TracePartLine()
{}




//---------------------------------------------------
// TracePartCall

TracePartCall::TracePartCall(TraceCall* call)
    : TraceCallListCost(ProfileContext::context(ProfileContext::PartCall))
{
    _dep = call;

    _firstFixCallCost = nullptr;
}

TracePartCall::~TracePartCall()
{}

bool TracePartCall::isRecursion()
{
    return call()->isRecursion();
}

void TracePartCall::update()
{
#if !USE_FIXCOST
    TraceCallListCost::update();
#else

    if (!_dirty) return;

#if TRACE_DEBUG
    qDebug("update %s", qPrintable( fullName() ));
#endif

    /* Without dependent cost items, assume fixed costs,
     * i.e. do not change cost */
    if (_firstFixCallCost) {
        clear();
        FixCallCost* item;
        for (item = _firstFixCallCost; item; item = item->nextCostOfPartCall())
            item->addTo(this);
    }

    _dirty = false;

#if TRACE_DEBUG
    qDebug("   > %s", qPrintable(costString(0)));
#endif

#endif // USE_FIXCOST
}


//---------------------------------------------------
// TracePartFunction

TracePartFunction::TracePartFunction(TraceFunction* function,
                                     TracePartObject* partObject,
                                     TracePartFile *partFile)
    : TraceInclusiveCost(ProfileContext::context(ProfileContext::PartFunction))
{
    _dep = function;
    _partObject = partObject;
    _partFile = partFile;
    _partClass = nullptr;

    _calledCount     = 0;
    _callingCount    = 0;
    _calledContexts  = 0;
    _callingContexts = 0;

    _firstFixCost = nullptr;
    _firstFixJump = nullptr;
}

TracePartFunction::~TracePartFunction()
{}

QString TracePartFunction::prettyCalledCount()
{
    return _calledCount.pretty();
}

QString TracePartFunction::prettyCallingCount()
{
    return _callingCount.pretty();
}

QString TracePartFunction::costString(EventTypeSet* m)
{
    update();

    QString res = TraceInclusiveCost::costString(m);
    res += QStringLiteral(", called from %1: %2")
           .arg(_calledContexts).arg(prettyCalledCount());
    res += QStringLiteral(", calling from %1: %2")
           .arg(_callingContexts).arg(prettyCallingCount());

    return res;
}


void TracePartFunction::addPartInstr(TracePartInstr* ref)
{
#if TRACE_ASSERTIONS
    if (_partInstr.contains(ref)) {
        qDebug("TracePartFunction::addPartInstr: %s already in list!",
               qPrintable(ref->name()));
        return;
    }
#endif

    _partInstr.append(ref);
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(ref->fullName()),
           _partInstr.count());
#endif
}


void TracePartFunction::addPartLine(TracePartLine* ref)
{
#if TRACE_ASSERTIONS
    if (_partLines.contains(ref)) {
        qDebug("TracePartFunction::addPartLine: %s already in list!",
               qPrintable(ref->name()));
        return;
    }
#endif

    _partLines.append(ref);
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(ref->fullName()),
           _partLines.count());
#endif
}


void TracePartFunction::addPartCaller(TracePartCall* ref)
{
#if TRACE_ASSERTIONS
    if (_partCallers.contains(ref)) {
        qDebug("TracePartFunction::addPartCaller: %s already in list!",
               qPrintable(ref->name()));
        return;
    }
#endif

    _partCallers.append(ref);
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added Caller\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(ref->fullName()),
           _partCallers.count());
#endif
}


void TracePartFunction::addPartCalling(TracePartCall* ref)
{
#if TRACE_ASSERTIONS
    if (_partCallings.contains(ref)) {
        qDebug("TracePartFunction::addPartCalling: %s already in list!",
               qPrintable(ref->name()));
        return;
    }
#endif

    _partCallings.append(ref);
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added Calling\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(ref->fullName()),
           _partCallings.count());
#endif
}

SubCost TracePartFunction::calledCount()
{
    if (_dirty) update();

    return _calledCount;
}

int TracePartFunction::calledContexts()
{
    if (_dirty) update();

    return _calledContexts;
}

SubCost TracePartFunction::callingCount()
{
    if (_dirty) update();

    return _callingCount;
}


int TracePartFunction::callingContexts()
{
    if (_dirty) update();

    return _callingContexts;
}


void TracePartFunction::update()
{
    if (!_dirty) return;

#if TRACE_DEBUG
    qDebug("TracePartFunction::update %s (Callers %d, Callings %d, lines %d)",
           qPrintable(name()), _partCallers.count(), _partCallings.count(),
           _partLines.count());
#endif

    _calledCount     = 0;
    _callingCount    = 0;
    _calledContexts  = 0;
    _callingContexts = 0;

    // To calculate context counts, we just use first real event type (FIXME?)
    EventType* e = data() ? data()->eventTypes()->realType(0) : nullptr;

    // calculate additional cost metrics
    foreach(TracePartCall* caller, _partCallers) {
        if (e && (caller->subCost(e) >0))
            _calledContexts++;

        SubCost c = caller->callCount();
        if (c>0) {
            _calledCount += c;
        }
    }
    foreach(TracePartCall* calling, _partCallings) {
        if (e && (calling->subCost(e)>0))
            _callingContexts++;

        SubCost c = calling->callCount();
        if (c>0) {
            _callingCount += c;
        }
    }

    // self cost
#if !USE_FIXCOST
    if (_partLines.count()>0) {
        ProfileCostArray::clear();

        foreach(TracePartLine* line, _partLines)
            addCost(line);
    }
#else
    if (_firstFixCost) {
        ProfileCostArray::clear();

        FixCost* item;
        for (item = _firstFixCost; item; item = item->nextCostOfPartFunction())
            item->addTo(this);
    }
#endif


    /* There are two possibilities to calculate inclusive cost:
     * 1) sum of call costs to this function
     * 2) sum of call costs from this function + self cost
     *
     * 1) is wrong if a function was called spontaneous, but also by a call.
     * This eventually can happen with thread/process startup functions,
     * and signal handlers.
     *
     * 2) is wrong with "skipped PLT" and the calltree skin, because
     *    cost of PLT is attributed to called function (?)
     *
     * For now, do 1) if there are callers, otherwise 2).
     * Should this be fixed to take the maximum of 1) and 2) ?
     */
    _inclusive.clear();
    if (_calledCount>0) {
        // inclusive cost: if possible, use caller sums
        foreach(TracePartCall* caller, _partCallers) {
            // detect simple recursion (no cycle)
            if (caller->isRecursion()) continue;

            addInclusive(caller);
        }
    }
    else {
        // without caller info, use calling sum + line costs
        foreach(TracePartCall* calling, _partCallings) {
            // detect simple recursion (no cycle)
            if (calling->isRecursion()) continue;

            addInclusive(calling);
        }
        _dirty = false; // do not recurse!
        addInclusive(this);
    }

    _dirty = false;

#if TRACE_DEBUG
    qDebug("   > %s", qPrintable(costString(0)));
#endif
}



//---------------------------------------------------
// TracePartClass

TracePartClass::TracePartClass(TraceClass* cls)
    : TraceInclusiveListCost(ProfileContext::context(ProfileContext::PartClass))
{
    _dep = cls;
}

TracePartClass::~TracePartClass()
{}

QString TracePartClass::prettyName() const
{
    return QStringLiteral("%1 from %2")
            .arg( _dep->name().isEmpty() ? QStringLiteral("(global)") : _dep->name())
            .arg(part()->name());
}

//---------------------------------------------------
// TracePartFile

TracePartFile::TracePartFile(TraceFile* file)
    : TraceInclusiveListCost(ProfileContext::context(ProfileContext::PartFile))
{
    _dep = file;
}

TracePartFile::~TracePartFile()
{}


//---------------------------------------------------
// TracePartObject

TracePartObject::TracePartObject(TraceObject* object)
    : TraceInclusiveListCost(ProfileContext::context(ProfileContext::PartObject))
{
    _dep = object;
}

TracePartObject::~TracePartObject()
{}




//---------------------------------------------------
// TraceInstrJump

TraceInstrJump::TraceInstrJump(TraceInstr* instrFrom, TraceInstr* instrTo,
                               bool isCondJump)
    : TraceJumpCost(ProfileContext::context(ProfileContext::InstrJump))
{
    _first = nullptr;

    _instrFrom = instrFrom;
    _instrTo = instrTo;
    _isCondJump = isCondJump;
}

TraceInstrJump::~TraceInstrJump()
{
    // we are the owner of the TracePartInstrJump's generated in our factory
    TracePartInstrJump* item = _first, *next;
    while(item) {
        next = item->next();
        delete item;
        item = next;
    }
}

TracePartInstrJump* TraceInstrJump::partInstrJump(TracePart* part)
{
    static TracePartInstrJump* item = nullptr;

    // shortcut if recently used
    if (item &&
        (item->instrJump()==this) &&
        (item->part() == part)) return item;

    for(item = _first; item; item = item->next())
        if (item->part() == part)
            return item;

    item = new TracePartInstrJump(this, _first);
    item->setPosition(part);
    _first = item;
    return item;
}

void TraceInstrJump::update()
{
    if (!_dirty) return;

    clear();
    TracePartInstrJump* item;
    for (item = _first; item; item = item->next()) {
        if (!item->part() || !item->part()->isActive()) continue;

        addCost(item);
    }
    _dirty = false;

#if TRACE_DEBUG
    qDebug("updated %s", qPrintable( fullName() ));
#endif

#if TRACE_DEBUG
    qDebug("   > %s", qPrintable(costString(0)));
#endif
}

QString TraceInstrJump::name() const
{
    return QStringLiteral("jump at 0x%1 to 0x%2")
            .arg(_instrFrom->addr().toString())
            .arg(_instrTo->addr().toString());
}


//---------------------------------------------------
// TraceLineJump

TraceLineJump::TraceLineJump(TraceLine* lineFrom, TraceLine* lineTo,
                             bool isCondJump)
    : TraceJumpListCost(ProfileContext::context(ProfileContext::LineJump))
{
    _lineFrom = lineFrom;
    _lineTo   = lineTo;
    _isCondJump = isCondJump;
}

TraceLineJump::~TraceLineJump()
{
    // we are the owner of TracePartLineJump's generated in our factory
    qDeleteAll(_deps);
}


TracePartLineJump* TraceLineJump::partLineJump(TracePart* part)
{
    TracePartLineJump* item = (TracePartLineJump*) findDepFromPart(part);
    if (!item) {
        item = new TracePartLineJump(this);
        item->setPosition(part);
        addDep(item);
    }
    return item;
}


QString TraceLineJump::name() const
{
    return QStringLiteral("jump at %1 to %2")
            .arg(_lineFrom->prettyName())
            .arg(_lineTo->prettyName());
}


//---------------------------------------------------
// TraceInstrCall

TraceInstrCall::TraceInstrCall(TraceCall* call, TraceInstr* instr)
    : TraceCallListCost(ProfileContext::context(ProfileContext::InstrCall))
{
    _call  = call;
    _instr = instr;
}

TraceInstrCall::~TraceInstrCall()
{
    // we are the owner of TracePartInstrCall's generated in our factory
    qDeleteAll(_deps);
}


TracePartInstrCall* TraceInstrCall::partInstrCall(TracePart* part,
                                                  TracePartCall*)
{
    TracePartInstrCall* item = (TracePartInstrCall*) findDepFromPart(part);
    if (!item) {
        item = new TracePartInstrCall(this);
        item->setPosition(part);
        addDep(item);
        // instruction calls are not registered in function calls
        // as together with line calls calls are duplicated
        //partCall->addDep(item);
    }
    return item;
}


QString TraceInstrCall::name() const
{
    return QStringLiteral("%1 at %2").arg(_call->name()).arg(_instr->name());
}


//---------------------------------------------------
// TraceLineCall

TraceLineCall::TraceLineCall(TraceCall* call, TraceLine* line)
    : TraceCallListCost(ProfileContext::context(ProfileContext::LineCall))
{
    _call = call;

    _line = line;
}

TraceLineCall::~TraceLineCall()
{
    // we are the owner of TracePartLineCall's generated in our factory
    qDeleteAll(_deps);
}


TracePartLineCall* TraceLineCall::partLineCall(TracePart* part,
                                               TracePartCall* partCall)
{
    TracePartLineCall* item = (TracePartLineCall*) findDepFromPart(part);
    if (!item) {
        item = new TracePartLineCall(this);
        item->setPosition(part);
        addDep(item);
        partCall->addDep(item);
    }
    return item;
}


QString TraceLineCall::name() const
{
    return QStringLiteral("%1 at %2").arg(_call->name()).arg(_line->name());
}


//---------------------------------------------------
// TraceCall

TraceCall::TraceCall(TraceFunction* caller, TraceFunction* called)
    : TraceCallListCost(ProfileContext::context(ProfileContext::Call))
{
    _caller = caller;
    _called = called;
}


TraceCall::~TraceCall()
{
    // we are the owner of all items generated in our factories
    qDeleteAll(_deps);
    qDeleteAll(_lineCalls);
}

TracePartCall* TraceCall::partCall(TracePart* part,
                                   TracePartFunction* partCaller,
                                   TracePartFunction* partCalling)
{
    TracePartCall* item = (TracePartCall*) findDepFromPart(part);
    if (!item) {
        item = new TracePartCall(this);
        item->setPosition(part);
        addDep(item);
        partCaller->addPartCalling(item);
        partCalling->addPartCaller(item);
    }
    return item;
}

TraceInstrCall* TraceCall::instrCall(TraceInstr* i)
{
    foreach(TraceInstrCall* icall, _instrCalls)
        if (icall->instr() == i)
            return icall;

    TraceInstrCall* icall = new TraceInstrCall(this, i);
    _instrCalls.append(icall);
    invalidate();

#if TRACE_DEBUG
    qDebug("Created %s [TraceCall::instrCall]", qPrintable(icall->fullName()));
#endif
    i->addInstrCall(icall);
    return icall;
}


TraceLineCall* TraceCall::lineCall(TraceLine* l)
{
    foreach(TraceLineCall* lcall, _lineCalls)
        if (lcall->line() == l)
            return lcall;

    TraceLineCall* lcall = new TraceLineCall(this, l);
    _lineCalls.append(lcall);
    invalidate();

#if TRACE_DEBUG
    qDebug("Created %s [TraceCall::lineCall]", qPrintable(lcall->fullName()));
#endif
    l->addLineCall(lcall);
    return lcall;
}


void TraceCall::invalidateDynamicCost()
{
    foreach(TraceLineCall* lc, _lineCalls)
        lc->invalidate();

    foreach(TraceInstrCall* ic, _instrCalls)
        ic->invalidate();

    invalidate();
}


QString TraceCall::name() const
{
    return QStringLiteral("%1 => %2")
            .arg(_caller->name())
            .arg(_called->name());
}

int TraceCall::inCycle()
{
    if (!_caller || !_called) return 0;
    if (!_caller->cycle()) return 0;
    if (_caller == _caller->cycle()) return 0;
    if (_caller->cycle() != _called->cycle()) return 0;

    return _caller->cycle()->cycleNo();
}

void TraceCall::update()
{
    if (!_dirty) return;

    // special handling for cycles
    if (_caller && _caller->cycle() && _caller==_caller->cycle()) {

        // we have no part calls: use inclusive cost of called function
        clear();
        if (_called)
            addCost(_called->inclusive());
        _dirty = false;
        return;
    }

    TraceCallListCost::update();
}

TraceFunction* TraceCall::caller(bool /*skipCycle*/) const
{
    return _caller;
}

TraceFunction* TraceCall::called(bool skipCycle) const
{
    if (!skipCycle && _called) {
        // if this is a call to a cycle member from outside of the cycle,
        // fake it to be a call to the whole cycle
        if (_called->cycle() && _caller &&
            (_caller->cycle() != _called->cycle()))
            return _called->cycle();
    }

    return _called;
}

QString TraceCall::callerName(bool skipCycle) const
{
    if (!_caller) return QObject::tr("(no caller)");

    if (!skipCycle) {
        // if this call goes into a cycle, add the entry function
        TraceFunctionCycle* c = _called->cycle();
        if (c && _caller && (_caller->cycle() != c)) {
            QString via = _called->prettyName();
            return QObject::tr("%1 via %2").arg(_caller->prettyName()).arg(via);
        }
    }

    return _caller->prettyName();
}

QString TraceCall::calledName(bool skipCycle) const
{
    if (!_called) return QObject::tr("(no callee)");

    if (!skipCycle) {
        // if this call goes into a cycle, add the entry function
        TraceFunctionCycle* c = _called->cycle();
        if (c && _caller && (_caller->cycle() != c)) {
            // HACK to get rid of cycle postfix...
            _called->setCycle(nullptr);
            QString via = _called->prettyName();
            _called->setCycle(c);
            return QObject::tr("%1 via %2").arg(c->name()).arg(via);
        }
    }
    return _called->prettyName();
}


//---------------------------------------------------
// TraceInstr

TraceInstr::TraceInstr()
    : TraceListCost(ProfileContext::context(ProfileContext::Instr))
{
    _addr = 0;
    _line = nullptr;
    _function = nullptr;
}

TraceInstr::~TraceInstr()
{
    // we are the owner of items generated in our factories
    qDeleteAll(_deps);
    qDeleteAll(_instrJumps);
}

bool TraceInstr::hasCost(EventType* ct)
{
    if (subCost(ct) >0)
        return true;

    foreach(TraceInstrCall* ic, _instrCalls)
        if (ic->subCost(ct) >0)
            return true;

    foreach(TraceInstrJump* ij, _instrJumps)
        if (ij->executedCount() >0)
            return true;

    return false;
}

TracePartInstr* TraceInstr::partInstr(TracePart* part,
                                      TracePartFunction* partFunction)
{
    TracePartInstr* item = (TracePartInstr*) findDepFromPart(part);
    if (!item) {
        item = new TracePartInstr(this);
        item->setPosition(part);
        addDep(item);
        //part->addDep(item);
        partFunction->addPartInstr(item);
    }
    return item;
}

TraceInstrJump* TraceInstr::instrJump(TraceInstr* to, bool isJmpCond)
{
    foreach(TraceInstrJump* jump, _instrJumps)
        if (jump->instrTo() == to)
            return jump;

    TraceInstrJump* jump = new TraceInstrJump(this, to, isJmpCond);
    _instrJumps.append(jump);
    return jump;
}



void TraceInstr::addInstrCall(TraceInstrCall* instrCall)
{
#if TRACE_ASSERTIONS
    if (_instrCalls.contains(instrCall)) return;

    if (instrCall->instr() != this) {
        qDebug("Can not add instruction call to another instruction!");
        return;
    }
#endif

    _instrCalls.append(instrCall);
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ),
           qPrintable(instrCall->fullName()), _instrCalls.count());
#endif
}


QString TraceInstr::name() const
{
    return QStringLiteral("0x%1").arg(_addr.toString());
}

QString TraceInstr::prettyName() const
{
    return QStringLiteral("0x%1").arg(_addr.toString());
}


//---------------------------------------------------
// TraceLine

TraceLine::TraceLine()
    : TraceListCost(ProfileContext::context(ProfileContext::Line))
{
    _lineno = 0;
    _sourceFile = nullptr;
}

TraceLine::~TraceLine()
{
    // we are the owner of items generated in our factories
    qDeleteAll(_deps);
    qDeleteAll(_lineJumps);
}

bool TraceLine::hasCost(EventType* ct)
{
    if (subCost(ct) >0)
        return true;

    foreach(TraceLineCall* lc, _lineCalls)
        if (lc->subCost(ct) >0)
            return true;

    foreach(TraceLineJump* lj, _lineJumps)
        if (lj->executedCount() >0)
            return true;

    return false;
}

TracePartLine* TraceLine::partLine(TracePart* part,
                                   TracePartFunction* partFunction)
{
    TracePartLine* item = (TracePartLine*) findDepFromPart(part);
    if (!item) {
        item = new TracePartLine(this);
        item->setPosition(part);
        addDep(item);
#if !USE_FIXCOST
        part->addDep(item);
#endif
        partFunction->addPartLine(item);
    }
    return item;
}

TraceLineJump* TraceLine::lineJump(TraceLine* to, bool isJmpCond)
{
    foreach(TraceLineJump* jump, _lineJumps)
        if (jump->lineTo() == to)
            return jump;

    TraceLineJump* jump = new TraceLineJump(this, to, isJmpCond);
    _lineJumps.append(jump);
    return jump;
}


void TraceLine::addLineCall(TraceLineCall* lineCall)
{
#if TRACE_ASSERTIONS
    if (_lineCalls.contains(lineCall)) return;

    if (lineCall->line() != this) {
        qDebug("Can not add line call to another line!");
        return;
    }
#endif

    TraceFunction* caller = lineCall->call()->caller();
    TraceFunction* function = _sourceFile->function();
    if (caller != function) {
        // We regard 2 functions as the same if they have
        // same class, name, object
        if ((caller->cls() != function->cls()) ||
            (caller->name() != function->name()) ||
            (caller->object() != function->object())) {

            qDebug("ERROR: Adding line call, line %d\n  of %s to\n  %s ?!",
                   lineCall->line()->lineno(),
                   qPrintable(caller->info()), qPrintable(function->info()));
        }
    }

    _lineCalls.append(lineCall);
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ),
           qPrintable(lineCall->fullName()), _lineCalls.count());
#endif
}


QString TraceLine::name() const
{
    QString fileShortName = _sourceFile->file()->shortName();
    if (fileShortName.isEmpty())
        return TraceFile::prettyEmptyName();

    return QStringLiteral("%1:%2")
            .arg(fileShortName).arg(_lineno);
}

QString TraceLine::prettyName() const
{
    return QStringLiteral("%1 [%2]")
            .arg(name()).arg(_sourceFile->function()->prettyName());
}

//---------------------------------------------------
// TraceCostItem

TraceCostItem::TraceCostItem(ProfileContext* context)
    : TraceInclusiveListCost(context)
{
}

TraceCostItem::~TraceCostItem()
{}


//---------------------------------------------------
// TraceFunctionSource

TraceFunctionSource::TraceFunctionSource(TraceFunction* function,
                                         TraceFile* file)
    : ProfileCostArray(ProfileContext::context(ProfileContext::FunctionSource))
{
    _file = file;
    _function = function;

    // the function is dependent from our cost sum
    _dep = _function;

    _lineMap = nullptr;
    _lineMapFilled = false;
    _line0 = nullptr;
}

TraceFunctionSource::~TraceFunctionSource()
{
    delete _lineMap;
    delete _line0;
}

QString TraceFunctionSource::name() const
{
    return QStringLiteral("%1 for %2").arg(_file->name()).arg(_function->name());
}

uint TraceFunctionSource::firstLineno()
{
    // lazy generate the map if not done up to now
    TraceLineMap* map = lineMap();
    // ignore line 0 here
    if (!map || map->count() == 0) return 0;
    TraceLineMap::Iterator it = map->begin();
    return (*it).lineno();
}

uint TraceFunctionSource::lastLineno()
{
    // lazy generate the map if not done up to now
    TraceLineMap* map = lineMap();
    // ignore line 0 here
    if (!map || map->count() == 0) return 0;
    TraceLineMap::Iterator it = map->end();
    --it;
    return (*it).lineno();
}

/* factory */
TraceLine* TraceFunctionSource::line(uint lineno, bool createNew)
{
    if (lineno == 0) {
        if (!_line0) {
            if (!createNew) return nullptr;
            _line0 = new TraceLine;
            _line0->setSourceFile(this);
            _line0->setLineno(0);
        }
        return _line0;
    }

    if (!createNew) {
        if (!_lineMap) return nullptr;
        TraceLineMap::Iterator it = _lineMap->find(lineno);
        if (it == _lineMap->end()) return nullptr;
        return &(it.value());
    }

    if (!_lineMap) _lineMap = new TraceLineMap;

    TraceLine& l = (*_lineMap)[lineno];
    if (!l.isValid()) {
        l.setSourceFile(this);
        l.setLineno(lineno);

#if TRACE_DEBUG
        qDebug("Created %s [TraceFunctionSource::line]",
               qPrintable(l.fullName()));
#endif
    }
    return &l;
}

void TraceFunctionSource::update()
{
    if (!_dirty) return;

    clear();

    // no need to create lineMap if not already created
    if (_lineMap) {
        TraceLineMap::Iterator lit;
        for ( lit = _lineMap->begin();
              lit != _lineMap->end(); ++lit )
            addCost( &(*lit) );
    }

    _dirty = false;
}

void TraceFunctionSource::invalidateDynamicCost()
{
    // no need to create lineMap if not already created
    if (_lineMap) {
        TraceLineMap::Iterator lit;
        for ( lit = _lineMap->begin();
              lit != _lineMap->end(); ++lit )
            (*lit).invalidate();
    }

    invalidate();
}

TraceLineMap* TraceFunctionSource::lineMap()
{
#if USE_FIXCOST

    if (_lineMapFilled) return _lineMap;
    _lineMapFilled = true;
    if (!_lineMap)
        _lineMap = new TraceLineMap;

    TraceLine* l = nullptr;
    TracePartLine* pl = nullptr;
    TraceLineCall* lc = nullptr;
    TracePartLineCall* plc = nullptr;

    /* go over all part objects for this function, and
     * - build TraceLines (the line map) using FixCost objects
     * - build TraceJumpLines using FixJump objects
     */
    foreach(TraceInclusiveCost* ic, _function->deps()) {
        TracePartFunction* pf = (TracePartFunction*) ic;

        if (0) qDebug("PartFunction %s:%d",
                      qPrintable(pf->function()->name()),
                      pf->part()->partNumber());

        FixCost* fc = pf->firstFixCost();
        for(; fc; fc = fc->nextCostOfPartFunction()) {
            if (fc->line() == 0) continue;
            if (fc->functionSource() != this) continue;

            if (!l || l->lineno() != fc->line()) {
                l = &(*_lineMap)[fc->line()];
                if (!l->isValid()) {
                    l->setSourceFile(this);
                    l->setLineno(fc->line());
                }
                pl = nullptr;
            }
            if (!pl || pl->part() != fc->part())
                pl = l->partLine(fc->part(), pf);
            fc->addTo(pl);
        }

        TraceLine* to = nullptr;
        TraceLineJump* lj;
        TracePartLineJump* plj;
        FixJump* fj = pf->firstFixJump();
        for(; fj; fj = fj->nextJumpOfPartFunction()) {
            if (fj->line() == 0) continue;
            if (fj->source() != this) continue;
            if (!fj->targetSource()) {
                // be robust against buggy loaders
                continue;
            }

            // do not display jumps to same or following line
            if ((fj->line() == fj->targetLine()) ||
                (fj->line()+1 == fj->targetLine())) continue;

            if (!l || l->lineno() != fj->line()) {
                l = &(*_lineMap)[fj->line()];
                if (!l->isValid()) {
                    l->setSourceFile(this);
                    l->setLineno(fj->line());
                }
            }

            to = fj->targetSource()->line(fj->targetLine(), true);

            lj = l->lineJump(to, fj->isCondJump());
            plj = lj->partLineJump(fj->part());

            fj->addTo(plj);
        }

        foreach(TracePartCall* pc, pf->partCallings()) {

            if (0) qDebug("PartCall %s:%d",
                          qPrintable(pc->call()->name()),
                          pf->part()->partNumber());

            FixCallCost* fcc = pc->firstFixCallCost();
            for(; fcc; fcc = fcc->nextCostOfPartCall()) {
                if (fcc->line() == 0) continue;
                if (fcc->functionSource() != this) continue;

                if (!l || l->lineno() != fcc->line()) {
                    l = &(*_lineMap)[fcc->line()];
                    if (!l->isValid()) {
                        l->setSourceFile(this);
                        l->setLineno(fcc->line());
                    }
                }
                if (!lc || lc->call() != pc->call() || lc->line() != l) {
                    lc = pc->call()->lineCall(l);
                    plc = nullptr;
                }
                if (!plc || plc->part() != fcc->part())
                    plc = lc->partLineCall(fcc->part(), pc);

                fcc->addTo(plc);
                if (0) qDebug("Add FixCallCost %s:%d/0x%s, CallCount %s",
                              qPrintable(fcc->functionSource()->file()->shortName()),
                              fcc->line(), qPrintable(fcc->addr().toString()),
                              qPrintable(fcc->callCount().pretty()));
            }
        }
    }

#endif

    return _lineMap;
}



//---------------------------------------------------
// TraceAssociation

TraceAssociation::TraceAssociation()
{
    _function = nullptr;
    _valid = false;
}

TraceAssociation::~TraceAssociation()
{
    // do not delete from TraceFunction
    if (_function) _function->removeAssociation(this);
}

bool TraceAssociation::isAssociated()
{
    if (!_function) return false;

    return _function->association(rtti())==this;
}

bool TraceAssociation::setFunction(TraceFunction* f)
{
    if (_function == f)
        return isAssociated();

    if (_function) {
        // do not delete ourself
        _function->removeAssociation(this);
    }

    _function = f;
    if (f && f->association(rtti()) == nullptr) {
        f->addAssociation(this);
        return true;
    }
    return false;
}

void TraceAssociation::clear(TraceData* d, int rtti)
{
    TraceFunctionMap::Iterator it;
    for ( it = d->functionMap().begin();
          it != d->functionMap().end(); ++it )
        (*it).removeAssociation(rtti);
}

void TraceAssociation::invalidate(TraceData* d, int rtti)
{
    TraceFunctionMap::Iterator it;
    for ( it = d->functionMap().begin();
          it != d->functionMap().end(); ++it )
        (*it).invalidateAssociation(rtti);
}


//---------------------------------------------------
// TraceFunction

TraceFunction::TraceFunction()
    : TraceCostItem(ProfileContext::context(ProfileContext::Function))
{
    _object = nullptr;
    _file = nullptr;
    _cls = nullptr;
    _cycle = nullptr;

    _calledCount     = 0;
    _callingCount    = 0;
    _calledContexts  = 0;
    _callingContexts = 0;

    _instrMap = nullptr;
    _instrMapFilled = false;
}


TraceFunction::~TraceFunction()
{
    qDeleteAll(_associations);

    // we are the owner of items generated in our factories
    qDeleteAll(_deps);
    qDeleteAll(_callings);
    qDeleteAll(_sourceFiles);
    qDeleteAll(_basicBlocks);

    delete _instrMap;
}

// no unique check is done!
void TraceFunction::addAssociation(TraceAssociation* a)
{
    if (!a) return;
    _associations.append(a);
}

void TraceFunction::removeAssociation(TraceAssociation* a)
{
    _associations.removeAll(a);
}

void TraceFunction::removeAssociation(int rtti, bool reallyDelete)
{
    if (rtti==0) {
        if (reallyDelete)
            qDeleteAll(_associations);
        _associations.clear();
        return;
    }

    foreach(TraceAssociation* a, _associations) {
        if (a->rtti() == rtti) {
            if (reallyDelete) delete a;
            _associations.removeAll(a);
            return;
        }
    }
}

void TraceFunction::invalidateAssociation(int rtti)
{
    foreach(TraceAssociation* a, _associations) {
        if ((rtti==0) || (a->rtti() == rtti))
            a->invalidate();
    }
}

TraceAssociation* TraceFunction::association(int rtti)
{
    foreach(TraceAssociation* a, _associations) {
        if (a->rtti() == rtti)
            return a;
    }
    return nullptr;
}

#if 0
// helper for prettyName
bool TraceFunction::isUniquePrefix(const QString& prefix) const
{
    TraceFunctionMap::ConstIterator it, it2;
    it = it2 = _myMapIterator;
    if (it != data()->functionBeginIterator()) {
        it2--;
        if ((*it2).name().startsWith(prefix)) return false;
    }
    if (it != data()->functionEndIterator()) {
        it++;
        if ((*it).name().startsWith(prefix)) return false;
    }
    return true;
}
#endif

QString TraceFunction::prettyName() const
{
    QString res = _name;

    if (_name.isEmpty())
        return prettyEmptyName();

    if (GlobalConfig::hideTemplates()) {

        res = QString();
        int d = 0;
        for(int i=0;i<_name.length();i++) {
            switch(_name[i].toLatin1()) {
            case '<':
                if (d<=0) res.append(_name[i]);
                d++;
                break;
            case '>':
                d--;
                // fall through
            default:
                if (d<=0) res.append(_name[i]);
                break;
            }
        }
    }
#if 0
    // TODO: make it a configuration, but disabled by default.
    //
    // Stripping parameter signature of C++ symbols is fine
    // if the function name is unique in the whole program.
    // However, we only can detect if it is unique in the profile,
    // which makes this "beautification" potentially confusing
    int p = _name.indexOf('(');
    if (p>0) {
        // handle C++ "operator()" correct
        if ( (p+2 < _name.size()) && (_name[p+1] == ')') && (_name[p+2] == '(')) p+=2;

        // we have a C++ symbol with argument types:
        // check for unique function name (inclusive '(' !)
        if (isUniquePrefix(_name.left(p+1)))
            res = _name.left(p);
    }
#endif

    // cycle members
    if (_cycle) {
        if (_cycle != this)
            res = QStringLiteral("%1 <cycle %2>").arg(res).arg(_cycle->cycleNo());
        else
            res = QStringLiteral("<cycle %2>").arg(_cycle->cycleNo());
    }


    return res;
}

QString TraceFunction::formattedName() const
{
    // produce a "rich" name only if templates are hidden
    if (!GlobalConfig::hideTemplates() || _name.isEmpty()) return QString();

    // bold, but inside template parameters normal, function arguments italic
    QString rich(QStringLiteral("<b>"));
    int d = 0;
    for(int i=0;i<_name.length();i++) {
        switch(_name[i].toLatin1()) {
        case '&':
            rich.append("&amp;");
            break;
        case '<':
            d++;
            rich.append("&lt;");
            if (d==1)
                rich.append("</b>");
            break;
        case '>':
            d--;
            if (d==0)
                rich.append("<b>");
            rich.append("&gt; "); // add space to allow for line break
            break;
        case '(':
            rich.append("</b>(<i><b>");
            break;
        case ')':
            rich.append("</b></i>)<b>");
            break;
        default:
            rich.append(_name[i]);
            break;
        }
    }
    rich.append("</b>");
    return rich;
}

QString TraceFunction::prettyEmptyName()
{
    return QObject::tr("(unknown)");
}

/*
 * Returns location string: ELF object and source file(s).
 */
QString TraceFunction::location(int maxFiles) const
{
    QString loc;

    // add object file with address range
    if (_object) {
        loc = _object->shortName();

#if 0
        uint from = firstAddress();
        uint to = lastAddress();
        if (from != 0 && to != 0) {
            if (from == to)
                loc += QString(" (0x%1)").arg(to, 0, 16);
            else
                loc += QString(" (0x%1-0x%2)").arg(from, 0, 16).arg(to, 0, 16);
        }
#endif
    }

    // add all source files
    int filesAdded = 0;
    foreach(TraceFunctionSource* sourceFile, _sourceFiles) {
        if (!sourceFile->file() ||
            (sourceFile->file()->name().isEmpty()) )
            continue;

        if (!loc.isEmpty())
            loc += (filesAdded>0) ? ", " : ": ";
        filesAdded++;

        if ((maxFiles>0) && (filesAdded>maxFiles)) {
            loc += QLatin1String("...");
            break;
        }
        loc += sourceFile->file()->shortName();

#if 0
        from = sourceFile->firstLineno();
        to = sourceFile->lastLineno();
        if (from != 0 && to != 0) {
            if (from == to)
                loc += QString(" (%1)").arg(to);
            else
                loc += QString(" (%1-%2)").arg(from).arg(to);
        }
#endif
    }

    return loc;
}

// pretty version is allowed to mangle the string...
QString TraceFunction::prettyLocation(int maxFiles) const
{
    QString l = location(maxFiles);
    if (l.isEmpty()) return QObject::tr("(unknown)");

    return l;
}

void TraceFunction::addPrettyLocation(QString& s, int maxFiles) const
{
    QString l = location(maxFiles);
    if (l.isEmpty()) return;

    s += QStringLiteral(" (%1)").arg(l);
}

QString TraceFunction::prettyNameWithLocation(int maxFiles) const
{
    QString l = location(maxFiles);
    if (l.isEmpty()) return prettyName();

    return QStringLiteral("%1 (%2)").arg(prettyName()).arg(l);
}

QString TraceFunction::info() const
{
    QString l = location();
    if (l.isEmpty())
        return QStringLiteral("Function %1").arg(name());

    return QStringLiteral("Function %1 (location %2)")
            .arg(name()).arg(l);
}


Addr TraceFunction::firstAddress() const
{
    // ignore address 0 here
    if (!_instrMap || _instrMap->count() == 0) return 0;
    TraceInstrMap::ConstIterator it = _instrMap->constBegin();
    return (*it).addr();
}

Addr TraceFunction::lastAddress() const
{
    // ignore address 0 here
    if (!_instrMap || _instrMap->count() == 0) return 0;
    TraceInstrMap::ConstIterator it = _instrMap->constEnd();
    --it;
    return (*it).addr();
}

/* factory */
TraceInstr* TraceFunction::instr(Addr addr, bool createNew)
{
    // address 0 not allowed
    if (addr == Addr(0)) return nullptr;

    if (!createNew) {
        if (!_instrMap) return nullptr;
        TraceInstrMap::Iterator it = _instrMap->find(addr);
        if (it == _instrMap->end())
            return nullptr;
        return &(it.value());
    }

    if (!_instrMap) _instrMap = new TraceInstrMap;

    TraceInstr& i = (*_instrMap)[addr];
    if (!i.isValid()) {
        i.setAddr(addr);
        i.setFunction(this);

#if TRACE_DEBUG
        qDebug("Created %s [TraceFunction::instr]",
               qPrintable(i.fullName()));
#endif
    }
    return &i;
}

void TraceFunction::addCaller(TraceCall* caller)
{
#if TRACE_ASSERTIONS
    if (caller->called() != this) {
        qDebug("Can not add call to another line!\n");
        return;
    }

    if (_callers.contains(caller)) return;
#endif

    _callers.append(caller);
    invalidate();

#if TRACE_DEBUG
    qDebug("%s added Caller\n %s (now %d)",
           qPrintable( fullName() ), qPrintable(caller->fullName()), _callers.count());
#endif
}



TraceCall* TraceFunction::calling(TraceFunction* called)
{
    foreach(TraceCall* calling, _callings)
        if (calling->called() == called)
            return calling;

    TraceCall* calling = new TraceCall(this, called);
    _callings.append(calling);

    // we have to invalidate ourself so invalidations from item propagate up
    invalidate();

#if TRACE_DEBUG
    qDebug("Created %s [TraceFunction::calling]", qPrintable(calling->fullName()));
#endif
    called->addCaller(calling);
    return calling;
}

TraceFunctionSource* TraceFunction::sourceFile(TraceFile* file,
                                               bool createNew)
{
    if (!file) file = _file;

    foreach(TraceFunctionSource* sourceFile, _sourceFiles)
        if (sourceFile->file() == file)
            return sourceFile;

    if (!createNew) return nullptr;

    TraceFunctionSource* sourceFile = new TraceFunctionSource(this, file);
    _sourceFiles.append(sourceFile);

    // we have to invalidate ourself so invalidations from item propagate up
    invalidate();

#if TRACE_DEBUG
    qDebug("Created SourceFile %s [TraceFunction::line]",
           qPrintable(file->name()));
#endif
    file->addSourceFile(sourceFile);
    return sourceFile;
}

TraceLine* TraceFunction::line(TraceFile* file, uint lineno,
                               bool createNew)
{
    Q_ASSERT(file!=nullptr);

    TraceFunctionSource* sf = sourceFile(file, createNew);
    if (!sf)
        return nullptr;
    else
        return sf->line(lineno, createNew);
}


TracePartFunction* TraceFunction::partFunction(TracePart* part,
                                               TracePartFile* partFile,
                                               TracePartObject* partObject)
{
    TracePartFunction* item = (TracePartFunction*) findDepFromPart(part);
    if (!item) {
        item = new TracePartFunction(this, partObject, partFile);
        item->setPosition(part);
        addDep(item);
#if USE_FIXCOST
        part->addDep(item);
#endif

        if (_cls) {
            TracePartClass* partClass = _cls->partClass(part);
            partClass->addPartFunction(item);
            item->setPartClass(partClass);
        }

        partFile->addPartFunction(item);
        if (partObject)
            partObject->addPartFunction(item);
    }
    else if (item->partObject()==nullptr && partObject) {
        item->setPartObject(partObject);
        partObject->addPartFunction(item);
    }

    return item;
}


SubCost TraceFunction::calledCount()
{
    if (_dirty) update();

    return _calledCount;
}

int TraceFunction::calledContexts()
{
    if (_dirty) update();

    return _calledContexts;
}

SubCost TraceFunction::callingCount()
{
    if (_dirty) update();

    return _callingCount;
}

int TraceFunction::callingContexts()
{
    if (_dirty) update();

    return _callingContexts;
}

QString TraceFunction::prettyCalledCount()
{
    return _calledCount.pretty();
}

QString TraceFunction::prettyCallingCount()
{
    return _callingCount.pretty();
}


TraceCallList TraceFunction::callers(bool skipCycle) const
{
    if (skipCycle) return _callers;

    // fake the callers for cycle members
    if (_cycle && (_cycle != this)) {
        TraceCallList l;

        // inner-cycle-callers
        foreach(TraceCall* c, _callers)
            if (c->caller()->cycle() == _cycle)
                l.append(c);

        // call from cycle itself
        foreach(TraceCall* c, _cycle->_callings)
            if (c->called() == this) {
                l.append(c);
                return l;
            }
    }

    return _callers;
}

const TraceCallList& TraceFunction::callings(bool /* skipCycle */) const
{
    return _callings;
}

void TraceFunction::invalidateDynamicCost()
{
    foreach(TraceCall* c, _callings)
        c->invalidateDynamicCost();

    foreach(TraceFunctionSource* sf, _sourceFiles)
        sf->invalidateDynamicCost();

    if (_instrMap) {
        TraceInstrMap::Iterator iit;
        for ( iit = _instrMap->begin();
              iit != _instrMap->end(); ++iit )
            (*iit).invalidate();
    }

    invalidate();
}

void TraceFunction::update()
{
    if (!_dirty) return;

#if TRACE_DEBUG
    qDebug("Update %s (Callers %d, sourceFiles %d, instrs %d)",
           qPrintable(_name), _callers.count(),
           _sourceFiles.count(), _instrMap ? _instrMap->count():0);
#endif

    _calledCount    = 0;
    _callingCount    = 0;
    _calledContexts  = 0;
    _callingContexts = 0;
    clear();

    // To calculate context counts, we just use first real event type (FIXME?)
    EventType* e = data() ? data()->eventTypes()->realType(0) : nullptr;

    // context count is NOT the sum of part contexts
    foreach(TraceCall *caller, _callers) {
        if (e && (caller->subCost(e) >0))
            _calledContexts++;
        _calledCount += caller->callCount();
    }

    foreach(TraceCall* callee, _callings) {
        if (e && (callee->subCost(e) >0))
            _callingContexts++;
        _callingCount += callee->callCount();
    }

    if (data()->inFunctionCycleUpdate() || !_cycle) {
        // usual case (no cycle member)
        foreach(TraceInclusiveCost* item, _deps) {
            if (!item->part() || !item->part()->isActive()) continue;

            addCost(item);
            addInclusive(item->inclusive());
        }
    }
    else {
        // this is a cycle or cycle member
        foreach(TraceCall* callee, _callings) {

            // ignore inner-cycle member calls for inclusive cost
            if ((_cycle != this) &&
                (callee->inCycle()>0))  continue;

            addInclusive(callee);
        }

        // self cost
        if (type() == ProfileContext::FunctionCycle) {
            // cycle: self cost is sum of cycle member self costs, but
            //        does not add to inclusive cost
            foreach(TraceFunction* m, ((TraceFunctionCycle*)this)->members())
                addCost(m);
        }
        else {
            // cycle member
            foreach(TraceInclusiveCost* item, _deps) {
                if (!item->part() || !item->part()->isActive()) continue;

                addCost(item);
            }
            _dirty = false; // do not recurse
            addInclusive(this);
        }
    }
    _dirty = false;

#if TRACE_DEBUG
    qDebug("> %s", qPrintable(costString(0)));
#endif
}

bool TraceFunction::isCycle()
{
    return _cycle == this;
}

bool TraceFunction::isCycleMember()
{
    return _cycle && (_cycle != this);
}

void TraceFunction::cycleReset()
{
    _cycle = nullptr;
    _cycleStackDown = nullptr;
    _cycleLow = 0;
}

// this does not mark functions calling themself !
void TraceFunction::cycleDFS(int d, int& pNo, TraceFunction** pTop)
{
    if (_cycleLow != 0) return;

    // initialize with prefix order
    pNo++;
    int prefixNo = pNo;
    _cycleLow = prefixNo;

    // put myself on stack
    _cycleStackDown = *pTop;
    *pTop = this;

    /* cycle cut heuristic:
     * skip calls for cycle detection if they make less than _cycleCut
     * percent of the cost of the function.
     * FIXME: Which cost type to use for this heuristic ?!
     */
    Q_ASSERT((data() != nullptr) && (data()->eventTypes()->realCount()>0));
    EventType* e = data()->eventTypes()->realType(0);

    SubCost base = 0;
    if (_callers.count()>0) {
        foreach(TraceCall* caller, _callers)
            if (caller->subCost(e) > base)
                base = caller->subCost(e);
    }
    else base = inclusive()->subCost(e);

    SubCost cutLimit = SubCost(base * GlobalConfig::cycleCut());

    if (0) {
        qDebug("%s (%d) Visiting %s",
               qPrintable(QString().fill(' ', d)),
               pNo, qPrintable(prettyName()));
        qDebug("%s       Cum. %s, Max Caller %s, cut limit %s",
               qPrintable(QString().fill(' ', d)),
               qPrintable(inclusive()->subCost(e).pretty()),
               qPrintable(base.pretty()),
               qPrintable(cutLimit.pretty()));
    }

    foreach(TraceCall *callee, _callings) {
        TraceFunction* called = callee->called();

        // cycle cut heuristic
        if (callee->subCost(e) < cutLimit) {
            if (0) qDebug("%s       Cut call to %s (cum. %s)",
                          qPrintable(QString().fill(' ', d)),
                          qPrintable(called->prettyName()),
                          qPrintable(callee->subCost(e).pretty()));

            continue;
        }

        if (called->_cycleLow==0) {
            // not visited yet
            called->cycleDFS(d+1, pNo, pTop);
            if (called->_cycleLow < _cycleLow)
                _cycleLow = called->_cycleLow;
        }
        else if (called->_cycleStackDown) {
            // backlink to same SCC (still in stack)
            if (called->_cycleLow < _cycleLow)
                _cycleLow = called->_cycleLow;

            if (0) qDebug("%s (low %d) Back to %s",
                          qPrintable(QString().fill(' ', d)),
                          _cycleLow, qPrintable(called->prettyName()));
        }
    }

    if (prefixNo == _cycleLow) {
        // this is the base of a SCC.

        if (*pTop == this) {
            *pTop = _cycleStackDown;
            _cycleStackDown = nullptr;
        }
        else {
            // a SCC with >1 members

            TraceFunctionCycle* cycle = data()->functionCycle(this);
            if (0) qDebug("Found Cycle %d with base %s:",
                          cycle->cycleNo(), qPrintable(prettyName()));
            while(*pTop) {
                TraceFunction* top = *pTop;
                cycle->add(top);

                // remove from stack
                *pTop = top->_cycleStackDown;
                top->_cycleStackDown = nullptr;

                if (0) qDebug("  %s", qPrintable(top->prettyName()));
                if (top == this) break;
            }
        }
    }
}


TraceInstrMap* TraceFunction::instrMap()
{
#if USE_FIXCOST

    if (_instrMapFilled) return _instrMap;
    _instrMapFilled = true;
    if (!_instrMap)
        _instrMap = new TraceInstrMap;

    TraceLine* l = nullptr;
    TraceInstr* i = nullptr;
    TracePartInstr* pi = nullptr;
    TraceInstrCall* ic = nullptr;
    TracePartInstrCall* pic = nullptr;

    foreach(TraceInclusiveCost* icost, deps()) {
        TracePartFunction* pf = (TracePartFunction*) icost;

        if (0) qDebug("PartFunction %s:%d",
                      qPrintable(pf->function()->name()),
                      pf->part()->partNumber());

        FixCost* fc = pf->firstFixCost();
        for(; fc; fc = fc->nextCostOfPartFunction()) {
            if (fc->addr() == 0) continue;

            if (!l || (l->lineno() != fc->line()) ||
                (l->functionSource() != fc->functionSource()))
                l = fc->functionSource()->line(fc->line(),true);

            if (!i || i->addr() != fc->addr()) {
                i = &(*_instrMap)[fc->addr()];
                if (!i->isValid()) {
                    i->setFunction(this);
                    i->setAddr(fc->addr());
                    i->setLine(l);
                }
                pi = nullptr;
            }
            if (!pi || pi->part() != fc->part())
                pi = i->partInstr(fc->part(), pf);
            fc->addTo(pi);
        }

        TraceInstr* to = nullptr;
        TraceInstrJump* ij;
        TracePartInstrJump* pij;
        FixJump* fj = pf->firstFixJump();
        for(; fj; fj = fj->nextJumpOfPartFunction()) {
            if (fj->addr() == 0) continue;

            if (!l || (l->lineno() != fj->line()) ||
                (l->functionSource() != fj->source()))
                l = fj->source()->line(fj->line(),true);

            if (!i || i->addr() != fj->addr()) {
                i = &(*_instrMap)[fj->addr()];
                if (!i->isValid()) {
                    i->setFunction(this);
                    i->setAddr(fj->addr());
                    i->setLine(l);
                }
            }

            to = fj->targetFunction()->instr(fj->targetAddr(), true);

            ij = i->instrJump(to, fj->isCondJump());
            pij = ij->partInstrJump(fj->part());

            fj->addTo(pij);
        }

        foreach(TracePartCall* pc, pf->partCallings()) {

            if (0) qDebug("PartCall %s:%d",
                          qPrintable(pc->call()->name()),
                          pf->part()->partNumber());

            FixCallCost* fcc = pc->firstFixCallCost();
            for(; fcc; fcc = fcc->nextCostOfPartCall()) {
                if (fcc->addr() == 0) continue;

                if (!l || (l->lineno() != fcc->line()) ||
                    (l->functionSource() != fcc->functionSource()))
                    l = fcc->functionSource()->line(fcc->line(),true);

                if (!i || i->addr() != fcc->addr()) {
                    i = &(*_instrMap)[fcc->addr()];
                    if (!i->isValid()) {
                        i->setFunction(this);
                        i->setAddr(fcc->addr());
                        i->setLine(l);
                    }
                }
                if (!ic || ic->call() != pc->call() || ic->instr() != i) {
                    ic = pc->call()->instrCall(i);
                    pic = nullptr;
                }
                if (!pic || pic->part() != fcc->part())
                    pic = ic->partInstrCall(fcc->part(), pc);

                fcc->addTo(pic);
                if (0) qDebug("Add FixCallCost %s:%d/0x%s, CallCount %s",
                              qPrintable(fcc->functionSource()->file()->shortName()),
                              fcc->line(), qPrintable(fcc->addr().toString()),
                              qPrintable(fcc->callCount().pretty()));
            }
        }
    }

#endif

    return _instrMap;
}

std::vector<TraceBasicBlock*>& TraceFunction::basicBlocks()
{
    if (_basicBlocks.empty())
        constructBasicBlocks();

    return _basicBlocks;
}

void TraceFunction::constructBasicBlocks()
{
    auto instructions = instrMap();
    if (!instructions || instructions->empty())
        return;

    divideInstructionsIntoBasicBlocks(instructions);
    handleInvalidBranches();
}

namespace
{

QSet<TraceInstr*> collectJumpDestinations(TraceInstrMap::iterator it,
                                          TraceInstrMap::iterator ite)
{
    QSet<TraceInstr*> jumpDestinations;

    // 1. collecting all instructions that are destination points for jumps
    for (; it != ite; ++it)
    {
        auto& jumps = it->instrJumps();

        if (jumps.empty())
        {
            if (!it->instrCalls().empty() && it != std::prev(ite))
                jumpDestinations.insert(std::addressof(*std::next(it)));
        }
        else if (jumps.size() == 1)
        {
            TraceInstrJump* jmp = jumps.front();
            jumpDestinations.insert(jmp->instrTo());

            if (jmp->isCondJump() && it != std::prev(ite))
                jumpDestinations.insert(std::addressof(*std::next(it)));
        }
        else
        {
            for (auto jmp : jumps)
                jumpDestinations.insert(jmp->instrTo());
        }
    }

    return jumpDestinations;
}

} // unnamed namespace

void TraceFunction::divideInstructionsIntoBasicBlocks(TraceInstrMap *instructions)
{
    QSet<TraceInstr*> jumpDestinations
        = collectJumpDestinations(instructions->begin(), instructions->end());

    for (auto from = instructions->begin(), ite = instructions->end(); from != ite; )
    {
        auto to = ite;

        for (auto it = std::next(from); it != ite; ++it)
        {
            if (jumpDestinations.contains(std::addressof(*it)))
            {
                to = it;
                break;
            }
            else if (!it->instrJumps().empty() || !it->instrCalls().empty() ||
                     std::next(it)->addr() > it->addr() + 3 * GlobalConfig::context())
            {
                to = std::next(it);
                break;
            }
        }

        assert(from != to);
        _basicBlocks.push_back(new TraceBasicBlock{from, to});
        from = to;
    }

    for (auto bb : _basicBlocks)
    {
        for (auto& br : bb->outgoingBranches())
        {
            TraceBasicBlock* bbTo = br.bbTo();
            if (bbTo)
                bbTo->addIncomingBranch(br);
        }
    }
}

void TraceFunction::handleInvalidBranches()
{
    /*
     * There are 2 types of invalid branches:
     *   Type 1: fallthrough branches which cost was measured incorrectly
     *   Type 2: branches from ret (truly invalid)
     */

    auto adder = [](uint64 val, TraceBranch* br){ return val + br->executedCount().v; };
    auto refAdder = [](uint64 val, TraceBranch& br){ return val + br.executedCount().v; };
    auto isInvalid = [](TraceBranch* br) { return br->brType() == TraceBranch::Type::invalid; };

    // turning invalid branches of type 1 into fallthrough branches
    for (auto bb : _basicBlocks)
    {
        auto& incoming = bb->incomingBranches();

        // can't be more than 1 invalid incoming branch
        auto invBrIt = std::find_if(incoming.begin(), incoming.end(), isInvalid);
        if (invBrIt != incoming.end())
        {
            auto incomingCount
                = std::accumulate(incoming.begin(), incoming.end(), uint64{0}, adder);

            auto& outgoing = bb->outgoingBranches();
            uint64 outgoingCount;
            if (outgoing.empty())
            {
                TraceData* data = this->data();
                assert(data);
                EventType* e = data->eventTypes()->realType(0);
                assert(e);
                outgoingCount = bb->lastInstr()->subCost(e);
            }
            else
                outgoingCount
                    = std::accumulate(outgoing.begin(), outgoing.end(), uint64{0}, refAdder);

            if (incomingCount == outgoingCount)
                (*invBrIt)->setType(TraceBranch::Type::fallThrough);
        }
    }

    // removing invalid branches of type 2
    auto isInvalidRef = [](TraceBranch& br){ return br.brType() == TraceBranch::Type::invalid; };

    for (auto bb : _basicBlocks)
    {
        auto& incoming = bb->incomingBranches();
        incoming.erase(std::remove_if(incoming.begin(), incoming.end(), isInvalid),
                       incoming.end());
    }

    for (auto bb : _basicBlocks)
    {
        auto& outgoing = bb->outgoingBranches();
        outgoing.erase(std::remove_if(outgoing.begin(), outgoing.end(), isInvalidRef),
                       outgoing.end());
    }

    assert(std::all_of(_basicBlocks.begin(), _basicBlocks.end(),
                       [](TraceBasicBlock* bb){ return bb->instrNumber() > 0; }));
}

//---------------------------------------------------
// TraceFunctionCycle

TraceFunctionCycle::TraceFunctionCycle(TraceFunction* f, int n)
{
    _base = f;
    _cycleNo = n;
    _cycle = this;

    setContext(ProfileContext::context(ProfileContext::FunctionCycle));

    setPosition(f->data());
    setName(QStringLiteral("<cycle %1>").arg(n));

    // reset to attributes of base function
    setFile(_base->file());
    setClass(_base->cls());
    setObject(_base->object());
}

void TraceFunctionCycle::init()
{
    _members.clear();
    _callers.clear();
    // this deletes all TraceCall's to members
    _callings.clear();

    invalidate();
}

void TraceFunctionCycle::add(TraceFunction* f)
{
    _members.append(f);
}

void TraceFunctionCycle::setup()
{
    if (_members.isEmpty()) return;

    foreach(TraceFunction* f, _members) {

        // the cycle takes all outside callers from its members
        foreach(TraceCall* call, f->callers()) {
            if (_members.contains(call->caller())) continue;
            _callers.append(call);
        }

        // the cycle has a call to each member
        TraceCall* call = new TraceCall(this, f);
        call->invalidate();
        _callings.append(call);

        // now do some faking...
        f->setCycle(this);
    }
    invalidate();
}


//---------------------------------------------------
// TraceClass

TraceClass::TraceClass()
    : TraceCostItem(ProfileContext::context(ProfileContext::Class))
{}

TraceClass::~TraceClass()
{
    // we are the owner of items generated in our factory
    qDeleteAll(_deps);
}

QString TraceClass::prettyName() const
{
    if (_name.isEmpty())
        return prettyEmptyName();
    return _name;
}

QString TraceClass::prettyEmptyName()
{
    return QObject::tr("(global)");
}

TracePartClass* TraceClass::partClass(TracePart* part)
{
    TracePartClass* item = (TracePartClass*) findDepFromPart(part);
    if (!item) {
        item = new TracePartClass(this);
        item->setPosition(part);
        addDep(item);
    }
    return item;
}

void TraceClass::addFunction(TraceFunction* function)
{
#if TRACE_ASSERTIONS
    if (function->cls() != this) {
        qDebug("Can not add function to a class not enclosing this function\n");
        return;
    }

    if (_functions.contains(function)) return;
#endif

    _functions.append(function);

    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ),
           qPrintable(function->fullName()), _functions.count());
#endif
}



//---------------------------------------------------
// TraceFile

TraceFile::TraceFile()
    : TraceCostItem(ProfileContext::context(ProfileContext::File))
{}

TraceFile::~TraceFile()
{
    // we are the owner of items generated in our factory
    qDeleteAll(_deps);
}

TracePartFile* TraceFile::partFile(TracePart* part)
{
    TracePartFile* item = (TracePartFile*) findDepFromPart(part);
    if (!item) {
        item = new TracePartFile(this);
        item->setPosition(part);
        addDep(item);
    }
    return item;
}

void TraceFile::addFunction(TraceFunction* function)
{
#if TRACE_ASSERTIONS
    if (function->file() != this) {
        qDebug("Can not add function to a file not enclosing this function\n");
        return;
    }

    if (_functions.contains(function)) return;
#endif

    _functions.append(function);

    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ),
           qPrintable(function->fullName()), _functions.count());
#endif
}


void TraceFile::addSourceFile(TraceFunctionSource* sourceFile)
{
#if TRACE_ASSERTIONS
    if (sourceFile->file() != this) {
        qDebug("Can not add sourceFile to a file not having lines for it\n");
        return;
    }
#endif

    _sourceFiles.append(sourceFile);
    // not truly needed, as we do not use the sourceFiles for cost update
    invalidate();

#if TRACE_DEBUG
    qDebug("%s \n added SourceFile %s (now %d)",
           qPrintable( fullName() ), qPrintable(sourceFile->fullName()),
           _sourceFiles.count());
#endif
}



void TraceFile::setDirectory(const QString& dir)
{
    if (dir.endsWith('/'))
        _dir = dir.left(dir.length()-1);
    else
        _dir = dir;
}

QString TraceFile::directory()
{
    if (!_dir.isEmpty()) return _dir;

    int lastIndex = 0, index;
    while ( (index=_name.indexOf(QLatin1Char('/'), lastIndex)) >=0)
        lastIndex = index+1;

    if (lastIndex==0) return QString();

    // without ending "/"
    return _name.left(lastIndex-1);
}


QString TraceFile::shortName() const
{
    int lastIndex = 0, index;
    while ( (index=_name.indexOf(QLatin1Char('/'), lastIndex)) >=0)
        lastIndex = index+1;

    return _name.mid(lastIndex);
}

QString TraceFile::prettyName() const
{
    QString sn = shortName();

    if (sn.isEmpty())
        return prettyEmptyName();

    return sn;
}

QString TraceFile::prettyEmptyName()
{
    return QObject::tr("(unknown)");
}

QString TraceFile::prettyLongName() const
{
    if (_name.isEmpty())
        return prettyEmptyName();
    return _name;
}


//---------------------------------------------------
// TraceObject

TraceObject::TraceObject()
    : TraceCostItem(ProfileContext::context(ProfileContext::Object))
{}

TraceObject::~TraceObject()
{
    // we are the owner of items generated in our factory
    qDeleteAll(_deps);
}

TracePartObject* TraceObject::partObject(TracePart* part)
{
    TracePartObject* item = (TracePartObject*) findDepFromPart(part);
    if (!item) {
        item = new TracePartObject(this);
        item->setPosition(part);
        addDep(item);
    }
    return item;
}

void TraceObject::addFunction(TraceFunction* function)
{
#if TRACE_ASSERTIONS
    if (function->object() != this) {
        qDebug("Can not add function to an object not enclosing this function\n");
        return;
    }

    if (_functions.contains(function)) return;
#endif

    _functions.append(function);

    invalidate();

#if TRACE_DEBUG
    qDebug("%s added\n %s (now %d)",
           qPrintable( fullName() ),
           qPrintable(function->fullName()), _functions.count());
#endif
}

void TraceObject::setDirectory(const QString& dir)
{
    if (dir.endsWith('/'))
        _dir = dir.left(dir.length()-1);
    else
        _dir = dir;
}

QString TraceObject::directory()
{
    if (!_dir.isEmpty()) return _dir;

    int lastIndex = 0, index;
    while ( (index=_name.indexOf(QLatin1Char('/'), lastIndex)) >=0)
        lastIndex = index+1;

    if (lastIndex==0) return QString();

    // without ending "/"
    return _name.left(lastIndex-1);
}


QString TraceObject::shortName() const
{
    int lastIndex = 0, index;
    while ( (index=_name.indexOf(QLatin1Char('/'), lastIndex)) >=0)
        lastIndex = index+1;

    return _name.mid(lastIndex);
}

QString TraceObject::prettyName() const
{
    QString sn = shortName();

    if (sn.isEmpty())
        return prettyEmptyName();

    return sn;
}

QString TraceObject::prettyEmptyName()
{
    return QObject::tr("(unknown)");
}

//---------------------------------------------------
// TracePart

TracePart::TracePart(TraceData* data)
    : TraceListCost(ProfileContext::context(ProfileContext::Part))
{
    setPosition(data);

    _dep = data;
    _active = true;
    _number = 0;
    _tid = 0;
    _pid = 0;

    _eventTypeMapping = nullptr;
}

TracePart::~TracePart()
{
    delete _eventTypeMapping;
}

void TracePart::setPartNumber(int n)
{
    if (data()->maxPartNumber() <n) data()->setMaxPartNumber(n);
    _number = n;
}

void TracePart::setThreadID(int tid)
{
    if (data()->maxThreadID() <tid) data()->setMaxThreadID(tid);
    _tid = tid;
}

void TracePart::setProcessID(int pid)
{
    _pid = pid;
}



// strip path
QString TracePart::shortName() const
{
    int lastIndex = 0, index;
    while ( (index=_name.indexOf(QLatin1Char('/'), lastIndex)) >=0)
        lastIndex = index+1;

    return _name.mid(lastIndex);
}

QString TracePart::prettyName() const
{
    if (_pid==0) return shortName();
    QString name = QStringLiteral("PID %1").arg(_pid);
    if (_number>0)
        name += QStringLiteral(", section %2").arg(_number);
    if ((data()->maxThreadID()>1) && (_tid>0))
        name += QStringLiteral(", thread %3").arg(_tid);
    return name;
}

bool TracePart::activate(bool active)
{
    if (_active == active) return false;
    _active = active;

    // to be done by the client of this function
    //  data()->invalidateDynamicCost();
    // So better use the TraceData functions...

    return true;
}

bool TracePart::operator<(const TracePart& p2) const
{
    if (processID() < p2.processID()) return true;

    if (processID() == p2.processID()) {
        if (partNumber() < p2.partNumber()) return true;

        if (partNumber() == p2.partNumber())
            return (threadID() < p2.threadID());
    }
    return false;
}


//---------------------------------------------------
// TraceData


// create vectors with reasonable default sizes, but not wasting memory
TraceData::TraceData(Logger* l)
    : ProfileCostArray(ProfileContext::context(ProfileContext::Data))
{
    _logger = l;
    init();
}

void TraceData::init()
{
    _functionCycleCount = 0;
    _inFunctionCycleUpdate = false;

    _maxThreadID = 0;
    _maxPartNumber = 0;
    _fixPool = nullptr;
    _dynPool = nullptr;

    _arch = ArchUnknown;
}

TraceData::~TraceData()
{
    qDeleteAll(_parts);

    delete _fixPool;
    delete _dynPool;
}

QString TraceData::shortTraceName() const
{
    int lastIndex = 0, index;
    while ( (index=_traceName.indexOf(QLatin1Char('/'), lastIndex)) >=0)
        lastIndex = index+1;

    return _traceName.mid(lastIndex);
}

FixPool* TraceData::fixPool()
{
    if (!_fixPool)
        _fixPool = new FixPool();

    return _fixPool;
}

DynPool* TraceData::dynPool()
{
    if (!_dynPool)
        _dynPool = new DynPool();

    return _dynPool;
}

bool partLessThan(const TracePart* p1, const TracePart* p2)
{
    return *p1 < *p2;
}

/**
 * Load a list of files.
 * If only one file is given, it is assumed to be a prefix, and all
 * existing files with that prefix are loaded.
 *
 * Returns 0 if nothing found to load
 */
int TraceData::load(QStringList files)
{
    if (files.isEmpty()) return 0;

    _traceName = files[0];
    if (files.count() == 1) {
        QFileInfo finfo(_traceName);
        QString prefix = finfo.fileName();
        QDir dir = finfo.dir();
        if (finfo.isDir()) {
            prefix = QStringLiteral("callgrind.out");
            _traceName += QLatin1String("/callgrind.out");
        }

        files = dir.entryList(QStringList() << prefix + '*', QDir::Files);
        QStringList::Iterator it = files.begin();
        for (; it != files.end(); ++it ) {
            *it = dir.path() + '/' + *it;
        }
    }

    if (files.isEmpty()) {
        _traceName += ' ' + QObject::tr("(not found)");
        return 0;
    }

    QStringList::const_iterator it;
    int partsLoaded = 0;
    for (it = files.constBegin(); it != files.constEnd(); ++it ) {
        QFile file(*it);
        partsLoaded += internalLoad(&file, *it);
    }
    if (partsLoaded == 0) return 0;

    std::sort(_parts.begin(), _parts.end(), partLessThan);
    invalidateDynamicCost();
    updateFunctionCycles();

    return partsLoaded;
}

int TraceData::load(QString file)
{
    return load(QStringList(file));
}

int TraceData::load(QIODevice* file, const QString& filename)
{
    _traceName = filename;
    int partsLoaded = internalLoad(file, filename);
    if (partsLoaded>0) {
        invalidateDynamicCost();
        updateFunctionCycles();
    }
    return partsLoaded;
}

int TraceData::internalLoad(QIODevice* device, const QString& filename)
{
    if (!device->open( QIODevice::ReadOnly ) ) {
        _logger->loadStart(filename);
        _logger->loadFinished(QString::fromLocal8Bit(strerror( errno )));
        return 0;
    }

    Loader* l = Loader::matchingLoader(device);
    if (!l) {
        // special case empty file: ignore...
        if (device->size() == 0) return 0;

        _logger->loadStart(filename);
        _logger->loadFinished(QStringLiteral("Unknown file format"));
        return 0;
    }
    l->setLogger(_logger);

    int partsLoaded = l->load(this, device, filename);

    l->setLogger(nullptr);

    return partsLoaded;
}

bool TraceData::activateParts(const TracePartList& l)
{
    bool changed = false;

    foreach(TracePart* part, _parts)
        if (part->activate(l.contains(part)))
            changed = true;

    if (changed) {
        // because active parts have changed, throw away calculated
        // costs...
        invalidateDynamicCost();
        updateFunctionCycles();
    }

    return changed;
}


bool TraceData::activateParts(TracePartList l, bool active)
{
    bool changed = false;

    foreach(TracePart* part, l) {
        if (_parts.contains(part))
            if (part->activate(active))
                changed = true;
    }

    if (changed) {
        invalidateDynamicCost();
        updateFunctionCycles();
    }

    return changed;
}

bool TraceData::activatePart(TracePart* p, bool active)
{
    return p->activate(active);
}

bool TraceData::activateAll(bool active)
{
    return activateParts(_parts, active);
}

void TraceData::addPart(TracePart* part)
{
    if (_parts.contains(part)>0) return;

    if ((part->partNumber()==0) &&
        (part->processID()==0)) {
        _maxPartNumber++;
        part->setPartNumber(_maxPartNumber);
    }
    _parts.append(part);
}

TracePart* TraceData::partWithName(const QString& name)
{
    foreach(TracePart* part, _parts)
        if (part->name() == name)
            return part;
    return nullptr;
}

QString TraceData::activePartRange()
{
    QString res;
    int r1=-1, r2=-1, count=0;
    foreach(TracePart* part, _parts) {
        count++;
        if (part->isActive()) {
            if (r1<0) { r1 = r2 = count; }
            else if (r2 == count-1) { r2 = count; }
            else {
                if (!res.isEmpty()) res += ';';
                if (r1==r2) res += QString::number(r1);
                else res += QStringLiteral("%1-%2").arg(r1).arg(r2);
                r1 = r2 = count;
            }
        }
    }
    if (r1>=0) {
        if (!res.isEmpty()) res += ';';
        if (r1==r2) res += QString::number(r1);
        else res += QStringLiteral("%1-%2").arg(r1).arg(r2);
    }

    return res;
}

void TraceData::invalidateDynamicCost()
{
    // invalidate all dynamic costs

    TraceObjectMap::Iterator oit;
    for ( oit = _objectMap.begin();
          oit != _objectMap.end(); ++oit )
        (*oit).invalidate();

    TraceClassMap::Iterator cit;
    for ( cit = _classMap.begin();
          cit != _classMap.end(); ++cit )
        (*cit).invalidate();

    TraceFileMap::Iterator fit;
    for ( fit = _fileMap.begin();
          fit != _fileMap.end(); ++fit )
        (*fit).invalidate();

    TraceFunctionMap::Iterator it;
    for ( it = _functionMap.begin();
          it != _functionMap.end(); ++it ) {
        (*it).invalidateDynamicCost();
    }

    invalidate();

}


TraceObject* TraceData::object(const QString& name)
{
    TraceObject& o = _objectMap[name];
    if (!o.data()) {
        // was created
        o.setPosition(this);
        o.setName(name);

#if TRACE_DEBUG
        qDebug("Created %s [TraceData::object]",
               qPrintable(o.fullName()));
#endif
    }
    return &o;
}


TraceFile* TraceData::file(const QString& name)
{
    TraceFile& f = _fileMap[name];
    if (!f.data()) {
        // was created
        f.setPosition(this);
        f.setName(name);

#if TRACE_DEBUG
        qDebug("Created %s [TraceData::file]",
               qPrintable(f.fullName()));
#endif
    }
    return &f;
}


// usually only called by function()
TraceClass* TraceData::cls(const QString& fnName, QString& shortName)
{
    int lastIndex = 0, index, pIndex;

    // we ignore any "::" after a '(' or a space
    pIndex=fnName.indexOf('(', 0);

#if 0
    int sIndex=fnName.find(" ", 0);
    if (sIndex>=0)
        if ((pIndex == -1) || (sIndex < pIndex))
            pIndex = sIndex;
#endif

    while ((index=fnName.indexOf(QLatin1String("::"), lastIndex)) >=0) {
        if (pIndex>=0 && pIndex<index) break;
        lastIndex = index+2;
    }

    QString clsName = (lastIndex < 3) ? QString() :
                                        fnName.left(lastIndex-2);
    shortName = fnName.mid(lastIndex);

    TraceClass& c = _classMap[clsName];
    if (!c.data()) {
        // was created
        c.setPosition(this);
        c.setName(clsName);

#if TRACE_DEBUG
        qDebug("Created %s [TraceData::cls]",
               qPrintable(c.fullName()));
#endif
    }
    return &c;
}


// name is inclusive class/namespace prefix
TraceFunction* TraceData::function(const QString& name,
                                   TraceFile* file, TraceObject* object)
{
    // strip class name
    QString shortName;
    TraceClass* c = cls(name, shortName);

    if (!file || !object || !c) {
        qDebug("ERROR - no file/object/class for %s ?!", qPrintable(name));
        return nullptr;
    }

    // Use object name and file name as part of key, to get distinct
    // function objects for functions with same name but defined in
    // different ELF objects or different files (this is possible e.g.
    // in C by using "static").
    //
    // Note about usage of this factory method by the Cachegrind loader:
    // that dump format does not explicitly specify the attribution
    // of functions to ELF objects and files. Rather, cost is attributed
    // to ELF object, source file and function. We use the first cost
    // seen for a function to bind an ELF object and source file to that
    // function. Callgrind always prints the cost of the instruction at
    // function entry first, so there, this strategy works.
    // But such an order is not enforced by the format. If the cost of
    // an inlined function from another source file would be printed first,
    // the attribution would go wrong. The format also allows cost of
    // the same function to be spread over the dump. With wrong
    // attributions, it can happen that cost of the same function is
    // interpreted as being from distinct functions.
    // For a correct solution, the format needs to be more expressive,
    // or the ordering of costs specified.
    // Previously, the file name was left out from the key.
    // The change was motivated by bug ID 3014067 (on SourceForge).
    QString key = name + file->shortName() + object->shortName();

    TraceFunctionMap::Iterator it;
    it = _functionMap.find(key);
    if (it == _functionMap.end()) {
        it = _functionMap.insert(key, TraceFunction());
        TraceFunction& f = it.value();

        f.setPosition(this);
        f.setName(name);
        f.setClass(c);
        f.setObject(object);
        f.setFile(file);
        //f.setMapIterator(it);

#if TRACE_DEBUG
        qDebug("Created %s [TraceData::function]\n  for %s, %s, %s",
               qPrintable(f.fullName()),
               qPrintable(c->fullName()), qPrintable(file->fullName()),
               object ? qPrintable(object->fullName()) : "(unknown object)");
#endif

        c->addFunction(&f);
        object->addFunction(&f);
        file->addFunction(&f);
    }

    return &(it.value());
}

TraceFunctionMap::Iterator TraceData::functionIterator(TraceFunction* f)
{

    // IMPORTANT: build as SAME key as used in function() above !!
    QString key;

    if (f->cls()) key = f->cls()->name() + "::";
    key += f->name();
    key += f->object()->shortName();

    return _functionMap.find(key);
}

TraceFunctionMap::ConstIterator TraceData::functionBeginIterator() const
{
    return _functionMap.begin();
}

TraceFunctionMap::ConstIterator TraceData::functionEndIterator() const
{
    return _functionMap.end();
}

// _maxCallCount is maintained globally, and only updated at loading
void TraceData::updateMaxCallCount(SubCost c)
{
    if (_maxCallCount < c)
        _maxCallCount = c;
}

void TraceData::resetSourceDirs()
{
    TraceFileMap::Iterator fit;
    for ( fit = _fileMap.begin();
          fit != _fileMap.end(); ++fit )
        (*fit).resetDirectory();
}

void TraceData::update()
{
    if (!_dirty) return;

    clear();
    _totals.clear();

    foreach(TracePart* part, _parts) {
        _totals.addCost(part->totals());
        if (part->isActive())
            addCost(part->totals());
    }

    _dirty = false;
}

ProfileCostArray* TraceData::search(ProfileContext::Type t, QString name,
                                    EventType* ct, ProfileCostArray* parent)
{
    ProfileCostArray* result = nullptr;
    ProfileContext::Type pt;
    SubCost sc, scTop = 0;

    pt = parent ? parent->type() : ProfileContext::InvalidType;
    switch(t) {
    case ProfileContext::Function:
    {
        TraceFunction *f;
        TraceFunctionMap::Iterator it;
        for ( it = _functionMap.begin();
              it != _functionMap.end(); ++it ) {
            f = &(*it);

            if (f->name() != name) continue;

            if ((pt == ProfileContext::Class) && (parent != f->cls())) continue;
            if ((pt == ProfileContext::File) && (parent != f->file())) continue;
            if ((pt == ProfileContext::Object) && (parent != f->object())) continue;

            if (ct) {
                sc = f->inclusive()->subCost(ct);
                if (sc <= scTop) continue;
                scTop = sc;
            }

            result = f;
        }
    }
        break;

    case ProfileContext::File:
    {
        TraceFile *f;
        TraceFileMap::Iterator it;
        for ( it = _fileMap.begin();
              it != _fileMap.end(); ++it ) {
            f = &(*it);
            if (f->name() != name) continue;
            if (ct) {
                sc = f->subCost(ct);
                if (sc <= scTop) continue;
                scTop = sc;
            }
            result = f;
        }
    }
        break;

    case ProfileContext::Class:
    {
        TraceClass *c;
        TraceClassMap::Iterator it;
        for ( it = _classMap.begin();
              it != _classMap.end(); ++it ) {
            c = &(*it);
            if (c->name() != name) continue;
            if (ct) {
                sc = c->subCost(ct);
                if (sc <= scTop) continue;
                scTop = sc;
            }
            result = c;
        }
    }
        break;

    case ProfileContext::Object:
    {
        TraceObject *o;
        TraceObjectMap::Iterator it;
        for ( it = _objectMap.begin();
              it != _objectMap.end(); ++it ) {
            o = &(*it);
            if (o->name() != name) continue;
            if (ct) {
                sc = o->subCost(ct);
                if (sc <= scTop) continue;
                scTop = sc;
            }
            result = o;
        }
    }
        break;

    case ProfileContext::Instr:
        if (pt == ProfileContext::Function) {
            TraceInstrMap* instrMap = ((TraceFunction*)parent)->instrMap();
            if (!instrMap) break;

            TraceInstr *instr;
            TraceInstrMap::Iterator it;
            for ( it = instrMap->begin();
                  it != instrMap->end(); ++it ) {
                instr = &(*it);
                if (instr->name() != name) continue;
                result = instr;
            }
        }
        break;

    case ProfileContext::Line:
    {
        TraceFunctionSourceList sList;
        if (pt == ProfileContext::Function)
            sList = ((TraceFunction*)parent)->sourceFiles();
        else if (pt == ProfileContext::FunctionSource)
            sList.append((TraceFunctionSource*) parent);
        else break;

        TraceLineMap* lineMap;
        TraceLine* line;
        TraceLineMap::Iterator it;
        foreach(TraceFunctionSource* fs, sList) {
            lineMap = fs->lineMap();
            if (!lineMap) continue;

            for ( it = lineMap->begin();
                  it != lineMap->end(); ++it ) {
                line = &(*it);
                if (line->name() != name) continue;
                result = line;
            }
        }
    }
        break;

    default:
        break;
    }

    return result;
}


TraceFunctionCycle* TraceData::functionCycle(TraceFunction* f)
{
    TraceFunctionCycle* cycle;
    foreach(cycle, _functionCycles)
        if (cycle->base() == f)
            return cycle;

    _functionCycleCount++;
    cycle = new TraceFunctionCycle(f, _functionCycleCount);

    _functionCycles.append(cycle);
    return cycle;
}


void TraceData::updateFunctionCycles()
{
    //qDebug("Updating cycles...");

    // init cycle info
    foreach(TraceFunctionCycle* cycle, _functionCycles)
        cycle->init();

    TraceFunctionMap::Iterator it;
    for ( it = _functionMap.begin(); it != _functionMap.end(); ++it )
        (*it).cycleReset();

    if (!GlobalConfig::showCycles()) return;

    _inFunctionCycleUpdate = true;


#if 0
    int fCount = _functionMap.size(), fNo = 0, progress=0, p;
    QString msg = tr("Recalculating Function Cycles...");
    if (_topLevel) _topLevel->showStatus(msg,0);
#endif

    // DFS and collapse strong connected components (Tarjan)
    int pNo = 0;
    TraceFunction* stackTop;
    for ( it = _functionMap.begin(); it != _functionMap.end(); ++it ) {

#if 0
        if (_topLevel) {
            fNo++;
            p = 100*fNo/fCount;
            if (p> progress) {
                progress = p;
                _topLevel->showStatus(msg, p);
            }
        }
#endif

        stackTop = nullptr;
        (*it).cycleDFS(1, pNo, &stackTop);
    }

    // postprocess cycles
    foreach(TraceFunctionCycle* cycle, _functionCycles)
        cycle->setup();

    _inFunctionCycleUpdate = false;
    // we have to invalidate costs because cycles are now taken into account
    invalidateDynamicCost();

#if 0
    if (0) if (_topLevel) _topLevel->showStatus(QString(), 0);
#endif
}

void TraceData::updateObjectCycles()
{
}


void TraceData::updateClassCycles()
{
}


void TraceData::updateFileCycles()
{
}

// ======================================================================================

//
// TraceBasicBlock
//

TraceBasicBlock::TraceBasicBlock(typename TraceInstrMap::iterator first,
                                 typename TraceInstrMap::iterator last)
    : TraceListCost{ProfileContext::context(ProfileContext::BasicBlock)},
      _instructions(std::distance(first, last)),
      _func{first->function()}
{
    std::transform(first, last, _instructions.begin(),
                   [](TraceInstr &i){ return std::addressof(i); });

    auto &jumps = lastInstr()->instrJumps();
    auto nJumps = jumps.size();

    if (nJumps == 0)
    {
        if (last != _func->instrMap()->end())
        {
            TraceData* data = _func->data();
            assert(data);
            EventType* e = data->eventTypes()->realType(0);
            assert(e);

            auto& calls = lastInstr()->instrCalls();

            SubCost execCount;
            if (calls.empty())
                execCount = lastInstr()->subCost(e);
            else
            {
                auto accumulator = [](uint64 count, TraceInstrCall* call)
                {
                    return count + call->callCount();
                };

                execCount = std::accumulate(calls.begin(), calls.end(), uint64{0}, accumulator);
            }

            _outgoingBranches.emplace_back(lastInstr(), std::addressof(*last),
                                           TraceBranch::Type::invalid, execCount);
        }
    }
    else if (nJumps == 1)
    {
        TraceInstrJump* jump = jumps.back();
        assert(jump);

        TraceInstr* from = jump->instrFrom();
        TraceInstr* to = jump->instrTo();

        TraceData* data = _func->data();
        EventType* e = data ? data->eventTypes()->realType(0) : nullptr;

        SubCost exec = e ? lastInstr()->subCost(e) : jump->executedCount();
        auto followed = (from == to) ? SubCost{exec - _func->calledCount()} : jump->followedCount();

        if (jump->isCondJump())
        {
            _outgoingBranches.emplace_back(from, to, TraceBranch::Type::true_, followed);

            if (exec.v != followed.v && last != _func->instrMap()->end())
            {
                _outgoingBranches.emplace_back(from, std::addressof(*last),
                                               TraceBranch::Type::false_, exec - followed);
            }
        }
        else
            _outgoingBranches.emplace_back(from, to, TraceBranch::Type::unconditional, exec);
    }
    else
    {
        _outgoingBranches.reserve(nJumps);
        for (auto jump : jumps)
        {
            assert(jump);
            _outgoingBranches.emplace_back(jump->instrFrom(), jump->instrTo(),
                                           TraceBranch::Type::indirect, jump->executedCount());
        }
    }

    for (; first != last; ++first)
    {
        first->setBasicBlock(this);
        addCost(std::addressof(*first));
    }
}

const TraceInstr* TraceBasicBlock::firstInstr() const
{
    assert(!_instructions.empty());
    return _instructions.front();
}

TraceInstr* TraceBasicBlock::firstInstr()
{
    assert(!_instructions.empty());
    return _instructions.front();
}

const TraceInstr* TraceBasicBlock::lastInstr() const
{
    assert(!_instructions.empty());
    return _instructions.back();
}

TraceInstr* TraceBasicBlock::lastInstr()
{
    assert(!_instructions.empty());
    return _instructions.back();
}

Addr TraceBasicBlock::firstAddr() const
{
    assert(firstInstr());
    return firstInstr()->addr();
}

Addr TraceBasicBlock::lastAddr() const
{
    assert(lastInstr());
    return lastInstr()->addr();
}

void TraceBasicBlock::addIncomingBranch(TraceBranch& br)
{
    assert(br.instrTo() == firstInstr());
    _incomingBranches.push_back(std::addressof(br));
}

// ======================================================================================

//
// TraceBranch
//

TraceBranch::TraceBranch(TraceInstr* from, TraceInstr* to, Type type, SubCost execCount)
    : TraceJumpCost{ProfileContext::context(ProfileContext::Branch)},
      _from{from}, _to{to}, _type{type}
{
    addExecutedCount(execCount);
}

TraceBasicBlock* TraceBranch::bbFrom()
{
    return _from ? _from->basicBlock() : nullptr;
}

const TraceBasicBlock* TraceBranch::bbFrom() const
{
    return _from ? _from->basicBlock() : nullptr;
}

TraceBasicBlock* TraceBranch::bbTo()
{
    return _to ? _to->basicBlock() : nullptr;
}

const TraceBasicBlock* TraceBranch::bbTo() const
{
    return _to ? _to->basicBlock() : nullptr;
}

bool TraceBranch::isCycle() const
{
    return (_type == Type::true_ || _type == Type::unconditional) && (bbFrom() == bbTo());
}
