Equivalent en LLDB de l'opérateur '@' de GDB dans Xcode 4.1

Question

Je voudrais voir un tableau d'éléments pointés par un pointeur. En GDB, cela peut être fait en traitant la mémoire pointée comme un tableau artificiel d’une longueur donnée en utilisant l’opérateur '@' comme

 *pointer @ length
 

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

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

Est-il possible d'accomplir ce qui précède dans LLDB?

Answer 1

En réalité, il existe un moyen simple de le faire, en plaçant le pointeur sur un pointeur vers un tableau.

Par exemple, si vous avez un int* ptr et que vous voulez le voir comme un tableau de dix entiers, vous pouvez le faire

 expr *(int(*)[10])ptr
 

Cela fonctionne sans aucun plugin ou paramètres manuellement. Juste C ++ régulier.

Answer 2

La seule façon que j'ai trouvée était via un module de script Python:

 """ 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)
 

Définissez 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 variable length ":

 (lldb) parray a 5
(double) *a = 0
(double) [1] = 0
(double) [2] = 1.14468
(double) [3] = 2.28936
(double) [4] = 3.43404
 

Answer 3

Avec Xcode 4.5.1 (qui peut vous aider ou pas maintenant), vous pouvez le faire dans la console lldb:

 (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 floats: float pointer[64];

Answer 4

Il ne semble pas être supporté pour le moment.

Vous pouvez utiliser la fonction de lecture mémoire (lecture mémoire / x), comme

 (lldb) p test
(float *) $0 = 0x00007fe078c331a0
(lldb) memory read -ff -c10 0x00007fe078c331a0
 

d'imprimer un nombre flottant dix fois à partir de ce pointeur. Cela devrait être la même fonctionnalité que @ de gdb. Je ne pouvais pas le faire utiliser le nom du pointeur à la place de l'adresse, ce qui est un inconvénient (vous devez le copier).

Answer 5

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. Faites 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')