Comment pourrais-je écrire "bonjour monde" en binaire?

Supposons que je voulais écrire un programme pour afficher "hello world", et je voulais l'écrire en binaire. Comment pourrais-je faire cela?

J'ai une idée:

J'avais besoin pour déterminer ce que l'architecture de la puce, je suis en utilisant
J'aurais besoin de savoir quel type de binaire, il utilise
J'aurais besoin de référence pour que la saveur de binaire
J'ai peut-être besoin de modifier un paramètre dans mon éditeur (Vim)

Quelqu'un peut-il me guider à travers cette?

source d'informationauteur Nathan Long

binary

C'est peu plus compliqué, parce qu'en fait, l'impression de "Hello, world!" à la sortie standard (stdout) est un appel système, donc vous avez besoin de connaître la bonne noyau syscall nombre. Qui, bien sûr, varie en fonction du système d'exploitation. Aussi, vous devez connaître le format binaire, qui ont également tendance à varier, bien que ELF (Executable et Linkable Format) est universelle dans quelques saveurs de Unix et Linux.

Voir Bonjour tout le monde! en assembleur.

C'est Linux code assembleur:

section .text
    global _start           ;must be declared for linker (ld)

_start:                 ;tell linker entry point

    mov edx,len ;message length
    mov ecx,msg ;message to write
    mov ebx,1   ;file descriptor (stdout)
    mov eax,4   ;system call number (sys_write)
    int 0x80    ;call kernel

    mov eax,1   ;system call number (sys_exit)
    int 0x80    ;call kernel

section .data

msg db  'Hello, world!',0xa ;our dear string
len equ $ - msg         ;length of our dear string

... qui sur Linux 32 bits, la compilation des résultats en binaire de 360 octets, même si c'est surtout les zéros:

00000000  7f 45 4c 46 01 01 01 00  00 00 00 00 00 00 00 00  |.ELF............|
00000010  02 00 03 00 01 00 00 00  80 80 04 08 34 00 00 00  |............4...|
00000020  c8 00 00 00 00 00 00 00  34 00 20 00 02 00 28 00  |........4. ...(.|
00000030  04 00 03 00 01 00 00 00  00 00 00 00 00 80 04 08  |................|
00000040  00 80 04 08 9d 00 00 00  9d 00 00 00 05 00 00 00  |................|
00000050  00 10 00 00 01 00 00 00  a0 00 00 00 a0 90 04 08  |................|
00000060  a0 90 04 08 0e 00 00 00  0e 00 00 00 06 00 00 00  |................|
00000070  00 10 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000080  ba 0e 00 00 00 b9 a0 90  04 08 bb 01 00 00 00 b8  |................|
00000090  04 00 00 00 cd 80 b8 01  00 00 00 cd 80 00 00 00  |................|
000000a0  48 65 6c 6c 6f 2c 20 77  6f 72 6c 64 21 0a 00 2e  |Hello, world!...|
000000b0  73 68 73 74 72 74 61 62  00 2e 74 65 78 74 00 2e  |shstrtab..text..|
000000c0  64 61 74 61 00 00 00 00  00 00 00 00 00 00 00 00  |data............|
000000d0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
000000f0  0b 00 00 00 01 00 00 00  06 00 00 00 80 80 04 08  |................|
00000100  80 00 00 00 1d 00 00 00  00 00 00 00 00 00 00 00  |................|
00000110  10 00 00 00 00 00 00 00  11 00 00 00 01 00 00 00  |................|
00000120  03 00 00 00 a0 90 04 08  a0 00 00 00 0e 00 00 00  |................|
00000130  00 00 00 00 00 00 00 00  04 00 00 00 00 00 00 00  |................|
00000140  01 00 00 00 03 00 00 00  00 00 00 00 00 00 00 00  |................|
00000150  ae 00 00 00 17 00 00 00  00 00 00 00 00 00 00 00  |................|
00000160  01 00 00 00 00 00 00 00                           |........|

Puisque vous voulez "compiler à la main", cela signifie essentiellement la traduction en assembleur mnémoniques au-dessus de leurs opcodespuis enrouler le résultat dans le bon format binaire (ELFE dans l'exemple ci-dessus)

Mise à JOUR: Comme cette réponse montre par @adam-rosenfield, le binaire ELF pour "Hello, world!" peut être découpé à la main en bas à 116 octets.

Voici une de 32 octets à l'aide de la version Linux du système d'appels:

 .globl _start
_start:
        movb $4, %al
        xor %ebx, %ebx
        inc %ebx
        movl $hello, %ecx
        xor %edx, %edx
        movb $11, %dl
        int $0x80               ;;; sys_write(1, $hello, 11)
        xor %eax, %eax
        inc %eax
        int $0x80               ;;; sys_exit(something) hello:
        .ascii "Hello world"

Lorsqu'il est compilé en un minimum de ELF, le fichier complet de l'exécutable est de 116
octets:

 00000000 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
|.ELF............| 00000010 02 00 03 00 01 00 00 00 54 80 04 08 34 
00 00 00 |........T...4...| 00000020 00 00 00 00 00 00 00 00 34 00 
20 00 01 00 00 00 |........4. .....| 00000030 00 00 00 00 01 00 00 
00 00 00 00 00 00 80 04 08 |................| 00000040 00 80 04 08 
74 00 00 00 74 00 00 00 05 00 00 00 |....t...t.......| 00000050 00 
10 00 00 b0 04 31 db 43 b9 69 80 04 08 31 d2 |......1.C.je...1.| 
00000060 b2 0b cd 80 31 c0 40 cd 80 48 65 6c 6c 6f 20 77 
|[email protected] w| 00000070 6c 6f 72 64 
|ondial| 00000074

3

Normalement, vous devriez utiliser un éditeur hexadécimal pour cela. Comprendre le code d'assemblée à la main, l'assemblage, l'utilisation de l'éditeur hexadécimal pour entrer les valeurs binaires, puis les enregistrer dans un fichier. Une fois que vous avez votre fichier, déposez-les dans votre machine de surveiller et de charger le fichier à disposition d'une adresse, puis de passer à la première instruction. C'était assez courant sur les ordinateurs à carte unique et se fait toujours sur des microcontrôleurs aujourd'hui, mais ce n'est pas quelque chose que vous allez faire sur un contemporain de l'OS. Si vous voulez vraiment pour ce faire, je recommande d'exécuter un faible niveau d'émulateur (SIMH de travail) ou de travailler avec un microcontrôleur (vous pouvez ramasser un TI MSP430 kit de développement pour moins de cinq dollars).

Vous devez vous connecter pour publier un commentaire.