Nachrichten

21

Lowlevel-Coding / Re: Laufwerkbezeichnungen patentiert?

« am: 26. December 2006, 19:34 »

Da fällt mir gerade ein, ich glaube mal gehört zu haben, dass der Doppelklick (Maus) auch von M$ patentiert ist.

^^

bitmaster

ja, stimmt.
Angeblich hätte übrigens MS das Patent auf eine benutzerfreundliche GUI verletzte, bzw. die Idee von jemanden anders geklaut.

An sich sind Software Patente ein Schwachsinn.
Würden die Patenteinhaber ihre Rechte ausüben, gäbe es keine Hobbycoder merh, bzw. wäre Hobby coden strafbar..
Oder man baut sein OS so, dass man anstatt eines Doppelklicks einfach 3 mal klicken muss 

22

OS-Design / Re: Schwieriges System^^

« am: 27. October 2006, 15:03 »

Also ich seh auf die schnelle nur, dass du dem INT13h nirgends die offsetadresse übergibst.
Kann aber auch sein, dass ich das irgendwo übersehen hab 
Die offsetadresse müsst in BX übergeben werden, wenn ich mich noch recht erinnere?

Code: [Auswählen]

ReadSector:
pusha
mov bp, 4

ReadSector_loop:
xor dx, dx
div word [SecPerTrack]
inc dl
mov cl, dl
xor dx, dx
div word [NumHeads]
mov dh, dl
mov ch, al
mov dl, [DrvNum]
mov al, 1
mov ah, 2
int 0x13
jnc ReadOk
dec bp
jz ReadError
jmp ReadSector_loop

ReadOk:
popa
ret




23

OS-Design / Re: OS schon wieder

« am: 17. October 2006, 19:55 »

Kauf dir beide.
Das eine Buch gibt dir den Einstieg, also Grundlagen etc.. und das andere Buch ist nur eine ziemlich umfassende referenz.
Die wirst du früher oder später auch brauchen.
Kostet 15 Euro (die Referenz) und du hast ne MENGE Inhalt.

Achso, und such mal im Internet nach der "Ralph Brown Interrupt List".
Doie wirt du später sicher auch mal brauchen.
Hab grad den Link nicht zur Hand.

24

Offtopic / Re: Hosen runter! Zeigt eure OS ;)

« am: 06. October 2006, 20:44 »

Ich hab leider keinen 64 Bit CPU
Wirst du überhaupt keine Version für 32 Bit mehr rausbringen?

naja, wenn ich nur mal wieder Zeit hätte für mein OS 

25

Offtopic / Re: Hosen runter! Zeigt eure OS ;)

« am: 06. October 2006, 15:37 »

Geile GUI

Davon bin ich meilenweit entfernt 

26

Lowlevel-Coding / Speicherbereich über 1MB

« am: 20. September 2006, 14:52 »

2. Ka was du damit meinst. Aber die Register FS / GS dürfen nicht verändert werden, da sie ansonsten wieder mit der 1MiB Begränzung arbeiten.

Damit mein ich, dass ich z.b. mit folgendem Code auf den speicher zugreifen kann

Code: [Auswählen]


mov [0a00h:102h], BYTE "a"


als auch mittels FS und GS so auf den Speicher zugreifen kann:

Code: [Auswählen]


mov [fs:0fffffh], BYTE "a"


Naja, auch egal

3. Normalerweise geht der Bootloader nach dem Laden selber in den PM und springt dann zum Kernel. Der Kernel muss den PM also nicht mehr selber einschalten. Ich glaube GRUB bietet das auch an.

Ich will ja das BiehlOS komplett im FRM laufen lassen.
Deshalb die Frage, wie ich dann dorthin springen könnte.

27

Lowlevel-Coding / Speicherbereich über 1MB

« am: 19. September 2006, 16:10 »

Hat leider nix gebracht.
Egal.
Ich hab jetzt einen Code, der scheint zu funktionieren:

Code: [Auswählen]


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Enable "unreal" mode
; This code is public domain (no copyright).
; You can do whatever you want with it.
;
; Unreal mode is identical with real mode with one exception: 32-bit
; addresses are allowed (they do not cause INT 0Dh, as they do in real mode)
;
; This code will fail if run in virtual 8086 mode (Windows DOS box
; or EMM386 loaded). Oh yeah, a 32-bit CPU is required (386+)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; we're in real mode
use16
DATA_SEL equ 8

jmp 07c0h:start
start:
mov ax, cs
mov ds, ax
mov es, ax

        ; ...

push ds
push es
                xor eax,eax     ; point gdt_ptr to gdt
mov ax,ds
shl eax,4
                add eax,gdt     ; EAX=linear address of gdt
                mov [gdt_ptr + 2],eax
                cli             ; interrupts off
                lgdt [gdt_ptr]
mov eax,cr0
or al,1
                mov cr0,eax     ; partial switch to 32-bit pmode
                mov bx,DATA_SEL ; selector to segment w/ 4G limit
mov fs,bx
                mov gs,bx       ; set seg limits in descriptor caches
dec al
                mov cr0,eax     ; back to (un)real mode
        pop es                  ; segment regs back to old values,
        pop ds                  ; but now 32-bit addresses are OK

        ; ...
mov ds, bx
mov ah, 0eh
mov al, "k"
int 10h

        mov     edi,0B8000h     ; point to screen
        mov     cx,160          ; just two lines
        mov     ah,1Eh          ; yellow on blue screen attrib
mov al, 1


loops:
mov [gs:edi], AX
inc ax
inc edi
loop loops
jmp $


gdt:    dw 0                    ; limit 15:0
        dw 0                    ; base 15:0
        db 0                    ; base 23:16
        db 0                    ; access byte (descriptor type)
        db 0                    ; limit 19:16, flags
        db 0                    ; base 31:24
DATA_SEL        equ     $-gdt
dw 0FFFFh
dw 0
db 0
        db 92h          ; present, ring 0, data, expand-up, writable
db 0CFh ; page-granular, 32-bit
db 0
gdt_end:

gdt_ptr:
        dw gdt_end - gdt - 1    ; GDT limit
        dd 0                    ; linear adr of GDT (set above)

db 510-$ dup(0)
dw 0aa55h


Bochs sagt dazu:

00034788000p[WGUI ] >>PANIC<< POWER button turned off.
00034788000i[SYS  ] Last time is 1158674124
00034788000i[CPU0 ] real mode
00034788000i[CPU0 ] CS.d_b = 16 bit
00034788000i[CPU0 ] SS.d_b = 16 bit
00034788000i[CPU0 ] | EAX=00001ea1  EBX=00000008  ECX=000f0000  EDX=00000000
00034788000i[CPU0 ] | ESP=0000fffe  EBP=00000000  ESI=0000733c  EDI=000b80a0
00034788000i[CPU0 ] | IOPL=0 NV UP DI PL NZ AC PE NC
00034788000i[CPU0 ] | SEG selector     base    limit G D
00034788000i[CPU0 ] | SEG sltr(index|ti|rpl)     base    limit G D
00034788000i[CPU0 ] |  CS:07c0( 0000| 0|  0) 00007c00 0000ffff 0 0
00034788000i[CPU0 ] |  DS:0008( 0000| 0|  0) 00000080 0000ffff 0 0
00034788000i[CPU0 ] |  SS:0000( 0000| 0|  0) 00000000 0000ffff 0 0
00034788000i[CPU0 ] |  ES:07c0( 0000| 0|  0) 00007c00 0000ffff 0 0
00034788000i[CPU0 ] |  FS:0008( 0001| 0|  0) 00000000 000fffff 1 1
00034788000i[CPU0 ] |  GS:0008( 0001| 0|  0) 00000000 000fffff 1 1
00034788000i[CPU0 ] | EIP=00000058 (00000058)
00034788000i[CPU0 ] | CR0=0x00000010 CR1=0 CR2=0x00000000
00034788000i[CPU0 ] | CR3=0x00000000 CR4=0x00000000
00034788000i[     ] restoring default signal behavior
00034788000i[CTRL ] quit_sim called with exit code 1

Müsste also alles glatt laufen.

Allerdings einige Fragen:

1. CS steht ja weiterhin auf 07c0h.
AUf den Speicher über 1 MB kann ich jetzt nur mittels FS und GS zUgreifen.
Wenn ich jetzt aber z.b. irgendwelche Daten mit CS addressiere?
Z.B.: MOV AX; [CS:0B8000H]
Dann tritt wohl ein ganz normaler Fehler auf (Speicherzugriffsfehler o.ä.)?

2. Ich kann also sowohl mit dem ganz normalen Segmentregister Zeugs auf den 1MB Speicher zugreifen, als auch mit dem Selektor auf den Teil über 1MB?
Der User (auch Anwendugsprogrammierer) merkt also praktisch nix davon?

3. Kann ich auch Programme in dem Speicher ausführen?
Weil:
CS steht ja weiterhon auf 07c0h.
Wenn ich nun den Kernel an z.b. 0x20000 lade, wie kann ich diesen anspringen?

4. Angenommen ich will jetzt mit dem INT13H einen Sektor über die 1MB hinaus kopieren.
Mit dem BIOS INT dürfte das ja wohgl nicht gehen?
Ich müsste wohl zuerst den Sektor in das untere MB laden und anschliesend die 512Byte irgendwo über die 1MB hinaus kopieren?

Ich weis, dass all dies eigentlich Fragen sind, die ich durch Ausprobieren selber rausfinden könnte, aber ich bin, wies leider so ist, zu faul  
Ich denke, das kennt ihr auch und hoffe, ihr helft mir trotzdem.

28

Lowlevel-Coding / Speicherbereich über 1MB

« am: 18. September 2006, 16:46 »

Mist, ich benutze FS und GS zum temporären Zwischenspeichern von Daten
Naja, aber kein Problem, das nicht lösbar wäre

Ich glaube jetzt wenigstens zu wissen, woran es liegt, dass ein Fehler ausgelöst wird.
Und zwar habe ich mal ein paar JMP $ gesetzt.

z.b. Hier:

Code: [Auswählen]



org 07c0h

;sw_to_pm macro

    mov ax, cs
    mov [cs:rmseg], ax ;sprung adresse berechnen
    and eax, 0ffffh
    shl eax, 4

    mov [cs:basis15], ax
    mov ebx, eax
    shr ebx, 16
    mov [cs:basis23], bl

    add eax, ptr cs:GDT_start ;GDT adresse berechnen
    mov [cs:gdt_DADR], eax
    lgdt [cs:gdt_adr]
    CLI ; intterupts sperren
    mov eax, cr0 ; in den pm wechseln
    or eax, 1
    mov cr0, eax

---> jmp $
    db 0eah ; sprung um schlange zu lerren
    dw pm
    dw 8



Und siehe da: Bochs zeigt ganz brav an:

00048740000i[SYS  ] Last time is 1158590493
00048740000i[CPU0 ] protected mode
00048740000i[CPU0 ] CS.d_b = 16 bit
00048740000i[CPU0 ] SS.d_b = 16 bit

OK.
Dann setze ich ein weiteres JMP $ (beim Label 'pm'):

Code: [Auswählen]



org 07c0h

;sw_to_pm macro

    mov ax, cs
    mov [cs:rmseg], ax ;sprung adresse berechnen
    and eax, 0ffffh
    shl eax, 4

    mov [cs:basis15], ax
    mov ebx, eax
    shr ebx, 16
    mov [cs:basis23], bl

    add eax, ptr cs:GDT_start ;GDT adresse berechnen
    mov [cs:gdt_DADR], eax
    lgdt [cs:gdt_adr]
    CLI ; intterupts sperren
    mov eax, cr0 ; in den pm wechseln
    or eax, 1
    mov cr0, eax

    db 0eah ; sprung um schlange zu lerren
    dw pm
    dw 8

gdt_adr:

    dw 32

gdt_DADR dd 0

GDT_start:

; DUMMY DESKRIPTOR

    dw 0
    dw 0
    db 0
    db 0
    db 0
    db 0

; CS DESKRIPTOR

    dw 0ffffh

basis15 dw ?

basis23 db ?

    db 09ah
    db 00h
    db 0

; fs/gs DESHRIPTOR

    dw 0ffffh
    dw 1
    db 1
    db 092h
    db 11001111b
    db 0


pm:
--> jmp $
mov ax, 10h ; segmentregister fs und gs laden

    mov fs, ax
    mov gs, ax
    mov eax, cr0 ; zurück in den rm
    btr eax, 0
    mov cr0, eax
    db 0eah
    dw rm

rmseg: dw 0

rm: sti ; interupt wieder erlauben

 ;   endm

;mov ax, 0
;mov ds, ax
;mov [ds:0ffffffh], byte 56
;mov al, [ds:0ffffffh]
jmp $

db 510-($-7c0h) DUP(0)
dw 0aa55h


Das läuft jetzt wiederum nichtmehr.

00000776212e[CPU0 ] exception(): 3rd (13) exception with no resolution, shutdown status is 00h, resetting
00000776212i[SYS  ] bx_pc_system_c::Reset(SOFTWARE) called
00000776212i[APIC0] local apic in CPU apicid=00 initializing
00000780659i[BIOS ]  rombios.c,v 1.138.2.1 2005/07/06 19:30:36 vruppert Exp $
00001110062i[KBD  ] reset-disable command received
00001231775i[VBIOS]
VGABios $Id: vgabios.c,v 1.62 2005/07/02 18:39:43 vruppert Exp $

00001231846i[CLVGA] VBE known Display Interface b0c0
00001231878i[CLVGA] VBE known Display Interface b0c3
00001234803i[VBIOS] VBE Bios $Id: vbe.c,v 1.47 2005/05/24 16:50:50 vruppert Exp $
00001506756e[HD   ] device set to 0 which does not exist
00001507049e[HD   ] device set to 1 which does not exist
00001556224i[CPU0 ] -----------------------------------
00001556224i[CPU0 ] selector->index*8 + 7 = 15
00001556224i[CPU0 ] gdtr.limit = 0
00001556224i[CPU0 ] fetch_raw_descriptor: GDT: index > limit
00001556224i[CPU0 ] protected mode
00001556224i[CPU0 ] CS.d_b = 16 bit
00001556224i[CPU0 ] SS.d_b = 16 bit
00001556224i[CPU0 ] | EAX=00000011  EBX=00000000  ECX=00100001  EDX=00000000
00001556224i[CPU0 ] | ESP=0000fffe  EBP=00000000  ESI=0000733c  EDI=0000ffde
00001556224i[CPU0 ] | IOPL=0 NV UP DI PL NZ NA PE NC
00001556224i[CPU0 ] | SEG selector     base    limit G D
00001556224i[CPU0 ] | SEG sltr(index|ti|rpl)     base    limit G D
00001556224i[CPU0 ] |  CS:0000( 0000| 0|  0) 00000000 0000ffff 0 0
00001556224i[CPU0 ] |  DS:0000( 0000| 0|  0) 00000000 0000ffff 0 0
00001556224i[CPU0 ] |  SS:0000( 0000| 0|  0) 00000000 0000ffff 0 0
00001556224i[CPU0 ] |  ES:0000( 0000| 0|  0) 00000000 0000ffff 0 0
00001556224i[CPU0 ] |  FS:0000( 0000| 0|  0) 00000000 0000ffff 0 0
00001556224i[CPU0 ] |  GS:0000( 0000| 0|  0) 00000000 0000ffff 0 0
00001556224i[CPU0 ] | EIP=00007c41 (00007c3c)
00001556224i[CPU0 ] | CR0=0x00000011 CR1=0 CR2=0x00000000
00001556224i[CPU0 ] | CR3=0x00000000 CR4=0x00000000

Heißt rein theoretisch:
Es muss an folgender Codesequenz liegen:

Code: [Auswählen]


    db 0eah ; sprung um schlange zu lerren
    dw pm
    dw 8


Blos wie kann ich das nun lösen?

29

Lowlevel-Coding / Speicherbereich über 1MB

« am: 18. September 2006, 15:01 »

Hat keiner ne Ahnung?
Kann mir vielleicht jemand den Originalen Code durch nen geeigneten Assembler jagen und mir die Binärdatei schicken?
Das ich die nur noch in dem Bootloader aufrufen brauche?

30

Lowlevel-Coding / Speicherbereich über 1MB

« am: 16. September 2006, 13:43 »

naja, ich will jetzt nicht unbedingt meinen ganzen Code auf PM umstellen.
wenn alles ausnahmsweise schon mal richtig läuft
Mir ist schon klar, dass das eher ne äußerste Notlösung ist.



naja.
ich hoffe, der Threadersteller verzeiht mir, wenn ich seinen Thread weiter missbrauche

ich hab nun versucht, den Code ( http://de.wikipedia.org/wiki/Benutzer:INFNIC/Makro_um_FS_und_GS_auf_4_GB_zu_erh%C3%B6hen ) für den FASM umzuschreiben.

Das kam dabei raus:

Code: [Auswählen]



jmp 07c0h:start

start:

;sw_to_pm macro

    mov ax, cs
    mov [cs:rmseg], ax ;sprung adresse berechnen
    and eax, 0ffffh
    shl eax, 4

    mov [cs:basis15], ax
    mov ebx, eax
    shr ebx, 16
    mov [cs:basis23], bl

    add eax, ptr cs:GDT_start ;GDT adresse berechnen
    mov [cs:gdt_DADR], eax
    lgdt [cs:gdt_adr]
    CLI ; intterupts sperren
    mov eax, cr0 ; in den pm wechseln
    or eax, 1
    mov cr0, eax
    db 0eah ; sprung um schlange zu lerren
    dw (pm);(offset pm)
    dw 8

gdt_adr:

    dw 32

gdt_DADR dd 0

GDT_start:

; DUMMY DESKRIPTOR

    dw 0
    dw 0
    db 0
    db 0
    db 0
    db 0

; CS DESKRIPTOR

    dw 0ffffh

basis15 dw ?

basis23 db ?

    db 09ah
    db 00h
    db 0

; fs/gs DESHRIPTOR

    dw 0ffffh
    dw 1
    db 1
    db 092h
    db 11001111b
    db 0

pm: mov ax, 10h ; segmentregister fs und gs laden

    mov fs, ax
    mov gs, ax
    mov eax, cr0 ; zurück in den rm
    btr eax, 0
    mov cr0, eax
    db 0eah
    dw (rm)

rmseg: dw 0

rm: sti ; interupt wieder erlauben

 ;   endm

mov [cs:0ffffffh], byte 56
mov al, [cs:0ffffffh]
jmp $

db 510-$ DUP(0)
dw 0aa55h


Leider scheint das nicht zu funktionieren.
Wenn ich das unter Bochs teste, startet sich der Bootloader ständig neu.
Die Fehlermeldung dürfte folgende sein:

//edit:

00002336258e[CPU0 ] jump_protected: dpl > CPL
00002336258e[CPU0 ] exception(): 3rd (13) exception with no resolution, shutdown status is 00h, resetting

Wo liegt der Fehler?
Und mit welchem Assembler wurde der originalcode erstellt?
NASM brachte mir ne Menge Fehler, FASM sowieso.
Und TASM oder MASM bringen mir auch Fehlermeldungen, allerdings ziemlich unterschiedliche.

Und nehmen wir an, der Code würde funktionieren.
Und ich will auf den RAM zugreifen.
Dann muss ich in die Segmentregister ja trotzdem irgendeinen Wert laden, oder?

31

Lowlevel-Coding / Speicherbereich über 1MB

« am: 16. September 2006, 08:37 »

Das hab ich jetzt so spontan gefunden: http://de.wikipedia.org/wiki/Benutzer:INFNIC/Makro_um_FS_und_GS_auf_4_GB_zu_erh%C3%B6hen
Aber ich würde ehrlich gesagt nicht im Bootloader in den Unreal Mode wechseln, nur um später den Kernel dann doch im Pmode laufen zu lassen. Also wenn schon dann gleich in den Protected Mode.

THX.
Werd ich ausprobieren, sobald ich Zeit hab.
Ich hab eigentlich vor, das BiehlOS die ganze Zeit im Unreal Mode laufen zu lassen.
Im protected Mode müsste ich erstmal Treiber für alles mögliche schreiben.
Und so kann ich jetzt schon 4GB Speicher nutzen und dann nach und nach die BIOS INT's durch eigene Treiber ersetzen.

Ich hab mal irgendwas gelesen, dass der prozessor aus dem Unreal Mode zurück in den Real Mode springt, wenn man einen Befehl verwendet, wie Push oder Pop.
Stimmt das?
weil das wär dann irgendwie blöd

32

Lowlevel-Coding / Speicherbereich über 1MB

« am: 15. September 2006, 15:18 »

Für einen Bootloader ist der UnrealMode dabei eventuell etwas interessanter.

Ich hab mich schon oft um Infos für den Unreal Mode bemüht, auch ein paar Materialien dazzu gefunden.
Leider alls nur Englisch bzw. die Teile, die Deutsch waren, verlangten einiges an Wissen um den Protected Mode.
Kennst du einfach ein Stück Code, dass ich in den Bootloader einbauen kann und in den Protected Mode schaltet, benötigte Operationen macht und wieder in den RM schaltet?

Die Codebeispiele, die ich gefunden habe, waren nur dazu geeignet, um in DOS ausgeführt zu werden.
Jegliche Versuche, den Code umzuschreiben, um für mein OS kompatibel zu sein, schlugen fehl ( ), was auch daran lag, dass ich Probleme hatte, den ASM Code für den FASM umzuschreiben.

33

Das Wiki / Ausgabe 9 & Wiki!!

« am: 06. September 2006, 23:26 »

Kurz ne Frage zur Ausgabe 9:

Die "Max. Dateien gesamt" dürfte beim FAT32 doch auch bei ca. 2^32 liegen?

34

Das Wiki / Genuine Reihe - Beta Leser

« am: 04. September 2006, 21:24 »

Ich glaube auch kaum dass Du, Toaster, der größte OS-developer für alle Zeit sind wirst. Es mag schon sein dass Du dich gut auskennst, aber nicht das Du dich mit deiner Leistung an Programmierer wie John Fine, Mike Hibbert, Ralf Browm oder auch Linus Torvalds, um nur einige zu nennen, herantasten kannst

He! Du hast in deiner Liste meinen Namen vergesssen!
Das nehm ich dir jetzt aber übel *überschäum vor Selbstbewusstsein*    

35

Offtopic / Spammer immer blöder?

« am: 02. September 2006, 22:02 »

Ich krieg jeden Tag ca. 30 Spammails.
ca. 4/5 davon von meiner @biehler-josef.de Adresse.
Ist komisch. Die Spamerei ist auf einen Schlag losgegangen.

36

Das Wiki / Genuine Reihe - Beta Leser

« am: 28. August 2006, 20:45 »

wie, welche Fehlermeldung?
welche doc wolltest du dir downloaden?

Das Floppy Tut.

37

Das Wiki / Genuine Reihe - Beta Leser

« am: 28. August 2006, 11:45 »

Wenn ich die Tuts runterladen will, kommt nur eine Fehlermeldung:

Extern Linken -Filetype

Edit:
OK: Ich habs anders hinbekommen.

38

Offtopic / Buildnummer automatisch erhöhen / GUI im Real Mode

« am: 26. August 2006, 09:09 »

OK. Wer suchet, der findet.

Code: [Auswählen]


mov ax, 4f02h
mov bx, 100h
int 10h


39

Das Wiki / Genuine Reihe - Beta Leser

« am: 25. August 2006, 17:16 »

Und bei fs und gs, da heißt es sie haben keine Verwendung so wie CS oder SS.

Da steht (stand), dass man sie wenn möglich nicht verwenden sollte.
Und das ist im Real Mode ja völlig egal, da diese ja keine Bedeutung haben

Soll man Rechtschreibfehler auch melden?
Mir sind vor allem ein paar Groß- und Kleinschreibefehler aufgefallen.

40

Das Wiki / Genuine Reihe - Beta Leser

« am: 25. August 2006, 15:03 »

Now I habe the Rest gereadet.
Und that's mein piece of Kritik:

Der erste Prozessor der den Real Mode unterstützt ist der 8086er, der erste 16 Bit Prozessor
und der Urvater aller späteren Prozessoren.

<vermutung>
Könnte es eventuell nicht sein, dass der 8008er auch bereits den Real Mode verwendete?
</vermutung>

Die Segment Register FS und GS haben keine besondere Verwendung, man sollte sie nach
Möglichkeit nicht verwenden.

ich dachte, du redest vom Real Mode?
Dann kann man FS und GS völlig frei verwenden, insofern man min. einen 386er zu Verfügung hat.

Microsoft Windows verwendet intern und für die API die Pascal Calling Convention,

Nö, soweit ich aus meiner Win32 Zeit noch weis, ist es eine Mischung aus Pascal und C.
Das ganze nennt sich dann Stdcall.

Und ich glaube eher, dass die meisten Hobby OS Coder Fast Call nehmen.
Vor allem Anfänger.

Overflow wird vom Prozessor gesetzt wenn das Ergebnis für den Zieloperanden zu groß oder
zu klein ist.

Ich würde das "Overflow" dick markieren.
(Der Satz war nur ein Beispiel - davon gibt es mehrere).
Dann sticht das eher ins Auge.