Je voudrais forcer un vidage de mémoire à un emplacement spécifique dans mon application C ++.

Je sais que je peux le faire en faisant quelque chose comme:

int * crash = NULL;
*crash = 1;

Mais j'aimerais savoir s'il existe un moyen plus propre?

J'utilise Linux au fait.

L'augmentation du signal numéro 6 ( SIGABRTsous Linux) est une façon de le faire (mais gardez à l'esprit que SIGABRT n'est pas obligé d'être 6 dans toutes les implémentations POSIX, vous pouvez donc utiliser la SIGABRTvaleur elle-même si c'est autre chose que quick'n 'code de débogage sale).

#include <signal.h>
: : :
raise (SIGABRT);

L'appel abort()provoquera également un vidage de mémoire, et vous pouvez même le faire sans terminer votre processus en appelant fork()suivi de abort()dans l'enfant uniquement - voir cette réponse pour plus de détails.

Il y a quelques années, Google a publié la bibliothèque coredumper .

Aperçu

La bibliothèque coredumper peut être compilée dans des applications pour créer des vidages de mémoire du programme en cours d'exécution - sans s'arrêter. Il prend en charge les vidages de mémoire à un et à plusieurs threads, même si le noyau ne prend pas en charge nativement les fichiers de base à plusieurs threads.

Coredumper est distribué sous les termes de la licence BSD.

Exemple

Ce n'est en aucun cas un exemple complet; cela vous donne simplement une idée de ce à quoi ressemble l'API coredumper.

#include <google/coredumper.h>
...
WriteCoreDump('core.myprogram');
/* Keep going, we generated a core file,
 * but we didn't crash.
 */

Ce n'est pas ce que vous demandiez, mais c'est peut-être encore mieux :)

Comme indiqué dans la page de manuel signal , tout signal avec l'action répertoriée comme «core» forcera un vidage de mémoire. Quelques exemples sont:

SIGQUIT       3       Core    Quit from keyboard
SIGILL        4       Core    Illegal Instruction
SIGABRT       6       Core    Abort signal from abort(3)
SIGFPE        8       Core    Floating point exception
SIGSEGV      11       Core    Invalid memory reference

Assurez-vous que vous activez les vidages de mémoire:

ulimit -c unlimited

#include <stdlib.h>   // C
//#include <cstdlib>  // C++

void core_dump(void)
{
    abort();
}

Invoquer

abort();

En relation, parfois vous voudriez une trace arrière sans un vidage de mémoire réel, et autorisez le programme à continuer à fonctionner: consultez les fonctions glibc backtrace () et backtrace_symbols (): http://www.gnu.org/s/libc/ manuel / html_node / Backtraces.html

Une autre façon de générer un vidage de mémoire:

$ bash
$ kill -s SIGSEGV $$

Créez simplement une nouvelle instance du bash et tuez-la avec le signal spécifié. Le $$est le PID du shell. Sinon, vous tuez votre bash actuel et serez déconnecté, le terminal fermé ou déconnecté.

$ bash 
$ kill -s SIGABRT $$
$ bash
$ kill -s SIGFPE $$

Vous pouvez utiliser kill (2) pour envoyer un signal.

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

Alors,

kill(getpid(), SIGSEGV);

Parfois, il peut être approprié de faire quelque chose comme ceci:

int st = 0;
pid_t p = fork();

if (!p) {
    signal(SIGABRT, SIG_DFL);
    abort(); // having the coredump of the exact copy of the calling thread
} else {
    waitpid(p, &st, 0); // rip the zombie
}

// here the original process continues to live

Un problème avec cette approche simple est qu'un seul thread sera coredumpé.

 #include <stdio.h>
 #include <stdlib.h>
 int main()
 {
   printf("\n");
   printf("Process is aborting\n");
   abort();
   printf("Control not reaching here\n");
   return 0;
 }

utilisez cette approche où vous voulez :)

#include <assert.h>
.
.
.
     assert(!"this should not happen");