Commutateur Cas De L'Assemblée De La Langue

Je suis en train de regarder le code de langage d'assemblage d'une instruction switch.

Je comprends comment le code fonctionne et quels sont les cas sont. Ma question est comment puis-je décider sur le cas des noms?

Ci-dessous est le code de langage d'assemblage, qui sera suivie par mon interprétation de la chose. En gros, j'ai juste besoin d'utiliser le saut de la table et de le remplir dans le cas des noms.

    1 8048420: push %ebp
    2 8048421: mov %esp, $ebp
    3 8048423: mov 0x8(%ebp), %eax       //x
    4 8048426: mov 0xc(%ebp), %edx       //n
    5 8048429: sub $0x32, %edx           //so least value of case is 32
    6 804842c: cmp $0x5, %edx            //max value is 37
    7 804842f: ja 8048448 <switch+0x28>  //if >37, go to default
    8 8048431: jmp *0x80485d0(, %edx, 4)  //THIS RIGHT HERE ?
    9 8048438: shl $0x2, %eax             //CASE A
   10 804843b: jmp 804844b <switch+0x2b>  //break;
   11 804843d: sar $0x2, %eax             //CASE B
   12 8048440: jmp 804844b <switch+0x2b>  //break
   13 8048442: lea (%eax, %eax, 2), %eax  //CASE C
   14 8048445: imul %eax, %eax     
   15 8048448: add $0xa, %eax             //fall through to default
   16 804844b: pop %ebp                   //return
   17 804844c: ret

Le saut de la table que la commande gdb crée:
Je suis en train de faire x/6w 0x80485d0

0x80485d0: 0x08048438 0x08048448 0x08048438 0x0804843d
0x80485e0: 0x08048442 0x08048445

Mon interprétation:

int result = x;
switch(n) {
case __:
    x = x << 2;
    break;  
case __:
    x = x >> 2
    break;
case __:
    x = 4*x;
    x = x*x
case __: //default
    x += 0xa 
return x;
}

Je ne comprends juste pas comment faire pour regarder le saut de la table et de décider quelles valeurs de n entre 32 et 37 ajustement dans lequel de l'affaire des blancs.

Toute aide serait appréciée.
Merci.

Notez que 0x32 est de 50, pas 32.
Je ne suis pas sûr de comprendre la question; vous avez déjà fait le travail! Le premier élément de la table de saut correspond à 0x32, la deuxième à 0x33, et ainsi de suite.
Ne pas le x=4*x être x=3*x (ou, plus précisément, x=x+2*x)?

OriginalL'auteur Catie | 2010-10-24

  1. 5

    Comme Oli dit, il n'y a pas beaucoup plus à faire. n-50 est stocké dans %edx, alors interrupteur+0x11 saute à l'adresse stockée dans 0x80485d0 + %edx * 4. En regardant le tableau, que le commutateur d'+0x18 lorsque n==50 ou 52, interrupteur+0 x 28 lorsque n==51, interrupteur+0x1d lorsque n==53, interrupteur+0x22 lorsque n==54 et interrupteur+0x25 lorsque n==55.

    OriginalL'auteur outis

  2. 1

    Le saut de la table a 6 valeurs, dont 5 sont distinctes (donc, il y a 5 cas, dont la valeur par défaut à 0x8048448). La première et la troisième (qui correspondent à des 0x32 et 0x34) allez dans le premier cas, le second (0x33) à la dernière (cinquième), la quatrième (0x35) pour le deuxième cas, la cinquième (0x36) pour le troisième cas, et la sixième (0x37) pour le quatrième cas. Tout le reste passe à la dernière (cinquième), faisant que la valeur par défaut.

    switch (n)
{
  case 0x32:
  case 0x34:
    x <<= 2;
    break;
  case 0x35:
    x >>= 2;
    break;
  case 0x36:
    x *= 3;
  case 0x37:
    x *= x;
  //case 0x33:  //not really necessary
  default:
    x += 10;
}
return x;

    OriginalL'auteur cHao