Lorsque je fais un crochet d'exception Android, comment juger l'instruction assembleur est ARM ou Thumb par adresse?

Question

Lorsque je fais un crochet d'exception Android, comment juger l'instruction assembleur est ARM ou Thumb par adresse? L'adresse du pouce ne se termine-t-elle pas par "0"? quand je passe le bras au pouce, j'utilise "BX targetaddr + 1", mais l'adresse du pouce se termine toujours par "0". Je ne sais pas pourquoi.

void WriteillegalInstructionAndSaveOpcode(uint32_t addr, uint32_t *OriginOpcode) 
{ 
if(0x00000001 == (addr & 0x00000001)) 
{ 
    g_bIsThumb = 1; 
    *OriginOpcode = *(uint32_t *)(addr & (~0x00000001)); 
    //Thumb illegal instruction : 0xdeXX 
    uint32_t uiThumbillegalValue = 0x0000de00 | (0xFFFF0000 & *OriginOpcode); 
    write_data_to_addr(addr & (~0x00000001), uiThumbillegalValue); 
} 
else 
{ 
    g_bIsThumb = 0; 
    //Arm illegal instruction: 0xf7fXaXXX 
    *OriginOpcode = *(uint32_t *)addr; 
    uint32_t uiArmillegalValue = 0x7f000f0; 
    write_data_to_addr(addr, uiArmillegalValue); 
} 

LOGI("[+] g_bIsThumb is %08x \n",g_bIsThumb); 
LOGI("[+] WriteillegalInstruction addr: %08x, OriginalOpcode is %08x",addr & (~0x00000001), *OriginOpcode); 

} 

Answer 1

android donc c'est un bras de taille normale pas un cortex-m. Les instructions Thumb sont 16 bits alignés sur 16 bits, thumb2 sont des extensions, donc un nombre variable (deux) d'éléments de 16 bits. Donc, un bit de pouce est zéro. Les instructions ARM sont de 32 bits et doivent être alignées de sorte que deux lsbits doivent être zéro. Lorsque le lsbit est défini pour quand vous faites un bx, blx, ou pop (ou la table de vecteur dans un cortex-m) l'instruction/action consommant cette adresse dépouille le lsbit entrant dans le pc, le pc ne contient pas le Lsbit étant réglé (pour le pouce), le cpsr reflète cela. Lorsque le bl ou le blx arrive, le lr reçoit le pc plus deux instructions et le bit est mis en mode pouce sinon il est clair.

Je pense aux bras de taille normale, mais vous devez vérifier ARM ARM ou ARM TRM pour que ce noyau exécute des exceptions en mode ARM.

Donc, pour votre question:

Chaque mode d'exception dispose également d'un programme enregistré du registre d'état (SPSR) qui détient le CPSR de la tâche immédiatement avant l'exception a eu lieu.

Vous devriez vérifier la SPSR pour vérifier le bit T pour voir quel mode vous dans (en supposant qu'il était le pouce ou ARM), puis en fonction de l'exception examiniez ce que vous devez examiner pour déterminer quelle adresse cette mauvaise instruction dans ce cas était et ensuite aller lire cet article. Attention à ne pas faire une lecture 32 bits s'il s'agit d'une instruction au pouce non alignée sur une limite de 32 bits.