[RPi zero W & ARM] Bug incompréhensible

Version imprimable

Salut à tous.

J'ai un problème pourtant fort simple, mais je n'arrive pas à trouver la solution.
Je suis dans en train de tester, en Bare Metal ARM sur une raspberry Pi Zero W, le mode UART.
Le problème n'est pas dans la gestion de l'UART qui fonctionne parfaitement (enfin, je crois).
J'utilise pour l'assemblage : "arm-none-eabi-as".

Pour l'instant, je mets un caractère en hexadécimal (0x65 = A) dans un registre que j'envoi vers mon écran COM4 sous windows.
Ca fonctionne très bien, puisque j'ai à l'affichage le caractère en question à l'écran.

Oui mais voilà, je préfère gérer une chaîne de caractères. J'ai crée une zone dans la section .data, que voici :

Code:

1
2
3
4
        .section .data

mess:   .ascii  "Hello The World!\n\r"
        .equ    end,.

et voilà le résultat de l'assemblage de cette zone :

Code:

1
2
3
4
5
6
7
8
Déassemblage de la section .data*:

00000000 <mess>:
   0:   6c6c6548        cfstr64vs       mvdx6, [ip], #-288      ; 0xfffffee0
   4:   6854206f        ldmdavs r4, {r0, r1, r2, r3, r5, r6, sp}^
   8:   6f572065        svcvs   0x00572065
   c:   21646c72        smccs   18114   ; 0x46c2
  10:   Adresse 0x00000010 hors intervalle.

On remarque que les caractères se lisent de droite à gauche : 0x48 (H), 0x54(e), 0xC6(l), ..., 0x64(d), 0x21(!).

Et le code assembleur :

Code:

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
61
62
63
64
65
66
67
68
69
70
71
72
73
@ ======================================================== @
@                                                          @
@ -------------------------------------------------------- @
@         Raspberry PI Zero / BCM2835 (Cortex-a7)          @
@ ======================================================== @

        .cpu    cortex-a7               @ RPi zero W
        .global _start

@ --------------- @
@ Storage Section @
@ --------------- @

        .section .data

mess:   .ascii  "Hello The World!\n\r"
        .equ    end,.

        .section .stack

        .include "init.asm"

@ -------------- @
@ Send a Message @
@ -------------- @

loop:   ldr     r2,=mess                @ Begin of Message
        ldr     r3,=end                 @ End   of Message

loop1:  ldrb    r1,[r2]                 @ Loading a Character
        bl      send                    @ send a character
        bl      delay

        add     r2,r2,#1
        cmp     r2,r3
        blt     loop1

        b       loop                    @ Infinite Loop

        .ltorg

@ ----------------- @
@ Subroutine : send @
@ ----------------- @

send:   push    {r2-r12,lr}

        str     r1,[r0,#0x40]
send1:  ldr     r2,[r0,#0x54]
        tst     r2,#0x20
        beq     send1

        pop     {r2-r12,lr}
        bx      lr

        .ltorg

@ ------------------ @
@ Subroutine : delay @
@ ------------------ @

delay:  push    {r0-r12,lr}

        ldr     r0,=0x00100000          @ Counter

delay1: sub     r0,r0,#1
        cmp     r0,#0
        bgt     delay1

        pop     {r0-r12,lr}
        bx      lr

        .ltorg

J'ai volontairement isolé dans un fichier include, le paramétrage de l'UART.
La seule information utile est contenu dans le registre 0.

La ligne qui me pose problème est celle où il y a le commentaire "@Loading a character".

A l'affichage, je n'obtiens pas la chaine de caractères, mais un caractère, genre pavé qui signifie que le code hexa > 0x7F.
C'est à ne rien y comprendre !!!

J'utilise maintenant l'assembleur "as" pour tester ce cas :

Code:

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
@ -------- @
@ Messages @
@ -------- @

        .section .data
mess:   .ascii  "Hello the World!\n"
        .equ    end,.

        .section .stack
        .section .text

@ ---------- @
@ Initialize @
@ ---------- @

        .global main
main:   push    {r1-r12,lr}

        ldr     r0,=mess
        ldr     r1,=end

loop:   ldrb    r2,[r0]

        bl      reg

        add     r0,r0,#1
        cmp     r0,r1
        blt     loop

@ ---- @
@ Exit @
@ ---- @

        mov     r0,#0                   @ return code 0

        pop     {r1-r12,lr}
        bx      lr

A l'exécution, j'ai bien ce que je veux dans le registre 2, que voici :

Code:

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
Reg 0  :  00021024   Reg 1  :  00021035   Reg 2  :  00000048   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021025   Reg 1  :  00021035   Reg 2  :  00000065   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021026   Reg 1  :  00021035   Reg 2  :  0000006C   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021027   Reg 1  :  00021035   Reg 2  :  0000006C   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021028   Reg 1  :  00021035   Reg 2  :  0000006F   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021029   Reg 1  :  00021035   Reg 2  :  00000020   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  0002102A   Reg 1  :  00021035   Reg 2  :  00000074   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  0002102B   Reg 1  :  00021035   Reg 2  :  00000068   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  0002102C   Reg 1  :  00021035   Reg 2  :  00000065   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  0002102D   Reg 1  :  00021035   Reg 2  :  00000020   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  0002102E   Reg 1  :  00021035   Reg 2  :  00000057   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  0002102F   Reg 1  :  00021035   Reg 2  :  0000006F   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021030   Reg 1  :  00021035   Reg 2  :  00000072   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021031   Reg 1  :  00021035   Reg 2  :  0000006C   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021032   Reg 1  :  00021035   Reg 2  :  00000064   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021033   Reg 1  :  00021035   Reg 2  :  00000021   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

Reg 0  :  00021034   Reg 1  :  00021035   Reg 2  :  0000000A   Reg 3  :  000103D0
Reg 4  :  00000000   Reg 5  :  000105F4   Reg 6  :  000102E0   Reg 7  :  00000000
Reg 8  :  00000000   Reg 9  :  00000000   Reg A  :  B6FAE000   Reg B  :  00000000
Reg C  :  BEF1DB30

>

Où se trouve mon problème ?

@+

Salut à tous.

J'ai trouvé la solution.
J'ai un fichier linker.ld que voici :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
ENTRY(_start)

MEMORY
{
  rom  (rx)  : ORIGIN = 0x0000, LENGTH = 0x0200
  mem1 (rwx) : ORIGIN = 0x0200, LENGTH = 0x0100
  mem2 (rwx) : ORIGIN = 0x0300, LENGTH = 0x0100
}

SECTIONS
{
        .text  : {      *(.text)                } > rom

        .data  : {      _data_start_  = .;
                        *(.data)
                        _data_end_    = .;      } > mem1

        .stack : {      _stack_start_ = .;
                        . += 0x0100;
                        _stack_end_   = .;      } > mem2
}

C'est lui qui est à l'origine de mon problème.

Comment j'ai résolu mon problème ?
Tout simplement ne ne l'utilisant pas dans la commande "arm-none-eabi-ld".

Par contre, je ne sais pas pourquoi j'ai cette erreur ?
Il y a quelque chose que je n'ai pas compris !

A l'adresse 0x00000000, il s'agit de la SDRAM (Synchronous Dynamic Random Access Memory).
Normalement, je peux écrire dedans et m'en servir pour stoker des données et un programme, non ?

Voici le dump de mon programme :

Code:

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
kernel.elf:     file format elf32-littlearm


Disassembly of section .text:

00008000 <_start>:
    8000:       e3a00902        mov     r0, #32768      ; 0x8000
    8004:       e1a0d000        mov     sp, r0
    8008:       eaffffff        b       800c <init>

0000800c <init>:
    800c:       e59f007c        ldr     r0, [pc, #124]  ; 8090 <init+0x84>
    8010:       e5901004        ldr     r1, [r0, #4]
    8014:       e3a02007        mov     r2, #7
    8018:       e1a02602        lsl     r2, r2, #12
    801c:       e1c11002        bic     r1, r1, r2
    8020:       e3a02002        mov     r2, #2
    8024:       e1a02602        lsl     r2, r2, #12
    8028:       e1811002        orr     r1, r1, r2
    802c:       e3a02007        mov     r2, #7
    8030:       e1a02782        lsl     r2, r2, #15
    8034:       e1c11002        bic     r1, r1, r2
    8038:       e3a02002        mov     r2, #2
    803c:       e1a02782        lsl     r2, r2, #15
    8040:       e1811002        orr     r1, r1, r2
    8044:       e5801004        str     r1, [r0, #4]
    8048:       e3a01000        mov     r1, #0
    804c:       e5801094        str     r1, [r0, #148]  ; 0x94
    8050:       e59f003c        ldr     r0, [pc, #60]   ; 8094 <init+0x88>
    8054:       e3a01001        mov     r1, #1
    8058:       e5801004        str     r1, [r0, #4]
    805c:       e3a01000        mov     r1, #0
    8060:       e5801060        str     r1, [r0, #96]   ; 0x60
    8064:       e3a01000        mov     r1, #0
    8068:       e5801044        str     r1, [r0, #68]   ; 0x44
    806c:       e3a01003        mov     r1, #3
    8070:       e580104c        str     r1, [r0, #76]   ; 0x4c
    8074:       e3a01000        mov     r1, #0
    8078:       e5801050        str     r1, [r0, #80]   ; 0x50
    807c:       e59f1014        ldr     r1, [pc, #20]   ; 8098 <init+0x8c>
    8080:       e5801068        str     r1, [r0, #104]  ; 0x68
    8084:       e3a01003        mov     r1, #3
    8088:       e5801060        str     r1, [r0, #96]   ; 0x60
    808c:       ea000002        b       809c <after>
    8090:       20200000        eorcs   r0, r0, r0
    8094:       20215000        eorcs   r5, r1, r0
    8098:       0000010e        andeq   r0, r0, lr, lsl #2

0000809c <after>:
    809c:       e320f000        nop     {0}

000080a0 <loop>:
    80a0:       e59f2038        ldr     r2, [pc, #56]   ; 80e0 <loop2+0x18>
    80a4:       e59f3038        ldr     r3, [pc, #56]   ; 80e4 <loop2+0x1c>

000080a8 <loop1>:
    80a8:       e5d21000        ldrb    r1, [r2]
    80ac:       eb00000d        bl      80e8 <send>
    80b0:       eb00001c        bl      8128 <delay>
    80b4:       e2822001        add     r2, r2, #1
    80b8:       e1520003        cmp     r2, r3
    80bc:       bafffff9        blt     80a8 <loop1>
    80c0:       e3a0100d        mov     r1, #13
    80c4:       eb000007        bl      80e8 <send>

000080c8 <loop2>:
    80c8:       eb00000d        bl      8104 <recv>
    80cc:       e351000d        cmp     r1, #13
    80d0:       1afffffc        bne     80c8 <loop2>
    80d4:       e3a0100a        mov     r1, #10
    80d8:       eb000002        bl      80e8 <send>
    80dc:       eaffffef        b       80a0 <loop>
    80e0:       00018144        andeq   r8, r1, r4, asr #2
    80e4:       0001815c        andeq   r8, r1, ip, asr r1

000080e8 <send>:
    80e8:       e52de004        push    {lr}            ; (str lr, [sp, #-4]!)
    80ec:       e5801040        str     r1, [r0, #64]   ; 0x40

000080f0 <send1>:
    80f0:       e5906054        ldr     r6, [r0, #84]   ; 0x54
    80f4:       e3160020        tst     r6, #32
    80f8:       0afffffc        beq     80f0 <send1>
    80fc:       e49de004        pop     {lr}            ; (ldr lr, [sp], #4)
    8100:       e12fff1e        bx      lr

00008104 <recv>:
    8104:       e92d4004        push    {r2, lr}

00008108 <recv1>:
    8108:       e5902054        ldr     r2, [r0, #84]   ; 0x54
    810c:       e3120001        tst     r2, #1
    8110:       0afffffc        beq     8108 <recv1>
    8114:       e5901040        ldr     r1, [r0, #64]   ; 0x40
    8118:       e20110ff        and     r1, r1, #255    ; 0xff
    811c:       ebfffff1        bl      80e8 <send>
    8120:       e8bd4004        pop     {r2, lr}
    8124:       e12fff1e        bx      lr

00008128 <delay>:
    8128:       e52de004        push    {lr}            ; (str lr, [sp, #-4]!)
    812c:       e3a06601        mov     r6, #1048576    ; 0x100000

00008130 <delay1>:
    8130:       e2466001        sub     r6, r6, #1
    8134:       e3560000        cmp     r6, #0
    8138:       cafffffc        bgt     8130 <delay1>
    813c:       e49de004        pop     {lr}            ; (ldr lr, [sp], #4)
    8140:       e12fff1e        bx      lr

Disassembly of section .data:

00018144 <__data_start>:
   18144:       203c3c3c        eorscs  r3, ip, ip, lsr ip
   18148:       6c6c6548        cfstr64vs       mvdx6, [ip], #-288      ; 0xfffffee0
   1814c:       6854206f        ldmdavs r4, {r0, r1, r2, r3, r5, r6, sp}^
   18150:       6f572065        svcvs   0x00572065
   18154:       21646c72        smccs   18114   ; 0x46c2
   18158:       3e3e3e20        cdpcc   14, 3, cr3, cr14, cr0, {1}

Disassembly of section .ARM.attributes:

00000000 <.ARM.attributes>:
   0:   00002841        andeq   r2, r0, r1, asr #16
   4:   61656100        cmnvs   r5, r0, lsl #2
   8:   01006962        tsteq   r0, r2, ror #18
   c:   0000001e        andeq   r0, r0, lr, lsl r0
  10:   726f4305        rsbvc   r4, pc, #335544320      ; 0x14000000
  14:   2d786574        cfldr64cs       mvdx6, [r8, #-464]!     ; 0xfffffe30
  18:   06003741        streq   r3, [r0], -r1, asr #14
  1c:   0841070a        stmdaeq r1, {r1, r3, r8, r9, sl}^
  20:   2a020901        bcs     8242c <_stack+0x242c>
  24:   44022c01        strmi   r2, [r2], #-3073        ; 0xfffff3ff
  28:   Address 0x00000028 is out of bounds.

>

L'adresse d'implantation de la section .text est 0x008000.
L'adresse de la section .data est 0x018444. Pourquoi cette adresse ?

Si une âme charitable peut m'expliquer ce que je dois mettre dans le fichier linker.ld pour :
--> réduire mon programme à sa plus juste utilité.
--> implanter chaque section au bonne endroit.
--> et faire en sorte que tout fonctionne normalement.

Merci :D
@+

10/02/2021, 01h19
Artemus24

Salut à tous.

C'est beaucoup plus simple que je ne le croyais.
Je fais commencer mon linker.ld à partir de l'adresse 0x8000 (ORIGIN).

Par contre, je ne sais pas à quoi correspond cette adresse. :(

@+
10/02/2021, 14h21
vincent Boulou

Bonjour.
Même si vous programmez en assembleur en bare métal, il n'est pas conseillé de commencer les instructions à l'adresse 0 car plusieurs des adresses sont réservées au processeur lui même pour gérer les vecteurs d'interruption. Je suspecte aussi le bootloader (dont nous de pouvons prendre la main)de mettre plein de choses dans les adresses basses de la mémoire.
L'adresse de la section data est située à la fin de votre code (d'après votre exemple du linker) dont la taille est 0x18444 - 0x8000 = 0x10444 octets.
Mais vous pouvez indiquer au linker une autre adresse par exemple 0X20000 pour la section data.
Une remarque sur votre codage d'une chaine qui me semble compliquée. Vous pouvez utiliser simplement l'instruction .asciz qui ajoute automatiquement un zéro à la fin.
exemple : szChaine : .asciz "Bonjour Developpez.com"

Bon courage.
10/02/2021, 23h43
Artemus24

1 pièce(s) jointe(s)

Salut Vincent.

Vois ici ? As tu déserté le forum framboise314 ?

Le désassemblage du kernel.elf (mon programme) donne comme adresse d'implantation de la section ".text" en 0x8000 et de la section ".data" en 0x018144.
Ce ne sont pas mes adresses à moi, mais ceux de l'éditeur de liens par défaut.

Je me pose la question de l'adresse de l'implantation de la section ".data", car elle contient l'adresse de la fin de la section ".text" (0x8144) + 0x010000.
Pourquoi laisser un trou de 0x010000 ? Peu importe.

Ma principale question est pourquoi implanter le programme à l'adresse 0x8000 ? A quoi correspond cette adresse ?

Sachant que j'utilise la raspberry PI zero W, la taille de RAM est seulement de 512 Mo.
Le processeur broadcom BCM2835 a un adressage sur 32 bits, soit de 0x00000000 jusqu'à 0xFFFFFFFF.
Ou commence l'adressage de la RAM, sachant que sa taille est de 0x20000000 ?

Dans le forum raspberry314, tu te posais la question de l'[usl=https://forums.framboise314.fr/viewtopic.php?t=4229]Adresses memoire du Raspberry[/url] :

Citation:

Or je suis étonné par les résultats : l'adresse de la pile se situe en BE904358 ce qui est au délà de la taille mémoire de mon raspberry. D'autre part le compteur d'instructions est dans les 1000h ce qui fait dans les 64K décimal, et cela me parait faible compte tenu de la taille du noyau Linux.

Après avoir mis mon nez dans la documentation du broadcom BCM2835, il faut distinguer les adresses physiques, des adresses virtuelles.

Voici la présentation de la mémoire du broadcom BCM2835 :

Pièce jointe 590677

Pour les périphériques, l'adressage va de 0x20000000 jusqu'à 0x20FFFFFF. Le bus gère ces mêmes adresses à partir de 0x7E000000 jusqu'à 0x7EFFFFFF.
Dans la documentation, quand je lis une adresse 0x7Exxxxxx, je la transcris en 0x20xxxxxx dans mes programmes.
Donc, je ne peux pas implanter mon programme et quoi que ce soit d'autre à l'adresse 0x20000000.

Dans un premier temps, j'ai implanté mon programme en 0x00000000. J'ai pu le faire exécuter sans problème.
Mais je n'avais pas accès à la section ".data" car tout ce que j'y mettais, ne s'y retrouvait pas. D'où mon sujet !

Après quelques exemples sur google j'ai compris que l'adresse d'implantation est plutôt 0x8000.
Sauf que je ne sais pas à quoi cela correspond.
Dois-je comprendre qu'avant cette adresse, c'est réservé au système ?
Et que la ram va donc de l'adresse 0x000000 jusqu'à 0x1FFFFFFF.

En gros, je me pose des questions et je ne sais quoi en penser.

@+
11/02/2021, 19h23
vincent Boulou

Bonsoir.
Comme nous ne sommes pas nombreux à pratiquer l'assembleur ARM sur raspberry, je me balade sur tous les forums qui concerne cette spécialité.

Quand au pourquoi de l'adresse 0x8000 pour commencer un de nos programmes, c'est un mystère !!
De nombreux exemples en anglais montent l'utilisation de cette adresse mais sans trop d'explication.
On va dire qu'elle est réservée au système !!
11/02/2021, 19h24
vincent Boulou

Pardon, je voulais dire que toute la place mémoire avant cette adresse est réservée au système.
Mais si tu trouve mieux comme explication je suis preneur.
11/02/2021, 21h23
Artemus24

Salut Vincent.

Il ne faut pas oublier que sur la carte micro SD, j'installe :
--> bootcode.bin
--> fixup.dat
--> start.elf

ainsi que mon programme :
--> kernel.img

Ce que tu nommes système, ce sont ces trois premiers fichiers ci-dessus qui sont installés dans la RAM.

@+
12/02/2021, 14h27
vincent Boulou

Salut.
Non je ne pense pas que ces 3 fichiers soient installés dans la Ram standard mais plutôt dans la mémoire réservée au GPU.
D'après les étapes de démarrage, ces fichiers sont chargés et exécutés par le GPU pour l'initialisation avant toute chose puis ne servent plus.
Pour l'adresse 0x8000, c'est soit disant l'adresse de démarrage standard de Linux. Même si tu n'installe pas Linux, le bootloader t'oblige à mettre le début de ton programme à cette adresse.
D'après les nombreuses discussions du post : https://www.raspberrypi.org/forums/viewtopic.php?t=6685 tu dois pouvoir utiliser la zone entre 0X4000 et 0X8000 en toute sécurité si tu ne charges pas Linux. A tenter pour stocker des tables en utilisant un pointeur qui commence à 0X4000.
Cdlt.
12/02/2021, 16h59
Artemus24

Salut Vincent.

Je n'ai aucune préférence en ce qui concerne l'implantation de l'adresse du kernel.img.
Ou plus précisément, j'aimerai connaitre les adresses d'implantations dont je suis autorisées.

J'ai un réponse partielle à ce lien.
Au paragraphe "kernel_address", il est dit :

Citation:

kernel_address is the memory address to which the kernel image should be loaded. 32-bit kernels are loaded to address 0x8000 by default, and 64-bit kernels to address 0x80000. If kernel_old is set, kernels are loaded to the address 0x0.

Soit en français :

Citation:

kernel_addressest l'adresse mémoire à laquelle l'image du noyau doit être chargée. Les noyaux 32 bits sont chargés à l'adresse 0x8000par défaut et les noyaux 64 bits à l'adresse 0x80000. Si kernel_oldest défini, les noyaux sont chargés à l'adresse 0x0.

Pour charger à l'adresse 0x00, je dois m'adjoindre le fichier config.txt avec le paramètre :

Code:

kernel_old = 1

@+