972
edits
Go Bare Bones: Difference between revisions
m
Fix lint errors
| [unchecked revision] | [unchecked revision] |
No edit summary |
m (Fix lint errors) |
||
| (8 intermediate revisions by 4 users not shown) | |||
Line 1:
{{BeginnersWarning}}
In this tutorial you'll learn how to get started using the Go language to write your own OS. It will be an example of how to create a very minimal system to get text on the screen. It's in no way an example of how you should organize or structure your project.▼
{{Rating|2}}
▲In this tutorial you'll learn how to get started using the Go language to write your own OS. It will be an example of how to create a very minimal system to get text on the screen. It's in no way an example of how you should organize or structure your project.
== Preface ==
Line 10 ⟶ 11:
== Building a Cross-Compiler ==
The first thing you should do is set up a GCC Cross Compiler that supports Go. To do this read and follow [[GCC Cross-Compiler]] to the letter with one exception. When configuring the build for GCC we need to enable Go to get the i686-elf-gccgo compiler.
So instead of using: <
== Overview ==
Line 76 ⟶ 77:
# This is useful when debugging or when you implement call tracing.
.size _start, . - _start
# The Go runtime is a big problem when wanting to write a kernel in Go.
Line 96 ⟶ 83:
# goes way beyond the scope of this barebone.
#
# Beware that there are
# The linker will fail with missing symbols when you try to use them.
#
# You have to implement those missing symbols yourself to get things working.
# Sometimes you can get away with declaring them as an empty function.
# But this won't
#
# After you get this bare bone working, the first priority should be to write
Line 124 ⟶ 111:
You can then assemble boot.s using:
<
== Writing the Terminal package in Go ==
:''Please read [[Printing to Screen]] to understand what this code does.''
Now we'll create the file terminal.go. It's the package "terminal" our kernel will depend on for printing text to the screen.
<
import "unsafe"
/*
* Map the text mode video memory into a multi-dimensional array that can be safely
* used from Go.
*/
func get_vidMem(addr uint32) *[25][80][2]byte {
return buff
}
/*
Line 226 ⟶ 211:
}
}
</syntaxhighlight>
Compile using: <
== How imported packages are found ==
Line 239 ⟶ 224:
* .o
A .gox file contains just the import data. If you wanted to extract it from our terminal.go.o object file we use: <
== Writing a kernel in Go ==
Line 245 ⟶ 230:
Now we create the file kernel.go that contains the Main() function called from our bootstrap assembly we've already created and compiled above. It will import the terminal package we also created & compiled. Then we use that package to print text to the screen.
<
import "terminal"
Line 262 ⟶ 247:
// Print our Hello, World!
terminal.Print("Hello, Kernel World!\n")
}</
Compile using: <
== Linking the Kernel ==
Line 316 ⟶ 301:
You can link your kernel using:
<
The file myos.bin is now your kernel. Note that we are linking against [[libgcc]], which implements various routines that your cross-compiler depends on. Leaving it out will give you problems in the future.
Line 325 ⟶ 310:
QEMU supports booting multiboot kernels directly without using a bootable medium:
<
== External Links ==
Line 331 ⟶ 316:
* [https://www.gnu.org/software/grub/manual/multiboot/multiboot.html Multiboot Specification]
* [https://golang.org/doc/install/gccgo Setting up and using gccgo]
[[Category: Bare bones tutorials]]
| |||