/*
 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
 * 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.code.*;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.interpreter.*;
import sun.jvm.hotspot.memory.*;
import sun.jvm.hotspot.runtime.*;
import sun.jvm.hotspot.types.*;
import sun.jvm.hotspot.utilities.*;

public class ConstMethod extends VMObject {
  static {
    VM.registerVMInitializedObserver(new Observer() {
        public void update(Observable o, Object data) {
          initialize(VM.getVM().getTypeDataBase());
        }
      });
  }

  // anon-enum constants for _flags.
  private static int HAS_LINENUMBER_TABLE;
  private static int HAS_CHECKED_EXCEPTIONS;
  private static int HAS_LOCALVARIABLE_TABLE;
  private static int HAS_EXCEPTION_TABLE;
  private static int HAS_GENERIC_SIGNATURE;
  private static int HAS_METHOD_ANNOTATIONS;
  private static int HAS_PARAMETER_ANNOTATIONS;
  private static int HAS_METHOD_PARAMETERS;
  private static int HAS_DEFAULT_ANNOTATIONS;
  private static int HAS_TYPE_ANNOTATIONS;

  private static final int sizeofShort = 2;

  private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
    Type type                  = db.lookupType("ConstMethod");
    constants                  = new MetadataField(type.getAddressField("_constants"), 0);
    constMethodSize            = new CIntField(type.getCIntegerField("_constMethod_size"), 0);
    flags                      = new CIntField(type.getCIntegerField("_flags"), 0);

    // enum constants for flags
    HAS_LINENUMBER_TABLE      = db.lookupIntConstant("ConstMethod::_has_linenumber_table").intValue();
    HAS_CHECKED_EXCEPTIONS     = db.lookupIntConstant("ConstMethod::_has_checked_exceptions").intValue();
    HAS_LOCALVARIABLE_TABLE   = db.lookupIntConstant("ConstMethod::_has_localvariable_table").intValue();
    HAS_EXCEPTION_TABLE       = db.lookupIntConstant("ConstMethod::_has_exception_table").intValue();
    HAS_GENERIC_SIGNATURE     = db.lookupIntConstant("ConstMethod::_has_generic_signature").intValue();
    HAS_METHOD_ANNOTATIONS    = db.lookupIntConstant("ConstMethod::_has_method_annotations").intValue();
    HAS_PARAMETER_ANNOTATIONS = db.lookupIntConstant("ConstMethod::_has_parameter_annotations").intValue();
    HAS_METHOD_PARAMETERS = db.lookupIntConstant("ConstMethod::_has_method_parameters").intValue();
    HAS_DEFAULT_ANNOTATIONS   = db.lookupIntConstant("ConstMethod::_has_default_annotations").intValue();
    HAS_TYPE_ANNOTATIONS      = db.lookupIntConstant("ConstMethod::_has_type_annotations").intValue();

    // Size of Java bytecodes allocated immediately after ConstMethod*.
    codeSize                   = new CIntField(type.getCIntegerField("_code_size"), 0);
    nameIndex                  = new CIntField(type.getCIntegerField("_name_index"), 0);
    signatureIndex             = new CIntField(type.getCIntegerField("_signature_index"), 0);
    idnum                      = new CIntField(type.getCIntegerField("_method_idnum"), 0);
    maxStack                   = new CIntField(type.getCIntegerField("_max_stack"), 0);
    maxLocals                  = new CIntField(type.getCIntegerField("_max_locals"), 0);
    sizeOfParameters           = new CIntField(type.getCIntegerField("_size_of_parameters"), 0);

    // start of byte code
    bytecodeOffset = type.getSize();

    type                       = db.lookupType("MethodParametersElement");
    methodParametersElementSize = type.getSize();

    type                       = db.lookupType("CheckedExceptionElement");
    checkedExceptionElementSize = type.getSize();

    type                       = db.lookupType("LocalVariableTableElement");
    localVariableTableElementSize = type.getSize();

    type                       = db.lookupType("ExceptionTableElement");
    exceptionTableElementSize = type.getSize();
  }

  public ConstMethod(Address addr) {
    super(addr);
  }

  // Fields
  private static MetadataField constants;
  private static CIntField constMethodSize;
  private static CIntField flags;
  private static CIntField codeSize;
  private static CIntField nameIndex;
  private static CIntField signatureIndex;
  private static CIntField idnum;
  private static CIntField maxStack;
  private static CIntField maxLocals;
  private static CIntField sizeOfParameters;

  // start of bytecode
  private static long bytecodeOffset;
  private static long methodParametersElementSize;
  private static long checkedExceptionElementSize;
  private static long localVariableTableElementSize;
  private static long exceptionTableElementSize;

  public Method getMethod() {
    InstanceKlass ik = (InstanceKlass)getConstants().getPoolHolder();
    MethodArray methods = ik.getMethods();
    return methods.at((int)getIdNum());
  }

  // Accessors for declared fields
  public ConstantPool getConstants() {
    return (ConstantPool) constants.getValue(this);
  }

  public long getConstMethodSize() {
    return constMethodSize.getValue(this);
  }

  public long getFlags() {
    return flags.getValue(this);
  }

  public long getCodeSize() {
    return codeSize.getValue(this);
  }

  public long getNameIndex() {
    return nameIndex.getValue(this);
  }

  public long getSignatureIndex() {
    return signatureIndex.getValue(this);
  }

  public long getGenericSignatureIndex() {
    if (hasGenericSignature()) {
      return getAddress().getCIntegerAt(offsetOfGenericSignatureIndex(), 2, true);
    } else {
      return 0;
    }
  }

  public long getIdNum() {
    return idnum.getValue(this);
  }

  public long getMaxStack() {
    return maxStack.getValue(this);
  }

  public long getMaxLocals() {
    return maxLocals.getValue(this);
  }

  public long getSizeOfParameters() {
    return sizeOfParameters.getValue(this);
  }

  public Symbol getName() {
    return getMethod().getName();
  }

  public Symbol getSignature() {
    return getMethod().getSignature();
  }

  public Symbol getGenericSignature() {
    return getMethod().getGenericSignature();
  }

  // bytecode accessors

  /** Get a bytecode or breakpoint at the given bci */
  public int getBytecodeOrBPAt(int bci) {
    return getAddress().getJByteAt(bytecodeOffset + bci) & 0xFF;
  }

  public byte getBytecodeByteArg(int bci) {
    return (byte) getBytecodeOrBPAt(bci);
  }

  /** Fetches a 16-bit big-endian ("Java ordered") value from the
      bytecode stream */
  public short getBytecodeShortArg(int bci) {
    int hi = getBytecodeOrBPAt(bci);
    int lo = getBytecodeOrBPAt(bci + 1);
    return (short) ((hi << 8) | lo);
  }

  /** Fetches a 16-bit native ordered value from the
      bytecode stream */
  public short getNativeShortArg(int bci) {
    int hi = getBytecodeOrBPAt(bci);
    int lo = getBytecodeOrBPAt(bci + 1);
    if (VM.getVM().isBigEndian()) {
        return (short) ((hi << 8) | lo);
    } else {
        return (short) ((lo << 8) | hi);
    }
  }

  /** Fetches a 32-bit big-endian ("Java ordered") value from the
      bytecode stream */
  public int getBytecodeIntArg(int bci) {
    int b4 = getBytecodeOrBPAt(bci);
    int b3 = getBytecodeOrBPAt(bci + 1);
    int b2 = getBytecodeOrBPAt(bci + 2);
    int b1 = getBytecodeOrBPAt(bci + 3);

    return (b4 << 24) | (b3 << 16) | (b2 << 8) | b1;
  }

  /** Fetches a 32-bit native ordered value from the
      bytecode stream */
  public int getNativeIntArg(int bci) {
    int b4 = getBytecodeOrBPAt(bci);
    int b3 = getBytecodeOrBPAt(bci + 1);
    int b2 = getBytecodeOrBPAt(bci + 2);
    int b1 = getBytecodeOrBPAt(bci + 3);

    if (VM.getVM().isBigEndian()) {
        return (b4 << 24) | (b3 << 16) | (b2 << 8) | b1;
    } else {
        return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
    }
  }

  public byte[] getByteCode() {
     byte[] bc = new byte[ (int) getCodeSize() ];
     for( int i=0; i < bc.length; i++ )
     {
        long offs = bytecodeOffset + i;
        bc[i] = getAddress().getJByteAt( offs );
     }
     return bc;
  }

  public long getSize() {
    return getConstMethodSize();
  }

  public void printValueOn(PrintStream tty) {
    tty.print("ConstMethod " + getName().asString() + getSignature().asString() + "@" + getAddress());
  }

  public void iterateFields(MetadataVisitor visitor) {
    visitor.doMetadata(constants, true);
      visitor.doCInt(constMethodSize, true);
      visitor.doCInt(flags, true);
      visitor.doCInt(codeSize, true);
      visitor.doCInt(nameIndex, true);
      visitor.doCInt(signatureIndex, true);
      visitor.doCInt(codeSize, true);
      visitor.doCInt(maxStack, true);
      visitor.doCInt(maxLocals, true);
      visitor.doCInt(sizeOfParameters, true);
    }

  // Accessors

  public boolean hasLineNumberTable() {
    return (getFlags() & HAS_LINENUMBER_TABLE) != 0;
  }

  public int getLineNumberFromBCI(int bci) {
    if (!VM.getVM().isCore()) {
      if (bci == DebugInformationRecorder.SYNCHRONIZATION_ENTRY_BCI) bci = 0;
    }

    if (isNative()) {
      return -1;
    }

    if (Assert.ASSERTS_ENABLED) {
      Assert.that(bci == 0 || 0 <= bci && bci < getCodeSize(), "illegal bci");
    }
    int bestBCI  =  0;
    int bestLine = -1;
    if (hasLineNumberTable()) {
      // The line numbers are a short array of 2-tuples [start_pc, line_number].
      // Not necessarily sorted and not necessarily one-to-one.
      CompressedLineNumberReadStream stream =
        new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
      while (stream.readPair()) {
        if (stream.bci() == bci) {
          // perfect match
          return stream.line();
        } else {
          // update best_bci/line
          if (stream.bci() < bci && stream.bci() >= bestBCI) {
            bestBCI  = stream.bci();
            bestLine = stream.line();
          }
        }
      }
    }
    return bestLine;
  }

  public LineNumberTableElement[] getLineNumberTable() {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasLineNumberTable(),
                  "should only be called if table is present");
    }
    int len = getLineNumberTableLength();
    CompressedLineNumberReadStream stream =
      new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
    LineNumberTableElement[] ret = new LineNumberTableElement[len];

    for (int idx = 0; idx < len; idx++) {
      stream.readPair();
      ret[idx] = new LineNumberTableElement(stream.bci(), stream.line());
    }
    return ret;
  }

  public boolean hasLocalVariableTable() {
    return (getFlags() & HAS_LOCALVARIABLE_TABLE) != 0;
  }

  public Symbol getLocalVariableName(int bci, int slot) {
    return getMethod().getLocalVariableName(bci, slot);
  }

  /** Should only be called if table is present */
  public LocalVariableTableElement[] getLocalVariableTable() {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasLocalVariableTable(), "should only be called if table is present");
    }
    LocalVariableTableElement[] ret = new LocalVariableTableElement[getLocalVariableTableLength()];
    long offset = offsetOfLocalVariableTable();
    for (int i = 0; i < ret.length; i++) {
      ret[i] = new LocalVariableTableElement(getAddress(), offset);
      offset += localVariableTableElementSize;
    }
    return ret;
  }

  public boolean hasExceptionTable() {
    return (getFlags() & HAS_EXCEPTION_TABLE) != 0;
  }

  public ExceptionTableElement[] getExceptionTable() {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasExceptionTable(), "should only be called if table is present");
    }
    ExceptionTableElement[] ret = new ExceptionTableElement[getExceptionTableLength()];
    long offset = offsetOfExceptionTable();
    for (int i = 0; i < ret.length; i++) {
      ret[i] = new ExceptionTableElement(getAddress(), offset);
      offset += exceptionTableElementSize;
    }
    return ret;
  }

  public boolean hasCheckedExceptions() {
    return (getFlags() & HAS_CHECKED_EXCEPTIONS) != 0;
  }

  public CheckedExceptionElement[] getCheckedExceptions() {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasCheckedExceptions(), "should only be called if table is present");
    }
    CheckedExceptionElement[] ret = new CheckedExceptionElement[getCheckedExceptionsLength()];
    long offset = offsetOfCheckedExceptions();
    for (int i = 0; i < ret.length; i++) {
      ret[i] = new CheckedExceptionElement(getAddress(), offset);
      offset += checkedExceptionElementSize;
    }
    return ret;
  }

  private boolean hasMethodParameters() {
    return (getFlags() & HAS_METHOD_PARAMETERS) != 0;
  }

  private boolean hasGenericSignature() {
    return (getFlags() & HAS_GENERIC_SIGNATURE) != 0;
  }

  private boolean hasMethodAnnotations() {
    return (getFlags() & HAS_METHOD_ANNOTATIONS) != 0;
  }

  private boolean hasParameterAnnotations() {
    return (getFlags() & HAS_PARAMETER_ANNOTATIONS) != 0;
  }

  private boolean hasDefaultAnnotations() {
    return (getFlags() & HAS_DEFAULT_ANNOTATIONS) != 0;
  }

  private boolean hasTypeAnnotations() {
    return (getFlags() & HAS_TYPE_ANNOTATIONS) != 0;
  }


  //---------------------------------------------------------------------------
  // Internals only below this point
  //

  private boolean isNative() {
    return getMethod().isNative();
  }

  // Offset of end of code
  private long offsetOfCodeEnd() {
    return bytecodeOffset + getCodeSize();
  }

  // Offset of start of compressed line number table (see method.hpp)
  private long offsetOfCompressedLineNumberTable() {
    return offsetOfCodeEnd() + (isNative() ? 2 * VM.getVM().getAddressSize() : 0);
  }

  // Offset of last short in Method* before annotations, if present
  private long offsetOfLastU2Element() {
    int offset = 0;
    if (hasMethodAnnotations()) offset++;
    if (hasParameterAnnotations()) offset++;
    if (hasTypeAnnotations()) offset++;
    if (hasDefaultAnnotations()) offset++;
    long wordSize = VM.getVM().getObjectHeap().getOopSize();
    return (getSize() * wordSize) - (offset * wordSize) - sizeofShort;
  }

  // Offset of the generic signature index
  private long offsetOfGenericSignatureIndex() {
    return offsetOfLastU2Element();
  }

  private long offsetOfMethodParametersLength() {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasMethodParameters(), "should only be called if table is present");
    }
    return hasGenericSignature() ? offsetOfLastU2Element() - sizeofShort :
                                   offsetOfLastU2Element();
  }

  private int getMethodParametersLength() {
      if (hasMethodParameters())
          return (int) getAddress().getCIntegerAt(offsetOfMethodParametersLength(), 2, true);
      else
          return 0;
  }

  // Offset of start of checked exceptions
  private long offsetOfMethodParameters() {
    long offset = offsetOfMethodParametersLength();
    long length = getMethodParametersLength();
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(length > 0, "should only be called if method parameter information is present");
    }
    offset -= length * methodParametersElementSize;
    return offset;
  }

  private long offsetOfCheckedExceptionsLength() {
    if (hasMethodParameters())
      return offsetOfMethodParameters() - sizeofShort;
    else {
      return hasGenericSignature() ? offsetOfLastU2Element() - sizeofShort :
                                     offsetOfLastU2Element();
    }
  }

  private int getCheckedExceptionsLength() {
    if (hasCheckedExceptions()) {
      return (int) getAddress().getCIntegerAt(offsetOfCheckedExceptionsLength(), 2, true);
    } else {
      return 0;
    }
  }

  // Offset of start of checked exceptions
  private long offsetOfCheckedExceptions() {
    long offset = offsetOfCheckedExceptionsLength();
    long length = getCheckedExceptionsLength();
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(length > 0, "should only be called if table is present");
    }
    offset -= length * checkedExceptionElementSize;
    return offset;
  }

  private int getLineNumberTableLength() {
    int len = 0;
    if (hasLineNumberTable()) {
      CompressedLineNumberReadStream stream =
        new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
      while (stream.readPair()) {
        len += 1;
      }
    }
    return len;
  }

  private int getLocalVariableTableLength() {
    if (hasLocalVariableTable()) {
      return (int) getAddress().getCIntegerAt(offsetOfLocalVariableTableLength(), 2, true);
    } else {
      return 0;
    }
  }

  // Offset of local variable table length
  private long offsetOfLocalVariableTableLength() {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasLocalVariableTable(), "should only be called if table is present");
    }

    if (hasExceptionTable()) {
      return offsetOfExceptionTable() - sizeofShort;
    } else if (hasCheckedExceptions()) {
      return offsetOfCheckedExceptions() - sizeofShort;
    } else if (hasMethodParameters()) {
      return offsetOfMethodParameters() - sizeofShort;
    } else {
      return hasGenericSignature() ? offsetOfLastU2Element() - sizeofShort :
                                     offsetOfLastU2Element();
    }
  }

  private long offsetOfLocalVariableTable() {
    long offset = offsetOfLocalVariableTableLength();
    long length = getLocalVariableTableLength();
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(length > 0, "should only be called if table is present");
    }
    offset -= length * localVariableTableElementSize;
    return offset;
  }

  private int getExceptionTableLength() {
    if (hasExceptionTable()) {
      return (int) getAddress().getCIntegerAt(offsetOfExceptionTableLength(), 2, true);
    } else {
      return 0;
    }
  }

  private long offsetOfExceptionTableLength() {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasExceptionTable(), "should only be called if table is present");
    }
    if (hasCheckedExceptions()) {
      return offsetOfCheckedExceptions() - sizeofShort;
    } else if (hasMethodParameters()) {
      return offsetOfMethodParameters() - sizeofShort;
    } else {
      return hasGenericSignature() ? offsetOfLastU2Element() - sizeofShort :
                                     offsetOfLastU2Element();
    }
  }

  private long offsetOfExceptionTable() {
    long offset = offsetOfExceptionTableLength();
    long length = getExceptionTableLength();
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(length > 0, "should only be called if table is present");
    }
    offset -= length * exceptionTableElementSize;
    return offset;
  }

}