💾
How to make an Operating System
💾
How to make an Operating System
  • Introduction
  • Introduction about the x86 architecture and about our OS
  • Setup the development environment
  • First boot with GRUB
  • Backbone of the OS and C++ runtime
  • Base classes for managing x86 architecture
  • GDT
  • IDT and interrupts
  • Theory: physical and virtual memory
  • Memory management: physical and virtual
  • Process management and multitasking
  • External program execution: ELF files
  • Userland and syscalls
  • Modular drivers
  • Some basics modules: console, keyboard
  • IDE Hard disks
  • DOS Partitions
  • EXT2 read-only filesystems
  • Standard C library (libC)
  • UNIX basic tools: sh, cat
  • Lua interpreter
Powered by GitBook
On this page

Was this helpful?

Last updated 5 years ago

C++ kernel run-time

A kernel can be written in C++ just as it can be in C, with the exception of a few pitfalls that come with using C++ (runtime support, constructors, etc).

The compiler will assume that all the necessary C++ runtime support is available by default, but as we are not linking libsupc++ into your C++ kernel, we need to add some basic functions that can be found in the file.

Caution: The operators new and delete cannot be used before virtual memory and pagination have been initialized.

Basic C/C++ functions

The kernel code can't use functions from the standard libraries so we need to add some basic functions for managing memory and strings:

C types

In the next step, we're going to define different types we're going to use in our code. Most of our variable types are going to be unsigned. This means that all the bits are used to store the integer. Signed variables use their first bit to indicate their sign.

Compile our kernel

Compiling a kernel is not the same thing as compiling a linux executable, we can't use a standard library and should have no dependencies to the system.

For x86 architecture, the followings arguments will be used for gcc/g++/ld:

These functions are defined in , ,

Our will define the process to compile and link our kernel.

string.cc
memory.cc
itoa.cc
Makefile
# Linker
LD=ld
LDFLAG= -melf_i386 -static  -L ./  -T ./arch/$(ARCH)/linker.ld

# C++ compiler
SC=g++
FLAG= $(INCDIR) -g -O2 -w -trigraphs -fno-builtin  -fno-exceptions -fno-stack-protector -O0 -m32  -fno-rtti -nostdlib -nodefaultlibs 

# Assembly compiler
ASM=nasm
ASMFLAG=-f elf -o
  • C++ kernel run-time
  • Basic C/C++ functions
  • C types
  • Compile our kernel
PreviousFirst boot with GRUBNextBase classes for managing x86 architecture

Backbone of the OS and C++ runtime

cxx.cc
void     itoa(char *buf, unsigned long int n, int base);

void *    memset(char *dst,char src, int n);
void *    memcpy(char *dst, char *src, int n);

int     strlen(char *s);
int     strcmp(const char *dst, char *src);
int     strcpy(char *dst,const char *src);
void     strcat(void *dest,const void *src);
char *    strncpy(char *destString, const char *sourceString,int maxLength);
int     strncmp( const char* s1, const char* s2, int c );
typedef unsigned char     u8;
typedef unsigned short     u16;
typedef unsigned int     u32;
typedef unsigned long long     u64;

typedef signed char     s8;
typedef signed short     s16;
typedef signed int         s32;
typedef signed long long    s64;