kstd_libcxx.cpp

Go to the documentation of this file.

 
#include <cpu_io.h>
#include <stdint.h>
 
#include <algorithm>
#include <atomic>
 
#include "kernel_log.hpp"
 
using function_t = void (*)();
// 在 link.ld 中定义
extern "C" function_t __init_array_start;
extern "C" function_t __init_array_end;
extern "C" function_t __fini_array_start;
extern "C" function_t __fini_array_end;
void* __dso_handle = nullptr;
 
static constexpr size_t kMaxAtExitFuncsCount = 128;
 
struct atexit_func_entry_t {
  // 析构函数指针
  void (*destructor_func)(void*);
  // 要析构的对象
  void* obj_ptr;
  // 共享库对象，在内核中没有使用
  void* dso_handle;
};
 
static atexit_func_entry_t atexit_funcs[kMaxAtExitFuncsCount];  // NOLINT
static size_t atexit_func_count = 0;
 
extern "C" auto __cxa_atexit(void (*destructor_func)(void*), void* obj_ptr,
                             void*) -> int {
  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;
}
 
extern "C" auto __cxa_finalize(void* destructor_func) -> void {
  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;
      }
    }
  }
}
 
 
struct GuardType {
  std::atomic<uint64_t> guard{0};
 
  static constexpr uint64_t kInitializedMask = 0x01;
  static constexpr uint64_t kInUseMask = 0x100;
};
 
static_assert(sizeof(GuardType) == 8, "GuardType must be 64 bits per ABI");
 
extern "C" auto __cxa_guard_acquire(GuardType* guard) -> int {
  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;
}
 
extern "C" auto __cxa_guard_release(GuardType* guard) -> void {
  // 设置 initialized 位，清除 in_use 位
  guard->guard.store(GuardType::kInitializedMask, std::memory_order_release);
}
 
extern "C" auto __cxa_guard_abort(GuardType* guard) -> void {
  // 清除所有位
  guard->guard.store(0, std::memory_order_release);
}
 
 
extern "C" auto __cxa_pure_virtual() -> void {
  while (true) {
    cpu_io::Pause();
  }
}
 
extern "C" auto abort() -> void {
  while (true) {
    cpu_io::Pause();
  }
}
 
extern "C" [[noreturn]] void __assert_fail(const char* assertion,
                                           const char* file, unsigned int line,
                                           const char* function) {
  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();
  }
}
 
auto CppInit() -> void {
  // 调用构造函数
  std::for_each(&__init_array_start, &__init_array_end,
                [](function_t func) { (func)(); });
}
 
auto CppDeInit() -> void {
  // 调用析构函数
  std::for_each(&__fini_array_start, &__fini_array_end,
                [](function_t func) { (func)(); });
}