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

boot.s

@@ -1,90 +1,58 @@
-; Declare constants for the multiboot header.
+global start
-MBALIGN  equ  1<<0              ; align loaded modules on page boundaries
+extern kernel_main        ; Allow main() to be called from the assembly code
-MEMINFO  equ  1<<1              ; provide memory map
+extern start_ctors, end_ctors, start_dtors, end_dtors
-FLAGS    equ  MBALIGN | MEMINFO ; this is the Multiboot 'flag' field
+ 
-MAGIC    equ  0x1BADB002        ; 'magic number' lets bootloader find the header
+MODULEALIGN        equ        1<<0
-CHECKSUM equ -(MAGIC + FLAGS)   ; checksum of above, to prove we are multiboot
+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
+MultiBootHeader:
-	dd FLAGS
+       dd MAGIC
-	dd CHECKSUM
+       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
+align 32
-stack_bottom:
-resb 16384 ; 16 KiB
-stack_top:
  
-; The linker script specifies _start as the entry point to the kernel and the
+stack:
-; bootloader will jump to this position once the kernel has been loaded. It
+      resb      STACKSIZE
-; 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:

kernel.nim

@@ -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):
-  if(terminalColumn == vgaWidth): terminalColumn = 0
+    terminalColumn = 0
-  if(terminalRow == vgaHeight): terminalRow = 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!")
 

makefile

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