Comment android native code écrit pour BRAS exécuter sur x86?

Oui, natif ARM code s'exécute sur le processeur Intel x86 à l'aide d'une fonction d'émulation nommé Houdini

Ce que cette bibliothèque n'est lit les BRAS instructions à la volée et les convertit en équivalent x86 instructions. C'est la raison pour laquelle de nombreuses applications peuvent fonctionner que sur x86 sans avoir à construire un équivalent de la bibliothèque.

Android Studio 3 émulateur utilise QEMU comme un backend

https://en.wikipedia.org/wiki/QEMU

QEMU est sans doute l'open source leader de la croix de l'arche de l'émulateur. C'est un logiciel sous licence GPL, et prend en charge de nombreuses architectures en plus de x86 et ARM.

Android puis ajoute juste un peu de l'INTERFACE utilisateur de la magie sur le dessus de QEMU et, éventuellement, certains correctifs, mais le cœur est définitivement dans QEMU en amont.

QEMU utilise une technique appelée binaire traduction de réaliser raisonnablement rapide de l'émulation: https://en.wikipedia.org/wiki/Binary_translation

Binaire traduction fondamentalement traduit BRAS instructions en équivalent x86 instructions.

Par conséquent, pour comprendre les détails, le meilleur moyen est de:

• lire QEMU code source: https://github.com/qemu/qemu
• étude binaire de la traduction en général, éventuellement écrire votre propre jouet de mise en œuvre

Théorie

• Processeurs sont "Turing" (jusqu'aux limites de la mémoire)
• Processeurs ont un simple déterministe du comportement qui peut être simulé avec mémoire finie machines de Turing

Par conséquent, il est clair que tout le CPU peut imiter n'importe quel CPU donné assez de mémoire.

La question difficile est de savoir comment le faire rapide.

Pratique: QEMU utilisateur en mode simulation

QEMU a un userland mode qui le rend très facile à jouer avec userland BRAS de code sur votre machine x86 pour voir ce qui se passe, aussi longtemps que votre invité et l'hôte sont le même OS.

Dans ce mode, ce qui se passe est que le binaire de traduction prend soin de les instructions de base, et les appels système sont simplement transmis à l'hôte, les appels système.

E. g., pour Linux sur Linux avec Linux autonome (pas de glibc) bonjour tout le monde:

principal.S

.text
.global _start
_start:
asm_main_after_prologue:
    /* write */
    mov x0, 1
    adr x1, msg
    ldr x2, =len
    mov x8, 64
    svc 0

    /* exit */
    mov x0, 0
    mov x8, 93
    svc 0
msg:
    .ascii "hello syscall v8\n"
len = . - msg

GitHub en amont.

Ensuite les assembler et de les exécuter en tant qu':

sudo apt-get install qemu-user gcc-aarch64-linux-gnu
aarch64-linux-gnu-as -o main.o main.S
aarch64-linux-gnu-ld -o main.out main.o
qemu-aarch64 main.out 

et les extrants attendus:

hello syscall v8

Vous pouvez même exécuter le BRAS programmes compilés à l'encontre de la bibliothèque C standard, et GDB étape déboguer le programme! Voir cet exemple concret: Comment seule étape de montage de BRAS dans GDB sur QEMU?

Puisque nous parlons des binaires de traduction, nous pouvons également permettre à certains de journalisation pour voir la traduction exacte que QEMU est en train de faire:

qemu-aarch64 -d in_asm,out_asm main.out

Ici:

• in_asm désigne le BRAS invité d'entrée de l'assemblée
• out_asm désigne X86 hôte assembly généré qui est exécuté

La sortie contient:

----------------
IN: 
0x0000000000400078:  d2800020      mov x0, #0x1
0x000000000040007c:  100000e1      adr x1, #+0x1c (addr 0x400098)
0x0000000000400080:  58000182      ldr x2, pc+48 (addr 0x4000b0)
0x0000000000400084:  d2800808      mov x8, #0x40
0x0000000000400088:  d4000001      svc #0x0

OUT: [size=105]
0x5578d016b428:  mov    -0x8(%r14),%ebp
0x5578d016b42c:  test   %ebp,%ebp
0x5578d016b42e:  jne    0x5578d016b482
0x5578d016b434:  mov    $0x1,%ebp
0x5578d016b439:  mov    %rbp,0x40(%r14)
0x5578d016b43d:  mov    $0x400098,%ebp
0x5578d016b442:  mov    %rbp,0x48(%r14)
0x5578d016b446:  mov    $0x4000b0,%ebp
0x5578d016b44b:  mov    0x0(%rbp),%rbp
0x5578d016b44f:  mov    %rbp,0x50(%r14)
0x5578d016b453:  mov    $0x40,%ebp
0x5578d016b458:  mov    %rbp,0x80(%r14)
0x5578d016b45f:  mov    $0x40008c,%ebp
0x5578d016b464:  mov    %rbp,0x140(%r14)
0x5578d016b46b:  mov    %r14,%rdi
0x5578d016b46e:  mov    $0x2,%esi
0x5578d016b473:  mov    $0x56000000,%edx
0x5578d016b478:  mov    $0x1,%ecx
0x5578d016b47d:  callq  0x5578cfdfe130
0x5578d016b482:  mov    $0x7f8af0565013,%rax
0x5578d016b48c:  jmpq   0x5578d016b416 

donc dans le IN section, nous voyons nos écrits à la main montage de BRAS de code, et dans le OUT section, nous voyons le générés x86 assemblée.

Testé sous Ubuntu 16.04 amd64, QEMU 2.5.0, binutils 2.26.1.

QEMU complète du système d'émulation

Lors du démarrage d'Android dans QEMU cependant, il n'est pas en cours d'exécution un userland binaire de cours, mais plutôt de faire le plein système de la simulation, où il dirige le véritable noyau Linux et tous les appareils de la simulation.

Complète du système de simulation est plus précis, mais un peu plus lent, et vous avez besoin de donner un noyau et de l'image du disque de QEMU.

À essayer ça, avoir un regard sur les configurations suivantes:

• construire PSBA à partir de la source et de l'exécuter sur QEMU: Comment faire pour compiler le Android PSBA noyau et le tester avec l'Émulateur Android?
• construire un minimum de belles système Linux avec Buildroot et de l'exécuter avec QEMU: Comment faire pour télécharger le Noyau Linux Torvalds maître, (re)compiler, et démarrer avec QEMU?
• build et run run baremetal code sur QEMU: https://github.com/cirosantilli/linux-kernel-module-cheat/tree/79b35fb395f9f7f7621609186931408fe2f79881#baremetal-setup-getting-started

KVM

Si vous exécutez Android X86 sur QEMU, vous constaterez qu'il est beaucoup plus rapide.

La raison en est que QEMU utilise KVM, qui est une fonctionnalité du noyau Linux que peut exécuter l'invité des instructions directement sur l'ordinateur hôte!

Si vous arrive d'avoir un BRAS puissant de la machine (encore rares à compter de 2019), vous pouvez également exécuter des BRAS sur les BRAS avec KVM beaucoup plus rapide.

Pour cette raison, je recommande que vous vous en tenez à X86 simulation de PSBA si vous êtes sur un système X86 d'hôte comme indiqué au: Comment faire pour compiler le Android PSBA noyau et le tester avec l'Émulateur Android?, à moins que vous vraiment besoin de toucher à quelque chose de faible niveau.