rename mm_allocN
This commit is contained in:
parent
43d0d1e043
commit
49810ce8bc
@ -20,7 +20,7 @@ B m_str32(u32* s) {
|
||||
}
|
||||
|
||||
static B m_c32slice(B p, u32* ptr) {
|
||||
C32Slice* r = mm_allocN(sizeof(C32Slice), t_c32slice);
|
||||
C32Slice* r = mm_alloc(sizeof(C32Slice), t_c32slice);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return tag(r, ARR_TAG);
|
||||
|
||||
@ -9,19 +9,19 @@ typedef struct C32Slice {
|
||||
|
||||
|
||||
static B m_c32arrv(u32** p, usz ia) {
|
||||
C32Arr* r = mm_allocN(fsizeof(C32Arr,a,u32,ia), t_c32arr);
|
||||
C32Arr* r = mm_alloc(fsizeof(C32Arr,a,u32,ia), t_c32arr);
|
||||
*p = r->a;
|
||||
arrP_shVec((Arr*)r, ia);
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
static B m_c32arrc(u32** p, B x) { assert(isArr(x));
|
||||
C32Arr* r = mm_allocN(fsizeof(C32Arr,a,u32,a(x)->ia), t_c32arr);
|
||||
C32Arr* r = mm_alloc(fsizeof(C32Arr,a,u32,a(x)->ia), t_c32arr);
|
||||
*p = r->a;
|
||||
arrP_shCopy((Arr*)r, x);
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
static B m_c32arrp(u32** p, usz ia) { // doesn't write shape/rank
|
||||
C32Arr* r = mm_allocN(fsizeof(C32Arr,a,u32,ia), t_c32arr);
|
||||
C32Arr* r = mm_alloc(fsizeof(C32Arr,a,u32,ia), t_c32arr);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return tag(r, ARR_TAG);
|
||||
|
||||
@ -35,11 +35,11 @@ B fork_c2(B t, B w, B x);
|
||||
B md2H_c1(B d, B x);
|
||||
B md2H_c2(B d, B w, B x);
|
||||
// consume all args
|
||||
static B m_md1D(B m, B f ) { Md1D* r = mm_allocN(sizeof(Md1D), t_md1D); r->f = f; r->m1 = m; r->c1=md1D_c1; r->c2=md1D_c2; return tag(r,FUN_TAG); }
|
||||
static B m_md2D(B m, B f, B g) { Md2D* r = mm_allocN(sizeof(Md2D), t_md2D); r->f = f; r->m2 = m; r->g = g; r->c1=md2D_c1; r->c2=md2D_c2; return tag(r,FUN_TAG); }
|
||||
static B m_md2H(B m, B g) { Md2H* r = mm_allocN(sizeof(Md2H), t_md2H); r->m2 = m; r->g = g; r->c1=md2H_c1; r->c2=md2H_c2; return tag(r,MD1_TAG); }
|
||||
static B m_fork(B f, B g, B h) { Fork* r = mm_allocN(sizeof(Fork), t_fork); r->f = f; r->g = g; r->h = h; r->c1=fork_c1; r->c2=fork_c2; return tag(r,FUN_TAG); }
|
||||
static B m_atop( B g, B h) { Atop* r = mm_allocN(sizeof(Atop), t_atop); r->g = g; r->h = h; r->c1=tr2D_c1; r->c2=tr2D_c2; return tag(r,FUN_TAG); }
|
||||
static B m_md1D(B m, B f ) { Md1D* r = mm_alloc(sizeof(Md1D), t_md1D); r->f = f; r->m1 = m; r->c1=md1D_c1; r->c2=md1D_c2; return tag(r,FUN_TAG); }
|
||||
static B m_md2D(B m, B f, B g) { Md2D* r = mm_alloc(sizeof(Md2D), t_md2D); r->f = f; r->m2 = m; r->g = g; r->c1=md2D_c1; r->c2=md2D_c2; return tag(r,FUN_TAG); }
|
||||
static B m_md2H(B m, B g) { Md2H* r = mm_alloc(sizeof(Md2H), t_md2H); r->m2 = m; r->g = g; r->c1=md2H_c1; r->c2=md2H_c2; return tag(r,MD1_TAG); }
|
||||
static B m_fork(B f, B g, B h) { Fork* r = mm_alloc(sizeof(Fork), t_fork); r->f = f; r->g = g; r->h = h; r->c1=fork_c1; r->c2=fork_c2; return tag(r,FUN_TAG); }
|
||||
static B m_atop( B g, B h) { Atop* r = mm_alloc(sizeof(Atop), t_atop); r->g = g; r->h = h; r->c1=tr2D_c1; r->c2=tr2D_c2; return tag(r,FUN_TAG); }
|
||||
|
||||
// consume all args
|
||||
static B m1_d(B m, B f ) { if(isMd1(m)) return TI(m).m1_d(m, f ); thrM("Interpreting non-1-modifier as 1-modifier"); }
|
||||
|
||||
@ -7,7 +7,7 @@ NOINLINE B m_caf64(usz sz, f64* a) {
|
||||
}
|
||||
|
||||
static B m_f64slice(B p, f64* ptr) {
|
||||
F64Slice* r = mm_allocN(sizeof(F64Slice), t_f64slice);
|
||||
F64Slice* r = mm_alloc(sizeof(F64Slice), t_f64slice);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return tag(r, ARR_TAG);
|
||||
|
||||
@ -9,19 +9,19 @@ typedef struct F64Slice {
|
||||
|
||||
|
||||
static B m_f64arrv(f64** p, usz ia) {
|
||||
F64Arr* r = mm_allocN(fsizeof(F64Arr,a,f64,ia), t_f64arr);
|
||||
F64Arr* r = mm_alloc(fsizeof(F64Arr,a,f64,ia), t_f64arr);
|
||||
*p = r->a;
|
||||
arrP_shVec((Arr*)r, ia);
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
static B m_f64arrc(f64** p, B x) { assert(isArr(x));
|
||||
F64Arr* r = mm_allocN(fsizeof(F64Arr,a,f64,a(x)->ia), t_f64arr);
|
||||
F64Arr* r = mm_alloc(fsizeof(F64Arr,a,f64,a(x)->ia), t_f64arr);
|
||||
*p = r->a;
|
||||
arrP_shCopy((Arr*)r, x);
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
static B m_f64arrp(f64** p, usz ia) { // doesn't write shape/rank
|
||||
F64Arr* r = mm_allocN(fsizeof(F64Arr,a,f64,ia), t_f64arr);
|
||||
F64Arr* r = mm_alloc(fsizeof(F64Arr,a,f64,ia), t_f64arr);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return tag(r, ARR_TAG);
|
||||
|
||||
@ -194,7 +194,7 @@ B withFill(B x, B fill) { // consumes both
|
||||
return r;
|
||||
}
|
||||
base:;
|
||||
FillArr* r = mm_allocN(fsizeof(FillArr,a,B,ia), t_fillarr);
|
||||
FillArr* r = mm_alloc(fsizeof(FillArr,a,B,ia), t_fillarr);
|
||||
arrP_shCopy((Arr*)r, x);
|
||||
r->fill = fill;
|
||||
B* a = r->a;
|
||||
|
||||
@ -60,14 +60,14 @@ static B getFillE(B x) { // errors if there's no fill
|
||||
|
||||
|
||||
static B m_fillarrp(usz ia) { // doesn't set ia
|
||||
return tag(mm_allocN(fsizeof(FillArr,a,B,ia), t_fillarr), ARR_TAG);
|
||||
return tag(mm_alloc(fsizeof(FillArr,a,B,ia), t_fillarr), ARR_TAG);
|
||||
}
|
||||
static void fillarr_setFill(B x, B fill) { // consumes fill
|
||||
c(FillArr, x)->fill = fill;
|
||||
}
|
||||
|
||||
static B m_fillslice(B p, B* ptr) {
|
||||
FillSlice* r = mm_allocN(sizeof(FillSlice), t_fillslice);
|
||||
FillSlice* r = mm_alloc(sizeof(FillSlice), t_fillslice);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return tag(r, ARR_TAG);
|
||||
@ -84,7 +84,7 @@ static B m_unit(B x) {
|
||||
r.a[0] = x;
|
||||
return r.b;
|
||||
}
|
||||
FillArr* r = mm_allocN(fsizeof(FillArr,a,B,1), t_fillarr);
|
||||
FillArr* r = mm_alloc(fsizeof(FillArr,a,B,1), t_fillarr);
|
||||
arrP_shAllocI((Arr*)r, 1, 0);
|
||||
r->fill = xf;
|
||||
r->a[0] = x;
|
||||
|
||||
@ -92,7 +92,7 @@ NOINLINE void harr_pfree(B x, usz am) { // am - item after last written
|
||||
|
||||
|
||||
B m_hslice(B p, B* ptr) {
|
||||
HSlice* r = mm_allocN(sizeof(HSlice), t_hslice);
|
||||
HSlice* r = mm_alloc(sizeof(HSlice), t_hslice);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return tag(r, ARR_TAG);
|
||||
|
||||
@ -24,7 +24,7 @@ NOINLINE void harr_pfree(B x, usz am); // am - item after last written
|
||||
|
||||
|
||||
static HArr_p m_harrs(usz ia, usz* ctr) { // writes just ia
|
||||
HArr* r = mm_allocN(fsizeof(HArr,a,B,ia), t_harrPartial);
|
||||
HArr* r = mm_alloc(fsizeof(HArr,a,B,ia), t_harrPartial);
|
||||
r->ia = ia;
|
||||
r->sh = ctr;
|
||||
HArr_p rp = harrP_parts(r);
|
||||
@ -65,17 +65,17 @@ static void harr_abandon(HArr_p p) { VTY(p.b, t_harrPartial);
|
||||
}
|
||||
|
||||
static HArr_p m_harrUv(usz ia) {
|
||||
HArr* r = mm_allocN(fsizeof(HArr,a,B,ia), t_harr);
|
||||
HArr* r = mm_alloc(fsizeof(HArr,a,B,ia), t_harr);
|
||||
arrP_shVec((Arr*)r, ia);
|
||||
return harrP_parts(r);
|
||||
}
|
||||
static HArr_p m_harrUc(B x) { assert(isArr(x));
|
||||
HArr* r = mm_allocN(fsizeof(HArr,a,B,a(x)->ia), t_harr);
|
||||
HArr* r = mm_alloc(fsizeof(HArr,a,B,a(x)->ia), t_harr);
|
||||
arrP_shCopy((Arr*)r, x);
|
||||
return harrP_parts(r);
|
||||
}
|
||||
static HArr_p m_harrUp(usz ia) { // doesn't write shape/rank
|
||||
HArr* r = mm_allocN(fsizeof(HArr,a,B,ia), t_harr);
|
||||
HArr* r = mm_alloc(fsizeof(HArr,a,B,ia), t_harr);
|
||||
r->ia = ia;
|
||||
return harrP_parts(r);
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@ NOINLINE B m_cai32(usz ia, i32* a) {
|
||||
}
|
||||
|
||||
static B m_i32slice(B p, i32* ptr) {
|
||||
I32Slice* r = mm_allocN(sizeof(I32Slice), t_i32slice);
|
||||
I32Slice* r = mm_alloc(sizeof(I32Slice), t_i32slice);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return tag(r, ARR_TAG);
|
||||
|
||||
@ -9,19 +9,19 @@ typedef struct I32Slice {
|
||||
|
||||
|
||||
static B m_i32arrv(i32** p, usz ia) {
|
||||
I32Arr* r = mm_allocN(fsizeof(I32Arr,a,i32,ia), t_i32arr);
|
||||
I32Arr* r = mm_alloc(fsizeof(I32Arr,a,i32,ia), t_i32arr);
|
||||
*p = r->a;
|
||||
arrP_shVec((Arr*)r, ia);
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
static B m_i32arrc(i32** p, B x) { assert(isArr(x));
|
||||
I32Arr* r = mm_allocN(fsizeof(I32Arr,a,i32,a(x)->ia), t_i32arr);
|
||||
I32Arr* r = mm_alloc(fsizeof(I32Arr,a,i32,a(x)->ia), t_i32arr);
|
||||
*p = r->a;
|
||||
arrP_shCopy((Arr*)r, x);
|
||||
return tag(r, ARR_TAG);
|
||||
}
|
||||
static B m_i32arrp(i32** p, usz ia) { // doesn't write shape/rank
|
||||
I32Arr* r = mm_allocN(fsizeof(I32Arr,a,i32,ia), t_i32arr);
|
||||
I32Arr* r = mm_alloc(fsizeof(I32Arr,a,i32,ia), t_i32arr);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return tag(r, ARR_TAG);
|
||||
|
||||
@ -19,7 +19,7 @@ NOINLINE TStack* ts_e(TStack* o, u32 elsz, u64 am) { u64 size = o->size;
|
||||
if (alsz==mm_size((Value*)o)) {
|
||||
n = o;
|
||||
} else {
|
||||
n = (TStack*)mm_allocN(alsz, t_temp);
|
||||
n = (TStack*)mm_alloc(alsz, t_temp);
|
||||
memcpy(n->data, o->data, o->cap*elsz);
|
||||
mm_free((Value*)o);
|
||||
n->size = size;
|
||||
|
||||
@ -3,7 +3,7 @@ extern u64 allocB; // currently allocated number of bytes
|
||||
|
||||
// memory defs
|
||||
|
||||
static void* mm_allocN(usz sz, u8 type);
|
||||
static void* mm_alloc(usz sz, u8 type);
|
||||
static void mm_free(Value* x);
|
||||
static u64 mm_size(Value* x);
|
||||
static void mm_visit(B x);
|
||||
@ -11,10 +11,6 @@ static void mm_visitP(void* x);
|
||||
NORETURN void bqn_exit(i32 code);
|
||||
u64 mm_heapUsed();
|
||||
void printAllocStats();
|
||||
static B mm_alloc(usz sz, u8 type, u64 tag) {
|
||||
assert(tag>1LL<<16 || tag==0); // make sure it's `ftag`ged :|
|
||||
return b((u64)mm_allocN(sz,type) | tag);
|
||||
}
|
||||
|
||||
|
||||
#ifndef MAP_NORESERVE
|
||||
@ -37,7 +33,7 @@ static void decSh(Value* x) { if (prnk(x)>1) ptr_dec(shObjP(x)); }
|
||||
|
||||
static ShArr* m_shArr(ur r) {
|
||||
assert(r>1);
|
||||
return ((ShArr*)mm_allocN(fsizeof(ShArr, a, usz, r), t_shape));
|
||||
return ((ShArr*)mm_alloc(fsizeof(ShArr, a, usz, r), t_shape));
|
||||
}
|
||||
|
||||
static void arr_shVec(B x, usz ia) {
|
||||
|
||||
@ -140,7 +140,7 @@ INS B i_FLDO(B ns, u32 p, Scope* sc) {
|
||||
return r;
|
||||
}
|
||||
INS B i_NSPM(B o, u32 l) {
|
||||
FldAlias* a = mm_allocN(sizeof(FldAlias), t_fldAlias);
|
||||
FldAlias* a = mm_alloc(sizeof(FldAlias), t_fldAlias);
|
||||
a->obj = o;
|
||||
a->p = l;
|
||||
return tag(a,OBJ_TAG);
|
||||
|
||||
@ -61,7 +61,7 @@ typedef u8 Reg;
|
||||
#define R_P4 12 // r12
|
||||
|
||||
|
||||
#define ALLOC_ASM_ARR(N) TStack* b_o = (TStack*)mm_allocN(sizeof(TStack)+(N), t_temp); b_o->size=0; b_o->cap=(N)
|
||||
#define ALLOC_ASM_ARR(N) TStack* b_o = (TStack*)mm_alloc(sizeof(TStack)+(N), t_temp); b_o->size=0; b_o->cap=(N)
|
||||
#define ALLOC_ASM(N) ALLOC_ASM_ARR(N); TSALLOC(u32, b_r, 64);
|
||||
#define GET_ASM() u8* bin = b_o->data;
|
||||
#define AADD(P,N) b_o=asm_add(b_o, P, N)
|
||||
|
||||
18
src/load.c
18
src/load.c
@ -384,25 +384,25 @@ static inline void base_init() { // very first init function
|
||||
ti[t_funBI].free = ti[t_md1BI].free = ti[t_md2BI].free = builtin_free;
|
||||
assert((MD1_TAG>>1) == (MD2_TAG>>1)); // just to be sure it isn't changed incorrectly, `isMd` depends on this
|
||||
|
||||
#define FA(N,X) { BFn* f = mm_allocN(sizeof(BFn), t_funBI); f->c2=N##_c2 ; f->c1=N##_c1 ; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
#define FM(N,X) { BFn* f = mm_allocN(sizeof(BFn), t_funBI); f->c2=c2_invalid; f->c1=N##_c1 ; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
#define FD(N,X) { BFn* f = mm_allocN(sizeof(BFn), t_funBI); f->c2=N##_c2 ; f->c1=c1_invalid; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
#define FA(N,X) { BFn* f = mm_alloc(sizeof(BFn), t_funBI); f->c2=N##_c2 ; f->c1=N##_c1 ; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
#define FM(N,X) { BFn* f = mm_alloc(sizeof(BFn), t_funBI); f->c2=c2_invalid; f->c1=N##_c1 ; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
#define FD(N,X) { BFn* f = mm_alloc(sizeof(BFn), t_funBI); f->c2=N##_c2 ; f->c1=c1_invalid; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
FOR_PFN(FA,FM,FD)
|
||||
#undef FA
|
||||
#undef FM
|
||||
#undef FD
|
||||
|
||||
#define FA(N,X) { Md1* m = mm_allocN(sizeof(Md1), t_md1BI); m->c2 = N##_c2 ; m->c1 = N##_c1 ; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
#define FM(N,X) { Md1* m = mm_allocN(sizeof(Md1), t_md1BI); m->c2 = c2_invalid; m->c1 = N##_c1 ; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
#define FD(N,X) { Md1* m = mm_allocN(sizeof(Md1), t_md1BI); m->c2 = N##_c2 ; m->c1 = c1_invalid; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
#define FA(N,X) { Md1* m = mm_alloc(sizeof(Md1), t_md1BI); m->c2 = N##_c2 ; m->c1 = N##_c1 ; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
#define FM(N,X) { Md1* m = mm_alloc(sizeof(Md1), t_md1BI); m->c2 = c2_invalid; m->c1 = N##_c1 ; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
#define FD(N,X) { Md1* m = mm_alloc(sizeof(Md1), t_md1BI); m->c2 = N##_c2 ; m->c1 = c1_invalid; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
FOR_PM1(FA,FM,FD)
|
||||
#undef FA
|
||||
#undef FM
|
||||
#undef FD
|
||||
|
||||
#define FA(N,X) { BMd2* m = mm_allocN(sizeof(BMd2), t_md2BI); m->c2 = N##_c2 ; m->c1 = N##_c1; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
#define FM(N,X) { BMd2* m = mm_allocN(sizeof(BMd2), t_md2BI); m->c2 = N##_c2 ; m->c1 = c1_invalid; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
#define FD(N,X) { BMd2* m = mm_allocN(sizeof(BMd2), t_md2BI); m->c2 = c2_invalid; m->c1 = N##_c1; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
#define FA(N,X) { BMd2* m = mm_alloc(sizeof(BMd2), t_md2BI); m->c2 = N##_c2 ; m->c1 = N##_c1; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
#define FM(N,X) { BMd2* m = mm_alloc(sizeof(BMd2), t_md2BI); m->c2 = N##_c2 ; m->c1 = c1_invalid; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
#define FD(N,X) { BMd2* m = mm_alloc(sizeof(BMd2), t_md2BI); m->c2 = c2_invalid; m->c1 = N##_c1; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
FOR_PM2(FA,FM,FD)
|
||||
#undef FA
|
||||
#undef FM
|
||||
|
||||
@ -15,7 +15,7 @@ static B nfn_list;
|
||||
|
||||
NFnDesc* registerNFn(B name, BB2B c1, BBB2B c2) {
|
||||
u32 id = nfn_curr++;
|
||||
NFnDesc* r = mm_allocN(sizeof(NFnDesc), t_nfnDesc);
|
||||
NFnDesc* r = mm_alloc(sizeof(NFnDesc), t_nfnDesc);
|
||||
r->id = id;
|
||||
r->c1 = c1;
|
||||
r->c2 = c2;
|
||||
@ -24,7 +24,7 @@ NFnDesc* registerNFn(B name, BB2B c1, BBB2B c2) {
|
||||
return r;
|
||||
}
|
||||
B m_nfn(NFnDesc* desc, B obj) {
|
||||
NFn* r = mm_allocN(sizeof(NFn), t_nfn);
|
||||
NFn* r = mm_alloc(sizeof(NFn), t_nfn);
|
||||
r->id = desc->id;
|
||||
r->c1 = desc->c1;
|
||||
r->c2 = desc->c2;
|
||||
|
||||
4
src/ns.c
4
src/ns.c
@ -10,7 +10,7 @@ void m_nsDesc(Body* body, bool imm, u8 ty, B nameList, B varIDs, B exported) { /
|
||||
i32 vam = ia+off;
|
||||
if (vam != body->varAm) thrM("Bad namespace description information");
|
||||
|
||||
NSDesc* r = mm_allocN(fsizeof(NSDesc, expIDs, i32, vam), t_nsDesc);
|
||||
NSDesc* r = mm_alloc(fsizeof(NSDesc, expIDs, i32, vam), t_nsDesc);
|
||||
r->nameList = nameList;
|
||||
r->varAm = vam;
|
||||
BS2B getIDU = TI(varIDs).getU;
|
||||
@ -30,7 +30,7 @@ void m_nsDesc(Body* body, bool imm, u8 ty, B nameList, B varIDs, B exported) { /
|
||||
body->nsDesc = r;
|
||||
}
|
||||
B m_ns(Scope* sc, NSDesc* desc) { // consumes both
|
||||
NS* r = mm_allocN(sizeof(NS), t_ns);
|
||||
NS* r = mm_alloc(sizeof(NS), t_ns);
|
||||
r->desc = desc;
|
||||
r->nameList = r->desc->nameList;
|
||||
r->sc = sc;
|
||||
|
||||
@ -35,7 +35,7 @@ extern u64 mm_heapMax;
|
||||
extern u64 currObjCounter;
|
||||
#endif
|
||||
|
||||
static void* mm_allocN(usz sz, u8 type) {
|
||||
static void* mm_alloc(usz sz, u8 type) {
|
||||
assert(sz>=16);
|
||||
onAlloc(sz, type);
|
||||
u8 b1 = 64-__builtin_clzl(sz-1ull);
|
||||
|
||||
@ -20,7 +20,7 @@ extern u64 mm_heapMax;
|
||||
extern u64 currObjCounter;
|
||||
#endif
|
||||
|
||||
static void* mm_allocN(usz sz, u8 type) {
|
||||
static void* mm_alloc(usz sz, u8 type) {
|
||||
assert(sz>=16);
|
||||
onAlloc(sz, type);
|
||||
Value* r = mm_allocL(BSZI(sz), type);
|
||||
|
||||
@ -9,7 +9,7 @@ static void mm_free(Value* x) {
|
||||
free(x);
|
||||
}
|
||||
|
||||
static void* mm_allocN(usz sz, u8 type) {
|
||||
static void* mm_alloc(usz sz, u8 type) {
|
||||
Value* x = malloc(sz);
|
||||
onAlloc(sz, type);
|
||||
x->flags = x->extra = x->mmInfo = x->type = 0;
|
||||
|
||||
@ -153,7 +153,7 @@ B rtWrap_wrap(B t) {
|
||||
#ifdef RT_VERIFY
|
||||
if(v(t)->flags==0) return t;
|
||||
#endif
|
||||
WFun* r = mm_allocN(sizeof(WFun), t_funWrap);
|
||||
WFun* r = mm_alloc(sizeof(WFun), t_funWrap);
|
||||
r->extra = v(t)->extra;
|
||||
r->flags = v(t)->flags;
|
||||
r->c1 = wf_c1;
|
||||
@ -171,7 +171,7 @@ B rtWrap_wrap(B t) {
|
||||
}
|
||||
#ifdef RT_PERF
|
||||
if (isMd1(t)) {
|
||||
WMd1* r = mm_allocN(sizeof(WMd1), t_md1Wrap);
|
||||
WMd1* r = mm_alloc(sizeof(WMd1), t_md1Wrap);
|
||||
r->extra = v(t)->extra;
|
||||
r->flags = v(t)->flags;
|
||||
r->c1 = wm1_c1;
|
||||
@ -184,7 +184,7 @@ B rtWrap_wrap(B t) {
|
||||
}
|
||||
if (isMd2(t)) {
|
||||
Md2* fc = c(Md2,t);
|
||||
WMd2* r = mm_allocN(sizeof(WMd2), t_md2Wrap);
|
||||
WMd2* r = mm_alloc(sizeof(WMd2), t_md2Wrap);
|
||||
r->c1 = wm2_c1;
|
||||
r->c2 = wm2_c2;
|
||||
r->extra = fc->extra;
|
||||
|
||||
@ -30,7 +30,7 @@ TmpFile* file_bytes(B path) { // consumes
|
||||
fseek(f, 0, SEEK_END);
|
||||
u64 len = ftell(f);
|
||||
fseek(f, 0, SEEK_SET);
|
||||
TmpFile* src = mm_allocN(fsizeof(TmpFile,a,u8,len), t_i8arr);
|
||||
TmpFile* src = mm_alloc(fsizeof(TmpFile,a,u8,len), t_i8arr);
|
||||
arr_shVec(tag(src,ARR_TAG), len);
|
||||
if (fread((char*)src->a, 1, len, f)!=len) thrF("Error reading file \"%R\"", path);
|
||||
dec(path);
|
||||
|
||||
@ -46,7 +46,7 @@ typedef struct Map {
|
||||
|
||||
static Map* N(m) (u64 sz) {
|
||||
assert(sz && (sz & sz-1)==0);
|
||||
Map* r = mm_allocN(fsizeof(Map,a,Ent,sz), t_hashmap);
|
||||
Map* r = mm_alloc(fsizeof(Map,a,Ent,sz), t_hashmap);
|
||||
#ifdef HDEF
|
||||
for (u64 i = 0; i < sz; i++) r->a[i].hash = HDEF;
|
||||
#endif
|
||||
|
||||
@ -5,7 +5,7 @@ typedef struct TAlloc {
|
||||
u8 data[];
|
||||
} TAlloc;
|
||||
#define TOFF offsetof(TAlloc, data)
|
||||
#define TALLOC(T,N,AM) T* N = (T*) ((TAlloc*)mm_allocN(TOFF + (AM)*sizeof(T) + 8, t_temp))->data; // +8 so mm is happy
|
||||
#define TALLOC(T,N,AM) T* N = (T*) ((TAlloc*)mm_alloc(TOFF + (AM)*sizeof(T) + 8, t_temp))->data; // +8 so mm is happy
|
||||
#define TOBJ(N) (void*)((u8*)(N) - TOFF)
|
||||
#define TFREE(N) mm_free((Value*)TOBJ(N));
|
||||
#define TREALLOC(N, AM) talloc_realloc(TOBJ(N), AM)
|
||||
@ -25,7 +25,7 @@ typedef struct TStack {
|
||||
usz cap;
|
||||
u8 data[];
|
||||
} TStack;
|
||||
#define TSALLOC(T,N,I) usz N##_dc=(I); u32 N##_e=sizeof(T); TStack* N##_o = (TStack*)mm_allocN(sizeof(TStack)+N##_e*N##_dc, t_temp); N##_o->size=0; N##_o->cap=N##_dc; T* N = (T*)N##_o->data;
|
||||
#define TSALLOC(T,N,I) usz N##_dc=(I); u32 N##_e=sizeof(T); TStack* N##_o = (TStack*)mm_alloc(sizeof(TStack)+N##_e*N##_dc, t_temp); N##_o->size=0; N##_o->cap=N##_dc; T* N = (T*)N##_o->data;
|
||||
#define TSFREE(N) mm_free((Value*)N##_o);
|
||||
#define TSUPD(N,AM) { N##_o = ts_e(N##_o, N##_e, AM); N = (void*)N##_o->data; }
|
||||
#define TSADD(N,X) { if (N##_o->size==N##_o->cap) TSUPD(N, 1); N[N##_o->size++] = X; }
|
||||
|
||||
20
src/vm.c
20
src/vm.c
@ -131,7 +131,7 @@ Block* compileBlock(B block, Comp* comp, bool* bDone, u32* bc, usz bcIA, B block
|
||||
ScopeExt* oE = sc->ext;
|
||||
if (oE==NULL || vam > regAm + oE->varAm) {
|
||||
i32 nSZ = vam - regAm;
|
||||
ScopeExt* nE = mm_allocN(fsizeof(ScopeExt, vars, B, nSZ*2), t_scopeExt);
|
||||
ScopeExt* nE = mm_alloc(fsizeof(ScopeExt, vars, B, nSZ*2), t_scopeExt);
|
||||
nE->varAm = nSZ;
|
||||
i32 oSZ = 0;
|
||||
if (oE) {
|
||||
@ -218,7 +218,7 @@ Block* compileBlock(B block, Comp* comp, bool* bDone, u32* bc, usz bcIA, B block
|
||||
usz blC = TSSIZE(nBlT);
|
||||
BlBlocks* nBl = NULL;
|
||||
if (blC) {
|
||||
nBl = mm_allocN(fsizeof(BlBlocks,a,Block*,blC), t_blBlocks);
|
||||
nBl = mm_alloc(fsizeof(BlBlocks,a,Block*,blC), t_blBlocks);
|
||||
nBl->am = blC;
|
||||
memcpy(nBl->a, nBlT, blC*sizeof(Block*));
|
||||
}
|
||||
@ -227,7 +227,7 @@ Block* compileBlock(B block, Comp* comp, bool* bDone, u32* bc, usz bcIA, B block
|
||||
usz nbcC = TSSIZE(nBCT); i32* nbc; m_i32arrv(&nbc, nbcC); memcpy(nbc, nBCT, nbcC*4); TSFREE(nBCT);
|
||||
usz mapC = TSSIZE(mapT); i32* map; m_i32arrv(&map, mapC); memcpy(map, mapT, mapC*4); TSFREE(mapT);
|
||||
|
||||
Body* body = mm_allocN(fsizeof(Body,varIDs,i32,vam), t_body);
|
||||
Body* body = mm_alloc(fsizeof(Body,varIDs,i32,vam), t_body);
|
||||
body->comp = comp; ptr_inc(comp);
|
||||
body->bc = (u32*)nbc;
|
||||
#if JIT_START != -1
|
||||
@ -247,7 +247,7 @@ Block* compileBlock(B block, Comp* comp, bool* bDone, u32* bc, usz bcIA, B block
|
||||
for (i32 i = 0; i < vam; i++) body->varIDs[i] = -1;
|
||||
} else m_nsDesc(body, imm, ty, inc(nameList), bgetU(block,4), bgetU(block,5));
|
||||
|
||||
Block* bl = mm_allocN(sizeof(Block), t_block);
|
||||
Block* bl = mm_alloc(sizeof(Block), t_block);
|
||||
bl->body = body;
|
||||
bl->imm = imm;
|
||||
bl->ty = (u8)ty;
|
||||
@ -261,7 +261,7 @@ NOINLINE Block* compile(B bcq, B objs, B blocks, B indices, B tokenInfo, B src,
|
||||
I32Arr* bca = toI32Arr(bcq);
|
||||
u32* bc = (u32*)bca->a;
|
||||
usz bcIA = bca->ia;
|
||||
Comp* comp = mm_allocN(sizeof(Comp), t_comp);
|
||||
Comp* comp = mm_alloc(sizeof(Comp), t_comp);
|
||||
comp->bc = tag(bca, ARR_TAG);
|
||||
comp->indices = indices;
|
||||
comp->src = src;
|
||||
@ -539,7 +539,7 @@ B evalBC(Body* b, Scope* sc) { // doesn't consume
|
||||
goto end;
|
||||
}
|
||||
case NSPM: { P(o) u32 l = *bc++;
|
||||
FldAlias* a = mm_allocN(sizeof(FldAlias), t_fldAlias);
|
||||
FldAlias* a = mm_alloc(sizeof(FldAlias), t_fldAlias);
|
||||
a->obj = o;
|
||||
a->p = l;
|
||||
ADD(tag(a,OBJ_TAG));
|
||||
@ -581,7 +581,7 @@ B evalBC(Body* b, Scope* sc) { // doesn't consume
|
||||
}
|
||||
|
||||
Scope* m_scope(Body* body, Scope* psc, u16 varAm, i32 initVarAm, B* initVars) { // doesn't consume
|
||||
Scope* sc = mm_allocN(fsizeof(Scope, vars, B, varAm), t_scope);
|
||||
Scope* sc = mm_alloc(fsizeof(Scope, vars, B, varAm), t_scope);
|
||||
sc->body = body; ptr_inc(body);
|
||||
sc->psc = psc; if(psc) ptr_inc(psc);
|
||||
sc->varAm = varAm;
|
||||
@ -650,7 +650,7 @@ B md2Bl_c1(B D, B x) { Md2D* d=c(Md2D,D); Md2Block* b=c(Md2Block, d->m2); p
|
||||
B md2Bl_c2(B D, B w, B x) { Md2D* d=c(Md2D,D); Md2Block* b=c(Md2Block, d->m2); ptr_inc(d); return execBlock(b->bl, b->sc, 6, (B[]){D, x, w , inc(d->m2), inc(d->f), inc(d->g)}); }
|
||||
B m_funBlock(Block* bl, Scope* psc) { // doesn't consume anything
|
||||
if (bl->imm) return execBlock(bl, psc, 0, NULL);
|
||||
FunBlock* r = mm_allocN(sizeof(FunBlock), t_fun_block);
|
||||
FunBlock* r = mm_alloc(sizeof(FunBlock), t_fun_block);
|
||||
r->bl = bl; ptr_inc(bl);
|
||||
r->sc = psc; ptr_inc(psc);
|
||||
r->c1 = funBl_c1;
|
||||
@ -658,7 +658,7 @@ B m_funBlock(Block* bl, Scope* psc) { // doesn't consume anything
|
||||
return tag(r, FUN_TAG);
|
||||
}
|
||||
B m_md1Block(Block* bl, Scope* psc) {
|
||||
Md1Block* r = mm_allocN(sizeof(Md1Block), t_md1_block);
|
||||
Md1Block* r = mm_alloc(sizeof(Md1Block), t_md1_block);
|
||||
r->bl = bl; ptr_inc(bl);
|
||||
r->sc = psc; ptr_inc(psc);
|
||||
r->c1 = md1Bl_c1;
|
||||
@ -666,7 +666,7 @@ B m_md1Block(Block* bl, Scope* psc) {
|
||||
return tag(r, MD1_TAG);
|
||||
}
|
||||
B m_md2Block(Block* bl, Scope* psc) {
|
||||
Md2Block* r = mm_allocN(sizeof(Md2Block), t_md2_block);
|
||||
Md2Block* r = mm_alloc(sizeof(Md2Block), t_md2_block);
|
||||
r->bl = bl; ptr_inc(bl);
|
||||
r->sc = psc; ptr_inc(psc);
|
||||
r->c1 = md2Bl_c1;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user