/*

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

 *

 */

package sun.jvm.hotspot.oops;

import java.io.*;

import java.util.*;

import sun.jvm.hotspot.debugger.*;

import sun.jvm.hotspot.runtime.*;

import sun.jvm.hotspot.types.*;

import sun.jvm.hotspot.utilities.*;

// A ConstantPool is an oop containing class constants

// as described in the class file

public class ConstantPool extends Metadata implements ClassConstants {

  public class CPSlot {

    private Address ptr;

    CPSlot(Address ptr) {

      this.ptr = ptr;

    }

    CPSlot(Symbol sym) {

      this.ptr = sym.getAddress().orWithMask(1);

    }

    public boolean isResolved() {

      return (ptr.minus(null) & 1) == 0;

    }

    public boolean isUnresolved() {

      return (ptr.minus(null) & 1) == 1;

    }

    public Symbol getSymbol() {

      if (!isUnresolved()) throw new InternalError("not a symbol");

        return Symbol.create(ptr.xorWithMask(1));

      }

    public Klass getKlass() {

      if (!isResolved()) throw new InternalError("not klass");

      return (Klass)Metadata.instantiateWrapperFor(ptr);

    }

  }

  // Used for debugging this code

  private static final boolean DEBUG = false;

  protected void debugMessage(String message) {

    System.out.println(message);

  }

  static {

    VM.registerVMInitializedObserver(new Observer() {

        public void update(Observable o, Object data) {

          initialize(VM.getVM().getTypeDataBase());

        }

      });

  }

  private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {

    Type type   = db.lookupType("ConstantPool");

    tags        = type.getAddressField("_tags");

    operands    = type.getAddressField("_operands");

    cache       = type.getAddressField("_cache");

    poolHolder  = new MetadataField(type.getAddressField("_pool_holder"), 0);

    length      = new CIntField(type.getCIntegerField("_length"), 0);

    headerSize  = type.getSize();

    elementSize = 0;

    // fetch constants:

    INDY_BSM_OFFSET = db.lookupIntConstant("ConstantPool::_indy_bsm_offset").intValue();

    INDY_ARGC_OFFSET = db.lookupIntConstant("ConstantPool::_indy_argc_offset").intValue();

    INDY_ARGV_OFFSET = db.lookupIntConstant("ConstantPool::_indy_argv_offset").intValue();

  }

  public ConstantPool(Address addr) {

    super(addr);

  }

  public boolean isConstantPool()      { return true; }

  private static AddressField tags;

  private static AddressField operands;

  private static AddressField cache;

  private static MetadataField poolHolder;

  private static CIntField length; // number of elements in oop

  private static long headerSize;

  private static long elementSize;

  private static int INDY_BSM_OFFSET;

  private static int INDY_ARGC_OFFSET;

  private static int INDY_ARGV_OFFSET;

  public U1Array           getTags()       { return new U1Array(tags.getValue(getAddress())); }

  public U2Array           getOperands()   { return new U2Array(operands.getValue(getAddress())); }

  public ConstantPoolCache getCache()      {

    Address addr = cache.getValue(getAddress());

    return (ConstantPoolCache) VMObjectFactory.newObject(ConstantPoolCache.class, addr);

  }

  public InstanceKlass     getPoolHolder() { return (InstanceKlass)poolHolder.getValue(this); }

  public int               getLength()     { return (int)length.getValue(getAddress()); }

  public Oop               getResolvedReferences() {

  }

  public U2Array referenceMap() {

  }

  public int objectToCPIndex(int index) {

    return referenceMap().at(index);

  }

  private long getElementSize() {

    if (elementSize !=0 ) {

      return elementSize;

    } else {

      elementSize = VM.getVM().getOopSize();

    }

    return elementSize;

  }

  private long indexOffset(long index) {

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(index >= 0 && index < getLength(),  "invalid cp index " + index + " " + getLength());

    }

    return (index * getElementSize()) + headerSize;

  }

  public ConstantTag getTagAt(long index) {

    return new ConstantTag((byte)getTags().at((int) index));

  }

  public CPSlot getSlotAt(long index) {

    return new CPSlot(getAddressAtRaw(index));

  }

  public Address getAddressAtRaw(long index) {

    return getAddress().getAddressAt(indexOffset(index));

  }

  public Symbol getSymbolAt(long index) {

    return Symbol.create(getAddressAtRaw(index));

  }

  public int getIntAt(long index){

    return getAddress().getJIntAt(indexOffset(index));

  }

  public float getFloatAt(long index){

    return getAddress().getJFloatAt(indexOffset(index));

  }

  public long getLongAt(long index) {

    int oneHalf = getAddress().getJIntAt(indexOffset(index + 1));

    int otherHalf   = getAddress().getJIntAt(indexOffset(index));

    // buildLongFromIntsPD accepts higher address value, lower address value

    // in that order.

    return VM.getVM().buildLongFromIntsPD(oneHalf, otherHalf);

  }

  public double getDoubleAt(long index) {

    return Double.longBitsToDouble(getLongAt(index));

  }

  public int getFieldOrMethodAt(int which) {

    if (DEBUG) {

      System.err.print("ConstantPool.getFieldOrMethodAt(" + which + "): new index = ");

    }

    int i = -1;

    ConstantPoolCache cache = getCache();

    if (cache == null) {

      i = which;

    } else {

      // change byte-ordering and go via cache

      i = cache.getEntryAt(0xFFFF & which).getConstantPoolIndex();

    }

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(getTagAt(i).isFieldOrMethod(), "Corrupted constant pool");

    }

    if (DEBUG) {

      System.err.println(i);

    }

    int res = getIntAt(i);

    if (DEBUG) {

      System.err.println("ConstantPool.getFieldOrMethodAt(" + i + "): result = " + res);

    }

    return res;

  }

  public int[] getNameAndTypeAt(int which) {

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(getTagAt(which).isNameAndType(), "Corrupted constant pool: " + which + " " + getTagAt(which));

    }

    int i = getIntAt(which);

    if (DEBUG) {

      System.err.println("ConstantPool.getNameAndTypeAt(" + which + "): result = " + i);

    }

    return new int[] { extractLowShortFromInt(i), extractHighShortFromInt(i) };

  }

  public Symbol getNameRefAt(int which) {

    return implGetNameRefAt(which, false);

  }

  public Symbol uncachedGetNameRefAt(int which) {

    return implGetNameRefAt(which, true);

  }

  private Symbol implGetNameRefAt(int which, boolean uncached) {

    int signatureIndex = getNameRefIndexAt(implNameAndTypeRefIndexAt(which, uncached));

    return getSymbolAt(signatureIndex);

  }

  public Symbol getSignatureRefAt(int which) {

    return implGetSignatureRefAt(which, false);

  }

  public Symbol uncachedGetSignatureRefAt(int which) {

    return implGetSignatureRefAt(which, true);

  }

  private Symbol implGetSignatureRefAt(int which, boolean uncached) {

    int signatureIndex = getSignatureRefIndexAt(implNameAndTypeRefIndexAt(which, uncached));

    return getSymbolAt(signatureIndex);

  }

  public static boolean isInvokedynamicIndex(int i) { return (i < 0); }

  public static int  decodeInvokedynamicIndex(int i) { Assert.that(isInvokedynamicIndex(i),  ""); return ~i; }

  // The invokedynamic points at the object index.  The object map points at

  // the cpCache index and the cpCache entry points at the original constant

  // pool index.

  public int invokedynamicCPCacheIndex(int index) {

    Assert.that(isInvokedynamicIndex(index), "should be a invokedynamic index");

    int rawIndex = decodeInvokedynamicIndex(index);

    return referenceMap().at(rawIndex);

  }

  ConstantPoolCacheEntry invokedynamicCPCacheEntryAt(int index) {

    // decode index that invokedynamic points to.

    int cpCacheIndex = invokedynamicCPCacheIndex(index);

    return getCache().getEntryAt(cpCacheIndex);

  }

  private int implNameAndTypeRefIndexAt(int which, boolean uncached) {

    int i = which;

    if (!uncached && getCache() != null) {

      if (isInvokedynamicIndex(which)) {

        // Invokedynamic index is index into resolved_references

        int poolIndex = invokedynamicCPCacheEntryAt(which).getConstantPoolIndex();

        poolIndex = invokeDynamicNameAndTypeRefIndexAt(poolIndex);

        Assert.that(getTagAt(poolIndex).isNameAndType(), "");

        return poolIndex;

      }

      // change byte-ordering and go via cache

      i = remapInstructionOperandFromCache(which);

    } else {

      if (getTagAt(which).isInvokeDynamic()) {

        int poolIndex = invokeDynamicNameAndTypeRefIndexAt(which);

        Assert.that(getTagAt(poolIndex).isNameAndType(), "");

        return poolIndex;

      }

    }

    // assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");

    // assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");

    int refIndex = getIntAt(i);

    return extractHighShortFromInt(refIndex);

  }

  private int remapInstructionOperandFromCache(int operand) {

    int cpc_index = operand;

    // DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);

    // assert((int)(u2)cpc_index == cpc_index, "clean u2");

    int member_index = getCache().getEntryAt(cpc_index).getConstantPoolIndex();

    return member_index;

  }

  public int invokeDynamicNameAndTypeRefIndexAt(int which) {

    // assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");

    return extractHighShortFromInt(getIntAt(which));

  }

  // returns null, if not resolved.

  public Klass getKlassAt(int which) {

    if( ! getTagAt(which).isKlass()) return null;

    return (Klass)Metadata.instantiateWrapperFor(getAddressAtRaw(which));

  }

  public Symbol getKlassNameAt(int which) {

    CPSlot entry = getSlotAt(which);

    if (entry.isResolved()) {

      return entry.getKlass().getName();

    } else {

      return entry.getSymbol();

    }

  }

  public Symbol getUnresolvedStringAt(int which) {

    return getSlotAt(which).getSymbol();

  }

  // returns null, if not resolved.

  public InstanceKlass getFieldOrMethodKlassRefAt(int which) {

    int refIndex = getFieldOrMethodAt(which);

    int klassIndex = extractLowShortFromInt(refIndex);

    return (InstanceKlass) getKlassAt(klassIndex);

  }

  // returns null, if not resolved.

  public Method getMethodRefAt(int which) {

    InstanceKlass klass = getFieldOrMethodKlassRefAt(which);

    if (klass == null) return null;

    Symbol name = getNameRefAt(which);

    Symbol sig  = getSignatureRefAt(which);

    return klass.findMethod(name, sig);

  }

  // returns null, if not resolved.

  public Field getFieldRefAt(int which) {

    InstanceKlass klass = getFieldOrMethodKlassRefAt(which);

    if (klass == null) return null;

    Symbol name = getNameRefAt(which);

    Symbol sig  = getSignatureRefAt(which);

    return klass.findField(name, sig);

  }

  public int getNameAndTypeRefIndexAt(int index) {

    return implNameAndTypeRefIndexAt(index, false);

  }

  /** Lookup for entries consisting of (name_index, signature_index) */

  public int getNameRefIndexAt(int index) {

    int[] refIndex = getNameAndTypeAt(index);

    if (DEBUG) {

      System.err.println("ConstantPool.getNameRefIndexAt(" + index + "): refIndex = " + refIndex[0]+"/"+refIndex[1]);

    }

    int i = refIndex[0];

    if (DEBUG) {

      System.err.println("ConstantPool.getNameRefIndexAt(" + index + "): result = " + i);

    }

    return i;

  }

  /** Lookup for entries consisting of (name_index, signature_index) */

  public int getSignatureRefIndexAt(int index) {

    int[] refIndex = getNameAndTypeAt(index);

    if (DEBUG) {

      System.err.println("ConstantPool.getSignatureRefIndexAt(" + index + "): refIndex = " + refIndex[0]+"/"+refIndex[1]);

    }

    int i = refIndex[1];

    if (DEBUG) {

      System.err.println("ConstantPool.getSignatureRefIndexAt(" + index + "): result = " + i);

    }

    return i;

  }

  /** Lookup for MethodHandle entries. */

  public int getMethodHandleIndexAt(int i) {

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(getTagAt(i).isMethodHandle(), "Corrupted constant pool");

    }

    int res = extractHighShortFromInt(getIntAt(i));

    if (DEBUG) {

      System.err.println("ConstantPool.getMethodHandleIndexAt(" + i + "): result = " + res);

    }

    return res;

  }

  /** Lookup for MethodHandle entries. */

  public int getMethodHandleRefKindAt(int i) {

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(getTagAt(i).isMethodHandle(), "Corrupted constant pool");

    }

    int res = extractLowShortFromInt(getIntAt(i));

    if (DEBUG) {

      System.err.println("ConstantPool.getMethodHandleRefKindAt(" + i + "): result = " + res);

    }

    return res;

  }

  /** Lookup for MethodType entries. */

  public int getMethodTypeIndexAt(int i) {

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(getTagAt(i).isMethodType(), "Corrupted constant pool");

    }

    int res = getIntAt(i);

    if (DEBUG) {

      System.err.println("ConstantPool.getMethodHandleTypeAt(" + i + "): result = " + res);

    }

    return res;

  }

  /** Lookup for multi-operand (InvokeDynamic) entries. */

  public short[] getBootstrapSpecifierAt(int i) {

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(getTagAt(i).isInvokeDynamic(), "Corrupted constant pool");

    }

    int bsmSpec = extractLowShortFromInt(this.getIntAt(i));

    U2Array operands = getOperands();

    if (operands == null)  return null;  // safety first

    int basePos = VM.getVM().buildIntFromShorts(operands.at(bsmSpec * 2 + 0),

                                                operands.at(bsmSpec * 2 + 1));

    int argv = basePos + INDY_ARGV_OFFSET;

    int argc = operands.at(basePos + INDY_ARGC_OFFSET);

    int endPos = argv + argc;

    short[] values = new short[endPos - basePos];

    for (int j = 0; j < values.length; j++) {

        values[j] = operands.at(basePos+j);

    }

    return values;

  }

  final private static String[] nameForTag = new String[] {

  };

  private String nameForTag(int tag) {

    switch (tag) {

    case JVM_CONSTANT_Utf8:               return "JVM_CONSTANT_Utf8";

    case JVM_CONSTANT_Unicode:            return "JVM_CONSTANT_Unicode";

    case JVM_CONSTANT_Integer:            return "JVM_CONSTANT_Integer";

    case JVM_CONSTANT_Float:              return "JVM_CONSTANT_Float";

    case JVM_CONSTANT_Long:               return "JVM_CONSTANT_Long";

    case JVM_CONSTANT_Double:             return "JVM_CONSTANT_Double";

    case JVM_CONSTANT_Class:              return "JVM_CONSTANT_Class";

    case JVM_CONSTANT_String:             return "JVM_CONSTANT_String";

    case JVM_CONSTANT_Fieldref:           return "JVM_CONSTANT_Fieldref";

    case JVM_CONSTANT_Methodref:          return "JVM_CONSTANT_Methodref";

    case JVM_CONSTANT_InterfaceMethodref: return "JVM_CONSTANT_InterfaceMethodref";

    case JVM_CONSTANT_NameAndType:        return "JVM_CONSTANT_NameAndType";

    case JVM_CONSTANT_MethodHandle:       return "JVM_CONSTANT_MethodHandle";

    case JVM_CONSTANT_MethodType:         return "JVM_CONSTANT_MethodType";

    case JVM_CONSTANT_InvokeDynamic:      return "JVM_CONSTANT_InvokeDynamic";

    case JVM_CONSTANT_Invalid:            return "JVM_CONSTANT_Invalid";

    case JVM_CONSTANT_UnresolvedClass:    return "JVM_CONSTANT_UnresolvedClass";

    case JVM_CONSTANT_ClassIndex:         return "JVM_CONSTANT_ClassIndex";

    case JVM_CONSTANT_StringIndex:        return "JVM_CONSTANT_StringIndex";

    case JVM_CONSTANT_UnresolvedClassInError:    return "JVM_CONSTANT_UnresolvedClassInError";

    case JVM_CONSTANT_MethodHandleInError:return "JVM_CONSTANT_MethodHandleInError";

    case JVM_CONSTANT_MethodTypeInError:  return "JVM_CONSTANT_MethodTypeInError";

    }

    throw new InternalError("Unknown tag: " + tag);

  }

  public void iterateFields(MetadataVisitor visitor) {

    super.iterateFields(visitor);

    visitor.doMetadata(poolHolder, true);

      final int length = (int) getLength();

      // zero'th pool entry is always invalid. ignore it.

      for (int index = 1; index < length; index++) {

      int ctag = (int) getTags().at((int) index);

        switch (ctag) {

        case JVM_CONSTANT_ClassIndex:

        case JVM_CONSTANT_StringIndex:

        case JVM_CONSTANT_Integer:

          visitor.doInt(new IntField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);

          break;

        case JVM_CONSTANT_Float:

          visitor.doFloat(new FloatField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);

          break;

        case JVM_CONSTANT_Long:

          visitor.doLong(new LongField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);

          // long entries occupy two slots

          index++;

          break;

        case JVM_CONSTANT_Double:

          visitor.doDouble(new DoubleField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);

          // double entries occupy two slots

          index++;

          break;

        case JVM_CONSTANT_UnresolvedClassInError:

        case JVM_CONSTANT_UnresolvedClass:

        case JVM_CONSTANT_Class:

        case JVM_CONSTANT_Utf8:

          visitor.doOop(new OopField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);