lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

dtrace: Make D style more D-ish

v0.11.0-release
isaacs 12 years ago
committed by Ben Noordhuis
parent
3375bd8db7
commit
425163e0d6
1 changed files with 296 additions and 296 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 592
      src/v8ustack.d

592
src/v8ustack.d
View File

@ -17,9 +17,9 @@
* V8 represents small integers (SMI) using the upper 31 bits of a 32/64-bit * V8 represents small integers (SMI) using the upper 31 bits of a 32/64-bit
* value. To extract the actual integer value, we must shift it over. * value. To extract the actual integer value, we must shift it over.
*/ */
#define IS_SMI(value) \ #define IS_SMI(value) \
((value & V8_SmiTagMask) == V8_SmiTag) ((value & V8_SmiTagMask) == V8_SmiTag)
#define SMI_VALUE(value) \ #define SMI_VALUE(value) \
((uint32_t) ((value) >> V8_SmiValueShift)) ((uint32_t) ((value) >> V8_SmiValueShift))
/* /*
@ -28,143 +28,143 @@
* pointer (which are normally 01) are used to record GC state. Of course, we * pointer (which are normally 01) are used to record GC state. Of course, we
* have no idea if we're in GC or not, so we must always normalize the pointer. * have no idea if we're in GC or not, so we must always normalize the pointer.
*/ */
#define V8_MAP_PTR(ptr) \ #define V8_MAP_PTR(ptr) \
((ptr & ~V8_HeapObjectTagMask) | V8_HeapObjectTag) ((ptr & ~V8_HeapObjectTagMask) | V8_HeapObjectTag)
/* /*
* Determine the encoding and representation of a V8 string. * Determine the encoding and representation of a V8 string.
*/ */
#define V8_TYPE_STRING(type) \ #define V8_TYPE_STRING(type) \
(((type) & V8_IsNotStringMask) == V8_StringTag) (((type) & V8_IsNotStringMask) == V8_StringTag)
#define V8_STRENC_ASCII(type) \ #define V8_STRENC_ASCII(type) \
(((type) & V8_StringEncodingMask) == V8_AsciiStringTag) (((type) & V8_StringEncodingMask) == V8_AsciiStringTag)
#define V8_STRREP_SEQ(type) \ #define V8_STRREP_SEQ(type) \
(((type) & V8_StringRepresentationMask) == V8_SeqStringTag) (((type) & V8_StringRepresentationMask) == V8_SeqStringTag)
#define V8_STRREP_CONS(type) \ #define V8_STRREP_CONS(type) \
(((type) & V8_StringRepresentationMask) == V8_ConsStringTag) (((type) & V8_StringRepresentationMask) == V8_ConsStringTag)
#define V8_STRREP_EXT(type) \ #define V8_STRREP_EXT(type) \
(((type) & V8_StringRepresentationMask) == V8_ExternalStringTag) (((type) & V8_StringRepresentationMask) == V8_ExternalStringTag)
/* /*
* String type predicates * String type predicates
*/ */
#define ASCII_SEQSTR(value) \ #define ASCII_SEQSTR(value) \
(V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_SEQ(value)) (V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_SEQ(value))
#define ASCII_CONSSTR(value) \ #define ASCII_CONSSTR(value) \
(V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_CONS(value)) (V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_CONS(value))
#define ASCII_EXTSTR(value) \ #define ASCII_EXTSTR(value) \
(V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_EXT(value)) (V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_EXT(value))
/* /*
* General helper macros * General helper macros
*/ */
#define COPYIN_UINT8(addr) (*(uint8_t*) copyin((addr), sizeof(uint8_t))) #define COPYIN_UINT8(addr) (*(uint8_t*) copyin((addr), sizeof(uint8_t)))
#define COPYIN_UINT32(addr) (*(uint32_t*) copyin((addr), sizeof(uint32_t))) #define COPYIN_UINT32(addr) (*(uint32_t*) copyin((addr), sizeof(uint32_t)))
#define COPYIN_UINT64(addr) (*(uint64_t*) copyin((addr), sizeof(uint64_t))) #define COPYIN_UINT64(addr) (*(uint64_t*) copyin((addr), sizeof(uint64_t)))
#if defined(__i386) #if defined(__i386)
# define COPYIN_PTR(addr) COPYIN_UINT32(addr) # define COPYIN_PTR(addr) COPYIN_UINT32(addr)
# define off_t uint32_t # define off_t uint32_t
# define APPEND_PTR(p) APPEND_PTR_32(p) # define APPEND_PTR(p) APPEND_PTR_32(p)
#else #else
# define COPYIN_PTR(addr) COPYIN_UINT64(addr) # define COPYIN_PTR(addr) COPYIN_UINT64(addr)
# define off_t uint64_t # define off_t uint64_t
# define APPEND_PTR(p) APPEND_PTR_64(p) # define APPEND_PTR(p) APPEND_PTR_64(p)
#endif #endif
#define APPEND_CHR(c) (this->buf[this->off++] = (c)) #define APPEND_CHR(c) (this->buf[this->off++] = (c))
#define APPEND_CHR4(s0, s1, s2, s3) \ #define APPEND_CHR4(s0, s1, s2, s3) \
APPEND_CHR(s0); \ APPEND_CHR(s0); \
APPEND_CHR(s1); \ APPEND_CHR(s1); \
APPEND_CHR(s2); \ APPEND_CHR(s2); \
APPEND_CHR(s3); APPEND_CHR(s3);
#define APPEND_CHR8(s0, s1, s2, s3, s4, s5, s6, s7) \ #define APPEND_CHR8(s0, s1, s2, s3, s4, s5, s6, s7) \
APPEND_CHR4(s0, s1, s2, s3) \ APPEND_CHR4(s0, s1, s2, s3) \
APPEND_CHR4(s4, s5, s6, s7) APPEND_CHR4(s4, s5, s6, s7)
#define APPEND_DGT(i, d) \ #define APPEND_DGT(i, d) \
(((i) / (d)) ? APPEND_CHR('0' + ((i)/(d) % 10)) : 0) (((i) / (d)) ? APPEND_CHR('0' + ((i)/(d) % 10)) : 0)
#define APPEND_NUM(i) \ #define APPEND_NUM(i) \
APPEND_DGT((i), 100000); \ APPEND_DGT((i), 100000); \
APPEND_DGT((i), 10000); \ APPEND_DGT((i), 10000); \
APPEND_DGT((i), 1000); \ APPEND_DGT((i), 1000); \
APPEND_DGT((i), 100); \ APPEND_DGT((i), 100); \
APPEND_DGT((i), 10); \ APPEND_DGT((i), 10); \
APPEND_DGT((i), 1); APPEND_DGT((i), 1);
#define APPEND_HEX(d) \ #define APPEND_HEX(d) \
APPEND_CHR((d) < 10 ? '0' + (d) : 'a' - 10 + (d)) APPEND_CHR((d) < 10 ? '0' + (d) : 'a' - 10 + (d))
#define APPEND_PTR_32(p) \ #define APPEND_PTR_32(p) \
APPEND_HEX((p >> 28) & 0xf); \ APPEND_HEX((p >> 28) & 0xf); \
APPEND_HEX((p >> 24) & 0xf); \ APPEND_HEX((p >> 24) & 0xf); \
APPEND_HEX((p >> 20) & 0xf); \ APPEND_HEX((p >> 20) & 0xf); \
APPEND_HEX((p >> 16) & 0xf); \ APPEND_HEX((p >> 16) & 0xf); \
APPEND_HEX((p >> 12) & 0xf); \ APPEND_HEX((p >> 12) & 0xf); \
APPEND_HEX((p >> 8) & 0xf); \ APPEND_HEX((p >> 8) & 0xf); \
APPEND_HEX((p >> 4) & 0xf); \ APPEND_HEX((p >> 4) & 0xf); \
APPEND_HEX((p) & 0xf); APPEND_HEX((p) & 0xf);
#define APPEND_PTR_64(p) \ #define APPEND_PTR_64(p) \
APPEND_PTR_32(p >> 32) \ APPEND_PTR_32(p >> 32) \
APPEND_PTR_32(p) APPEND_PTR_32(p)
/* /*
* The following macros are used to output ASCII SeqStrings, ConsStrings, and * The following macros are used to output ASCII SeqStrings, ConsStrings, and
* Node.js ExternalStrings. To represent each string, we use three fields: * Node.js ExternalStrings. To represent each string, we use three fields:
* *
* "str": a pointer to the string itself * "str": a pointer to the string itself
* *
* "len": the string length * "len": the string length
* *
* "attrs": the type identifier for the string, which indicates the * "attrs": the type identifier for the string, which indicates the
* encoding and representation. We're only interested in ASCII * encoding and representation. We're only interested in ASCII
* encoded strings whose representation is one of: * encoded strings whose representation is one of:
* *
* SeqString stored directly as a char array inside the object * SeqString stored directly as a char array inside the object
* *
* ConsString pointer to two strings that should be concatenated * ConsString pointer to two strings that should be concatenated
* *
* ExternalString pointer to a char* outside the V8 heap * ExternalString pointer to a char* outside the V8 heap
*/ */
/* /*
* Load "len" and "attrs" for the given "str". * Load "len" and "attrs" for the given "str".
*/ */
#define LOAD_STRFIELDS(str, len, attrs) \ #define LOAD_STRFIELDS(str, len, attrs) \
len = SMI_VALUE(COPYIN_PTR(str + V8_OFF_STR_LENGTH)); \ len = SMI_VALUE(COPYIN_PTR(str + V8_OFF_STR_LENGTH)); \
this->map = V8_MAP_PTR(COPYIN_PTR(str + V8_OFF_HEAPOBJ_MAP)); \ this->map = V8_MAP_PTR(COPYIN_PTR(str + V8_OFF_HEAPOBJ_MAP)); \
attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS); attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS);
/* /*
* Print out the given SeqString, or do nothing if the string is not an ASCII * Print out the given SeqString, or do nothing if the string is not an ASCII
* SeqString. * SeqString.
*/ */
#define APPEND_SEQSTR(str, len, attrs) \ #define APPEND_SEQSTR(str, len, attrs) \
dtrace:helper:ustack: \ dtrace:helper:ustack: \
/!this->done && len > 0 && ASCII_SEQSTR(attrs)/ \ /!this->done && len > 0 && ASCII_SEQSTR(attrs)/ \
{ \ { \
copyinto(str + V8_OFF_STR_CHARS, len, this->buf + this->off); \ copyinto(str + V8_OFF_STR_CHARS, len, this->buf + this->off); \
this->off += len; \ this->off += len; \
} }
/* /*
* Print out the given Node.js ExternalString, or do nothing if the string is * Print out the given Node.js ExternalString, or do nothing if the string is
* not an ASCII ExternalString. * not an ASCII ExternalString.
*/ */
#define APPEND_NODESTR(str, len, attrs) \ #define APPEND_NODESTR(str, len, attrs) \
dtrace:helper:ustack: \ dtrace:helper:ustack: \
/!this->done && len > 0 && ASCII_EXTSTR(attrs)/ \ /!this->done && len > 0 && ASCII_EXTSTR(attrs)/ \
{ \ { \
this->resource = COPYIN_PTR(str + V8_OFF_EXTSTR_RSRC); \ this->resource = COPYIN_PTR(str + V8_OFF_EXTSTR_RSRC); \
this->dataptr = COPYIN_PTR(this->resource + NODE_OFF_EXTSTR_DATA); \ this->dataptr = COPYIN_PTR(this->resource + NODE_OFF_EXTSTR_DATA); \
copyinto(this->dataptr, len, this->buf + this->off); \ copyinto(this->dataptr, len, this->buf + this->off); \
this->off += len; \ this->off += len; \
} }
/* /*
@ -180,9 +180,9 @@
* *
* +---- str ----+ * +---- str ----+
* / \ <-- 1st expansion * / \ <-- 1st expansion
* / \ * / \
* s0 s7 * s0 s7
* / \ / \ * / \ / \
* / \ / \ <-- 2nd expansion * / \ / \ <-- 2nd expansion
* / \ / \ * / \ / \
* s1 s4 s8 s11 * s1 s4 s8 s11
@ -196,27 +196,27 @@
* all non-zero-length strings in order (including both internal nodes and * all non-zero-length strings in order (including both internal nodes and
* leafs in the tree above) to get the final output. * leafs in the tree above) to get the final output.
*/ */
#define EXPAND_START() \ #define EXPAND_START() \
dtrace:helper:ustack: \ dtrace:helper:ustack: \
/!this->done/ \ /!this->done/ \
{ \ { \
this->s0str = this->s1str = this->s2str = (off_t) 0; \ this->s0str = this->s1str = this->s2str = (off_t) 0; \
this->s3str = this->s4str = this->s5str = (off_t) 0; \ this->s3str = this->s4str = this->s5str = (off_t) 0; \
this->s6str = this->s7str = this->s8str = (off_t) 0; \ this->s6str = this->s7str = this->s8str = (off_t) 0; \
this->s9str = this->s10str = this->s11str = (off_t) 0; \ this->s9str = this->s10str = this->s11str = (off_t) 0; \
this->s12str = this->s13str = (off_t) 0; \ this->s12str = this->s13str = (off_t) 0; \
\ \
this->s0len = this->s1len = this->s2len = (off_t) 0; \ this->s0len = this->s1len = this->s2len = (off_t) 0; \
this->s3len = this->s4len = this->s5len = (off_t) 0; \ this->s3len = this->s4len = this->s5len = (off_t) 0; \
this->s6len = this->s7len = this->s8len = (off_t) 0; \ this->s6len = this->s7len = this->s8len = (off_t) 0; \
this->s9len = this->s10len = this->s11len = (off_t) 0; \ this->s9len = this->s10len = this->s11len = (off_t) 0; \
this->s12len = this->s13len = (off_t) 0; \ this->s12len = this->s13len = (off_t) 0; \
\ \
this->s0attrs = this->s1attrs = this->s2attrs = 0; \ this->s0attrs = this->s1attrs = this->s2attrs = 0; \
this->s3attrs = this->s4attrs = this->s5attrs = 0; \ this->s3attrs = this->s4attrs = this->s5attrs = 0; \
this->s6attrs = this->s7attrs = this->s8attrs = 0; \ this->s6attrs = this->s7attrs = this->s8attrs = 0; \
this->s9attrs = this->s10attrs = this->s11attrs = 0; \ this->s9attrs = this->s10attrs = this->s11attrs = 0; \
this->s12attrs = this->s13attrs = 0; \ this->s12attrs = this->s13attrs = 0; \
} }
/* /*
@ -224,62 +224,62 @@
* strings "s1" (represented by "s1s", "s1l", and "s1a") and "s2" (represented * strings "s1" (represented by "s1s", "s1l", and "s1a") and "s2" (represented
* by "s2s", "s2l", "s2a"). If "str" is not a ConsString, do nothing. * by "s2s", "s2l", "s2a"). If "str" is not a ConsString, do nothing.
*/ */
#define EXPAND_STR(str, len, attrs, s1s, s1l, s1a, s2s, s2l, s2a) \ #define EXPAND_STR(str, len, attrs, s1s, s1l, s1a, s2s, s2l, s2a) \
dtrace:helper:ustack: \ dtrace:helper:ustack: \
/!this->done && len > 0 && ASCII_CONSSTR(attrs)/ \ /!this->done && len > 0 && ASCII_CONSSTR(attrs)/ \
{ \ { \
len = 0; \ len = 0; \
\ \
s1s = COPYIN_PTR(str + V8_OFF_CONSSTR_CAR); \ s1s = COPYIN_PTR(str + V8_OFF_CONSSTR_CAR); \
LOAD_STRFIELDS(s1s, s1l, s1a) \ LOAD_STRFIELDS(s1s, s1l, s1a) \
\ \
s2s = COPYIN_PTR(str + V8_OFF_CONSSTR_CDR); \ s2s = COPYIN_PTR(str + V8_OFF_CONSSTR_CDR); \
LOAD_STRFIELDS(s2s, s2l, s2a) \ LOAD_STRFIELDS(s2s, s2l, s2a) \
} }
/* /*
* Print out a ConsString by expanding it up to three levels and printing out * Print out a ConsString by expanding it up to three levels and printing out
* the resulting SeqStrings. * the resulting SeqStrings.
*/ */
#define APPEND_CONSSTR(str, len, attrs) \ #define APPEND_CONSSTR(str, len, attrs) \
EXPAND_START() \ EXPAND_START() \
EXPAND_STR(str, len, attrs, \ EXPAND_STR(str, len, attrs, \
this->s0str, this->s0len, this->s0attrs, \ this->s0str, this->s0len, this->s0attrs, \
this->s7str, this->s7len, this->s7attrs) \ this->s7str, this->s7len, this->s7attrs) \
EXPAND_STR(this->s0str, this->s0len, this->s0attrs, \ EXPAND_STR(this->s0str, this->s0len, this->s0attrs, \
this->s1str, this->s1len, this->s1attrs, \ this->s1str, this->s1len, this->s1attrs, \
this->s4str, this->s4len, this->s4attrs) \ this->s4str, this->s4len, this->s4attrs) \
EXPAND_STR(this->s1str, this->s1len, this->s1attrs, \ EXPAND_STR(this->s1str, this->s1len, this->s1attrs, \
this->s2str, this->s2len, this->s2attrs, \ this->s2str, this->s2len, this->s2attrs, \
this->s3str, this->s3len, this->s3attrs) \ this->s3str, this->s3len, this->s3attrs) \
EXPAND_STR(this->s4str, this->s4len, this->s4attrs, \ EXPAND_STR(this->s4str, this->s4len, this->s4attrs, \
this->s5str, this->s5len, this->s5attrs, \ this->s5str, this->s5len, this->s5attrs, \
this->s6str, this->s6len, this->s6attrs) \ this->s6str, this->s6len, this->s6attrs) \
EXPAND_STR(this->s7str, this->s7len, this->s7attrs, \ EXPAND_STR(this->s7str, this->s7len, this->s7attrs, \
this->s8str, this->s8len, this->s8attrs, \ this->s8str, this->s8len, this->s8attrs, \
this->s11str, this->s11len, this->s11attrs) \ this->s11str, this->s11len, this->s11attrs) \
EXPAND_STR(this->s8str, this->s8len, this->s8attrs, \ EXPAND_STR(this->s8str, this->s8len, this->s8attrs, \
this->s9str, this->s9len, this->s9attrs, \ this->s9str, this->s9len, this->s9attrs, \
this->s10str, this->s10len, this->s10attrs) \ this->s10str, this->s10len, this->s10attrs) \
EXPAND_STR(this->s11str, this->s11len, this->s11attrs, \ EXPAND_STR(this->s11str, this->s11len, this->s11attrs, \
this->s12str, this->s12len, this->s12attrs, \ this->s12str, this->s12len, this->s12attrs, \
this->s13str, this->s13len, this->s13attrs) \ this->s13str, this->s13len, this->s13attrs) \
\ \
APPEND_SEQSTR(str, len, attrs) \ APPEND_SEQSTR(str, len, attrs) \
APPEND_SEQSTR(this->s0str, this->s0len, this->s0attrs) \ APPEND_SEQSTR(this->s0str, this->s0len, this->s0attrs) \
APPEND_SEQSTR(this->s1str, this->s1len, this->s1attrs) \ APPEND_SEQSTR(this->s1str, this->s1len, this->s1attrs) \
APPEND_SEQSTR(this->s2str, this->s2len, this->s2attrs) \ APPEND_SEQSTR(this->s2str, this->s2len, this->s2attrs) \
APPEND_SEQSTR(this->s3str, this->s3len, this->s3attrs) \ APPEND_SEQSTR(this->s3str, this->s3len, this->s3attrs) \
APPEND_SEQSTR(this->s4str, this->s4len, this->s4attrs) \ APPEND_SEQSTR(this->s4str, this->s4len, this->s4attrs) \
APPEND_SEQSTR(this->s5str, this->s5len, this->s5attrs) \ APPEND_SEQSTR(this->s5str, this->s5len, this->s5attrs) \
APPEND_SEQSTR(this->s6str, this->s6len, this->s6attrs) \ APPEND_SEQSTR(this->s6str, this->s6len, this->s6attrs) \
APPEND_SEQSTR(this->s7str, this->s7len, this->s7attrs) \ APPEND_SEQSTR(this->s7str, this->s7len, this->s7attrs) \
APPEND_SEQSTR(this->s8str, this->s8len, this->s8attrs) \ APPEND_SEQSTR(this->s8str, this->s8len, this->s8attrs) \
APPEND_SEQSTR(this->s9str, this->s9len, this->s9attrs) \ APPEND_SEQSTR(this->s9str, this->s9len, this->s9attrs) \
APPEND_SEQSTR(this->s10str, this->s10len, this->s10attrs) \ APPEND_SEQSTR(this->s10str, this->s10len, this->s10attrs) \
APPEND_SEQSTR(this->s11str, this->s11len, this->s11attrs) \ APPEND_SEQSTR(this->s11str, this->s11len, this->s11attrs) \
APPEND_SEQSTR(this->s12str, this->s12len, this->s12attrs) \ APPEND_SEQSTR(this->s12str, this->s12len, this->s12attrs) \
APPEND_SEQSTR(this->s13str, this->s13len, this->s13attrs) \ APPEND_SEQSTR(this->s13str, this->s13len, this->s13attrs) \
/* /*
@ -287,9 +287,9 @@
* APPEND_CONSSTR implicitly handles SeqStrings as the degenerate case of an * APPEND_CONSSTR implicitly handles SeqStrings as the degenerate case of an
* expanded ConsString. * expanded ConsString.
*/ */
#define APPEND_V8STR(str, len, attrs) \ #define APPEND_V8STR(str, len, attrs) \
APPEND_CONSSTR(str, len, attrs) \ APPEND_CONSSTR(str, len, attrs) \
APPEND_NODESTR(str, len, attrs) APPEND_NODESTR(str, len, attrs)
/* /*
* In this first clause we initialize all variables. We must explicitly clear * In this first clause we initialize all variables. We must explicitly clear
@ -297,36 +297,36 @@
*/ */
dtrace:helper:ustack: dtrace:helper:ustack:
{ {
/* input */ /* input */
this->fp = arg1; this->fp = arg1;
/* output/flow control */ /* output/flow control */
this->buf = (char*) alloca(128); this->buf = (char*) alloca(128);
this->off = 0; this->off = 0;
this->done = 0; this->done = 0;
/* program state */ /* program state */
this->ctx = (off_t) 0; this->ctx = (off_t) 0;
this->marker = (off_t) 0; this->marker = (off_t) 0;
this->func = (off_t) 0; this->func = (off_t) 0;
this->shared = (off_t) 0; this->shared = (off_t) 0;
this->map = (off_t) 0; this->map = (off_t) 0;
this->attrs = 0; this->attrs = 0;
this->funcnamestr = (off_t) 0; this->funcnamestr = (off_t) 0;
this->funcnamelen = 0; this->funcnamelen = 0;
this->funcnameattrs = 0; this->funcnameattrs = 0;
this->script = (off_t) 0; this->script = (off_t) 0;
this->scriptnamestr = (off_t) 0; this->scriptnamestr = (off_t) 0;
this->scriptnamelen = 0; this->scriptnamelen = 0;
this->scriptnameattrs = 0; this->scriptnameattrs = 0;
this->position = 0; this->position = 0;
this->line_ends = (off_t) 0; this->line_ends = (off_t) 0;
this->le_attrs = 0; this->le_attrs = 0;
/* binary search fields */ /* binary search fields */
this->bsearch_min = 0; this->bsearch_min = 0;
this->bsearch_max = 0; this->bsearch_max = 0;
this->ii = 0; this->ii = 0;
} }
/* /*
@ -335,16 +335,16 @@ dtrace:helper:ustack:
*/ */
dtrace:helper:ustack: dtrace:helper:ustack:
{ {
this->ctx = COPYIN_PTR(this->fp + V8_OFF_FP_CONTEXT); this->ctx = COPYIN_PTR(this->fp + V8_OFF_FP_CONTEXT);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/IS_SMI(this->ctx) && SMI_VALUE(this->ctx) == V8_FT_ADAPTOR/ /IS_SMI(this->ctx) && SMI_VALUE(this->ctx) == V8_FT_ADAPTOR/
{ {
this->done = 1; this->done = 1;
APPEND_CHR8('<','<',' ','a','d','a','p','t'); APPEND_CHR8('<','<',' ','a','d','a','p','t');
APPEND_CHR8('o','r',' ','>','>','\0','\0','\0'); APPEND_CHR8('o','r',' ','>','>','\0','\0','\0');
stringof(this->buf); stringof(this->buf);
} }
/* /*
@ -353,60 +353,60 @@ dtrace:helper:ustack:
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done/ /!this->done/
{ {
this->marker = COPYIN_PTR(this->fp + V8_OFF_FP_MARKER); this->marker = COPYIN_PTR(this->fp + V8_OFF_FP_MARKER);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && IS_SMI(this->marker) && /!this->done && IS_SMI(this->marker) &&
SMI_VALUE(this->marker) == V8_FT_ENTRY/ SMI_VALUE(this->marker) == V8_FT_ENTRY/
{ {
this->done = 1; this->done = 1;
APPEND_CHR8('<','<',' ','e','n','t','r','y'); APPEND_CHR8('<','<',' ','e','n','t','r','y');
APPEND_CHR4(' ','>','>','\0'); APPEND_CHR4(' ','>','>','\0');
stringof(this->buf); stringof(this->buf);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && IS_SMI(this->marker) && /!this->done && IS_SMI(this->marker) &&
SMI_VALUE(this->marker) == V8_FT_ENTRYCONSTRUCT/ SMI_VALUE(this->marker) == V8_FT_ENTRYCONSTRUCT/
{ {
this->done = 1; this->done = 1;
APPEND_CHR8('<','<',' ','e','n','t','r','y'); APPEND_CHR8('<','<',' ','e','n','t','r','y');
APPEND_CHR8('_','c','o','n','s','t','r','u'); APPEND_CHR8('_','c','o','n','s','t','r','u');
APPEND_CHR4('t',' ','>','>'); APPEND_CHR4('t',' ','>','>');
APPEND_CHR('\0'); APPEND_CHR('\0');
stringof(this->buf); stringof(this->buf);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && IS_SMI(this->marker) && /!this->done && IS_SMI(this->marker) &&
SMI_VALUE(this->marker) == V8_FT_EXIT/ SMI_VALUE(this->marker) == V8_FT_EXIT/
{ {
this->done = 1; this->done = 1;
APPEND_CHR8('<','<',' ','e','x','i','t',' '); APPEND_CHR8('<','<',' ','e','x','i','t',' ');
APPEND_CHR4('>','>','\0','\0'); APPEND_CHR4('>','>','\0','\0');
stringof(this->buf); stringof(this->buf);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && IS_SMI(this->marker) && /!this->done && IS_SMI(this->marker) &&
SMI_VALUE(this->marker) == V8_FT_INTERNAL/ SMI_VALUE(this->marker) == V8_FT_INTERNAL/
{ {
this->done = 1; this->done = 1;
APPEND_CHR8('<','<',' ','i','n','t','e','r'); APPEND_CHR8('<','<',' ','i','n','t','e','r');
APPEND_CHR8('n','a','l',' ','>','>','\0','\0'); APPEND_CHR8('n','a','l',' ','>','>','\0','\0');
stringof(this->buf); stringof(this->buf);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && IS_SMI(this->marker) && /!this->done && IS_SMI(this->marker) &&
SMI_VALUE(this->marker) == V8_FT_CONSTRUCT/ SMI_VALUE(this->marker) == V8_FT_CONSTRUCT/
{ {
this->done = 1; this->done = 1;
APPEND_CHR8('<','<',' ','c','o','n','s','t'); APPEND_CHR8('<','<',' ','c','o','n','s','t');
APPEND_CHR8('r','u','c','t','o','r',' ','>'); APPEND_CHR8('r','u','c','t','o','r',' ','>');
APPEND_CHR4('>','\0','\0','\0'); APPEND_CHR4('>','\0','\0','\0');
stringof(this->buf); stringof(this->buf);
} }
/* /*
@ -417,19 +417,19 @@ dtrace:helper:ustack:
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done/ /!this->done/
{ {
this->func = COPYIN_PTR(this->fp + V8_OFF_FP_FUNC); this->func = COPYIN_PTR(this->fp + V8_OFF_FP_FUNC);
this->map = V8_MAP_PTR(COPYIN_PTR(this->func + V8_OFF_HEAPOBJ_MAP)); this->map = V8_MAP_PTR(COPYIN_PTR(this->func + V8_OFF_HEAPOBJ_MAP));
this->attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS); this->attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && this->attrs == V8_IT_CODE/ /!this->done && this->attrs == V8_IT_CODE/
{ {
this->done = 1; this->done = 1;
APPEND_CHR8('<','<',' ','i','n','t','e','r'); APPEND_CHR8('<','<',' ','i','n','t','e','r');
APPEND_CHR8('n','a','l',' ','c','o','d','e'); APPEND_CHR8('n','a','l',' ','c','o','d','e');
APPEND_CHR4(' ','>','>','\0'); APPEND_CHR4(' ','>','>','\0');
stringof(this->buf); stringof(this->buf);
} }
/* /*
@ -440,38 +440,38 @@ dtrace:helper:ustack:
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done/ /!this->done/
{ {
this->map = 0; this->map = 0;
this->attrs = 0; this->attrs = 0;
this->shared = COPYIN_PTR(this->func + V8_OFF_FUNC_SHARED); this->shared = COPYIN_PTR(this->func + V8_OFF_FUNC_SHARED);
this->funcnamestr = COPYIN_PTR(this->shared + V8_OFF_SHARED_NAME); this->funcnamestr = COPYIN_PTR(this->shared + V8_OFF_SHARED_NAME);
LOAD_STRFIELDS(this->funcnamestr, this->funcnamelen, LOAD_STRFIELDS(this->funcnamestr, this->funcnamelen,
this->funcnameattrs); this->funcnameattrs);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && this->funcnamelen == 0/ /!this->done && this->funcnamelen == 0/
{ {
/* /*
* This is an anonymous function, but if it was invoked as a method of * This is an anonymous function, but if it was invoked as a method of
* some object then V8 will have computed an inferred name that we can * some object then V8 will have computed an inferred name that we can
* include in the stack trace. * include in the stack trace.
*/ */
APPEND_CHR8('(','a','n','o','n',')',' ','a'); APPEND_CHR8('(','a','n','o','n',')',' ','a');
APPEND_CHR('s'); APPEND_CHR('s');
APPEND_CHR(' '); APPEND_CHR(' ');
this->funcnamestr = COPYIN_PTR(this->shared + V8_OFF_SHARED_INFERRED); this->funcnamestr = COPYIN_PTR(this->shared + V8_OFF_SHARED_INFERRED);
LOAD_STRFIELDS(this->funcnamestr, this->funcnamelen, LOAD_STRFIELDS(this->funcnamestr, this->funcnamelen,
this->funcnameattrs); this->funcnameattrs);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && this->funcnamelen == 0/ /!this->done && this->funcnamelen == 0/
{ {
APPEND_CHR('('); APPEND_CHR('(');
APPEND_CHR4('a','n','o','n'); APPEND_CHR4('a','n','o','n');
APPEND_CHR(')'); APPEND_CHR(')');
} }
APPEND_V8STR(this->funcnamestr, this->funcnamelen, this->funcnameattrs) APPEND_V8STR(this->funcnamestr, this->funcnamelen, this->funcnameattrs)
@ -482,19 +482,19 @@ APPEND_V8STR(this->funcnamestr, this->funcnamelen, this->funcnameattrs)
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done/ /!this->done/
{ {
this->script = COPYIN_PTR(this->shared + V8_OFF_SHARED_SCRIPT); this->script = COPYIN_PTR(this->shared + V8_OFF_SHARED_SCRIPT);
this->scriptnamestr = COPYIN_PTR(this->script + V8_OFF_SCRIPT_NAME); this->scriptnamestr = COPYIN_PTR(this->script + V8_OFF_SCRIPT_NAME);
LOAD_STRFIELDS(this->scriptnamestr, this->scriptnamelen, LOAD_STRFIELDS(this->scriptnamestr, this->scriptnamelen,
this->scriptnameattrs); this->scriptnameattrs);
APPEND_CHR4(' ','a','t',' '); APPEND_CHR4(' ','a','t',' ');
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && this->scriptnamelen == 0/ /!this->done && this->scriptnamelen == 0/
{ {
APPEND_CHR8('<','u','n','k','n','o','w','n'); APPEND_CHR8('<','u','n','k','n','o','w','n');
APPEND_CHR('>'); APPEND_CHR('>');
} }
APPEND_V8STR(this->scriptnamestr, this->scriptnamelen, this->scriptnameattrs) APPEND_V8STR(this->scriptnamestr, this->scriptnamelen, this->scriptnameattrs)
@ -505,27 +505,27 @@ APPEND_V8STR(this->scriptnamestr, this->scriptnamelen, this->scriptnameattrs)
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done/ /!this->done/
{ {
this->position = COPYIN_UINT32(this->shared + V8_OFF_SHARED_FUNTOK); this->position = COPYIN_UINT32(this->shared + V8_OFF_SHARED_FUNTOK);
this->line_ends = COPYIN_PTR(this->script + V8_OFF_SCRIPT_LENDS); this->line_ends = COPYIN_PTR(this->script + V8_OFF_SCRIPT_LENDS);
this->map = V8_MAP_PTR(COPYIN_PTR(this->line_ends + V8_OFF_HEAPOBJ_MAP)); this->map = V8_MAP_PTR(COPYIN_PTR(this->line_ends + V8_OFF_HEAPOBJ_MAP));
this->le_attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS); this->le_attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS);
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && this->le_attrs != V8_IT_FIXEDARRAY/ /!this->done && this->le_attrs != V8_IT_FIXEDARRAY/
{ {
/* /*
* If the line number array was not a valid FixedArray, it's probably * If the line number array was not a valid FixedArray, it's probably
* undefined because V8 has not had to compute it yet. In this case we * undefined because V8 has not had to compute it yet. In this case we
* just show the raw position and call it a day. * just show the raw position and call it a day.
*/ */
APPEND_CHR8(' ','p','o','s','i','t','i','o'); APPEND_CHR8(' ','p','o','s','i','t','i','o');
APPEND_CHR('n'); APPEND_CHR('n');
APPEND_CHR(' '); APPEND_CHR(' ');
APPEND_NUM(this->position); APPEND_NUM(this->position);
APPEND_CHR('\0'); APPEND_CHR('\0');
this->done = 1; this->done = 1;
stringof(this->buf); stringof(this->buf);
} }
/* /*
@ -537,12 +537,12 @@ dtrace:helper:ustack:
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done/ /!this->done/
{ {
/* initialize binary search */ /* initialize binary search */
this->bsearch_line = this->position < this->bsearch_line = this->position <
SMI_VALUE(COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA)) ? 1 : 0; SMI_VALUE(COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA)) ? 1 : 0;
this->bsearch_min = 0; this->bsearch_min = 0;
this->bsearch_max = this->bsearch_line != 0 ? 0 : this->bsearch_max = this->bsearch_line != 0 ? 0 :
SMI_VALUE(COPYIN_PTR(this->line_ends + V8_OFF_FA_SIZE)) - 1; SMI_VALUE(COPYIN_PTR(this->line_ends + V8_OFF_FA_SIZE)) - 1;
} }
/* /*
@ -550,29 +550,29 @@ dtrace:helper:ustack:
* iterations. That's enough to precisely identify the line number in files up * iterations. That's enough to precisely identify the line number in files up
* to 32768 lines of code. * to 32768 lines of code.
*/ */
#define BSEARCH_LOOP \ #define BSEARCH_LOOP \
dtrace:helper:ustack: \ dtrace:helper:ustack: \
/!this->done && this->bsearch_max >= 1/ \ /!this->done && this->bsearch_max >= 1/ \
{ \ { \
this->ii = (this->bsearch_min + this->bsearch_max) >> 1; \ this->ii = (this->bsearch_min + this->bsearch_max) >> 1; \
} \ } \
\ \
dtrace:helper:ustack: \ dtrace:helper:ustack: \
/!this->done && this->bsearch_max >= 1 && \ /!this->done && this->bsearch_max >= 1 && \
this->position > SMI_VALUE( \ this->position > SMI_VALUE( \
COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA + \ COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA + \
this->ii * sizeof (uint32_t)))/ \ this->ii * sizeof (uint32_t)))/ \
{ \ { \
this->bsearch_min = this->ii + 1; \ this->bsearch_min = this->ii + 1; \
} \ } \
\ \
dtrace:helper:ustack: \ dtrace:helper:ustack: \
/!this->done && this->bsearch_max >= 1 && \ /!this->done && this->bsearch_max >= 1 && \
this->position <= SMI_VALUE( \ this->position <= SMI_VALUE( \
COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA + \ COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA + \
(this->ii - 1) * sizeof (uint32_t)))/ \ (this->ii - 1) * sizeof (uint32_t)))/ \
{ \ { \
this->bsearch_max = this->ii - 1; \ this->bsearch_max = this->ii - 1; \
} }
BSEARCH_LOOP BSEARCH_LOOP
@ -594,19 +594,19 @@ BSEARCH_LOOP
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done && !this->bsearch_line/ /!this->done && !this->bsearch_line/
{ {
this->bsearch_line = this->ii + 1; this->bsearch_line = this->ii + 1;
} }
dtrace:helper:ustack: dtrace:helper:ustack:
/!this->done/ /!this->done/
{ {
APPEND_CHR(' '); APPEND_CHR(' ');
APPEND_CHR4('l','i','n','e'); APPEND_CHR4('l','i','n','e');
APPEND_CHR(' '); APPEND_CHR(' ');
APPEND_NUM(this->bsearch_line); APPEND_NUM(this->bsearch_line);
APPEND_CHR('\0'); APPEND_CHR('\0');
this->done = 1; this->done = 1;
stringof(this->buf); stringof(this->buf);
} }
/* vim: set tabstop=8 softtabstop=8 shiftwidth=8 noexpandtab: */ /* vim: set tabstop=8 softtabstop=8 shiftwidth=8 noexpandtab: */

Write Preview
Loading…
Cancel
Save