/*

 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.

 * Copyright 2009, 2010 Red Hat, Inc.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

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

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "oops/arrayOop.hpp"

#include "oops/oop.hpp"

#include "shark/llvmHeaders.hpp"

#include "shark/sharkContext.hpp"

#include "utilities/globalDefinitions.hpp"

#include "memory/allocation.hpp"

using namespace llvm;

SharkContext::SharkContext(const char* name)

  : LLVMContext(),

    _free_queue(NULL) {

  // Create a module to build our functions into

  _module = new Module(name, *this);

  // Create basic types

  _void_type    = Type::getVoidTy(*this);

  _bit_type     = Type::getInt1Ty(*this);

  _jbyte_type   = Type::getInt8Ty(*this);

  _jshort_type  = Type::getInt16Ty(*this);

  _jint_type    = Type::getInt32Ty(*this);

  _jlong_type   = Type::getInt64Ty(*this);

  _jfloat_type  = Type::getFloatTy(*this);

  _jdouble_type = Type::getDoubleTy(*this);

  // Create compound types

  _itableOffsetEntry_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), itableOffsetEntry::size() * wordSize));

  _Metadata_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), sizeof(Metadata)));

  _klass_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), sizeof(Klass)));

  _jniEnv_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), sizeof(JNIEnv)));

  _jniHandleBlock_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), sizeof(JNIHandleBlock)));

  _Method_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), sizeof(Method)));

  _monitor_type = ArrayType::get(

    jbyte_type(), frame::interpreter_frame_monitor_size() * wordSize);

  _oop_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), sizeof(oopDesc)));

  _thread_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), sizeof(JavaThread)));

  _zeroStack_type = PointerType::getUnqual(

    ArrayType::get(jbyte_type(), sizeof(ZeroStack)));

  std::vector<Type*> params;

  params.push_back(Method_type());

  params.push_back(intptr_type());

  params.push_back(thread_type());

  _entry_point_type = FunctionType::get(jint_type(), params, false);

  params.clear();

  params.push_back(Method_type());

  params.push_back(PointerType::getUnqual(jbyte_type()));

  params.push_back(intptr_type());

  params.push_back(thread_type());

  _osr_entry_point_type = FunctionType::get(jint_type(), params, false);

  // Create mappings

  for (int i = 0; i < T_CONFLICT; i++) {

    switch (i) {

    case T_BOOLEAN:

      _to_stackType[i] = jint_type();

      _to_arrayType[i] = jbyte_type();

      break;

    case T_BYTE:

      _to_stackType[i] = jint_type();

      _to_arrayType[i] = jbyte_type();

      break;

    case T_CHAR:

      _to_stackType[i] = jint_type();

      _to_arrayType[i] = jshort_type();

      break;

    case T_SHORT:

      _to_stackType[i] = jint_type();

      _to_arrayType[i] = jshort_type();

      break;

    case T_INT:

      _to_stackType[i] = jint_type();

      _to_arrayType[i] = jint_type();

      break;

    case T_LONG:

      _to_stackType[i] = jlong_type();

      _to_arrayType[i] = jlong_type();

      break;

    case T_FLOAT:

      _to_stackType[i] = jfloat_type();

      _to_arrayType[i] = jfloat_type();

      break;

    case T_DOUBLE:

      _to_stackType[i] = jdouble_type();

      _to_arrayType[i] = jdouble_type();

      break;

    case T_OBJECT:

    case T_ARRAY:

      _to_stackType[i] = oop_type();

      _to_arrayType[i] = oop_type();

      break;

    case T_ADDRESS:

      _to_stackType[i] = intptr_type();

      _to_arrayType[i] = NULL;

      break;

    default:

      _to_stackType[i] = NULL;

      _to_arrayType[i] = NULL;

    }

  }

}

class SharkFreeQueueItem : public CHeapObj<mtNone> {

 public:

  SharkFreeQueueItem(llvm::Function* function, SharkFreeQueueItem *next)

    : _function(function), _next(next) {}

 private:

  llvm::Function*     _function;

  SharkFreeQueueItem* _next;

 public:

  llvm::Function* function() const {

    return _function;

  }

  SharkFreeQueueItem* next() const {

    return _next;

  }

};

void SharkContext::push_to_free_queue(Function* function) {

  _free_queue = new SharkFreeQueueItem(function, _free_queue);

}

Function* SharkContext::pop_from_free_queue() {

  if (_free_queue == NULL)

    return NULL;

  SharkFreeQueueItem *item = _free_queue;

  Function *function = item->function();

  _free_queue = item->next();

  delete item;

  return function;

}