/* 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 "Heap-inl.h"

using namespace ke;

OpInfo ke::OpcodeInfo[] =

{

#define OPDEF(name, number, 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, unsigned maxStackDepth, Handle<Module> module,

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

          unsigned lineNumber)

{

    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_ = module;

    code->safepoints_ = safepoints;

    code->sourcemap_ = sourcemap;

    code->lineNumber_ = lineNumber;

    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.

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

    assert(op == OP_CALL || op == OP_NEWARRAY || op == OP_VARREF_LIFO ||

           op == OP_ARGREF_LIFO || op == OP_SLOTREF_LIFO || op == OP_ARRAYREF_LIFO ||

           op == OP_ARRAYCOPY);

    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_JL_LENGTH == OP_JUMP_LENGTH);

STATIC_ASSERT(OP_JLE_LENGTH == OP_JUMP_LENGTH);

STATIC_ASSERT(OP_JG_LENGTH == OP_JUMP_LENGTH);

STATIC_ASSERT(OP_JGE_LENGTH == OP_JUMP_LENGTH);

STATIC_ASSERT(OP_JEQ_LENGTH == OP_JUMP_LENGTH);

STATIC_ASSERT(OP_JNE_LENGTH == OP_JUMP_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_POP:

          case OP_GETARRAY_I:

          case OP_SETARRAY_I:

          case OP_GETARRAY_F:

          case OP_SETARRAY_F:

          case OP_GETARRAY_C:

          case OP_SETARRAY_C:

          case OP_GETARRAY_O:

          case OP_BOUNDS:

          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_ARRAYREF_LIFO:

          case OP_ARRAYCOPY:

          case OP_DUP:

          case OP_DUP2:

          case OP_SWAP:

          case OP_ROLL3:

          case OP_PICK2:

          case OP_PICK3:

          case OP_CALL:

          case OP_MODULE:

          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:

            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_JL:

          case OP_JLE:

          case OP_JG:

          case OP_JGE:

          case OP_JEQ:

          case OP_JNE:

          case OP_JT:

          case OP_JF:

          case OP_JL_F:

          case OP_JLE_F:

          case OP_JG_F:

          case OP_JGE_F:

          case OP_JEQ_F:

          case OP_JNE_F:

          case OP_JT_F:

          case OP_JF_F:

          case OP_JUMP:

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

            break;

          case OP_NEWARRAY:

          {

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

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

            fprintf(fp, "%s:", map->type()->innermost()->tag()

                               ? map->type()->innermost()->tag()->chars()

                               : "_");

            for (; map; map = map->contained()) {

                Type *type = map->type();

                fprintf(fp, "[%d]", type->elements());

            }

            if (tenure == Heap::Tenure_Stack)

                fprintf(fp, " ; lifo");

            else if (tenure == Heap::Tenure_Old)

                fprintf(fp, " ; pretenured");

            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_GETMODULE_FN:

          case OP_GETGLOBAL_I:

          case OP_GETGLOBAL_F:

          case OP_GETGLOBAL_O:

          case OP_SETGLOBAL_I:

          case OP_SETGLOBAL_F:

          case OP_SETGLOBAL_O:

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

            break;

          case OP_CALLNATIVE:

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

            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");

        }

    }

}