writing

Examples will show hot to use :-

• GJGPP - a complete 32-bit C/C++ development system for INtel 80386(and higher) PCs running DOS.
• NASM - The Netwide Assembler Project - Open sourced 80x86 assembler

Source code listed on this site has only been tested on djgpp version 2.03 and nasm version 0.98.08, running on the Windows XP environment. Some of the techniques discussed here will not work on other versions of gcc. I will try to give a warning for compiler specific implementations.

I assume that this is not your first attempt at writing a Kernel.

I assume you are already proficient in the programming language C++.

I assume you have already written a boot loader, or that you know how to use a standard one like GRUB. If you do use grub, you will need to add the necessary code to the assembler code below.

The aim of these tutorials is to show you how to implement a simple kernel written in C++. We will need a small amount of assembler (to initialise our kernel), and a smidgen of C code (to provide some C++ runtime support). The end result, will be the typical “Hello, world!” example.

Part 1, will introduce the Video driver, with no Run-Time support.
Part 2, will help add some run-time support, enabling global/static objects.
Part 3, will demonstrate a very simple implementation of std::cout (Standard output stream in the C++ Standard lib).

The end result will be this (taken from the first example in Accelerated C++, Andrew Koenig and BarBara E. Moo) :-

1
2
3
4
5
6
7
8

int ()
{
	std:cout << "Hello, world!" << std::endl;
	return 0;
}

Part 4, will set-up a global descriptor table, and an interrupt descriptor table. With some encapsulation in C++.
Part 5, will introduce a simple interrupt driven Keyboard driver.
Part 6, will demonstrate a very simple implementation of std::string
Part 7, will demonstrate a very simple implementation of std::cin.

The end result wil be this (taken from the second example in Accelerated C++, Andrew Koenig and Barbara E. Moo) :-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <string>

int ()
{
	//ask for the person's name
	std::cout << "Please enter your first name: ";
	//read name
	std::string name;	//define name
	std::cin >> name;	//read into name

	//write a greeting
	std::cout << "Hello, " << name << "!" << std::endl;
	return 0;
}

As you can see, there is more work involved to get the C++ kernel up and running, at least compared to a C kernel, but hopefully the end result will be a solid base onto which to build a more flexible object oriented kernel.

Quoting from the creator of C++, Bjarne Stroustrup’s book “The C++ programming language third edition (section 1.3.1)”,

“Except for the _new, delete, typeid, dynamic_cast_, and throw operators and the try-block, individual C++ expressions and statements need no run-time support.”

The features which need Run-TIme support full into 3 categories :-

• Built in functions (new, delete),
• Run Time Type Information (typeid, dynamic_cast),
• And Exception handling (throw, try-block).

However, Stroustrup was refering to C++ code on an operating system which has an implementation of the C++ standard library. So this must also be implemented or ported for use in the kernel.

The good news in we can disable these features with most compilers, and everything will be ok as long as we don’t use those off-limit expressions and statements. When the time comes when we want to use them, we have to add our own support code and link it to our kernel.

example of how to disable these in gxx, the win32 g++ compiler.

1	gcc -c *.cpp -ffreestanding -nostdlib -fno-builtin -fno-rtti -fno-exceptions

Lets start with the ASM code which will call our kernel’s main function. Later this code will also make calls to our run-time support, _main() and _atexit().

1
2
3
4
5
6
7
8
9
10

;Loader.asm
[BITS 32] ; protected mode

[global start]
[extern _main] ; this is in our C++ code

start:
call _main ; call int main(void) from our C++ code
cli ; interrupts could disturb the halt
hlt ; halt the CPU

Now in our C++ Kernel, we are going to create a class Video, which will act as a simple video driver. This is the entire code for the kernel.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//Video.h
#ifndef VIDEO_H
#define VIDEO_H		//so we don't get multiple definitions of VIdeo

class Video
{
public:
	Video();
	~Video();
	void clear();
	void write(char *cp);
	void put(char c);
private:
	unsigned short *videomem;	//pointer to video memory
	unsigned int off;			//offset, used like a y cord
	unsigned int pos;			//position, used like x cord

}; //don't forget the semicolon!

#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

//Video.cpp

Video:Video()
{
	pos=0;	off=0; 
	videomem = (unsigned short*) 0xb8000;
}

Video::~Video() {}

void Video::clear()
{
	unsigned int i;

	for(i=0; i<(80*25); i++)
	{
		videomem[i] = (unsigned char) ' ' | 0x0700;
	}
	pos=0; off=0;
}

void Video::write(char *cp)
{
	char *str = cp, *ch;

	for(ch=str; *ch; ch++)
	{
		put(*ch);
	}
}

void Video::put(char c)
{
	if(pos>=80)
	{
		pos=0;
		off += 80;
	}

	if(off>=(80*20))
	{
		clear(); //should scroll the screen, but for now, just clear
	}

	videomem[off + pos] = (unsigned char) c | 0x0700;
	pos++;
}

1
2
3
4
5
6
7
8
9

//Kernel.cpp
#include "Video.h"

int (void)
{
	Video vid; //local, (global variables need some Run-Time support code)

	vid.write("Hello, world!");
}

Video.cpp and Kernel.cpp need to be compiled with a C++ compiler, remembering to disable the above mentioned C++ features. The output from your C++ compiler should be the object files Video.o and Kernel.o. Loader.asm also needs to be assembled with an assembler. The output from your assembler should be the object file Loader.o.

An example of how to compile using DJGPP gxx and NASM.

1
2
3

gxx -c Video.cpp -ffreestanding -nostdlib -fno-builtin -fno-rtti -fno-exceptions
gxx -c Kernel.cpp -ffreestanding -nostdlib -fno-builting -fno-rtti -fno-exceptions
nasm -f aout Loader.asm -o Loader.o

Now we must link our object files into a flat binary which we shall call Kernel.bin.

I recommend suing a linker script, we will be making use of the linker script in part2. Here is an example of a linker script for LD.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/* Link.ld */
OUTPUT_FORMAT("binary")
ENTRY(start)
SECTIONS
{
	.text 0x100000 :
	{
		code = .; _code = .; __code = .;
		*(.text)
		. = ALIGN(4096);
	}

	.data :
	{
		data = .; _data = .; __data = .;
		*(.data)
		. = ALIGN(4096);
	}

	.bss :
	{
		bss = .; _bss = .; __bss = .;
		*(.bss)
		. = ALIGN(4096);
	}

	end = .; _end = .; __end = .;
}

Now we can use the linker script with LD,

1

ld -T Link.ld -o Kernel.bin Loader.o Kernel.o Video.o

Hopefully your C++ Kerrnel should have compiled and linked without any errors. Congratulations.

::Warning - Compiler Specific::

This method will only work for compilers which add two sections to the object files, the .ctor and .dtor section. Here are 4 steps to find out if you can use this solution :-

Step 1 - Move the Video object from a local to global scope.

1
2
3
4
5
6
7
8
9

//Kernel.cpp
#include "Video.h"

Video vid; //global variable

int (void)
{
	vid.write("Hello, world!");
}

Step 2 - Compile Kernel.cpp for a freestanding environment, without run-time support, or standard library.

1

gxx -c Kernel.cpp -ffreestanding -nostdlib -fno-builtin -fno-rtti -fno-exceptions

Step 3 - Use the object dump tool to display contents of the sections.

1	objdump -h Kernel.o > Kernel.dis

Redirects the output of objdump to a file named Kernel.dis

Step 4 - Open the Kernel.dis with a text editor (Notepad, WordPad, my preferred choice is TextPad)

Look for something like this in the file
7 .ctors 00000004 000000f4 000000f4 00000294 2**2
CONTENTS, ALLOC, LOAD, RELOC, DATA
8 .dtors 00000004 000000f8 000000f8 00000298 2**2
CONTENTS, ALLOC, LOAD, RELOC, DATA
If they are present, you can use solution 1.

We are now going to implement _main() and _atexit(). In our linker script we are going to create a list of pointers in the .ctor section, and a list of pointers in the .dtor section. Which are the Constructor lists, and Deconstructor lists repectively.

Note - THe list is not sorted into order of precedence, in a complex hierachy the constructors could be called in an incorrect order!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

//Support.c
void _main()
{
	//Walk and call the constructors in the ctor_list

	//the ctor list is defined in the linker script
	extern void (*_CTOR_LIST__)();

	//hold current constructor in list
	void (**constructor)() = &_CTOR_LIST__;

	//the first int is the number of constructors
	int total = *(int *)constructor;

	//increment to first constructor
	constructor++;

	while(total)
	{
		(*constructor)();
		total--;
		constructor++;
	}
}

void _atexit()
{
	//Walk and call the deconstructors in the dtor_list

	//the dtor list is defined in the linker script
	extern void (*_DTOR_LIST__)();

	//hold current deconstructor in list
	void (**deconstructor)() = &_DTOR_LIST__;

	//the first int is the number of deconstructors
	int total = *(int *)deconstructor;

	//increment to first deconstructor
	deconstructor++;

	while(total)
	{
		(*deconstructor)();
		total--;
		deconstructor++;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

;Loader.asm

[BITS 32] ;protected mode

[global start]
[extern _main]	;this is in our C++ code
[extern __main]	;this is in our C support code
[extern __atexit];tihs is in our C support code

start:
call __main
call _main ;call int main(void) from our C++ code
call __atexit
cli ;interrupts could disturb the halt
hlt ;halt the CPU

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

/* Link.ld */
OUTPUT_FORMAT("binary")
ENTRY(start)
SECTIONS
{
	.text 0x100000 :
	{
		code = .; _code = .; __code = .;
		*(.text)
		. = ALIGN(4096);
	}

	.data :
	{
		__CTOR_LIST__ = .;
		LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
		*(.ctors)
		LONG(0)
		__CTOR_END__ = .;
		__DTOR_LIST__ = .;
		LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
		*(.dtors)
		LONG(0)
		__DTOR_END__ = .;

		data = .; _data = .; __data = .;
		*(.data);
		. = ALIGN(4096);
	}

	.bss :
	{
		bss = .; _bss = .; __bss = .;
		*(.bss)
		. = ALIGN(4096);
		end = .; _end = .; __end = .;
	}
}

Compile and link as in Part 1. You will now be able to use Global / Static objects in your C++ Kernel. In Part 3 we will look at a simple implementation of Class OStream which resides in namespace std. We will use a global instance of OStream, cout.

All trademarks and/or registered trademarks on this site are property of their respective owners. Use this site and its contents at your own risk…