/*

  * 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/.

  */

 #ifndef _include_bytecode_emitter_h_

 #define _include_bytecode_emitter_h_

 #include <assert.h>

 #include <limits.h>

 #include "Opcodes.h"

 namespace jc {

 class Type;

 class BytecodeEmitter

 {

     bytecode *buffer_;

     bytecode *buffer_pos_;

     bytecode *buffer_end_;

     bytecode inline_buffer_[512];

     bool oom_;

     unsigned maxStackDepth_;

     unsigned stackDepth_;

   private:

     static const size_t MAX_LENGTH = INT_MAX / 2;

   private:

     bool growBuffer(size_t bytes);

     // Checking the return value is not necessary, since the inline buffer is

     // used as a ballast.

     bool ensure(size_t bytes) {

         if (buffer_pos_ + bytes > buffer_end_)

             return growBuffer(bytes);

         return true;

     }

     void writeUint8(unsigned value) {

         assert(value >= 0 && value <= UCHAR_MAX);

         *buffer_pos_++ = value;

     }

     void writeInt32(int value) {

         *(int *)buffer_pos_ = value;

         buffer_pos_ += sizeof(int);

     }

     void writeUint32(unsigned value) {

         *(unsigned *)buffer_pos_ = value;

         buffer_pos_ += sizeof(unsigned);

     }

     void writeOp(Opcode op) {

         writeUint8(op);

         stackDepth_ += OpcodeInfo[op].ndefs;

         if (OpcodeInfo[op].nuses != -1)

             stackDepth_ -= OpcodeInfo[op].nuses;

         if (stackDepth_ > maxStackDepth_)

             maxStackDepth_ = stackDepth_;

     }

     int position() const {

         assert(buffer_pos_ - buffer_ < INT_MAX / 2);

         return int(buffer_pos_ - buffer_);

     }

   public:

     BytecodeEmitter();

     bytecode *buffer() const {

         return buffer_;

     }

     unsigned length() const {

         return unsigned(buffer_pos_ - buffer_);

     }

     bool oom() const {

         return oom_;

     }

     unsigned stackDepth() const {

         return stackDepth_;

     }

     unsigned maxStackDepth() const {

         return maxStackDepth_;

     }

   public:

     // A label represents a local control-flow target in the bytecode. A label

     // may be in three states:

     //

     // (1) Empty - the label is not used yet.

     // (2) Pending - the label has incoming jumps, but the actual location of

     //               is not yet known. The list of jumps is threaded through

     //               the four bytes reserved for each emitted jump target. In

     //               this case, the offset field is the location of the most

     //               recently emitted incoming jump.

     // (3) Bound   - the label's position has been pinned.

     //

     // A jump can be emitted to a label in any state. Binding a label

     // immediately backpatches all pending incoming jumps. A label must be

     // bound if it is used.

     class Label

     {

         int offset_ : 31;

         bool bound_ : 1;

         void setOffset(int offset) {

             offset_ = offset;

             assert(offset_ == offset);

         }

       public:

         static const int INVALID_OFFSET = -1;

       public:

         Label()

           : offset_(INVALID_OFFSET),

             bound_(false)

         {

         }

         ~Label()

         {

             assert(bound_ || offset_ == INVALID_OFFSET);

         }

         bool bound() const {

             return bound_;

         }

         int offset() const {

             return offset_;

         }

         void bind(int offset) {

             assert(!bound_);

             setOffset(offset);

             bound_ = true;

         }

         int link(int offset) {

             assert(!bound_);

             int old = offset_;

             setOffset(offset);

             return old;

         }

     };

   private:

     int patchJumpAt(int at, int to) {

         assert(at >= 0 && at < position());

         int old = *(int *)(buffer_ + at + 1);

         *(int *)(buffer_ + at + 1) = (to - at);

         return old;

     }

     void singleByteOp(Opcode op) {

         assert(OpcodeInfo[op].length == 1);

         ensure(OpcodeInfo[op].length);

         writeOp(op);

     }

   public:

     void int_(int value) {

         ensure(OP_INT);

         writeOp(OP_INT);

         writeInt32(value);

     }

     void return_() {

         ensure(OP_RETURN);

         writeOp(OP_RETURN);

     }

     void getlocal(unsigned local) {

         ensure(OP_GETLOCAL_LENGTH);

         writeOp(OP_GETLOCAL);

         writeUint32(local);

     }

     void setlocal(unsigned local) {

         ensure(OP_SETLOCAL_LENGTH);

         writeOp(OP_SETLOCAL);

         writeUint32(local);

     }

     void getarg(unsigned slot) {

         ensure(OP_GETARG_LENGTH);

         writeOp(OP_GETARG);

         writeUint32(slot);

     }

     void setarg(unsigned slot) {

         ensure(OP_SETARG_LENGTH);

         writeOp(OP_SETARG);

         writeUint32(slot);

     }

     void j(Opcode op, Label *label) {

         // Since jumps can skip around the stream, do not try to do anything

         // in a potentially truncated state.

         if (oom())

             return;

         assert(op >= OP_JL && op <= OP_JUMP);

         ensure(OP_JUMP_LENGTH);

         if (label->bound()) {

             // We can immediately emit this jump.

             int distance = label->offset() - position();

             writeOp(op);

             writeInt32(distance);

         } else {

             // We can't emit this jump yet. Add a placeholder.

             int old = label->link(position());

             writeOp(op);

             writeInt32(old);

         }

     }

     void bind(Label *label) {

         if (oom())

             return;

         assert(!label->bound());

         int offset = label->offset();

         while (offset != Label::INVALID_OFFSET)

             offset = patchJumpAt(offset, position());

         label->bind(position());

     }

     void jump(Label *label) {

         j(OP_JUMP, label);

     }

     void binary(Opcode op) {

         singleByteOp(op);

     }

     void pop() {

         singleByteOp(OP_POP);

     }

     void stop() {

         singleByteOp(OP_STOP);

     }

     void callglobal(unsigned nargs, unsigned index) {

         ensure(OP_CALLGLOBAL_LENGTH);

         writeOp(OP_CALLGLOBAL);

         writeUint32(nargs);

         writeUint32(index);

         stackDepth_ -= nargs;

     }

     void ld_sta_i() {

         singleByteOp(OP_LD_STA_I);

     }

     void st_sta_i() {

         singleByteOp(OP_ST_STA_I);

     }

     void ld_sta_p() {

         singleByteOp(OP_LD_STA_P);

     }

     void stackarray(Type *type);

     void bounds_sta() {

         singleByteOp(OP_BOUNDS_STA);

     }

 };

 }

 #endif // _include_bytecode_emitter_h_