kstd_libcxx.cpp File Reference

#include <cpu_io.h>
#include <stdint.h>
#include <algorithm>
#include <atomic>
#include "kernel_log.hpp"

Include dependency graph for kstd_libcxx.cpp:

Go to the source code of this file.

Classes
struct	atexit_func_entry_t
	析构函数结构 More...
struct	GuardType

Typedefs
using	function_t = void(*)()
	全局构造函数函数指针

Functions
auto	__cxa_atexit (void(*destructor_func)(void *), void *obj_ptr, void *) -> int
auto	__cxa_finalize (void *destructor_func) -> void
auto	__cxa_pure_virtual () -> void
auto	abort () -> void
void	__assert_fail (const char *assertion, const char *file, unsigned int line, const char *function)
	libc assert() 失败时调用的底层接口
auto	CppInit () -> void
	构造 c++ 全局对象
auto	CppDeInit () -> void
	析构 c++ 全局对象
保证静态局部变量线程安全
Todo: 确保正确
auto	__cxa_guard_acquire (GuardType *guard) -> int
auto	__cxa_guard_release (GuardType *guard) -> void
auto	__cxa_guard_abort (GuardType *guard) -> void

Variables
function_t	__init_array_start
	全局构造函数函数指针起点地址
function_t	__init_array_end
	全局构造函数函数指针终点地址
function_t	__fini_array_start
	全局析构函数函数指针起点地址
function_t	__fini_array_end
	全局析构函数函数指针终点地址
void *	__dso_handle = nullptr
	动态共享对象标识，内核使用静态链接，此变量在内核中没有使用
static constexpr size_t	kMaxAtExitFuncsCount = 128
	最大析构函数数量
static atexit_func_entry_t	atexit_funcs [kMaxAtExitFuncsCount]
	析构函数数组
static size_t	atexit_func_count = 0
	析构函数个数

Typedef Documentation

function_t

using function_t = void (*)()

全局构造函数函数指针

Copyright

Copyright The SimpleKernel Contributors

Definition at line 14 of file kstd_libcxx.cpp.

Function Documentation

__assert_fail()

void __assert_fail	(	const char *	assertion,
		const char *	file,
		unsigned int	line,
		const char *	function
	)

libc assert() 失败时调用的底层接口

Parameters

assertion	断言表达式字符串
file	源文件名
line	行号
function	函数名

Definition at line 199 of file kstd_libcxx.cpp.

                                                                 {
  klog::RawPut("\n[ASSERT FAILED] ");
  klog::RawPut(file);
  etl_putchar(':');
  char buf_line[12];
  auto* end = etl::format_to_n(buf_line, sizeof(buf_line) - 1, "{}", line);
  *end = '\0';
  klog::RawPut(" in ");
  klog::RawPut(function);
  klog::RawPut("\n Expression: ");
  klog::RawPut(assertion);
  etl_putchar('\n');
  while (1) {
    cpu_io::Pause();
  }
}

Here is the call graph for this function:

__cxa_atexit()

auto __cxa_atexit	(	void(*)(void *)	destructor_func,
		void *	obj_ptr,
		void *
	)		-> int

注册在程序正常终止时调用的析构函数

Parameters

destructor_func	指向要调用的析构函数的指针
obj_ptr	传递给析构函数的参数

Returns

成功返回 0

Definition at line 51 of file kstd_libcxx.cpp.

                                           {
  if (atexit_func_count >= kMaxAtExitFuncsCount) {
    return -1;
  }
  atexit_funcs[atexit_func_count].destructor_func = destructor_func;
  atexit_funcs[atexit_func_count].obj_ptr = obj_ptr;
  atexit_funcs[atexit_func_count].dso_handle = nullptr;
  atexit_func_count++;
  return 0;
}

__cxa_finalize()

auto __cxa_finalize

(

void *

destructor_func

)

-> void

调用析构函数

Parameters

destructor_func

要调用的析构函数指针，为 nullptr 时调用所有注册的析构函数。

Definition at line 68 of file kstd_libcxx.cpp.

                                                              {
  if (destructor_func == nullptr) {
    // 如果 destructor_func 为 nullptr，调用所有析构函数
    for (size_t i = atexit_func_count; i > 0; --i) {
      size_t idx = i - 1;
      if (atexit_funcs[idx].destructor_func != nullptr) {
        (*atexit_funcs[idx].destructor_func)(atexit_funcs[idx].obj_ptr);
      }
    }
  } else {
    // 不为空时只调用对应的析构函数
    for (size_t i = atexit_func_count; i > 0; --i) {
      size_t idx = i - 1;
      if (reinterpret_cast<void*>(atexit_funcs[idx].destructor_func) ==
          destructor_func) {
        (*atexit_funcs[idx].destructor_func)(atexit_funcs[idx].obj_ptr);
        atexit_funcs[idx].destructor_func = nullptr;
      }
    }
  }
}

__cxa_guard_abort()

auto __cxa_guard_abort

(

GuardType *

guard

)

-> void

如果在初始化过程中出现异常或其他错误，调用此函数以释放锁而不标记变量为已初始化

Parameters

guard

锁

Definition at line 167 of file kstd_libcxx.cpp.

                                                            {
  // 清除所有位
  guard->guard.store(0, std::memory_order_release);
}

__cxa_guard_acquire()

auto __cxa_guard_acquire

(

GuardType *

guard

)

-> int

检测静态局部变量是否已经初始化

Parameters

guard

锁，一个 64 位变量

Returns

未初始化返回非零值，已初始化返回 0

Note

使用紧凑的 CAS 循环，compare_exchange_weak 失败时会自动更新 expected

Definition at line 127 of file kstd_libcxx.cpp.

                                                             {
  uint64_t expected = 0;
 
  // 紧凑的 CAS 循环：尝试将 0 -> kInUseMask
  // compare_exchange_weak 失败时会将当前值写入 expected
  while (!guard->guard.compare_exchange_weak(expected, GuardType::kInUseMask,
                                             std::memory_order_acq_rel,
                                             std::memory_order_acquire)) {
    // CAS 失败，检查失败原因
    if ((expected & GuardType::kInitializedMask) != 0U) {
      // 已被其他核心初始化完成
      return 0;
    }
 
    // 其他核心正在初始化中，等待
    cpu_io::Pause();
 
    // 重置 expected 以便下次 CAS 尝试
    // 如果当前值仍有 kInUseMask，CAS 会再次失败并更新 expected
    expected = 0;
  }
 
  // CAS 成功，当前核心负责初始化
  return 1;
}

Here is the call graph for this function:

__cxa_guard_release()

auto __cxa_guard_release

(

GuardType *

guard

)

-> void

用于检测静态局部变量是否已经初始化，并设置锁

Parameters

guard

锁，一个 64 位变量

Returns

未初始化返回非零值并设置锁，已初始化返回 0

Definition at line 158 of file kstd_libcxx.cpp.

                                                              {
  // 设置 initialized 位，清除 in_use 位
  guard->guard.store(GuardType::kInitializedMask, std::memory_order_release);
}

__cxa_pure_virtual()

auto __cxa_pure_virtual

(

)

-> void

纯虚函数调用处理

Definition at line 177 of file kstd_libcxx.cpp.

                                             {
  while (true) {
    cpu_io::Pause();
  }
}

Here is the call graph for this function:

abort()

auto abort

(

)

-> void

终止程序

Definition at line 186 of file kstd_libcxx.cpp.

                                {
  while (true) {
    cpu_io::Pause();
  }
}

Here is the call graph for this function:

CppDeInit()

auto CppDeInit

(

)

-> void

析构 c++ 全局对象

c++ 全局对象析构

Definition at line 230 of file kstd_libcxx.cpp.

                         {
  // 调用析构函数
  std::for_each(&__fini_array_start, &__fini_array_end,
                [](function_t func) { (func)(); });
}

CppInit()

auto CppInit

(

)

-> void

构造 c++ 全局对象

c++ 全局对象构造

Definition at line 221 of file kstd_libcxx.cpp.

                       {
  // 调用构造函数
  std::for_each(&__init_array_start, &__init_array_end,
                [](function_t func) { (func)(); });
}

Here is the caller graph for this function:

Variable Documentation

__dso_handle

void* __dso_handle = nullptr

动态共享对象标识，内核使用静态链接，此变量在内核中没有使用

Definition at line 25 of file kstd_libcxx.cpp.

__fini_array_end

function_t __fini_array_end

全局析构函数函数指针终点地址

Definition at line 23 of file kstd_libcxx.cpp.

__fini_array_start

function_t __fini_array_start

全局析构函数函数指针起点地址

Definition at line 21 of file kstd_libcxx.cpp.

__init_array_end

function_t __init_array_end

全局构造函数函数指针终点地址

Definition at line 19 of file kstd_libcxx.cpp.

__init_array_start

function_t __init_array_start

全局构造函数函数指针起点地址

Definition at line 17 of file kstd_libcxx.cpp.

atexit_func_count

size_t atexit_func_count = 0

static

析构函数个数

Definition at line 43 of file kstd_libcxx.cpp.

atexit_funcs

atexit_func_entry_t atexit_funcs[kMaxAtExitFuncsCount]

static

析构函数数组

Definition at line 41 of file kstd_libcxx.cpp.

kMaxAtExitFuncsCount

constexpr size_t kMaxAtExitFuncsCount = 128

staticconstexpr

最大析构函数数量

Definition at line 28 of file kstd_libcxx.cpp.