Débogage panique dans Symbian OS en utilisant Carbide.c ++

Question

Est-il possible de tomber dans le débogueur lorsque any panique se passe comme s'il y avait un point d'arrêt?

J'utilise Carbide.c ++ 2.3.0. Je sais que sur les configurations de débogage> x86 exceptions, mais il ne couvre qu'une petite partie de ce qui peut réellement se produire dans une application réelle. Par exemple, il ne panique utilisateur piège, ou paniques alloc lorsque les sorties d'applications avec des fuites de mémoire.

Answer 1

Si vous utilisez l'émulateur, vous pouvez déboguer paniques en activant « le débogage juste-à-temps. Cela se fait en ajoutant la ligne suivante à epoc32\data\epoc.ini:

JustInTime debug

Pour plus de détails, voir le référence epoc.ini dans la documentation du SDK .

Answer 2

Au meilleur de ma connaissance, il ne peut se faire.

Qu'est-ce que je l'ai fait est d'utiliser la logique de traçage fonction simple, alors quand une panique arrive j'ai une trace de la pile au point de la panique dans mon code de traitement de panique (que je déconnecterai). Cela fonctionne bien à l'exception du fait que vous devez vous rappeler d'ajouter votre macro de début de chaque fonction.

par exemple.

#ifndef NDEBUG
class __FTrace
{
    __FTrace(const char* function)
    {
        TraceManager::GetInstance().EnterFunction(function);
    }
    ~__FTrace()
    {
        TraceManager::GetInstance().LeaveFunction(function);
    }
};    

#define FTRACE() __FTrace(__PRETTY_FUNCTION__)
#else
#define FTRACE()
#endif

void Func()
{
    FTRACE();
    ...
}

Pour ALLOC de, j'ai eu beaucoup de succès avec le crochet Logger sous l'émulateur. Il est une vraie douleur à installer et à utiliser, mais il sera plus vraiment facile de traquer les fuites de mémoire ALLOC.

Mise à jour: Comme demandé, voici ce que la manipulation ma panique apparence de code comme. Notez que mon application doit fonctionner en arrière-plan tout le temps, donc la configuration de pour redémarrer l'application quand quelque chose se passe mal. Aussi ce code fonctionne pour la 3ème édition SDK, je ne l'ai pas essayé les versions ultérieures du SDK.

Le point est d'exécuter l'application principale dans un autre thread, puis attendre pour quitter. Vérifiez ensuite pourquoi les sorties de fil, il le fil comme sorti pour des raisons inconnues, des trucs de journal comme ma propre trace de la pile et redémarrez l'application.

TInt StartMainThread(TAny*)
    {
    FTRACE();
    __LOGSTR_TOFILE("Main Thread Start");
    TInt result(KErrNone);

    TRAPD(err, result = EikStart::RunApplication(NewApplication));

    if(KErrNone != err || KErrNone != result )
        {
        __LOGSTR_TOFILE("EikStart::RunApplication error: trap(%d), %d", err, result);
        }

    __LOGSTR_TOFILE("Main Thread End");
    return result;
    }

const TInt KMainThreadToLiveInSeconds = 10;

} // namespace *unnamed*

LOCAL_C CApaApplication* NewApplication()
    {
    FTRACE();
    return new CMainApplication;
    }


GLDEF_C TInt E32Main()
    {
#ifdef NDEBUG
    __LOGSTR_TOFILE("Application Start (release)");
#else   
    __LOGSTR_TOFILE("Application Start (debug)");
#endif  

#ifndef NO_TRACING
    __TraceManager::NewL();
#endif // !NO_TRACING

    RHeap& heap(User::Heap());
    TInt heapsize=heap.MaxLength();

    TInt exitReason(KErrNone);

    TTime timeToLive;
    timeToLive.UniversalTime();
    timeToLive += TTimeIntervalSeconds(KMainThreadToLiveInSeconds);

    LManagedHandle<RThread> mainThread;
    TInt err = mainThread->Create(_L("Main Thread"), StartMainThread, KDefaultStackSize, KMinHeapSize, heapsize, NULL);
    if (KErrNone != err) 
        {
        __LOGSTR_TOFILE("MainThread failed : %d", err);
        return err;
        }

    mainThread->SetPriority(EPriorityNormal);
    TRequestStatus status; 
    mainThread->Logon(status);

    mainThread->Resume();

    User::WaitForRequest(status);

    exitReason = mainThread->ExitReason();
TExitCategoryName category(mainThread->ExitCategory());

switch(mainThread->ExitType())
    {
    case EExitKill:
        __LOGSTR_TOFILE("ExitKill : (%S) : %d", &category, exitReason);
        break;

    case EExitTerminate:
        __LOGSTR_TOFILE("ExitTerminate : (%S) : %d", &category, exitReason);
        break;

    case EExitPanic:
        __LOGSTR_TOFILE("ExitPanic : (%S) : %d", &category, exitReason);
        break;

    default:
        __LOGSTR_TOFILE("ExitUnknown : (%S) : %d", &category, exitReason);
        break;
    }

#ifndef NO_TRACING
    __TraceManager::GetInstance().LogStackTrace();
#endif // NO_TRACING


    if( KErrNone != status.Int() )
        {
        TTime now;
        now.UniversalTime();

        if (timeToLive > now)
            {
            TTimeIntervalMicroSeconds diff = timeToLive.MicroSecondsFrom(now);
            __LOGSTR_TOFILE("Exiting due to TTL : (%Lu)", diff.Int64());
            }
        else
            {
            RProcess current;
            RProcess restart;
            err = restart.Create(current.FileName(), _L(""));
            if( KErrNone == err )
                {
                __LOGSTR_TOFILE("Restarting...");
                restart.Resume();
                return KErrNone;
                }
            else
                {
                __LOGSTR_TOFILE("Failed to start app: %d", err);
                }
            }
        }

    __LOGSTR_TOFILE("Application End");
    return exitReason;
    }