Impression du tableau des caractères au fichier GDB

J'ai un tableau de caractères avec environ 100 entrées. Il semble que lorsque dans la fonction que j'
print *buffer c'est se couper prématurément. est-ce que je peux faire pour allonger la quantité de caractères gdb va imprimer à la console? Si non, puis-je imprimer cette variable de fichier? J'ai essayé d'utiliser les commandes d'image, mais ne pourrais pas réussi à trouver la bonne chose.

À partir de votre description, il semble que votre tableau est en fait un pointeur. Avez-vous spécifier une longueur d'impression lorsque vous en a donné l'ordre?
Eh bien, il est transmis à la fonction **tampon à partir de la fonction appelante.
Alors, comment est GDB censé savoir combien de temps il est?
Je trouve ça beaucoup plus facile de définir des fonctions dans le code qui effectuer le vidage des données, et de les appeler directement à partir de gdb. (Envelopper les définitions de la #ifdef DEBUG)
Pas plus facile si vous êtes le débogage de code de production. 😉

OriginalL'auteur Derek | 2013-01-30

c gdb

(gdb) help x
Examine memory: x/FMT ADDRESS.
ADDRESS is an expression for the memory address to examine.
FMT is a repeat count followed by a format letter and a size letter.
Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),
t(binary), f(float), a(address), i(instruction), c(char) and s(string).
Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).
The specified number of objects of the specified size are printed
according to the format.
Defaults for format and size letters are those previously used.
Default count is 1.  Default address is following last thing printed
with this command or "print".
(gdb) x/8b array
0xbffd7670:     0       0       0       0       0       0       0       0
(gdb) x/16b array
0xbffd7670:     0       0       0       0       0       0       0       0
0xbffd7678:     0       0       0       0       0       0       0       0
(gdb) x/128b array
0xbffd7670:     0       0       0       0       0       0       0       0
0xbffd7678:     0       0       0       0       0       0       0       0
0xbffd7680:     0       0       0       0       0       0       0       0
0xbffd7688:     0       0       0       0       0       0       0       0
0xbffd7690:     0       0       0       0       0       0       0       0
0xbffd7698:     0       0       0       0       0       0       0       0
0xbffd76a0:     0       0       0       0       0       0       0       0
0xbffd76a8:     0       0       0       0       0       0       0       0
0xbffd76b0:     0       0       0       0       0       0       0       0
0xbffd76b8:     0       0       0       0       0       0       0       0
0xbffd76c0:     0       0       0       0       0       0       0       0
0xbffd76c8:     0       0       0       0       0       0       0       0
0xbffd76d0:     0       0       0       0       0       0       0       0
0xbffd76d8:     0       0       0       0       0       0       0       0
0xbffd76e0:     0       0       0       0       0       0       0       0
0xbffd76e8:     0       0       0       0       0       0       0       0
(gdb)

Si vous voulez le caractère ASCII symboles imprimés ainsi, l'utilisation x/<size>c.

(gdb) set logging file ~/gdb_dump.txt
(gdb) set logging on
Copying output to /home/mminich/gdb_dump.txt.
(gdb) x/26c array
0xbfff4b20:     97 'a'  98 'b'  99 'c'  100 'd' 101 'e' 102 'f' 103 'g' 104 'h'
0xbfff4b28:     105 'i' 106 'j' 107 'k' 108 'l' 109 'm' 110 'n' 111 'o' 112 'p'
0xbfff4b30:     113 'q' 114 'r' 115 's' 116 't' 117 'u' 118 'v' 119 'w' 120 'x'
0xbfff4b38:     121 'y' 122 'z'
(gdb) set logging off
Done logging to /home/mminich/gdb_dump.txt.
(gdb)

BTW, je suis entièrement d'accord avec William Pursell commentaire sous votre question: "je trouve ça beaucoup plus facile de définir des fonctions dans le code qui effectuer le vidage des données, et de les appeler directement à partir de gdb. (Envelopper les définitions de la #ifdef DEBUG)"

Que diriez-vous que l'imprimé dans un fichier?
voir mise à jour.

OriginalL'auteur phonetagger

17

Je pense que vous voulez quelque chose comme ceci:
```
(gdb) dump binary memory ~/file.bin 0x100390f4c (0x100390f4c + 940)
```
La commande dump est un peu délicat à utiliser. Il faut un début à une fin de l'adresse, et les expressions qui indiquent que dump (vous pouvez utiliser value au lieu de memory pour spécifier une expression, si cela fonctionne pour vous, mais parfois je préfère être précis.) Mais il semble (que j'ai testé ci-dessus) que vous pouvez utiliser des expressions de toute façon, comme je l'ai précisé à la fin de l'adresse ci-dessus dans les conditions de l'adresse de début je voulais dump, plus la quantité d'octets que je voulais.

Vous pouvez aussi faire quelque chose comme ceci (transmettre dans l'expression qui donne la valeur du pointeur plutôt que la valeur du pointeur lui-même):
```
(gdb) dump binary memory ~/file.bin buf (buf + len)
```
Pour plus d'informations, voir la la documentation ici.

OriginalL'auteur mpontillo
2

Pour imprimer nombre illimité de caractères de la console utiliser
```
set print elements 0
```
OriginalL'auteur Brice M. Dempsey
0

Personnellement, j'utilise python embarqué pour l'immersion des données.Par exemple:
```
(gdb) pi open("output_data.log","w").write(gdb.execute("print myarray@100000",to_string=True))
```
OriginalL'auteur Jacek Czaja

Vous devez vous connecter pour publier un commentaire.