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

#include "BytecodeEmitter.h"

#include "../Heap-inl.h"

#include "../Handles-inl.h"

using namespace ke;

class HIRTranslator : public HIRVisitor

{

  public:

    HIRTranslator(Zone *zone, BytecodeEmitter &emitter)

      : zone_(zone),

        emitter_(emitter)

    {

    }

    void translate(HIR *hir) {

        hir->accept(this);

    }

    void visitFloat(HFloat *hir);

    void visitInteger(HInteger *hir);

    void visitCall(HCall *call);

    void visitStore(HStore *store);

    void visitBinary(HBinary *binary);

    void visitLocal(HLocal *local);

    void visitGlobal(HGlobal *global);

    void visitConvert(HConvert *convert);

    void visitIndex(HIndex *index);

  private:

    Zone *zone_;

    BytecodeEmitter &emitter_;

};

#define __ emitter_.

void

HIRTranslator::visitFloat(HFloat *hir)

{

    __ float_(hir->value());

}

void

HIRTranslator::visitInteger(HInteger *hir)

{

    __ int_(hir->value());

}

void

HIRTranslator::visitCall(HCall *call)

{

    Local<FunctionType> fun(zone_, FunctionType::cast(call->callee()->type()));

    assert(call->args()->length() == fun->parameters()->length());

    unsigned argc = call->args()->length();

    for (size_t i = call->args()->length() - 1; i < call->args()->length(); i--) {

        HIR *hir = call->args()->at(i);

        hir->accept(this);

    }

    call->callee()->accept(this);

    __ call(fun, argc);

}

void

HGlobal::bind(HIRVisitor *visitor, BytecodeEmitter &emitter_)

{

}

void

HGlobal::hold(BytecodeEmitter &emitter_)

{

}

void

HGlobal::store(BytecodeEmitter &emitter_)

{

    __ setglobal(sym_);

}

void

HGlobal::load(BytecodeEmitter &emitter_)

{

    __ getglobal(sym_);

}

void

HLocal::bind(HIRVisitor *visitor, BytecodeEmitter &emitter_)

{

    if (sym_->type()->isReference())

        __ getlocal(sym_);

}

void

HLocal::hold(BytecodeEmitter &emitter_)

{

    if (sym_->type()->isReference())

        __ dup();

}

void

HLocal::store(BytecodeEmitter &emitter_)

{

    if (sym_->type()->isReference())

        __ setref(sym_->type()->contained_ref());

    else

        __ setlocal(sym_);

}

void

HLocal::load(BytecodeEmitter &emitter_)

{

    if (sym_->type()->isReference())

        __ getref(sym_->type());

    else

        __ getlocal(sym_);

}

void

HIndex::bind(HIRVisitor *visitor, BytecodeEmitter &emitter_)

{

    left_->accept(visitor);

    right_->accept(visitor);

}

void

HIndex::hold(BytecodeEmitter &emitter_)

{

    __ dup2();

}

void

HIndex::store(BytecodeEmitter &emitter_)

{

    __ setelem(type());

}

void

HIndex::load(BytecodeEmitter &emitter_)

{

    __ getelem(type());

}

void

HIRTranslator::visitLocal(HLocal *local)

{

    local->bind(this, emitter_);

    local->load(emitter_);

}

void

HIRTranslator::visitIndex(HIndex *index)

{

    index->bind(this, emitter_);

    index->load(emitter_);

}

void

HIRTranslator::visitGlobal(HGlobal *global)

{

    __ getglobal(global->sym());

}

static inline Opcode

TokenToOpcode(TokenKind kind)

{

    switch (kind) {

      case TOK_PLUS:

      case TOK_ASSIGN_ADD:

        return OP_ADD;

      case TOK_MINUS:

      case TOK_ASSIGN_SUB:

        return OP_SUB;

      case TOK_STAR:

      case TOK_ASSIGN_MUL:

        return OP_MUL;

      case TOK_SLASH:

      case TOK_ASSIGN_DIV:

        return OP_DIV;

      case TOK_PERCENT:

      case TOK_ASSIGN_MOD:

        return OP_MOD;

      case TOK_SHR:

      case TOK_ASSIGN_SHR:

        return OP_SHR;

      case TOK_USHR:

      case TOK_ASSIGN_USHR:

        return OP_USHR;

      case TOK_SHL:

      case TOK_ASSIGN_SHL:

        return OP_SHL;

      case TOK_BITAND:

      case TOK_ASSIGN_BITAND:

        return OP_BITAND;

      case TOK_BITOR:

      case TOK_ASSIGN_BITOR:

        return OP_BITOR;

      case TOK_GT:

          return OP_GT;

      case TOK_GE:

          return OP_GE;

      case TOK_LT:

          return OP_LT;

      case TOK_LE:

          return OP_LE;

      case TOK_EQUALS:

          return OP_EQ;

      case TOK_NOTEQUALS:

          return OP_NE;

      default:

        assert(kind == TOK_BITXOR);

        return OP_BITXOR;

    }

}

void

HIRTranslator::visitStore(HStore *store)

{

    store->lval()->bind(this, emitter_);

    if (store->kind() == TOK_ASSIGN) {

        store->rval()->accept(this);

    } else {

        // Advanced case: dup the ref, load, op, store.

        store->lval()->hold(emitter_);

        store->lval()->load(emitter_);

        store->rval()->accept(this);

        __ binary(TokenToOpcode(store->kind()));

    }

    store->lval()->store(emitter_);

}

void

HIRTranslator::visitBinary(HBinary *binary)

{

    binary->left()->accept(this);

    binary->right()->accept(this);

    // We define three sets of math operators:

    //

    //  (1) ADD, SUB, MUL, DIV, MOD, which take two equal types and produce

    //      the same type.

    //  (2) LT, LE, GE, GT, EQ, NE, which take two equal types and produce

    //      a boolean.

    //  (3) SHL, SR, USHR, BITAND, BITOR, BITXOR, BITNOT, which take two

    //      equal integer types and return that integer type.

    //

    Opcode op = TokenToOpcode(binary->token());

    if (op >= OP_ADD && op <= OP_NE) {

        if (binary->type()->isFloat())

            op = Opcode(int(op) + int(OP_ADD_F - OP_ADD));

    } else {

        assert(binary->type()->isInt32());

    }

    __ binary(op);

}

void

HIRTranslator::visitConvert(HConvert *convert)

{

    convert->in()->accept(this);

    __ unary(convert->opcode());

}

void

ke::EmitHIR(Zone *zone, BytecodeEmitter &emitter, HIR *hir)

{

    HIRTranslator translator(zone, emitter);

    translator.translate(hir);

}