duk_hobject_pc2line.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Functions
DUK_INTERNAL void	duk_hobject_pc2line_pack (duk_hthread *thr, duk_compiler_instr *instrs, duk_uint_fast32_t length)
DUK_LOCAL duk_uint_fast32_t	duk__hobject_pc2line_query_raw (duk_hthread *thr, duk_hbuffer_fixed *buf, duk_uint_fast32_t pc)
DUK_INTERNAL duk_uint_fast32_t	duk_hobject_pc2line_query (duk_context *ctx, duk_idx_t idx_func, duk_uint_fast32_t pc)

Function Documentation

duk__hobject_pc2line_query_raw()

DUK_LOCAL duk_uint_fast32_t duk__hobject_pc2line_query_raw	(	duk_hthread *	thr,
		duk_hbuffer_fixed *	buf,
		duk_uint_fast32_t	pc )

Definition at line 129 of file duktape-1.5.2/src-separate/duk_hobject_pc2line.c.

                                                                                                                           {
    duk_bitdecoder_ctx bd_ctx_alloc;
    duk_bitdecoder_ctx *bd_ctx = &bd_ctx_alloc;
    duk_uint32_t *hdr;
    duk_uint_fast32_t start_offset;
    duk_uint_fast32_t pc_limit;
    duk_uint_fast32_t hdr_index;
    duk_uint_fast32_t pc_base;
    duk_uint_fast32_t n;
    duk_uint_fast32_t curr_line;
 
    DUK_ASSERT(buf != NULL);
    DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) buf) && !DUK_HBUFFER_HAS_EXTERNAL((duk_hbuffer *) buf));
    DUK_UNREF(thr);
 
    /*
     *  Use the index in the header to find the right starting point
     */
 
    hdr_index = pc / DUK_PC2LINE_SKIP;
    pc_base = hdr_index * DUK_PC2LINE_SKIP;
    n = pc - pc_base;
 
    if (DUK_HBUFFER_FIXED_GET_SIZE(buf) <= sizeof(duk_uint32_t)) {
        DUK_DD(DUK_DDPRINT("pc2line lookup failed: buffer is smaller than minimal header"));
        goto error;
    }
 
    hdr = (duk_uint32_t *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, buf);
    pc_limit = hdr[0];
    if (pc >= pc_limit) {
        /* Note: pc is unsigned and cannot be negative */
        DUK_DD(DUK_DDPRINT("pc2line lookup failed: pc out of bounds (pc=%ld, limit=%ld)",
                           (long) pc, (long) pc_limit));
        goto error;
    }
 
    curr_line = hdr[1 + hdr_index * 2];
    start_offset = hdr[1 + hdr_index * 2 + 1];
    if ((duk_size_t) start_offset > DUK_HBUFFER_FIXED_GET_SIZE(buf)) {
        DUK_DD(DUK_DDPRINT("pc2line lookup failed: start_offset out of bounds (start_offset=%ld, buffer_size=%ld)",
                           (long) start_offset, (long) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) buf)));
        goto error;
    }
 
    /*
     *  Iterate the bitstream (line diffs) until PC is reached
     */
 
    DUK_MEMZERO(bd_ctx, sizeof(*bd_ctx));
    bd_ctx->data = ((duk_uint8_t *) hdr) + start_offset;
    bd_ctx->length = (duk_size_t) (DUK_HBUFFER_FIXED_GET_SIZE(buf) - start_offset);
 
#if 0
    DUK_DDD(DUK_DDDPRINT("pc2line lookup: pc=%ld -> hdr_index=%ld, pc_base=%ld, n=%ld, start_offset=%ld",
                         (long) pc, (long) hdr_index, (long) pc_base, (long) n, (long) start_offset));
#endif
 
    while (n > 0) {
#if 0
        DUK_DDD(DUK_DDDPRINT("lookup: n=%ld, curr_line=%ld", (long) n, (long) curr_line));
#endif
 
        if (duk_bd_decode_flag(bd_ctx)) {
            if (duk_bd_decode_flag(bd_ctx)) {
                if (duk_bd_decode_flag(bd_ctx)) {
                    /* 1 1 1 <32 bits> */
                    duk_uint_fast32_t t;
                    t = duk_bd_decode(bd_ctx, 16);  /* workaround: max nbits = 24 now */
                    t = (t << 16) + duk_bd_decode(bd_ctx, 16);
                    curr_line = t;
                } else {
                    /* 1 1 0 <8 bits> */
                    duk_uint_fast32_t t;
                    t = duk_bd_decode(bd_ctx, 8);
                    curr_line = curr_line + t - 0x80;
                }
            } else {
                /* 1 0 <2 bits> */
                duk_uint_fast32_t t;
                t = duk_bd_decode(bd_ctx, 2);
                curr_line = curr_line + t + 1;
            }
        } else {
            /* 0: no change */
        }
 
        n--;
    }
 
    DUK_DDD(DUK_DDDPRINT("pc2line lookup result: pc %ld -> line %ld", (long) pc, (long) curr_line));
    return curr_line;
 
 error:
    DUK_D(DUK_DPRINT("pc2line conversion failed for pc=%ld", (long) pc));
    return 0;
}

References duk_bitdecoder_ctx::data, DUK_ASSERT, duk_bd_decode(), duk_bd_decode_flag(), DUK_D, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_DPRINT, DUK_HBUFFER_FIXED_GET_DATA_PTR, DUK_HBUFFER_FIXED_GET_SIZE, DUK_HBUFFER_GET_SIZE, DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, DUK_MEMZERO, DUK_PC2LINE_SKIP, DUK_UNREF, error(), duk_hthread::heap, duk_bitdecoder_ctx::length, and NULL.

Referenced by duk_hobject_pc2line_query().

duk_hobject_pc2line_pack()

DUK_INTERNAL void duk_hobject_pc2line_pack	(	duk_hthread *	thr,
		duk_compiler_instr *	instrs,
		duk_uint_fast32_t	length )

Definition at line 15 of file duktape-1.5.2/src-separate/duk_hobject_pc2line.c.

                                                                                                                   {
    duk_context *ctx = (duk_context *) thr;
    duk_hbuffer_dynamic *h_buf;
    duk_bitencoder_ctx be_ctx_alloc;
    duk_bitencoder_ctx *be_ctx = &be_ctx_alloc;
    duk_uint32_t *hdr;
    duk_size_t new_size;
    duk_uint_fast32_t num_header_entries;
    duk_uint_fast32_t curr_offset;
    duk_int_fast32_t curr_line, next_line, diff_line;
    duk_uint_fast32_t curr_pc;
    duk_uint_fast32_t hdr_index;
 
    DUK_ASSERT(length <= DUK_COMPILER_MAX_BYTECODE_LENGTH);
 
    /* XXX: add proper spare handling to dynamic buffer, to minimize
     * reallocs; currently there is no spare at all.
     */
 
    num_header_entries = (length + DUK_PC2LINE_SKIP - 1) / DUK_PC2LINE_SKIP;
    curr_offset = (duk_uint_fast32_t) (sizeof(duk_uint32_t) + num_header_entries * sizeof(duk_uint32_t) * 2);
 
    duk_push_dynamic_buffer(ctx, (duk_size_t) curr_offset);
    h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
    DUK_ASSERT(h_buf != NULL);
    DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf) && !DUK_HBUFFER_HAS_EXTERNAL(h_buf));
 
    hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
    DUK_ASSERT(hdr != NULL);
    hdr[0] = (duk_uint32_t) length;  /* valid pc range is [0, length[ */
 
    curr_pc = 0U;
    while (curr_pc < length) {
        new_size = (duk_size_t) (curr_offset + DUK_PC2LINE_MAX_DIFF_LENGTH);
        duk_hbuffer_resize(thr, h_buf, new_size);
 
        hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
        DUK_ASSERT(hdr != NULL);
        DUK_ASSERT(curr_pc < length);
        hdr_index = 1 + (curr_pc / DUK_PC2LINE_SKIP) * 2;
        curr_line = (duk_int_fast32_t) instrs[curr_pc].line;
        hdr[hdr_index + 0] = (duk_uint32_t) curr_line;
        hdr[hdr_index + 1] = (duk_uint32_t) curr_offset;
 
#if 0
        DUK_DDD(DUK_DDDPRINT("hdr[%ld]: pc=%ld line=%ld offset=%ld",
                             (long) (curr_pc / DUK_PC2LINE_SKIP),
                             (long) curr_pc,
                             (long) hdr[hdr_index + 0],
                             (long) hdr[hdr_index + 1]));
#endif
 
        DUK_MEMZERO(be_ctx, sizeof(*be_ctx));
        be_ctx->data = ((duk_uint8_t *) hdr) + curr_offset;
        be_ctx->length = (duk_size_t) DUK_PC2LINE_MAX_DIFF_LENGTH;
 
        for (;;) {
            curr_pc++;
            if ( ((curr_pc % DUK_PC2LINE_SKIP) == 0) ||  /* end of diff run */
                 (curr_pc >= length) ) {                 /* end of bytecode */
                break;
            }
            DUK_ASSERT(curr_pc < length);
            next_line = (duk_int32_t) instrs[curr_pc].line;
            diff_line = next_line - curr_line;
 
#if 0
            DUK_DDD(DUK_DDDPRINT("curr_line=%ld, next_line=%ld -> diff_line=%ld",
                                 (long) curr_line, (long) next_line, (long) diff_line));
#endif
 
            if (diff_line == 0) {
                /* 0 */
                duk_be_encode(be_ctx, 0, 1);
            } else if (diff_line >= 1 && diff_line <= 4) {
                /* 1 0 <2 bits> */
                duk_be_encode(be_ctx, (0x02 << 2) + (diff_line - 1), 4);
            } else if (diff_line >= -0x80 && diff_line <= 0x7f) {
                /* 1 1 0 <8 bits> */
                DUK_ASSERT(diff_line + 0x80 >= 0 && diff_line + 0x80 <= 0xff);
                duk_be_encode(be_ctx, (0x06 << 8) + (diff_line + 0x80), 11);
            } else {
                /* 1 1 1 <32 bits>
                 * Encode in two parts to avoid bitencode 24-bit limitation
                 */
                duk_be_encode(be_ctx, (0x07 << 16) + ((next_line >> 16) & 0xffffU), 19);
                duk_be_encode(be_ctx, next_line & 0xffffU, 16);
            }
 
            curr_line = next_line;
        }
 
        duk_be_finish(be_ctx);
        DUK_ASSERT(!be_ctx->truncated);
 
        /* be_ctx->offset == length of encoded bitstream */
        curr_offset += (duk_uint_fast32_t) be_ctx->offset;
    }
 
    /* compact */
    new_size = (duk_size_t) curr_offset;
    duk_hbuffer_resize(thr, h_buf, new_size);
 
    (void) duk_to_fixed_buffer(ctx, -1, NULL);
 
    DUK_DDD(DUK_DDDPRINT("final pc2line data: pc_limit=%ld, length=%ld, %lf bits/opcode --> %!ixT",
                         (long) length, (long) new_size, (double) new_size * 8.0 / (double) length,
                         (duk_tval *) duk_get_tval(ctx, -1)));
}

References duk_bitencoder_ctx::data, DUK_ASSERT, duk_be_encode(), duk_be_finish(), DUK_COMPILER_MAX_BYTECODE_LENGTH, DUK_DDD, DUK_DDDPRINT, duk_get_hbuffer(), duk_get_tval(), DUK_HBUFFER_DYNAMIC_GET_DATA_PTR, DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, duk_hbuffer_resize(), DUK_MEMZERO, DUK_PC2LINE_MAX_DIFF_LENGTH, DUK_PC2LINE_SKIP, duk_push_dynamic_buffer, duk_to_fixed_buffer, duk_hthread::heap, duk_bitencoder_ctx::length, NULL, duk_bitencoder_ctx::offset, and duk_bitencoder_ctx::truncated.

duk_hobject_pc2line_query()

DUK_INTERNAL duk_uint_fast32_t duk_hobject_pc2line_query	(	duk_context *	ctx,
		duk_idx_t	idx_func,
		duk_uint_fast32_t	pc )

Definition at line 227 of file duktape-1.5.2/src-separate/duk_hobject_pc2line.c.

                                                                                                                     {
    duk_hbuffer_fixed *pc2line;
    duk_uint_fast32_t line;
 
    /* XXX: now that pc2line is used by the debugger quite heavily in
     * checked execution, this should be optimized to avoid value stack
     * and perhaps also implement some form of pc2line caching (see
     * future work in debugger.rst).
     */
 
    duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_PC2LINE);
    pc2line = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1);
    if (pc2line != NULL) {
        DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) pc2line) && !DUK_HBUFFER_HAS_EXTERNAL((duk_hbuffer *) pc2line));
        line = duk__hobject_pc2line_query_raw((duk_hthread *) ctx, pc2line, (duk_uint_fast32_t) pc);
    } else {
        line = 0;
    }
    duk_pop(ctx);
 
    return line;
}

References duk__hobject_pc2line_query_raw(), DUK_ASSERT, duk_get_hbuffer(), duk_get_prop_stridx(), DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, duk_pop(), DUK_STRIDX_INT_PC2LINE, and NULL.