启用优化后使用std::alloc出现非法指令崩溃，如何修复？

问题场景 #

这段Rust代码在opt_level=0编译下运行正常，但启用opt_level=3优化编译后，运行触发Illegal instruction(core dumped)错误，相关代码及环境信息如下：

代码示例 #

use std::alloc;

fn main() {
    let name = String::from("a");
    let obj = unsafe { GcObject::allocate(name) };

    println!("{:?}", obj.object);
}

pub struct GcObject {
    object: *mut Object,
}

impl GcObject {
    pub unsafe fn allocate(object: String) -> Self {
        let layout = alloc::Layout::new::<Object>();

        // Allocate the object
        let ptr = alloc::alloc(layout) as *mut Object;

        if ptr.is_null() {
            eprintln!("Alloc error!");
            alloc::handle_alloc_error(layout);
        }

        *ptr = Object { kind: object };

        GcObject { object: ptr }
    }
}

struct Object {
    kind: String,
}

环境与编译信息 #

• Rustc版本：rustc 1.70.0 (90c541806 2023-05-31)
• 平台：Fedora Linux 38
• 正常编译命令：rustc main.rs -C opt_level=0
• 崩溃编译命令：rustc main.rs -C opt_level=3
• 报错信息：Illegal instruction(core dumped)

问题根源 #

代码的核心问题是手动分配内存后直接初始化包含String的Object结构体，违反了Rust内存安全规则：

1. alloc::alloc仅分配原始内存，不会调用任何类型的构造函数。String是带有堆内存指针的复杂类型，直接通过*ptr = Object { kind: object }赋值时，相当于在未初始化内存上执行String的移动操作，会破坏内存布局；优化编译时编译器生成的激进指令会直接触发非法指令错误。
2. 代码未处理内存释放，会造成内存泄漏，但这不是崩溃的直接原因。

修复方法 #

方法1：使用Box替代手动内存分配（推荐） #

Rust的Box已封装安全的堆内存分配与释放，完全无需手动调用alloc模块，既保证安全又避免崩溃：

fn main() {
    let name = String::from("a");
    let obj = GcObject::allocate(name);

    println!("{:?}", obj.object);
}

pub struct GcObject {
    object: Box<Object>,
}

impl GcObject {
    pub fn allocate(object: String) -> Self {
        let obj_box = Box::new(Object { kind: object });
        GcObject { object: obj_box }
    }
}

struct Object {
    kind: String,
}

方法2：正确使用手动内存分配（仅在必须手动管理内存时使用） #

若一定要手动调用alloc，需用ptr::write避免直接赋值触发未初始化内存上的移动操作，同时添加内存释放逻辑：

use std::alloc;
use std::ptr;

fn main() {
    let name = String::from("a");
    let mut obj = unsafe { GcObject::allocate(name) };

    println!("{:?}", obj.object);
    unsafe {
        obj.deallocate();
    }
}

pub struct GcObject {
    object: *mut Object,
}

impl GcObject {
    pub unsafe fn allocate(object: String) -> Self {
        let layout = alloc::Layout::new::<Object>();

        let ptr = alloc::alloc(layout) as *mut Object;

        if ptr.is_null() {
            eprintln!("Alloc error!");
            alloc::handle_alloc_error(layout);
        }

        // 使用ptr::write将值写入未初始化内存，避免移动操作
        ptr::write(ptr, Object { kind: object });

        GcObject { object: ptr }
    }

    pub unsafe fn deallocate(&mut self) {
        // 先调用Object的析构函数，释放String的堆内存
        ptr::drop_in_place(self.object);
        let layout = alloc::Layout::new::<Object>();
        alloc::dealloc(self.object as *mut u8, layout);
        self.object = ptr::null_mut();
    }
}

struct Object {
    kind: String,
}

// 实现Drop trait自动释放内存（可选，提升安全性）
impl Drop for GcObject {
    fn drop(&mut self) {
        if !self.object.is_null() {
            unsafe {
                self.deallocate();
            }
        }
    }
}

内容的提问来源于stack exchange，提问作者AVX-42