kit

native_frame.c (5827B)

---

 #include "cg/native_frame.h"
 
 #include <string.h>
 
 #include "core/arena.h"
 
 static u32 nf_align_up(u32 v, u32 align) {
   u32 mask = align ? align - 1u : 0u;
   return (v + mask) & ~mask;
 }
 
 static void nf_panic(NativeFrame* f, const char* msg) {
   compiler_panic(f->c, (SrcLoc){0, 0, 0}, "native frame: %s", msg);
 }
 
 void native_frame_init(NativeFrame* f, Compiler* c) {
   memset(f, 0, sizeof *f);
   f->c = c;
 }
 
 void native_frame_reset(NativeFrame* f) {
   /* Keep the slots buffer (slots/slots_cap) for reuse across functions in the
    * translation unit; nslots = 0 logically clears it. The transient free list is
    * per-function: dropping nfree_bins discards any stale buckets, and each fresh
    * slot_alloc reinitializes its entry's free_next/in_free, so no stale handle
    * from the previous function can be served. */
   f->nslots = 0;
   f->cum_off = 0;
   f->max_outgoing = 0;
   f->ncallee_saves = 0;
   f->nfree_bins = 0;
   f->frame_final = 0;
   f->known_frame = 0;
   f->has_alloca = 0;
 }
 
 /* Find the free bucket for (size,align), or NULL. */
 static u32* nf_free_bin_find(NativeFrame* f, u32 size, u32 align) {
   for (u32 i = 0; i < f->nfree_bins; ++i)
     if (f->free_bins[i].size == size && f->free_bins[i].align == align)
       return &f->free_bins[i].head;
   return NULL;
 }
 
 NativeFrameSlot native_frame_slot_alloc(NativeFrame* f,
                                         const NativeFrameSlotDesc* d) {
   NativeFrameSlotEntry* s;
   u32 size = d->size ? d->size : 8u;
   u32 align = d->align ? d->align : 1u;
   if (f->frame_final) nf_panic(f, "frame slot requested after prologue");
   /* A transient temp first tries to reuse a dead slot of the exact same
    * (size,align): its home offset already satisfies the alignment, so handing
    * the same handle back is safe and leaves cum_off (the frame high-water mark)
    * unchanged. */
   if (d->flags & NATIVE_FRAME_SLOT_TRANSIENT) {
     u32* head = nf_free_bin_find(f, size, align);
     if (head && *head != NATIVE_FRAME_SLOT_NONE) {
       NativeFrameSlot slot = *head;
       s = &f->slots[slot - 1u];
       *head = s->free_next;
       s->free_next = NATIVE_FRAME_SLOT_NONE;
       s->in_free = 0;
       s->kind = d->kind;
       return slot;
     }
   }
   if (f->nslots == f->slots_cap) {
     u32 cap = f->slots_cap ? f->slots_cap * 2u : 16u;
     NativeFrameSlotEntry* nb =
         arena_zarray(f->c->tu, NativeFrameSlotEntry, cap);
     if (f->slots) memcpy(nb, f->slots, sizeof(*nb) * f->nslots);
     f->slots = nb;
     f->slots_cap = cap;
   }
   f->cum_off = nf_align_up(f->cum_off + size, align);
   s = &f->slots[f->nslots++];
   s->off = f->cum_off;
   s->size = size;
   s->align = align;
   s->free_next = NATIVE_FRAME_SLOT_NONE;
   s->kind = d->kind;
   s->in_free = 0;
   return (NativeFrameSlot)f->nslots;
 }
 
 void native_frame_release_slot(NativeFrame* f, NativeFrameSlot slot) {
   NativeFrameSlotEntry* s;
   u32* head;
   if (slot == NATIVE_FRAME_SLOT_NONE || slot > f->nslots) return;
   s = &f->slots[slot - 1u];
   if (s->in_free) return; /* already released */
   head = nf_free_bin_find(f, s->size, s->align);
   if (!head) {
     if (f->nfree_bins >= (u32)(sizeof f->free_bins / sizeof f->free_bins[0]))
       return; /* bucket table full: don't recycle this shape (still correct) */
     f->free_bins[f->nfree_bins].size = s->size;
     f->free_bins[f->nfree_bins].align = s->align;
     f->free_bins[f->nfree_bins].head = NATIVE_FRAME_SLOT_NONE;
     head = &f->free_bins[f->nfree_bins].head;
     f->nfree_bins++;
   }
   s->free_next = *head;
   *head = slot;
   s->in_free = 1;
 }
 
 NativeFrameSlotEntry* native_frame_slot_at(NativeFrame* f,
                                            NativeFrameSlot slot) {
   if (slot == NATIVE_FRAME_SLOT_NONE || slot > f->nslots)
     nf_panic(f, "bad frame slot");
   return &f->slots[slot - 1u];
 }
 
 void native_frame_note_outgoing(NativeFrame* f, u32 bytes) {
   if (bytes > f->max_outgoing) f->max_outgoing = bytes;
 }
 
 void native_frame_set_final(NativeFrame* f) { f->frame_final = 1; }
 
 void native_frame_set_callee_saves(NativeFrame* f, const u32* used_by_class,
                                    u32 nclasses,
                                    const NativeFrameSaveSpec* spec_by_class,
                                    u32 nspec, int alloc_slots) {
   f->ncallee_saves = 0;
   if (!used_by_class) return;
   for (u32 cls = 0; cls < nclasses; ++cls) {
     u32 mask = used_by_class[cls];
     for (Reg r = 0; r < 32u && mask; ++r) {
       NativeFrameCalleeSave* cs;
       if ((mask & (1u << r)) == 0) continue;
       mask &= ~(1u << r);
       if (f->ncallee_saves >= NATIVE_FRAME_MAX_CALLEE_SAVES)
         nf_panic(f, "too many callee-saved registers");
       cs = &f->callee_saves[f->ncallee_saves++];
       cs->cls = (u8)cls;
       cs->reg = r;
       cs->slot = NATIVE_FRAME_SLOT_NONE;
       cs->type = 0;
       if (cls < nspec && spec_by_class) cs->type = spec_by_class[cls].type;
       if (alloc_slots) {
         NativeFrameSlotDesc sd;
         const NativeFrameSaveSpec* sp =
             (cls < nspec && spec_by_class) ? &spec_by_class[cls] : NULL;
         memset(&sd, 0, sizeof sd);
         sd.type = cs->type;
         sd.size = sp && sp->size ? sp->size : 8u;
         sd.align = sp && sp->align ? sp->align : 8u;
         sd.kind = NATIVE_FRAME_SLOT_SAVE;
         cs->slot = native_frame_slot_alloc(f, &sd);
       }
     }
   }
 }
 
 u32 native_frame_collect_saves(const NativeFrame* f, NativeAllocClass cls,
                                Reg* out, u32 cap) {
   u32 n = 0;
   for (u32 i = 0; i < f->ncallee_saves; ++i) {
     if (f->callee_saves[i].cls != (u8)cls) continue;
     if (n >= cap) break;
     out[n++] = f->callee_saves[i].reg;
   }
   return n;
 }
 
 u32 native_frame_va_save_bytes(TargetABI* abi) {
   ABIVaListInfo va = abi_va_list_layout(abi);
   return va.gp_reg_count * va.gp_slot_size + va.fp_reg_count * va.fp_slot_size;
 }