neviyn/alcedo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Tried fixing int-ness. Now has output albeit garbled.

Browse Source
This commit is contained in:
neviyn 2017-10-20 22:04:09 +01:00
parent ff925996ca
commit 3711ef34d8
4 changed files with 67 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
boot.o
View File

Binary file not shown.

138
boot.s
View File

@ -1,90 +1,58 @@
; Declare constants for the multiboot header.
MBALIGN equ 1<<0 ; align loaded modules on page boundaries
MEMINFO equ 1<<1 ; provide memory map
FLAGS equ MBALIGN | MEMINFO ; this is the Multiboot 'flag' field
MAGIC equ 0x1BADB002 ; 'magic number' lets bootloader find the header
CHECKSUM equ -(MAGIC + FLAGS) ; checksum of above, to prove we are multiboot
global start
extern kernel_main ; Allow main() to be called from the assembly code
extern start_ctors, end_ctors, start_dtors, end_dtors
MODULEALIGN equ 1<<0
MEMINFO equ 1<<1
FLAGS equ MODULEALIGN | MEMINFO
MAGIC equ 0x1BADB002
CHECKSUM equ -(MAGIC + FLAGS)
section .text ; Next is the Grub Multiboot Header
; Declare a multiboot header that marks the program as a kernel. These are magic
; values that are documented in the multiboot standard. The bootloader will
; search for this signature in the first 8 KiB of the kernel file, aligned at a
; 32-bit boundary. The signature is in its own section so the header can be
; forced to be within the first 8 KiB of the kernel file.
section .multiboot
align 4
dd MAGIC
dd FLAGS
dd CHECKSUM
MultiBootHeader:
dd MAGIC
dd FLAGS
dd CHECKSUM
STACKSIZE equ 0x4000 ; 16 KiB if you're wondering
static_ctors_loop:
mov ebx, start_ctors
jmp .test
.body:
call [ebx]
add ebx,4
.test:
cmp ebx, end_ctors
jb .body
start:
mov esp, STACKSIZE+stack
push eax
push ebx
call kernel_main
static_dtors_loop:
mov ebx, start_dtors
jmp .test
.body:
call [ebx]
add ebx,4
.test:
cmp ebx, end_dtors
jb .body
cpuhalt:
hlt
jmp cpuhalt
; The multiboot standard does not define the value of the stack pointer register
; (esp) and it is up to the kernel to provide a stack. This allocates room for a
; small stack by creating a symbol at the bottom of it, then allocating 16384
; bytes for it, and finally creating a symbol at the top. The stack grows
; downwards on x86. The stack is in its own section so it can be marked nobits,
; which means the kernel file is smaller because it does not contain an
; uninitialized stack. The stack on x86 must be 16-byte aligned according to the
; System V ABI standard and de-facto extensions. The compiler will assume the
; stack is properly aligned and failure to align the stack will result in
; undefined behavior.
section .bss
align 16
stack_bottom:
resb 16384 ; 16 KiB
stack_top:
align 32
; The linker script specifies _start as the entry point to the kernel and the
; bootloader will jump to this position once the kernel has been loaded. It
; doesn't make sense to return from this function as the bootloader is gone.
; Declare _start as a function symbol with the given symbol size.
section .text
global _start:function (_start.end - _start)
_start:
; The bootloader has loaded us into 32-bit protected mode on a x86
; machine. Interrupts are disabled. Paging is disabled. The processor
; state is as defined in the multiboot standard. The kernel has full
; control of the CPU. The kernel can only make use of hardware features
; and any code it provides as part of itself. There's no printf
; function, unless the kernel provides its own <stdio.h> header and a
; printf implementation. There are no security restrictions, no
; safeguards, no debugging mechanisms, only what the kernel provides
; itself. It has absolute and complete power over the
; machine.
; To set up a stack, we set the esp register to point to the top of our
; stack (as it grows downwards on x86 systems). This is necessarily done
; in assembly as languages such as C cannot function without a stack.
mov esp, stack_top
; This is a good place to initialize crucial processor state before the
; high-level kernel is entered. It's best to minimize the early
; environment where crucial features are offline. Note that the
; processor is not fully initialized yet: Features such as floating
; point instructions and instruction set extensions are not initialized
; yet. The GDT should be loaded here. Paging should be enabled here.
; C++ features such as global constructors and exceptions will require
; runtime support to work as well.
; Enter the high-level kernel. The ABI requires the stack is 16-byte
; aligned at the time of the call instruction (which afterwards pushes
; the return pointer of size 4 bytes). The stack was originally 16-byte
; aligned above and we've since pushed a multiple of 16 bytes to the
; stack since (pushed 0 bytes so far) and the alignment is thus
; preserved and the call is well defined.
; note, that if you are building on Windows, C functions may have "_" prefix in assembly: _kernel_main
extern kernel_main
call kernel_main
; If the system has nothing more to do, put the computer into an
; infinite loop. To do that:
; 1) Disable interrupts with cli (clear interrupt enable in eflags).
; They are already disabled by the bootloader, so this is not needed.
; Mind that you might later enable interrupts and return from
; kernel_main (which is sort of nonsensical to do).
; 2) Wait for the next interrupt to arrive with hlt (halt instruction).
; Since they are disabled, this will lock up the computer.
; 3) Jump to the hlt instruction if it ever wakes up due to a
; non-maskable interrupt occurring or due to system management mode.
cli
.hang: hlt
jmp .hang
.end:
stack:
resb STACKSIZE

21
kernel.nim
View File

@ -18,10 +18,10 @@ type
white = 15
proc vgaEntryColour(fg: VGA_Colour, bg: VGA_Colour): uint8 =
result = uint8(ord(fg) or (ord(bg) shl 4))
result = uint8(ord(fg)) or (uint8(ord(bg)) shl 4)
proc vgaEntry(c: char, colour: uint8): uint16 =
result = uint16(uint8(c) or (colour shl 8))
result = uint16(c) or (uint16(colour) shl 8)
const
vgaWidth = 80
@ -34,22 +34,27 @@ var
proc terminalWriteAtPoint(writeChar: char, colour: uint8, xPos: int, yPos: int) =
let index = terminalBufferBaseAddress + (yPos * vgaWidth + xPos)
cast[ptr uint16](index)[] = vgaEntry(' ', terminalColour) # Write directly to display memory
cast[ptr uint16](index)[] = vgaEntry(writeChar, colour) # Write directly to display memory
proc terminalInitialize() =
for y in 0..<vgaWidth:
for x in 0..<vgaHeight:
terminalWriteAtPoint(' ', terminalColour, x, y)
terminalWriteAtPoint(' ', 0, x, y)
proc setTerminalColour(newColour: uint8) =
terminalColour = newColour
proc terminalWriteChar(writeChar: char) =
if(writeChar == '\r'):
inc(terminalRow)
if(terminalRow == vgaHeight): terminalRow = 0
return
terminalWriteAtPoint(writeChar, terminalColour, terminalColumn, terminalRow)
inc(terminalColumn)
inc(terminalRow)
if(terminalColumn == vgaWidth): terminalColumn = 0
if(terminalRow == vgaHeight): terminalRow = 0
if(terminalColumn == vgaWidth):
terminalColumn = 0
inc(terminalRow)
if(terminalRow == vgaHeight): terminalRow = 0
proc terminalWrite(data: string) =
for character in data:
@ -57,5 +62,5 @@ proc terminalWrite(data: string) =
proc kernelMain() {.exportc: "kernel_main"}=
terminalInitialize()
terminalWrite("Hello World")
terminalWrite("Hello World\rThis is Nim!")

2
makefile
View File

@ -1,7 +1,7 @@
all: kernel
kernel: bootloader
nim cc --cc:clang --clang.linkerexe=ld.lld --gc:none --deadCodeElim:on --cpu:i386 --os:standalone --passC:"-ffreestanding -nostdlib --target=i686-pc-none-elf -march=i686" --passL:"-m elf_i386 boot.o" kernel.nim
nim cc --cc:clang --clang.linkerexe=ld.lld --gc:none --deadCodeElim:on --cpu:i386 --os:standalone --passC:"-ffreestanding -nostdlib --target=i686-pc-none-elf -march=i686" --passL:"-m elf_i386 -T linker.ld boot.o" kernel.nim
bootloader:
nasm -felf32 boot.s -o boot.o