Lernen Sie "x86-Architektur mit Ihrem eigenen Emulator" mit Manjaro (Linux)

Einführung

Ich habe ein Buch mit dem Titel "x86-Architektur mit meinem eigenen Emulator gelernt" gekauft. Das Makefile dieses Beispielcodes bezieht sich auf die enthaltene Toolkette (gcc usw.), und das Tool war für Windows. Ich mag es aus religiösen Gründen nicht, unter Windows zu entwickeln, deshalb habe ich beschlossen, einen x86-Emulator auf meinem üblichen Manjaro (Archlinux-basierte Linux-Umgebung) zu entwickeln.

In diesem Artikel werde ich erklären, wie der für Manjaro und den geänderten Teil geänderte Beispielcode verwendet wird.

Lernumgebung vorbereiten

Installation der notwendigen Werkzeuge (gcc, nasm, objdump, qemu)

$ sudo pacman -S git gcc nasm binutils qemu

Laden Sie den Beispielcode herunter

$ git clone https://github.com/Kenta11/x86-emulator-book-Manjaro

Änderung des Beispielcodes

Die Unterschiede zum offiziell verteilten Beispielcode sind wie folgt.

Ersetzen Sie das von Makefile referenzierte Tool durch das gerade installierte

In dem verteilten Beispielcode wurden gcc usw. enthalten und referenziert.

--Vorher (von tolset_p86 / emu4.2 / Makefile)

TARGET = px86.exe                                                                                                                               
OBJS = main.o emulator_function.o instruction.o modrm.o io.o bios.o
Z_TOOLS = ../z_tools

CC = $(Z_TOOLS)/mingw32-gcc/bin/gcc
CFLAGS += -Wall

.PHONY: all 
all :
    make $(TARGET)

%.o : %.c Makefile
    $(CC) $(CFLAGS) -c $<

$(TARGET) : $(OBJS) Makefile
    $(CC) -o $@ $(OBJS)

Ich habe das referenzierte Tool durch das mit pacman installierte ersetzt und eine Regel hinzugefügt, die ich für nützlicher hielt.

--Nachher (aus Kapitel 4 / Abschnitt 2 / Makefile)

TARGET = px86                                                                                                                                   
PROGRAM = subroutine32.bin
OBJS = main.o emulator_function.o instruction.o modrm.o io.o bios.o

CC = gcc 
ASM = nasm
CFLAGS += -O2 -Wall -Wextra

.PHONY: all run clean
all : $(TARGET) $(PROGRAM)

run : $(TARGET) $(PROGRAM)
        ./$(TARGET) -q $(PROGRAM)

$(TARGET) : $(OBJS)
        $(CC) -o $@ $(OBJS)

%.o : %.c 
        $(CC) $(CFLAGS) -c $<

%.bin : %.asm
        $(ASM) -f bin -o $@ $<

clean :
        rm -f $(TARGET) $(PROGRAM) $(OBJS)

Im Fall dieses Makefiles habe ich run and clean hinzugefügt. run führt das Testprogramm auf dem Emulator aus. Clean entfernt auch Produkte (Objektdateien, Emulator-Binärdateien, Testprogramme).

Entwickelte Stiefel zur Verwendung in "4.5 Let's see PBR" mit vollem Kratzer

Da boot ausnahmslos eine Binärdatei für Windows war, habe ich ein Programm erstellt, das eine Verarbeitung ähnlich dem Original ausführt (Kapitel 4 / Abschnitt 5. Baum / Master / Kapitel4 / Abschnitt5)). Das Buch zeigt den Inhalt von FAT16, aber alle USB-Speicher um mich herum wurden mit FAT32 formatiert. Daher kann auch FAT32 angezeigt werden. (Ich frage mich, ob die Originalstiefel auch FAT32 sehen können ... ich werde es später überprüfen)

Makefile hinzugefügt, damit "4.6 Lass uns auf dem tatsächlichen Computer laufen" mit QEMU durchgeführt werden kann

In diesem Buch wird das von boot ausgegebene Assembly-Programm so geändert, dass das Programm ausgeführt wird, das die Zeichenfolge auf dem tatsächlichen Computer anzeigt. Ich befürchtete jedoch, dass es einen Unfall gab, bei dem der Computer aufgrund eines Fehlers im Montageprogramm kaputt ging, und versuchte es stattdessen mit QEMU (Emulator). Fügen Sie das Assembly-Programm pbr.asm in Kapitel 4 / Abschnitt 6 ein und führen Sie make aus, QEMU wird Es liest pbr.bin und zeigt das gleiche Ergebnis wie die tatsächliche Maschine an.

TARGET = pbr.bin
ASM = nasm
QEMU = qemu-system-x86_64

.PHONY: all clean
all : $(TARGET)
	$(QEMU) $<

%.bin : %.asm
	nasm $< -o $@

clean :
	rm -f $(TARGET)

Toolchain für Windows entfernt

Das mitgelieferte gcc und die Stiefel sind für Windows und für Manjaro nicht erforderlich, daher habe ich sie gelöscht. Ich bin glücklich, weil die Dateigröße kleiner ist.

Zusammenfassung

Ich habe mit Manjaro an "x86-Architektur, die ich mit meinem eigenen Emulator gelernt habe" gearbeitet. Ich glaube nicht, dass Sie den Spaß daran genießen können, dass der 80386-Emulator schrittweise erstellt wird, wenn Sie die Seiten in anderen Büchern (insbesondere japanischen Büchern!) Lesen. Die x86-Architektur sieht auf den ersten Blick kompliziert aus, aber nach dem Lesen dieses Buches scheint es kompliziert zu sein: P Natürlich ist dies aus historischen Gründen geschehen, aber wie Sie es lesen, warum? Ich konnte es erleben. Ich würde es definitiv jedem empfehlen, der daran interessiert ist, wie Computer funktionieren.

Durch Ersetzen des Tools, auf das der Beispielcode Makefile verweist, durch ein Tool, das mit Manjaros Package Manager installiert werden kann, ist es einfacher, es in einer Linux-Umgebung wiederzuverwenden, während es kleiner als die ursprüngliche Beispielcode-ZIP-Datei ist. Wenn Sie unter Linux an den Inhalten dieses Buches arbeiten möchten, verwenden Sie bitte den auf GitHub hochgeladenen Beispielcode.

Verknüpfung

Recommended Posts

Lernen Sie "x86-Architektur mit Ihrem eigenen Emulator" mit Manjaro (Linux)
Verwenden Sie WDC-433SU2M2 mit Manjaro Linux
Machen Sie Ihr eigenes Handbuch. [Linux] [Mann]
Löse dein eigenes Labyrinth mit Q-Lernen
Trainiere UGATIT mit deinem eigenen Datensatz
Löse dein eigenes Labyrinth mit DQN
Ihr eigener Twitter-Client mit Django
Erstellen Sie Ihre eigenen Linux-Befehle in Python
[Stärkung des Lernens] DQN mit Ihrer eigenen Bibliothek
Lernen Sie mit TensorFlow Y = 2X verteilte Daten
Erstellen Sie mit Twisted Ihren eigenen DNS-Server
Erstellen Sie mit SQLAlchemy Ihren eigenen zusammengesetzten Wert
X86 Assembler unter Linux (Verknüpfung mit C)
So importieren Sie Ihr eigenes Modul mit jupyter
Veröffentlichen Sie Ihre eigene Python-Bibliothek auf Homebrew
Führen Sie Linux mit ARM-Architektur mit QEMU aus