内存分配

静态内存分配

全局变量或静态变量静态内存分配，编译时内存分配在data段上，程序运行期间永久可用

let a = 0

struct S {
    static let a = 0
}

#![allow(unused)]
fn main() {
static mut A: usize = 0;
}

static int a = 0;

// arm64, AT&T

    .data
_a:
    .quad 0

栈内存分配

基础类型或栈上复合类型的局部变量栈内存分配
编译时生成管理栈的汇编代码，进入函数分配栈，离开函数回收栈
运行时内存分配在栈上，在函数内部可用

struct S {
    let a: Int
    let b: Int
    let c: Int
}

let a = 0
let s = S(a: 1, b: 2, c: 3)

#![allow(unused)]
fn main() {
struct S {
    a: i32,
    b: i32,
    c: i32,
}

let a = 0;
let s = S { a: 1, b: 2, c: 3 };
}

struct S {
    int a;
    int b;
    int c;
};

int a = 0;
struct S s = {1, 2, 3};

// arm64, AT&T

_main:
    sub sp, sp, #64
    stp x29, x30, [sp, #48]
    add x29, sp, #48


    // int a = 0;
    mov w8, #0
    str w8, [x29, #-4*1]

    // struct S s = {1, 2, 3};
    mov w8, #1
    str w8, [x29, #-4*4]
    mov w8, #2
    str w8, [x29, #-4*3]
    mov w8, #3
    str w8, [x29, #-4*2]


    ldp x29, x30, [sp, #48]
    add sp, sp, #64

    ret

堆内存分配

堆上复合类型的局部变量堆内存分配
运行时内存分配在堆上，按照堆内存管理规则，在堆内存被释放前可用

在栈上保存堆内存的地址，即指针变量是分配在栈上的

class C {
    let a: Int
    
    init(a: Int) {
        self.a = a
    }
}

let c = C(a: 1)

#![allow(unused)]
fn main() {
struct C {
    a: i32,
}

let c = Box::new(C { a: 1 });
}

struct C {
    int a;
};

struct C *c = malloc(sizeof(struct C));
c->a = 1;

// arm64, AT&T

_main:
    sub sp, sp, #64
    stp x29, x30, [sp, #48]
    add x29, sp, #48


    // struct C *c = malloc(sizeof(struct C));
    mov	x0, #4
    bl _malloc
    str x0, [x29, #-8]

    // c->a = 1;
    mov w8, #1
    ldr x9, [x29, #-8]
    str w8, [x9]


    ldp x29, x30, [sp, #48]
    add sp, sp, #64

    ret