WebKitSite/specs/squirrelfish-bytecode.html

   1 <style>p code { font-size: 14px; }</style>
   2 <h2><code>load</code></h2>
   3 <p><b>Format: </b><code>
   4 load dst(r) src(k)
   5 </code></p>
   6 <p>
   7
   8             Copies constant src to register dst.
   9
  10 </p>
  11 <h2><code>new_object</code></h2>
  12 <p><b>Format: </b><code>
  13 new_object dst(r)
  14 </code></p>
  15 <p>
  16
  17             Constructs a new empty Object instance using the original
  18             constructor, and puts the result in register dst.
  19
  20 </p>
  21 <h2><code>new_array</code></h2>
  22 <p><b>Format: </b><code>
  23 new_array dst(r) firstArg(r) argCount(n)
  24 </code></p>
  25 <p>
  26
  27             Constructs a new Array instance using the original
  28             constructor, and puts the result in register dst.
  29             The array will contain argCount elements with values
  30             taken from registers starting at register firstArg.
  31
  32 </p>
  33 <h2><code>new_regexp</code></h2>
  34 <p><b>Format: </b><code>
  35 new_regexp dst(r) regExp(re)
  36 </code></p>
  37 <p>
  38
  39             Constructs a new RegExp instance using the original
  40             constructor from regexp regExp, and puts the result in
  41             register dst.
  42
  43 </p>
  44 <h2><code>mov</code></h2>
  45 <p><b>Format: </b><code>
  46 mov dst(r) src(r)
  47 </code></p>
  48 <p>
  49
  50             Copies register src to register dst.
  51
  52 </p>
  53 <h2><code>eq</code></h2>
  54 <p><b>Format: </b><code>
  55 eq dst(r) src1(r) src2(r)
  56 </code></p>
  57 <p>
  58
  59             Checks whether register src1 and register src2 are equal,
  60             as with the ECMAScript '==' operator, and puts the result
  61             as a boolean in register dst.
  62
  63 </p>
  64 <h2><code>neq</code></h2>
  65 <p><b>Format: </b><code>
  66 neq dst(r) src1(r) src2(r)
  67 </code></p>
  68 <p>
  69
  70             Checks whether register src1 and register src2 are not
  71             equal, as with the ECMAScript '!=' operator, and puts the
  72             result as a boolean in register dst.
  73
  74 </p>
  75 <h2><code>stricteq</code></h2>
  76 <p><b>Format: </b><code>
  77 stricteq dst(r) src1(r) src2(r)
  78 </code></p>
  79 <p>
  80
  81             Checks whether register src1 and register src2 are strictly
  82             equal, as with the ECMAScript '===' operator, and puts the
  83             result as a boolean in register dst.
  84
  85 </p>
  86 <h2><code>nstricteq</code></h2>
  87 <p><b>Format: </b><code>
  88 nstricteq dst(r) src1(r) src2(r)
  89 </code></p>
  90 <p>
  91
  92             Checks whether register src1 and register src2 are not
  93             strictly equal, as with the ECMAScript '!==' operator, and
  94             puts the result as a boolean in register dst.
  95
  96 </p>
  97 <h2><code>less</code></h2>
  98 <p><b>Format: </b><code>
  99 less dst(r) src1(r) src2(r)
 100 </code></p>
 101 <p>
 102
 103             Checks whether register src1 is less than register src2, as
 104             with the ECMAScript '<' operator, and puts the result as
 105             a boolean in register dst.
 106
 107 </p>
 108 <h2><code>lesseq</code></h2>
 109 <p><b>Format: </b><code>
 110 lesseq dst(r) src1(r) src2(r)
 111 </code></p>
 112 <p>
 113
 114             Checks whether register src1 is less than or equal to
 115             register src2, as with the ECMAScript '<=' operator, and
 116             puts the result as a boolean in register dst.
 117
 118 </p>
 119 <h2><code>pre_inc</code></h2>
 120 <p><b>Format: </b><code>
 121 pre_inc srcDst(r)
 122 </code></p>
 123 <p>
 124
 125             Converts register srcDst to number, adds one, and puts the result
 126             back in register srcDst.
 127
 128 </p>
 129 <h2><code>pre_dec</code></h2>
 130 <p><b>Format: </b><code>
 131 pre_dec srcDst(r)
 132 </code></p>
 133 <p>
 134
 135             Converts register srcDst to number, subtracts one, and puts the result
 136             back in register srcDst.
 137
 138 </p>
 139 <h2><code>post_inc</code></h2>
 140 <p><b>Format: </b><code>
 141 post_inc dst(r) srcDst(r)
 142 </code></p>
 143 <p>
 144
 145             Converts register srcDst to number. The number itself is
 146             written to register dst, and the number plus one is written
 147             back to register srcDst.
 148
 149 </p>
 150 <h2><code>post_dec</code></h2>
 151 <p><b>Format: </b><code>
 152 post_dec dst(r) srcDst(r)
 153 </code></p>
 154 <p>
 155
 156             Converts register srcDst to number. The number itself is
 157             written to register dst, and the number minus one is written
 158             back to register srcDst.
 159
 160 </p>
 161 <h2><code>to_jsnumber</code></h2>
 162 <p><b>Format: </b><code>
 163 to_jsnumber dst(r) src(r)
 164 </code></p>
 165 <p>
 166
 167             Converts register src to number, and puts the result
 168             in register dst.
 169
 170 </p>
 171 <h2><code>negate</code></h2>
 172 <p><b>Format: </b><code>
 173 negate dst(r) src(r)
 174 </code></p>
 175 <p>
 176
 177             Converts register src to number, negates it, and puts the
 178             result in register dst.
 179
 180 </p>
 181 <h2><code>add</code></h2>
 182 <p><b>Format: </b><code>
 183 add dst(r) src1(r) src2(r)
 184 </code></p>
 185 <p>
 186
 187             Adds register src1 and register src2, and puts the result
 188             in register dst. (JS add may be string concatenation or
 189             numeric add, depending on the types of the operands.)
 190
 191 </p>
 192 <h2><code>mul</code></h2>
 193 <p><b>Format: </b><code>
 194 mul dst(r) src1(r) src2(r)
 195 </code></p>
 196 <p>
 197
 198             Multiplies register src1 and register src2 (converted to
 199             numbers), and puts the product in register dst.
 200
 201 </p>
 202 <h2><code>div</code></h2>
 203 <p><b>Format: </b><code>
 204 div dst(r) dividend(r) divisor(r)
 205 </code></p>
 206 <p>
 207
 208             Divides register dividend (converted to number) by the
 209             register divisor (converted to number), and puts the
 210             quotient in register dst.
 211
 212 </p>
 213 <h2><code>mod</code></h2>
 214 <p><b>Format: </b><code>
 215 mod dst(r) dividend(r) divisor(r)
 216 </code></p>
 217 <p>
 218
 219             Divides register dividend (converted to number) by
 220             register divisor (converted to number), and puts the
 221             remainder in register dst.
 222
 223 </p>
 224 <h2><code>sub</code></h2>
 225 <p><b>Format: </b><code>
 226 sub dst(r) src1(r) src2(r)
 227 </code></p>
 228 <p>
 229
 230             Subtracts register src2 (converted to number) from register
 231             src1 (converted to number), and puts the difference in
 232             register dst.
 233
 234 </p>
 235 <h2><code>lshift</code></h2>
 236 <p><b>Format: </b><code>
 237 lshift dst(r) val(r) shift(r)
 238 </code></p>
 239 <p>
 240
 241             Performs left shift of register val (converted to int32) by
 242             register shift (converted to uint32), and puts the result
 243             in register dst.
 244
 245 </p>
 246 <h2><code>rshift</code></h2>
 247 <p><b>Format: </b><code>
 248 rshift dst(r) val(r) shift(r)
 249 </code></p>
 250 <p>
 251
 252             Performs arithmetic right shift of register val (converted
 253             to int32) by register shift (converted to
 254             uint32), and puts the result in register dst.
 255
 256 </p>
 257 <h2><code>urshift</code></h2>
 258 <p><b>Format: </b><code>
 259 rshift dst(r) val(r) shift(r)
 260 </code></p>
 261 <p>
 262
 263             Performs logical right shift of register val (converted
 264             to uint32) by register shift (converted to
 265             uint32), and puts the result in register dst.
 266
 267 </p>
 268 <h2><code>bitand</code></h2>
 269 <p><b>Format: </b><code>
 270 bitand dst(r) src1(r) src2(r)
 271 </code></p>
 272 <p>
 273
 274             Computes bitwise AND of register src1 (converted to int32)
 275             and register src2 (converted to int32), and puts the result
 276             in register dst.
 277
 278 </p>
 279 <h2><code>bitxor</code></h2>
 280 <p><b>Format: </b><code>
 281 bitxor dst(r) src1(r) src2(r)
 282 </code></p>
 283 <p>
 284
 285             Computes bitwise XOR of register src1 (converted to int32)
 286             and register src2 (converted to int32), and puts the result
 287             in register dst.
 288
 289 </p>
 290 <h2><code>bitor</code></h2>
 291 <p><b>Format: </b><code>
 292 bitor dst(r) src1(r) src2(r)
 293 </code></p>
 294 <p>
 295
 296             Computes bitwise OR of register src1 (converted to int32)
 297             and register src2 (converted to int32), and puts the
 298             result in register dst.
 299
 300 </p>
 301 <h2><code>bitnot</code></h2>
 302 <p><b>Format: </b><code>
 303 bitnot dst(r) src(r)
 304 </code></p>
 305 <p>
 306
 307             Computes bitwise NOT of register src1 (converted to int32),
 308             and puts the result in register dst.
 309
 310 </p>
 311 <h2><code>not</code></h2>
 312 <p><b>Format: </b><code>
 313 not dst(r) src1(r) src2(r)
 314 </code></p>
 315 <p>
 316
 317             Computes logical NOT of register src1 (converted to
 318             boolean), and puts the result in register dst.
 319
 320 </p>
 321 <h2><code>instanceof</code></h2>
 322 <p><b>Format: </b><code>
 323 instanceof dst(r) value(r) constructor(r)
 324 </code></p>
 325 <p>
 326
 327             Tests whether register value is an instance of register
 328             constructor, and puts the boolean result in register dst.
 329
 330             Raises an exception if register constructor is not an
 331             object.
 332
 333 </p>
 334 <h2><code>typeof</code></h2>
 335 <p><b>Format: </b><code>
 336 typeof dst(r) src(r)
 337 </code></p>
 338 <p>
 339
 340             Determines the type string for src according to ECMAScript
 341             rules, and puts the result in register dst.
 342
 343 </p>
 344 <h2><code>in</code></h2>
 345 <p><b>Format: </b><code>
 346 in dst(r) property(r) base(r)
 347 </code></p>
 348 <p>
 349
 350             Tests whether register base has a property named register
 351             property, and puts the boolean result in register dst.
 352
 353             Raises an exception if register constructor is not an
 354             object.
 355
 356 </p>
 357 <h2><code>resolve</code></h2>
 358 <p><b>Format: </b><code>
 359 resolve dst(r) property(id)
 360 </code></p>
 361 <p>
 362
 363             Looks up the property named by identifier property in the
 364             scope chain, and writes the resulting value to register
 365             dst. If the property is not found, raises an exception.
 366
 367 </p>
 368 <h2><code>resolve_skip</code></h2>
 369 <p><b>Format: </b><code>
 370 resolve_skip dst(r) property(id) skip(n)
 371 </code></p>
 372 <p>
 373
 374           Looks up the property named by identifier property in the
 375           scope chain skipping the top 'skip' levels, and writes the resulting
 376           value to register dst. If the property is not found, raises an exception.
 377
 378 </p>
 379 <h2><code>get_scoped_var</code></h2>
 380 <p><b>Format: </b><code>
 381 get_scoped_var dst(r) index(n) skip(n)
 382 </code></p>
 383 <p>
 384
 385           Loads the contents of the index-th local from the scope skip nodes from
 386           the top of the scope chain, and places it in register dst
 387
 388 </p>
 389 <h2><code>put_scoped_var</code></h2>
 390 <p><b>Format: </b><code>
 391 put_scoped_var index(n) skip(n) value(r)
 392 </code></p>
 393 <p>
 394
 395
 396 </p>
 397 <h2><code>resolve_base</code></h2>
 398 <p><b>Format: </b><code>
 399 resolve_base dst(r) property(id)
 400 </code></p>
 401 <p>
 402
 403             Searches the scope chain for an object containing
 404             identifier property, and if one is found, writes it to
 405             register dst. If none is found, the outermost scope (which
 406             will be the global object) is stored in register dst.
 407
 408 </p>
 409 <h2><code>resolve_with_base</code></h2>
 410 <p><b>Format: </b><code>
 411 resolve_with_base baseDst(r) propDst(r) property(id)
 412 </code></p>
 413 <p>
 414
 415             Searches the scope chain for an object containing
 416             identifier property, and if one is found, writes it to
 417             register srcDst, and the retrieved property value to register
 418             propDst. If the property is not found, raises an exception.
 419
 420             This is more efficient than doing resolve_base followed by
 421             resolve, or resolve_base followed by get_by_id, as it
 422             avoids duplicate hash lookups.
 423
 424 </p>
 425 <h2><code>resolve_func</code></h2>
 426 <p><b>Format: </b><code>
 427 resolve_func baseDst(r) funcDst(r) property(id)
 428 </code></p>
 429 <p>
 430
 431             Searches the scope chain for an object containing
 432             identifier property, and if one is found, writes the
 433             appropriate object to use as "this" when calling its
 434             properties to register baseDst; and the retrieved property
 435             value to register propDst. If the property is not found,
 436             raises an exception.
 437
 438             This differs from resolve_with_base, because the
 439             global this value will be substituted for activations or
 440             the global object, which is the right behavior for function
 441             calls but not for other property lookup.
 442
 443 </p>
 444 <h2><code>get_by_id</code></h2>
 445 <p><b>Format: </b><code>
 446 get_by_id dst(r) base(r) property(id)
 447 </code></p>
 448 <p>
 449
 450             Converts register base to Object, gets the property
 451             named by identifier property from the object, and puts the
 452             result in register dst.
 453
 454 </p>
 455 <h2><code>put_by_id</code></h2>
 456 <p><b>Format: </b><code>
 457 put_by_id base(r) property(id) value(r)
 458 </code></p>
 459 <p>
 460
 461             Sets register value on register base as the property named
 462             by identifier property. Base is converted to object first.
 463
 464             Unlike many opcodes, this one does not write any output to
 465             the register file.
 466
 467 </p>
 468 <h2><code>del_by_id</code></h2>
 469 <p><b>Format: </b><code>
 470 del_by_id dst(r) base(r) property(id)
 471 </code></p>
 472 <p>
 473
 474             Converts register base to Object, deletes the property
 475             named by identifier property from the object, and writes a
 476             boolean indicating success (if true) or failure (if false)
 477             to register dst.
 478
 479 </p>
 480 <h2><code>get_by_val</code></h2>
 481 <p><b>Format: </b><code>
 482 get_by_val dst(r) base(r) property(r)
 483 </code></p>
 484 <p>
 485
 486             Converts register base to Object, gets the property named
 487             by register property from the object, and puts the result
 488             in register dst. property is nominally converted to string
 489             but numbers are treated more efficiently.
 490
 491 </p>
 492 <h2><code>put_by_val</code></h2>
 493 <p><b>Format: </b><code>
 494 put_by_val base(r) property(r) value(r)
 495 </code></p>
 496 <p>
 497
 498             Sets register value on register base as the property named
 499             by register property. Base is converted to object
 500             first. register property is nominally converted to string
 501             but numbers are treated more efficiently.
 502
 503             Unlike many opcodes, this one does not write any output to
 504             the register file.
 505
 506 </p>
 507 <h2><code>del_by_val</code></h2>
 508 <p><b>Format: </b><code>
 509 del_by_val dst(r) base(r) property(r)
 510 </code></p>
 511 <p>
 512
 513             Converts register base to Object, deletes the property
 514             named by register property from the object, and writes a
 515             boolean indicating success (if true) or failure (if false)
 516             to register dst.
 517
 518 </p>
 519 <h2><code>put_by_index</code></h2>
 520 <p><b>Format: </b><code>
 521 put_by_index base(r) property(n) value(r)
 522 </code></p>
 523 <p>
 524
 525             Sets register value on register base as the property named
 526             by the immediate number property. Base is converted to
 527             object first.
 528
 529             Unlike many opcodes, this one does not write any output to
 530             the register file.
 531
 532             This opcode is mainly used to initialize array literals.
 533
 534 </p>
 535 <h2><code>loop</code></h2>
 536 <p><b>Format: </b><code>
 537 loop target(offset)
 538 </code></p>
 539 <p>
 540
 541             Jumps unconditionally to offset target from the current
 542             instruction.
 543
 544             Additionally this loop instruction may terminate JS execution is
 545             the JS timeout is reached.
 546
 547 </p>
 548 <h2><code>jmp</code></h2>
 549 <p><b>Format: </b><code>
 550 jmp target(offset)
 551 </code></p>
 552 <p>
 553
 554             Jumps unconditionally to offset target from the current
 555             instruction.
 556
 557 </p>
 558 <h2><code>loop_if_true</code></h2>
 559 <p><b>Format: </b><code>
 560 loop_if_true cond(r) target(offset)
 561 </code></p>
 562 <p>
 563
 564             Jumps to offset target from the current instruction, if and
 565             only if register cond converts to boolean as true.
 566
 567             Additionally this loop instruction may terminate JS execution is
 568             the JS timeout is reached.
 569
 570 </p>
 571 <h2><code>jtrue</code></h2>
 572 <p><b>Format: </b><code>
 573 jtrue cond(r) target(offset)
 574 </code></p>
 575 <p>
 576
 577             Jumps to offset target from the current instruction, if and
 578             only if register cond converts to boolean as true.
 579
 580 </p>
 581 <h2><code>jfalse</code></h2>
 582 <p><b>Format: </b><code>
 583 jfalse cond(r) target(offset)
 584 </code></p>
 585 <p>
 586
 587             Jumps to offset target from the current instruction, if and
 588             only if register cond converts to boolean as false.
 589
 590 </p>
 591 <h2><code>loop_if_less</code></h2>
 592 <p><b>Format: </b><code>
 593 loop_if_less src1(r) src2(r) target(offset)
 594 </code></p>
 595 <p>
 596
 597             Checks whether register src1 is less than register src2, as
 598             with the ECMAScript '<' operator, and then jumps to offset
 599             target from the current instruction, if and only if the
 600             result of the comparison is true.
 601
 602             Additionally this loop instruction may terminate JS execution is
 603             the JS timeout is reached.
 604
 605 </p>
 606 <h2><code>jless</code></h2>
 607 <p><b>Format: </b><code>
 608 jless src1(r) src2(r) target(offset)
 609 </code></p>
 610 <p>
 611
 612             Checks whether register src1 is less than register src2, as
 613             with the ECMAScript '<' operator, and then jumps to offset
 614             target from the current instruction, if and only if the
 615             result of the comparison is true.
 616
 617 </p>
 618 <h2><code>jnless</code></h2>
 619 <p><b>Format: </b><code>
 620 jnless src1(r) src2(r) target(offset)
 621 </code></p>
 622 <p>
 623
 624             Checks whether register src1 is less than register src2, as
 625             with the ECMAScript '<' operator, and then jumps to offset
 626             target from the current instruction, if and only if the
 627             result of the comparison is false.
 628
 629 </p>
 630 <h2><code>switch_imm</code></h2>
 631 <p><b>Format: </b><code>
 632 switch_imm tableIndex(n) defaultOffset(offset) scrutinee(r)
 633 </code></p>
 634 <p>
 635
 636             Performs a range checked switch on the scrutinee value, using
 637             the tableIndex-th immediate switch jump table.  If the scrutinee value
 638             is an immediate number in the range covered by the referenced jump
 639             table, and the value at jumpTable[scrutinee value] is non-zero, then
 640             that value is used as the jump offset, otherwise defaultOffset is used.
 641
 642 </p>
 643 <h2><code>switch_char</code></h2>
 644 <p><b>Format: </b><code>
 645 switch_char tableIndex(n) defaultOffset(offset) scrutinee(r)
 646 </code></p>
 647 <p>
 648
 649             Performs a range checked switch on the scrutinee value, using
 650             the tableIndex-th character switch jump table.  If the scrutinee value
 651             is a single character string in the range covered by the referenced jump
 652             table, and the value at jumpTable[scrutinee value] is non-zero, then
 653             that value is used as the jump offset, otherwise defaultOffset is used.
 654
 655 </p>
 656 <h2><code>switch_string</code></h2>
 657 <p><b>Format: </b><code>
 658 switch_string tableIndex(n) defaultOffset(offset) scrutinee(r)
 659 </code></p>
 660 <p>
 661
 662             Performs a sparse hashmap based switch on the value in the scrutinee
 663             register, using the tableIndex-th string switch jump table.  If the
 664             scrutinee value is a string that exists as a key in the referenced
 665             jump table, then the value associated with the string is used as the
 666             jump offset, otherwise defaultOffset is used.
 667
 668 </p>
 669 <h2><code>new_func</code></h2>
 670 <p><b>Format: </b><code>
 671 new_func dst(r) func(f)
 672 </code></p>
 673 <p>
 674
 675             Constructs a new Function instance from function func and
 676             the current scope chain using the original Function
 677             constructor, using the rules for function declarations, and
 678             puts the result in register dst.
 679
 680 </p>
 681 <h2><code>new_func_exp</code></h2>
 682 <p><b>Format: </b><code>
 683 new_func_exp dst(r) func(f)
 684 </code></p>
 685 <p>
 686
 687             Constructs a new Function instance from function func and
 688             the current scope chain using the original Function
 689             constructor, using the rules for function expressions, and
 690             puts the result in register dst.
 691
 692 </p>
 693 <h2><code>call_eval</code></h2>
 694 <p><b>Format: </b><code>
 695 call_eval dst(r) func(r) thisVal(r) firstArg(r) argCount(n)
 696 </code></p>
 697 <p>
 698
 699             Call a function named "eval" with no explicit "this" value
 700             (which may therefore be the eval operator). If register
 701             thisVal is the global object, and register func contains
 702             that global object's original global eval function, then
 703             perform the eval operator in local scope (interpreting
 704             the argument registers as for the "call"
 705             opcode). Otherwise, act exactly as the "call" opcode would.
 706
 707 </p>
 708 <h2><code>call</code></h2>
 709 <p><b>Format: </b><code>
 710 call dst(r) func(r) thisVal(r) firstArg(r) argCount(n)
 711 </code></p>
 712 <p>
 713
 714             Perform a function call. Specifically, call register func
 715             with a "this" value of register thisVal, and put the result
 716             in register dst.
 717
 718             The arguments start at register firstArg and go up to
 719             argCount, but the "this" value is considered an implicit
 720             first argument, so the argCount should be one greater than
 721             the number of explicit arguments passed, and the register
 722             after firstArg should contain the actual first
 723             argument. This opcode will copy from the thisVal register
 724             to the firstArg register, unless the register index of
 725             thisVal is the special missing this object marker, which is
 726             2^31-1; in that case, the global object will be used as the
 727             "this" value.
 728
 729             If func is a native code function, then this opcode calls
 730             it and returns the value immediately.
 731
 732             But if it is a JS function, then the current scope chain
 733             and code block is set to the function's, and we slide the
 734             register window so that the arguments would form the first
 735             few local registers of the called function's register
 736             window. In addition, a call frame header is written
 737             immediately before the arguments; see the call frame
 738             documentation for an explanation of how many registers a
 739             call frame takes and what they contain. That many registers
 740             before the firstArg register will be overwritten by the
 741             call. In addition, any registers higher than firstArg +
 742             argCount may be overwritten. Once this setup is complete,
 743             execution continues from the called function's first
 744             argument, and does not return until a "ret" opcode is
 745             encountered.
 746
 747 </p>
 748 <h2><code>ret</code></h2>
 749 <p><b>Format: </b><code>
 750 ret result(r)
 751 </code></p>
 752 <p>
 753
 754             Return register result as the return value of the current
 755             function call, writing it into the caller's expected return
 756             value register. In addition, unwind one call frame and
 757             restore the scope chain, code block instruction pointer and
 758             register base to those of the calling function.
 759
 760 </p>
 761 <h2><code>construct</code></h2>
 762 <p><b>Format: </b><code>
 763 construct dst(r) constr(r) firstArg(r) argCount(n)
 764 </code></p>
 765 <p>
 766
 767             Invoke register "constr" as a constructor. For JS
 768             functions, the calling convention is exactly as for the
 769             "call" opcode, except that the "this" value is a newly
 770             created Object. For native constructors, a null "this"
 771             value is passed. In either case, the firstArg and argCount
 772             registers are interpreted as for the "call" opcode.
 773
 774 </p>
 775 <h2><code>push_scope</code></h2>
 776 <p><b>Format: </b><code>
 777 push_scope scope(r)
 778 </code></p>
 779 <p>
 780
 781             Converts register scope to object, and pushes it onto the top
 782             of the current scope chain.
 783
 784 </p>
 785 <h2><code>pop_scope</code></h2>
 786 <p><b>Format: </b><code>
 787 pop_scope
 788 </code></p>
 789 <p>
 790
 791             Removes the top item from the current scope chain.
 792
 793 </p>
 794 <h2><code>get_pnames</code></h2>
 795 <p><b>Format: </b><code>
 796 get_pnames dst(r) base(r)
 797 </code></p>
 798 <p>
 799
 800             Creates a property name list for register base and puts it
 801             in register dst. This is not a true JavaScript value, just
 802             a synthetic value used to keep the iteration state in a
 803             register.
 804
 805 </p>
 806 <h2><code>next_pname</code></h2>
 807 <p><b>Format: </b><code>
 808 next_pname dst(r) iter(r) target(offset)
 809 </code></p>
 810 <p>
 811
 812             Tries to copies the next name from property name list in
 813             register iter. If there are names left, then copies one to
 814             register dst, and jumps to offset target. If there are none
 815             left, invalidates the iterator and continues to the next
 816             instruction.
 817
 818 </p>
 819 <h2><code>jmp_scopes</code></h2>
 820 <p><b>Format: </b><code>
 821 jmp_scopes count(n) target(offset)
 822 </code></p>
 823 <p>
 824
 825             Removes the a number of items from the current scope chain
 826             specified by immediate number count, then jumps to offset
 827             target.
 828
 829 </p>
 830 <h2><code>catch</code></h2>
 831 <p><b>Format: </b><code>
 832 catch ex(r)
 833 </code></p>
 834 <p>
 835
 836             Retrieves the VMs current exception and puts it in register
 837             ex. This is only valid after an exception has been raised,
 838             and usually forms the beginning of an exception handler.
 839
 840 </p>
 841 <h2><code>throw</code></h2>
 842 <p><b>Format: </b><code>
 843 throw ex(r)
 844 </code></p>
 845 <p>
 846
 847             Throws register ex as an exception. This involves three
 848             steps: first, it is set as the current exception in the
 849             VM's internal state, then the stack is unwound until an
 850             exception handler or a native code boundary is found, and
 851             then control resumes at the exception handler if any or
 852             else the script returns control to the nearest native caller.
 853
 854 </p>
 855 <h2><code>new_error</code></h2>
 856 <p><b>Format: </b><code>
 857 new_error dst(r) type(n) message(k)
 858 </code></p>
 859 <p>
 860
 861             Constructs a new Error instance using the original
 862             constructor, using immediate number n as the type and
 863             constant message as the message string. The result is
 864             written to register dst.
 865
 866 </p>
 867 <h2><code>end</code></h2>
 868 <p><b>Format: </b><code>
 869 end result(r)
 870 </code></p>
 871 <p>
 872
 873             Return register result as the value of a global or eval
 874             program. Return control to the calling native code.
 875
 876 </p>
 877 <h2><code>put_getter</code></h2>
 878 <p><b>Format: </b><code>
 879 put_getter base(r) property(id) function(r)
 880 </code></p>
 881 <p>
 882
 883             Sets register function on register base as the getter named
 884             by identifier property. Base and function are assumed to be
 885             objects as this op should only be used for getters defined
 886             in object literal form.
 887
 888             Unlike many opcodes, this one does not write any output to
 889             the register file.
 890
 891 </p>
 892 <h2><code>put_setter</code></h2>
 893 <p><b>Format: </b><code>
 894 put_setter base(r) property(id) function(r)
 895 </code></p>
 896 <p>
 897
 898             Sets register function on register base as the setter named
 899             by identifier property. Base and function are assumed to be
 900             objects as this op should only be used for setters defined
 901             in object literal form.
 902
 903             Unlike many opcodes, this one does not write any output to
 904             the register file.
 905
 906 </p>
 907 <h2><code>jsr</code></h2>
 908 <p><b>Format: </b><code>
 909 jsr retAddrDst(r) target(offset)
 910 </code></p>
 911 <p>
 912
 913             Places the address of the next instruction into the retAddrDst
 914             register and jumps to offset target from the current instruction.
 915
 916 </p>
 917 <h2><code>sret</code></h2>
 918 <p><b>Format: </b><code>
 919 sret retAddrSrc(r)
 920 </code></p>
 921 <p>
 922
 923           Jumps to the address stored in the retAddrSrc register. This
 924           differs from op_jmp because the target address is stored in a
 925           register, not as an immediate.
 926
 927 </p>
 928 <h2><code>debug</code></h2>
 929 <p><b>Format: </b><code>
 930 debug debugHookID(n) firstLine(n) lastLine(n)
 931 </code></p>
 932 <p>
 933
 934           Notifies the debugger of the current state of execution. This opcode
 935           is only generated while the debugger is attached.
 936
 937 </p>