agent/src/share/classes/sun/jvm/hotspot/HotSpotTypeDataBase.java
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 7088955 Sdiff agent/src/share/classes/sun/jvm/hotspot

agent/src/share/classes/sun/jvm/hotspot/HotSpotTypeDataBase.java

Print this page




  70       known is illegal. </P>
  71 
  72       <P> Throws NoSuchSymbolException if a problem occurred while
  73       looking up one of the bootstrapping symbols related to the
  74       VMStructs table in the remote VM; this may indicate that the
  75       remote process is not actually a HotSpot VM. </P>
  76   */
  77   public HotSpotTypeDataBase(MachineDescription machDesc,
  78                              VtblAccess vtblAccess,
  79                              Debugger symbolLookup,
  80                              String[] jvmLibNames) throws NoSuchSymbolException {
  81     super(machDesc, vtblAccess);
  82     this.symbolLookup = symbolLookup;
  83     this.jvmLibNames = jvmLibNames;
  84 
  85     readVMTypes();
  86     initializePrimitiveTypes();
  87     readVMStructs();
  88     readVMIntConstants();
  89     readVMLongConstants();

  90   }
  91 
  92   public Type lookupType(String cTypeName, boolean throwException) {
  93     Type fieldType = super.lookupType(cTypeName, false);
  94     if (fieldType == null && cTypeName.startsWith("const ")) {
  95       fieldType = (BasicType)lookupType(cTypeName.substring(6), false);
  96     }
  97     if (fieldType == null && cTypeName.endsWith(" const")) {
  98         fieldType = (BasicType)lookupType(cTypeName.substring(0, cTypeName.length() - 6), false);
  99     }
 100     if (fieldType == null) {
 101       if (cTypeName.startsWith("GrowableArray<") && cTypeName.endsWith(">*")) {
 102         String ttype = cTypeName.substring("GrowableArray<".length(),
 103                                             cTypeName.length() - 2);
 104         Type templateType = lookupType(ttype, false);
 105         if (templateType == null && typeNameIsPointerType(ttype)) {
 106           templateType = recursiveCreateBasicPointerType(ttype);
 107         }
 108         if (templateType == null) {
 109           lookupOrFail(ttype);
 110         }
 111         fieldType = recursiveCreateBasicPointerType(cTypeName);












 112       }

 113     }

 114     if (fieldType == null && typeNameIsPointerType(cTypeName)) {
 115       fieldType = recursiveCreateBasicPointerType(cTypeName);
 116     }
 117     if (fieldType == null && throwException) {
 118       super.lookupType(cTypeName, true);
 119     }
 120     return fieldType;
 121   }
 122 
 123   private void readVMTypes() {
 124     // Get the variables we need in order to traverse the VMTypeEntry[]
 125     long typeEntryTypeNameOffset;
 126     long typeEntrySuperclassNameOffset;
 127     long typeEntryIsOopTypeOffset;
 128     long typeEntryIsIntegerTypeOffset;
 129     long typeEntryIsUnsignedOffset;
 130     long typeEntrySizeOffset;
 131     long typeEntryArrayStride;
 132 
 133     // Fetch the address of the VMTypeEntry*. We get this symbol first


 191     ((BasicType) getJBooleanType()).setIsJavaPrimitiveType(true);
 192     ((BasicType) getJByteType()).setIsJavaPrimitiveType(true);
 193     ((BasicType) getJCharType()).setIsJavaPrimitiveType(true);
 194     ((BasicType) getJDoubleType()).setIsJavaPrimitiveType(true);
 195     ((BasicType) getJFloatType()).setIsJavaPrimitiveType(true);
 196     ((BasicType) getJIntType()).setIsJavaPrimitiveType(true);
 197     ((BasicType) getJLongType()).setIsJavaPrimitiveType(true);
 198     ((BasicType) getJShortType()).setIsJavaPrimitiveType(true);
 199   }
 200 
 201   private Type lookupPrimitiveType(String typeName) {
 202     Type type = lookupType(typeName, false);
 203     if (type == null) {
 204       throw new RuntimeException("Error initializing the HotSpotDataBase: could not find the primitive type \"" +
 205                                  typeName + "\" in the remote VM's VMStructs table. This type is required in " +
 206                                  "order to determine the size of Java primitive types. Can not continue.");
 207     }
 208     return type;
 209   }
 210 






















































































































































 211   private void readVMStructs() {
 212     // Get the variables we need in order to traverse the VMStructEntry[]
 213     long structEntryTypeNameOffset;
 214     long structEntryFieldNameOffset;
 215     long structEntryTypeStringOffset;
 216     long structEntryIsStaticOffset;
 217     long structEntryOffsetOffset;
 218     long structEntryAddressOffset;
 219     long structEntryArrayStride;
 220 
 221     structEntryTypeNameOffset     = getLongValueFromProcess("gHotSpotVMStructEntryTypeNameOffset");
 222     structEntryFieldNameOffset    = getLongValueFromProcess("gHotSpotVMStructEntryFieldNameOffset");
 223     structEntryTypeStringOffset   = getLongValueFromProcess("gHotSpotVMStructEntryTypeStringOffset");
 224     structEntryIsStaticOffset     = getLongValueFromProcess("gHotSpotVMStructEntryIsStaticOffset");
 225     structEntryOffsetOffset       = getLongValueFromProcess("gHotSpotVMStructEntryOffsetOffset");
 226     structEntryAddressOffset      = getLongValueFromProcess("gHotSpotVMStructEntryAddressOffset");
 227     structEntryArrayStride        = getLongValueFromProcess("gHotSpotVMStructEntryArrayStride");
 228 
 229     // Fetch the address of the VMStructEntry*
 230     Address entryAddr = lookupInProcess("gHotSpotVMStructs");


 487     } else {
 488       targetType = lookupType(targetTypeName, false);
 489       if (targetType == null) {
 490         // Workaround for missing C integer types in database.
 491         // Also looks like we can't throw an exception for other
 492         // missing target types because there are some in old
 493         // VMStructs tables that didn't have the target type declared.
 494         // For this case, we create basic types that never get filled
 495         // in.
 496 
 497         if (targetTypeName.equals("char") ||
 498             targetTypeName.equals("const char")) {
 499           // We don't have a representation of const-ness of C types in the SA
 500           BasicType basicTargetType = createBasicType(targetTypeName, false, true, false);
 501           basicTargetType.setSize(1);
 502           targetType = basicTargetType;
 503         } else if (targetTypeName.equals("u_char")) {
 504           BasicType basicTargetType = createBasicType(targetTypeName, false, true, true);
 505           basicTargetType.setSize(1);
 506           targetType = basicTargetType;
 507         } else if (targetTypeName.startsWith("GrowableArray<")) {
 508           BasicType basicTargetType = createBasicType(targetTypeName, false, false, false);
 509 
 510           // transfer fields from GenericGrowableArray to template instance
 511           BasicType generic = lookupOrFail("GenericGrowableArray");
 512           basicTargetType.setSize(generic.getSize());
 513           Iterator fields = generic.getFields();
 514           while (fields.hasNext()) {
 515               Field f = (Field)fields.next();
 516               basicTargetType.addField(internalCreateField(basicTargetType, f.getName(),
 517                                                            f.getType(), f.isStatic(),
 518                                                            f.getOffset(), null));
 519           }
 520           targetType = basicTargetType;
 521         } else {
 522           if (DEBUG) {
 523             System.err.println("WARNING: missing target type \"" + targetTypeName + "\" for pointer type \"" + typeName + "\"");
 524           }
 525           targetType = createBasicType(targetTypeName, false, false, false);
 526         }
 527       }
 528     }
 529     result = new BasicPointerType(this, typeName, targetType);
 530     result.setSize(UNINITIALIZED_SIZE);
 531     addType(result);
 532     return result;
 533   }
 534 
 535   private boolean typeNameIsPointerType(String typeName) {
 536     int i = typeName.length() - 1;
 537     while (i >= 0 && Character.isWhitespace(typeName.charAt(i))) {
 538       --i;
 539     }
 540     if (i >= 0 && typeName.charAt(i) == '*') {


 555         }
 556 
 557         // Lookup or create the current type
 558         BasicType curType = lookupOrCreateClass(typeName, isOopType, isIntegerType, isUnsigned);
 559         // Set superclass and/or ensure it's correct
 560         if (superclass != null) {
 561             if (curType.getSuperclass() == null) {
 562                 // Set the superclass in the current type
 563                 curType.setSuperclass(superclass);
 564             }
 565 
 566             if (curType.getSuperclass() != superclass) {
 567                 throw new RuntimeException("Error: the type \"" + typeName + "\" (declared in the remote VM in VMStructs::localHotSpotVMTypes) " +
 568                                            "had its superclass redefined (old was " + curType.getSuperclass().getName() + ", new is " +
 569                                            superclass.getName() + ").");
 570             }
 571         }
 572 
 573         // Classes are created with a size of UNINITIALIZED_SIZE.
 574         // Set size if necessary.
 575         if (curType.getSize() == UNINITIALIZED_SIZE) {
 576             curType.setSize(size);
 577         } else {
 578             if (curType.getSize() != size) {
 579                 throw new RuntimeException("Error: the type \"" + typeName + "\" (declared in the remote VM in VMStructs::localHotSpotVMTypes) " +
 580                                            "had its size redefined (old was " + curType.getSize() + ", new is " + size + ").");
 581             }
 582 
 583             System.err.println("Warning: the type \"" + typeName + "\" (declared in the remote VM in VMStructs::localHotSpotVMTypes) " +
 584                                "had its size declared as " + size + " twice. Continuing.");
 585         }
 586 
 587     }
 588 
 589     /** "Virtual constructor" for fields based on type */
 590     public void createField(BasicType containingType,
 591                             String name, Type type, boolean isStatic,
 592                             long offset, Address staticFieldAddress) {
 593         // Add field to containing type
 594         containingType.addField(internalCreateField(containingType, name, type, isStatic, offset, staticFieldAddress));
 595     }




  70       known is illegal. </P>
  71 
  72       <P> Throws NoSuchSymbolException if a problem occurred while
  73       looking up one of the bootstrapping symbols related to the
  74       VMStructs table in the remote VM; this may indicate that the
  75       remote process is not actually a HotSpot VM. </P>
  76   */
  77   public HotSpotTypeDataBase(MachineDescription machDesc,
  78                              VtblAccess vtblAccess,
  79                              Debugger symbolLookup,
  80                              String[] jvmLibNames) throws NoSuchSymbolException {
  81     super(machDesc, vtblAccess);
  82     this.symbolLookup = symbolLookup;
  83     this.jvmLibNames = jvmLibNames;
  84 
  85     readVMTypes();
  86     initializePrimitiveTypes();
  87     readVMStructs();
  88     readVMIntConstants();
  89     readVMLongConstants();
  90     readExternalDefinitions();
  91   }
  92 
  93   public Type lookupType(String cTypeName, boolean throwException) {
  94     Type fieldType = super.lookupType(cTypeName, false);
  95     if (fieldType == null && cTypeName.startsWith("const ")) {
  96       fieldType = (BasicType)lookupType(cTypeName.substring(6), false);
  97     }
  98     if (fieldType == null && cTypeName.endsWith(" const")) {
  99         fieldType = (BasicType)lookupType(cTypeName.substring(0, cTypeName.length() - 6), false);
 100     }
 101     if (fieldType == null) {
 102       if (cTypeName.startsWith("GrowableArray<") && cTypeName.endsWith(">")) {
 103         String ttype = cTypeName.substring("GrowableArray<".length(),
 104                                             cTypeName.length() - 1);
 105         Type templateType = lookupType(ttype, false);
 106         if (templateType == null && typeNameIsPointerType(ttype)) {
 107           templateType = recursiveCreateBasicPointerType(ttype);
 108         }
 109         if (templateType == null) {
 110           lookupOrFail(ttype);
 111         }
 112 
 113         BasicType basicTargetType = createBasicType(cTypeName, false, false, false);
 114 
 115         // transfer fields from GenericGrowableArray to template instance
 116         BasicType generic = lookupOrFail("GenericGrowableArray");
 117         BasicType specific = lookupOrFail("GrowableArray<int>");
 118         basicTargetType.setSize(specific.getSize());
 119         Iterator fields = generic.getFields();
 120         while (fields.hasNext()) {
 121           Field f = (Field)fields.next();
 122           basicTargetType.addField(internalCreateField(basicTargetType, f.getName(),
 123                                                        f.getType(), f.isStatic(),
 124                                                        f.getOffset(), null));
 125         }
 126         fieldType = basicTargetType;
 127       }
 128     }
 129     if (fieldType == null && typeNameIsPointerType(cTypeName)) {
 130       fieldType = recursiveCreateBasicPointerType(cTypeName);
 131     }
 132     if (fieldType == null && throwException) {
 133       super.lookupType(cTypeName, true);
 134     }
 135     return fieldType;
 136   }
 137 
 138   private void readVMTypes() {
 139     // Get the variables we need in order to traverse the VMTypeEntry[]
 140     long typeEntryTypeNameOffset;
 141     long typeEntrySuperclassNameOffset;
 142     long typeEntryIsOopTypeOffset;
 143     long typeEntryIsIntegerTypeOffset;
 144     long typeEntryIsUnsignedOffset;
 145     long typeEntrySizeOffset;
 146     long typeEntryArrayStride;
 147 
 148     // Fetch the address of the VMTypeEntry*. We get this symbol first


 206     ((BasicType) getJBooleanType()).setIsJavaPrimitiveType(true);
 207     ((BasicType) getJByteType()).setIsJavaPrimitiveType(true);
 208     ((BasicType) getJCharType()).setIsJavaPrimitiveType(true);
 209     ((BasicType) getJDoubleType()).setIsJavaPrimitiveType(true);
 210     ((BasicType) getJFloatType()).setIsJavaPrimitiveType(true);
 211     ((BasicType) getJIntType()).setIsJavaPrimitiveType(true);
 212     ((BasicType) getJLongType()).setIsJavaPrimitiveType(true);
 213     ((BasicType) getJShortType()).setIsJavaPrimitiveType(true);
 214   }
 215 
 216   private Type lookupPrimitiveType(String typeName) {
 217     Type type = lookupType(typeName, false);
 218     if (type == null) {
 219       throw new RuntimeException("Error initializing the HotSpotDataBase: could not find the primitive type \"" +
 220                                  typeName + "\" in the remote VM's VMStructs table. This type is required in " +
 221                                  "order to determine the size of Java primitive types. Can not continue.");
 222     }
 223     return type;
 224   }
 225 
 226   private void readExternalDefinitions() {
 227     String file = System.getProperty("sun.jvm.hotspot.typedb");
 228     if (file != null) {
 229       System.out.println("Reading " + file);
 230       BufferedReader in = null;
 231       try {
 232         StreamTokenizer t = new StreamTokenizer(in = new BufferedReader(new InputStreamReader(new FileInputStream(file))));
 233         t.resetSyntax();
 234         t.wordChars('\u0000','\uFFFF');
 235         t.whitespaceChars(' ', ' ');
 236         t.whitespaceChars('\n', '\n');
 237         t.whitespaceChars('\r', '\r');
 238         t.quoteChar('\"');
 239         t.eolIsSignificant(true);
 240         while (t.nextToken() != StreamTokenizer.TT_EOF) {
 241           if (t.ttype == StreamTokenizer.TT_EOL) {
 242             continue;
 243           }
 244 
 245           if (t.sval.equals("field")) {
 246             t.nextToken();
 247             BasicType containingType = (BasicType)lookupType(t.sval);
 248             t.nextToken();
 249             String fieldName = t.sval;
 250 
 251             // The field's Type must already be in the database -- no exceptions
 252             t.nextToken();
 253             Type fieldType = lookupType(t.sval);
 254             t.nextToken();
 255             boolean isStatic = Boolean.valueOf(t.sval).booleanValue();
 256             t.nextToken();
 257             long offset = Long.parseLong(t.sval);
 258             t.nextToken();
 259             Address staticAddress = null;
 260             if (isStatic) {
 261               throw new InternalError("static fields not supported");
 262             }
 263 
 264             // check to see if the field already exists
 265             Iterator i = containingType.getFields();
 266             boolean defined = false;
 267             while (i.hasNext()) {
 268               Field f = (Field) i.next();
 269               if (f.getName().equals(fieldName)) {
 270                 if (f.isStatic() != isStatic) {
 271                   throw new RuntimeException("static/nonstatic mismatch: " + fieldName);
 272                 }
 273                 if (!isStatic) {
 274                   if (f.getOffset() != offset) {
 275                     throw new RuntimeException("bad redefinition of field offset: " + fieldName);
 276                   }
 277                 } else {
 278                   if (!f.getStaticFieldAddress().equals(staticAddress)) {
 279                     throw new RuntimeException("bad redefinition of field location: " + fieldName);
 280                   }
 281                 }
 282                 if (f.getType() != fieldType) {
 283                   System.out.println(fieldType);
 284                   System.out.println(f.getType());
 285                   throw new RuntimeException("bad redefinition of field type: " + fieldName);
 286                 }
 287                 defined = true;
 288                 break;
 289               }
 290             }
 291 
 292             if (!defined) {
 293               // Create field by type
 294               createField(containingType,
 295                           fieldName, fieldType,
 296                           isStatic,
 297                           offset,
 298                           staticAddress);
 299             }
 300           } else if (t.sval.equals("type")) {
 301             t.nextToken();
 302             String typeName = t.sval;
 303             t.nextToken();
 304             String superclassName = t.sval;
 305             if (superclassName.equals("null")) {
 306               superclassName = null;
 307             }
 308             t.nextToken();
 309             boolean isOop = Boolean.valueOf(t.sval).booleanValue();
 310             t.nextToken();
 311             boolean isInteger = Boolean.valueOf(t.sval).booleanValue();
 312             t.nextToken();
 313             boolean isUnsigned = Boolean.valueOf(t.sval).booleanValue();
 314             t.nextToken();
 315             long size = Long.parseLong(t.sval);
 316 
 317             BasicType type = null;
 318             try {
 319               type = (BasicType)lookupType(typeName);
 320             } catch (RuntimeException e) {
 321             }
 322             if (type != null) {
 323               if (type.isOopType() != isOop) {
 324                 throw new RuntimeException("oop mismatch in type definition: " + typeName);
 325               }
 326               if (type.isCIntegerType() != isInteger) {
 327                 throw new RuntimeException("integer type mismatch in type definition: " + typeName);
 328               }
 329               if (type.isCIntegerType() && (((CIntegerType)type).isUnsigned()) != isUnsigned) {
 330                 throw new RuntimeException("unsigned mismatch in type definition: " + typeName);
 331               }
 332               if (type.getSuperclass() == null) {
 333                 if (superclassName != null) {
 334                   if (type.getSize() == -1) {
 335                     type.setSuperclass(lookupType(superclassName));
 336                   } else {
 337                     throw new RuntimeException("unexpected superclass in type definition: " + typeName);
 338                   }
 339                 }
 340               } else {
 341                 if (superclassName == null) {
 342                   throw new RuntimeException("missing superclass in type definition: " + typeName);
 343                 }
 344                 if (!type.getSuperclass().getName().equals(superclassName)) {
 345                   throw new RuntimeException("incorrect superclass in type definition: " + typeName);
 346                 }
 347               }
 348               if (type.getSize() != size) {
 349                 if (type.getSize() == -1 || type.getSize() == 0) {
 350                   type.setSize(size);
 351                 } else {
 352                   throw new RuntimeException("size mismatch in type definition: " + typeName + ": " + type.getSize() + " != " + size);
 353                 }
 354               }
 355             }
 356 
 357             if (lookupType(typeName, false) == null) {
 358               // Create type
 359               createType(typeName, superclassName, isOop, isInteger, isUnsigned, size);
 360             }
 361           } else {
 362             throw new InternalError("\"" + t.sval + "\"");
 363           }
 364         }
 365       } catch (IOException ioe) {
 366         ioe.printStackTrace();
 367       } finally {
 368         try {
 369           in.close();
 370         } catch (Exception e) {
 371         }
 372       }
 373     }
 374   }
 375 
 376   private void readVMStructs() {
 377     // Get the variables we need in order to traverse the VMStructEntry[]
 378     long structEntryTypeNameOffset;
 379     long structEntryFieldNameOffset;
 380     long structEntryTypeStringOffset;
 381     long structEntryIsStaticOffset;
 382     long structEntryOffsetOffset;
 383     long structEntryAddressOffset;
 384     long structEntryArrayStride;
 385 
 386     structEntryTypeNameOffset     = getLongValueFromProcess("gHotSpotVMStructEntryTypeNameOffset");
 387     structEntryFieldNameOffset    = getLongValueFromProcess("gHotSpotVMStructEntryFieldNameOffset");
 388     structEntryTypeStringOffset   = getLongValueFromProcess("gHotSpotVMStructEntryTypeStringOffset");
 389     structEntryIsStaticOffset     = getLongValueFromProcess("gHotSpotVMStructEntryIsStaticOffset");
 390     structEntryOffsetOffset       = getLongValueFromProcess("gHotSpotVMStructEntryOffsetOffset");
 391     structEntryAddressOffset      = getLongValueFromProcess("gHotSpotVMStructEntryAddressOffset");
 392     structEntryArrayStride        = getLongValueFromProcess("gHotSpotVMStructEntryArrayStride");
 393 
 394     // Fetch the address of the VMStructEntry*
 395     Address entryAddr = lookupInProcess("gHotSpotVMStructs");


 652     } else {
 653       targetType = lookupType(targetTypeName, false);
 654       if (targetType == null) {
 655         // Workaround for missing C integer types in database.
 656         // Also looks like we can't throw an exception for other
 657         // missing target types because there are some in old
 658         // VMStructs tables that didn't have the target type declared.
 659         // For this case, we create basic types that never get filled
 660         // in.
 661 
 662         if (targetTypeName.equals("char") ||
 663             targetTypeName.equals("const char")) {
 664           // We don't have a representation of const-ness of C types in the SA
 665           BasicType basicTargetType = createBasicType(targetTypeName, false, true, false);
 666           basicTargetType.setSize(1);
 667           targetType = basicTargetType;
 668         } else if (targetTypeName.equals("u_char")) {
 669           BasicType basicTargetType = createBasicType(targetTypeName, false, true, true);
 670           basicTargetType.setSize(1);
 671           targetType = basicTargetType;














 672         } else {
 673           if (DEBUG) {
 674             System.err.println("WARNING: missing target type \"" + targetTypeName + "\" for pointer type \"" + typeName + "\"");
 675           }
 676           targetType = createBasicType(targetTypeName, false, false, false);
 677         }
 678       }
 679     }
 680     result = new BasicPointerType(this, typeName, targetType);
 681     result.setSize(UNINITIALIZED_SIZE);
 682     addType(result);
 683     return result;
 684   }
 685 
 686   private boolean typeNameIsPointerType(String typeName) {
 687     int i = typeName.length() - 1;
 688     while (i >= 0 && Character.isWhitespace(typeName.charAt(i))) {
 689       --i;
 690     }
 691     if (i >= 0 && typeName.charAt(i) == '*') {


 706         }
 707 
 708         // Lookup or create the current type
 709         BasicType curType = lookupOrCreateClass(typeName, isOopType, isIntegerType, isUnsigned);
 710         // Set superclass and/or ensure it's correct
 711         if (superclass != null) {
 712             if (curType.getSuperclass() == null) {
 713                 // Set the superclass in the current type
 714                 curType.setSuperclass(superclass);
 715             }
 716 
 717             if (curType.getSuperclass() != superclass) {
 718                 throw new RuntimeException("Error: the type \"" + typeName + "\" (declared in the remote VM in VMStructs::localHotSpotVMTypes) " +
 719                                            "had its superclass redefined (old was " + curType.getSuperclass().getName() + ", new is " +
 720                                            superclass.getName() + ").");
 721             }
 722         }
 723 
 724         // Classes are created with a size of UNINITIALIZED_SIZE.
 725         // Set size if necessary.
 726         if (curType.getSize() == UNINITIALIZED_SIZE || curType.getSize() == 0) {
 727             curType.setSize(size);
 728         } else {
 729             if (curType.getSize() != size) {
 730                 throw new RuntimeException("Error: the type \"" + typeName + "\" (declared in the remote VM in VMStructs::localHotSpotVMTypes) " +
 731                                            "had its size redefined (old was " + curType.getSize() + ", new is " + size + ").");
 732             }
 733 
 734             System.err.println("Warning: the type \"" + typeName + "\" (declared in the remote VM in VMStructs::localHotSpotVMTypes) " +
 735                                "had its size declared as " + size + " twice. Continuing.");
 736         }
 737 
 738     }
 739 
 740     /** "Virtual constructor" for fields based on type */
 741     public void createField(BasicType containingType,
 742                             String name, Type type, boolean isStatic,
 743                             long offset, Address staticFieldAddress) {
 744         // Add field to containing type
 745         containingType.addField(internalCreateField(containingType, name, type, isStatic, offset, staticFieldAddress));
 746     }


agent/src/share/classes/sun/jvm/hotspot/HotSpotTypeDataBase.java
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File