![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jsemit.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / javascript / include / mozilla / js|
Return to jsemit.h CVS log | Up to [Synchronet] / sbbs / javascript / include / mozilla / js |
1.1 ! root 1: /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- ! 2: * ! 3: * The contents of this file are subject to the Netscape Public ! 4: * License Version 1.1 (the "License"); you may not use this file ! 5: * except in compliance with the License. You may obtain a copy of ! 6: * the License at http://www.mozilla.org/NPL/ ! 7: * ! 8: * Software distributed under the License is distributed on an "AS ! 9: * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or ! 10: * implied. See the License for the specific language governing ! 11: * rights and limitations under the License. ! 12: * ! 13: * The Original Code is Mozilla Communicator client code, released ! 14: * March 31, 1998. ! 15: * ! 16: * The Initial Developer of the Original Code is Netscape ! 17: * Communications Corporation. Portions created by Netscape are ! 18: * Copyright (C) 1998 Netscape Communications Corporation. All ! 19: * Rights Reserved. ! 20: * ! 21: * Contributor(s): ! 22: * ! 23: * Alternatively, the contents of this file may be used under the ! 24: * terms of the GNU Public License (the "GPL"), in which case the ! 25: * provisions of the GPL are applicable instead of those above. ! 26: * If you wish to allow use of your version of this file only ! 27: * under the terms of the GPL and not to allow others to use your ! 28: * version of this file under the NPL, indicate your decision by ! 29: * deleting the provisions above and replace them with the notice ! 30: * and other provisions required by the GPL. If you do not delete ! 31: * the provisions above, a recipient may use your version of this ! 32: * file under either the NPL or the GPL. ! 33: */ ! 34: ! 35: #ifndef jsemit_h___ ! 36: #define jsemit_h___ ! 37: /* ! 38: * JS bytecode generation. ! 39: */ ! 40: ! 41: #include "jsstddef.h" ! 42: #include "jstypes.h" ! 43: #include "jsatom.h" ! 44: #include "jsopcode.h" ! 45: #include "jsprvtd.h" ! 46: #include "jspubtd.h" ! 47: ! 48: JS_BEGIN_EXTERN_C ! 49: ! 50: /* ! 51: * NB: If you add non-loop STMT_* enumerators, do so before STMT_DO_LOOP or ! 52: * you will break the STMT_IS_LOOP macro, just below this enum. ! 53: */ ! 54: typedef enum JSStmtType { ! 55: STMT_BLOCK = 0, /* compound statement: { s1[;... sN] } */ ! 56: STMT_LABEL = 1, /* labeled statement: L: s */ ! 57: STMT_IF = 2, /* if (then) statement */ ! 58: STMT_ELSE = 3, /* else clause of if statement */ ! 59: STMT_SWITCH = 4, /* switch statement */ ! 60: STMT_WITH = 5, /* with statement */ ! 61: STMT_TRY = 6, /* try statement */ ! 62: STMT_CATCH = 7, /* catch block */ ! 63: STMT_FINALLY = 8, /* finally statement */ ! 64: STMT_SUBROUTINE = 9, /* gosub-target subroutine body */ ! 65: STMT_DO_LOOP = 10, /* do/while loop statement */ ! 66: STMT_FOR_LOOP = 11, /* for loop statement */ ! 67: STMT_FOR_IN_LOOP = 12, /* for/in loop statement */ ! 68: STMT_WHILE_LOOP = 13 /* while loop statement */ ! 69: } JSStmtType; ! 70: ! 71: #define STMT_IS_LOOP(stmt) ((stmt)->type >= STMT_DO_LOOP) ! 72: ! 73: typedef struct JSStmtInfo JSStmtInfo; ! 74: ! 75: struct JSStmtInfo { ! 76: JSStmtType type; /* statement type */ ! 77: ptrdiff_t update; /* loop update offset (top if none) */ ! 78: ptrdiff_t breaks; /* offset of last break in loop */ ! 79: ptrdiff_t continues; /* offset of last continue in loop */ ! 80: ptrdiff_t gosub; /* offset of last GOSUB for this finally */ ! 81: ptrdiff_t catchJump; /* offset of last end-of-catch jump */ ! 82: JSAtom *label; /* name of LABEL or CATCH var */ ! 83: JSStmtInfo *down; /* info for enclosing statement */ ! 84: }; ! 85: ! 86: #define SET_STATEMENT_TOP(stmt, top) \ ! 87: ((stmt)->update = (top), (stmt)->breaks = \ ! 88: (stmt)->continues = (stmt)->catchJump = (stmt)->gosub = (-1)) ! 89: ! 90: struct JSTreeContext { /* tree context for semantic checks */ ! 91: uint32 flags; /* statement state flags, see below */ ! 92: uint32 tryCount; /* total count of try statements parsed */ ! 93: JSStmtInfo *topStmt; /* top of statement info stack */ ! 94: JSAtomList decls; /* function, const, and var declarations */ ! 95: JSParseNode *nodeList; /* list of recyclable parse-node structs */ ! 96: }; ! 97: ! 98: #define TCF_COMPILING 0x01 /* generating bytecode; this tc is a cg */ ! 99: #define TCF_IN_FUNCTION 0x02 /* parsing inside function body */ ! 100: #define TCF_RETURN_EXPR 0x04 /* function has 'return expr;' */ ! 101: #define TCF_RETURN_VOID 0x08 /* function has 'return;' */ ! 102: #define TCF_IN_FOR_INIT 0x10 /* parsing init expr of for; exclude 'in' */ ! 103: #define TCF_FUN_CLOSURE_VS_VAR 0x20 /* function and var with same name */ ! 104: #define TCF_FUN_USES_NONLOCALS 0x40 /* function refers to non-local names */ ! 105: #define TCF_FUN_HEAVYWEIGHT 0x80 /* function needs Call object per call */ ! 106: #define TCF_FUN_FLAGS 0xE0 /* flags to propagate from FunctionBody */ ! 107: ! 108: #define TREE_CONTEXT_INIT(tc) \ ! 109: ((tc)->flags = 0, (tc)->tryCount = 0, (tc)->topStmt = NULL, \ ! 110: ATOM_LIST_INIT(&(tc)->decls), (tc)->nodeList = NULL) ! 111: ! 112: #define TREE_CONTEXT_FINISH(tc) \ ! 113: ((void)0) ! 114: ! 115: /* ! 116: * Span-dependent instructions are jumps whose span (from the jump bytecode to ! 117: * the jump target) may require 2 or 4 bytes of immediate operand. ! 118: */ ! 119: typedef struct JSSpanDep JSSpanDep; ! 120: typedef struct JSJumpTarget JSJumpTarget; ! 121: ! 122: struct JSSpanDep { ! 123: ptrdiff_t top; /* offset of first bytecode in an opcode */ ! 124: ptrdiff_t offset; /* offset - 1 within opcode of jump operand */ ! 125: ptrdiff_t before; /* original offset - 1 of jump operand */ ! 126: JSJumpTarget *target; /* tagged target pointer or backpatch delta */ ! 127: }; ! 128: ! 129: /* ! 130: * Jump targets are stored in an AVL tree, for O(log(n)) lookup with targets ! 131: * sorted by offset from left to right, so that targets above a span-dependent ! 132: * instruction whose jump offset operand must be extended can be found quickly ! 133: * and adjusted upward (toward higher offsets). ! 134: */ ! 135: struct JSJumpTarget { ! 136: ptrdiff_t offset; /* offset of span-dependent jump target */ ! 137: int balance; /* AVL tree balance number */ ! 138: JSJumpTarget *kids[2]; /* left and right AVL tree child pointers */ ! 139: }; ! 140: ! 141: #define JT_LEFT 0 ! 142: #define JT_RIGHT 1 ! 143: #define JT_OTHER_DIR(dir) (1 - (dir)) ! 144: #define JT_IMBALANCE(dir) (((dir) << 1) - 1) ! 145: #define JT_DIR(imbalance) (((imbalance) + 1) >> 1) ! 146: ! 147: /* ! 148: * Backpatch deltas are encoded in JSSpanDep.target if JT_TAG_BIT is clear, ! 149: * so we can maintain backpatch chains when using span dependency records to ! 150: * hold jump offsets that overflow 16 bits. ! 151: */ ! 152: #define JT_TAG_BIT ((jsword) 1) ! 153: #define JT_UNTAG_SHIFT 1 ! 154: #define JT_SET_TAG(jt) ((JSJumpTarget *)((jsword)(jt) | JT_TAG_BIT)) ! 155: #define JT_CLR_TAG(jt) ((JSJumpTarget *)((jsword)(jt) & ~JT_TAG_BIT)) ! 156: #define JT_HAS_TAG(jt) ((jsword)(jt) & JT_TAG_BIT) ! 157: ! 158: #define BITS_PER_PTRDIFF (sizeof(ptrdiff_t) * JS_BITS_PER_BYTE) ! 159: #define BITS_PER_BPDELTA (BITS_PER_PTRDIFF - 1 - JT_UNTAG_SHIFT) ! 160: #define BPDELTA_MAX (((ptrdiff_t)1 << BITS_PER_BPDELTA) - 1) ! 161: #define BPDELTA_TO_JT(bp) ((JSJumpTarget *)((bp) << JT_UNTAG_SHIFT)) ! 162: #define JT_TO_BPDELTA(jt) ((ptrdiff_t)((jsword)(jt) >> JT_UNTAG_SHIFT)) ! 163: ! 164: #define SD_SET_TARGET(sd,jt) ((sd)->target = JT_SET_TAG(jt)) ! 165: #define SD_SET_BPDELTA(sd,bp) ((sd)->target = BPDELTA_TO_JT(bp)) ! 166: #define SD_GET_BPDELTA(sd) (JS_ASSERT(!JT_HAS_TAG((sd)->target)), \ ! 167: JT_TO_BPDELTA((sd)->target)) ! 168: #define SD_TARGET_OFFSET(sd) (JS_ASSERT(JT_HAS_TAG((sd)->target)), \ ! 169: JT_CLR_TAG((sd)->target)->offset) ! 170: ! 171: struct JSCodeGenerator { ! 172: JSTreeContext treeContext; /* base state: statement info stack, etc. */ ! 173: void *codeMark; /* low watermark in cx->codePool */ ! 174: void *noteMark; /* low watermark in cx->notePool */ ! 175: void *tempMark; /* low watermark in cx->tempPool */ ! 176: struct { ! 177: jsbytecode *base; /* base of JS bytecode vector */ ! 178: jsbytecode *limit; /* one byte beyond end of bytecode */ ! 179: jsbytecode *next; /* pointer to next free bytecode */ ! 180: jssrcnote *notes; /* source notes, see below */ ! 181: uintN noteCount; /* number of source notes so far */ ! 182: uintN noteMask; /* growth increment for notes */ ! 183: ptrdiff_t lastNoteOffset; /* code offset for last source note */ ! 184: uintN currentLine; /* line number for tree-based srcnote gen */ ! 185: } prolog, main, *current; ! 186: const char *filename; /* null or weak link to source filename */ ! 187: uintN firstLine; /* first line, for js_NewScriptFromCG */ ! 188: JSPrincipals *principals; /* principals for constant folding eval */ ! 189: JSAtomList atomList; /* literals indexed for mapping */ ! 190: intN stackDepth; /* current stack depth in script frame */ ! 191: uintN maxStackDepth; /* maximum stack depth so far */ ! 192: JSTryNote *tryBase; /* first exception handling note */ ! 193: JSTryNote *tryNext; /* next available note */ ! 194: size_t tryNoteSpace; /* # of bytes allocated at tryBase */ ! 195: JSSpanDep *spanDeps; /* span dependent instruction records */ ! 196: JSJumpTarget *jumpTargets; /* AVL tree of jump target offsets */ ! 197: JSJumpTarget *jtFreeList; /* JT_LEFT-linked list of free structs */ ! 198: uintN numSpanDeps; /* number of span dependencies */ ! 199: uintN numJumpTargets; /* number of jump targets */ ! 200: uintN emitLevel; /* js_EmitTree recursion level */ ! 201: }; ! 202: ! 203: #define CG_BASE(cg) ((cg)->current->base) ! 204: #define CG_LIMIT(cg) ((cg)->current->limit) ! 205: #define CG_NEXT(cg) ((cg)->current->next) ! 206: #define CG_CODE(cg,offset) (CG_BASE(cg) + (offset)) ! 207: #define CG_OFFSET(cg) PTRDIFF(CG_NEXT(cg), CG_BASE(cg), jsbytecode) ! 208: ! 209: #define CG_NOTES(cg) ((cg)->current->notes) ! 210: #define CG_NOTE_COUNT(cg) ((cg)->current->noteCount) ! 211: #define CG_NOTE_MASK(cg) ((cg)->current->noteMask) ! 212: #define CG_LAST_NOTE_OFFSET(cg) ((cg)->current->lastNoteOffset) ! 213: #define CG_CURRENT_LINE(cg) ((cg)->current->currentLine) ! 214: ! 215: #define CG_PROLOG_BASE(cg) ((cg)->prolog.base) ! 216: #define CG_PROLOG_LIMIT(cg) ((cg)->prolog.limit) ! 217: #define CG_PROLOG_NEXT(cg) ((cg)->prolog.next) ! 218: #define CG_PROLOG_CODE(cg,poff) (CG_PROLOG_BASE(cg) + (poff)) ! 219: #define CG_PROLOG_OFFSET(cg) PTRDIFF(CG_PROLOG_NEXT(cg), CG_PROLOG_BASE(cg),\ ! 220: jsbytecode) ! 221: ! 222: #define CG_SWITCH_TO_MAIN(cg) ((cg)->current = &(cg)->main) ! 223: #define CG_SWITCH_TO_PROLOG(cg) ((cg)->current = &(cg)->prolog) ! 224: ! 225: /* ! 226: * Initialize cg to allocate bytecode space from cx->codePool, source note ! 227: * space from cx->notePool, and all other arena-allocated temporaries from ! 228: * cx->tempPool. Return true on success. Report an error and return false ! 229: * if the initial code segment can't be allocated. ! 230: */ ! 231: extern JS_FRIEND_API(JSBool) ! 232: js_InitCodeGenerator(JSContext *cx, JSCodeGenerator *cg, ! 233: const char *filename, uintN lineno, ! 234: JSPrincipals *principals); ! 235: ! 236: /* ! 237: * Release cx->codePool, cx->notePool, and cx->tempPool to marks set by ! 238: * js_InitCodeGenerator. Note that cgs are magic: they own the arena pool ! 239: * "tops-of-stack" space above their codeMark, noteMark, and tempMark points. ! 240: * This means you cannot alloc from tempPool and save the pointer beyond the ! 241: * next JS_FinishCodeGenerator. ! 242: */ ! 243: extern JS_FRIEND_API(void) ! 244: js_FinishCodeGenerator(JSContext *cx, JSCodeGenerator *cg); ! 245: ! 246: /* ! 247: * Emit one bytecode. ! 248: */ ! 249: extern ptrdiff_t ! 250: js_Emit1(JSContext *cx, JSCodeGenerator *cg, JSOp op); ! 251: ! 252: /* ! 253: * Emit two bytecodes, an opcode (op) with a byte of immediate operand (op1). ! 254: */ ! 255: extern ptrdiff_t ! 256: js_Emit2(JSContext *cx, JSCodeGenerator *cg, JSOp op, jsbytecode op1); ! 257: ! 258: /* ! 259: * Emit three bytecodes, an opcode with two bytes of immediate operands. ! 260: */ ! 261: extern ptrdiff_t ! 262: js_Emit3(JSContext *cx, JSCodeGenerator *cg, JSOp op, jsbytecode op1, ! 263: jsbytecode op2); ! 264: ! 265: /* ! 266: * Emit (1 + extra) bytecodes, for N bytes of op and its immediate operand. ! 267: */ ! 268: extern ptrdiff_t ! 269: js_EmitN(JSContext *cx, JSCodeGenerator *cg, JSOp op, size_t extra); ! 270: ! 271: /* ! 272: * Unsafe macro to call js_SetJumpOffset and return false if it does. ! 273: */ ! 274: #define CHECK_AND_SET_JUMP_OFFSET(cx,cg,pc,off) \ ! 275: JS_BEGIN_MACRO \ ! 276: if (!js_SetJumpOffset(cx, cg, pc, off)) \ ! 277: return JS_FALSE; \ ! 278: JS_END_MACRO ! 279: ! 280: #define CHECK_AND_SET_JUMP_OFFSET_AT(cx,cg,off) \ ! 281: CHECK_AND_SET_JUMP_OFFSET(cx, cg, CG_CODE(cg,off), CG_OFFSET(cg) - (off)) ! 282: ! 283: extern JSBool ! 284: js_SetJumpOffset(JSContext *cx, JSCodeGenerator *cg, jsbytecode *pc, ! 285: ptrdiff_t off); ! 286: ! 287: /* Test whether we're in a with statement. */ ! 288: extern JSBool ! 289: js_InWithStatement(JSTreeContext *tc); ! 290: ! 291: /* Test whether we're in a catch block with exception named by atom. */ ! 292: extern JSBool ! 293: js_InCatchBlock(JSTreeContext *tc, JSAtom *atom); ! 294: ! 295: /* ! 296: * Push the C-stack-allocated struct at stmt onto the stmtInfo stack. ! 297: */ ! 298: extern void ! 299: js_PushStatement(JSTreeContext *tc, JSStmtInfo *stmt, JSStmtType type, ! 300: ptrdiff_t top); ! 301: ! 302: /* ! 303: * Pop tc->topStmt. If the top JSStmtInfo struct is not stack-allocated, it ! 304: * is up to the caller to free it. ! 305: */ ! 306: extern void ! 307: js_PopStatement(JSTreeContext *tc); ! 308: ! 309: /* ! 310: * Like js_PopStatement(&cg->treeContext), also patch breaks and continues. ! 311: * May fail if a jump offset overflows. ! 312: */ ! 313: extern JSBool ! 314: js_PopStatementCG(JSContext *cx, JSCodeGenerator *cg); ! 315: ! 316: /* ! 317: * Emit code into cg for the tree rooted at pn. ! 318: */ ! 319: extern JSBool ! 320: js_EmitTree(JSContext *cx, JSCodeGenerator *cg, JSParseNode *pn); ! 321: ! 322: /* ! 323: * Emit code into cg for the tree rooted at body, then create a persistent ! 324: * script for fun from cg. ! 325: */ ! 326: extern JSBool ! 327: js_EmitFunctionBody(JSContext *cx, JSCodeGenerator *cg, JSParseNode *body, ! 328: JSFunction *fun); ! 329: ! 330: /* ! 331: * Source notes generated along with bytecode for decompiling and debugging. ! 332: * A source note is a uint8 with 5 bits of type and 3 of offset from the pc of ! 333: * the previous note. If 3 bits of offset aren't enough, extended delta notes ! 334: * (SRC_XDELTA) consisting of 2 set high order bits followed by 6 offset bits ! 335: * are emitted before the next note. Some notes have operand offsets encoded ! 336: * immediately after them, in note bytes or byte-triples. ! 337: * ! 338: * Source Note Extended Delta ! 339: * +7-6-5-4-3+2-1-0+ +7-6-5+4-3-2-1-0+ ! 340: * |note-type|delta| |1 1| ext-delta | ! 341: * +---------+-----+ +---+-----------+ ! 342: * ! 343: * At most one "gettable" note (i.e., a note of type other than SRC_NEWLINE, ! 344: * SRC_SETLINE, and SRC_XDELTA) applies to a given bytecode. ! 345: * ! 346: * NB: the js_SrcNoteSpec array in jsemit.c is indexed by this enum, so its ! 347: * initializers need to match the order here. ! 348: */ ! 349: typedef enum JSSrcNoteType { ! 350: SRC_NULL = 0, /* terminates a note vector */ ! 351: SRC_IF = 1, /* JSOP_IFEQ bytecode is from an if-then */ ! 352: SRC_IF_ELSE = 2, /* JSOP_IFEQ bytecode is from an if-then-else */ ! 353: SRC_WHILE = 3, /* JSOP_IFEQ is from a while loop */ ! 354: SRC_FOR = 4, /* JSOP_NOP or JSOP_POP in for loop head */ ! 355: SRC_CONTINUE = 5, /* JSOP_GOTO is a continue, not a break; ! 356: also used on JSOP_ENDINIT if extra comma ! 357: at end of array literal: [1,2,,] */ ! 358: SRC_VAR = 6, /* JSOP_NAME/SETNAME/FORNAME in a var decl */ ! 359: SRC_PCDELTA = 7, /* offset from comma-operator to next POP, ! 360: or from CONDSWITCH to first CASE opcode */ ! 361: SRC_ASSIGNOP = 8, /* += or another assign-op follows */ ! 362: SRC_COND = 9, /* JSOP_IFEQ is from conditional ?: operator */ ! 363: SRC_RESERVED0 = 10, /* reserved for future use */ ! 364: SRC_HIDDEN = 11, /* opcode shouldn't be decompiled */ ! 365: SRC_PCBASE = 12, /* offset of first obj.prop.subprop bytecode */ ! 366: SRC_LABEL = 13, /* JSOP_NOP for label: with atomid immediate */ ! 367: SRC_LABELBRACE = 14, /* JSOP_NOP for label: {...} begin brace */ ! 368: SRC_ENDBRACE = 15, /* JSOP_NOP for label: {...} end brace */ ! 369: SRC_BREAK2LABEL = 16, /* JSOP_GOTO for 'break label' with atomid */ ! 370: SRC_CONT2LABEL = 17, /* JSOP_GOTO for 'continue label' with atomid */ ! 371: SRC_SWITCH = 18, /* JSOP_*SWITCH with offset to end of switch, ! 372: 2nd off to first JSOP_CASE if condswitch */ ! 373: SRC_FUNCDEF = 19, /* JSOP_NOP for function f() with atomid */ ! 374: SRC_CATCH = 20, /* catch block has guard */ ! 375: SRC_CONST = 21, /* JSOP_SETCONST in a const decl */ ! 376: SRC_NEWLINE = 22, /* bytecode follows a source newline */ ! 377: SRC_SETLINE = 23, /* a file-absolute source line number note */ ! 378: SRC_XDELTA = 24 /* 24-31 are for extended delta notes */ ! 379: } JSSrcNoteType; ! 380: ! 381: #define SN_TYPE_BITS 5 ! 382: #define SN_DELTA_BITS 3 ! 383: #define SN_XDELTA_BITS 6 ! 384: #define SN_TYPE_MASK (JS_BITMASK(SN_TYPE_BITS) << SN_DELTA_BITS) ! 385: #define SN_DELTA_MASK ((ptrdiff_t)JS_BITMASK(SN_DELTA_BITS)) ! 386: #define SN_XDELTA_MASK ((ptrdiff_t)JS_BITMASK(SN_XDELTA_BITS)) ! 387: ! 388: #define SN_MAKE_NOTE(sn,t,d) (*(sn) = (jssrcnote) \ ! 389: (((t) << SN_DELTA_BITS) \ ! 390: | ((d) & SN_DELTA_MASK))) ! 391: #define SN_MAKE_XDELTA(sn,d) (*(sn) = (jssrcnote) \ ! 392: ((SRC_XDELTA << SN_DELTA_BITS) \ ! 393: | ((d) & SN_XDELTA_MASK))) ! 394: ! 395: #define SN_IS_XDELTA(sn) ((*(sn) >> SN_DELTA_BITS) >= SRC_XDELTA) ! 396: #define SN_TYPE(sn) (SN_IS_XDELTA(sn) ? SRC_XDELTA \ ! 397: : *(sn) >> SN_DELTA_BITS) ! 398: #define SN_SET_TYPE(sn,type) SN_MAKE_NOTE(sn, type, SN_DELTA(sn)) ! 399: #define SN_IS_GETTABLE(sn) (SN_TYPE(sn) < SRC_NEWLINE) ! 400: ! 401: #define SN_DELTA(sn) ((ptrdiff_t)(SN_IS_XDELTA(sn) \ ! 402: ? *(sn) & SN_XDELTA_MASK \ ! 403: : *(sn) & SN_DELTA_MASK)) ! 404: #define SN_SET_DELTA(sn,delta) (SN_IS_XDELTA(sn) \ ! 405: ? SN_MAKE_XDELTA(sn, delta) \ ! 406: : SN_MAKE_NOTE(sn, SN_TYPE(sn), delta)) ! 407: ! 408: #define SN_DELTA_LIMIT ((ptrdiff_t)JS_BIT(SN_DELTA_BITS)) ! 409: #define SN_XDELTA_LIMIT ((ptrdiff_t)JS_BIT(SN_XDELTA_BITS)) ! 410: ! 411: /* ! 412: * Offset fields follow certain notes and are frequency-encoded: an offset in ! 413: * [0,0x7f] consumes one byte, an offset in [0x80,0x7fffff] takes three, and ! 414: * the high bit of the first byte is set. ! 415: */ ! 416: #define SN_3BYTE_OFFSET_FLAG 0x80 ! 417: #define SN_3BYTE_OFFSET_MASK 0x7f ! 418: ! 419: typedef struct JSSrcNoteSpec { ! 420: const char *name; /* name for disassembly/debugging output */ ! 421: uint8 arity; /* number of offset operands */ ! 422: uint8 offsetBias; /* bias of offset(s) from annotated pc */ ! 423: int8 isSpanDep; /* 1 or -1 if offsets could span extended ops, ! 424: 0 otherwise; sign tells span direction */ ! 425: } JSSrcNoteSpec; ! 426: ! 427: extern JS_FRIEND_DATA(JSSrcNoteSpec) js_SrcNoteSpec[]; ! 428: extern JS_FRIEND_API(uintN) js_SrcNoteLength(jssrcnote *sn); ! 429: ! 430: #define SN_LENGTH(sn) ((js_SrcNoteSpec[SN_TYPE(sn)].arity == 0) ? 1 \ ! 431: : js_SrcNoteLength(sn)) ! 432: #define SN_NEXT(sn) ((sn) + SN_LENGTH(sn)) ! 433: ! 434: /* A source note array is terminated by an all-zero element. */ ! 435: #define SN_MAKE_TERMINATOR(sn) (*(sn) = SRC_NULL) ! 436: #define SN_IS_TERMINATOR(sn) (*(sn) == SRC_NULL) ! 437: ! 438: /* ! 439: * Append a new source note of the given type (and therefore size) to cg's ! 440: * notes dynamic array, updating cg->noteCount. Return the new note's index ! 441: * within the array pointed at by cg->current->notes. Return -1 if out of ! 442: * memory. ! 443: */ ! 444: extern intN ! 445: js_NewSrcNote(JSContext *cx, JSCodeGenerator *cg, JSSrcNoteType type); ! 446: ! 447: extern intN ! 448: js_NewSrcNote2(JSContext *cx, JSCodeGenerator *cg, JSSrcNoteType type, ! 449: ptrdiff_t offset); ! 450: ! 451: extern intN ! 452: js_NewSrcNote3(JSContext *cx, JSCodeGenerator *cg, JSSrcNoteType type, ! 453: ptrdiff_t offset1, ptrdiff_t offset2); ! 454: ! 455: /* ! 456: * NB: this function can add at most one extra extended delta note. ! 457: */ ! 458: extern jssrcnote * ! 459: js_AddToSrcNoteDelta(JSContext *cx, JSCodeGenerator *cg, jssrcnote *sn, ! 460: ptrdiff_t delta); ! 461: ! 462: /* ! 463: * Get and set the offset operand identified by which (0 for the first, etc.). ! 464: */ ! 465: extern JS_FRIEND_API(ptrdiff_t) ! 466: js_GetSrcNoteOffset(jssrcnote *sn, uintN which); ! 467: ! 468: extern JSBool ! 469: js_SetSrcNoteOffset(JSContext *cx, JSCodeGenerator *cg, uintN index, ! 470: uintN which, ptrdiff_t offset); ! 471: ! 472: /* ! 473: * Finish taking source notes in cx's notePool, copying final notes to the new ! 474: * stable store allocated by the caller and passed in via notes. Return false ! 475: * on malloc failure, which means this function reported an error. ! 476: * ! 477: * To compute the number of jssrcnotes to allocate and pass in via notes, use ! 478: * the CG_COUNT_FINAL_SRCNOTES macro. This macro knows a lot about details of ! 479: * js_FinishTakingSrcNotes, SO DON'T CHANGE jsemit.c's js_FinishTakingSrcNotes ! 480: * FUNCTION WITHOUT CHECKING WHETHER THIS MACRO NEEDS CORRESPONDING CHANGES! ! 481: */ ! 482: #define CG_COUNT_FINAL_SRCNOTES(cg, cnt) \ ! 483: JS_BEGIN_MACRO \ ! 484: ptrdiff_t diff_ = CG_PROLOG_OFFSET(cg) - (cg)->prolog.lastNoteOffset; \ ! 485: cnt = (cg)->prolog.noteCount + (cg)->main.noteCount + 1; \ ! 486: if ((cg)->prolog.noteCount && \ ! 487: (cg)->prolog.currentLine != (cg)->firstLine) { \ ! 488: if (diff_ > SN_DELTA_MASK) \ ! 489: cnt += JS_HOWMANY(diff_ - SN_DELTA_MASK, SN_XDELTA_MASK); \ ! 490: cnt += 2 + (((cg)->firstLine > SN_3BYTE_OFFSET_MASK) << 1); \ ! 491: } else if (diff_ > 0) { \ ! 492: if (cg->main.noteCount) { \ ! 493: jssrcnote *sn_ = (cg)->main.notes; \ ! 494: diff_ -= SN_IS_XDELTA(sn_) \ ! 495: ? SN_XDELTA_MASK - (*sn_ & SN_XDELTA_MASK) \ ! 496: : SN_DELTA_MASK - (*sn_ & SN_DELTA_MASK); \ ! 497: } \ ! 498: if (diff_ > 0) \ ! 499: cnt += JS_HOWMANY(diff_, SN_XDELTA_MASK); \ ! 500: } \ ! 501: JS_END_MACRO ! 502: ! 503: extern JSBool ! 504: js_FinishTakingSrcNotes(JSContext *cx, JSCodeGenerator *cg, jssrcnote *notes); ! 505: ! 506: /* ! 507: * Allocate cg->treeContext.tryCount notes (plus one for the end sentinel) ! 508: * from cx->tempPool and set up cg->tryBase/tryNext for exactly tryCount ! 509: * js_NewTryNote calls. The storage is freed by js_FinishCodeGenerator. ! 510: */ ! 511: extern JSBool ! 512: js_AllocTryNotes(JSContext *cx, JSCodeGenerator *cg); ! 513: ! 514: /* ! 515: * Grab the next trynote slot in cg, filling it in appropriately. ! 516: */ ! 517: extern JSTryNote * ! 518: js_NewTryNote(JSContext *cx, JSCodeGenerator *cg, ptrdiff_t start, ! 519: ptrdiff_t end, ptrdiff_t catchStart); ! 520: ! 521: /* ! 522: * Finish generating exception information into the space at notes. As with ! 523: * js_FinishTakingSrcNotes, the caller must use CG_COUNT_FINAL_TRYNOTES(cg) to ! 524: * preallocate enough space in a JSTryNote[] to pass as the notes parameter of ! 525: * js_FinishTakingTryNotes. ! 526: */ ! 527: #define CG_COUNT_FINAL_TRYNOTES(cg, cnt) \ ! 528: JS_BEGIN_MACRO \ ! 529: cnt = ((cg)->tryNext > (cg)->tryBase) \ ! 530: ? PTRDIFF(cg->tryNext, cg->tryBase, JSTryNote) + 1 \ ! 531: : 0; \ ! 532: JS_END_MACRO ! 533: ! 534: extern void ! 535: js_FinishTakingTryNotes(JSContext *cx, JSCodeGenerator *cg, JSTryNote *notes); ! 536: ! 537: JS_END_EXTERN_C ! 538: ! 539: #endif /* jsemit_h___ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.