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/debugger/windbg/WindbgCDebugInfoBuilder.java
/*
* Copyright (c) 2002, 2003, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package sun.jvm.hotspot.debugger.windbg;
import java.util.*;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.debugger.win32.coff.*;
import sun.jvm.hotspot.debugger.cdbg.*;
import sun.jvm.hotspot.debugger.cdbg.basic.*;
import sun.jvm.hotspot.utilities.Assert;
class WindbgCDebugInfoBuilder
implements DebugVC50SubsectionTypes, DebugVC50TypeLeafIndices, DebugVC50TypeEnums, DebugVC50SymbolTypes, DebugVC50MemberAttributes, CVAttributes, AccessControl {
private WindbgDebugger dbg;
private Address base;
private DebugVC50 vc50;
private BasicCDebugInfoDataBase db;
private DebugVC50TypeIterator iter;
private DebugVC50SymbolIterator symIter;
// Logical->physical segment mapping
private COFFFile file;
private DebugVC50SSSegMap segMap;
// Canonicalization of primitive types
private Map primIndexToTypeMap;
// Global unnamed enumeration
// (FIXME: must figure out how to handle nested type descriptions)
private BasicEnumType unnamedEnum;
private Stack blockStack;
private int endsToSkip;
private static final int POINTER_SIZE = 4;
WindbgCDebugInfoBuilder(WindbgDebugger dbg) {
this.dbg = dbg;
}
CDebugInfoDataBase buildDataBase(String dllName, Address base) {
this.base = base;
file = COFFFileParser.getParser().parse(dllName);
vc50 = getDebugVC50(file);
if (vc50 == null) return null;
segMap = getSegMap();
primIndexToTypeMap = new HashMap();
blockStack = new Stack();
endsToSkip = 0;
db = new BasicCDebugInfoDataBase();
db.beginConstruction();
// Get global types and add them to the database
DebugVC50SSGlobalTypes types = getGlobalTypes();
for (iter = types.getTypeIterator(); !iter.done(); iter.next()) {
while (!iter.typeStringDone()) {
switch (iter.typeStringLeaf()) {
case LF_MODIFIER: {
int idx = iter.getModifierIndex();
BasicType target = getTypeByIndex(idx);
short windowsMods = iter.getModifierAttribute();
short mods = 0;
if ((windowsMods & MODIFIER_CONST_MASK) != 0) mods |= CONST;
if ((windowsMods & MODIFIER_VOLATILE_MASK) != 0) mods |= VOLATILE;
putType(target.getCVVariant(mods));
break;
}
case LF_POINTER: {
int idx = iter.getPointerType();
BasicType target = getTypeByIndex(idx);
short windowsMods = iter.getModifierAttribute();
short mods = 0;
if ((windowsMods & POINTER_CONST_MASK) != 0) mods |= CONST;
if ((windowsMods & POINTER_VOLATILE_MASK) != 0) mods |= VOLATILE;
BasicPointerType ptrType = new BasicPointerType(POINTER_SIZE, target);
if (mods != 0) {
ptrType = (BasicPointerType) ptrType.getCVVariant(mods);
}
putType(ptrType);
break;
}
case LF_ARRAY: {
BasicType elemType = getTypeByIndex(iter.getArrayElementType());
putType(new BasicArrayType(iter.getArrayName(), elemType, iter.getArrayLength()));
break;
}
case LF_CLASS:
case LF_STRUCTURE: {
CompoundTypeKind kind = ((iter.typeStringLeaf() == LF_CLASS) ? CompoundTypeKind.CLASS
: CompoundTypeKind.STRUCT);
BasicCompoundType type = new BasicCompoundType(iter.getClassName(),
iter.getClassSize(),
kind);
// Skip parsing of forward references to types
// FIXME: do we have to resolve these later?
if ((iter.getClassProperty() & PROPERTY_FWDREF) == 0) {
DebugVC50TypeIterator fieldIter = iter.getClassFieldListIterator();
if (Assert.ASSERTS_ENABLED) {
Assert.that(fieldIter.typeStringLeaf() == LF_FIELDLIST, "Expected field list");
}
boolean advance = false;
while (!fieldIter.typeStringDone()) {
advance = true;
switch (fieldIter.typeStringLeaf()) {
case LF_FIELDLIST: break;
case LF_BCLASS: {
int accessControl = memberAttributeToAccessControl(fieldIter.getBClassAttribute());
Type baseType = getTypeByIndex(fieldIter.getBClassType());
// FIXME: take offset into account
type.addBaseClass(new BasicBaseClass(accessControl, false, baseType));
break;
}
case LF_VBCLASS: {
int accessControl = memberAttributeToAccessControl(fieldIter.getVBClassAttribute());
Type baseType = getTypeByIndex(fieldIter.getVBClassBaseClassType());
// FIXME: take offset and virtual base offset into account
type.addBaseClass(new BasicBaseClass(accessControl, true, baseType));
break;
}
// I don't think we need to handle indirect virtual base
// classes since they should be handled indirectly through
// the modeling of the type hierarchy
case LF_IVBCLASS: break;
case LF_INDEX: {
fieldIter = fieldIter.getIndexIterator();
advance = false;
break;
}
case LF_MEMBER: {
BasicField field = new BasicField(fieldIter.getMemberName(),
getTypeByIndex(fieldIter.getMemberType()),
memberAttributeToAccessControl(fieldIter.getMemberAttribute()),
false);
field.setOffset(fieldIter.getMemberOffset());
type.addField(field);
break;
}
case LF_STMEMBER: {
BasicField field = new BasicField(fieldIter.getStaticName(),
getTypeByIndex(fieldIter.getStaticType()),
memberAttributeToAccessControl(fieldIter.getStaticAttribute()),
true);
// The field's address will be found during resolution
// of the debug info database
type.addField(field);
break;
}
// FIXME: handle methods
case LF_METHOD: break;
case LF_ONEMETHOD: break;
// FIXME: handle nested types
case LF_NESTTYPE: break;
case LF_NESTTYPEEX: break;
// NOTE: virtual functions not needed/handled yet for
// this debugging system (because we are not planning to
// handle calling methods in the target process at
// runtime)
case LF_VFUNCTAB: break;
case LF_FRIENDCLS: break;
case LF_VFUNCOFF: break;
case LF_MEMBERMODIFY: break;
case LF_PAD0: case LF_PAD1: case LF_PAD2: case LF_PAD3:
case LF_PAD4: case LF_PAD5: case LF_PAD6: case LF_PAD7:
case LF_PAD8: case LF_PAD9: case LF_PAD10: case LF_PAD11:
case LF_PAD12: case LF_PAD13: case LF_PAD14: case LF_PAD15: break;
default: System.err.println("WARNING: unexpected leaf index " +
fieldIter.typeStringLeaf() +
" in field list for type " + iter.getTypeIndex());
}
if (advance) {
fieldIter.typeStringNext();
}
}
}
putType(type);
break;
}
case LF_UNION: {
BasicCompoundType type = new BasicCompoundType(iter.getUnionName(),
iter.getUnionSize(),
CompoundTypeKind.UNION);
// Skip parsing of forward references to types
// FIXME: do we have to resolve these later?
if ((iter.getClassProperty() & PROPERTY_FWDREF) == 0) {
DebugVC50TypeIterator fieldIter = iter.getUnionFieldListIterator();
if (Assert.ASSERTS_ENABLED) {
Assert.that(fieldIter.typeStringLeaf() == LF_FIELDLIST, "Expected field list");
}
boolean advance = false;
while (!fieldIter.typeStringDone()) {
advance = true;
switch (fieldIter.typeStringLeaf()) {
case LF_FIELDLIST: break;
case LF_BCLASS: break;
case LF_VBCLASS: break;
case LF_IVBCLASS: break;
case LF_INDEX: {
fieldIter = fieldIter.getIndexIterator();
advance = false;
break;
}
case LF_MEMBER: {
BasicField field = new BasicField(fieldIter.getMemberName(),
getTypeByIndex(fieldIter.getMemberType()),
memberAttributeToAccessControl(fieldIter.getMemberAttribute()),
false);
field.setOffset(fieldIter.getMemberOffset());
type.addField(field);
break;
}
case LF_STMEMBER: {
System.err.println("WARNING: I didn't think unions could contain static fields...");
BasicField field = new BasicField(fieldIter.getStaticName(),
getTypeByIndex(fieldIter.getStaticType()),
memberAttributeToAccessControl(fieldIter.getStaticAttribute()),
true);
// The field's address will be found during resolution
// of the debug info database
type.addField(field);
break;
}
case LF_METHOD: break;
case LF_ONEMETHOD: break;
// FIXME: handle nested types
case LF_NESTTYPE: break;
case LF_NESTTYPEEX: break;
case LF_VFUNCTAB: break;
case LF_FRIENDCLS: break;
case LF_VFUNCOFF: break;
case LF_MEMBERMODIFY: break;
case LF_PAD0: case LF_PAD1: case LF_PAD2: case LF_PAD3:
case LF_PAD4: case LF_PAD5: case LF_PAD6: case LF_PAD7:
case LF_PAD8: case LF_PAD9: case LF_PAD10: case LF_PAD11:
case LF_PAD12: case LF_PAD13: case LF_PAD14: case LF_PAD15: break;
default: System.err.println("WARNING: unexpected leaf index " +
fieldIter.typeStringLeaf() +
" in field list for union of type " + iter.getTypeIndex());
}
if (advance) {
fieldIter.typeStringNext();
}
}
}
putType(type);
break;
}
case LF_ENUM: {
String name = iter.getEnumName();
BasicEnumType enumType = null;
if ((name == null) || (name.equals(""))) {
if (unnamedEnum == null) {
unnamedEnum = new BasicEnumType(null, getTypeByIndex(iter.getEnumType()));
}
enumType = unnamedEnum;
} else {
enumType = new BasicEnumType(name, getTypeByIndex(iter.getEnumType()));
}
DebugVC50TypeIterator fieldIter = iter.getEnumFieldListIterator();
if (Assert.ASSERTS_ENABLED) {
Assert.that(fieldIter.typeStringLeaf() == LF_FIELDLIST, "Expected field list");
}
boolean advance = false;
while (!fieldIter.typeStringDone()) {
advance = true;
switch (fieldIter.typeStringLeaf()) {
case LF_FIELDLIST: break;
case LF_ENUMERATE: {
String enumName = fieldIter.getEnumerateName();
long enumVal = fieldIter.getEnumerateValue();
enumType.addEnum(enumName, enumVal);
break;
}
case LF_INDEX: {
fieldIter = fieldIter.getIndexIterator();
advance = false;
break;
}
case LF_PAD0: case LF_PAD1: case LF_PAD2: case LF_PAD3:
case LF_PAD4: case LF_PAD5: case LF_PAD6: case LF_PAD7:
case LF_PAD8: case LF_PAD9: case LF_PAD10: case LF_PAD11:
case LF_PAD12: case LF_PAD13: case LF_PAD14: case LF_PAD15: break;
default: System.err.println("WARNING: unexpected leaf index " +
fieldIter.typeStringLeaf() +
" in field list for enum of type " + iter.getTypeIndex());
}
if (advance) {
fieldIter.typeStringNext();
}
}
putType(enumType);
break;
}
case LF_PROCEDURE: {
Type retType = getTypeByIndex(iter.getProcedureReturnType());
BasicFunctionType func = new BasicFunctionType(null, POINTER_SIZE, retType);
DebugVC50TypeIterator argIter = iter.getProcedureArgumentListIterator();
if (Assert.ASSERTS_ENABLED) {
Assert.that(argIter.typeStringLeaf() == LF_ARGLIST, "Expected argument list");
}
for (int i = 0; i < argIter.getArgListCount(); i++) {
func.addArgumentType(getTypeByIndex(argIter.getArgListType(i)));
}
putType(func);
break;
}
case LF_MFUNCTION: {
Type retType = getTypeByIndex(iter.getMFunctionReturnType());
Type container = getTypeByIndex(iter.getMFunctionContainingClass());
Type thisType = getTypeByIndex(iter.getMFunctionThis());
long thisAdjust = iter.getMFunctionThisAdjust();
BasicMemberFunctionType func = new BasicMemberFunctionType(null,
POINTER_SIZE,
retType,
container,
thisType,
thisAdjust);
DebugVC50TypeIterator argIter = iter.getMFunctionArgumentListIterator();
for (int i = 0; i < argIter.getArgListCount(); i++) {
func.addArgumentType(getTypeByIndex(argIter.getArgListType(i)));
}
putType(func);
break;
}
// FIXME: handle virtual function table shape description
case LF_VTSHAPE: break;
case LF_BARRAY: System.err.println("FIXME: don't know what to do with LF_BARRAY leaves (convert to pointers?"); break;
case LF_LABEL: break;
case LF_NULL: break; // FIXME: do we need to handle this? With what?
case LF_DIMARRAY: System.err.println("FIXME: don't know what to do with LF_DIMARRAY leaves yet"); break;
case LF_VFTPATH: break;
case LF_PRECOMP: break;
case LF_ENDPRECOMP: break;
case LF_OEM: break;
case LF_TYPESERVER: break;
// Type records referenced from other type records
case LF_SKIP: break;
case LF_ARGLIST: skipTypeRecord(); break;
case LF_DEFARG: System.err.println("FIXME: handle default arguments (dereference the type)"); break;
case LF_FIELDLIST: skipTypeRecord(); break;
case LF_DERIVED: break;
case LF_BITFIELD: {
Type underlyingType = getTypeByIndex(iter.getBitfieldFieldType());
BasicBitType bit = new BasicBitType(underlyingType,
(iter.getBitfieldLength() & 0xFF),
(iter.getBitfieldPosition() & 0xFF));
putType(bit);
break;
}
case LF_METHODLIST: break;
case LF_DIMCONU:
case LF_DIMCONLU:
case LF_DIMVARU:
case LF_DIMVARLU: break;
case LF_REFSYM: break;
case LF_PAD0: case LF_PAD1: case LF_PAD2: case LF_PAD3:
case LF_PAD4: case LF_PAD5: case LF_PAD6: case LF_PAD7:
case LF_PAD8: case LF_PAD9: case LF_PAD10: case LF_PAD11:
case LF_PAD12: case LF_PAD13: case LF_PAD14: case LF_PAD15: break;
default: {
System.err.println("Unexpected leaf index " +
iter.typeStringLeaf() + " at offset 0x" +
Integer.toHexString(iter.typeStringOffset()));
break;
}
}
if (!iter.typeStringDone()) {
iter.typeStringNext();
}
}
}
// Add all symbol directories to debug info
// (FIXME: must figure out how to handle module-by-module
// arrangement of at least the static symbols to have proper
// lookup -- should probably also take advantage of the PROCREF
// and UDT references to understand how to build the global
// database vs. the module-by-module one)
DebugVC50SubsectionDirectory dir = vc50.getSubsectionDirectory();
int moduleNumber = 0; // Debugging
for (int i = 0; i < dir.getNumEntries(); i++) {
DebugVC50Subsection ss = dir.getSubsection(i);
int ssType = ss.getSubsectionType();
boolean process = false;
if ((ssType == SST_GLOBAL_SYM) ||
(ssType == SST_GLOBAL_PUB) ||
(ssType == SST_STATIC_SYM)) {
DebugVC50SSSymbolBase syms = (DebugVC50SSSymbolBase) ss;
symIter = syms.getSymbolIterator();
process = true;
}
if (ssType == SST_ALIGN_SYM) {
DebugVC50SSAlignSym syms = (DebugVC50SSAlignSym) ss;
symIter = syms.getSymbolIterator();
process = true;
}
if (process) {
for (; !symIter.done(); symIter.next()) {
switch (symIter.getType()) {
case S_COMPILE: break;
case S_SSEARCH: break; // FIXME: may need this later
case S_END: {
try {
// FIXME: workaround for warnings until we figure out
// what to do with THUNK32 symbols
if (endsToSkip == 0) {
blockStack.pop();
} else {
--endsToSkip;
}
} catch (EmptyStackException e) {
System.err.println("WARNING: mismatched block begins/ends in debug information");
}
break;
}
case S_SKIP: break;
case S_CVRESERVE: break;
case S_OBJNAME: break; // FIXME: may need this later
case S_ENDARG: break;
case S_COBOLUDT: break;
case S_MANYREG: break; // FIXME: may need to add support for this
case S_RETURN: break; // NOTE: would need this if adding support for calling functions
case S_ENTRYTHIS: break; // FIXME: may need to add support for this
case S_REGISTER: break; // FIXME: may need to add support for this
case S_CONSTANT: break; // FIXME: will need to add support for this
case S_UDT: break; // FIXME: need to see how these are used; are
// they redundant, or are they used to describe
// global variables as opposed to types?
case S_COBOLUDT2: break;
case S_MANYREG2: break;
case S_BPREL32: {
LocalSym sym = new BasicLocalSym(symIter.getBPRelName(),
getTypeByIndex(symIter.getBPRelType()),
symIter.getBPRelOffset());
addLocalToCurBlock(sym);
break;
}
case S_LDATA32:
case S_GDATA32: {
// FIXME: must handle these separately from global data (have
// module scoping and only add these at the module level)
boolean isModuleLocal = (symIter.getType() == S_LDATA32);
GlobalSym sym = new BasicGlobalSym(symIter.getLGDataName(),
getTypeByIndex(symIter.getLGDataType()),
newAddress(symIter.getLGDataOffset(), symIter.getLGDataSegment()),
isModuleLocal);
// FIXME: must handle module-local symbols differently
addGlobalSym(sym);
break;
}
case S_PUB32: break; // FIXME: figure out how these differ from
// above and how they are used
case S_LPROC32:
case S_GPROC32: {
BasicFunctionSym sym = new BasicFunctionSym(newLazyBlockSym(symIter.getLGProcParentOffset()),
symIter.getLGProcLength(),
newAddress(symIter.getLGProcOffset(), symIter.getLGProcSegment()),
symIter.getLGProcName(),
getTypeByIndex(symIter.getLGProcType()),
(symIter.getType() == S_LPROC32));
// FIXME: have to handle local procedures differently (have
// notion of modules and only add those procedures to the
// module they are defined in)
addBlock(sym);
break;
}
case S_THUNK32: {
// FIXME: see whether we need to handle these
skipEnd();
break;
}
case S_BLOCK32: {
BasicBlockSym sym = new BasicBlockSym(newLazyBlockSym(symIter.getBlockParentOffset()),
symIter.getBlockLength(),
newAddress(symIter.getBlockOffset(), symIter.getBlockSegment()),
symIter.getBlockName());
addBlock(sym);
break;
}
case S_WITH32: break;
case S_LABEL32: break;
case S_CEXMODEL32: break;
case S_VFTTABLE32: break; // FIXME: may need to handle this
// (most likely for run-time type determination)
case S_REGREL32: break; // FIXME: may need to add support for this
case S_LTHREAD32: break;
case S_GTHREAD32: break; // FIXME: may need to add support for these
case S_PROCREF: break;
case S_DATAREF: break;
case S_ALIGN: break;
default:
// These two unknown symbol types show up very frequently.
// Symbol type 0 appears to always be a no-op symbol of
// length 2 (i.e., length just covers the symbol type.)
// Symbol type 4115 appears to be a copyright notice for
// the Microsoft linker.
if ((symIter.getType() != 0) && (symIter.getType() != 4115)) {
System.err.println(" NOTE: Unexpected symbol of type " +
symIter.getType() + " at offset 0x" +
Integer.toHexString(symIter.getOffset()));
}
break;
}
}
}
}
// Add line number information for all modules
for (int i = 0; i < dir.getNumEntries(); i++) {
DebugVC50Subsection ss = dir.getSubsection(i);
if (ss.getSubsectionType() == SST_SRC_MODULE) {
DebugVC50SSSrcModule srcMod = (DebugVC50SSSrcModule) ss;
for (int sf = 0; sf < srcMod.getNumSourceFiles(); sf++) {
DebugVC50SrcModFileDesc desc = srcMod.getSourceFileDesc(sf);
// Uniquify these to save space
String name = desc.getSourceFileName().intern();
for (int cs = 0; cs < desc.getNumCodeSegments(); cs++) {
DebugVC50SrcModLineNumberMap map = desc.getLineNumberMap(cs);
SectionHeader seg = file.getHeader().getSectionHeader(map.getSegment());
for (int lp = 0; lp < map.getNumSourceLinePairs(); lp++) {
Address startPC = base.addOffsetTo(seg.getVirtualAddress() + map.getCodeOffset(lp));
// Fake address for endPC -- will be filled in by BasicLineNumberMapping
Address endPC = base.addOffsetTo(seg.getSize());
db.addLineNumberInfo(new BasicLineNumberInfo(name, map.getLineNumber(lp), startPC, endPC));
}
}
}
}
}
// Finish assembly of database
db.resolve(new ResolveListener() {
public void resolveFailed(Type containingType, LazyType failedResolve, String detail) {
System.err.println("WARNING: failed to resolve type of index " +
((Integer) failedResolve.getKey()).intValue() +
" in type " + containingType.getName() + " (class " +
containingType.getClass().getName() + ") while " + detail);
}
public void resolveFailed(Type containingType, String staticFieldName) {
System.err.println("WARNING: failed to resolve address of static field \"" +
staticFieldName + "\" in type " + containingType.getName());
}
public void resolveFailed(Sym containingSymbol, LazyType failedResolve, String detail) {
System.err.println("WARNING: failed to resolve type of index " +
((Integer) failedResolve.getKey()).intValue() +
" in symbol of type " + containingSymbol.getClass().getName() +
" while " + detail);
}
public void resolveFailed(Sym containingSymbol, LazyBlockSym failedResolve, String detail) {
System.err.println("WARNING: failed to resolve block at offset 0x" +
Integer.toHexString(((Integer) failedResolve.getKey()).intValue()) +
" in symbol of type " + containingSymbol.getClass().getName() +
" while " + detail);
}
});
db.endConstruction();
return db;
}
//----------------------------------------------------------------------
// Internals only below this point
//
private static DebugVC50 getDebugVC50(COFFFile file) {
COFFHeader header = file.getHeader();
OptionalHeader opt = header.getOptionalHeader();
if (opt == null) {
// Optional header not found
return null;
}
OptionalHeaderDataDirectories dd = opt.getDataDirectories();
if (dd == null) {
// Optional header data directories not found
return null;
}
DebugDirectory debug = dd.getDebugDirectory();
if (debug == null) {
// Debug directory not found
return null;
}
for (int i = 0; i < debug.getNumEntries(); i++) {
DebugDirectoryEntry entry = debug.getEntry(i);
if (entry.getType() == DebugTypes.IMAGE_DEBUG_TYPE_CODEVIEW) {
return entry.getDebugVC50();
}
}
// CodeView information not found in debug directory
return null;
}
private DebugVC50SSSegMap getSegMap() {
return (DebugVC50SSSegMap) findSubsection(SST_SEG_MAP);
}
private DebugVC50SSGlobalTypes getGlobalTypes() {
return (DebugVC50SSGlobalTypes) findSubsection(SST_GLOBAL_TYPES);
}
private DebugVC50SSGlobalSym getGlobalSymbols() {
return (DebugVC50SSGlobalSym) findSubsection(SST_GLOBAL_SYM);
}
private DebugVC50Subsection findSubsection(short ssType) {
DebugVC50SubsectionDirectory dir = vc50.getSubsectionDirectory();
for (int i = 0; i < dir.getNumEntries(); i++) {
DebugVC50Subsection ss = dir.getSubsection(i);
if (ss.getSubsectionType() == ssType) {
return ss;
}
}
throw new DebuggerException("Unable to find subsection of type " + ssType);
}
private void putType(Type t) {
db.addType(new Integer(iter.getTypeIndex()), t);
}
private Address newAddress(int offset, short segment) {
int seg = segment & 0xFFFF;
// NOTE: it isn't clear how to use the segMap to map from logical
// to physical segments. It seems it would make more sense if the
// SegDescs contained a physical segment number in addition to the
// offset within the physical segment of the logical one.
// Get the section header corresponding to this segment
SectionHeader section = file.getHeader().getSectionHeader(seg);
// Result is relative to image base
return base.addOffsetTo(section.getVirtualAddress() + offset);
}
private BasicType getTypeByIndex(int intIndex) {
Integer index = new Integer(intIndex);
// Handle primitive types here.
if (intIndex <= 0x0FFF) {
BasicType type = (BasicType) primIndexToTypeMap.get(index);
if (type != null) {
return type;
}
// Construct appropriate new primitive type
int primMode = intIndex & RESERVED_MODE_MASK;
if (primMode == RESERVED_MODE_DIRECT) {
int primType = intIndex & RESERVED_TYPE_MASK;
switch (primType) {
case RESERVED_TYPE_SIGNED_INT:
case RESERVED_TYPE_UNSIGNED_INT: {
boolean unsigned = (primType == RESERVED_TYPE_UNSIGNED_INT);
int size = 0;
String name = null;
switch (intIndex & RESERVED_SIZE_MASK) {
case RESERVED_SIZE_INT_1_BYTE: size = 1; name = "char"; break;
case RESERVED_SIZE_INT_2_BYTE: size = 2; name = "short"; break;
case RESERVED_SIZE_INT_4_BYTE: size = 4; name = "int"; break;
case RESERVED_SIZE_INT_8_BYTE: size = 8; name = "__int64"; break;
default: throw new DebuggerException("Illegal size of integer type " + intIndex);
}
type = new BasicIntType(name, size, unsigned);
break;
}
case RESERVED_TYPE_BOOLEAN: {
int size = 0;
switch (intIndex & RESERVED_SIZE_MASK) {
case RESERVED_SIZE_INT_1_BYTE: size = 1; break;
case RESERVED_SIZE_INT_2_BYTE: size = 2; break;
case RESERVED_SIZE_INT_4_BYTE: size = 4; break;
case RESERVED_SIZE_INT_8_BYTE: size = 8; break;
default: throw new DebuggerException("Illegal size of boolean type " + intIndex);
}
type = new BasicIntType("bool", size, false);
break;
}
case RESERVED_TYPE_REAL: {
switch (intIndex & RESERVED_SIZE_MASK) {
case RESERVED_SIZE_REAL_32_BIT:
type = new BasicFloatType("float", 4);
break;
case RESERVED_SIZE_REAL_64_BIT:
type = new BasicDoubleType("double", 8);
break;
default:
throw new DebuggerException("Unsupported floating-point size in type " + intIndex);
}
break;
}
case RESERVED_TYPE_REALLY_INT: {
switch (intIndex & RESERVED_SIZE_MASK) {
case RESERVED_SIZE_REALLY_INT_CHAR: type = new BasicIntType("char", 1, false); break;
case RESERVED_SIZE_REALLY_INT_WCHAR: type = new BasicIntType("wchar", 2, false); break;
case RESERVED_SIZE_REALLY_INT_2_BYTE: type = new BasicIntType("short", 2, false); break;
case RESERVED_SIZE_REALLY_INT_2_BYTE_U: type = new BasicIntType("short", 2, true); break;
case RESERVED_SIZE_REALLY_INT_4_BYTE: type = new BasicIntType("int", 4, false); break;
case RESERVED_SIZE_REALLY_INT_4_BYTE_U: type = new BasicIntType("int", 4, true); break;
case RESERVED_SIZE_REALLY_INT_8_BYTE: type = new BasicIntType("__int64", 8, false); break;
case RESERVED_SIZE_REALLY_INT_8_BYTE_U: type = new BasicIntType("__int64", 8, true); break;
default: throw new DebuggerException("Illegal REALLY_INT size in type " + intIndex);
}
break;
}
case RESERVED_TYPE_SPECIAL: {
switch (intIndex & RESERVED_SIZE_MASK) {
case RESERVED_SIZE_SPECIAL_NO_TYPE:
case RESERVED_SIZE_SPECIAL_VOID: type = new BasicVoidType(); break;
default: throw new DebuggerException("Don't know how to handle reserved special type " + intIndex);
}
break;
}
default:
throw new DebuggerException("Don't know how to handle reserved type " + intIndex);
}
} else {
// Fold all pointer types together since we only support
// flat-mode addressing anyway
Type targetType = getTypeByIndex(intIndex & (~RESERVED_MODE_MASK));
type = new BasicPointerType(POINTER_SIZE, targetType);
}
if (Assert.ASSERTS_ENABLED) {
Assert.that(type != null, "Got null Type for primitive type " + intIndex);
}
primIndexToTypeMap.put(index, type);
return type;
}
// Not primitive type. Construct lazy reference to target type.
// (Is it worth canonicalizing these as well to save space?)
return new LazyType(index);
}
private void addBlock(BlockSym block) {
db.addBlock(new Integer(symIter.getOffset()), block);
blockStack.push(block);
}
private void skipEnd() {
++endsToSkip;
}
private BlockSym newLazyBlockSym(int offset) {
if (offset == 0) {
return null;
}
return new LazyBlockSym(new Integer(offset));
}
private int memberAttributeToAccessControl(short memberAttribute) {
int acc = memberAttribute & MEMATTR_ACCESS_MASK;
switch (acc) {
case MEMATTR_ACCESS_NO_PROTECTION: return NO_PROTECTION;
case MEMATTR_ACCESS_PRIVATE: return PRIVATE;
case MEMATTR_ACCESS_PROTECTED: return PROTECTED;
case MEMATTR_ACCESS_PUBLIC: return PUBLIC;
default: throw new RuntimeException("Should not reach here");
}
}
private void addLocalToCurBlock(LocalSym local) {
((BasicBlockSym) blockStack.peek()).addLocal(local);
}
private void addGlobalSym(GlobalSym sym) {
db.addGlobalSym(sym);
}
private void skipTypeRecord() {
while (!iter.typeStringDone()) {
iter.typeStringNext();
}
}
}
⏎ sun/jvm/hotspot/debugger/windbg/WindbgCDebugInfoBuilder.java
Or download all of them as a single archive file:
File name: jdk.hotspot.agent-11.0.1-src.zip File size: 1243786 bytes Release date: 2018-11-04 Download
⇒ JDK 11 jdk.httpserver.jmod - HTTP Server Module
2020-02-29, 144822👍, 0💬
Related Topics: