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

  *

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of JITCraft.

  *

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

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

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

  * any later version.

  * 

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

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

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

  *

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

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

  */

 #include <stdlib.h>

 #include "Opcodes.h"

 #include "Utility.h"

 #include "Code.h"

 #include "Zone.h"

 #include "Array.h"

 #include "Strings.h"

 #include "CompactBuffer.h"

 #include "Structures.h"

 #include "Heap-inl.h"

 using namespace ke;

 OpInfo ke::OpcodeInfo[] =

 {

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

     {text, length, uses, defs},

 #include "Opcodes.tbl"

 #undef OPDEF

 };

 Code *

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

           Handle<FixedArray> objects, Handle<FixedArray> strings, unsigned maxStackDepth,

           unsigned maxLoopDepth, Handle<ByteArray> safepoints, Handle<ByteArray> sourcemap)

 {

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

     if (!code)

         return NULL;

     code->bytecode_ = bytecode;

     code->locals_ = locals;

     code->objects_ = objects;

     code->maxStackDepth_ = maxStackDepth;

     code->module_ = NULL;

     code->safepoints_ = safepoints;

     code->sourcemap_ = sourcemap;

     code->lineNumber_ = 0;

     code->strings_ = strings;

     code->maxLoopDepth_ = maxLoopDepth;

     return code;

 }

 static int

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

 {

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

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

     if (*sa > *sb)

         return 1;

     if (*sa == *sb)

         return 0;

     return -1;

 }

 uint8 *

 Code::safepointAt(unsigned pcOffset)

 {

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

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

     // safepoint, which is a bug.

 #ifndef NDEBUG

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

     assert(op == OP_CALL ||

            op == OP_NEWFIXED ||

            op == OP_NEWEMPTY ||

            op == OP_NEWSIZED ||

            op == OP_VARREF_LIFO ||

            op == OP_ARGREF_LIFO ||

            op == OP_SLOTREF_LIFO ||

            op == OP_COPYARRAY ||

            op == OP_CALLNATIVE ||

            op == OP_PUBLIC);

 #endif

     if (!safepoints_)

         return NULL;

     size_t bytesPerSafepoint = BytesPerSafepoint(maxStackDepth());

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

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

     void *result = bsearch(&pcOffset,

                            safepoints_->raw(),

                            count,

                            bytesPerSafepoint,

                            CompareSafepoints);

     if (!result)

         return NULL;

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

     return Address(result) + sizeof(unsigned);

 }

 SourcePosition

 Code::pcToSource(unsigned pc)

 {

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

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

     unsigned line = 1;

     unsigned col = 0;

     unsigned curPc = 0;

     while (!reader.done()) {

         curPc += reader.readUint32();

         if (curPc > pc)

             break;

         line = reader.readUint32();

         col = reader.readUint32();

     }

     return SourcePosition(lineNumber_ + line, col);

 }

 // All jumps must be the same length.

 STATIC_ASSERT(OP_JT_LENGTH == OP_JUMP_LENGTH);

 STATIC_ASSERT(OP_JF_LENGTH == OP_JUMP_LENGTH);

 void

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

 {

     bytecode *pc = code->start();

     for (;;) {

         Opcode op = Opcode(*pc);

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

         switch (op) {

           case OP_NOP:

           case OP_RETURN:

           case OP_RETURNVOID:

           case OP_ADD:

           case OP_SUB:

           case OP_MUL:

           case OP_DIV:

           case OP_ADD_F:

           case OP_SUB_F:

           case OP_MUL_F:

           case OP_DIV_F:

           case OP_CVT_I2F:

           case OP_CVT_I2B:

           case OP_POP:

           case OP_GETELEM:

           case OP_SETELEM:

           case OP_SHL:

           case OP_SHR:

           case OP_USHR:

           case OP_BITAND:

           case OP_BITOR:

           case OP_BITXOR:

           case OP_GETREF_I:

           case OP_SETREF_I:

           case OP_GETREF_F:

           case OP_SETREF_F:

           case OP_SLOTREF_LIFO:

           case OP_COPYARRAY:

           case OP_COPYSTRUCT:

           case OP_DUP:

           case OP_DUP2:

           case OP_SWAP:

           case OP_ROLL3:

           case OP_PICK2:

           case OP_PICK3:

           case OP_CALL:

           case OP_LT:

           case OP_LE:

           case OP_GE:

           case OP_GT:

           case OP_EQ:

           case OP_NE:

           case OP_LT_F:

           case OP_LE_F:

           case OP_GE_F:

           case OP_GT_F:

           case OP_EQ_F:

           case OP_NE_F:

           case OP_BITNOT:

           case OP_NOT:

           case OP_NOT_F:

           case OP_NEG:

           case OP_NEG_F:

           case OP_MOD:

           case OP_BITS_I2F:

           case OP_BITS_F2I:

           case OP_TRUE:

           case OP_FALSE:

           case OP_SIZEOF:

           case OP_PUBLIC:

           case OP_LEAVELOOP:

           case OP_DUPARRAY:

             break;

           case OP_ENTERLOOP:

             if (pc[1])

               fprintf(fp, "; lifo region");

             break;

           case OP_STOP:

             fprintf(fp, "\n");

             break;

           case OP_INT:

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

             break;

           case OP_FLOAT:

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

             break;

           case OP_JT:

           case OP_JF:

           case OP_JUMP:

           case OP_CONTINUE:

           case OP_BREAK:

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

             break;

           case OP_NEWFIXED:

           case OP_NEWEMPTY:

           case OP_NEWSIZED:

           {

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

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

             if (tenure == Heap::Tenure_Stack)

                 fprintf(fp, " ; lifo");

             else if (tenure == Heap::Tenure_Old)

                 fprintf(fp, " ; pretenured");

             else if (tenure == Heap::Tenure_Default)

                 fprintf(fp, " ; newborn");

             break;

           }

           case OP_NEWSTRUCT:

           {

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

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

             fprintf(fp, "%s", StructType::cast(map->type())->name()->chars());

             if (tenure == Heap::Tenure_Stack)

                 fprintf(fp, " ; lifo");

             else if (tenure == Heap::Tenure_Old)

                 fprintf(fp, " ; pretenured");

             else if (tenure == Heap::Tenure_Default)

                 fprintf(fp, " ; newborn");

             break;

           }

           case OP_GETLOCAL:

           case OP_SETLOCAL:

           case OP_GETARG:

           case OP_SETARG:

           case OP_SAVELIFO:

           case OP_UNWINDLIFO:

           case OP_VARREF_LIFO:

           case OP_ARGREF_LIFO:

           case OP_OBJECT:

           case OP_GETFIELD:

           case OP_SETFIELD:

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

             break;

           case OP_CALLNATIVE:

           {

             unsigned argc = READ_UINT32(pc);

             fprintf(fp, " ; %u args", argc);

             break;

           }

           case OP_TABLESWITCH:

           {

             int low = READ_TABLESWITCH_LOW(pc);

             int high = READ_TABLESWITCH_HIGH(pc);

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

             break;

           }

           case OP_GETGLOBAL:

           case OP_SETGLOBAL:

           {

             unsigned index = READ_UINT32(pc);

             fprintf(fp, "%s", String::cast(code->strings()->at(index))->chars());

             break;

           }

           default:

             // Unknown opcode!

             assert(false);

             return;

         }

         if (op == OP_STOP)

             break;

         fprintf(fp, "\n");

         pc += OpcodeInfo[op].length;

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

     }

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

     ByteArray *safepoints = code->safepoints();

     if (safepoints) {

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

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

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

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

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

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

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

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

             }

             fprintf(fp, "\n");

         }

     }

 }