kit

print_backtrace.c (2595B)

---

 /*
  * __kit_print_backtrace -- raw (unsymbolized) backtrace print, built on the
  * freestanding __kit_backtrace frame-pointer walk. See doc/plan/BACKTRACE.md
  * (L3a) and rt/include/kit/backtrace.h for the contract.
  *
  * Each captured return address is written as a "#<n> 0x<hex>\n" line to the
  * weak __kit_backtrace_write sink. Symbolization is deliberately out of
  * process: pipe the addresses to `kit addr2line -e <image>`. The integer
  * formatting is done by hand so the panic path drags in no printf/libc and
  * stays usable from a crash handler.
  */
 #include <kit/backtrace.h>
 #include <stdint.h>
 
 /* Weak default sink: discard. A host start file / runtime overrides this to
  * route the bytes to write(2), a serial port, etc. Keeping it weak means a
  * freestanding image that never wires a sink still links and runs. */
 __attribute__((weak)) void __kit_backtrace_write(const char* buf, size_t len) {
   (void)buf;
   (void)len;
 }
 
 #define KIT_BT_PRINT_MAX 64
 
 /* Format "#<idx> 0x<hex>\n" into `out` and return the byte count. `out` must
  * hold the longest line: '#' + up to 10 decimal digits (u32 idx) + " 0x" + up
  * to 16 hex digits (64-bit pointer) + '\n' == 31 bytes; the caller's line[48]
  * is comfortably large. The hex address uses uintptr_t so it is not truncated
  * on an LLP64 target, where `unsigned long` would be too narrow. */
 static int bt_format_frame(char* out, unsigned idx, void* addr) {
   static const char hexd[] = "0123456789abcdef";
   char digits[10];
   uintptr_t a = (uintptr_t)addr;
   int started = 0, shift, k = 0, j = 0;
 
   out[k++] = '#';
   do {
     digits[j++] = (char)('0' + (int)(idx % 10u));
     idx /= 10u;
   } while (idx);
   while (j > 0) out[k++] = digits[--j];
 
   out[k++] = ' ';
   out[k++] = '0';
   out[k++] = 'x';
   /* Most-significant nibble first; suppress leading zeros but always emit at
    * least the final nibble so an address of 0 still prints as "0x0". */
   for (shift = (int)(sizeof(uintptr_t) * 8) - 4; shift >= 0; shift -= 4) {
     unsigned nib = (unsigned)((a >> shift) & 0xfu);
     if (nib != 0u || started || shift == 0) {
       out[k++] = hexd[nib];
       started = 1;
     }
   }
   out[k++] = '\n';
   return k;
 }
 
 void __kit_print_backtrace(void) {
   void* frames[KIT_BT_PRINT_MAX];
   char line[48];
   int n, i;
 
   /* skip == 1 hides __kit_print_backtrace's own frame, so frame #0 is the
    * return address into its direct caller. */
   n = __kit_backtrace(frames, KIT_BT_PRINT_MAX, 1);
   for (i = 0; i < n; i++) {
     int len = bt_format_frame(line, (unsigned)i, frames[i]);
     __kit_backtrace_write(line, (size_t)len);
   }
 }