Wiso liegen die Sektionen nicht da wo sie sollen ??? =)



  • Hi,

    hab wohl ein Verständnisproblem.
    Und zwar habe ich ein Linkerfile, in welchem ich zum Beispiel
    die Textsektion definiert habe:

    SECTIONS
    {
        /*
         * . ist die aktuelle Position in der Datei. Wir wollen den Kernel wie gehabt
         * an 1 MB laden, also muessen wir dort die erste Sektion hinlegen
         */
        /*. = 0x100000;*/
    	. = 0x100000;
    
        /*
         * Der Multiboot-Header muss zuerst kommen (in den ersten 8 kB).
         * Die Standardsektionen einfach hintereinander weg einbinden.
         */
        .text : {
            *(multiboot)
            *(.text)
    		*(.gnu.linkonce.t*)
        } 
        .data ALIGN(4096) : {
            *(.data)
    		*(.gnu.linkonce.d*)
        } 
    	/*
    	* gcc macht Strings und Constanten in eine extra Sektion. 
    	* Diese nennt sich rodata
    	*/
        .rodata ALIGN(4096) : {
            *(.rodata)
    		*(.gnu.linkonce.r*)
        } 
        .bss ALIGN(4096) : {
            *(.bss)
    		*(.gnu.linkonce.b*)
        } 
    }
    

    Wenn ich baue, und dann
    objdump -D file

    dann bekomme ich:

    Disassembly of section .rdata:
    
    00100000 <.rdata>:
      100000:	48                   	dec    %eax
      100001:	65                   	gs
      100002:	6c                   	insb   (%dx),%es:(%edi)
      100003:	6c                   	insb   (%dx),%es:(%edi)
      100004:	6f                   	outsl  %ds:(%esi),(%dx)
      100005:	20 57 6f             	and    %dl,0x6f(%edi)
      100008:	72 6c                	jb     100076 <.rdata+0x76>
      10000a:	64 21 00             	and    %eax,%fs:(%eax)
      10000d:	00 00                	add    %al,(%eax)
    	...
    

    ??? Da sollte doch .text stehen ???

    Disassembly of section .text:
    
    00101044 <init>:
      101044:	55                   	push   %ebp
      101045:	89 e5                	mov    %esp,%ebp
      101047:	57                   	push   %edi
      101048:	56                   	push   %esi
      101049:	53                   	push   %ebx
      10104a:	83 ec 20             	sub    $0x20,%esp
      10104d:	8d 55 db             	lea    -0x25(%ebp),%edx
      101050:	bb 00 00 10 00       	mov    $0x100000,%ebx
      101055:	b8 0d 00 00 00       	mov    $0xd,%eax
      10105a:	89 d7                	mov    %edx,%edi
      10105c:	89 de                	mov    %ebx,%esi
      10105e:	89 c1                	mov    %eax,%ecx
      101060:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)
      101062:	c7 45 ec 00 80 0b 00 	movl   $0xb8000,-0x14(%ebp)
      101069:	c7 45 f0 00 00 00 00 	movl   $0x0,-0x10(%ebp)
      101070:	eb 2b                	jmp    10109d <init+0x59>
      101072:	c7 45 e8 0a 00 00 00 	movl   $0xa,-0x18(%ebp)
      101079:	ff 45 e8             	incl   -0x18(%ebp)
      10107c:	8b 45 f0             	mov    -0x10(%ebp),%eax
      10107f:	d1 e0                	shl    %eax
      101081:	03 45 ec             	add    -0x14(%ebp),%eax
      101084:	8d 55 db             	lea    -0x25(%ebp),%edx
      101087:	03 55 f0             	add    -0x10(%ebp),%edx
      10108a:	8a 12                	mov    (%edx),%dl
      10108c:	88 10                	mov    %dl,(%eax)
      10108e:	8b 45 f0             	mov    -0x10(%ebp),%eax
      101091:	d1 e0                	shl    %eax
      101093:	40                   	inc    %eax
      101094:	03 45 ec             	add    -0x14(%ebp),%eax
      101097:	c6 00 07             	movb   $0x7,(%eax)
      10109a:	ff 45 f0             	incl   -0x10(%ebp)
      10109d:	8d 45 db             	lea    -0x25(%ebp),%eax
      1010a0:	03 45 f0             	add    -0x10(%ebp),%eax
      1010a3:	8a 00                	mov    (%eax),%al
      1010a5:	84 c0                	test   %al,%al
      1010a7:	75 c9                	jne    101072 <init+0x2e>
      1010a9:	83 c4 20             	add    $0x20,%esp
      1010ac:	5b                   	pop    %ebx
      1010ad:	5e                   	pop    %esi
      1010ae:	5f                   	pop    %edi
      1010af:	5d                   	pop    %ebp
      1010b0:	c3                   	ret    
      1010b1:	90                   	nop
      1010b2:	90                   	nop
      1010b3:	90                   	nop
    
    001010b4 <.text>:
      1010b4:	02 b0 ad 1b 00 00    	add    0x1bad(%eax),%dh
      1010ba:	00 00                	add    %al,(%eax)
      1010bc:	fe 4f 52             	decb   0x52(%edi)
      1010bf:	e4 bc                	in     $0xbc,%al
    
    001010c0 <_start>:
      1010c0:	bc 00 40 10 00       	mov    $0x104000,%esp
      1010c5:	e8 7a ff ff ff       	call   101044 <init>
    
    001010ca <_stop>:
      1010ca:	fa                   	cli    
      1010cb:	f4                   	hlt    
      1010cc:	eb fc                	jmp    1010ca <_stop>
      1010ce:	90                   	nop
      1010cf:	90                   	nop
    
    Disassembly of section .bss:
    
    00102000 <.bss>:
    	...
    

    Wiso ist unter Disassembly von section .text plötzlich
    .init ??

    Gibt es ein gutes tutorial welche man mir empfehlen kann welche diese Wissenslücken schließen ??

    Was mich auch draus bringt... wiso gibt es, wenn ich mein
    fertiges ELF File mit einem Hexeditor öffne keine Addresse 0x100000 ???
    Das Dingens geht nur bis 0x19C0

    Beste Grüße
    Alex



  • Womit und wie compilierst du denn? Laut http://wiki.osdev.org/Beginner_Mistakes#Strings gibt es rdata statt rodata nur dann, wenn du MingW oder ähnliches verwendest und ebend kein ELF binary baust.

    Gezielt ein Tutorial kann ich dir nicht vorschlagen. Aber wie oben genannt das osdev.org Wiki oder auch das auf http://www.lowlevel.eu/ haben ganz gute Artikel zu Themen wie Bootvorgang etc. Muss man sich nur manchmal etwas zusammensuchen.

    AlexanderKiebler schrieb:

    Was mich auch draus bringt... wiso gibt es, wenn ich mein
    fertiges ELF File mit einem Hexeditor öffne keine Addresse 0x100000 ???
    Das Dingens geht nur bis 0x19C0

    Weil das Verschwendung wäre. Was wäre, wenn du deinen Code z.B. bei 2gb ablegen willst. Sollte die Executable dann 2gb groß sein?

    Die Adressen, die du angibst, stehen nur in der Beschreibung der Sections. Der Bootloader (oder dein OS) lesen die Sectionbeschreibung und sorgen dafür das die jeweiligen Teile an die richtigen Stellen geladen werden. Deswegen ist es auch wichtig, dass du ein ELF binary erzeugst, wenn es so erwartet wird.



  • Hi Tobi,

    ja Du hast Recht, habe es gerade entdeckt.
    Habs umgestellt und arbeite jetzt mit dem Corsscompiler.

    Habe mir gerade auch noch ein PDF über das ELF format "Durchgelesen" (überfolgen eher)... Die erklärung bezüglich der Dateigröße ist sehr einleuchtend, und ergibt dann auch mit dem PDF sehr viel Sinn...

    Wenn ich wieder FOlgendes eingebe
    objdump -D file

    Disassembly of section .text:
    
    00100000 <init>:
      100000:	55                   	push   %ebp
      100001:	89 e5                	mov    %esp,%ebp
      100003:	83 ec 20             	sub    $0x20,%esp
      100006:	c7 45 e7 48 65 6c 6c 	movl   $0x6c6c6548,-0x19(%ebp)
      10000d:	c7 45 eb 6f 20 57 6f 	movl   $0x6f57206f,-0x15(%ebp)
      100014:	c7 45 ef 72 6c 64 21 	movl   $0x21646c72,-0x11(%ebp)
      10001b:	c6 45 f3 00          	movb   $0x0,-0xd(%ebp)
      10001f:	c7 45 f8 00 80 0b 00 	movl   $0xb8000,-0x8(%ebp)
      100026:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
      10002d:	eb 2a                	jmp    100059 <init+0x59>
      10002f:	c7 45 fc 0a 00 00 00 	movl   $0xa,-0x4(%ebp)
      100036:	ff 45 fc             	incl   -0x4(%ebp)
      100039:	8b 45 f4             	mov    -0xc(%ebp),%eax
      10003c:	01 c0                	add    %eax,%eax
      10003e:	03 45 f8             	add    -0x8(%ebp),%eax
      100041:	8b 55 f4             	mov    -0xc(%ebp),%edx
      100044:	8a 54 15 e7          	mov    -0x19(%ebp,%edx,1),%dl
      100048:	88 10                	mov    %dl,(%eax)
      10004a:	8b 45 f4             	mov    -0xc(%ebp),%eax
      10004d:	01 c0                	add    %eax,%eax
      10004f:	40                   	inc    %eax
      100050:	03 45 f8             	add    -0x8(%ebp),%eax
      100053:	c6 00 07             	movb   $0x7,(%eax)
      100056:	ff 45 f4             	incl   -0xc(%ebp)
      100059:	8b 45 f4             	mov    -0xc(%ebp),%eax
      10005c:	8a 44 05 e7          	mov    -0x19(%ebp,%eax,1),%al
      100060:	84 c0                	test   %al,%al
      100062:	75 cb                	jne    10002f <init+0x2f>
      100064:	c9                   	leave  
      100065:	c3                   	ret    
      100066:	00 00                	add    %al,(%eax)
      100068:	02 b0 ad 1b 00 00    	add    0x1bad(%eax),%dh
      10006e:	00 00                	add    %al,(%eax)
      100070:	fe 4f 52             	decb   0x52(%edi)
      100073:	e4 bc                	in     $0xbc,%al
    
    00100074 <_start>:
      100074:	bc 00 30 10 00       	mov    $0x103000,%esp
      100079:	e8 82 ff ff ff       	call   100000 <init>
    ...
    

    heißt dass:
    1.) Das ausgegebene von objedump ist die .text section.
    (Also objdump hat aus dem ELF file sowas ähnliches gebaut wie es der bootloader machen würde ??
    2.) In der .text sektion stehen die funktionen init und _start ??

    Gruß Alex



  • AlexanderKiebler schrieb:

    objdump -D file

    Mhh, warum objdump?

    objdump versucht auch, die data-section zu disassemblieren, obwohl in der data-sections garkeine opcodes sind 🙄

    such dir nen gescheiten disassembler. vielleicht liegts daran.



  • AlexanderKiebler schrieb:

    1.) Das ausgegebene von objedump ist die .text section.
    (Also objdump hat aus dem ELF file sowas ähnliches gebaut wie es der bootloader machen würde ??

    Objdump liest dein ELF binary zumindest so ein, wie es der Bootloader auch tun würde. Allerdings gibt Objdump dir nur die Informationen aus, während der Bootloader diese Informationen nutzt um die Sections an die gewünschten Stellen im Speicher bzw. Adressraum zu laden.

    AlexanderKiebler schrieb:

    2.) In der .text sektion stehen die funktionen init und _start ??

    Genau, in der .text Section steht der Code deiner Funktionen. Wie im Linkerfile angegeben wird da auch angezeigt das dieser bei der Adresse 0x100000 beginnt.



  • Okay, super...
    Gibt es Spezifikationen, oder Schubladen für Sektionen ??
    Oder ist das von Compiler-Linker zu Compiler-Linker pärchen unterschiedlich ??

    Es gibt ja das DS Register und das CS Register. Dann zeigt das CS Register auf .text und das DS Register auf .data ??
    Also werden meine .data einfach ans Codesegment hinten dran gehängt ??



  • Okay, die Frage hat sich erledigt,
    CS und DS sind vom Bootloader (bei mir GRUB) bereits initialisiert:
    Und zwar nach der Multiboot Spezi:
    Ein Codesegment mit der Basisadresse 0 und der Größe 0xFFFFFFFF
    Ein Datensegment mit der Basisaddresse 0 und der Größe 0xFFFFFFFF


Log in to reply