//===--- JavaConstantPool.cpp - Java constant pool definition ---------------===//
//
//                            The VMKit project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#define JNJVM_LOAD 0

#include <cstdio>
#include <cstdlib>

#include "debug.h"

#include "JavaAccess.h"
#include "JavaArray.h"
#include "JavaClass.h"
#include "j3/JavaCompiler.h"
#include "JavaConstantPool.h"
#include "Jnjvm.h"
#include "JavaThread.h"
#include "JavaTypes.h"
#include "LockedMap.h"
#include "Reader.h"
 
using namespace j3;

const uint32 JavaConstantPool::ConstantUTF8 = 1;
const uint32 JavaConstantPool::ConstantInteger = 3;
const uint32 JavaConstantPool::ConstantFloat = 4;
const uint32 JavaConstantPool::ConstantLong = 5;
const uint32 JavaConstantPool::ConstantDouble = 6;
const uint32 JavaConstantPool::ConstantClass = 7;
const uint32 JavaConstantPool::ConstantString = 8;
const uint32 JavaConstantPool::ConstantFieldref = 9;
const uint32 JavaConstantPool::ConstantMethodref = 10;
const uint32 JavaConstantPool::ConstantInterfaceMethodref = 11;
const uint32 JavaConstantPool::ConstantNameAndType = 12;


static uint32 unimplemented(JavaConstantPool* ctp, Reader& reader,
                            uint32 index) {
  fprintf(stderr, "Unimplemented in constant pool: %d\n", index);
  abort();
  return 1;
}


uint32 JavaConstantPool::CtpReaderClass(JavaConstantPool* ctp, Reader& reader,
                                   uint32 index) {
  uint16 entry = reader.readU2();
  ctp->ctpDef[index] = entry;
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <class>\t\tutf8 is at %d\n",entry);
  return 1;
}
  
uint32 JavaConstantPool::CtpReaderInteger(JavaConstantPool* ctp, Reader& reader,
                                     uint32 index) {
  uint32 val = reader.readU4();
  ctp->ctpDef[index] = val;
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <class>\tinteger: %d\n", val);
  return 1;
}
  
uint32 JavaConstantPool::CtpReaderFloat(JavaConstantPool* ctp, Reader& reader,
                                   uint32 index) { 
  uint32 val = reader.readU4();
  ctp->ctpDef[index] = val;
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <class>\tfloat: %d\n", val);
  return 1;
}
  
uint32 JavaConstantPool::CtpReaderUTF8(JavaConstantPool* ctp, Reader& reader,
                                  uint32 index) { 
  ctp->ctpDef[index] = reader.cursor;
  uint16 len = reader.readU2();
  reader.cursor += len;
  return 1;
}
  
uint32 JavaConstantPool::CtpReaderNameAndType(JavaConstantPool* ctp, Reader& reader,
                                         uint32 index) {
  uint32 entry = reader.readU4();
  ctp->ctpDef[index] = entry;
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, 
              "; [%5d] <name/type>\tname is at %d, type is at %d\n", index,
              (entry >> 16), (entry & 0xffff));
  return 1;
}
  
uint32 JavaConstantPool::CtpReaderFieldref(JavaConstantPool* ctp,
                                           Reader& reader, uint32 index) {

  uint32 entry = reader.readU4();
  ctp->ctpDef[index] = entry;
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, 
              "; [%5d] <fieldref>\tclass is at %d, name/type is at %d\n", index,
              (entry >> 16), (entry & 0xffff));
  return 1;
}

uint32 JavaConstantPool::CtpReaderString(JavaConstantPool* ctp, Reader& reader,
                                         uint32 index) {
  uint16 entry = reader.readU2();
  ctp->ctpDef[index] = entry;
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <string>\tutf8 is at %d\n",
              index, entry);
  return 1;
}
  
uint32 JavaConstantPool::CtpReaderMethodref(JavaConstantPool* ctp,
                                            Reader& reader,
                                            uint32 index) {
  uint32 entry = reader.readU4();
  ctp->ctpDef[index] = entry;
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, 
              "; [%5d] <methodref>\tclass is at %d, name/type is at %d\n",
              index, (entry >> 16), (entry & 0xffff));
  return 1;
}

uint32 JavaConstantPool::CtpReaderInterfaceMethodref(JavaConstantPool* ctp,
                                                     Reader& reader,
                                                     uint32 index) {
  uint32 entry = reader.readU4();
  ctp->ctpDef[index] = entry;
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, 
        "; [%5d] <Interface xmethodref>\tclass is at %d, name/type is at %d\n",
        index, (entry >> 16), (entry & 0xffff));
  return 1;
}
  
uint32 JavaConstantPool::CtpReaderLong(JavaConstantPool* ctp, Reader& reader,
                                       uint32 index) {
  ctp->ctpDef[index + 1] = reader.readU4();
  ctp->ctpDef[index] = reader.readU4();
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <long>%d %d %d\n", index,
              ctp->ctpDef[index], ctp->ctpDef[index + 1]);
  return 2;
}

uint32 JavaConstantPool::CtpReaderDouble(JavaConstantPool* ctp, Reader& reader,
                                         uint32 index) {
  ctp->ctpDef[index + 1] = reader.readU4();
  ctp->ctpDef[index] = reader.readU4();
  PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <double>%d %d\n", index,
              ctp->ctpDef[index], ctp->ctpDef[index + 1]);
  return 2;
}


void*
JavaConstantPool::operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
                               uint32 ctpSize) {
  uint32 size = sz + ctpSize * (sizeof(void*) + sizeof(sint32) + sizeof(uint8));
  void* res = allocator.Allocate(size, "Constant pool");
  return res;
}

JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader, uint32 size) {
  ctpSize = size;
  classDef = cl;
  
  ctpType  = (uint8*)((uint64)this + sizeof(JavaConstantPool));
  ctpDef   = (sint32*)((uint64)ctpType + ctpSize * sizeof(uint8));
  ctpRes   = (void**)((uint64)ctpDef + ctpSize * sizeof(sint32));

  memset(ctpType, 0, 
         ctpSize * (sizeof(uint8) + sizeof(sint32) + sizeof(void*)));

  uint32 cur = 1;
  while (cur < ctpSize) {
    uint8 curType = reader.readU1();
    ctpType[cur] = curType;
    cur += ((funcsReader[curType])(this, reader, cur));
  }
}

const UTF8* JavaConstantPool::UTF8At(uint32 entry) {
  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantUTF8)) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }
  
  if (!ctpRes[entry]) {
    vmkit::ThreadAllocator allocator;
    Reader reader(classDef->bytes, ctpDef[entry]);
    uint32 len = reader.readU2();
    uint16* buf = (uint16*)allocator.Allocate(len * sizeof(uint16));
    uint32 n = 0;
    uint32 i = 0;
  
    while (i < len) {
      uint32 cur = reader.readU1();
      if (cur & 0x80) {
        uint32 y = reader.readU1();
        if (cur & 0x20) {
          uint32 z = reader.readU1();
          cur = ((cur & 0x0F) << 12) +
                ((y & 0x3F) << 6) +
                (z & 0x3F);
          i += 3;
        } else {
          cur = ((cur & 0x1F) << 6) +
                (y & 0x3F);
          i += 2;
        }
      } else {
        ++i;
      }
      buf[n] = ((uint16)cur);
      ++n;
    }
  
    JnjvmClassLoader* loader = classDef->classLoader;
    const UTF8* utf8 = loader->hashUTF8->lookupOrCreateReader(buf, n);
    ctpRes[entry] = const_cast<UTF8*>(utf8);
  
    PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] <utf8>\t\t\"%s\"\n",
                entry, UTF8Buffer(utf8).cString());

  }
  return (const UTF8*)ctpRes[entry];
}

float JavaConstantPool::FloatAt(uint32 entry) {
  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantFloat)) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }
  return ((float*)ctpDef)[entry];
}

sint32 JavaConstantPool::IntegerAt(uint32 entry) {
  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantInteger)) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }
  return ((sint32*)ctpDef)[entry];
}

sint64 JavaConstantPool::LongAt(uint32 entry) {
  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantLong)) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }
  return Reader::readLong(ctpDef[entry], ctpDef[entry + 1]);
}

double JavaConstantPool::DoubleAt(uint32 entry) {
  if (!((entry > 0) && (entry < ctpSize) && typeAt(entry) == ConstantDouble)) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }
  return Reader::readDouble(ctpDef[entry], ctpDef[entry + 1]);
}

CommonClass* JavaConstantPool::isClassLoaded(uint32 entry) {
  if (!((entry > 0) && (entry < ctpSize) &&  typeAt(entry) == ConstantClass)) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }

  CommonClass* res = (CommonClass*)ctpRes[entry];
  if (res == NULL) {
    JnjvmClassLoader* loader = classDef->classLoader;
    const UTF8* name = UTF8At(ctpDef[entry]);
    res = loader->lookupClassOrArray(name);
    ctpRes[entry] = res;
  }
  return res;
}

const UTF8* JavaConstantPool::resolveClassName(uint32 index) {
  CommonClass* cl = isClassLoaded(index);
  if (cl) return cl->name;
  else return UTF8At(ctpDef[index]);
}

CommonClass* JavaConstantPool::loadClass(uint32 index, bool resolve) {
  CommonClass* temp = isClassLoaded(index);
  if (!temp) {
    JnjvmClassLoader* loader = classDef->classLoader;
    const UTF8* name = UTF8At(ctpDef[index]);
    if (name->elements[0] == I_TAB) {
      temp = loader->constructArray(name);
    } else {
      temp = loader->loadName(name, resolve, false, NULL);
    }
    ctpRes[index] = temp;
  } else if (resolve && temp->isClass()) {
    temp->asClass()->resolveClass();
  }
  return temp;
}

CommonClass* JavaConstantPool::getMethodClassIfLoaded(uint32 index) {
  CommonClass* temp = isClassLoaded(index);

  if (classDef->classLoader->getCompiler()->isStaticCompiling()) {
    if (temp == NULL) {
      temp = loadClass(index, true);
    } else if (temp->isClass()) {
      temp->asClass()->resolveClass();
    }
  }

  return temp;
}

Typedef* JavaConstantPool::resolveNameAndType(uint32 index) {
  void* res = ctpRes[index];
  if (!res) {
    if (typeAt(index) != ConstantNameAndType) {
      fprintf(stderr, "Malformed class %s\n",
              UTF8Buffer(classDef->name).cString());
      abort();
    }
    sint32 entry = ctpDef[index];
    const UTF8* type = UTF8At(entry & 0xFFFF);
    Typedef* sign = classDef->classLoader->constructType(type);
    ctpRes[index] = sign;
    return sign;
  }
  return (Typedef*)res;
}

Signdef* JavaConstantPool::resolveNameAndSign(uint32 index) {
  void* res = ctpRes[index];
  if (!res) {
    if (typeAt(index) != ConstantNameAndType) {
      fprintf(stderr, "Malformed class %s\n",
              UTF8Buffer(classDef->name).cString());
      abort();
    }
    sint32 entry = ctpDef[index];
    const UTF8* type = UTF8At(entry & 0xFFFF);
    Signdef* sign = classDef->classLoader->constructSign(type);
    ctpRes[index] = sign;
    return sign;
  }
  return (Signdef*)res;
}

Typedef* JavaConstantPool::infoOfField(uint32 index) {
  if (typeAt(index) != ConstantFieldref) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }

  return resolveNameAndType(ctpDef[index] & 0xFFFF);
}

void JavaConstantPool::infoOfMethod(uint32 index, uint32 access, 
                                    CommonClass*& cl, JavaMethod*& meth) {
  uint8 id = typeAt(index);
  if (id != ConstantMethodref && id != ConstantInterfaceMethodref) {
    fprintf(stderr, "Malformed class %s\n", UTF8Buffer(classDef->name).cString());
    abort();
  }
  
  Signdef* sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
  sint32 entry = ctpDef[index];
  sint32 ntIndex = entry & 0xFFFF;
  const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16);
  cl = getMethodClassIfLoaded(entry >> 16);
  if (cl) {
    Class* lookup = cl->isArray() ? cl->super : cl->asClass();
    if (lookup->isResolved()) {
    
      // lookup the method
      meth = lookup->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access),
                                         true, 0);
      // OK, this is rare, but the Java bytecode may do an invokevirtual on an
      // interface method. Lookup the method as if it was static.
      // The caller is responsible for taking any action if the method is
      // an interface method.
      if (!meth) {
        meth = lookup->lookupInterfaceMethodDontThrow(utf8, sign->keyName);
      }
    }
  }
}

uint32 JavaConstantPool::getClassIndexFromMethod(uint32 index) {
  sint32 entry = ctpDef[index];
  return (uint32)(entry >> 16);
}


void JavaConstantPool::nameOfStaticOrSpecialMethod(uint32 index, 
                                              const UTF8*& cl,
                                              const UTF8*& name,
                                              Signdef*& sign) {
  uint8 id = typeAt(index);
  if (id != ConstantMethodref && id != ConstantInterfaceMethodref) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }
  
  sign = resolveNameAndSign(ctpDef[index] & 0xFFFF);
  sint32 entry = ctpDef[index];
  sint32 ntIndex = entry & 0xFFFF;
  name = UTF8At(ctpDef[ntIndex] >> 16);
  cl = resolveClassName(entry >> 16);
}

JavaMethod* JavaConstantPool::infoOfStaticOrSpecialMethod(uint32 index, 
                                                          uint32 access,
                                                          Signdef* sign) {
  uint8 id = typeAt(index);
  if (id != ConstantMethodref && id != ConstantInterfaceMethodref) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }
  
  sint32 entry = ctpDef[index];
  sint32 ntIndex = entry & 0xFFFF;
  const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16);
  CommonClass* cl = getMethodClassIfLoaded(entry >> 16);
  JavaMethod* meth = 0;
  if (cl) {
    Class* lookup = cl->isArray() ? cl->super : cl->asClass();
    if (lookup->isResolved()) {
      // lookup the method
      if (isStatic(access)) {
        meth = lookup->lookupMethodDontThrow(utf8, sign->keyName,
                                             true, true, 0);
      } else {
        meth = lookup->lookupSpecialMethodDontThrow(utf8, sign->keyName,
                                                    classDef);
      }
    }
  }
  
  return meth;
}


Signdef* JavaConstantPool::infoOfInterfaceOrVirtualMethod(uint32 index,
                                                          const UTF8*& name) {

  uint8 id = typeAt(index);
  if (id != ConstantMethodref && id != ConstantInterfaceMethodref) {
    fprintf(stderr, "Malformed class %s\n",
            UTF8Buffer(classDef->name).cString());
    abort();
  }
  
  sint32 entry = ctpDef[index];
  sint32 ntIndex = entry & 0xFFFF;
  Signdef* sign = resolveNameAndSign(ntIndex); 
  name = UTF8At(ctpDef[ntIndex] >> 16);
  return sign;
}

void JavaConstantPool::resolveMethod(uint32 index, CommonClass*& cl,
                                     const UTF8*& utf8, Signdef*& sign) {
  sint32 entry = ctpDef[index];
  sint32 ntIndex = entry & 0xFFFF;
  sign = (Signdef*)ctpRes[ntIndex];
  assert(sign && "No cached signature after JITting");
  utf8 = UTF8At(ctpDef[ntIndex] >> 16);
  cl = loadClass(entry >> 16);
  assert(cl && "No class after loadClass");
  assert((cl->isArray() || (cl->isClass() && cl->asClass()->isResolved())) &&
         "Class not resolved after loadClass");
}
  
void JavaConstantPool::resolveField(uint32 index, CommonClass*& cl,
                                    const UTF8*& utf8, Typedef*& sign) {
  sint32 entry = ctpDef[index];
  sint32 ntIndex = entry & 0xFFFF;
  sign = (Typedef*)ctpRes[ntIndex];
  assert(sign && "No cached Typedef after JITting");
  utf8 = UTF8At(ctpDef[ntIndex] >> 16);
  cl = loadClass(entry >> 16);
  assert(cl && "No class after loadClass");
  assert((cl->isClass() && cl->asClass()->isResolved()) && 
         "Class not resolved after loadClass");
}

JavaField* JavaConstantPool::lookupField(uint32 index, bool stat) {
  sint32 entry = ctpDef[index];
  sint32 ntIndex = entry & 0xFFFF;
  Typedef* sign = (Typedef*)ctpRes[ntIndex];
  const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16);
  CommonClass* cl = getMethodClassIfLoaded(entry >> 16);
  if (cl) {
    Class* lookup = cl->isArray() ? cl->super : cl->asClass();
    if (lookup->isResolved()) {
      JavaField* field = lookup->lookupFieldDontThrow(utf8, sign->keyName, stat,
                                                      true, 0);
      // don't throw if no field, the exception will be thrown just in time  
      if (field) {
        if (!stat) {
          ctpRes[index] = (void*)(uintptr_t)field->ptrOffset;
        } else if (lookup->isReady()) {
          void* S = field->classDef->getStaticInstance();
          ctpRes[index] = (void*)(uintptr_t)((uint64)S + field->ptrOffset);
        }
      }
      return field;
    }
  } 
  return 0;
}

JavaString* JavaConstantPool::resolveString(const UTF8* utf8, uint16 index) {
  JavaString* str = NULL;
  llvm_gcroot(str, 0);
  Jnjvm* vm = JavaThread::get()->getJVM();
  str = vm->internalUTF8ToStr(utf8);
  return str;
}

JavaConstantPool::ctpReader JavaConstantPool::funcsReader[16] = {
  unimplemented,
  CtpReaderUTF8,
  unimplemented,
  CtpReaderInteger,
  CtpReaderFloat,
  CtpReaderLong,
  CtpReaderDouble,
  CtpReaderClass,
  CtpReaderString,
  CtpReaderFieldref,
  CtpReaderMethodref,
  CtpReaderInterfaceMethodref,
  CtpReaderNameAndType,
  unimplemented,
  unimplemented,
  unimplemented
};