C++实现无C库依赖的运行时环境：定制化底层I/O与系统调用 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

C++ 无 C 库依赖的运行时环境：定制化底层 I/O 与系统调用

各位来宾，大家好。今天我们来探讨一个颇具挑战性但也极具价值的话题：如何在 C++ 中构建一个不依赖标准 C 库（libc）的运行时环境。这种环境允许我们对底层 I/O 和系统调用进行完全的定制化，从而实现更高的性能、更小的体积，以及更强的安全性。

一、为何要摆脱 libc 的束缚？

标准 C 库提供了丰富的函数，涵盖了内存管理、字符串操作、I/O 等多个方面。然而，在某些特定场景下，依赖 libc 会带来一些问题：

体积膨胀： libc 体积较大，即使只用到其中一小部分功能，也需要链接整个库。对于嵌入式系统或资源受限的环境，这会造成浪费。
性能开销： libc 的某些函数为了通用性，可能引入额外的开销。定制化的实现可以针对特定场景进行优化，提升性能。
安全风险： libc 历史上存在一些安全漏洞。减少对 libc 的依赖，可以降低安全风险。
控制力： libc 的行为受到标准规范的约束。定制化的实现可以突破这些约束，提供更大的灵活性。
可移植性限制： 标准库的具体实现会因操作系统和编译器而异。完全不依赖 C 库，可以最大程度地保证代码在不同平台上的可移植性。

二、构建无 libc 运行时环境的核心要素

构建无 libc 运行时环境，需要我们接管 libc 所提供的关键功能。以下是一些核心要素：

启动代码（Startup Code）： 负责初始化运行环境，包括设置堆栈、初始化全局变量等。
系统调用接口： 提供访问操作系统内核服务的接口，如文件 I/O、内存分配等。
内存管理： 实现自定义的内存分配器，替代 libc 的 malloc 和 free。
异常处理： 处理 C++ 异常，例如 try-catch 块。
I/O： 实现自定义的输入输出机制，替代 libc 的 printf、scanf 等。
C++ 标准库支持（部分）： 实现 C++ 标准库中需要的部分，例如 new、delete 操作符。

三、启动代码（Startup Code）

启动代码是程序执行的入口点，通常由汇编语言编写。它的主要任务是：

设置堆栈： 为程序分配堆栈空间。
初始化全局变量： 将全局变量初始化为预定义的值。
调用 main 函数： 将控制权交给 C++ 的 main 函数。

下面是一个简单的 x86-64 汇编语言启动代码示例（start.asm）：

section .text
    global _start

_start:
    ; 设置堆栈指针
    mov rsp, stack_top

    ; 初始化全局变量（如果需要）

    ; 调用 main 函数
    extern main
    call main

    ; 程序退出
    mov rdi, rax  ; 将 main 函数的返回值作为退出码
    mov rax, 60   ; 系统调用号 60 是 exit
    syscall

section .bss
    stack_bottom: resb 16384 ; 16KB 堆栈
    stack_top:

这个启动代码首先将堆栈指针 rsp 设置为 stack_top，然后调用 C++ 的 main 函数。 main 函数返回后，使用 exit 系统调用退出程序。

四、系统调用接口

系统调用是用户程序访问操作系统内核服务的唯一途径。不同的操作系统使用不同的系统调用接口。在 Linux 上，系统调用通过 syscall 指令触发。

以下是一个简单的系统调用封装函数，用于执行 write 系统调用（syscalls.h）：

#ifndef SYSCALLS_H
#define SYSCALLS_H

#include <stdint.h>

// 系统调用封装函数
int64_t syscall(int64_t syscall_number, int64_t arg1, int64_t arg2, int64_t arg3, int64_t arg4, int64_t arg5, int64_t arg6) {
  int64_t result;
  asm volatile (
    "syscall"
    : "=a" (result)
    : "a" (syscall_number),
      "D" (arg1),
      "S" (arg2),
      "d" (arg3),
      "r10" (arg4),
      "r8" (arg5),
      "r9" (arg6)
    : "rcx", "r11", "memory"
  );
  return result;
}

#endif

这个函数接受系统调用号和最多六个参数，然后使用 syscall 指令执行系统调用。

有了这个封装函数，我们可以方便地调用操作系统提供的各种服务。例如，我们可以使用以下代码向标准输出写入字符串：

#include "syscalls.h"

void print(const char* str) {
  syscall(1, 1, (int64_t)str, strlen(str), 0, 0, 0); // 1 是 write 系统调用号，1 是标准输出文件描述符
}

size_t strlen(const char* str) {
    size_t len = 0;
    while (*str++) len++;
    return len;
}

五、内存管理

为了替代 libc 的 malloc 和 free，我们需要实现自定义的内存分配器。一个简单的内存分配器可以使用一个大的连续内存块，并使用链表或其他数据结构来跟踪空闲块。

以下是一个简单的基于链表的内存分配器示例：

#include <stdint.h>
#include <stddef.h> // for size_t

// 内存块结构
struct MemBlock {
  size_t size;      // 块大小
  MemBlock* next;   // 指向下一个空闲块
  bool is_free;    // 标识是否为空闲块
};

// 内存池起始地址和大小
#define HEAP_SIZE (1024 * 1024) // 1MB
static uint8_t heap[HEAP_SIZE];
static MemBlock* free_list = nullptr;

// 初始化内存池
void init_memory() {
  MemBlock* first_block = (MemBlock*)heap;
  first_block->size = HEAP_SIZE - sizeof(MemBlock);
  first_block->next = nullptr;
  first_block->is_free = true;
  free_list = first_block;
}

// 分配内存
void* allocate(size_t size) {
  MemBlock* current = free_list;
  MemBlock* previous = nullptr;

  // 遍历空闲块链表
  while (current != nullptr) {
    if (current->is_free && current->size >= size + sizeof(MemBlock)) {
      // 找到合适的空闲块
        size_t remaining_size = current->size - size - sizeof(MemBlock);

        if (remaining_size >= sizeof(MemBlock)) {
            // 分割空闲块
            MemBlock* new_block = (MemBlock*)((uint8_t*)current + sizeof(MemBlock) + size);
            new_block->size = remaining_size;
            new_block->next = current->next;
            new_block->is_free = true;

            current->size = size;
            current->next = new_block;
        }

      current->is_free = false;

      return (void*)((uint8_t*)current + sizeof(MemBlock)); // 返回用户可用的内存起始位置
    }

    previous = current;
    current = current->next;
  }

  // 没有找到合适的空闲块
  return nullptr;
}

// 释放内存
void deallocate(void* ptr) {
    if (ptr == nullptr) return;

  MemBlock* block = (MemBlock*)((uint8_t*)ptr - sizeof(MemBlock));
  block->is_free = true;

  // 合并相邻的空闲块
  MemBlock* current = free_list;
  MemBlock* previous = nullptr;

  while (current != nullptr) {
    if (current == block) {
      // 合并后面的空闲块
      if (current->next != nullptr && current->next->is_free) {
        current->size += sizeof(MemBlock) + current->next->size;
        current->next = current->next->next;
      }

      // 合并前面的空闲块
      if (previous != nullptr && previous->is_free) {
        previous->size += sizeof(MemBlock) + current->size;
        previous->next = current->next;
      }
      break;
    }

    previous = current;
    current = current->next;
  }

}

// C++ new 和 delete 操作符的重载
void* operator new(size_t size) {
  void* ptr = allocate(size);
  if (!ptr) {
    // 处理内存分配失败的情况，例如抛出异常
    return nullptr;
  }
  return ptr;
}

void operator delete(void* ptr) noexcept {
  deallocate(ptr);
}

void operator delete(void* ptr, size_t size) noexcept {
    deallocate(ptr);
    (void)size; // Suppress unused variable warning
}

void* operator new[](size_t size) {
    void* ptr = allocate(size);
    if (!ptr) {
        // Handle memory allocation failure
        return nullptr;
    }
    return ptr;
}

void operator delete[](void* ptr) noexcept {
    deallocate(ptr);
}

void operator delete[](void* ptr, size_t size) noexcept {
    deallocate(ptr);
    (void)size; // Suppress unused variable warning
}

这个分配器使用一个静态的 heap 数组作为内存池，并使用 MemBlock 结构体来记录空闲块的信息。allocate 函数遍历空闲块链表，找到合适的空闲块并将其分割成两部分：一部分分配给用户，另一部分仍然作为空闲块。deallocate 函数将释放的内存块标记为空闲，并尝试与相邻的空闲块合并。

此外，我们还需要重载 C++ 的 new 和 delete 操作符，以便使用我们自定义的内存分配器。

六、异常处理

C++ 异常处理依赖于编译器和运行时环境的支持。在没有 libc 的情况下，我们需要自己实现异常处理机制。一种简单的方法是使用 setjmp 和 longjmp 函数来模拟异常的抛出和捕获。

然而，这种方法非常复杂，并且与编译器的异常处理机制不兼容。更常见的方法是禁用异常处理，并使用错误码或其他机制来处理错误。可以使用 -fno-exceptions 编译器选项来禁用异常处理。

如果需要异常处理，则需要深入了解编译器如何生成异常处理的代码，并且需要自己实现异常处理表和相关的运行时函数。这是一项非常艰巨的任务。

七、I/O

为了替代 libc 的 printf 和 scanf，我们需要实现自定义的输入输出机制。我们可以直接使用系统调用来完成 I/O 操作。

以下是一个简单的 printf 函数的实现示例：

#include "syscalls.h"

void print_int(int n) {
    char buffer[20];
    int i = 0;
    if (n == 0) {
        buffer[i++] = '0';
    } else {
        if (n < 0) {
            print("-");
            n = -n;
        }
        while (n > 0) {
            buffer[i++] = (n % 10) + '0';
            n /= 10;
        }
    }

    for (int j = i - 1; j >= 0; j--) {
        char c[] = {buffer[j], 0};
        print(c);
    }
}

void printf(const char* format, ...) {
  va_list args;
  va_start(args, format);

  while (*format) {
    if (*format == '%') {
      format++;
      if (*format == 'd') {
          int val = va_arg(args, int);
          print_int(val);
      } else if (*format == 's') {
        const char* str = va_arg(args, const char*);
        print(str);
      } else if (*format == 'c'){
          char c = (char)va_arg(args, int);
          char str[] = {c, 0};
          print(str);

      }
       else {
        // 未知格式化字符，直接输出
        char str[] = {*format, 0};
        print(str);
      }
    } else {
        char str[] = {*format, 0};
        print(str);

    }
    format++;
  }

  va_end(args);
}

这个 printf 函数只支持 %d 和 %s 两种格式化字符，并且直接使用 write 系统调用进行输出。

八、C++ 标准库支持（部分）

即使不依赖 libc，我们仍然可以使用 C++ 的一些标准库功能。例如，我们可以使用 new 和 delete 操作符来动态分配和释放内存。我们也可以实现一些常用的数据结构，例如 vector 和 string。

以下是一个简单的 string 类的实现示例：

#include <stddef.h>
#include "memory.h"

class String {
private:
  char* data;
  size_t length;
  size_t capacity;

public:
  String() : data(nullptr), length(0), capacity(0) {}

  String(const char* str) {
    length = strlen(str);
    capacity = length + 1;
    data = (char*)allocate(capacity);
    strcpy(data, str);
  }

  ~String() {
    deallocate(data);
  }

  const char* c_str() const {
    return data;
  }

  size_t size() const {
    return length;
  }

  // 赋值操作
  String& operator=(const char* str) {
      if (data != nullptr) {
          deallocate(data);
      }
      length = strlen(str);
      capacity = length + 1;
      data = (char*)allocate(capacity);
      strcpy(data, str);
      return *this;
  }

private:
    size_t strlen(const char* str) const {
        size_t len = 0;
        while (*str++) len++;
        return len;
    }

    char* strcpy(char* dest, const char* src) {
        char* originalDest = dest;
        while (*src != '') {
            *dest++ = *src++;
        }
        *dest = '';
        return originalDest;
    }

};

这个 String 类使用我们自定义的内存分配器来存储字符串数据。

九、编译和链接

为了构建无 libc 的程序，我们需要使用特殊的编译和链接选项。以下是一些常用的选项：

-nostdlib: 禁止链接标准库。
-nodefaultlibs: 禁止链接默认的系统库。
-fno-builtin: 禁止使用内置函数。
-fno-exceptions: 禁用异常处理

以下是一个简单的编译和链接命令示例：

g++ -c -fno-exceptions -fno-rtti main.cpp -o main.o
g++ -c -fno-exceptions -fno-rtti memory.cpp -o memory.o
g++ -c -fno-exceptions -fno-rtti syscalls.cpp -o syscalls.o
as start.asm -o start.o
ld -T linker.ld -o myprogram start.o main.o memory.o syscalls.o -m elf_x86_64

其中，linker.ld 是一个链接脚本，用于指定程序的入口点和内存布局。一个简单的 linker.ld 脚本如下

ENTRY(_start)

SECTIONS
{
    . = 0x400000; /* 程序加载地址 */

    .text : {
        *(.text*)
    }

    .data : {
        *(.data*)
    }

    .bss : {
        *(.bss*)
    }
}

十、调试

调试无 libc 的程序可能比较困难，因为我们无法使用常用的调试工具，例如 GDB。一种方法是使用 print 语句来输出程序的运行状态。另一种方法是使用硬件调试器，例如 JTAG。

十一、总结

构建无 libc 的 C++ 运行时环境是一个复杂而艰巨的任务，但它可以带来更高的性能、更小的体积和更强的安全性。通过接管 libc 的关键功能，我们可以对底层 I/O 和系统调用进行完全的定制化，从而实现更大的灵活性。虽然有难度，但可以更深刻的理解操作系统和编程语言的底层实现原理。

更多IT精英技术系列讲座，到智猿学院

C++ 无 C 库依赖的运行时环境：定制化底层 I/O 与系统调用

发表回复 取消回复

发表回复取消回复