kolibrios-gitea/kernel/trunk/core/malloc.inc

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2024. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


; Small heap based on malloc/free/realloc written by Doug Lea
; Version 2.8.3 Thu Sep 22 11:16:15 2005  Doug Lea  (dl at gee)
; Source ftp://gee.cs.oswego.edu/pub/misc/malloc.c
; License http://creativecommons.org/licenses/publicdomain.


; eax= size

; temp
;  esi= nb
;  ebx= idx
;
align 4
malloc:
        push    ebx esi

; nb = ((size+7)&~7)+8;

        mov     esi, eax   ;size
        add     esi, 7
        and     esi, -8
        add     esi, 8

        mov     ecx, mst.mutex
        call    mutex_lock

        cmp     esi, 256
        jae     .large

        mov     ecx, esi
        shr     ecx, 3
        or      eax, -1
        shl     eax, cl
        and     eax, [mst.smallmap]
        jz      .small

        push    ebp
        push    edi

        bsf     eax, eax
        mov     ebx, eax

; psize= idx<<3;
; B = &ms.smallbins[idx];
; p = B->fd;
; F = p->fd;
; rsize= psize-nb;

        lea     ebp, [eax*8]              ;ebp= psize
        shl     eax, 4
        lea     edi, [mst.smallbins+eax]  ;edi= B
        mov     edx, [edi+8]              ;edx= p
        mov     eax, [edx+8]              ;eax= F
        mov     ecx, ebp
        sub     ecx, esi                  ;ecx= rsize

; if (B == F)
        cmp     edi, eax
        jne     @F

        btr     [mst.smallmap], ebx
@@:

; B->fd = F;
; F->bk = B;
; if(rsize<16)

        cmp     ecx, 16
        mov     [edi+8], eax
        mov     [eax+12], edi
        jae     .split

; p->head = psize|PINUSE_BIT|CINUSE_BIT;
; (p + psize)->head |= PINUSE_BIT;

        lea     eax, [edx+8]
        or      dword [edx+ebp+4], 1

        or      ebp, 3
        mov     [edx+4], ebp

        pop     edi
        pop     ebp
.done:
        mov     esi, eax
        mov     ecx, mst.mutex
        call    mutex_unlock
        mov     eax, esi
        pop     esi ebx
        ret

.split:
        lea     ebx, [edx+8]              ;ebx=mem

; r = chunk_plus_offset(p, nb);
; p->head = nb|PINUSE_BIT|CINUSE_BIT;
; r->head = rsize|PINUSE_BIT;

        lea     eax, [edx+esi]            ;eax= r
        or      esi, 3
        mov     [edx+4], esi

        mov     edx, ecx
        or      edx, 1
        mov     [eax+4], edx

; (r + rsize)->prev_foot = rsize;

        mov     [eax+ecx], ecx

; I  = rsize>>3;

        shr     ecx, 3

;      ms.smallmap |=  1<< I;
        bts     [mst.smallmap], ecx

; B = &ms.smallbins[I];

        shl     ecx, 4
        pop     edi
        pop     ebp
        add     ecx, mst.smallbins        ;ecx= B

        mov     edx, [ecx+8]              ; F = B->fd;
        mov     [ecx+8], eax              ; B->fd = r;
        mov     [edx+12], eax             ; F->bk = r;
        mov     [eax+8], edx              ; r->fd = F;
        mov     [eax+12], ecx             ; r->bk = B;

        mov     eax, ebx
        jmp     .done

.small:

; if (ms.treemap != 0 && (mem = malloc_small(nb)) != 0)
;;;;;;;;;;; start a change <lrz>
        mov     eax, [mst.treemap]
        test    eax, eax
;;;;;;;;;;; end the change <lrz>
;           cmp [mst.treemap], 0
        jz      .from_top
        mov     eax, esi
        call    malloc_small
        test    eax, eax
        jz      .from_top
        jmp     .done

.large:

; if (ms.treemap != 0 && (mem = malloc_large(nb)) != 0)

        cmp     [mst.treemap], 0
        je      .from_top

        call    malloc_large  ;esi= nb
        test    eax, eax
        jne     .done
.from_top:

; if (nb < ms.topsize)

        mov     eax, [mst.topsize]
        cmp     esi, eax
        jae     .fail

; rsize = ms.topsize -= nb;
; p = ms.top;

        mov     ecx, [mst.top]
        sub     eax, esi
        mov     [mst.topsize], eax

; r = ms.top = chunk_plus_offset(p, nb);
; r->head = rsize | PINUSE_BIT;
; p->head = nb |PINUSE_BIT|CINUSE_BIT;

        lea     edx, [ecx+esi]
        or      eax, 1
        mov     [mst.top], edx
        or      esi, 3
        mov     [edx+4], eax
        mov     [ecx+4], esi
        lea     eax, [ecx+8]
        jmp     .done

.fail:
        xor     eax, eax
        jmp     .done

; param
;  eax= mem
align 4
free:
        test    eax, eax
        jz      .exit

        push    ebx edi
        mov     edi, eax
        add     edi, -8

; if(p->head & CINUSE_BIT)

        test    byte [edi+4], 2
        je      .fail

        mov     ecx, mst.mutex
        call    mutex_lock

; psize = p->head & (~3);

        mov     eax, [edi+4]
        push    esi
        mov     esi, eax
        and     esi, -4

; next = chunk_plus_offset(p, psize);
; if(!(p->head & PINUSE_BIT))

        test    al, 1
        lea     ebx, [esi+edi]
        jne     .next

; prevsize = p->prev_foot;
; prev=p - prevsize;
; psize += prevsize;
; p = prev;

        mov     ecx, [edi] ;ecx= prevsize
        add     esi, ecx             ;esi= psize
        sub     edi, ecx             ;edi= p

; if (prevsize < 256)

        cmp     ecx, 256
        jae     .unlink_large

        mov     eax, [edi+8]         ;F = p->fd;
        mov     edx, [edi+12]        ;B = p->bk;

; if (F == B)
; ms.smallmap &=  ~(1<< I);
        shr     ecx, 3
        cmp     eax, edx
        jne     @F
        btr     [mst.smallmap], ecx
@@:
        mov     [eax+12], edx          ;F->bk = B;
        mov     [edx+8], eax           ;B->fd = F
        jmp     .next
.unlink_large:
        mov     edx, edi
        call    unlink_large_chunk
.next:

; if(next->head & PINUSE_BIT)

        mov     eax, [ebx+4]
        test    al, 1
        jz      .fail2

; if (! (next->head & CINUSE_BIT))

        test    al, 2
        jnz     .fix_next

; if (next == ms.top)

        cmp     ebx, [mst.top]
        jne     @F

; tsize = ms.topsize += psize;

        mov     eax, [mst.topsize]
        add     eax, esi
        mov     [mst.topsize], eax

; ms.top = p;
; p->head = tsize | PINUSE_BIT;

        or      eax, 1
        mov     [mst.top], edi
        mov     [edi+4], eax
.fail2:
        mov     esi, eax
        mov     ecx, mst.mutex
        call    mutex_unlock
        mov     eax, esi
        pop     esi
.fail:
        pop     edi ebx
.exit:
        ret

@@:

; nsize = next->head & ~INUSE_BITS;

        and     eax, -4
        add     esi, eax               ;psize += nsize;

; if (nsize < 256)

        cmp     eax, 256
        jae     .unl_large

        mov     edx, [ebx+8]           ;F = next->fd
        mov     ebx, [ebx+12]          ;B = next->bk

; if (F == B)

        cmp     edx, ebx
        jne     @F
        mov     ecx, eax
        shr     ecx, 3
        btr     [mst.smallmap], ecx
@@:
        mov     [edx+12], ebx          ;F->bk = B

; p->head = psize|PINUSE_BIT;

        mov     ecx, esi
        mov     [ebx+8], edx
        or      ecx, 1
        mov     [edi+4], ecx

; (p+psize)->prev_foot = psize;

        mov     [esi+edi], esi

; insert_chunk(p,psize);

        mov     eax, esi
        mov     ecx, edi
        call    insert_chunk
        jmp     .fail2
.unl_large:

; unlink_large_chunk((tchunkptr)next);

        mov     edx, ebx
        call    unlink_large_chunk
; p->head = psize|PINUSE_BIT;

        mov     ecx, esi
        or      ecx, 1
        mov     [edi+4], ecx

; (p+psize)->prev_foot = psize;

        mov     [esi+edi], esi

; insert_chunk(p,psize);

        mov     eax, esi
        mov     ecx, edi
        call    insert_chunk
        jmp     .fail2
.fix_next:

; (p+psize)->prev_foot = psize;
; next->head &= ~PINUSE_BIT;
; p->head = psize|PINUSE_BIT;

        and     eax, -2
        mov     edx, esi
        mov     [ebx+4], eax
        or      edx, 1
        mov     [edi+4], edx

; (p+psize)->prev_foot = psize;

        mov     [esi+edi], esi
; insert_chunk(p,psize);

        mov     eax, esi
        mov     ecx, edi
        call    insert_chunk
        jmp     .fail2

; param
;  ecx = chunk
;  eax = size

insert_chunk:

        cmp     eax, 256
        push    esi
        mov     esi, ecx
        jae     .large

; I  = S>>3;
; ms.smallmap |=  1<< I;

        shr     eax, 3
        bts     [mst.smallmap], eax

; B = &ms.smallbins[I];

        shl     eax, 4
        add     eax, mst.smallbins
        mov     edx, [eax+8]           ;F = B->fd
        mov     [eax+8], esi           ;B->fd = P
        mov     [edx+12], esi          ;F->bk = P
        mov     [esi+8], edx           ;P->fd = F
        mov     [esi+12], eax          ;P->bk = B
        pop     esi
        ret
.large:
        mov     ebx, eax
        call    insert_large_chunk
        pop     esi
        ret


; param
;  esi= chunk
;  ebx= size

insert_large_chunk:

; I = compute_tree_index(S);

        mov     edx, ebx
        shr     edx, 8
        bsr     eax, edx
        lea     ecx, [eax+7]
        mov     edx, ebx
        shr     edx, cl
        and     edx, 1
        lea     ecx, [edx+eax*2]

; X->index = I;
        mov     dword [esi+28], ecx

; X->child[0] = X->child[1] = 0;
        and     dword [esi+20], 0
        and     dword [esi+16], 0

; H = &ms.treebins[I];

        mov     eax, ecx
        lea     edx, [mst.treebins+eax*4]

; if (!(ms.treemap & 1<<I))
        bt      [mst.treemap], ecx
        jc      .tree

; ms.treemap |= 1<<I;
        bts     [mst.treemap], ecx
; *H = X;
        mov     dword [edx], esi
        jmp     .done
.tree:

; T = *H;
        mov     edx, [edx]

; K = S << leftshift_for_tree_index(I);
        mov     eax, ecx
        shr     eax, 1
        sub     ecx, 31
        mov     edi, 37
        sub     edi, eax
        neg     ecx
        sbb     ecx, ecx
        and     ecx, edi
        mov     eax, ebx
        shl     eax, cl    ;eax= K

        jmp     .loop
.not_eq_size:

; C = &(T->child[(K >> 31) & 1]);
        mov     ecx, eax
        shr     ecx, 31
        lea     ecx, [edx+ecx*4+16]

; K <<= 1;
; if (*C != 0)
        mov     edi, [ecx]
        add     eax, eax
        test    edi, edi
        jz      .insert_child

; T = *C;
        mov     edx, edi
.loop:

; for (;;)
; if ((T->head & ~INUSE_BITS) != S)

        mov     ecx, [edx+4]
        and     ecx, not 3
        cmp     ecx, ebx
        jne     .not_eq_size

; F = T->fd;
        mov     eax, [edx+8]

; T->fd = F->bk = X;
        mov     [eax+12], esi
        mov     [edx+8], esi

; X->fd = F;
; X->bk = T;
; X->parent = 0;

        and     dword [esi+24], 0
        mov     [esi+8], eax
        mov     [esi+12], edx
        ret
.insert_child:

; *C = X;
        mov     [ecx], esi
.done:

; X->parent = T;
        mov     [esi+24], edx

; X->fd = X->bk = X;
        mov     [esi+12], esi
        mov     [esi+8], esi
        ret


; param
;  edx= chunk

unlink_large_chunk:

        mov     eax, [edx+12]
        cmp     eax, edx
        push    edi
        mov     edi, [edx+24]
        je      @F

        mov     ecx, [edx+8]          ;F = X->fd
        mov     [ecx+12], eax         ;F->bk = R;
        mov     [eax+8], ecx          ;R->fd = F
        jmp     .parent
@@:
        mov     eax, [edx+20]
        test    eax, eax
        push    esi
        lea     esi, [edx+20]
        jne     .loop

        mov     eax, [edx+16]
        test    eax, eax
        lea     esi, [edx+16]
        je      .l2
.loop:
        cmp     dword [eax+20], 0
        lea     ecx, [eax+20]
        jne     @F

        cmp     dword [eax+16], 0
        lea     ecx, [eax+16]
        je      .l1
@@:
        mov     eax, [ecx]
        mov     esi, ecx
        jmp     .loop
.l1:
        mov     dword [esi], 0
.l2:
        pop     esi
.parent:
        test    edi, edi
        je      .done

        mov     ecx, [edx+28]
        cmp     edx, [mst.treebins + ecx*4]
        lea     ecx, [mst.treebins + ecx*4]
        jne     .l3

        test    eax, eax
        mov     [ecx], eax
        jne     .l5

        mov     ecx, [edx+28]
        btr     [mst.treemap], ecx
        pop     edi
        ret

.l3:
        cmp     [edi+16], edx
        jne     @F

        mov     [edi+16], eax
        jmp     .l4

@@:
        mov     [edi+20], eax

.l4:
        test    eax, eax
        je      .done

.l5:
        mov     [eax+24], edi
        mov     ecx, [edx+16]
        test    ecx, ecx
        je      .l6

        mov     [eax+16], ecx
        mov     [ecx+24], eax

.l6:
        mov     edx, [edx+20]
        test    edx, edx
        je      .done

        mov     [eax+20], edx
        mov     [edx+24], eax

.done:
        pop     edi
        ret

; param
;  esi= nb

malloc_small:
        push    ebp
        mov     ebp, esi

        push    edi

        bsf     eax, [mst.treemap]
        mov     ecx, [mst.treebins + eax*4]

; rsize = (t->head & ~INUSE_BITS) - nb;

        mov     edi, [ecx+4]
        and     edi, -4
        sub     edi, esi

.loop:
        mov     ebx, ecx

.loop_1:

; while ((t = leftmost_child(t)) != 0)

        mov     eax, [ecx+16]
        test    eax, eax
        jz      @F
        mov     ecx, eax
        jmp     .l1

@@:
        mov     ecx, [ecx+20]

.l1:
        test    ecx, ecx
        jz      .unlink

; trem = (t->head & ~INUSE_BITS) - nb;

        mov     eax, [ecx+4]
        and     eax, -4
        sub     eax, ebp

; if (trem < rsize)

        cmp     eax, edi
        jae     .loop_1

; rsize = trem;

        mov     edi, eax
        jmp     .loop
.unlink:


; r = chunk_plus_offset((mchunkptr)v, nb);
; unlink_large_chunk(v);

        mov     edx, ebx
        lea     esi, [ebx + ebp]
        call    unlink_large_chunk

; if (rsize < 16)

        cmp     edi, 16
        jae     .split

; v->head = (rsize + nb)|PINUSE_BIT|CINUSE_BIT;

        lea     ecx, [edi + ebp]

; (v+rsize + nb)->head |= PINUSE_BIT;

        add     edi, ebx
        lea     eax, [edi + ebp + 4]
        pop     edi
        or      ecx, 3
        mov     [ebx + 4], ecx
        or      dword [eax], 1
        pop     ebp

        lea     eax, [ebx + 8]
        ret

.split:

; v->head = nb|PINUSE_BIT|CINUSE_BIT;
; r->head = rsize|PINUSE_BIT;
; (r+rsize)->prev_foot = rsize;

        or      ebp, 3
        mov     edx, edi
        or      edx, 1

        cmp     edi, 256
        mov     [ebx+4], ebp
        mov     [esi+4], edx
        mov     [esi+edi], edi
        jae     .large

        shr     edi, 3
        bts     [mst.smallmap], edi

        mov     eax, edi
        shl     eax, 4
        add     eax, mst.smallbins

        mov     edx, [eax+8]
        mov     [eax+8], esi
        mov     [edx+12], esi
        pop     edi
        mov     [esi+12], eax
        mov     [esi+8], edx
        pop     ebp
        lea     eax, [ebx+8]
        ret

.large:
        lea     eax, [ebx+8]
        push    eax
        mov     ebx, edi
        call    insert_large_chunk
        pop     eax
        pop     edi
        pop     ebp
        ret


; param
;  esi= nb

malloc_large:
.idx equ esp+4
.rst equ esp

        push    ebp
        push    esi
        push    edi
        sub     esp, 8
; v = 0;
; rsize = -nb;

        mov     edi, esi
        mov     ebx, esi
        xor     ebp, ebp
        neg     edi

; idx = compute_tree_index(nb);

        mov     edx, esi
        shr     edx, 8
        bsr     eax, edx
        lea     ecx, [eax+7]
        shr     esi, cl
        and     esi, 1
        lea     ecx, [esi + eax*2]
        mov     [.idx], ecx

; if ((t = ms.treebins[idx]) != 0)

        mov     eax, [mst.treebins + ecx*4]
        test    eax, eax
        jz      .l3

; sizebits = nb << leftshift_for_tree_index(idx);

        cmp     ecx, 31
        jne     @F
        xor     ecx, ecx
        jmp     .l1

@@:
        mov     edx, ecx
        shr     edx, 1
        mov     ecx, 37
        sub     ecx, edx

.l1:
        mov     edx, ebx
        shl     edx, cl

; rst = 0;
        mov     [.rst], ebp

.loop:

; trem = (t->head & ~INUSE_BITS) - nb;

        mov     ecx, [eax+4]
        and     ecx, -4
        sub     ecx, ebx

; if (trem < rsize)

        cmp     ecx, edi
        jae     @F
; v = t;
; if ((rsize = trem) == 0)

        test    ecx, ecx
        mov     ebp, eax
        mov     edi, ecx
        je      .l2

@@:

; rt = t->child[1];

        mov     ecx, [eax+20]

; t = t->child[(sizebits >> 31) & 1];

        mov     esi, edx
        shr     esi, 31

; if (rt != 0 && rt != t)

        test    ecx, ecx
        mov     eax, [eax + esi*4+16]
        jz      @F
        cmp     ecx, eax
        jz      @F

; rst = rt;
        mov     [.rst], ecx

@@:
; if (t == 0)

        test    eax, eax
        jz      @F

; sizebits <<= 1;

        add     edx, edx
        jmp     .loop

@@:
; t = rst;
        mov     eax, [.rst]

.l2:
; if (t == 0 && v == 0)

        test    eax, eax
        jne     .l4
        test    ebp, ebp
        jne     .l7
        mov     ecx, [.idx]

.l3:

; leftbits = (-1<<idx) & ms.treemap;
; if (leftbits != 0)

        or      edx, -1
        shl     edx, cl
        and     edx, [mst.treemap]
        jz      @F

        bsf     eax, edx
; t = ms.treebins[i];
        mov     eax, [mst.treebins + eax*4]

@@:

; while (t != 0)
        test    eax, eax
        jz      .l5

.l4:

; trem = (t->head & ~INUSE_BITS) - nb;

        mov     ecx, [eax+4]
        and     ecx, -4
        sub     ecx, ebx

; if (trem < rsize)

        cmp     ecx, edi
        jae     @F
; rsize = trem;

        mov     edi, ecx
; v = t;
        mov     ebp, eax

@@:

; t = leftmost_child(t);

        mov     ecx, [eax+16]
        test    ecx, ecx
        je      @F
        mov     eax, ecx
        jmp     .l6

@@:
        mov     eax, [eax+20]

.l6:

; while (t != 0)

        test    eax, eax
        jne     .l4

.l5:

; if (v != 0)

        test    ebp, ebp
        jz      .done

.l7:

; r = chunk_plus_offset((mchunkptr)v, nb);
; unlink_large_chunk(v);

        mov     edx, ebp
        lea     esi, [ebx + ebp]
        call    unlink_large_chunk

; if (rsize < 16)

        cmp     edi, 16
        jae     .large

; v->head = (rsize + nb)|PINUSE_BIT|CINUSE_BIT;

        lea     ecx, [edi + ebx]

; (v+rsize + nb)->head |= PINUSE_BIT;

        add     edi, ebp
        lea     eax, [edi + ebx + 4]
        or      ecx, 3
        mov     [ebp+4], ecx
        or      dword [eax], 1
        lea     eax, [ebp+8]
        add     esp, 8
        pop     edi
        pop     esi
        pop     ebp
        ret

.large:

; v->head = nb|PINUSE_BIT|CINUSE_BIT;
; r->head = rsize|PINUSE_BIT;

        mov     edx, edi
        or      ebx, 3
        mov     [ebp+4], ebx
        or      edx, 1
        mov     [esi+4], edx

; (r+rsize)->prev_foot = rsize;
; insert_large_chunk((tchunkptr)r, rsize);

        mov     [esi+edi], edi
        mov     eax, edi
        mov     ecx, esi
        call    insert_chunk

        lea     eax, [ebp+8]
        add     esp, 8
        pop     edi
        pop     esi
        pop     ebp
        ret

.done:
        add     esp, 8
        pop     edi
        pop     esi
        pop     ebp
        xor     eax, eax
        ret

init_malloc:

        stdcall kernel_alloc, 0x40000

        mov     [mst.top], eax
        mov     [mst.topsize], 128*1024
        mov     dword [eax+4], (128*1024) or 1
        mov     eax, mst.smallbins

@@:
        mov     [eax+8], eax
        mov     [eax+12], eax
        add     eax, 16
        cmp     eax, mst.smallbins + 512
        jb      @B

        mov     ecx, mst.mutex
        call    mutex_init

        ret