1 /*
  2  * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  */
 23 
 24 import java.io.BufferedReader;
 25 import java.io.FileReader;
 26 import java.io.IOException;
 27 import java.util.ArrayList;
 28 import java.util.HashMap;
 29 import java.util.HashSet;
 30 import java.util.regex.Matcher;
 31 import java.util.regex.Pattern;
 32 
 33 /*
 34 
 35 This is a simple parser for parsing the output of
 36 
 37    java -Xshare:dump -Xlog:aot+map=debug,aot+map+oops=trace:file=aot.map:none:filesize=0
 38 
 39 The map file contains patterns like this for the heap objects:
 40 
 41 ======================================================================
 42 0x00000000ffe00000: @@ Object (0xffe00000) java.lang.String ""
 43  - klass: 'java/lang/String' 0x0000000800010220
 44  - fields (3 words):
 45  - private 'hash' 'I' @12  0 (0x00000000)
 46  - private final 'coder' 'B' @16  0 (0x00)
 47  - private 'hashIsZero' 'Z' @17  true (0x01)
 48  - injected 'flags' 'B' @18  1 (0x01)
 49  - private final 'value' '[B' @20 0x00000000ffe00018 (0xffe00018) [B length: 0
 50 0x00000000ffe00018: @@ Object (0xffe00018) [B length: 0
 51  - klass: {type array byte} 0x00000008000024d8
 52 ======================================================================
 53 
 54 Currently this parser just check the output related to JDK-8308903.
 55 I.e., each oop field must point to a valid HeapObject. For example, the 'value' field
 56 in the String must point to a valid byte array.
 57 
 58 This parser can be extended to check for the other parts of the map file, or perform
 59 more analysis on the HeapObjects.
 60 
 61 */
 62 
 63 public class AOTMapReader {
 64     public static class MapFile {
 65         HashSet<String> classes = new HashSet<>();
 66         ArrayList<HeapObject> heapObjects = new ArrayList<>();
 67         HashMap<Long, HeapObject> oopToObject = new HashMap<>();
 68         HashMap<Long, HeapObject> narrowOopToObject = new HashMap<>();
 69         public int stringCount = 0;
 70 
 71         void add(HeapObject heapObject) {
 72             heapObjects.add(heapObject);
 73             oopToObject.put(heapObject.address.oop, heapObject);
 74             if (heapObject.address.narrowOop != 0) {
 75                 narrowOopToObject.put(heapObject.address.narrowOop, heapObject);
 76             }
 77             if (heapObject.className.equals("java.lang.String")) {
 78                 stringCount ++;
 79             }
 80         }
 81 
 82         public int heapObjectCount() {
 83             return heapObjects.size();
 84         }
 85 
 86         void addClass(String className) {
 87             classes.add(className);
 88         }
 89 
 90         public boolean hasClass(String className) {
 91             return classes.contains(className);
 92         }
 93 
 94         public void shouldHaveClass(String className) {
 95             if (!hasClass(className)) {
 96                 throw new RuntimeException("AOT map file is missing class " + className);
 97             }
 98         }
 99     }
100 
101     public static class HeapAddress {
102         long oop;
103         long narrowOop;
104 
105         HeapAddress(String oopStr, String narrowOopStr) {
106             oop = Long.parseUnsignedLong(oopStr, 16);
107             if (narrowOopStr != null) {
108                 narrowOop = Long.parseUnsignedLong(narrowOopStr, 16);
109             }
110         }
111     }
112 
113     public static class Klass {
114         long address;
115         String name;
116 
117         static Klass getKlass(String name, String addr) {
118             // TODO: look up from a table of known Klasses
119             Klass k = new Klass();
120             k.name = name;
121             k.address =  Long.parseUnsignedLong(addr, 16);
122             return k;
123         }
124     }
125 
126     public static class HeapObject {
127         HeapAddress address;
128         ArrayList<Field> fields;
129         String className;
130         Klass klass;
131 
132         HeapObject(String className, String oop, String narrowOop) {
133             this.className = className;
134             address = new HeapAddress(oop, narrowOop);
135         }
136 
137         void setKlass(String klassName, String address) {
138             klass = Klass.getKlass(klassName, address);
139         }
140 
141         void addOopField(String name, String offset, String oopStr, String narrowOopStr) {
142             if (fields == null) {
143                 fields = new ArrayList<Field>();
144             }
145             fields.add(new Field(name, offset, oopStr, narrowOopStr));
146         }
147     }
148 
149     public static class Field {
150         String name;
151         int offset;
152         HeapAddress referentAddress; // non-null iff this is an object field
153         int lineCount;
154 
155         Field(String name, String offset, String oopStr, String narrowOopStr) {
156             this.name = name;
157             this.offset = Integer.parseInt(offset);
158             this.referentAddress = new HeapAddress(oopStr, narrowOopStr);
159             this.lineCount = AOTMapReader.lineCount;
160         }
161     }
162 
163     // 0x00000007ffc00000:   4a5b8701 00000063 00010290 00000000 00010100 fff80003
164     static Pattern rawDataPattern = Pattern.compile("^0x([0-9a-f]+): *( [0-9a-f]+)+ *$");
165 
166     // -------------------------------------------------------------------------------
167     // Patterns for heap objects
168     // -------------------------------------------------------------------------------
169 
170     // (one address)
171     // 0x00000007ffc00000: @@ Object java.lang.String
172     static Pattern objPattern1 = Pattern.compile("^0x([0-9a-f]+): @@ Object ([^ ]*)");
173 
174     // (two addresses)
175     // 0x00000007ffc00000: @@ Object (0xfff80000) java.lang.String
176     static Pattern objPattern2 = Pattern.compile("^0x([0-9a-f]+): @@ Object [(]0x([0-9a-f]+)[)] ([^ ]*)");
177 
178     //  - klass: 'java/lang/String' 0x0000000800010290
179     static Pattern instanceObjKlassPattern = Pattern.compile("^ - klass: '([^']+)' 0x([0-9a-f]+)");
180 
181     //  - klass: {type array byte} 0x00000008000024c8
182     static Pattern typeArrayKlassPattern = Pattern.compile("^ - klass: [{]type array ([a-z]+)[}] 0x([0-9a-f]+)");
183 
184     //  - klass: 'java/lang/Object'[] 0x00000008000013e0
185     static Pattern objArrayKlassPattern = Pattern.compile("^ - klass: ('[^']+'(\\[\\])+) 0x([0-9a-f]+)");
186 
187     //  - fields (3 words):
188     static Pattern fieldsWordsPattern = Pattern.compile("^ - fields [(]([0-9]+) words[)]:$");
189 
190     // (one address)
191     //  - final 'key' 'Ljava/lang/Object;' @16 0x00000007ffc68260 java.lang.String
192     static Pattern oopFieldPattern1 = Pattern.compile(" - [^']* '([^']+)'.*@([0-9]+) 0x([0-9a-f]+) (.*)");
193 
194     // (two addresses)
195     //  - final 'key' 'Ljava/lang/Object;' @16 0x00000007ffc68260 (0xfff8d04c) java.lang.String
196     static Pattern oopFieldPattern2 = Pattern.compile(" - [^']* '([^']+)'.*@([0-9]+) 0x([0-9a-f]+) [(]0x([0-9a-f]+)[)] (.*)");
197 











198     // (injected module_entry)
199     //  - injected 'module_entry' 'J' @16 0 (0x0000000000000000)
200     static Pattern moduleEntryPattern = Pattern.compile("- injected 'module_entry' 'J' @[0-9]+[ ]+([0-9]+)");
201 
202     // -------------------------------------------------------------------------------
203     // Patterns for metaspace objects
204     // -------------------------------------------------------------------------------
205 
206     // 0x00000008000d1698: @@ Class             512 [Ljdk.internal.vm.FillerElement;
207     // 0x00000008000d18a0: @@ Class             520 java.lang.Cloneable
208     static Pattern classPattern = Pattern.compile("^0x([0-9a-f]+): @@ Class [ ]*([0-9]+) (.*)");
209 
210 
211     private static Matcher match(String line, Pattern pattern) {
212         Matcher m = pattern.matcher(line);
213         if (m.find()) {
214             return m;
215         } else {
216             return null;
217         }
218     }
219 
220     private static void parseHeapObject(String className, String oop, String narrowOop) throws IOException {
221         HeapObject heapObject = parseHeapObjectImpl(className, oop, narrowOop);
222         mapFile.add(heapObject);
223     }
224 


















































225     private static HeapObject parseHeapObjectImpl(String className, String oop, String narrowOop) throws IOException {
226         HeapObject heapObject = new HeapObject(className, oop, narrowOop);
227         Matcher m;
228 
229         nextLine();
230         while (line != null && match(line, rawDataPattern) != null) { // skip raw data
231             nextLine();
232         }
233 
234         if (line == null || !line.startsWith(" - ")) {
235             return heapObject;
236         }
237 
238         if ((m = match(line, instanceObjKlassPattern)) != null) {
239             heapObject.setKlass(m.group(1), m.group(2));
240             nextLine();
241             if ((m = match(line, fieldsWordsPattern)) == null) {
242                 throw new RuntimeException("Expected field size info");
243             }
244             while (true) {
245                 nextLine();
246                 if (line == null || !line.startsWith(" - ")) {
247                     return heapObject;
248                 }
249                 if (!line.contains("marked metadata pointer")) {
250                     if ((m = match(line, oopFieldPattern2)) != null) {
251                         heapObject.addOopField(m.group(1), m.group(2), m.group(3), m.group(4));
252                     } else if ((m = match(line, oopFieldPattern1)) != null) {
253                         heapObject.addOopField(m.group(1), m.group(2), m.group(3), null);







254                     } else if ((m = match(line, moduleEntryPattern)) != null) {
255                         String value = m.group(1);
256                         if (!value.equals("0")) {
257                             throw new RuntimeException("module_entry should be 0 but found: " + line);
258                         }
259                     }
260                 }
261             }
262         } else if ((m = match(line, typeArrayKlassPattern)) != null) {
263             heapObject.setKlass(m.group(1), m.group(2));
264             // TODO: read all the array elements
265             while (true) {
266                 nextLine();
267                 if (line == null || !line.startsWith(" - ")) {
268                     return heapObject;
269                 }
270             }
271         } else if ((m = match(line, objArrayKlassPattern)) != null) {
272             heapObject.setKlass(m.group(1), m.group(3));
273             // TODO: read all the array elements
274             while (true) {
275                 nextLine();
276                 if (line == null || !line.startsWith(" - ")) {
277                     return heapObject;
278                 }






279             }
280         } else {
281             throw new RuntimeException("Expected klass info");
282         }
283     }
284 
285     private static void parseClassObject(String className, String addr, String size) throws IOException {
286         mapFile.addClass(className);
287         nextLine();
288     }
289 
290     static MapFile mapFile;
291     static BufferedReader reader;
292     static String line = null; // current line being parsed
293     static int lineCount = 0;
294     static String nextLine()  throws IOException {
295         line = reader.readLine();
296         ++ lineCount;
297         return line;
298     }
299 
300     public static MapFile read(String fileName) {
301         mapFile = new MapFile();
302         lineCount = 0;
303 
304         try (BufferedReader r = new BufferedReader(new FileReader(fileName))) {
305             reader = r;
306             nextLine();
307 
308             Matcher m;
309             while (line != null) {
310                 if ((m = match(line, objPattern2)) != null) {
311                     parseHeapObject(m.group(3), m.group(1), m.group(2));
312                 } else if ((m = match(line, objPattern1)) != null) {
313                     parseHeapObject(m.group(2), m.group(1), null);
314                 } else if ((m = match(line, classPattern)) != null) {
315                     parseClassObject(m.group(3), m.group(1), m.group(2)); // name, addr, size
316                 } else {
317                     nextLine();
318                 }
319             }
320             return mapFile;
321         } catch (Throwable t) {
322             System.out.println("Error parsing line " + lineCount + ": " + line);
323             throw new RuntimeException(t);
324         } finally {
325             System.out.println("Parsed " + lineCount + " lines in " + fileName);
326             System.out.println("Found " + mapFile.heapObjectCount() + " heap objects ("
327                                + mapFile.stringCount + " strings)");
328             mapFile = null;
329             reader = null;
330             line = null;
331             lineCount = 0;
332         }
333     }
334 
335     private static void mustContain(HashMap<Long, HeapObject> allObjects, Field field, long pointer, boolean isNarrow) {
336         if (allObjects.get(pointer) == null) {
337             throw new RuntimeException((isNarrow ? "narrowOop" : "oop") + " pointer 0x" + Long.toHexString(pointer) +
338                                        " on line " + field.lineCount + " doesn't point to a valid heap object");
339         }
340     }
341 
342     public static void validate(MapFile mapFile, String classLoadLogFile) throws IOException {
343         validateOops(mapFile);
344         if (classLoadLogFile != null) {
345             validateClasses(mapFile, classLoadLogFile);
346         }
347     }
348 
349     // Check that each oop fields in the HeapObjects must point to a valid HeapObject.
350     static void validateOops(MapFile mapFile) {
351         int count1 = 0;
352         int count2 = 0;
353         for (HeapObject heapObject : mapFile.heapObjects) {
354             if (heapObject.fields != null) {
355                 for (Field field : heapObject.fields) {
356                     HeapAddress referentAddress = field.referentAddress;
357                     long oop = referentAddress.oop;
358                     long narrowOop = referentAddress.narrowOop;
359                     // Is this test actually doing something?
360                     //     To see how an invalidate pointer may be found, change oop in the
361                     //     following line to oop+1
362                     if (oop != 0) {
363                         mustContain(mapFile.oopToObject, field, oop, false);
364                         count1 ++;
365                     }
366                     if (narrowOop != 0) {
367                         mustContain(mapFile.narrowOopToObject, field, narrowOop, true);
368                         count2 ++;
369                     }
370                 }
371             }
372         }
373         System.out.println("Found " + count1 + " non-null oop field references (normal)");
374         System.out.println("Found " + count2 + " non-null oop field references (narrow)");
375 
376         if (mapFile.heapObjectCount() > 0) {
377             // heapObjectCount() may be zero if the selected GC doesn't support heap object archiving.
378             if (mapFile.stringCount <= 0) {
379                 throw new RuntimeException("AOT map file should contain at least one string");
380             }
381             if (count1 < mapFile.stringCount) {
382                 throw new RuntimeException("AOT map file seems incorrect: " + mapFile.heapObjectCount() +
383                                            " objects (" + mapFile.stringCount + " strings). Each string should" +
384                                            " have one non-null oop field but we found only " + count1 +
385                                            " non-null oop field references");
386             }
387         }
388     }
389 
390     // classLoadLogFile should be generated with -Xlog:class+load:file=<classLoadLogFile>:none:filesize=0
391     // Check that every class loaded from "source: shared objects file" have an entry inside the mapFile.
392     static void validateClasses(MapFile mapFile, String classLoadLogFile) throws IOException {
393         try (BufferedReader r = new BufferedReader(new FileReader(classLoadLogFile))) {
394             String line;
395             String suffix = " source: shared objects file";
396             int suffixLen = suffix.length();
397             while ((line = r.readLine()) != null) {
398                 if (line.endsWith(suffix)) {
399                     String className = line.substring(0, line.length() - suffixLen);
400                     if (!mapFile.hasClass(className)) {
401                         throw new RuntimeException("AOT map file is missing class " + className);
402                     }
403                 }
404             }
405         }
406     }
407 
408     public static void main(String args[]) throws IOException {
409         MapFile mapFile = read(args[0]);
410         validate(mapFile, null);
411     }
412 }
--- EOF ---