Discussion :

[Artemus24]

Salut à tous.

J'ai un petit souci concernant mes développements en assembleur sous Raspberry Pi OS BookWorm.
J'utilise l'assembleur ("AS") 32bits et par voie de conséquence, mon OS est en 32bits.

J'aimerais basculer mon OS en 64bits car il est bien plus rapide que l'OS en 32bits.
C'est ce que j'ai constaté lors du démarrage de la Raspberry Pi mais en fait, j'utilise deux OS, dont l'un est en 32bits et l'autre en 64bits.
Le problème que je rencontre, l'assembleur 32bits ne fonctionne plus du tout quand je suis dans l'OS 64bits.

Je recherche le moyen de continuer à développer en assembleur mais avec un compilateur en 64bits dans mon OS 64bits.
Ou alors une solution pour ne pas tout réécrire et de continuer à exploiter mes projets écrits en 32bits dans l'OS 64bits.

Autrement dit, dois je changer d'assembleur et passer du 32bits au 64bits ?
Ou existe-t-il une solution sans casser mon existant ?

@+

[Artemus24]

Là où cela se complique dans l'usage que je fais de l'assembleur sous Raspberry Pi, j'utilise aussi du bare metal avec mes RPi Zero qui ne fonctionne qu'en 32bits. Je n'ai pas besoin de simuler le 32bits dans l'OS 64bits car j'installe l'application sur une carte micro SD que j'insère ensuite dans la RPi Zero.

Mais comme par ailleurs, j'ai déjà un existant en assembleur 32bits où j'appelle des fonctions assembleur dans des scripts écrits en 'C/C++', je me demande si je ne vais pas devoir tout réécrire.

J'ai fait une recherche en utilisant ChatGPT, et il me semble que la solution est d'utiliser le "Multiarch" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sudo dpkg --add-architecture i386
sudo apt update

et d'installer les outils assembleurs 32bits dans l'OS 64bits :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sudo apt install gcc-multilib g++-multilib libc6:i386 libc6-dev:i386
sudo apt install binutils-multiarch

Forcer l'assembleur à travailler en 32bits :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
as --32 mon_code.s -o mon_code.o
ld -m elf_i386 mon_code.o -o mon_executable

et d'utiliser gcc pour l'édition des liens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

gcc -m32 mon_code.o -o mon_executable

Jusqu'à présent, j'utilise deux OS, l'un en 32bits et l'autre en 64bits.
Cela me permet aussi d'utiliser l'OS 32Bits sur mes RPi Zero puisqu'ils fonctionnent qu'en 32Bits.
Mais si je bascule le tout en 64Bits, je ne pourrais plus utiliser mes RPi Zero, sauf en bare metal.
Je reconnais que c'est le bordel ce passage du 32Bits en 64Bits.
Et je ne sais pas trop comment m'y prendre sans tout casser mon existent.

Pour l'instant, j'expose mon problème avant d'entreprendre des modifications en profondeur.

J'ai aussi une bibliothèque en 'C/C++' qui exploite des appels systèmes de mes Raspberry Pi.
J'ignore si elle va continuer à fonctionner dans l'OS 64Bits, après recompilation.

[Artemus24]

Comme à son habitude, ChatGPT me dit beaucoup de conneries. Dans mon message précédent, les indications données sont fausses ! Je tenais à le préciser.

Je précise le contexte car j'ai plusieurs cas qui peuvent porter à confusion dans ce que j'essaye de faire.
Je suis dans ma Raspberry Pi 4B avec l'OS 64Bits de la version BookWorm.
J'ai un source écrit en assembleur 32Bits, qui n'est ni une fonction appelé par un programme 'C/C++', et qui n'utilise aucune bibliothèque.
Voilà ce qu'il faut faire :

a) Ajouter la prise en charge 32 bits (armhf) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sudo dpkg --add-architecture armhf
sudo apt update

b) Installer les bibliothèques de base 32 bits :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sudo apt install libc6:armhf libgcc1:armhf

c) je modifie mon makefile :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# ----------------------------- #
#   Déclaration des Commandes   #
# ----------------------------- #

RM      = @rm -rf
ASM     = @arm-linux-gnueabihf-as
CC      = @arm-linux-gnueabihf-gcc
AU      = @chown root:pi
EX      = @chmod 4110

# -------------------------- #
#   Déclaration des Objets   #
# -------------------------- #

SRC     = main.asm
OBJ     = main.o
BIN     = hello

# ------------------------------------ #
#   Compilation et Edition des liens   #
# ------------------------------------ #

all: clean $(BIN) after

.PHONY: clean $(BIN) after

clean:
        $(RM) $(OBJ)
        $(RM) $(BIN)

$(BIN): $(OBJ)
        $(CC)  $(OBJ) -o $(BIN) $(LIBS)

$(OBJ): $(SRC)
        $(ASM) $(SRC) -o $(OBJ) $(FLAG)

after:
        $(RM) $(OBJ)
        $(AU) $(BIN)
        $(EX) $(BIN)
#       @./$(BIN)

En rouge, ce que j'ai modifié par rapport à mon ancien makefile, dont les anciennes lignes étaient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
ASM     = @as
CC      = @gcc

4) et je teste :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

./hello

5) Résultat : sous l'OS 64Bits, j'ai pu exécuter l'assembleur écrit en 32Bits sans modifier le source.

6) par ailleurs, j'utilise des programmes 'C/C++' pour appeler des fonctions écrites en assembleurs 32Bits :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
sudo apt install g++-arm-linux-gnueabihf
sudo apt install libstdc++6:armhf
sudo apt install libc6:armhf

afin d'avoir aussi bien le 'C' que le 'C++' en 32bits.

7) dans le makefile, ajouter ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
CPP = arm-linux-gnueabihf-g++
CC  = arm-linux-gnueabihf-gcc
ASM = arm-linux-gnueabihf-as

ainsi les prorammes 'C' et/ou 'C++' et l'assembleurs seront tous en 32Bits.
J'espère ne rien avoir oublié des dépendances.

[Artemus24]

Je viens de tester l'assemblage d'une bibliothèque et l'assemblage du source qui appelle celle bibliothèque, toujours dans l'OS 64Bits sur de l'assembleur 32Bits : ca fonctionne !

Les seules modifications à faire dans le makefile sont :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
ASM	= @arm-linux-gnueabihf-as
CC	= @arm-linux-gnueabihf-gcc

Le reste ne change pas.

Je ne redonne pas les ajouts des packages et bibliothèques que j'ai donnés précédemment.

[Artemus24]

J'ai aussi testé le bare metal, à savoir transfert de l'exécutable 32Bits, assemblé dans l'OS 64Bits, vers mes RPi Zero qui sont en 32Bits, ca fonctionne.

Par rapport à la version 32Bits, il n'y a rien à faire. Voici le makefile d'origine :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# ----------------------------- #
#   Déclaration des Commandes   #
# ----------------------------- #

RM      = @rm -rf
EX      = @chmod +x

DMP     = @arm-none-eabi-objdump
CPY     = @arm-none-eabi-objcopy
LD      = @arm-none-eabi-ld
AS      = @arm-none-eabi-as

# -------------------------- #
#   Déclaration des Objets   #
# -------------------------- #

SRC     = main.asm
OBJ     = main.o

ELF     = kernel.elf
BIN     = kernel.img

LNK     = linker.ld

# ---------------------------- #
#   Déclaration des includes   #
# ---------------------------- #

INC     = -I ./include

# ------------------------------------ #
#   Compilation et Edition des liens   #
# ------------------------------------ #

all: clean $(BIN) dump after

.PHONY: clean

clean:
        clear
        $(RM) $(OBJ)
        $(RM) $(ELF)
        $(RM) $(BIN)

$(BIN): $(ELF)
        $(CPY) $(ELF) -O binary $(BIN)

$(ELF): $(OBJ)
        $(LD)  $(OBJ) -T $(LNK) -o $(ELF)

$(OBJ): $(SRC)
        $(AS)  $(SRC)           -o $(OBJ) $(INC)

dump:
        $(DMP)        -D $(ELF)

after:
        $(RM) $(OBJ)
        $(RM) $(ELF)
        $(EX) $(BIN)

Tout fonctionne comme si j'étais encore en 32Bits.
Problème résolu.

Remarque: pour constituer la carte Micro SD qui va venir s'insérer dans le lecteur de la RPi Zero, je dois récupérer les versions 32Bits suivants :
--> bootcode.bin
--> start.elf
--> fixup.dat

Et y placer aussi le résultat de l'assemblage 32Bits :
--> kernel.img

P.S.: Il me reste maintnenant à traiter le développement en assembleur 64Bits pure. Mais ça, c'est une autre histoire.

[fred1599]

Hello,

Ça semble plutôt intéressant, mais j'ai bien peur que vous tombiez dans un piège suite au besoin de compiler pour le Raspberry Pi Zero.

Le Pi Zero utilise un processeur ARMv6.

La toolchain arm-linux-gnueabihf-gcc qu'il a installée est conçue pour l'architecture "armhf", qui par défaut cible des processeurs ARMv7.

Si vous compilez sans précautions, le binaire qui en résultera fonctionnera sur votre Pi 4 (ARMv8) mais plantera sur votre Pi Zero (ARMv6) avec une erreur "Instruction illégale".

Aussi une petite confusion je pense... Bare Metal veut bien dire sans OS ?

Pour des applications linux (même en assembleur), vous utilisez la toolchain arm-linux-gnueabihf-gcc. Ce qui est correct, mais pas pour du vrai "Bare Metal" je pense.

EDIT : Vous devriez tester docker...