/*

 * Copyright (c) 2000, 2012, 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.runtime.sparc;

import sun.jvm.hotspot.asm.sparc.*;

import sun.jvm.hotspot.code.*;

import sun.jvm.hotspot.compiler.*;

import sun.jvm.hotspot.debugger.*;

import sun.jvm.hotspot.debugger.cdbg.*;

import sun.jvm.hotspot.oops.*;

import sun.jvm.hotspot.runtime.*;

import sun.jvm.hotspot.runtime.posix.*;

import sun.jvm.hotspot.utilities.*;

/** Specialization of and implementation of abstract methods of the

    Frame class for the SPARC CPU. (FIXME: this is as quick a port as

    possible to get things running; will have to do a better job right

    away.) */

public class SPARCFrame extends Frame {

  // The pc value is the raw return address, plus 8 (pcReturnOffset()).

  // the value of sp and youngerSP that is stored in this object

  // is always, always, always the value that would be found in the

  // register (or window save area) while the target VM was executing.

  // The caller of the constructor will alwasy know if has a biased or

  // unbiased version of the stack pointer and can convert real (unbiased)

  // value via a helper routine we supply.

  // Whenever we return sp or youngerSP values we do not return the internal

  // value but the real (unbiased) pointers since these are the true, usable

  // memory addresses. The outlier case is that of the null pointer. The current

  // mechanism makes null pointers always look null whether biased or not.

  // This seems to cause no problems. In theory null real pointers could be biased

  // just like other values however this has impact on things like addOffsetTo()

  // to be able to take an Address that represents null and add an offset to it.

  // This doesn't seem worth the bother and the impact on the rest of the code

  // when the biasSP and unbiasSP can make this invisible.

  //

  // The general rule in this code is that when we have a variable like FP, youngerSP, SP

  // that these are real (i.e. unbiased) addresses. The instance variables in a Frame are

  // always raw values. The other rule is that it except for the frame constructors and

  // the unBiasSP helper all methods accept parameters that are real addresses.

  //

  /** Optional next-younger SP (used to locate O7, the PC) */

  private Address raw_youngerSP;

  /** Intepreter adjusts the stack pointer to make all locals contiguous */

  private long    interpreterSPAdjustmentOffset;

  /** Number of stack entries for longs */

  private static final int WORDS_PER_LONG = 2;

  /** Normal SPARC return is 2 words past PC */

  public static final int PC_RETURN_OFFSET = 8;

  /** Size of each block, in order of increasing address */

  public static final int REGISTER_SAVE_WORDS   = 16;

  // FIXME: read these from the remote process

  //#ifdef _LP64

  //    callee_aggregate_return_pointer_words        =  0,

  //#else

  //    callee_aggregate_return_pointer_words        =  1,

  //#endif

  public static final int CALLEE_AGGREGATE_RETURN_POINTER_WORDS     = 1;

  public static final int CALLEE_REGISTER_ARGUMENT_SAVE_AREA_WORDS  = 6;

  // offset of each block, in order of increasing address:

  public static final int REGISTER_SAVE_WORDS_SP_OFFSET             = 0;

  public static final int CALLEE_AGGREGATE_RETURN_POINTER_SP_OFFSET = REGISTER_SAVE_WORDS_SP_OFFSET + REGISTER_SAVE_WORDS;

  public static final int CALLEE_REGISTER_ARGUMENT_SAVE_AREA_SP_OFFSET = (CALLEE_AGGREGATE_RETURN_POINTER_SP_OFFSET +

                                                                          CALLEE_AGGREGATE_RETURN_POINTER_WORDS);

  public static final int MEMORY_PARAMETER_WORD_SP_OFFSET              = (CALLEE_REGISTER_ARGUMENT_SAVE_AREA_SP_OFFSET +

                                                                          CALLEE_REGISTER_ARGUMENT_SAVE_AREA_WORDS);

  public static final int VARARGS_OFFSET                               = MEMORY_PARAMETER_WORD_SP_OFFSET;

  private static final boolean DEBUG = System.getProperty("sun.jvm.hotspot.runtime.sparc.SPARCFrame.DEBUG") != null;

  public static Address unBiasSP(Address raw_sp) {

    if (raw_sp != null) {

      return raw_sp.addOffsetTo(VM.getVM().getStackBias());

    } else {

      return null;

    }

  }

  public static Address biasSP(Address real_sp) {

    if (real_sp != null) {

      if (DEBUG) {

        System.out.println("biasing realsp: " + real_sp + " biased: " + real_sp.addOffsetTo(-VM.getVM().getStackBias()) );

      }

      return real_sp.addOffsetTo(-VM.getVM().getStackBias());

    } else {

      if (DEBUG) {

        System.out.println("biasing null realsp");

      }

      return null;

    }

  }

  //

  // This is used to find the younger sp for a thread thatn has stopped but hasn't

  // conveniently told us the information where we can find the pc or the frame

  // containing the pc that corresponds to last_java_sp. This method will walk

  // the frames trying to find the frame which we contains the data we need.

  //

  public static Address findYoungerSP(Address top, Address find) {

    // top and find are unBiased sp values

    // we return an unBiased value

    Address findRaw = biasSP(find);

    if (top == null || find == null || findRaw == null) {

      throw new RuntimeException("bad values for findYoungerSP top: " + top + " find: " + find);

    }

    // It would be unusual to find more than 20 native frames before we find the java frame

    // we are looking for.

    final int maxFrames = 20;

    int count = 0;

    Address search = top;

    Address next;

    Address pc;

    if (DEBUG) {

      System.out.println("findYoungerSP top: " + top + " find: " + find + " findRaw: " + findRaw);

    }

    while ( count != maxFrames && search != null) {

      next = search.getAddressAt(SPARCRegisters.I6.spOffsetInSavedWindow());

      pc = search.getAddressAt(SPARCRegisters.I7.spOffsetInSavedWindow());

      if (DEBUG) {

        System.out.println("findYoungerSP next: " + next + " pc: " + pc);

      }

      if (next.equals(findRaw)) {

        return search;

      }

      search = unBiasSP(next);

    }

    if (DEBUG) {

      System.out.println("findYoungerSP: never found younger, top: " + top + " find: " + find);

    }

    return null;

  }

  public Address getSP()              {

    if (DEBUG) {

      System.out.println("getSP raw: " + raw_sp + " unbiased: " + unBiasSP(raw_sp));

    }

    return  unBiasSP(raw_sp);

  }

  public Address getID()              {

    return getSP();

  }

  public Address getYoungerSP()       {

    if (DEBUG) {

      System.out.println("getYoungerSP: " + raw_youngerSP + " unbiased: " + unBiasSP(raw_youngerSP));

    }

    return unBiasSP(raw_youngerSP);

  }

  /** This constructor relies on the fact that the creator of a frame

      has flushed register windows which the frame will refer to, and

      that those register windows will not be reloaded until the frame

      is done reading and writing the stack.  Moreover, if the

      "younger_pc" argument points into the register save area of the

      next younger frame (though it need not), the register window for

      that next younger frame must also stay flushed.  (The caller is

      responsible for ensuring this.) */

  public SPARCFrame(Address raw_sp, Address raw_youngerSP, boolean youngerFrameIsInterpreted) {

    super();

    if (DEBUG) {

      System.out.println("Constructing frame(1) raw_sp: " + raw_sp + " raw_youngerSP: " + raw_youngerSP);

    }

    if (Assert.ASSERTS_ENABLED) {

      Assert.that((unBiasSP(raw_sp).andWithMask(VM.getVM().getAddressSize() - 1) == null),

                   "Expected raw sp likely got real sp, value was " + raw_sp);

      if (raw_youngerSP != null) {

        Assert.that((unBiasSP(raw_youngerSP).andWithMask(VM.getVM().getAddressSize() - 1) == null),

                    "Expected raw youngerSP likely got real youngerSP, value was " + raw_youngerSP);

      }

    }

    this.raw_sp = raw_sp;

    this.raw_youngerSP = raw_youngerSP;

    if (raw_youngerSP == null) {

      // make a deficient frame which doesn't know where its PC is

      pc = null;

    } else {

      Address youngerSP = unBiasSP(raw_youngerSP);

      pc = youngerSP.getAddressAt(SPARCRegisters.I7.spOffsetInSavedWindow()).addOffsetTo(PC_RETURN_OFFSET);

      if (Assert.ASSERTS_ENABLED) {

        Assert.that(youngerSP.getAddressAt(SPARCRegisters.FP.spOffsetInSavedWindow()).

                    equals(raw_sp),

                    "youngerSP must be valid");

      }

    }

    if (youngerFrameIsInterpreted) {

      long IsavedSP = SPARCRegisters.IsavedSP.spOffsetInSavedWindow();

      // compute adjustment to this frame's SP made by its interpreted callee

      interpreterSPAdjustmentOffset = 0;

      Address savedSP = unBiasSP(getYoungerSP().getAddressAt(IsavedSP));

      if (savedSP == null) {

        if ( DEBUG) {

          System.out.println("WARNING: IsavedSP was null for frame " + this);

        }

      } else {

        interpreterSPAdjustmentOffset = savedSP.minus(getSP());

      }

    } else {

      interpreterSPAdjustmentOffset = 0;

    }

    if ( pc != null) {

      // Look for a deopt pc and if it is deopted convert to original pc

      CodeBlob cb = VM.getVM().getCodeCache().findBlob(pc);

      if (cb != null && cb.isJavaMethod()) {

        NMethod nm = (NMethod) cb;

        if (pc.equals(nm.deoptHandlerBegin())) {

          // adjust pc if frame is deoptimized.

          pc = this.getUnextendedSP().getAddressAt(nm.origPCOffset());

          deoptimized = true;

        }

      }

    }

  }

  /** Make a deficient frame which doesn't know where its PC is (note

      no youngerSP argument) */

  public SPARCFrame(Address raw_sp, Address pc) {

    super();

    if (DEBUG) {

      System.out.println("Constructing frame(2) raw_sp: " + raw_sp );

    }

    this.raw_sp = raw_sp;

    if (Assert.ASSERTS_ENABLED) {

      Assert.that((unBiasSP(raw_sp).andWithMask(VM.getVM().getAddressSize() - 1) == null),

                   "Expected raw sp likely got real sp, value was " + raw_sp);

    }

    raw_youngerSP = null;

    this.pc = pc;

    interpreterSPAdjustmentOffset = 0;

  }

  /** Only used internally */

  private SPARCFrame() {

  }

  public Object clone() {

    SPARCFrame frame = new SPARCFrame();

    frame.raw_sp = raw_sp;

    frame.pc = pc;

    frame.raw_youngerSP = raw_youngerSP;

    frame.interpreterSPAdjustmentOffset = interpreterSPAdjustmentOffset;

    frame.deoptimized = deoptimized;

    return frame;

  }

  public boolean equals(Object arg) {

    if (arg == null) {

      return false;

    }

    if (!(arg instanceof SPARCFrame)) {

      return false;

    }

    SPARCFrame other = (SPARCFrame) arg;

    return (AddressOps.equal(getSP(), other.getSP()) &&

            AddressOps.equal(getFP(), other.getFP()) &&

            AddressOps.equal(getPC(), other.getPC()));

  }

  public int hashCode() {

    if (raw_sp == null) {

      return 0;

    }

    return raw_sp.hashCode();

  }

  public String toString() {

    Address fp = getFP();

    Address sp = getSP();

    Address youngerSP = getYoungerSP();

    return "sp: " + (sp == null? "null" : sp.toString()) +

         ", younger_sp: " + (youngerSP == null? "null" : youngerSP.toString()) +

         ", fp: " + (fp == null? "null" : fp.toString()) +

         ", pc: " + (pc == null? "null" : pc.toString());

  }

  /** <P> Identifies a signal handler frame on the stack. </P>

      <P> There are a few different algorithms for doing this, and

      they vary from platform to platform. For example, based on a

      conversation with Dave Dice, Solaris/x86 will be substantially

      simpler to handle than Solaris/SPARC because the signal handler

      frame can be identified because of a program counter == -1. </P>

      <P> The dbx group provided code and advice on these topics; the

      code below evolved from theirs, but is not correct/robust.

      Without going into too many details, it seems that looking for

      the incoming argument to the sigacthandler frame (which is what

      this code identifies) is not guaranteed to be stable across

      versions of Solaris, since that function is supplied by

      libthread and is not guaranteed not to clobber I2 before it

      calls __sighndlr later. From discussions, it sounds like a

      robust algorithm which wouldn't require traversal of the

      ucontext chain (used by dbx, but which Dave Dice thinks isn't

      robust in the face of libthread -- need to follow up) would be

      to be able to properly identify the __sighndlr frame, then get

      I2 and treat that as a ucontext. To identify __sighndlr we would

      need to look up that symbol in the remote process and look for a

      program counter within a certain (small) distance. </P>

      <P> If the underlying Debugger supports CDebugger interface, we

      take the approach of __sighnldr symbol. This approach is more robust

      compared to the original hueristic approach. Of course, if there

      is no CDebugger support, we fallback to the hueristic approach. </P>

      <P> The current implementation seems to work with Solaris 2.8.

      A nice property of this system is that if we find a core file

      this algorithm doesn't work on, we can change the code and try

      again, so I'm putting this in as the current mechanism for

      finding signal handler frames on Solaris/SPARC. </P> */

  public boolean isSignalHandlerFrameDbg() {

    CDebugger cdbg = VM.getVM().getDebugger().getCDebugger();

    if (cdbg != null) {

      LoadObject dso = cdbg.loadObjectContainingPC(getPC());

      if (dso != null) {

        ClosestSymbol cs = dso.closestSymbolToPC(getPC());

        if (cs != null && cs.getName().equals("__sighndlr")) {

          return true;

        } else {

          return false;

        }

      } else {

        return false;

      }

    } else {

      if (getYoungerSP() == null) {

        //      System.err.println("  SPARCFrame.isSignalHandlerFrameDbg: youngerSP = " + getYoungerSP());

        return false;

      }

      Address i2 = getSP().getAddressAt(SPARCRegisters.I2.spOffsetInSavedWindow());

      if (i2 == null) {

        return false;

      }

      Address fp = getFP();

      // My (mistaken) understanding of the dbx group's code was that

      // the signal handler frame could be identified by testing the

      // incoming argument to see whether it was a certain distance

      // below the frame pointer; in fact, their code did substantially

      // more than this (traversal of the ucontext chain, which this

      // code can't do because the topmost ucontext is not currently

      // available via the proc_service APIs in dbx). The current code

      // appears to work, but is probably not robust.

      int MAJOR_HACK_OFFSET = 8;  // Difference between expected location of the ucontext and reality

      // System.err.println("  SPARCFrame.isSignalHandlerFrameDbg: I2 = " + i2 +

      //                          ", fp = " + fp + ", raw_youngerSP = " + getYoungerSP());

      boolean res = i2.equals(fp.addOffsetTo(VM.getVM().getAddressSize() * (REGISTER_SAVE_WORDS + MAJOR_HACK_OFFSET)));

      if (res) {

        // Qualify this with another test (FIXME: this is a gross heuristic found while testing)

        Address sigInfoAddr = getSP().getAddressAt(SPARCRegisters.I5.spOffsetInSavedWindow());

        if (sigInfoAddr == null) {

          System.err.println("Frame with fp = " + fp + " looked like a signal handler frame but wasn't");

          res = false;

        }

      }

      return res;

    }

  }

  public int getSignalNumberDbg() {

    // From looking at the stack trace in dbx, it looks like the

    // siginfo* comes into sigacthandler in I5. It would be much more

    // robust to look at the __sighndlr frame instead, but we can't

    // currently identify that frame.

    Address sigInfoAddr = getSP().getAddressAt(SPARCRegisters.I5.spOffsetInSavedWindow());

    // Read si_signo out of siginfo*

    return (int) sigInfoAddr.getCIntegerAt(0, 4, false);

  }

  public String getSignalNameDbg() {

    return POSIXSignals.getSignalName(getSignalNumberDbg());

  }

  public boolean isInterpretedFrameValid() {

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(isInterpretedFrame(), "Not an interpreted frame");

    }

    // These are reasonable sanity checks

    if (getFP() == null || (getFP().andWithMask(2 * VM.getVM().getAddressSize() - 1)) != null) {

      return false;

    }

    if (getSP() == null || (getSP().andWithMask(2 * VM.getVM().getAddressSize() - 1)) != null) {

      return false;

    }

    if (getFP().addOffsetTo(INTERPRETER_FRAME_VM_LOCAL_WORDS * VM.getVM().getAddressSize()).lessThan(getSP())) {

      return false;

    }

    Address methodHandle = addressOfInterpreterFrameMethod().getAddressAt(0);

    if (VM.getVM().getObjectHeap().isValidMethod(methodHandle) == false) {

      return false;

    }

    // These are hacks to keep us out of trouble.

    // The problem with these is that they mask other problems

    if (getFP().lessThanOrEqual(getSP())) {        // this attempts to deal with unsigned comparison above

      return false;

    }

    if (getFP().minus(getSP()) > 4096 * VM.getVM().getAddressSize()) {  // stack frames shouldn't be large.

      return false;

    }

    // FIXME: this is not atomic with respect to GC and is unsuitable

    // for use in a non-debugging, or reflective, system. Need to

    // figure out how to express this.

    Address bcx =  addressOfInterpreterFrameBCX().getAddressAt(0);

    Method method;

    try {

      method = (Method)Metadata.instantiateWrapperFor(methodHandle);

    } catch (UnknownOopException ex) {

       return false;

    }

    int  bci = bcpToBci(bcx, method);

    //validate bci

    if (bci < 0) return false;

    return true;

  }

  //--------------------------------------------------------------------------------

  // Accessors:

  //

  /** Accessors */

  public long frameSize() {

    return (getSenderSP().minus(getSP()) / VM.getVM().getAddressSize());

  }

  public Address getLink() {

    return unBiasSP(getFP().getAddressAt(SPARCRegisters.FP.spOffsetInSavedWindow()));

  }

  // FIXME: not implementable yet

  //  public void setLink(Address addr) {

  //    if (Assert.ASSERTS_ENABLED) {

  //      Assert.that(getLink().equals(addr), "frame nesting is controlled by hardware");

  //    }

  //  }

  public Frame sender(RegisterMap regMap, CodeBlob cb) {

    SPARCRegisterMap map = (SPARCRegisterMap) regMap;

    if (Assert.ASSERTS_ENABLED) {

      Assert.that(map != null, "map must be set");

    }

    // Default is we don't have to follow them. The sender_for_xxx

    // will update it accordingly

    map.setIncludeArgumentOops(false);

    if (isEntryFrame()) {

      return senderForEntryFrame(map);

    }

    Address youngerSP = getSP();

    Address sp        = getSenderSP();

    boolean isInterpreted = false;

    // FIXME: this is a hack to get stackwalking to work in the face

    // of a signal like a SEGV. For debugging purposes it's important

    // that (a) we are able to traverse the stack if we take a signal

    // and (b) that we get the correct program counter in this

    // situation. If we are not using alternate signal stacks then (a)

    // seems to work all the time (on SPARC), but (b) is violated for

    // the frame just below the signal handler.

    // The mechanism for finding the ucontext is not robust. In

    // addition, we may find that we need to be able to fetch more

    // registers from the ucontext than just the program counter,

    // since the register windows on the stack are "stale". This will

    // require substantial restructuring of this frame code, so has

    // been avoided for now.

    // It is difficult to find a clean solution for mixing debugging

    // situations with VM frame traversal. One could consider

    // implementing generic frame traversal in the dbx style and only

    // using the VM's stack walking mechanism on a per-frame basis,

    // for example to traverse Java-level activations in a compiled

    // frame. However, this will probably not interact well with the

    // mechanism for finding oops on the stack.

    if (VM.getVM().isDebugging()) {

      // If we are a signal handler frame, use a trick: make the

      // youngerSP of the caller frame point to the top of the

      // ucontext's contained register set. This should allow fetching

      // of the registers for the frame just below the signal handler

      // frame in the usual fashion.

      if (isSignalHandlerFrameDbg()) {

        if (DEBUG) {