JDK 11 jdk.hotspot.agent.jmod - Hotspot Agent Module

JDK 11 jdk.hotspot.agent.jmod is the JMOD file for JDK 11 Hotspot Agent module.

JDK 11 Hotspot Agent module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.hotspot.agent.jmod.

JDK 11 Hotspot Agent module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.

JDK 11 Hotspot Agent module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.hotspot.agent.

You can click and view the content of each source code file in the list below.

✍: FYIcenter

sun/jvm/hotspot/runtime/sparc/SPARCRegisterMap.java

/*
 * Copyright (c) 2000, 2005, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package sun.jvm.hotspot.runtime.sparc;

import java.util.*;

import sun.jvm.hotspot.asm.sparc.*;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.runtime.*;
import sun.jvm.hotspot.types.*;
import sun.jvm.hotspot.utilities.*;

public class SPARCRegisterMap extends RegisterMap {
  /** Register window save area (for L and I regs) */
  private Address window;
  /** Previous save area (for O regs, if needed) */
  private Address youngerWindow;

  private static int registerImplNumberOfRegisters;

  // Unified register numbering scheme: each 32-bits counts as a register
  // number, so all the V9 registers take 2 slots.
  private static int[] R_L_nums = new int[] {0+040,2+040,4+040,6+040,8+040,10+040,12+040,14+040};
  private static int[] R_I_nums = new int[] {0+060,2+060,4+060,6+060,8+060,10+060,12+060,14+060};
  private static int[] R_O_nums = new int[] {0+020,2+020,4+020,6+020,8+020,10+020,12+020,14+020};
  private static int[] R_G_nums = new int[] {0+000,2+000,4+000,6+000,8+000,10+000,12+000,14+000};

  private static long badMask;
  private static long R_LIO_mask;

  private static int sizeofJint;

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

  private static void initialize(TypeDataBase db) {
    badMask = 0;
    R_LIO_mask = 0;

    sizeofJint = (int) db.lookupType("jint").getSize();
    registerImplNumberOfRegisters = db.lookupIntConstant("RegisterImpl::number_of_registers").intValue();

    for (int i = 0; i < 8; i++) {
      Assert.that(R_L_nums[i] < locationValidTypeSize, "in first chunk");
      Assert.that(R_I_nums[i] < locationValidTypeSize, "in first chunk");
      Assert.that(R_O_nums[i] < locationValidTypeSize, "in first chunk");
      Assert.that(R_G_nums[i] < locationValidTypeSize, "in first chunk");
    }

    badMask |= ((long) 1 << R_O_nums[6]); // SP
    badMask |= ((long) 1 << R_O_nums[7]); // cPC
    badMask |= ((long) 1 << R_I_nums[6]); // FP
    badMask |= ((long) 1 << R_I_nums[7]); // rPC
    badMask |= ((long) 1 << R_G_nums[2]); // TLS
    badMask |= ((long) 1 << R_G_nums[7]); // reserved by libthread

    for (int i = 0; i < 8; i++) {
      R_LIO_mask |= ((long) 1 << R_L_nums[i]);
      R_LIO_mask |= ((long) 1 << R_I_nums[i]);
      R_LIO_mask |= ((long) 1 << R_O_nums[i]);
    }
  }

  /** This is the only public constructor, and is only called by
      SolarisSPARCJavaThread */
  public SPARCRegisterMap(JavaThread thread, boolean updateMap) {
    super(thread, updateMap);
  }

  protected SPARCRegisterMap(RegisterMap map) {
    super(map);
  }

  public Object clone() {
    SPARCRegisterMap retval = new SPARCRegisterMap(this);
    return retval;
  }

  protected void clearPD() {
    if (thread.hasLastJavaFrame()) {
      Frame fr = thread.getLastFrame();
      window = fr.getSP();
    } else {
      window = null;
      if (VM.getVM().isDebugging()) {
        Frame fr = thread.getCurrentFrameGuess();
        if (fr != null) {
          window = fr.getSP();
        }
      }
    }
    youngerWindow = null;
  }

  protected Address getLocationPD(VMReg vmreg) {
    VM vm = VM.getVM();
    int regname = vmreg.getValue();
    if (Assert.ASSERTS_ENABLED) {
       Assert.that(0 <= regname && regname < regCount, "sanity check");
    }

    // Only the GPRs get handled this way
    if (regname >= (registerImplNumberOfRegisters << 1)) {
       return null;
    }

    // don't talk about bad registers
    if ((badMask & ((long) 1 << regname)) != 0) {
      return null;
    }

    // Convert to a GPR
    int secondWord = 0;
    // 32-bit registers for in, out and local
    if (!isEven(regname)) {
      if (vm.isLP64()) {
        secondWord = sizeofJint;
      } else {
        return null;
      }
    }

    SPARCRegister reg = new SPARCRegister(regname >> 1);
    if (reg.isOut()) {
      if (Assert.ASSERTS_ENABLED) {
         Assert.that(youngerWindow != null, "Younger window should be available");
      }
      return youngerWindow.addOffsetTo(reg.afterSave().spOffsetInSavedWindow() + secondWord);
    }
    if (reg.isLocal() || reg.isIn()) {
      if (Assert.ASSERTS_ENABLED) {
        Assert.that(window != null, "Window should be available");
      }
      return window.addOffsetTo(reg.spOffsetInSavedWindow() + secondWord);
    }

    // Only the window'd GPRs get handled this way; not the globals.
    return null;
  }

  protected void initializePD() {
    window        = null;
    youngerWindow = null;
    // avoid the shift_individual_registers game
    makeIntegerRegsUnsaved();
  }

  protected void initializeFromPD(RegisterMap map) {
    SPARCRegisterMap srm = (SPARCRegisterMap) map;
    window        = srm.window;
    youngerWindow = srm.youngerWindow;
    // avoid the shift_individual_registers game
    makeIntegerRegsUnsaved();
  }

  public void shiftWindow(Address sp, Address youngerSP) {
    window        = sp;
    youngerWindow = youngerSP;
    // Throw away locations for %i, %o, and %l registers:
    // But do not throw away %g register locs.
    if (locationValid[0] != 0) {
      shiftIndividualRegisters();
    }
  }

  /** When popping out of compiled frames, we make all IRegs disappear. */
  public void makeIntegerRegsUnsaved() {
    locationValid[0] = 0;
  }

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

  private void shiftIndividualRegisters() {
    if (!getUpdateMap()) {
      return;
    }

    checkLocationValid();

    long lv = locationValid[0];
    long lv0 = lv;

    lv &= ~R_LIO_mask;  // clear %l, %o, %i regs

    // if we cleared some non-%g locations, we may have to do some shifting
    if (lv != lv0) {
      // copy %i0-%i5 to %o0-%o5, if they have special locations
      // This can happen in within stubs which spill argument registers
      // around a dynamic link operation, such as resolve_opt_virtual_call.
      for (int i = 0; i < 8; i++) {
        if ((lv0 & ((long) 1 << R_I_nums[i])) != 0) {
          location[R_O_nums[i]] = location[R_I_nums[i]];
          lv |= ((long) 1 << R_O_nums[i]);
        }
      }
    }

    locationValid[0] = lv;
    checkLocationValid();
  }

  private boolean isEven(int i) {
    return (i & 1) == 0;
  }

  private void checkLocationValid() {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that((locationValid[0] & badMask) == 0, "cannot have special locations for SP,FP,TLS,etc.");
    }
  }
}

sun/jvm/hotspot/runtime/sparc/SPARCRegisterMap.java

 

JDK 11 jdk.httpserver.jmod - HTTP Server Module

JDK 11 jdk.editpad.jmod - Edit Pad Module

Download and Use JDK 11

⇑⇑ FAQ for JDK (Java Development Kit)

2020-02-29, 23243👍, 0💬