Afficher le tableau dans LLDB: l'équivalent de GDB '@' opérateur dans Xcode 4.1

Je voudrais afficher un tableau d'éléments pointé par un pointeur. Dans GDB cela peut être fait par le traitement de la pointe de la mémoire comme une artificielle tableau d'une certaine longueur, à l'aide de l'opérateur '@' comme

*pointer @ length

où length est le nombre d'éléments que je voudrais voir.

La syntaxe ci-dessus ne fonctionne pas dans LLDB fourni avec Xcode 4.1.

Est-il de toute façon à atteindre les objectifs susmentionnés en LLDB?

Près d'un an plus tard, et il ne semble pas encore à ce type de fonctionnalité dans lldb (je suis en utilisant LLDB-à 112,2 avec Xcode 4.3.3) - ajout d'une prime dans l'espoir que quelqu'un peut venir avec un utilisable d'une solution (autre que de retourner dans gdb).

InformationsquelleAutor midinastasurazz | 2011-08-15

116

En fait, il ya un moyen simple de le faire, en jetant le pointeur vers un pointeur vers un tableau.

Par exemple, si vous avez un int* ptr, et que vous souhaitez afficher comme un tableau de dix entiers, que vous pouvez faire
```
p *(int(*)[10])ptr
```
Car il repose uniquement sur la norme C, cette méthode fonctionne sans plugins ou des paramètres spéciaux. De même, il travaille avec d'autres débogueurs comme GDB ou de la CDB, même si elles aussi ont des syntaxes pour l'impression des tableaux.
- C'est une belle réponse qu'il mérite plus upvotes. Pas besoin de scripts personnalisés ou quoi que ce soit, et il fonctionne même avec des structures.
- Il est plus facile pour moi de lire à l'aide de 'int8_t' au lieu de 'int'
- Pour ceux qui utilisent le Xcode GUI qui ont un pointeur indiquant uniquement les premières données elment, procédez de la manière suivante: right click on data pointer > View value as... > Custom Type... Dans le champ d'expression mis *(double(*)[10])value_type. Qui permet d'imprimer les 10 valeurs souligné. Vous pouvez modifier doubles et 10 soit le type ou la quantité que vous souhaitez.
- Merci @AndrewHundt pour l'interface graphique d'aide. C'est exactement ce que je voulais.
- J'apprécierais si vous pouviez upvote le commentaire alors 🙂 @ Siyuan Ren peut-être l'info pourrait être incorporé dans votre réponse?
- Fait. Ne savais même pas que vous pourriez upvote commentaires jusqu'à maintenant. 🙂
- Je ne pense pas que c'est une bonne idée d'intégrer votre commentaire directement dans la réponse, depuis l'OP n'ont pas de poser une question à propos de l'interface graphique. Commentant l'article est assez bon pour l'information que les gens peuvent avoir besoin, mais ne pas répondre à la question en soi.
InformationsquelleAutor Siyuan Ren
28

En commençant par le lldb dans Xcode 8.0, il y a un nouveau lecteur de parray de commande. Ainsi, vous pouvez dire:
```
(lldb) parray <COUNT> <EXPRESSION>
```
pour imprimer le mémoire pointé par le résultat de la EXPRESSION comme un tableau de COUNT éléments du type pointé par l'expression.

Si le nombre est stocké dans une variable disponible dans le cadre actuel, puis n'oubliez pas que vous pouvez faire:
```
(lldb) parray `count_variable` pointer_to_malloced_array
```
C'est un général lldb fonctionnalité, n'importe quel argument de ligne de commande dans lldb entouré de backticks obtient évalué comme une expression qui renvoie un entier, puis l'entier se substituer à l'argument avant exécution de la commande.
- Est-il un moyen de définir cette variable permenantly, donc je ne pas avoir à retaper dans la lldb invite de commande chaque fois que je lance mon application?
- Pas tout à fait sûr de ce que tu veux dire. Si vous avez un lldb commande que vous souhaitez utiliser verbatim de nombreuses fois, vous pouvez utiliser command alias pour faire un raccourci.
InformationsquelleAutor Jim Ingham
26

Le seul moyen que j'ai trouvé était via un script Python module:
```
""" File: parray.py """
import lldb
import shlex

def parray(debugger, command, result, dict):
    args = shlex.split(command)
    va = lldb.frame.FindVariable(args[0])
    for i in range(0, int(args[1])):
        print va.GetChildAtIndex(i, 0, 1)
```
De définir une commande "parray" dans lldb:
```
(lldb) command script import /path/to/parray.py
(lldb) command script add --function parray.parray parray
```
Maintenant, vous pouvez utiliser "parray de longueur variable":
```
(lldb) parray a 5
(double) *a = 0
(double) [1] = 0
(double) [2] = 1.14468
(double) [3] = 2.28936
(double) [4] = 3.43404
```
- astuce: si vous avez besoin de recharger le script après modification, de type "script reload(parray)" (voir la section libertypages.com/clarktech/?p=4303)
- Merci pour l'astuce. Et chaque lien pour lldb/Python renseignements si précieux, que les documentations officielles est encore limitée.
- Un commentaire pour expliquer le downvote serait sympa ...
- parce que dans mon expérimentation, la valeur 'a' doit être un straight-up pointeur qui existe dans le cadre de la pile et ne fonctionne pas si son expression de tout genre. (par exemple pointeur de la fonte, l'offset appliqué, etc.)
- Lorsque j'essaie d'imprimer un tableau à l'intérieur d'une structure (struct) - je obtenir AttributeError: 'NoneType' object has no attribute 'FindVariable'
InformationsquelleAutor Martin R
15

Avec Xcode 4.5.1 (qui peut ou ne peut pas vous aider maintenant), vous pouvez le faire dans le lldb console:
```
(lldb) type summary add -s "${var[0-63]}" "float *"
(lldb) frame variable pointer
  (float *) pointer = 0x000000010ba92950 [0.0,1.0,2.0,3.0, ... ,63.0]
```
Cet exemple suppose que "pointeur" est un tableau de 64 flotteurs: float pointer[64];
- Je ne comprends pas vraiment quoi que ce soit là, mais il fonctionne et est très utile! Où voulez-vous apprendre ces grands lldb astuces?
- Ça ne ferait pas de tous float* imprimé à partir de maintenant apparaître comme un tableau de 64 éléments?
- Oui, c'est fait. Vous pouvez supprimer le résumé de type lorsque vous n'avez pas besoin de plus. Toujours mieux que de ne voir que de la première valeur.
InformationsquelleAutor davidA
12

En commençant par Martin R réponse que j'ai amélioré comme suit:
1. Si le pointeur n'est pas une simple variable, par exemple:
```
struct {
  int* at;
  size_t size;
} a;
```
  Puis "parray un.à 5" échoue.
  
  J'ai résolu ce problème en remplaçant "FindVariable" avec "GetValueForVariablePath".
2. Maintenant, si les éléments de votre tableau sont des agrégats, par exemple:
```
struct {
  struct { float x; float y; }* at;
  size_t size;
} a;
```
  Puis "parray un.à 5" imprime: une.au->x, une.au->y, une.[2], une.en[3], une.à[4] parce que GetChildAtIndex() renvoie les membres des agrégats.
  
  J'ai fixé ce, par la résolution de "un.au" + "[" + str(i) + "]" à l'intérieur de la boucle au lieu de le résoudre "un."et puis récupérer ses enfants.
3. Ajout d'une option "premier" argument (Utilisation: parray [FIRST] COMTE), ce qui est utile lorsque vous avez un grand nombre d'éléments.
4. Fait de faire le "script de commande add-f parray.parray parray" à l'initialisation
Voici ma version modifiée:
```
import lldb
import shlex

def parray(debugger, command, result, dict):
  args = shlex.split(command)
  if len(args) == 2:
    count = int(args[1])
    indices = range(count)
  elif len(args) == 3:
    first = int(args[1]), count = int(args[2])
    indices = range(first, first + count)
  else:
    print 'Usage: parray ARRAY [FIRST] COUNT'
    return
  for i in indices:
    print lldb.frame.GetValueForVariablePath(args[0] + "[" + str(i) + "]")

def __lldb_init_module(debugger, internal_dict):
  debugger.HandleCommand('command script add -f parray.parray parray')
```
- Des versions plus récentes de lldb (ou peut-être Python) exiger que les devoirs à la première et à compter sur des lignes séparées. Outre que cela fonctionne très bien! Merci pour cette!
- J'ai eu du mal pendant une heure à s'adapter Martin de R pour mon cas précis, merci pour le GetValueForVariablePath astuce !!
- Grande tentative et très utile. Pour la plupart des pointeur expressions, je suis intéressé par GetValueForVariablePath est de retour No Value. Je suis en utilisant lldb-300.2.47 dans Xcode 5.0. Pour int array[8], parry array 8 retourne No Value huit fois tout en print array[0] fonctionne comme prévu.
- Je crois que le problème, c'est que lldb.le cadre est fixé au module d'importation donc, au lieu de cela, vous avez besoin de la commande pour obtenir l'image en cours: target = débogueur.GetSelectedTarget() processus = cible.GetProcess() thread = processus.GetSelectedThread() frame = thread.GetSelectedFrame() et ensuite utiliser un cadre.GetValueForVariablePath au lieu de lldb.cadre.GetValueForVariablePath
- Le commentaire ci-dessus par @DaveReed adressé une partie du problème. La Simple utilisation du pointeur commencé à travailler. (pointeur de variable dans l'image actuelle, aucune conversion de type ou de calcul). Je veux faire des expressions plus sophistiquées, donc j'ai changé GetValueForVariablePath pour EvaluateExpression parce que j'étais toujours de voir No value. Maintenant un pointeur expression comme cela fonctionne: parray ((double*)sourcePointer+1) 5. Le type de retour pour les deux fonctions est la même pour la documentation de l'API, donc EvaluateExpression semble une meilleure façon d'aller.
InformationsquelleAutor jng
12

Il ne semble pas être encore pris en charge.

Vous pouvez utiliser la mémoire de la fonction de lecture (lecture de la mémoire /x), comme
```
(lldb) memory read -ff -c10 `test`
```
pour imprimer un flotteur de dix fois à partir de ce pointeur. Cela devrait être la même fonctionnalité que gdb @.
- Vous pouvez utiliser des backticks pour évaluer un pointeur expression, par exemple: (lldb) memory read -ff -c10 `test`
- Ce doit être la accepté de répondre! Il est facile et fonctionne hors de la boîte
- Et pour économiser de l'tapant x/10f test
InformationsquelleAutor w-m
4

J'ai essayé d'ajouter un commentaire, mais ce n'était pas idéal pour l'affichage d'une réponse j'ai donc fait ma propre réponse. Cela résout le problème à l'obtention de la mention "Aucune Valeur". Vous avez besoin pour obtenir l'image en cours, comme je le crois lldb.le cadre est fixé au module d'importation de temps donc il n'a pas l'image actuelle, lorsque vous vous arrêtez à un point d'arrêt si vous chargez le module de .lldbinit. L'autre version de travail si vous importez ou rechargé le script lorsque vous vous êtes arrêté au point d'arrêt. La version ci-dessous devrait toujours fonctionner.
```
import lldb
import shlex

@lldb.command('parray', 'command script add -f parray.parray parray')
def parray(debugger, command, result, dict):

    target = debugger.GetSelectedTarget()
    process = target.GetProcess()
    thread = process.GetSelectedThread()
    frame = thread.GetSelectedFrame()

    args = shlex.split(command)
    if len(args) == 2:
        count = int(args[1])
        indices = range(count)
    elif len(args) == 3:
        first = int(args[1])
        count = int(args[2])
        indices = range(first, first + count)
    else:
        print 'Usage: parray ARRAY [FIRST] COUNT'
        return

    for i in indices:
        print frame.GetValueForVariablePath(args[0] + "[" + str(i) + "]")
```
- Oups. commenté votre commentaire avant de voir votre réponse. Avec cela, la simple utilisation du pointeur fonctionne. (pointeur de variable dans l'image actuelle, aucune conversion de type ou de calcul). Je veux faire des expressions plus sophistiquées, donc j'ai changé GetValueForVariablePath pour EvaluateExpression parce que j'ai été voir encore Aucune valeur. Maintenant un pointeur expression comme cela fonctionne: parray ((double*)sourcePointer+1) 5. Le type de retour pour les deux fonctions est la même pour la documentation de l'API, donc EvaluateExpression semble une meilleure façon d'aller. Êtes-vous d'accord?
- Ainsi, une différence est que la sortie de EvaluateExpression est attribué à lldb variables, et l'index du tableau n'est pas imprimé. Ainsi, la sortie des lignes comme: (double) $68 = 0
- comment faire pour installer ou de fixer ce script pour lldb? Dois-je l'enregistrer quelque part, puis les ajouter dans .lldbinit?
InformationsquelleAutor Dave Reed
1

Bien, à ce stade, vous pouvez aussi écrire votre propre fonction de C et de l'invoquer à l':
```
call (int)myprint(args)
```
- Pas vraiment, vous pouvez ajouter la version de Python en direct à la LLDB session sans avoir à redémarrer votre programme et d'en reproduire l'erreur.
InformationsquelleAutor Elektraglide

Vous devez vous connecter pour publier un commentaire.