/* * Duktape debugger */ #include "duk_internal.h" #if defined(DUK_USE_DEBUGGER_SUPPORT) /* * Assert helpers */ #if defined(DUK_USE_ASSERTIONS) #define DUK__DBG_TPORT_ENTER() do { \ DUK_ASSERT(heap->dbg_calling_transport == 0); \ heap->dbg_calling_transport = 1; \ } while (0) #define DUK__DBG_TPORT_EXIT() do { \ DUK_ASSERT(heap->dbg_calling_transport == 1); \ heap->dbg_calling_transport = 0; \ } while (0) #else #define DUK__DBG_TPORT_ENTER() do {} while (0) #define DUK__DBG_TPORT_EXIT() do {} while (0) #endif /* * Helper structs */ typedef union { void *p; duk_uint_t b[1]; /* Use b[] to access the size of the union, which is strictly not * correct. Can't use fixed size unless there's feature detection * for pointer byte size. */ } duk__ptr_union; /* * Detach handling */ #define DUK__SET_CONN_BROKEN(thr,reason) do { \ /* For now shared handler is fine. */ \ duk__debug_do_detach1((thr)->heap, (reason)); \ } while (0) DUK_LOCAL void duk__debug_do_detach1(duk_heap *heap, duk_int_t reason) { /* Can be called multiple times with no harm. Mark the transport * bad (dbg_read_cb == NULL) and clear state except for the detached * callback and the udata field. The detached callback is delayed * to the message loop so that it can be called between messages; * this avoids corner cases related to immediate debugger reattach * inside the detached callback. */ if (heap->dbg_detaching) { DUK_D(DUK_DPRINT("debugger already detaching, ignore detach1")); return; } DUK_D(DUK_DPRINT("debugger transport detaching, marking transport broken")); heap->dbg_detaching = 1; /* prevent multiple in-progress detaches */ if (heap->dbg_write_cb != NULL) { duk_hthread *thr; thr = heap->heap_thread; DUK_ASSERT(thr != NULL); duk_debug_write_notify(thr, DUK_DBG_CMD_DETACHING); duk_debug_write_int(thr, reason); duk_debug_write_eom(thr); } heap->dbg_read_cb = NULL; heap->dbg_write_cb = NULL; heap->dbg_peek_cb = NULL; heap->dbg_read_flush_cb = NULL; heap->dbg_write_flush_cb = NULL; heap->dbg_request_cb = NULL; /* heap->dbg_detached_cb: keep */ /* heap->dbg_udata: keep */ /* heap->dbg_processing: keep on purpose to avoid debugger re-entry in detaching state */ heap->dbg_state_dirty = 0; heap->dbg_force_restart = 0; heap->dbg_pause_flags = 0; heap->dbg_pause_act = NULL; heap->dbg_pause_startline = 0; heap->dbg_have_next_byte = 0; duk_debug_clear_paused(heap); /* XXX: some overlap with field inits above */ heap->dbg_state_dirty = 0; /* XXX: clear_paused sets dirty; rework? */ /* Ensure there are no stale active breakpoint pointers. * Breakpoint list is currently kept - we could empty it * here but we'd need to handle refcounts correctly, and * we'd need a 'thr' reference for that. * * XXX: clear breakpoint on either attach or detach? */ heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL; } DUK_LOCAL void duk__debug_do_detach2(duk_heap *heap) { duk_debug_detached_function detached_cb; void *detached_udata; duk_hthread *thr; thr = heap->heap_thread; if (thr == NULL) { DUK_ASSERT(heap->dbg_detached_cb == NULL); return; } /* Safe to call multiple times. */ detached_cb = heap->dbg_detached_cb; detached_udata = heap->dbg_udata; heap->dbg_detached_cb = NULL; heap->dbg_udata = NULL; if (detached_cb) { /* Careful here: state must be wiped before the call * so that we can cleanly handle a re-attach from * inside the callback. */ DUK_D(DUK_DPRINT("detached during message loop, delayed call to detached_cb")); detached_cb(thr, detached_udata); } heap->dbg_detaching = 0; } DUK_INTERNAL void duk_debug_do_detach(duk_heap *heap) { duk__debug_do_detach1(heap, 0); duk__debug_do_detach2(heap); } /* Called on a read/write error: NULL all callbacks except the detached * callback so that we never accidentally call them after a read/write * error has been indicated. This is especially important for the transport * I/O callbacks to fulfill guaranteed callback semantics. */ DUK_LOCAL void duk__debug_null_most_callbacks(duk_hthread *thr) { duk_heap *heap; DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_D(DUK_DPRINT("transport read/write error, NULL all callbacks expected detached")); heap->dbg_read_cb = NULL; heap->dbg_write_cb = NULL; /* this is especially critical to avoid another write call in detach1() */ heap->dbg_peek_cb = NULL; heap->dbg_read_flush_cb = NULL; heap->dbg_write_flush_cb = NULL; heap->dbg_request_cb = NULL; /* keep heap->dbg_detached_cb */ } /* * Pause handling */ DUK_LOCAL void duk__debug_set_pause_state(duk_hthread *thr, duk_heap *heap, duk_small_uint_t pause_flags) { duk_uint_fast32_t line; line = duk_debug_curr_line(thr); if (line == 0) { /* No line info for current function. */ duk_small_uint_t updated_flags; updated_flags = pause_flags & ~(DUK_PAUSE_FLAG_LINE_CHANGE); DUK_D(DUK_DPRINT("no line info for current activation, disable line-based pause flags: 0x%08lx -> 0x%08lx", (long) pause_flags, (long) updated_flags)); pause_flags = updated_flags; } heap->dbg_pause_flags = pause_flags; heap->dbg_pause_act = thr->callstack_curr; heap->dbg_pause_startline = (duk_uint32_t) line; heap->dbg_state_dirty = 1; DUK_D(DUK_DPRINT("set state for automatic pause triggers, flags=0x%08lx, act=%p, startline=%ld", (long) heap->dbg_pause_flags, (void *) heap->dbg_pause_act, (long) heap->dbg_pause_startline)); } /* * Debug connection peek and flush primitives */ DUK_INTERNAL duk_bool_t duk_debug_read_peek(duk_hthread *thr) { duk_heap *heap; duk_bool_t ret; DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); if (heap->dbg_read_cb == NULL) { DUK_D(DUK_DPRINT("attempt to peek in detached state, return zero (= no data)")); return 0; } if (heap->dbg_peek_cb == NULL) { DUK_DD(DUK_DDPRINT("no peek callback, return zero (= no data)")); return 0; } DUK__DBG_TPORT_ENTER(); ret = (duk_bool_t) (heap->dbg_peek_cb(heap->dbg_udata) > 0); DUK__DBG_TPORT_EXIT(); return ret; } DUK_INTERNAL void duk_debug_read_flush(duk_hthread *thr) { duk_heap *heap; DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); if (heap->dbg_read_cb == NULL) { DUK_D(DUK_DPRINT("attempt to read flush in detached state, ignore")); return; } if (heap->dbg_read_flush_cb == NULL) { DUK_DD(DUK_DDPRINT("no read flush callback, ignore")); return; } DUK__DBG_TPORT_ENTER(); heap->dbg_read_flush_cb(heap->dbg_udata); DUK__DBG_TPORT_EXIT(); } DUK_INTERNAL void duk_debug_write_flush(duk_hthread *thr) { duk_heap *heap; DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); if (heap->dbg_read_cb == NULL) { DUK_D(DUK_DPRINT("attempt to write flush in detached state, ignore")); return; } if (heap->dbg_write_flush_cb == NULL) { DUK_DD(DUK_DDPRINT("no write flush callback, ignore")); return; } DUK__DBG_TPORT_ENTER(); heap->dbg_write_flush_cb(heap->dbg_udata); DUK__DBG_TPORT_EXIT(); } /* * Debug connection skip primitives */ /* Skip fully. */ DUK_INTERNAL void duk_debug_skip_bytes(duk_hthread *thr, duk_size_t length) { duk_uint8_t dummy[64]; duk_size_t now; DUK_ASSERT(thr != NULL); while (length > 0) { now = (length > sizeof(dummy) ? sizeof(dummy) : length); duk_debug_read_bytes(thr, dummy, now); length -= now; } } DUK_INTERNAL void duk_debug_skip_byte(duk_hthread *thr) { DUK_ASSERT(thr != NULL); (void) duk_debug_read_byte(thr); } /* * Debug connection read primitives */ /* Peek ahead in the stream one byte. */ DUK_INTERNAL uint8_t duk_debug_peek_byte(duk_hthread *thr) { /* It is important not to call this if the last byte read was an EOM. * Reading ahead in this scenario would cause unnecessary blocking if * another message is not available. */ duk_uint8_t x; x = duk_debug_read_byte(thr); thr->heap->dbg_have_next_byte = 1; thr->heap->dbg_next_byte = x; return x; } /* Read fully. */ DUK_INTERNAL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_size_t length) { duk_heap *heap; duk_uint8_t *p; duk_size_t left; duk_size_t got; DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); DUK_ASSERT(data != NULL); if (heap->dbg_read_cb == NULL) { DUK_D(DUK_DPRINT("attempt to read %ld bytes in detached state, return zero data", (long) length)); goto fail; } /* NOTE: length may be zero */ p = data; if (length >= 1 && heap->dbg_have_next_byte) { heap->dbg_have_next_byte = 0; *p++ = heap->dbg_next_byte; } for (;;) { left = (duk_size_t) ((data + length) - p); if (left == 0) { break; } DUK_ASSERT(heap->dbg_read_cb != NULL); DUK_ASSERT(left >= 1); #if defined(DUK_USE_DEBUGGER_TRANSPORT_TORTURE) left = 1; #endif DUK__DBG_TPORT_ENTER(); got = heap->dbg_read_cb(heap->dbg_udata, (char *) p, left); DUK__DBG_TPORT_EXIT(); if (got == 0 || got > left) { DUK_D(DUK_DPRINT("connection error during read, return zero data")); duk__debug_null_most_callbacks(thr); /* avoid calling write callback in detach1() */ DUK__SET_CONN_BROKEN(thr, 1); goto fail; } p += got; } return; fail: duk_memzero((void *) data, (size_t) length); } DUK_INTERNAL duk_uint8_t duk_debug_read_byte(duk_hthread *thr) { duk_uint8_t x; x = 0; /* just in case callback is broken and won't write 'x' */ duk_debug_read_bytes(thr, &x, 1); return x; } DUK_LOCAL duk_uint32_t duk__debug_read_uint32_raw(duk_hthread *thr) { duk_uint8_t buf[4]; DUK_ASSERT(thr != NULL); duk_debug_read_bytes(thr, buf, 4); return ((duk_uint32_t) buf[0] << 24) | ((duk_uint32_t) buf[1] << 16) | ((duk_uint32_t) buf[2] << 8) | (duk_uint32_t) buf[3]; } DUK_LOCAL duk_int32_t duk__debug_read_int32_raw(duk_hthread *thr) { return (duk_int32_t) duk__debug_read_uint32_raw(thr); } DUK_LOCAL duk_uint16_t duk__debug_read_uint16_raw(duk_hthread *thr) { duk_uint8_t buf[2]; DUK_ASSERT(thr != NULL); duk_debug_read_bytes(thr, buf, 2); return ((duk_uint16_t) buf[0] << 8) | (duk_uint16_t) buf[1]; } DUK_INTERNAL duk_int32_t duk_debug_read_int(duk_hthread *thr) { duk_small_uint_t x; duk_small_uint_t t; DUK_ASSERT(thr != NULL); x = duk_debug_read_byte(thr); if (x >= 0xc0) { t = duk_debug_read_byte(thr); return (duk_int32_t) (((x - 0xc0) << 8) + t); } else if (x >= 0x80) { return (duk_int32_t) (x - 0x80); } else if (x == DUK_DBG_IB_INT4) { return (duk_int32_t) duk__debug_read_uint32_raw(thr); } DUK_D(DUK_DPRINT("debug connection error: failed to decode int")); DUK__SET_CONN_BROKEN(thr, 1); return 0; } DUK_LOCAL duk_hstring *duk__debug_read_hstring_raw(duk_hthread *thr, duk_uint32_t len) { duk_uint8_t buf[31]; duk_uint8_t *p; if (len <= sizeof(buf)) { duk_debug_read_bytes(thr, buf, (duk_size_t) len); duk_push_lstring(thr, (const char *) buf, (duk_size_t) len); } else { p = (duk_uint8_t *) duk_push_fixed_buffer(thr, (duk_size_t) len); /* zero for paranoia */ DUK_ASSERT(p != NULL); duk_debug_read_bytes(thr, p, (duk_size_t) len); (void) duk_buffer_to_string(thr, -1); /* Safety relies on debug client, which is OK. */ } return duk_require_hstring(thr, -1); } DUK_INTERNAL duk_hstring *duk_debug_read_hstring(duk_hthread *thr) { duk_small_uint_t x; duk_uint32_t len; DUK_ASSERT(thr != NULL); x = duk_debug_read_byte(thr); if (x >= 0x60 && x <= 0x7f) { /* For short strings, use a fixed temp buffer. */ len = (duk_uint32_t) (x - 0x60); } else if (x == DUK_DBG_IB_STR2) { len = (duk_uint32_t) duk__debug_read_uint16_raw(thr); } else if (x == DUK_DBG_IB_STR4) { len = (duk_uint32_t) duk__debug_read_uint32_raw(thr); } else { goto fail; } return duk__debug_read_hstring_raw(thr, len); fail: DUK_D(DUK_DPRINT("debug connection error: failed to decode int")); DUK__SET_CONN_BROKEN(thr, 1); duk_push_hstring_empty(thr); /* always push some string */ return duk_require_hstring(thr, -1); } DUK_LOCAL duk_hbuffer *duk__debug_read_hbuffer_raw(duk_hthread *thr, duk_uint32_t len) { duk_uint8_t *p; p = (duk_uint8_t *) duk_push_fixed_buffer(thr, (duk_size_t) len); /* zero for paranoia */ DUK_ASSERT(p != NULL); duk_debug_read_bytes(thr, p, (duk_size_t) len); return duk_require_hbuffer(thr, -1); } DUK_LOCAL void *duk__debug_read_pointer_raw(duk_hthread *thr) { duk_small_uint_t x; duk__ptr_union pu; DUK_ASSERT(thr != NULL); x = duk_debug_read_byte(thr); if (x != sizeof(pu)) { goto fail; } duk_debug_read_bytes(thr, (duk_uint8_t *) &pu.p, sizeof(pu)); #if defined(DUK_USE_INTEGER_LE) duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu)); #endif return (void *) pu.p; fail: DUK_D(DUK_DPRINT("debug connection error: failed to decode pointer")); DUK__SET_CONN_BROKEN(thr, 1); return (void *) NULL; } DUK_LOCAL duk_double_t duk__debug_read_double_raw(duk_hthread *thr) { duk_double_union du; DUK_ASSERT(sizeof(du.uc) == 8); duk_debug_read_bytes(thr, (duk_uint8_t *) du.uc, sizeof(du.uc)); DUK_DBLUNION_DOUBLE_NTOH(&du); return du.d; } #if 0 DUK_INTERNAL duk_heaphdr *duk_debug_read_heapptr(duk_hthread *thr) { duk_small_uint_t x; DUK_ASSERT(thr != NULL); x = duk_debug_read_byte(thr); if (x != DUK_DBG_IB_HEAPPTR) { goto fail; } return (duk_heaphdr *) duk__debug_read_pointer_raw(thr); fail: DUK_D(DUK_DPRINT("debug connection error: failed to decode heapptr")); DUK__SET_CONN_BROKEN(thr, 1); return NULL; } #endif DUK_INTERNAL duk_heaphdr *duk_debug_read_any_ptr(duk_hthread *thr) { duk_small_uint_t x; DUK_ASSERT(thr != NULL); x = duk_debug_read_byte(thr); switch (x) { case DUK_DBG_IB_OBJECT: case DUK_DBG_IB_POINTER: case DUK_DBG_IB_HEAPPTR: /* Accept any pointer-like value; for 'object' dvalue, read * and ignore the class number. */ if (x == DUK_DBG_IB_OBJECT) { duk_debug_skip_byte(thr); } break; default: goto fail; } return (duk_heaphdr *) duk__debug_read_pointer_raw(thr); fail: DUK_D(DUK_DPRINT("debug connection error: failed to decode any pointer (object, pointer, heapptr)")); DUK__SET_CONN_BROKEN(thr, 1); return NULL; } DUK_INTERNAL duk_tval *duk_debug_read_tval(duk_hthread *thr) { duk_uint8_t x; duk_uint_t t; duk_uint32_t len; DUK_ASSERT(thr != NULL); x = duk_debug_read_byte(thr); if (x >= 0xc0) { t = (duk_uint_t) (x - 0xc0); t = (t << 8) + duk_debug_read_byte(thr); duk_push_uint(thr, (duk_uint_t) t); goto return_ptr; } if (x >= 0x80) { duk_push_uint(thr, (duk_uint_t) (x - 0x80)); goto return_ptr; } if (x >= 0x60) { len = (duk_uint32_t) (x - 0x60); duk__debug_read_hstring_raw(thr, len); goto return_ptr; } switch (x) { case DUK_DBG_IB_INT4: { duk_int32_t i = duk__debug_read_int32_raw(thr); duk_push_i32(thr, i); break; } case DUK_DBG_IB_STR4: { len = duk__debug_read_uint32_raw(thr); duk__debug_read_hstring_raw(thr, len); break; } case DUK_DBG_IB_STR2: { len = duk__debug_read_uint16_raw(thr); duk__debug_read_hstring_raw(thr, len); break; } case DUK_DBG_IB_BUF4: { len = duk__debug_read_uint32_raw(thr); duk__debug_read_hbuffer_raw(thr, len); break; } case DUK_DBG_IB_BUF2: { len = duk__debug_read_uint16_raw(thr); duk__debug_read_hbuffer_raw(thr, len); break; } case DUK_DBG_IB_UNDEFINED: { duk_push_undefined(thr); break; } case DUK_DBG_IB_NULL: { duk_push_null(thr); break; } case DUK_DBG_IB_TRUE: { duk_push_true(thr); break; } case DUK_DBG_IB_FALSE: { duk_push_false(thr); break; } case DUK_DBG_IB_NUMBER: { duk_double_t d; d = duk__debug_read_double_raw(thr); duk_push_number(thr, d); break; } case DUK_DBG_IB_OBJECT: { duk_heaphdr *h; duk_debug_skip_byte(thr); h = (duk_heaphdr *) duk__debug_read_pointer_raw(thr); duk_push_heapptr(thr, (void *) h); break; } case DUK_DBG_IB_POINTER: { void *ptr; ptr = duk__debug_read_pointer_raw(thr); duk_push_pointer(thr, ptr); break; } case DUK_DBG_IB_LIGHTFUNC: { /* XXX: Not needed for now, so not implemented. Note that * function pointers may have different size/layout than * a void pointer. */ DUK_D(DUK_DPRINT("reading lightfunc values unimplemented")); goto fail; } case DUK_DBG_IB_HEAPPTR: { duk_heaphdr *h; h = (duk_heaphdr *) duk__debug_read_pointer_raw(thr); duk_push_heapptr(thr, (void *) h); break; } case DUK_DBG_IB_UNUSED: /* unused: not accepted in inbound messages */ default: goto fail; } return_ptr: return DUK_GET_TVAL_NEGIDX(thr, -1); fail: DUK_D(DUK_DPRINT("debug connection error: failed to decode tval")); DUK__SET_CONN_BROKEN(thr, 1); return NULL; } /* * Debug connection write primitives */ /* Write fully. */ DUK_INTERNAL void duk_debug_write_bytes(duk_hthread *thr, const duk_uint8_t *data, duk_size_t length) { duk_heap *heap; const duk_uint8_t *p; duk_size_t left; duk_size_t got; DUK_ASSERT(thr != NULL); DUK_ASSERT(length == 0 || data != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); if (heap->dbg_write_cb == NULL) { DUK_D(DUK_DPRINT("attempt to write %ld bytes in detached state, ignore", (long) length)); return; } if (length == 0) { /* Avoid doing an actual write callback with length == 0, * because that's reserved for a write flush. */ return; } DUK_ASSERT(data != NULL); p = data; for (;;) { left = (duk_size_t) ((data + length) - p); if (left == 0) { break; } DUK_ASSERT(heap->dbg_write_cb != NULL); DUK_ASSERT(left >= 1); #if defined(DUK_USE_DEBUGGER_TRANSPORT_TORTURE) left = 1; #endif DUK__DBG_TPORT_ENTER(); got = heap->dbg_write_cb(heap->dbg_udata, (const char *) p, left); DUK__DBG_TPORT_EXIT(); if (got == 0 || got > left) { duk__debug_null_most_callbacks(thr); /* avoid calling write callback in detach1() */ DUK_D(DUK_DPRINT("connection error during write")); DUK__SET_CONN_BROKEN(thr, 1); return; } p += got; } } DUK_INTERNAL void duk_debug_write_byte(duk_hthread *thr, duk_uint8_t x) { duk_debug_write_bytes(thr, (const duk_uint8_t *) &x, 1); } DUK_INTERNAL void duk_debug_write_unused(duk_hthread *thr) { duk_debug_write_byte(thr, DUK_DBG_IB_UNUSED); } DUK_INTERNAL void duk_debug_write_undefined(duk_hthread *thr) { duk_debug_write_byte(thr, DUK_DBG_IB_UNDEFINED); } #if defined(DUK_USE_DEBUGGER_INSPECT) DUK_INTERNAL void duk_debug_write_null(duk_hthread *thr) { duk_debug_write_byte(thr, DUK_DBG_IB_NULL); } #endif DUK_INTERNAL void duk_debug_write_boolean(duk_hthread *thr, duk_uint_t val) { duk_debug_write_byte(thr, val ? DUK_DBG_IB_TRUE : DUK_DBG_IB_FALSE); } /* Write signed 32-bit integer. */ DUK_INTERNAL void duk_debug_write_int(duk_hthread *thr, duk_int32_t x) { duk_uint8_t buf[5]; duk_size_t len; DUK_ASSERT(thr != NULL); if (x >= 0 && x <= 0x3fL) { buf[0] = (duk_uint8_t) (0x80 + x); len = 1; } else if (x >= 0 && x <= 0x3fffL) { buf[0] = (duk_uint8_t) (0xc0 + (x >> 8)); buf[1] = (duk_uint8_t) (x & 0xff); len = 2; } else { /* Signed integers always map to 4 bytes now. */ buf[0] = (duk_uint8_t) DUK_DBG_IB_INT4; buf[1] = (duk_uint8_t) ((x >> 24) & 0xff); buf[2] = (duk_uint8_t) ((x >> 16) & 0xff); buf[3] = (duk_uint8_t) ((x >> 8) & 0xff); buf[4] = (duk_uint8_t) (x & 0xff); len = 5; } duk_debug_write_bytes(thr, buf, len); } /* Write unsigned 32-bit integer. */ DUK_INTERNAL void duk_debug_write_uint(duk_hthread *thr, duk_uint32_t x) { /* The debugger protocol doesn't support a plain integer encoding for * the full 32-bit unsigned range (only 32-bit signed). For now, * unsigned 32-bit values simply written as signed ones. This is not * a concrete issue except for 32-bit heaphdr fields. Proper solutions * would be to (a) write such integers as IEEE doubles or (b) add an * unsigned 32-bit dvalue. */ if (x >= 0x80000000UL) { DUK_D(DUK_DPRINT("writing unsigned integer 0x%08lx as signed integer", (long) x)); } duk_debug_write_int(thr, (duk_int32_t) x); } DUK_INTERNAL void duk_debug_write_strbuf(duk_hthread *thr, const char *data, duk_size_t length, duk_uint8_t marker_base) { duk_uint8_t buf[5]; duk_size_t buflen; DUK_ASSERT(thr != NULL); DUK_ASSERT(length == 0 || data != NULL); if (length <= 0x1fUL && marker_base == DUK_DBG_IB_STR4) { /* For strings, special form for short lengths. */ buf[0] = (duk_uint8_t) (0x60 + length); buflen = 1; } else if (length <= 0xffffUL) { buf[0] = (duk_uint8_t) (marker_base + 1); buf[1] = (duk_uint8_t) (length >> 8); buf[2] = (duk_uint8_t) (length & 0xff); buflen = 3; } else { buf[0] = (duk_uint8_t) marker_base; buf[1] = (duk_uint8_t) (length >> 24); buf[2] = (duk_uint8_t) ((length >> 16) & 0xff); buf[3] = (duk_uint8_t) ((length >> 8) & 0xff); buf[4] = (duk_uint8_t) (length & 0xff); buflen = 5; } duk_debug_write_bytes(thr, (const duk_uint8_t *) buf, buflen); duk_debug_write_bytes(thr, (const duk_uint8_t *) data, length); } DUK_INTERNAL void duk_debug_write_string(duk_hthread *thr, const char *data, duk_size_t length) { duk_debug_write_strbuf(thr, data, length, DUK_DBG_IB_STR4); } DUK_INTERNAL void duk_debug_write_cstring(duk_hthread *thr, const char *data) { DUK_ASSERT(thr != NULL); duk_debug_write_string(thr, data, data ? DUK_STRLEN(data) : 0); } DUK_INTERNAL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h) { DUK_ASSERT(thr != NULL); /* XXX: differentiate null pointer from empty string? */ duk_debug_write_string(thr, (h != NULL ? (const char *) DUK_HSTRING_GET_DATA(h) : NULL), (h != NULL ? (duk_size_t) DUK_HSTRING_GET_BYTELEN(h) : 0)); } DUK_LOCAL void duk__debug_write_hstring_safe_top(duk_hthread *thr) { duk_debug_write_hstring(thr, duk_safe_to_hstring(thr, -1)); } DUK_INTERNAL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length) { duk_debug_write_strbuf(thr, data, length, DUK_DBG_IB_BUF4); } DUK_INTERNAL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h) { DUK_ASSERT(thr != NULL); duk_debug_write_buffer(thr, (h != NULL ? (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h) : NULL), (h != NULL ? (duk_size_t) DUK_HBUFFER_GET_SIZE(h) : 0)); } DUK_LOCAL void duk__debug_write_pointer_raw(duk_hthread *thr, void *ptr, duk_uint8_t ibyte) { duk_uint8_t buf[2]; duk__ptr_union pu; DUK_ASSERT(thr != NULL); DUK_ASSERT(sizeof(ptr) >= 1 && sizeof(ptr) <= 16); /* ptr may be NULL */ buf[0] = ibyte; buf[1] = sizeof(pu); duk_debug_write_bytes(thr, buf, 2); pu.p = (void *) ptr; #if defined(DUK_USE_INTEGER_LE) duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu)); #endif duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu)); } DUK_INTERNAL void duk_debug_write_pointer(duk_hthread *thr, void *ptr) { duk__debug_write_pointer_raw(thr, ptr, DUK_DBG_IB_POINTER); } #if defined(DUK_USE_DEBUGGER_DUMPHEAP) || defined(DUK_USE_DEBUGGER_INSPECT) DUK_INTERNAL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h) { duk__debug_write_pointer_raw(thr, (void *) h, DUK_DBG_IB_HEAPPTR); } #endif /* DUK_USE_DEBUGGER_DUMPHEAP || DUK_USE_DEBUGGER_INSPECT */ DUK_INTERNAL void duk_debug_write_hobject(duk_hthread *thr, duk_hobject *obj) { duk_uint8_t buf[3]; duk__ptr_union pu; DUK_ASSERT(thr != NULL); DUK_ASSERT(sizeof(obj) >= 1 && sizeof(obj) <= 16); DUK_ASSERT(obj != NULL); buf[0] = DUK_DBG_IB_OBJECT; buf[1] = (duk_uint8_t) DUK_HOBJECT_GET_CLASS_NUMBER(obj); buf[2] = sizeof(pu); duk_debug_write_bytes(thr, buf, 3); pu.p = (void *) obj; #if defined(DUK_USE_INTEGER_LE) duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu)); #endif duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu)); } DUK_INTERNAL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv) { duk_c_function lf_func; duk_small_uint_t lf_flags; duk_uint8_t buf[4]; duk_double_union du1; duk_double_union du2; duk_int32_t i32; DUK_ASSERT(thr != NULL); DUK_ASSERT(tv != NULL); switch (DUK_TVAL_GET_TAG(tv)) { case DUK_TAG_UNDEFINED: duk_debug_write_byte(thr, DUK_DBG_IB_UNDEFINED); break; case DUK_TAG_UNUSED: duk_debug_write_byte(thr, DUK_DBG_IB_UNUSED); break; case DUK_TAG_NULL: duk_debug_write_byte(thr, DUK_DBG_IB_NULL); break; case DUK_TAG_BOOLEAN: DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv) == 0 || DUK_TVAL_GET_BOOLEAN(tv) == 1); duk_debug_write_boolean(thr, DUK_TVAL_GET_BOOLEAN(tv)); break; case DUK_TAG_POINTER: duk_debug_write_pointer(thr, (void *) DUK_TVAL_GET_POINTER(tv)); break; case DUK_TAG_LIGHTFUNC: DUK_TVAL_GET_LIGHTFUNC(tv, lf_func, lf_flags); buf[0] = DUK_DBG_IB_LIGHTFUNC; buf[1] = (duk_uint8_t) (lf_flags >> 8); buf[2] = (duk_uint8_t) (lf_flags & 0xff); buf[3] = sizeof(lf_func); duk_debug_write_bytes(thr, buf, 4); duk_debug_write_bytes(thr, (const duk_uint8_t *) &lf_func, sizeof(lf_func)); break; case DUK_TAG_STRING: duk_debug_write_hstring(thr, DUK_TVAL_GET_STRING(tv)); break; case DUK_TAG_OBJECT: duk_debug_write_hobject(thr, DUK_TVAL_GET_OBJECT(tv)); break; case DUK_TAG_BUFFER: duk_debug_write_hbuffer(thr, DUK_TVAL_GET_BUFFER(tv)); break; #if defined(DUK_USE_FASTINT) case DUK_TAG_FASTINT: #endif default: /* Numbers are normalized to big (network) endian. We can * (but are not required) to use integer dvalues when there's * no loss of precision. * * XXX: share check with other code; this check is slow but * reliable and doesn't require careful exponent/mantissa * mask tricks as in the fastint downgrade code. */ DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); du1.d = DUK_TVAL_GET_NUMBER(tv); i32 = (duk_int32_t) du1.d; du2.d = (duk_double_t) i32; DUK_DD(DUK_DDPRINT("i32=%ld du1=%02x%02x%02x%02x%02x%02x%02x%02x " "du2=%02x%02x%02x%02x%02x%02x%02x%02x", (long) i32, (unsigned int) du1.uc[0], (unsigned int) du1.uc[1], (unsigned int) du1.uc[2], (unsigned int) du1.uc[3], (unsigned int) du1.uc[4], (unsigned int) du1.uc[5], (unsigned int) du1.uc[6], (unsigned int) du1.uc[7], (unsigned int) du2.uc[0], (unsigned int) du2.uc[1], (unsigned int) du2.uc[2], (unsigned int) du2.uc[3], (unsigned int) du2.uc[4], (unsigned int) du2.uc[5], (unsigned int) du2.uc[6], (unsigned int) du2.uc[7])); if (duk_memcmp((const void *) du1.uc, (const void *) du2.uc, sizeof(du1.uc)) == 0) { duk_debug_write_int(thr, i32); } else { DUK_DBLUNION_DOUBLE_HTON(&du1); duk_debug_write_byte(thr, DUK_DBG_IB_NUMBER); duk_debug_write_bytes(thr, (const duk_uint8_t *) du1.uc, sizeof(du1.uc)); } } } #if defined(DUK_USE_DEBUGGER_DUMPHEAP) /* Variant for writing duk_tvals so that any heap allocated values are * written out as tagged heap pointers. */ DUK_LOCAL void duk__debug_write_tval_heapptr(duk_hthread *thr, duk_tval *tv) { if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv); duk_debug_write_heapptr(thr, h); } else { duk_debug_write_tval(thr, tv); } } #endif /* DUK_USE_DEBUGGER_DUMPHEAP */ /* * Debug connection message write helpers */ #if 0 /* unused */ DUK_INTERNAL void duk_debug_write_request(duk_hthread *thr, duk_small_uint_t command) { duk_debug_write_byte(thr, DUK_DBG_IB_REQUEST); duk_debug_write_int(thr, command); } #endif DUK_INTERNAL void duk_debug_write_reply(duk_hthread *thr) { duk_debug_write_byte(thr, DUK_DBG_IB_REPLY); } DUK_INTERNAL void duk_debug_write_error_eom(duk_hthread *thr, duk_small_uint_t err_code, const char *msg) { /* Allow NULL 'msg' */ duk_debug_write_byte(thr, DUK_DBG_IB_ERROR); duk_debug_write_int(thr, (duk_int32_t) err_code); duk_debug_write_cstring(thr, msg); duk_debug_write_eom(thr); } DUK_INTERNAL void duk_debug_write_notify(duk_hthread *thr, duk_small_uint_t command) { duk_debug_write_byte(thr, DUK_DBG_IB_NOTIFY); duk_debug_write_int(thr, (duk_int32_t) command); } DUK_INTERNAL void duk_debug_write_eom(duk_hthread *thr) { duk_debug_write_byte(thr, DUK_DBG_IB_EOM); /* As an initial implementation, write flush after every EOM (and the * version identifier). A better implementation would flush only when * Duktape is finished processing messages so that a flush only happens * after all outbound messages are finished on that occasion. */ duk_debug_write_flush(thr); } /* * Status message and helpers */ DUK_INTERNAL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr) { duk_activation *act; duk_uint_fast32_t line; duk_uint_fast32_t pc; act = thr->callstack_curr; if (act == NULL) { return 0; } /* We're conceptually between two opcodes; act->pc indicates the next * instruction to be executed. This is usually the correct pc/line to * indicate in Status. (For the 'debugger' statement this now reports * the pc/line after the debugger statement because the debugger opcode * has already been executed.) */ pc = duk_hthread_get_act_curr_pc(thr, act); /* XXX: this should be optimized to be a raw query and avoid valstack * operations if possible. */ duk_push_tval(thr, &act->tv_func); line = duk_hobject_pc2line_query(thr, -1, pc); duk_pop(thr); return line; } DUK_INTERNAL void duk_debug_send_status(duk_hthread *thr) { duk_activation *act; duk_debug_write_notify(thr, DUK_DBG_CMD_STATUS); duk_debug_write_int(thr, (DUK_HEAP_HAS_DEBUGGER_PAUSED(thr->heap) ? 1 : 0)); act = thr->callstack_curr; if (act == NULL) { duk_debug_write_undefined(thr); duk_debug_write_undefined(thr); duk_debug_write_int(thr, 0); duk_debug_write_int(thr, 0); } else { duk_push_tval(thr, &act->tv_func); duk_get_prop_literal(thr, -1, "fileName"); duk__debug_write_hstring_safe_top(thr); duk_get_prop_literal(thr, -2, "name"); duk__debug_write_hstring_safe_top(thr); duk_pop_3(thr); /* Report next pc/line to be executed. */ duk_debug_write_uint(thr, (duk_uint32_t) duk_debug_curr_line(thr)); duk_debug_write_uint(thr, (duk_uint32_t) duk_hthread_get_act_curr_pc(thr, act)); } duk_debug_write_eom(thr); } #if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) DUK_INTERNAL void duk_debug_send_throw(duk_hthread *thr, duk_bool_t fatal) { /* * NFY EOM */ duk_activation *act; duk_uint32_t pc; DUK_ASSERT(thr->valstack_top > thr->valstack); /* At least: ... [err] */ duk_debug_write_notify(thr, DUK_DBG_CMD_THROW); duk_debug_write_int(thr, (duk_int32_t) fatal); /* Report thrown value to client coerced to string */ duk_dup_top(thr); duk__debug_write_hstring_safe_top(thr); duk_pop(thr); if (duk_is_error(thr, -1)) { /* Error instance, use augmented error data directly */ duk_get_prop_stridx_short(thr, -1, DUK_STRIDX_FILE_NAME); duk__debug_write_hstring_safe_top(thr); duk_get_prop_stridx_short(thr, -2, DUK_STRIDX_LINE_NUMBER); duk_debug_write_uint(thr, duk_get_uint(thr, -1)); duk_pop_2(thr); } else { /* For anything other than an Error instance, we calculate the * error location directly from the current activation if one * exists. */ act = thr->callstack_curr; if (act != NULL) { duk_push_tval(thr, &act->tv_func); duk_get_prop_literal(thr, -1, "fileName"); duk__debug_write_hstring_safe_top(thr); pc = (duk_uint32_t) duk_hthread_get_act_prev_pc(thr, act); duk_debug_write_uint(thr, (duk_uint32_t) duk_hobject_pc2line_query(thr, -2, pc)); duk_pop_2(thr); } else { /* Can happen if duk_throw() is called on an empty * callstack. */ duk_debug_write_cstring(thr, ""); duk_debug_write_uint(thr, 0); } } duk_debug_write_eom(thr); } #endif /* DUK_USE_DEBUGGER_THROW_NOTIFY */ /* * Debug message processing */ /* Skip dvalue. */ DUK_LOCAL duk_bool_t duk__debug_skip_dvalue(duk_hthread *thr) { duk_uint8_t x; duk_uint32_t len; x = duk_debug_read_byte(thr); if (x >= 0xc0) { duk_debug_skip_byte(thr); return 0; } if (x >= 0x80) { return 0; } if (x >= 0x60) { duk_debug_skip_bytes(thr, (duk_size_t) (x - 0x60)); return 0; } switch(x) { case DUK_DBG_IB_EOM: return 1; /* Return 1: got EOM */ case DUK_DBG_IB_REQUEST: case DUK_DBG_IB_REPLY: case DUK_DBG_IB_ERROR: case DUK_DBG_IB_NOTIFY: break; case DUK_DBG_IB_INT4: (void) duk__debug_read_uint32_raw(thr); break; case DUK_DBG_IB_STR4: case DUK_DBG_IB_BUF4: len = duk__debug_read_uint32_raw(thr); duk_debug_skip_bytes(thr, len); break; case DUK_DBG_IB_STR2: case DUK_DBG_IB_BUF2: len = duk__debug_read_uint16_raw(thr); duk_debug_skip_bytes(thr, len); break; case DUK_DBG_IB_UNUSED: case DUK_DBG_IB_UNDEFINED: case DUK_DBG_IB_NULL: case DUK_DBG_IB_TRUE: case DUK_DBG_IB_FALSE: break; case DUK_DBG_IB_NUMBER: duk_debug_skip_bytes(thr, 8); break; case DUK_DBG_IB_OBJECT: duk_debug_skip_byte(thr); len = duk_debug_read_byte(thr); duk_debug_skip_bytes(thr, len); break; case DUK_DBG_IB_POINTER: case DUK_DBG_IB_HEAPPTR: len = duk_debug_read_byte(thr); duk_debug_skip_bytes(thr, len); break; case DUK_DBG_IB_LIGHTFUNC: duk_debug_skip_bytes(thr, 2); len = duk_debug_read_byte(thr); duk_debug_skip_bytes(thr, len); break; default: goto fail; } return 0; fail: DUK__SET_CONN_BROKEN(thr, 1); return 1; /* Pretend like we got EOM */ } /* Skip dvalues to EOM. */ DUK_LOCAL void duk__debug_skip_to_eom(duk_hthread *thr) { for (;;) { if (duk__debug_skip_dvalue(thr)) { break; } } } /* Read and validate a call stack index. If index is invalid, write out an * error message and return zero. */ DUK_LOCAL duk_int32_t duk__debug_read_validate_csindex(duk_hthread *thr) { duk_int32_t level; level = duk_debug_read_int(thr); if (level >= 0 || -level > (duk_int32_t) thr->callstack_top) { duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid callstack index"); return 0; /* zero indicates failure */ } return level; } /* Read a call stack index and lookup the corresponding duk_activation. * If index is invalid, write out an error message and return NULL. */ DUK_LOCAL duk_activation *duk__debug_read_level_get_activation(duk_hthread *thr) { duk_activation *act; duk_int32_t level; level = duk_debug_read_int(thr); act = duk_hthread_get_activation_for_level(thr, level); if (act == NULL) { duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid callstack index"); } return act; } /* * Simple commands */ DUK_LOCAL void duk__debug_handle_basic_info(duk_hthread *thr, duk_heap *heap) { DUK_UNREF(heap); DUK_D(DUK_DPRINT("debug command Version")); duk_debug_write_reply(thr); duk_debug_write_int(thr, DUK_VERSION); duk_debug_write_cstring(thr, DUK_GIT_DESCRIBE); duk_debug_write_cstring(thr, DUK_USE_TARGET_INFO); #if defined(DUK_USE_DOUBLE_LE) duk_debug_write_int(thr, 1); #elif defined(DUK_USE_DOUBLE_ME) duk_debug_write_int(thr, 2); #elif defined(DUK_USE_DOUBLE_BE) duk_debug_write_int(thr, 3); #else duk_debug_write_int(thr, 0); #endif duk_debug_write_int(thr, (duk_int_t) sizeof(void *)); duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_trigger_status(duk_hthread *thr, duk_heap *heap) { DUK_UNREF(heap); DUK_D(DUK_DPRINT("debug command TriggerStatus")); duk_debug_write_reply(thr); duk_debug_write_eom(thr); heap->dbg_state_dirty = 1; } DUK_LOCAL void duk__debug_handle_pause(duk_hthread *thr, duk_heap *heap) { DUK_D(DUK_DPRINT("debug command Pause")); duk_debug_set_paused(heap); duk_debug_write_reply(thr); duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_resume(duk_hthread *thr, duk_heap *heap) { duk_small_uint_t pause_flags; DUK_D(DUK_DPRINT("debug command Resume")); duk_debug_clear_paused(heap); pause_flags = 0; #if 0 /* manual testing */ pause_flags |= DUK_PAUSE_FLAG_ONE_OPCODE; pause_flags |= DUK_PAUSE_FLAG_CAUGHT_ERROR; pause_flags |= DUK_PAUSE_FLAG_UNCAUGHT_ERROR; #endif #if defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT) pause_flags |= DUK_PAUSE_FLAG_UNCAUGHT_ERROR; #endif duk__debug_set_pause_state(thr, heap, pause_flags); duk_debug_write_reply(thr); duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_step(duk_hthread *thr, duk_heap *heap, duk_int32_t cmd) { duk_small_uint_t pause_flags; DUK_D(DUK_DPRINT("debug command StepInto/StepOver/StepOut: %d", (int) cmd)); if (cmd == DUK_DBG_CMD_STEPINTO) { pause_flags = DUK_PAUSE_FLAG_LINE_CHANGE | DUK_PAUSE_FLAG_FUNC_ENTRY | DUK_PAUSE_FLAG_FUNC_EXIT; } else if (cmd == DUK_DBG_CMD_STEPOVER) { pause_flags = DUK_PAUSE_FLAG_LINE_CHANGE | DUK_PAUSE_FLAG_FUNC_EXIT; } else { DUK_ASSERT(cmd == DUK_DBG_CMD_STEPOUT); pause_flags = DUK_PAUSE_FLAG_FUNC_EXIT; } #if defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT) pause_flags |= DUK_PAUSE_FLAG_UNCAUGHT_ERROR; #endif /* If current activation doesn't have line information, line-based * pause flags are automatically disabled. As a result, e.g. * StepInto will then pause on (native) function entry or exit. */ duk_debug_clear_paused(heap); duk__debug_set_pause_state(thr, heap, pause_flags); duk_debug_write_reply(thr); duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_list_break(duk_hthread *thr, duk_heap *heap) { duk_small_int_t i; DUK_D(DUK_DPRINT("debug command ListBreak")); duk_debug_write_reply(thr); for (i = 0; i < (duk_small_int_t) heap->dbg_breakpoint_count; i++) { duk_debug_write_hstring(thr, heap->dbg_breakpoints[i].filename); duk_debug_write_uint(thr, (duk_uint32_t) heap->dbg_breakpoints[i].line); } duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_add_break(duk_hthread *thr, duk_heap *heap) { duk_hstring *filename; duk_uint32_t linenumber; duk_small_int_t idx; DUK_UNREF(heap); filename = duk_debug_read_hstring(thr); linenumber = (duk_uint32_t) duk_debug_read_int(thr); DUK_D(DUK_DPRINT("debug command AddBreak: %!O:%ld", (duk_hobject *) filename, (long) linenumber)); idx = duk_debug_add_breakpoint(thr, filename, linenumber); if (idx >= 0) { duk_debug_write_reply(thr); duk_debug_write_int(thr, (duk_int32_t) idx); duk_debug_write_eom(thr); } else { duk_debug_write_error_eom(thr, DUK_DBG_ERR_TOOMANY, "no space for breakpoint"); } } DUK_LOCAL void duk__debug_handle_del_break(duk_hthread *thr, duk_heap *heap) { duk_small_uint_t idx; DUK_UNREF(heap); DUK_D(DUK_DPRINT("debug command DelBreak")); idx = (duk_small_uint_t) duk_debug_read_int(thr); if (duk_debug_remove_breakpoint(thr, idx)) { duk_debug_write_reply(thr); duk_debug_write_eom(thr); } else { duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid breakpoint index"); } } DUK_LOCAL void duk__debug_handle_get_var(duk_hthread *thr, duk_heap *heap) { duk_activation *act; duk_hstring *str; duk_bool_t rc; DUK_UNREF(heap); DUK_D(DUK_DPRINT("debug command GetVar")); act = duk__debug_read_level_get_activation(thr); if (act == NULL) { return; } str = duk_debug_read_hstring(thr); /* push to stack */ DUK_ASSERT(str != NULL); rc = duk_js_getvar_activation(thr, act, str, 0); duk_debug_write_reply(thr); if (rc) { duk_debug_write_int(thr, 1); DUK_ASSERT(duk_get_tval(thr, -2) != NULL); duk_debug_write_tval(thr, duk_get_tval(thr, -2)); } else { duk_debug_write_int(thr, 0); duk_debug_write_unused(thr); } duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_put_var(duk_hthread *thr, duk_heap *heap) { duk_activation *act; duk_hstring *str; duk_tval *tv; DUK_UNREF(heap); DUK_D(DUK_DPRINT("debug command PutVar")); act = duk__debug_read_level_get_activation(thr); if (act == NULL) { return; } str = duk_debug_read_hstring(thr); /* push to stack */ DUK_ASSERT(str != NULL); tv = duk_debug_read_tval(thr); if (tv == NULL) { /* detached */ return; } duk_js_putvar_activation(thr, act, str, tv, 0); /* XXX: Current putvar implementation doesn't have a success flag, * add one and send to debug client? */ duk_debug_write_reply(thr); duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_get_call_stack(duk_hthread *thr, duk_heap *heap) { duk_hthread *curr_thr = thr; duk_activation *curr_act; duk_uint_fast32_t pc; duk_uint_fast32_t line; DUK_ASSERT(thr != NULL); DUK_UNREF(heap); duk_debug_write_reply(thr); while (curr_thr != NULL) { for (curr_act = curr_thr->callstack_curr; curr_act != NULL; curr_act = curr_act->parent) { /* PC/line semantics here are: * - For callstack top we're conceptually between two * opcodes and current PC indicates next line to * execute, so report that (matches Status). * - For other activations we're conceptually still * executing the instruction at PC-1, so report that * (matches error stacktrace behavior). * - See: https://github.com/svaarala/duktape/issues/281 */ /* XXX: optimize to use direct reads, i.e. avoid * value stack operations. */ duk_push_tval(thr, &curr_act->tv_func); duk_get_prop_stridx_short(thr, -1, DUK_STRIDX_FILE_NAME); duk__debug_write_hstring_safe_top(thr); duk_get_prop_stridx_short(thr, -2, DUK_STRIDX_NAME); duk__debug_write_hstring_safe_top(thr); pc = duk_hthread_get_act_curr_pc(thr, curr_act); if (curr_act != curr_thr->callstack_curr && pc > 0) { pc--; } line = duk_hobject_pc2line_query(thr, -3, pc); duk_debug_write_uint(thr, (duk_uint32_t) line); duk_debug_write_uint(thr, (duk_uint32_t) pc); duk_pop_3(thr); } curr_thr = curr_thr->resumer; } /* SCANBUILD: warning about 'thr' potentially being NULL here, * warning is incorrect because thr != NULL always here. */ duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_get_locals(duk_hthread *thr, duk_heap *heap) { duk_activation *act; duk_hstring *varname; DUK_UNREF(heap); act = duk__debug_read_level_get_activation(thr); if (act == NULL) { return; } duk_debug_write_reply(thr); /* XXX: several nice-to-have improvements here: * - Use direct reads avoiding value stack operations * - Avoid triggering getters, indicate getter values to debug client * - If side effects are possible, add error catching */ duk_push_tval(thr, &act->tv_func); duk_get_prop_stridx_short(thr, -1, DUK_STRIDX_INT_VARMAP); if (duk_is_object(thr, -1)) { duk_enum(thr, -1, 0 /*enum_flags*/); while (duk_next(thr, -1 /*enum_index*/, 0 /*get_value*/)) { varname = duk_known_hstring(thr, -1); duk_js_getvar_activation(thr, act, varname, 0 /*throw_flag*/); /* [ ... func varmap enum key value this ] */ duk_debug_write_hstring(thr, duk_get_hstring(thr, -3)); duk_debug_write_tval(thr, duk_get_tval(thr, -2)); duk_pop_3(thr); /* -> [ ... func varmap enum ] */ } } else { DUK_D(DUK_DPRINT("varmap is not an object in GetLocals, ignore")); } duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_eval(duk_hthread *thr, duk_heap *heap) { duk_small_uint_t call_flags; duk_int_t call_ret; duk_small_int_t eval_err; duk_bool_t direct_eval; duk_int32_t level; duk_idx_t idx_func; DUK_UNREF(heap); DUK_D(DUK_DPRINT("debug command Eval")); /* The eval code is executed within the lexical environment of a specified * activation. For now, use global object eval() function, with the eval * considered a 'direct call to eval'. * * Callstack index for debug commands only affects scope -- the callstack * as seen by, e.g. Duktape.act() will be the same regardless. */ /* nargs == 2 so we can pass a callstack index to eval(). */ idx_func = duk_get_top(thr); duk_push_c_function(thr, duk_bi_global_object_eval, 2 /*nargs*/); duk_push_undefined(thr); /* 'this' binding shouldn't matter here */ /* Read callstack index, if non-null. */ if (duk_debug_peek_byte(thr) == DUK_DBG_IB_NULL) { direct_eval = 0; level = -1; /* Not needed, but silences warning. */ (void) duk_debug_read_byte(thr); } else { direct_eval = 1; level = duk__debug_read_validate_csindex(thr); if (level == 0) { return; } } DUK_ASSERT(!direct_eval || (level < 0 && -level <= (duk_int32_t) thr->callstack_top)); (void) duk_debug_read_hstring(thr); if (direct_eval) { duk_push_int(thr, level - 1); /* compensate for eval() call */ } /* [ ... eval "eval" eval_input level? ] */ call_flags = 0; if (direct_eval) { duk_activation *act; duk_hobject *fun; act = duk_hthread_get_activation_for_level(thr, level); if (act != NULL) { fun = DUK_ACT_GET_FUNC(act); if (fun != NULL && DUK_HOBJECT_IS_COMPFUNC(fun)) { /* Direct eval requires that there's a current * activation and it is an ECMAScript function. * When Eval is executed from e.g. cooperate API * call we'll need to do an indirect eval instead. */ call_flags |= DUK_CALL_FLAG_DIRECT_EVAL; } } } call_ret = duk_pcall_method_flags(thr, duk_get_top(thr) - (idx_func + 2), call_flags); if (call_ret == DUK_EXEC_SUCCESS) { eval_err = 0; /* Use result value as is. */ } else { /* For errors a string coerced result is most informative * right now, as the debug client doesn't have the capability * to traverse the error object. */ eval_err = 1; duk_safe_to_string(thr, -1); } /* [ ... result ] */ duk_debug_write_reply(thr); duk_debug_write_int(thr, (duk_int32_t) eval_err); DUK_ASSERT(duk_get_tval(thr, -1) != NULL); duk_debug_write_tval(thr, duk_get_tval(thr, -1)); duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_detach(duk_hthread *thr, duk_heap *heap) { DUK_UNREF(heap); DUK_D(DUK_DPRINT("debug command Detach")); duk_debug_write_reply(thr); duk_debug_write_eom(thr); DUK_D(DUK_DPRINT("debug connection detached, mark broken")); DUK__SET_CONN_BROKEN(thr, 0); /* not an error */ } DUK_LOCAL void duk__debug_handle_apprequest(duk_hthread *thr, duk_heap *heap) { duk_idx_t old_top; DUK_D(DUK_DPRINT("debug command AppRequest")); old_top = duk_get_top(thr); /* save stack top */ if (heap->dbg_request_cb != NULL) { duk_idx_t nrets; duk_idx_t nvalues = 0; duk_idx_t top, idx; /* Read tvals from the message and push them onto the valstack, * then call the request callback to process the request. */ while (duk_debug_peek_byte(thr) != DUK_DBG_IB_EOM) { duk_tval *tv; if (!duk_check_stack(thr, 1)) { DUK_D(DUK_DPRINT("failed to allocate space for request dvalue(s)")); goto fail; } tv = duk_debug_read_tval(thr); /* push to stack */ if (tv == NULL) { /* detached */ return; } nvalues++; } DUK_ASSERT(duk_get_top(thr) == old_top + nvalues); /* Request callback should push values for reply to client onto valstack */ DUK_D(DUK_DPRINT("calling into AppRequest request_cb with nvalues=%ld, old_top=%ld, top=%ld", (long) nvalues, (long) old_top, (long) duk_get_top(thr))); nrets = heap->dbg_request_cb(thr, heap->dbg_udata, nvalues); DUK_D(DUK_DPRINT("returned from AppRequest request_cb; nvalues=%ld -> nrets=%ld, old_top=%ld, top=%ld", (long) nvalues, (long) nrets, (long) old_top, (long) duk_get_top(thr))); if (nrets >= 0) { DUK_ASSERT(duk_get_top(thr) >= old_top + nrets); if (duk_get_top(thr) < old_top + nrets) { DUK_D(DUK_DPRINT("AppRequest callback doesn't match value stack configuration, " "top=%ld < old_top=%ld + nrets=%ld; " "this might mean it's unsafe to continue!", (long) duk_get_top(thr), (long) old_top, (long) nrets)); goto fail; } /* Reply with tvals pushed by request callback */ duk_debug_write_byte(thr, DUK_DBG_IB_REPLY); top = duk_get_top(thr); for (idx = top - nrets; idx < top; idx++) { duk_debug_write_tval(thr, DUK_GET_TVAL_POSIDX(thr, idx)); } duk_debug_write_eom(thr); } else { DUK_ASSERT(duk_get_top(thr) >= old_top + 1); if (duk_get_top(thr) < old_top + 1) { DUK_D(DUK_DPRINT("request callback return value doesn't match value stack configuration")); goto fail; } duk_debug_write_error_eom(thr, DUK_DBG_ERR_APPLICATION, duk_get_string(thr, -1)); } duk_set_top(thr, old_top); /* restore stack top */ } else { DUK_D(DUK_DPRINT("no request callback, treat AppRequest as unsupported")); duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNSUPPORTED, "AppRequest unsupported by target"); } return; fail: duk_set_top(thr, old_top); /* restore stack top */ DUK__SET_CONN_BROKEN(thr, 1); } /* * DumpHeap command */ #if defined(DUK_USE_DEBUGGER_DUMPHEAP) /* XXX: this has some overlap with object inspection; remove this and make * DumpHeap return lists of heapptrs instead? */ DUK_LOCAL void duk__debug_dump_heaphdr(duk_hthread *thr, duk_heap *heap, duk_heaphdr *hdr) { DUK_UNREF(heap); duk_debug_write_heapptr(thr, hdr); duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_TYPE(hdr)); duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_FLAGS_RAW(hdr)); #if defined(DUK_USE_REFERENCE_COUNTING) duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_REFCOUNT(hdr)); #else duk_debug_write_int(thr, (duk_int32_t) -1); #endif switch (DUK_HEAPHDR_GET_TYPE(hdr)) { case DUK_HTYPE_STRING: { duk_hstring *h = (duk_hstring *) hdr; duk_debug_write_uint(thr, (duk_uint32_t) DUK_HSTRING_GET_BYTELEN(h)); duk_debug_write_uint(thr, (duk_uint32_t) DUK_HSTRING_GET_CHARLEN(h)); duk_debug_write_uint(thr, (duk_uint32_t) DUK_HSTRING_GET_HASH(h)); duk_debug_write_hstring(thr, h); break; } case DUK_HTYPE_OBJECT: { duk_hobject *h = (duk_hobject *) hdr; duk_hstring *k; duk_uint_fast32_t i; duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_CLASS_NUMBER(h)); duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(heap, h)); duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ESIZE(h)); duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ENEXT(h)); duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ASIZE(h)); duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_HSIZE(h)); for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) { duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_E_GET_FLAGS(heap, h, i)); k = DUK_HOBJECT_E_GET_KEY(heap, h, i); duk_debug_write_heapptr(thr, (duk_heaphdr *) k); if (k == NULL) { duk_debug_write_int(thr, 0); /* isAccessor */ duk_debug_write_unused(thr); continue; } if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) { duk_debug_write_int(thr, 1); /* isAccessor */ duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get); duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set); } else { duk_debug_write_int(thr, 0); /* isAccessor */ duk__debug_write_tval_heapptr(thr, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v); } } for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) { /* Note: array dump will include elements beyond * 'length'. */ duk__debug_write_tval_heapptr(thr, DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i)); } break; } case DUK_HTYPE_BUFFER: { duk_hbuffer *h = (duk_hbuffer *) hdr; duk_debug_write_uint(thr, (duk_uint32_t) DUK_HBUFFER_GET_SIZE(h)); duk_debug_write_buffer(thr, (const char *) DUK_HBUFFER_GET_DATA_PTR(heap, h), (duk_size_t) DUK_HBUFFER_GET_SIZE(h)); break; } default: { DUK_D(DUK_DPRINT("invalid htype: %d", (int) DUK_HEAPHDR_GET_TYPE(hdr))); } } } DUK_LOCAL void duk__debug_dump_heap_allocated(duk_hthread *thr, duk_heap *heap) { duk_heaphdr *hdr; hdr = heap->heap_allocated; while (hdr != NULL) { duk__debug_dump_heaphdr(thr, heap, hdr); hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr); } } DUK_LOCAL void duk__debug_dump_strtab(duk_hthread *thr, duk_heap *heap) { duk_uint32_t i; duk_hstring *h; for (i = 0; i < heap->st_size; i++) { #if defined(DUK_USE_STRTAB_PTRCOMP) h = DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, heap->strtable16[i]); #else h = heap->strtable[i]; #endif while (h != NULL) { duk__debug_dump_heaphdr(thr, heap, (duk_heaphdr *) h); h = h->hdr.h_next; } } } DUK_LOCAL void duk__debug_handle_dump_heap(duk_hthread *thr, duk_heap *heap) { DUK_D(DUK_DPRINT("debug command DumpHeap")); duk_debug_write_reply(thr); duk__debug_dump_heap_allocated(thr, heap); duk__debug_dump_strtab(thr, heap); duk_debug_write_eom(thr); } #endif /* DUK_USE_DEBUGGER_DUMPHEAP */ DUK_LOCAL void duk__debug_handle_get_bytecode(duk_hthread *thr, duk_heap *heap) { duk_activation *act; duk_hcompfunc *fun = NULL; duk_size_t i, n; duk_tval *tv; duk_hobject **fn; duk_int32_t level = -1; duk_uint8_t ibyte; DUK_UNREF(heap); DUK_D(DUK_DPRINT("debug command GetBytecode")); ibyte = duk_debug_peek_byte(thr); if (ibyte != DUK_DBG_IB_EOM) { tv = duk_debug_read_tval(thr); if (tv == NULL) { /* detached */ return; } if (DUK_TVAL_IS_OBJECT(tv)) { /* tentative, checked later */ fun = (duk_hcompfunc *) DUK_TVAL_GET_OBJECT(tv); DUK_ASSERT(fun != NULL); } else if (DUK_TVAL_IS_NUMBER(tv)) { level = (duk_int32_t) DUK_TVAL_GET_NUMBER(tv); } else { DUK_D(DUK_DPRINT("invalid argument to GetBytecode: %!T", tv)); goto fail_args; } } if (fun == NULL) { act = duk_hthread_get_activation_for_level(thr, level); if (act == NULL) { goto fail_index; } fun = (duk_hcompfunc *) DUK_ACT_GET_FUNC(act); } if (fun == NULL || !DUK_HOBJECT_IS_COMPFUNC((duk_hobject *) fun)) { DUK_D(DUK_DPRINT("invalid argument to GetBytecode: %!O", fun)); goto fail_args; } DUK_ASSERT(fun != NULL && DUK_HOBJECT_IS_COMPFUNC((duk_hobject *) fun)); duk_debug_write_reply(thr); n = DUK_HCOMPFUNC_GET_CONSTS_COUNT(heap, fun); duk_debug_write_int(thr, (duk_int32_t) n); tv = DUK_HCOMPFUNC_GET_CONSTS_BASE(heap, fun); for (i = 0; i < n; i++) { duk_debug_write_tval(thr, tv); tv++; } n = DUK_HCOMPFUNC_GET_FUNCS_COUNT(heap, fun); duk_debug_write_int(thr, (duk_int32_t) n); fn = DUK_HCOMPFUNC_GET_FUNCS_BASE(heap, fun); for (i = 0; i < n; i++) { duk_debug_write_hobject(thr, *fn); fn++; } duk_debug_write_string(thr, (const char *) DUK_HCOMPFUNC_GET_CODE_BASE(heap, fun), (duk_size_t) DUK_HCOMPFUNC_GET_CODE_SIZE(heap, fun)); duk_debug_write_eom(thr); return; fail_args: duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNKNOWN, "invalid argument"); return; fail_index: duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid callstack index"); return; } /* * Object inspection commands: GetHeapObjInfo, GetObjPropDesc, * GetObjPropDescRange */ #if defined(DUK_USE_DEBUGGER_INSPECT) #if 0 /* pruned */ DUK_LOCAL const char * const duk__debug_getinfo_heaphdr_keys[] = { "reachable", "temproot", "finalizable", "finalized", "readonly" /* NULL not needed here */ }; DUK_LOCAL duk_uint_t duk__debug_getinfo_heaphdr_masks[] = { DUK_HEAPHDR_FLAG_REACHABLE, DUK_HEAPHDR_FLAG_TEMPROOT, DUK_HEAPHDR_FLAG_FINALIZABLE, DUK_HEAPHDR_FLAG_FINALIZED, DUK_HEAPHDR_FLAG_READONLY, 0 /* terminator */ }; #endif DUK_LOCAL const char * const duk__debug_getinfo_hstring_keys[] = { #if 0 "arridx", "symbol", "hidden", "reserved_word", "strict_reserved_word", "eval_or_arguments", #endif "extdata" /* NULL not needed here */ }; DUK_LOCAL duk_uint_t duk__debug_getinfo_hstring_masks[] = { #if 0 DUK_HSTRING_FLAG_ARRIDX, DUK_HSTRING_FLAG_SYMBOL, DUK_HSTRING_FLAG_HIDDEN, DUK_HSTRING_FLAG_RESERVED_WORD, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS, #endif DUK_HSTRING_FLAG_EXTDATA, 0 /* terminator */ }; DUK_LOCAL const char * const duk__debug_getinfo_hobject_keys[] = { "extensible", "constructable", "callable", "boundfunc", "compfunc", "natfunc", "bufobj", "fastrefs", "array_part", "strict", "notail", "newenv", "namebinding", "createargs", "have_finalizer", "exotic_array", "exotic_stringobj", "exotic_arguments", "exotic_proxyobj", "special_call" /* NULL not needed here */ }; DUK_LOCAL duk_uint_t duk__debug_getinfo_hobject_masks[] = { DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_CONSTRUCTABLE, DUK_HOBJECT_FLAG_CALLABLE, DUK_HOBJECT_FLAG_BOUNDFUNC, DUK_HOBJECT_FLAG_COMPFUNC, DUK_HOBJECT_FLAG_NATFUNC, DUK_HOBJECT_FLAG_BUFOBJ, DUK_HOBJECT_FLAG_FASTREFS, DUK_HOBJECT_FLAG_ARRAY_PART, DUK_HOBJECT_FLAG_STRICT, DUK_HOBJECT_FLAG_NOTAIL, DUK_HOBJECT_FLAG_NEWENV, DUK_HOBJECT_FLAG_NAMEBINDING, DUK_HOBJECT_FLAG_CREATEARGS, DUK_HOBJECT_FLAG_HAVE_FINALIZER, DUK_HOBJECT_FLAG_EXOTIC_ARRAY, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ, DUK_HOBJECT_FLAG_SPECIAL_CALL, 0 /* terminator */ }; DUK_LOCAL const char * const duk__debug_getinfo_hbuffer_keys[] = { "dynamic", "external" /* NULL not needed here */ }; DUK_LOCAL duk_uint_t duk__debug_getinfo_hbuffer_masks[] = { DUK_HBUFFER_FLAG_DYNAMIC, DUK_HBUFFER_FLAG_EXTERNAL, 0 /* terminator */ }; DUK_LOCAL void duk__debug_getinfo_flags_key(duk_hthread *thr, const char *key) { duk_debug_write_uint(thr, 0); duk_debug_write_cstring(thr, key); } DUK_LOCAL void duk__debug_getinfo_prop_uint(duk_hthread *thr, const char *key, duk_uint_t val) { duk_debug_write_uint(thr, 0); duk_debug_write_cstring(thr, key); duk_debug_write_uint(thr, val); } DUK_LOCAL void duk__debug_getinfo_prop_int(duk_hthread *thr, const char *key, duk_int_t val) { duk_debug_write_uint(thr, 0); duk_debug_write_cstring(thr, key); duk_debug_write_int(thr, val); } DUK_LOCAL void duk__debug_getinfo_prop_bool(duk_hthread *thr, const char *key, duk_bool_t val) { duk_debug_write_uint(thr, 0); duk_debug_write_cstring(thr, key); duk_debug_write_boolean(thr, val); } DUK_LOCAL void duk__debug_getinfo_bitmask(duk_hthread *thr, const char * const * keys, duk_uint_t *masks, duk_uint_t flags) { const char *key; duk_uint_t mask; for (;;) { mask = *masks++; if (mask == 0) { break; } key = *keys++; DUK_ASSERT(key != NULL); DUK_DD(DUK_DDPRINT("inspect bitmask: key=%s, mask=0x%08lx, flags=0x%08lx", key, (unsigned long) mask, (unsigned long) flags)); duk__debug_getinfo_prop_bool(thr, key, flags & mask); } } /* Inspect a property using a virtual index into a conceptual property list * consisting of (1) all array part items from [0,a_size[ (even when above * .length) and (2) all entry part items from [0,e_next[. Unused slots are * indicated using dvalue 'unused'. */ DUK_LOCAL duk_bool_t duk__debug_getprop_index(duk_hthread *thr, duk_heap *heap, duk_hobject *h_obj, duk_uint_t idx) { duk_uint_t a_size; duk_tval *tv; duk_hstring *h_key; duk_hobject *h_getset; duk_uint_t flags; DUK_UNREF(heap); a_size = DUK_HOBJECT_GET_ASIZE(h_obj); if (idx < a_size) { duk_debug_write_uint(thr, DUK_PROPDESC_FLAGS_WEC); duk_debug_write_uint(thr, idx); tv = DUK_HOBJECT_A_GET_VALUE_PTR(heap, h_obj, idx); duk_debug_write_tval(thr, tv); return 1; } idx -= a_size; if (idx >= DUK_HOBJECT_GET_ENEXT(h_obj)) { return 0; } h_key = DUK_HOBJECT_E_GET_KEY(heap, h_obj, idx); if (h_key == NULL) { duk_debug_write_uint(thr, 0); duk_debug_write_null(thr); duk_debug_write_unused(thr); return 1; } flags = DUK_HOBJECT_E_GET_FLAGS(heap, h_obj, idx); if (DUK_HSTRING_HAS_SYMBOL(h_key)) { flags |= DUK_DBG_PROPFLAG_SYMBOL; } if (DUK_HSTRING_HAS_HIDDEN(h_key)) { flags |= DUK_DBG_PROPFLAG_HIDDEN; } duk_debug_write_uint(thr, flags); duk_debug_write_hstring(thr, h_key); if (flags & DUK_PROPDESC_FLAG_ACCESSOR) { h_getset = DUK_HOBJECT_E_GET_VALUE_GETTER(heap, h_obj, idx); if (h_getset) { duk_debug_write_hobject(thr, h_getset); } else { duk_debug_write_null(thr); } h_getset = DUK_HOBJECT_E_GET_VALUE_SETTER(heap, h_obj, idx); if (h_getset) { duk_debug_write_hobject(thr, h_getset); } else { duk_debug_write_null(thr); } } else { tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, h_obj, idx); duk_debug_write_tval(thr, tv); } return 1; } DUK_LOCAL void duk__debug_handle_get_heap_obj_info(duk_hthread *thr, duk_heap *heap) { duk_heaphdr *h; DUK_D(DUK_DPRINT("debug command GetHeapObjInfo")); DUK_UNREF(heap); DUK_ASSERT(sizeof(duk__debug_getinfo_hstring_keys) / sizeof(const char *) == sizeof(duk__debug_getinfo_hstring_masks) / sizeof(duk_uint_t) - 1); DUK_ASSERT(sizeof(duk__debug_getinfo_hobject_keys) / sizeof(const char *) == sizeof(duk__debug_getinfo_hobject_masks) / sizeof(duk_uint_t) - 1); DUK_ASSERT(sizeof(duk__debug_getinfo_hbuffer_keys) / sizeof(const char *) == sizeof(duk__debug_getinfo_hbuffer_masks) / sizeof(duk_uint_t) - 1); h = duk_debug_read_any_ptr(thr); if (!h) { duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNKNOWN, "invalid target"); return; } duk_debug_write_reply(thr); /* As with all inspection code, we rely on the debug client providing * a valid, non-stale pointer: there's no portable way to safely * validate the pointer here. */ duk__debug_getinfo_flags_key(thr, "heapptr"); duk_debug_write_heapptr(thr, h); /* XXX: comes out as signed now */ duk__debug_getinfo_prop_uint(thr, "heaphdr_flags", (duk_uint_t) DUK_HEAPHDR_GET_FLAGS(h)); duk__debug_getinfo_prop_uint(thr, "heaphdr_type", (duk_uint_t) DUK_HEAPHDR_GET_TYPE(h)); #if defined(DUK_USE_REFERENCE_COUNTING) duk__debug_getinfo_prop_uint(thr, "refcount", (duk_uint_t) DUK_HEAPHDR_GET_REFCOUNT(h)); #endif #if 0 /* pruned */ duk__debug_getinfo_bitmask(thr, duk__debug_getinfo_heaphdr_keys, duk__debug_getinfo_heaphdr_masks, DUK_HEAPHDR_GET_FLAGS_RAW(h)); #endif switch (DUK_HEAPHDR_GET_TYPE(h)) { case DUK_HTYPE_STRING: { duk_hstring *h_str; h_str = (duk_hstring *) h; duk__debug_getinfo_bitmask(thr, duk__debug_getinfo_hstring_keys, duk__debug_getinfo_hstring_masks, DUK_HEAPHDR_GET_FLAGS_RAW(h)); duk__debug_getinfo_prop_uint(thr, "bytelen", (duk_uint_t) DUK_HSTRING_GET_BYTELEN(h_str)); duk__debug_getinfo_prop_uint(thr, "charlen", (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h_str)); duk__debug_getinfo_prop_uint(thr, "hash", (duk_uint_t) DUK_HSTRING_GET_HASH(h_str)); duk__debug_getinfo_flags_key(thr, "data"); duk_debug_write_hstring(thr, h_str); break; } case DUK_HTYPE_OBJECT: { duk_hobject *h_obj; duk_hobject *h_proto; h_obj = (duk_hobject *) h; h_proto = DUK_HOBJECT_GET_PROTOTYPE(heap, h_obj); /* duk_hobject specific fields. */ duk__debug_getinfo_bitmask(thr, duk__debug_getinfo_hobject_keys, duk__debug_getinfo_hobject_masks, DUK_HEAPHDR_GET_FLAGS_RAW(h)); duk__debug_getinfo_prop_uint(thr, "class_number", DUK_HOBJECT_GET_CLASS_NUMBER(h_obj)); duk__debug_getinfo_flags_key(thr, "class_name"); duk_debug_write_hstring(thr, DUK_HOBJECT_GET_CLASS_STRING(heap, h_obj)); duk__debug_getinfo_flags_key(thr, "prototype"); if (h_proto != NULL) { duk_debug_write_hobject(thr, h_proto); } else { duk_debug_write_null(thr); } duk__debug_getinfo_flags_key(thr, "props"); duk_debug_write_pointer(thr, (void *) DUK_HOBJECT_GET_PROPS(heap, h_obj)); duk__debug_getinfo_prop_uint(thr, "e_size", (duk_uint_t) DUK_HOBJECT_GET_ESIZE(h_obj)); duk__debug_getinfo_prop_uint(thr, "e_next", (duk_uint_t) DUK_HOBJECT_GET_ENEXT(h_obj)); duk__debug_getinfo_prop_uint(thr, "a_size", (duk_uint_t) DUK_HOBJECT_GET_ASIZE(h_obj)); duk__debug_getinfo_prop_uint(thr, "h_size", (duk_uint_t) DUK_HOBJECT_GET_HSIZE(h_obj)); if (DUK_HOBJECT_IS_ARRAY(h_obj)) { duk_harray *h_arr; h_arr = (duk_harray *) h_obj; duk__debug_getinfo_prop_uint(thr, "length", (duk_uint_t) h_arr->length); duk__debug_getinfo_prop_bool(thr, "length_nonwritable", h_arr->length_nonwritable); } if (DUK_HOBJECT_IS_NATFUNC(h_obj)) { duk_hnatfunc *h_fun; h_fun = (duk_hnatfunc *) h_obj; duk__debug_getinfo_prop_int(thr, "nargs", h_fun->nargs); duk__debug_getinfo_prop_int(thr, "magic", h_fun->magic); duk__debug_getinfo_prop_bool(thr, "varargs", h_fun->magic == DUK_HNATFUNC_NARGS_VARARGS); /* Native function pointer may be different from a void pointer, * and we serialize it from memory directly now (no byte swapping etc). */ duk__debug_getinfo_flags_key(thr, "funcptr"); duk_debug_write_buffer(thr, (const char *) &h_fun->func, sizeof(h_fun->func)); } if (DUK_HOBJECT_IS_COMPFUNC(h_obj)) { duk_hcompfunc *h_fun; duk_hbuffer *h_buf; duk_hobject *h_lexenv; duk_hobject *h_varenv; h_fun = (duk_hcompfunc *) h_obj; duk__debug_getinfo_prop_int(thr, "nregs", h_fun->nregs); duk__debug_getinfo_prop_int(thr, "nargs", h_fun->nargs); duk__debug_getinfo_flags_key(thr, "lex_env"); h_lexenv = DUK_HCOMPFUNC_GET_LEXENV(thr->heap, h_fun); if (h_lexenv != NULL) { duk_debug_write_hobject(thr, h_lexenv); } else { duk_debug_write_null(thr); } duk__debug_getinfo_flags_key(thr, "var_env"); h_varenv = DUK_HCOMPFUNC_GET_VARENV(thr->heap, h_fun); if (h_varenv != NULL) { duk_debug_write_hobject(thr, h_varenv); } else { duk_debug_write_null(thr); } duk__debug_getinfo_prop_uint(thr, "start_line", h_fun->start_line); duk__debug_getinfo_prop_uint(thr, "end_line", h_fun->end_line); h_buf = (duk_hbuffer *) DUK_HCOMPFUNC_GET_DATA(thr->heap, h_fun); if (h_buf != NULL) { duk__debug_getinfo_flags_key(thr, "data"); duk_debug_write_heapptr(thr, (duk_heaphdr *) h_buf); } } if (DUK_HOBJECT_IS_BOUNDFUNC(h_obj)) { duk_hboundfunc *h_bfun; h_bfun = (duk_hboundfunc *) (void *) h_obj; duk__debug_getinfo_flags_key(thr, "target"); duk_debug_write_tval(thr, &h_bfun->target); duk__debug_getinfo_flags_key(thr, "this_binding"); duk_debug_write_tval(thr, &h_bfun->this_binding); duk__debug_getinfo_flags_key(thr, "nargs"); duk_debug_write_int(thr, h_bfun->nargs); /* h_bfun->args not exposed now */ } if (DUK_HOBJECT_IS_THREAD(h_obj)) { /* XXX: Currently no inspection of threads, e.g. value stack, call * stack, catch stack, etc. */ duk_hthread *h_thr; h_thr = (duk_hthread *) h_obj; DUK_UNREF(h_thr); } if (DUK_HOBJECT_IS_DECENV(h_obj)) { duk_hdecenv *h_env; h_env = (duk_hdecenv *) h_obj; duk__debug_getinfo_flags_key(thr, "thread"); duk_debug_write_heapptr(thr, (duk_heaphdr *) (h_env->thread)); duk__debug_getinfo_flags_key(thr, "varmap"); duk_debug_write_heapptr(thr, (duk_heaphdr *) (h_env->varmap)); duk__debug_getinfo_prop_uint(thr, "regbase", (duk_uint_t) h_env->regbase_byteoff); } if (DUK_HOBJECT_IS_OBJENV(h_obj)) { duk_hobjenv *h_env; h_env = (duk_hobjenv *) h_obj; duk__debug_getinfo_flags_key(thr, "target"); duk_debug_write_heapptr(thr, (duk_heaphdr *) (h_env->target)); duk__debug_getinfo_prop_bool(thr, "has_this", h_env->has_this); } #if defined(DUK_USE_BUFFEROBJECT_SUPPORT) if (DUK_HOBJECT_IS_BUFOBJ(h_obj)) { duk_hbufobj *h_bufobj; h_bufobj = (duk_hbufobj *) h_obj; duk__debug_getinfo_prop_uint(thr, "slice_offset", h_bufobj->offset); duk__debug_getinfo_prop_uint(thr, "slice_length", h_bufobj->length); duk__debug_getinfo_prop_uint(thr, "elem_shift", (duk_uint_t) h_bufobj->shift); duk__debug_getinfo_prop_uint(thr, "elem_type", (duk_uint_t) h_bufobj->elem_type); duk__debug_getinfo_prop_bool(thr, "is_typedarray", (duk_uint_t) h_bufobj->is_typedarray); if (h_bufobj->buf != NULL) { duk__debug_getinfo_flags_key(thr, "buffer"); duk_debug_write_heapptr(thr, (duk_heaphdr *) h_bufobj->buf); } } #endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ break; } case DUK_HTYPE_BUFFER: { duk_hbuffer *h_buf; h_buf = (duk_hbuffer *) h; duk__debug_getinfo_bitmask(thr, duk__debug_getinfo_hbuffer_keys, duk__debug_getinfo_hbuffer_masks, DUK_HEAPHDR_GET_FLAGS_RAW(h)); duk__debug_getinfo_prop_uint(thr, "size", (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_buf)); duk__debug_getinfo_flags_key(thr, "dataptr"); duk_debug_write_pointer(thr, (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_buf)); duk__debug_getinfo_flags_key(thr, "data"); duk_debug_write_hbuffer(thr, h_buf); /* tolerates NULL h_buf */ break; } default: { /* Since we already started writing the reply, just emit nothing. */ DUK_D(DUK_DPRINT("inspect target pointer has invalid heaphdr type")); } } duk_debug_write_eom(thr); } DUK_LOCAL void duk__debug_handle_get_obj_prop_desc(duk_hthread *thr, duk_heap *heap) { duk_heaphdr *h; duk_hobject *h_obj; duk_hstring *h_key; duk_propdesc desc; DUK_D(DUK_DPRINT("debug command GetObjPropDesc")); DUK_UNREF(heap); h = duk_debug_read_any_ptr(thr); if (!h) { duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNKNOWN, "invalid target"); return; } h_key = duk_debug_read_hstring(thr); if (h == NULL || DUK_HEAPHDR_GET_TYPE(h) != DUK_HTYPE_OBJECT || h_key == NULL) { goto fail_args; } h_obj = (duk_hobject *) h; if (duk_hobject_get_own_propdesc(thr, h_obj, h_key, &desc, 0 /*flags*/)) { duk_int_t virtual_idx; duk_bool_t rc; /* To use the shared helper need the virtual index. */ DUK_ASSERT(desc.e_idx >= 0 || desc.a_idx >= 0); virtual_idx = (desc.a_idx >= 0 ? desc.a_idx : (duk_int_t) DUK_HOBJECT_GET_ASIZE(h_obj) + desc.e_idx); duk_debug_write_reply(thr); rc = duk__debug_getprop_index(thr, heap, h_obj, (duk_uint_t) virtual_idx); DUK_ASSERT(rc == 1); DUK_UNREF(rc); duk_debug_write_eom(thr); } else { duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "not found"); } return; fail_args: duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNKNOWN, "invalid args"); } DUK_LOCAL void duk__debug_handle_get_obj_prop_desc_range(duk_hthread *thr, duk_heap *heap) { duk_heaphdr *h; duk_hobject *h_obj; duk_uint_t idx, idx_start, idx_end; DUK_D(DUK_DPRINT("debug command GetObjPropDescRange")); DUK_UNREF(heap); h = duk_debug_read_any_ptr(thr); idx_start = (duk_uint_t) duk_debug_read_int(thr); idx_end = (duk_uint_t) duk_debug_read_int(thr); if (h == NULL || DUK_HEAPHDR_GET_TYPE(h) != DUK_HTYPE_OBJECT) { goto fail_args; } h_obj = (duk_hobject *) h; /* The index range space is conceptually the array part followed by the * entry part. Unlike normal enumeration all slots are exposed here as * is and return 'unused' if the slots are not in active use. In particular * the array part is included for the full a_size regardless of what the * array .length is. */ duk_debug_write_reply(thr); for (idx = idx_start; idx < idx_end; idx++) { if (!duk__debug_getprop_index(thr, heap, h_obj, idx)) { break; } } duk_debug_write_eom(thr); return; fail_args: duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNKNOWN, "invalid args"); } #endif /* DUK_USE_DEBUGGER_INSPECT */ /* * Process incoming debug requests * * Individual request handlers can push temporaries on the value stack and * rely on duk__debug_process_message() to restore the value stack top * automatically. */ /* Process one debug message. Automatically restore value stack top to its * entry value, so that individual message handlers don't need exact value * stack handling which is convenient. */ DUK_LOCAL void duk__debug_process_message(duk_hthread *thr) { duk_heap *heap; duk_uint8_t x; duk_int32_t cmd; duk_idx_t entry_top; DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); entry_top = duk_get_top(thr); x = duk_debug_read_byte(thr); switch (x) { case DUK_DBG_IB_REQUEST: { cmd = duk_debug_read_int(thr); switch (cmd) { case DUK_DBG_CMD_BASICINFO: { duk__debug_handle_basic_info(thr, heap); break; } case DUK_DBG_CMD_TRIGGERSTATUS: { duk__debug_handle_trigger_status(thr, heap); break; } case DUK_DBG_CMD_PAUSE: { duk__debug_handle_pause(thr, heap); break; } case DUK_DBG_CMD_RESUME: { duk__debug_handle_resume(thr, heap); break; } case DUK_DBG_CMD_STEPINTO: case DUK_DBG_CMD_STEPOVER: case DUK_DBG_CMD_STEPOUT: { duk__debug_handle_step(thr, heap, cmd); break; } case DUK_DBG_CMD_LISTBREAK: { duk__debug_handle_list_break(thr, heap); break; } case DUK_DBG_CMD_ADDBREAK: { duk__debug_handle_add_break(thr, heap); break; } case DUK_DBG_CMD_DELBREAK: { duk__debug_handle_del_break(thr, heap); break; } case DUK_DBG_CMD_GETVAR: { duk__debug_handle_get_var(thr, heap); break; } case DUK_DBG_CMD_PUTVAR: { duk__debug_handle_put_var(thr, heap); break; } case DUK_DBG_CMD_GETCALLSTACK: { duk__debug_handle_get_call_stack(thr, heap); break; } case DUK_DBG_CMD_GETLOCALS: { duk__debug_handle_get_locals(thr, heap); break; } case DUK_DBG_CMD_EVAL: { duk__debug_handle_eval(thr, heap); break; } case DUK_DBG_CMD_DETACH: { /* The actual detached_cb call is postponed to message loop so * we don't need any special precautions here (just skip to EOM * on the already closed connection). */ duk__debug_handle_detach(thr, heap); break; } #if defined(DUK_USE_DEBUGGER_DUMPHEAP) case DUK_DBG_CMD_DUMPHEAP: { duk__debug_handle_dump_heap(thr, heap); break; } #endif /* DUK_USE_DEBUGGER_DUMPHEAP */ case DUK_DBG_CMD_GETBYTECODE: { duk__debug_handle_get_bytecode(thr, heap); break; } case DUK_DBG_CMD_APPREQUEST: { duk__debug_handle_apprequest(thr, heap); break; } #if defined(DUK_USE_DEBUGGER_INSPECT) case DUK_DBG_CMD_GETHEAPOBJINFO: { duk__debug_handle_get_heap_obj_info(thr, heap); break; } case DUK_DBG_CMD_GETOBJPROPDESC: { duk__debug_handle_get_obj_prop_desc(thr, heap); break; } case DUK_DBG_CMD_GETOBJPROPDESCRANGE: { duk__debug_handle_get_obj_prop_desc_range(thr, heap); break; } #endif /* DUK_USE_DEBUGGER_INSPECT */ default: { DUK_D(DUK_DPRINT("debug command unsupported: %d", (int) cmd)); duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNSUPPORTED, "unsupported command"); } } /* switch cmd */ break; } case DUK_DBG_IB_REPLY: { DUK_D(DUK_DPRINT("debug reply, skipping")); break; } case DUK_DBG_IB_ERROR: { DUK_D(DUK_DPRINT("debug error, skipping")); break; } case DUK_DBG_IB_NOTIFY: { DUK_D(DUK_DPRINT("debug notify, skipping")); break; } default: { DUK_D(DUK_DPRINT("invalid initial byte, drop connection: %d", (int) x)); goto fail; } } /* switch initial byte */ DUK_ASSERT(duk_get_top(thr) >= entry_top); duk_set_top(thr, entry_top); duk__debug_skip_to_eom(thr); return; fail: DUK_ASSERT(duk_get_top(thr) >= entry_top); duk_set_top(thr, entry_top); DUK__SET_CONN_BROKEN(thr, 1); return; } DUK_LOCAL void duk__check_resend_status(duk_hthread *thr) { if (thr->heap->dbg_read_cb != NULL && thr->heap->dbg_state_dirty) { duk_debug_send_status(thr); thr->heap->dbg_state_dirty = 0; } } DUK_INTERNAL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t no_block) { #if defined(DUK_USE_ASSERTIONS) duk_idx_t entry_top; #endif duk_bool_t retval = 0; DUK_ASSERT(thr != NULL); DUK_ASSERT(thr->heap != NULL); #if defined(DUK_USE_ASSERTIONS) entry_top = duk_get_top(thr); #endif DUK_D(DUK_DPRINT("process debug messages: read_cb=%s, no_block=%ld, detaching=%ld, processing=%ld", thr->heap->dbg_read_cb ? "not NULL" : "NULL", (long) no_block, (long) thr->heap->dbg_detaching, (long) thr->heap->dbg_processing)); DUK_DD(DUK_DDPRINT("top at entry: %ld", (long) duk_get_top(thr))); /* thr->heap->dbg_detaching may be != 0 if a debugger write outside * the message loop caused a transport error and detach1() to run. */ DUK_ASSERT(thr->heap->dbg_detaching == 0 || thr->heap->dbg_detaching == 1); DUK_ASSERT(thr->heap->dbg_processing == 0); thr->heap->dbg_processing = 1; /* Ensure dirty state causes a Status even if never process any * messages. This is expected by the bytecode executor when in * the running state. */ duk__check_resend_status(thr); for (;;) { /* Process messages until we're no longer paused or we peek * and see there's nothing to read right now. */ DUK_DD(DUK_DDPRINT("top at loop top: %ld", (long) duk_get_top(thr))); DUK_ASSERT(thr->heap->dbg_processing == 1); while (thr->heap->dbg_read_cb == NULL && thr->heap->dbg_detaching) { /* Detach is pending; can be triggered from outside the * debugger loop (e.g. Status notify write error) or by * previous message handling. Call detached callback * here, in a controlled state, to ensure a possible * reattach inside the detached_cb is handled correctly. * * Recheck for detach in a while loop: an immediate * reattach involves a call to duk_debugger_attach() * which writes a debugger handshake line immediately * inside the API call. If the transport write fails * for that handshake, we can immediately end up in a * "transport broken, detaching" case several times here. * Loop back until we're either cleanly attached or * fully detached. * * NOTE: Reset dbg_processing = 1 forcibly, in case we * re-attached; duk_debugger_attach() sets dbg_processing * to 0 at the moment. */ DUK_D(DUK_DPRINT("detach pending (dbg_read_cb == NULL, dbg_detaching != 0), call detach2")); duk__debug_do_detach2(thr->heap); thr->heap->dbg_processing = 1; /* may be set to 0 by duk_debugger_attach() inside callback */ DUK_D(DUK_DPRINT("after detach2 (and possible reattach): dbg_read_cb=%s, dbg_detaching=%ld", thr->heap->dbg_read_cb ? "not NULL" : "NULL", (long) thr->heap->dbg_detaching)); } DUK_ASSERT(thr->heap->dbg_detaching == 0); /* true even with reattach */ DUK_ASSERT(thr->heap->dbg_processing == 1); /* even after a detach and possible reattach */ if (thr->heap->dbg_read_cb == NULL) { DUK_D(DUK_DPRINT("debug connection broken (and not detaching), stop processing messages")); break; } if (!DUK_HEAP_HAS_DEBUGGER_PAUSED(thr->heap) || no_block) { if (!duk_debug_read_peek(thr)) { /* Note: peek cannot currently trigger a detach * so the dbg_detaching == 0 assert outside the * loop is correct. */ DUK_D(DUK_DPRINT("processing debug message, peek indicated no data, stop processing messages")); break; } DUK_D(DUK_DPRINT("processing debug message, peek indicated there is data, handle it")); } else { DUK_D(DUK_DPRINT("paused, process debug message, blocking if necessary")); } duk__check_resend_status(thr); duk__debug_process_message(thr); duk__check_resend_status(thr); retval = 1; /* processed one or more messages */ } DUK_ASSERT(thr->heap->dbg_detaching == 0); DUK_ASSERT(thr->heap->dbg_processing == 1); thr->heap->dbg_processing = 0; /* As an initial implementation, read flush after exiting the message * loop. If transport is broken, this is a no-op (with debug logs). */ duk_debug_read_flush(thr); /* this cannot initiate a detach */ DUK_ASSERT(thr->heap->dbg_detaching == 0); DUK_DD(DUK_DDPRINT("top at exit: %ld", (long) duk_get_top(thr))); #if defined(DUK_USE_ASSERTIONS) /* Easy to get wrong, so assert for it. */ DUK_ASSERT(entry_top == duk_get_top(thr)); #endif return retval; } /* * Halt execution helper */ /* Halt execution and enter a debugger message loop until execution is resumed * by the client. PC for the current activation may be temporarily decremented * so that the "current" instruction will be shown by the client. This helper * is callable from anywhere, also outside bytecode executor. */ DUK_INTERNAL void duk_debug_halt_execution(duk_hthread *thr, duk_bool_t use_prev_pc) { duk_activation *act; duk_hcompfunc *fun; duk_instr_t *old_pc = NULL; DUK_ASSERT(thr != NULL); DUK_ASSERT(thr->heap != NULL); DUK_ASSERT(duk_debug_is_attached(thr->heap)); DUK_ASSERT(thr->heap->dbg_processing == 0); DUK_ASSERT(!duk_debug_is_paused(thr->heap)); duk_debug_set_paused(thr->heap); act = thr->callstack_curr; /* NOTE: act may be NULL if an error is thrown outside of any activation, * which may happen in the case of, e.g. syntax errors. */ /* Decrement PC if that was requested, this requires a PC sync. */ if (act != NULL) { duk_hthread_sync_currpc(thr); old_pc = act->curr_pc; fun = (duk_hcompfunc *) DUK_ACT_GET_FUNC(act); /* Short circuit if is safe: if act->curr_pc != NULL, 'fun' is * guaranteed to be a non-NULL ECMAScript function. */ DUK_ASSERT(act->curr_pc == NULL || (fun != NULL && DUK_HOBJECT_IS_COMPFUNC((duk_hobject *) fun))); if (use_prev_pc && act->curr_pc != NULL && act->curr_pc > DUK_HCOMPFUNC_GET_CODE_BASE(thr->heap, fun)) { act->curr_pc--; } } /* Process debug messages until we are no longer paused. */ /* NOTE: This is a bit fragile. It's important to ensure that * duk_debug_process_messages() never throws an error or * act->curr_pc will never be reset. */ thr->heap->dbg_state_dirty = 1; while (DUK_HEAP_HAS_DEBUGGER_PAUSED(thr->heap)) { DUK_ASSERT(duk_debug_is_attached(thr->heap)); DUK_ASSERT(thr->heap->dbg_processing == 0); duk_debug_process_messages(thr, 0 /*no_block*/); } /* XXX: Decrementing and restoring act->curr_pc works now, but if the * debugger message loop gains the ability to adjust the current PC * (e.g. a forced jump) restoring the PC here will break. Another * approach would be to use a state flag for the "decrement 1 from * topmost activation's PC" and take it into account whenever dealing * with PC values. */ if (act != NULL) { act->curr_pc = old_pc; /* restore PC */ } } /* * Breakpoint management */ DUK_INTERNAL duk_small_int_t duk_debug_add_breakpoint(duk_hthread *thr, duk_hstring *filename, duk_uint32_t line) { duk_heap *heap; duk_breakpoint *b; /* Caller must trigger recomputation of active breakpoint list. To * ensure stale values are not used if that doesn't happen, clear the * active breakpoint list here. */ DUK_ASSERT(thr != NULL); DUK_ASSERT(filename != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); if (heap->dbg_breakpoint_count >= DUK_HEAP_MAX_BREAKPOINTS) { DUK_D(DUK_DPRINT("failed to add breakpoint for %O:%ld, all breakpoint slots used", (duk_heaphdr *) filename, (long) line)); return -1; } heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL; b = heap->dbg_breakpoints + (heap->dbg_breakpoint_count++); b->filename = filename; b->line = line; DUK_HSTRING_INCREF(thr, filename); return (duk_small_int_t) (heap->dbg_breakpoint_count - 1); /* index */ } DUK_INTERNAL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_uint_t breakpoint_index) { duk_heap *heap; duk_hstring *h; duk_breakpoint *b; duk_size_t move_size; /* Caller must trigger recomputation of active breakpoint list. To * ensure stale values are not used if that doesn't happen, clear the * active breakpoint list here. */ DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); DUK_ASSERT(duk_debug_is_attached(thr->heap)); DUK_ASSERT_DISABLE(breakpoint_index >= 0); /* unsigned */ if (breakpoint_index >= heap->dbg_breakpoint_count) { DUK_D(DUK_DPRINT("invalid breakpoint index: %ld", (long) breakpoint_index)); return 0; } b = heap->dbg_breakpoints + breakpoint_index; h = b->filename; DUK_ASSERT(h != NULL); move_size = sizeof(duk_breakpoint) * (heap->dbg_breakpoint_count - breakpoint_index - 1); duk_memmove((void *) b, (const void *) (b + 1), (size_t) move_size); heap->dbg_breakpoint_count--; heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL; DUK_HSTRING_DECREF(thr, h); /* side effects */ DUK_UNREF(h); /* w/o refcounting */ /* Breakpoint entries above the used area are left as garbage. */ return 1; } /* * Misc state management */ DUK_INTERNAL duk_bool_t duk_debug_is_attached(duk_heap *heap) { return (heap->dbg_read_cb != NULL); } DUK_INTERNAL duk_bool_t duk_debug_is_paused(duk_heap *heap) { return (DUK_HEAP_HAS_DEBUGGER_PAUSED(heap) != 0); } DUK_INTERNAL void duk_debug_set_paused(duk_heap *heap) { if (duk_debug_is_paused(heap)) { DUK_D(DUK_DPRINT("trying to set paused state when already paused, ignoring")); } else { DUK_HEAP_SET_DEBUGGER_PAUSED(heap); heap->dbg_state_dirty = 1; duk_debug_clear_pause_state(heap); DUK_ASSERT(heap->ms_running == 0); /* debugger can't be triggered within mark-and-sweep */ heap->ms_running = 1; /* prevent mark-and-sweep, prevent refzero queueing */ heap->ms_prevent_count++; DUK_ASSERT(heap->ms_prevent_count != 0); /* Wrap. */ DUK_ASSERT(heap->heap_thread != NULL); } } DUK_INTERNAL void duk_debug_clear_paused(duk_heap *heap) { if (duk_debug_is_paused(heap)) { DUK_HEAP_CLEAR_DEBUGGER_PAUSED(heap); heap->dbg_state_dirty = 1; duk_debug_clear_pause_state(heap); DUK_ASSERT(heap->ms_running == 1); DUK_ASSERT(heap->ms_prevent_count > 0); heap->ms_prevent_count--; heap->ms_running = 0; DUK_ASSERT(heap->heap_thread != NULL); } else { DUK_D(DUK_DPRINT("trying to clear paused state when not paused, ignoring")); } } DUK_INTERNAL void duk_debug_clear_pause_state(duk_heap *heap) { heap->dbg_pause_flags = 0; heap->dbg_pause_act = NULL; heap->dbg_pause_startline = 0; } #else /* DUK_USE_DEBUGGER_SUPPORT */ /* No debugger support. */ #endif /* DUK_USE_DEBUGGER_SUPPORT */