C++: Difference between revisions

:''For a quick tutorial on getting a bare bones C++ kernel running see [[C++Bare bare bonesBones]]''

MostA featureslot of features C++ comeoffers "forcan free",be i.e.used on-the-fly; they require no additional supportingsupport or workcode to beuse usedthem inproperly kernel space(e.g. Templatestemplates, for example, do not require any additional logic; neither do classes, even when inheritance and, virtual functions). There are involved.however Otherother thingsparts of C++ that do require runtime support., This documentwhich will firstbe explaindiscussed howin to turn these features off, and then, gradually, how to implement the required support so you can turn them onthis againarticle.

// Do nothing or print an error message.

// Do nothing or print an error message.

If, during runtime, your kernel detects that a call to a pure virtual function couldn't be made, it calls the above functions. These functions should actually never be called, because without hacks, (or through undefined behaviour of your kernel), it is not possible to instantiate a class that doesn't define all pure virtual functions. But nonetheless you have to define these functions or your linker will complain about unresolved symbols.

<sourcesyntaxhighlight lang="cpp">

<sourcesyntaxhighlight lang="asmcpp">

The following is tested, working, fully commented source that gives a more detailed explanation than the source previously found here. It also highlights what improvements can be implemented and where they can be inserted. To use it, just include '''icxxabi.h''' in any ONE'''one''' file of your C++ kernel source. Preferable(preferably the file where your kernel's main statements begin).

<sourcesyntaxhighlight lang="cpp">

<sourcesyntaxhighlight lang="cpp">

while (i--i)

forwhile ( ; i >= 0; --)

===== Visual C==++ ===

=== Local staticStatic variablesVariables (GCC onlyOnly)= ==

When you declare a local static variable, at least GCC compiler, puts a guard around the variable's constructor call. This ensures that only one thread can call the constructor at the same time to initialize it.

__extension__ typedef int __guard __attribute__((mode (__DI__)));

ActualThe actual code, emitedemitted by GCC, to call a local static variable's constructor looks something like this:

<sourcesyntaxhighlight lang="cpp">

if (__cxa_guard_acquire (&!guard.first_byte)) {

} catch {

=== The Operators 'new' and 'delete=' ==

Before you can properly use '''new''' and '''delete''', you have to implement some sort of memory management,. andYou thealso operatorhave to implement both operators <tt>new(including their array counterparts)</tt>. '''new''' and operator'''delete''' respectively allocate and <tt>delete()</tt> functionsmemory (includingmuch theirlike array'''malloc''' counterpartsand '''free''' in C). Take a look at the [[Memory Management]] article if you would like to know more about this subject.

return kmallocmalloc(size);

//overload thevoid *operator "new[]"(size_t size)

return kmallocmalloc(size);

//overload thevoid operator "delete"(void *p)

kfreefree(p);

//overload thevoid operator "delete[]"(void *p)

kfreefree(p);

In C++, and (especially in OS code where structures can be found at fixed addresses,) it can be useful to construct an object in memory obtained elsewhere. This is accomplished through a technique known as 'placement new'. As anFor example, say you wanted to create an APIC object at address <tt>0x09fff0000</tt>.'''0x09FFF0000''', Thisthen this snippet of code will use placement new to do the trick:

<sourcesyntaxhighlight lang="cpp">

void* *apic_address = reinterpret_cast<void *>(0x09fff00000x09FFF0000);

APIC* *apic = new (apic_address) APIC;

In order to use placement new, you need special overloads of the new and delete operators defined in scope. Fortunately, the required definitions are simple and can be inlined in a header file (the C++ standard puts them in a header called <'''new>''').

<sourcesyntaxhighlight lang="cpp">

inline void* *operator new(uint_tsize_t, void* *p) throw() { return p; }

inline void* *operator new[](uint_tsize_t, void* *p) throw() { return p; }

inline void operator delete (void *, void *) throw() { };

inline void operator delete[](void *, void *) throw() { };

The above implementation can potentially be potentially unsafe for allocating memory, since your kernel does not mark the memory that was allocated as being used. Placement new is hardly ever used, and if you wish to read an object from a specified address in memory, it is usually easier to create a pointer to that address. [[liballoc]] does not support placement new.

<sourcesyntaxhighlight lang="cpp">

apic->~APIC();

* [https://www.dinkumware.com/cpp.aspx Dinkumware C++ Standard Library]

== Full C++ Runtime supportSupport withUsing libgcc andAnd libsupc++ ==

If you want Exceptions, RTTI, nice new and delete operators altogether, you also couldshould use [[libgcc]] and libsupc++. libgcc contains the unwinder (for exceptions), while libsupc++ contains the C++ support.