js/src/frontend/SourceNotes.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * vim: set ts=8 sts=4 et sw=4 tw=99:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef frontend_SourceNotes_h
   8 #define frontend_SourceNotes_h
   9
  10 #include <stdint.h>
  11
  12 #include "jstypes.h"
  13
  14 typedef uint8_t jssrcnote;
  15
  16 namespace js {
  17
  18 /*
  19  * Source notes generated along with bytecode for decompiling and debugging.
  20  * A source note is a uint8_t with 5 bits of type and 3 of offset from the pc
  21  * of the previous note. If 3 bits of offset aren't enough, extended delta
  22  * notes (SRC_XDELTA) consisting of 2 set high order bits followed by 6 offset
  23  * bits are emitted before the next note. Some notes have operand offsets
  24  * encoded immediately after them, in note bytes or byte-triples.
  25  *
  26  *                 Source Note               Extended Delta
  27  *              +7-6-5-4-3+2-1-0+           +7-6-5+4-3-2-1-0+
  28  *              |note-type|delta|           |1 1| ext-delta |
  29  *              +---------+-----+           +---+-----------+
  30  *
  31  * At most one "gettable" note (i.e., a note of type other than SRC_NEWLINE,
  32  * SRC_COLSPAN, SRC_SETLINE, and SRC_XDELTA) applies to a given bytecode.
  33  *
  34  * NB: the js_SrcNoteSpec array in BytecodeEmitter.cpp is indexed by this
  35  * enum, so its initializers need to match the order here.
  36  *
  37  * Don't forget to update XDR_BYTECODE_VERSION in vm/Xdr.h for all such
  38  * incompatible source note or other bytecode changes.
  39  */
  40 #define FOR_EACH_SRC_NOTE_TYPE(M)                                                                  \
  41     M(SRC_NULL,         "null",        0)  /* Terminates a note vector. */                         \
  42     M(SRC_IF,           "if",          0)  /* JSOP_IFEQ bytecode is from an if-then. */            \
  43     M(SRC_IF_ELSE,      "if-else",     1)  /* JSOP_IFEQ bytecode is from an if-then-else. */       \
  44     M(SRC_COND,         "cond",        1)  /* JSOP_IFEQ is from conditional ?: operator. */        \
  45     M(SRC_FOR,          "for",         3)  /* JSOP_NOP or JSOP_POP in for(;;) loop head. */        \
  46     M(SRC_WHILE,        "while",       1)  /* JSOP_GOTO to for or while loop condition from before \
  47                                               loop, else JSOP_NOP at top of do-while loop. */      \
  48     M(SRC_FOR_IN,       "for-in",      1)  /* JSOP_GOTO to for-in loop condition from before       \
  49                                               loop. */                                             \
  50     M(SRC_FOR_OF,       "for-of",      1)  /* JSOP_GOTO to for-of loop condition from before       \
  51                                               loop. */                                             \
  52     M(SRC_CONTINUE,     "continue",    0)  /* JSOP_GOTO is a continue. */                          \
  53     M(SRC_BREAK,        "break",       0)  /* JSOP_GOTO is a break. */                             \
  54     M(SRC_BREAK2LABEL,  "break2label", 0)  /* JSOP_GOTO for 'break label'. */                      \
  55     M(SRC_SWITCHBREAK,  "switchbreak", 0)  /* JSOP_GOTO is a break in a switch. */                 \
  56     M(SRC_TABLESWITCH,  "tableswitch", 1)  /* JSOP_TABLESWITCH; offset points to end of switch. */ \
  57     M(SRC_CONDSWITCH,   "condswitch",  2)  /* JSOP_CONDSWITCH; 1st offset points to end of switch, \
  58                                               2nd points to first JSOP_CASE. */                    \
  59     M(SRC_NEXTCASE,     "nextcase",    1)  /* Distance forward from one CASE in a CONDSWITCH to    \
  60                                               the next. */                                         \
  61     M(SRC_ASSIGNOP,     "assignop",    0)  /* += or another assign-op follows. */                  \
  62     M(SRC_TRY,          "try",         1)  /* JSOP_TRY, offset points to goto at the end of the    \
  63                                               try block. */                                        \
  64     /* All notes above here are "gettable".  See SN_IS_GETTABLE below. */                          \
  65     M(SRC_COLSPAN,      "colspan",     1)  /* Number of columns this opcode spans. */              \
  66     M(SRC_NEWLINE,      "newline",     0)  /* Bytecode follows a source newline. */                \
  67     M(SRC_SETLINE,      "setline",     1)  /* A file-absolute source line number note. */          \
  68     M(SRC_UNUSED20,     "unused20",    0)  /* Unused. */                                           \
  69     M(SRC_UNUSED21,     "unused21",    0)  /* Unused. */                                           \
  70     M(SRC_UNUSED22,     "unused22",    0)  /* Unused. */                                           \
  71     M(SRC_UNUSED23,     "unused23",    0)  /* Unused. */                                           \
  72     M(SRC_XDELTA,       "xdelta",      0)  /* 24-31 are for extended delta notes. */
  73
  74 enum SrcNoteType {
  75 #define DEFINE_SRC_NOTE_TYPE(sym, name, arity) sym,
  76     FOR_EACH_SRC_NOTE_TYPE(DEFINE_SRC_NOTE_TYPE)
  77 #undef DEFINE_SRC_NOTE_TYPE
  78
  79     SRC_LAST,
  80     SRC_LAST_GETTABLE = SRC_TRY
  81 };
  82
  83 static_assert(SRC_XDELTA == 24, "SRC_XDELTA should be 24");
  84
  85 /* A source note array is terminated by an all-zero element. */
  86 inline void
  87 SN_MAKE_TERMINATOR(jssrcnote* sn)
  88 {
  89     *sn = SRC_NULL;
  90 }
  91
  92 inline bool
  93 SN_IS_TERMINATOR(jssrcnote* sn)
  94 {
  95     return *sn == SRC_NULL;
  96 }
  97
  98 }  // namespace js
  99
 100 #define SN_TYPE_BITS            5
 101 #define SN_DELTA_BITS           3
 102 #define SN_XDELTA_BITS          6
 103 #define SN_TYPE_MASK            (JS_BITMASK(SN_TYPE_BITS) << SN_DELTA_BITS)
 104 #define SN_DELTA_MASK           ((ptrdiff_t)JS_BITMASK(SN_DELTA_BITS))
 105 #define SN_XDELTA_MASK          ((ptrdiff_t)JS_BITMASK(SN_XDELTA_BITS))
 106
 107 #define SN_MAKE_NOTE(sn,t,d)    (*(sn) = (jssrcnote)                          \
 108                                           (((t) << SN_DELTA_BITS)             \
 109                                            | ((d) & SN_DELTA_MASK)))
 110 #define SN_MAKE_XDELTA(sn,d)    (*(sn) = (jssrcnote)                          \
 111                                           ((SRC_XDELTA << SN_DELTA_BITS)      \
 112                                            | ((d) & SN_XDELTA_MASK)))
 113
 114 #define SN_IS_XDELTA(sn)        ((*(sn) >> SN_DELTA_BITS) >= SRC_XDELTA)
 115 #define SN_TYPE(sn)             ((js::SrcNoteType)(SN_IS_XDELTA(sn)           \
 116                                                    ? SRC_XDELTA               \
 117                                                    : *(sn) >> SN_DELTA_BITS))
 118 #define SN_SET_TYPE(sn,type)    SN_MAKE_NOTE(sn, type, SN_DELTA(sn))
 119 #define SN_IS_GETTABLE(sn)      (SN_TYPE(sn) <= SRC_LAST_GETTABLE)
 120
 121 #define SN_DELTA(sn)            ((ptrdiff_t)(SN_IS_XDELTA(sn)                 \
 122                                              ? *(sn) & SN_XDELTA_MASK         \
 123                                              : *(sn) & SN_DELTA_MASK))
 124 #define SN_SET_DELTA(sn,delta)  (SN_IS_XDELTA(sn)                             \
 125                                  ? SN_MAKE_XDELTA(sn, delta)                  \
 126                                  : SN_MAKE_NOTE(sn, SN_TYPE(sn), delta))
 127
 128 #define SN_DELTA_LIMIT          ((ptrdiff_t)JS_BIT(SN_DELTA_BITS))
 129 #define SN_XDELTA_LIMIT         ((ptrdiff_t)JS_BIT(SN_XDELTA_BITS))
 130
 131 /*
 132  * Offset fields follow certain notes and are frequency-encoded: an offset in
 133  * [0,0x7f] consumes one byte, an offset in [0x80,0x7fffffff] takes four, and
 134  * the high bit of the first byte is set.
 135  */
 136 #define SN_4BYTE_OFFSET_FLAG    0x80
 137 #define SN_4BYTE_OFFSET_MASK    0x7f
 138
 139 #define SN_OFFSET_BITS          31
 140 #define SN_MAX_OFFSET (((size_t) 1 << SN_OFFSET_BITS) - 1)
 141
 142 inline bool
 143 SN_REPRESENTABLE_OFFSET(ptrdiff_t offset)
 144 {
 145     return 0 <= offset && size_t(offset) <= SN_MAX_OFFSET;
 146 }
 147
 148 /*
 149  * SRC_COLSPAN values represent changes to the column number. Colspans are
 150  * signed: negative changes arise in describing constructs like for(;;) loops,
 151  * that generate code in non-source order. (Negative colspans also have a
 152  * history of indicating bugs in updating ParseNodes' source locations.)
 153  *
 154  * We store colspans using the same variable-length encoding as offsets,
 155  * described above. However, unlike offsets, colspans are signed, so we truncate
 156  * colspans (SN_COLSPAN_TO_OFFSET) for storage as offsets, and sign-extend
 157  * offsets into colspans when we read them (SN_OFFSET_TO_COLSPAN).
 158  */
 159 #define SN_COLSPAN_SIGN_BIT (1 << (SN_OFFSET_BITS - 1))
 160 #define SN_MIN_COLSPAN (-SN_COLSPAN_SIGN_BIT)
 161 #define SN_MAX_COLSPAN (SN_COLSPAN_SIGN_BIT - 1)
 162
 163 inline bool
 164 SN_REPRESENTABLE_COLSPAN(ptrdiff_t colspan)
 165 {
 166     return SN_MIN_COLSPAN <= colspan && colspan <= SN_MAX_COLSPAN;
 167 }
 168
 169 inline ptrdiff_t
 170 SN_OFFSET_TO_COLSPAN(ptrdiff_t offset) {
 171     // There should be no bits set outside the field we're going to sign-extend.
 172     MOZ_ASSERT(!(offset & ~((1U << SN_OFFSET_BITS) - 1)));
 173     // Sign-extend the least significant SN_OFFSET_BITS bits.
 174     return (offset ^ SN_COLSPAN_SIGN_BIT) - SN_COLSPAN_SIGN_BIT;
 175 }
 176
 177 inline ptrdiff_t
 178 SN_COLSPAN_TO_OFFSET(ptrdiff_t colspan) {
 179     // Truncate the two's complement colspan, for storage as an offset.
 180     ptrdiff_t offset = colspan & ((1U << SN_OFFSET_BITS) - 1);
 181     // When we read this back, we'd better get the value we stored.
 182     MOZ_ASSERT(SN_OFFSET_TO_COLSPAN(offset) == colspan);
 183     return offset;
 184 }
 185
 186 #define SN_LENGTH(sn)           ((js_SrcNoteSpec[SN_TYPE(sn)].arity == 0) ? 1 \
 187                                  : js_SrcNoteLength(sn))
 188 #define SN_NEXT(sn)             ((sn) + SN_LENGTH(sn))
 189
 190 struct JSSrcNoteSpec {
 191     const char*     name;      /* name for disassembly/debugging output */
 192     int8_t          arity;      /* number of offset operands */
 193 };
 194
 195 extern JS_FRIEND_DATA(const JSSrcNoteSpec) js_SrcNoteSpec[];
 196 extern JS_FRIEND_API(unsigned)         js_SrcNoteLength(jssrcnote* sn);
 197
 198 /*
 199  * Get and set the offset operand identified by which (0 for the first, etc.).
 200  */
 201 extern JS_FRIEND_API(ptrdiff_t)
 202 js_GetSrcNoteOffset(jssrcnote* sn, unsigned which);
 203
 204 #endif /* frontend_SourceNotes_h */