sourcepawn2: src/Opcodes.cpp@10936f3a2ba3

     1 /* vim: set ts=4 sw=4 tw=99 et:

     2  *

     3  * Copyright (C) 2012 David Anderson

     4  *

     5  * This file is part of JITCraft.

     6  *

     7  * JITCraft is free software: you can redistribute it and/or modify it under

     8  * the terms of the GNU General Public License as published by the Free

     9  * Software Foundation, either version 3 of the License, or (at your option)

    10  * any later version.

    11  *

    12  * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

    13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    14  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

    15  *

    16  * You should have received a copy of the GNU General Public License along with

    17  * JITCraft. If not, see http://www.gnu.org/licenses/.

    18  */

    19 #include <stdlib.h>

    20 #include "Opcodes.h"

    21 #include "Utility.h"

    22 #include "Code.h"

    23 #include "Zone.h"

    24 #include "Array.h"

    25 #include "Strings.h"

    26 #include "CompactBuffer.h"

    27 #include "Structures.h"

    28 #include "Heap-inl.h"

    30 using namespace ke;

    32 OpInfo ke::OpcodeInfo[] =

    33 {

    34 #define OPDEF(name, number, text, length, uses, defs) \

    35     {text, length, uses, defs},

    36 #include "Opcodes.tbl"

    37 #undef OPDEF

    38 };

    40 Code *

    41 Code::New(Zone *zone, Handle<ByteArray> bytecode, Handle<FixedArray> locals,

    42           Handle<FixedArray> objects, unsigned maxStackDepth, Handle<Module> module,

    43 	      Handle<ByteArray> safepoints, Handle<ByteArray> sourcemap,

    44           unsigned lineNumber)

    45 {

    46     Local<Code> code(zone, Code::cast(zone->allocate(MapKind_Code, sizeof(Code), Heap::Tenure_Old)));

    47     if (!code)

    48         return NULL;

    50     code->bytecode_ = bytecode;

    51     code->locals_ = locals;

    52     code->objects_ = objects;

    53     code->maxStackDepth_ = maxStackDepth;

    54     code->module_ = module;

    55     code->safepoints_ = safepoints;

    56     code->sourcemap_ = sourcemap;

    57     code->lineNumber_ = lineNumber;

    58     return code;

    59 }

    61 static int

    62 CompareSafepoints(const void *a, const void *b)

    63 {

    64     const unsigned *sa = reinterpret_cast<const unsigned *>(a);

    65     const unsigned *sb = reinterpret_cast<const unsigned *>(b);

    66     if (*sa > *sb)

    67         return 1;

    68     if (*sa == *sb)

    69         return 0;

    70     return -1;

    71 }

    73 uint8 *

    74 Code::safepointAt(unsigned pcOffset)

    75 {

    76     // Only specific opcodes may have safepoints. Asking for a safepoint at

    77     // any other position indicates a failure to mark that position as a

    78     // safepoint, which is a bug.

    79 #ifndef NDEBUG

    80     Opcode op = Opcode(*(start() + pcOffset));

    81     assert(op == OP_CALL ||

    82            op == OP_NEWFIXED ||

    83            op == OP_NEWEMPTY ||

    84            op == OP_NEWSIZED ||

    85            op == OP_VARREF_LIFO ||

    86            op == OP_ARGREF_LIFO ||

    87            op == OP_SLOTREF_LIFO ||

    88            op == OP_ARRAYREF_LIFO ||

    89            op == OP_COPYARRAY);

    90 #endif

    92     if (!safepoints_)

    93         return NULL;

    95     size_t bytesPerSafepoint = BytesPerSafepoint(maxStackDepth());

    96     assert(!(safepoints_->length() % bytesPerSafepoint));

    98     size_t count = safepoints_->length() / bytesPerSafepoint;

   100     void *result = bsearch(&pcOffset,

   101                            safepoints_->raw(),

   102                            count,

   103                            bytesPerSafepoint,

   104                            CompareSafepoints);

   106     if (!result)

   107         return NULL;

   109     assert(*reinterpret_cast<unsigned *>(result) == pcOffset);

   111     return Address(result) + sizeof(unsigned);

   112 }

   114 SourcePosition

   115 Code::pcToSource(unsigned pc)

   116 {

   117     assert(pc < bytecode_->length());

   119     CompactBufferReader reader(sourcemap_->raw(), sourcemap_->raw() + sourcemap_->length());

   121     unsigned line = 1;

   122     unsigned col = 0;

   123     unsigned curPc = 0;

   124     while (!reader.done()) {

   125         curPc += reader.readUint32();

   126         if (curPc > pc)

   127             break;

   129         line = reader.readUint32();

   130         col = reader.readUint32();

   131     }

   133     return SourcePosition(lineNumber_ + line, col);

   134 }

   136 // All jumps must be the same length.

   137 STATIC_ASSERT(OP_JL_LENGTH == OP_JUMP_LENGTH);

   138 STATIC_ASSERT(OP_JLE_LENGTH == OP_JUMP_LENGTH);

   139 STATIC_ASSERT(OP_JG_LENGTH == OP_JUMP_LENGTH);

   140 STATIC_ASSERT(OP_JGE_LENGTH == OP_JUMP_LENGTH);

   141 STATIC_ASSERT(OP_JEQ_LENGTH == OP_JUMP_LENGTH);

   142 STATIC_ASSERT(OP_JNE_LENGTH == OP_JUMP_LENGTH);

   143 STATIC_ASSERT(OP_JT_LENGTH == OP_JUMP_LENGTH);

   144 STATIC_ASSERT(OP_JF_LENGTH == OP_JUMP_LENGTH);

   146 void

   147 ke::Disassemble(Code *code, FILE *fp)

   148 {

   149     bytecode *pc = code->start();

   150     for (;;) {

   151         Opcode op = Opcode(*pc);

   153         fprintf(fp, "%-4d %s ", int(pc - code->start()), OpcodeInfo[op].name);

   155         switch (op) {

   156           case OP_NOP:

   157           case OP_RETURN:

   158           case OP_RETURNVOID:

   159           case OP_ADD:

   160           case OP_SUB:

   161           case OP_MUL:

   162           case OP_DIV:

   163           case OP_ADD_F:

   164           case OP_SUB_F:

   165           case OP_MUL_F:

   166           case OP_DIV_F:

   167           case OP_CVT_I2F:

   168           case OP_POP:

   169           case OP_GETELEM:

   170           case OP_SETELEM:

   171           case OP_SHL:

   172           case OP_SHR:

   173           case OP_USHR:

   174           case OP_BITAND:

   175           case OP_BITOR:

   176           case OP_BITXOR:

   177           case OP_GETREF_I:

   178           case OP_SETREF_I:

   179           case OP_GETREF_F:

   180           case OP_SETREF_F:

   181           case OP_SLOTREF_LIFO:

   182           case OP_ARRAYREF_LIFO:

   183           case OP_COPYARRAY:

   184           case OP_COPYSTRUCT:

   185           case OP_DUP:

   186           case OP_DUP2:

   187           case OP_SWAP:

   188           case OP_ROLL3:

   189           case OP_PICK2:

   190           case OP_PICK3:

   191           case OP_CALL:

   192           case OP_MODULE:

   193           case OP_LT:

   194           case OP_LE:

   195           case OP_GE:

   196           case OP_GT:

   197           case OP_EQ:

   198           case OP_NE:

   199           case OP_LT_F:

   200           case OP_LE_F:

   201           case OP_GE_F:

   202           case OP_GT_F:

   203           case OP_EQ_F:

   204           case OP_NE_F:

   205           case OP_BITNOT:

   206           case OP_NOT:

   207           case OP_NOT_F:

   208           case OP_NEG:

   209           case OP_NEG_F:

   210           case OP_MOD:

   211           case OP_BITS_I2F:

   212           case OP_BITS_F2I:

   213           case OP_TRUE:

   214           case OP_FALSE:

   215             break;

   217           case OP_STOP:

   218             fprintf(fp, "\n");

   219             break;

   221           case OP_INT:

   222             fprintf(fp, "%d", READ_INT32(pc));

   223             break;

   225           case OP_FLOAT:

   226             fprintf(fp, "%f", READ_FLOAT(pc));

   227             break;

   229           case OP_JL:

   230           case OP_JLE:

   231           case OP_JG:

   232           case OP_JGE:

   233           case OP_JEQ:

   234           case OP_JNE:

   235           case OP_JT:

   236           case OP_JF:

   237           case OP_JL_F:

   238           case OP_JLE_F:

   239           case OP_JG_F:

   240           case OP_JGE_F:

   241           case OP_JEQ_F:

   242           case OP_JNE_F:

   243           case OP_JT_F:

   244           case OP_JF_F:

   245           case OP_JUMP:

   246             fprintf(fp, "%u (%+d)", unsigned((pc + READ_INT32(pc)) - code->start()), READ_INT32(pc));

   247             break;

   249           case OP_NEWFIXED:

   250           case OP_NEWEMPTY:

   251           case OP_NEWSIZED:

   252           {

   253             Heap::Tenure tenure = (Heap::Tenure)pc[1];

   254             //ArrayMap *map = ArrayMap::cast(code->map(READ_UINT32(pc + 1)));

   255             if (tenure == Heap::Tenure_Stack)

   256                 fprintf(fp, " ; lifo");

   257             else if (tenure == Heap::Tenure_Old)

   258                 fprintf(fp, " ; pretenured");

   259             else if (tenure == Heap::Tenure_Default)

   260                 fprintf(fp, " ; newborn");

   261             break;

   262           }

   264           case OP_NEWSTRUCT:

   265           {

   266             Heap::Tenure tenure = (Heap::Tenure)pc[1];

   267             StructMap *map = StructMap::cast(code->map(READ_UINT32(pc + 1)));

   268             fprintf(fp, "%s", map->type()->name()->chars());

   269             if (tenure == Heap::Tenure_Stack)

   270                 fprintf(fp, " ; lifo");

   271             else if (tenure == Heap::Tenure_Old)

   272                 fprintf(fp, " ; pretenured");

   273             else if (tenure == Heap::Tenure_Default)

   274                 fprintf(fp, " ; newborn");

   275             break;

   276           }

   278           case OP_GETLOCAL:

   279           case OP_SETLOCAL:

   280           case OP_GETARG:

   281           case OP_SETARG:

   282           case OP_SAVELIFO:

   283           case OP_UNWINDLIFO:

   284           case OP_VARREF_LIFO:

   285           case OP_ARGREF_LIFO:

   286           case OP_OBJECT:

   287           case OP_GETMODULE_FN:

   288           case OP_GETGLOBAL_I:

   289           case OP_GETGLOBAL_F:

   290           case OP_GETGLOBAL_O:

   291           case OP_SETGLOBAL_I:

   292           case OP_SETGLOBAL_F:

   293           case OP_SETGLOBAL_O:

   294           case OP_GETFIELD:

   295           case OP_SETFIELD:

   296           case OP_FIELDREF_LIFO:

   297             fprintf(fp, "%u", READ_UINT32(pc));

   298             break;

   300           case OP_CALLNATIVE:

   301             fprintf(fp, "%u %u", READ_UINT32(pc), READ_UINT32(pc + 4));

   302             break;

   304           case OP_TABLESWITCH:

   305           {

   306             int low = READ_TABLESWITCH_LOW(pc);

   307             int high = READ_TABLESWITCH_HIGH(pc);

   308             fprintf(fp, "%d, %d\n", low, high);

   309             break;

   310           }

   312           default:

   313             // Unknown opcode!

   314             assert(false);

   315             return;

   316         }

   318         if (op == OP_STOP)

   319             break;

   321         fprintf(fp, "\n");

   322         pc += OpcodeInfo[op].length;

   323         assert(pc < code->start() + code->length());

   324     }

   326     fprintf(fp, "\nSafepoints:\n");

   327     ByteArray *safepoints = code->safepoints();

   328     if (safepoints) {

   329         size_t nsafepoints = safepoints->length() / Code::BytesPerSafepoint(code->maxStackDepth());

   330         for (size_t i = 0; i < nsafepoints; i++) {

   331             Address address = safepoints->raw() + Code::BytesPerSafepoint(code->maxStackDepth()) * i;

   332             fprintf(fp, "%4d: ", *reinterpret_cast<unsigned *>(address));

   333             unsigned char *bits = (unsigned char *)(address + sizeof(unsigned));

   334             for (unsigned j = 0; j < code->maxStackDepth(); j++) {

   335                 if (bits[j / 8] & (1 << (j % 8)))

   336                     fprintf(fp, "%d ", j);

   337             }

   338             fprintf(fp, "\n");

   339         }

   340     }

   341 }

author	David Anderson <dvander@alliedmods.net>
	Sat Sep 15 18:25:54 2012 -0700 (2012-09-15)
changeset 185	10936f3a2ba3
parent 182	c52ca323063f
child 188	bab29bcec7fe
permissions	-rw-r--r--