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