1 /*
  2  * Copyright (c) 2012, 2021, 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 package sun.hotspot;
 25 
 26 import java.lang.management.MemoryUsage;
 27 import java.lang.reflect.Executable;
 28 import java.util.Arrays;
 29 import java.util.List;
 30 import java.util.function.BiFunction;
 31 import java.util.function.Function;
 32 import java.security.BasicPermission;
 33 import java.util.Objects;
 34 
 35 import jdk.test.whitebox.parser.DiagnosticCommand;
 36 
 37 @Deprecated
 38 public class WhiteBox {
 39   @SuppressWarnings("serial")
 40   public static class WhiteBoxPermission extends BasicPermission {
 41     public WhiteBoxPermission(String s) {
 42       super(s);
 43     }
 44   }
 45 
 46   private WhiteBox() {}
 47   private static final WhiteBox instance = new WhiteBox();
 48   private static native void registerNatives();
 49 
 50   /**
 51    * Returns the singleton WhiteBox instance.
 52    *
 53    * The returned WhiteBox object should be carefully guarded
 54    * by the caller, since it can be used to read and write data
 55    * at arbitrary memory addresses. It must never be passed to
 56    * untrusted code.
 57    */
 58   public synchronized static WhiteBox getWhiteBox() {
 59     @SuppressWarnings("removal")
 60     SecurityManager sm = System.getSecurityManager();
 61     if (sm != null) {
 62       throw new SecurityException("can't use old whitebox with SecurityManager, please switch to jdk.test.whitebox.WhiteBox");
 63     }
 64     return instance;
 65   }
 66 
 67   static {
 68     registerNatives();
 69   }
 70 
 71   // Get the maximum heap size supporting COOPs
 72   public native long getCompressedOopsMaxHeapSize();
 73   // Arguments
 74   public native void printHeapSizes();
 75 
 76   // Memory
 77   private native long getObjectAddress0(Object o);
 78   public           long getObjectAddress(Object o) {
 79     Objects.requireNonNull(o);
 80     return getObjectAddress0(o);
 81   }
 82 
 83   public native int  getHeapOopSize();
 84   public native int  getVMPageSize();
 85   public native long getVMAllocationGranularity();
 86   public native long getVMLargePageSize();
 87   public native long getHeapSpaceAlignment();
 88   public native long getHeapAlignment();
 89 
 90   private native boolean isObjectInOldGen0(Object o);
 91   public         boolean isObjectInOldGen(Object o) {
 92     Objects.requireNonNull(o);
 93     return isObjectInOldGen0(o);
 94   }
 95 
 96   private native long getObjectSize0(Object o);
 97   public         long getObjectSize(Object o) {
 98     Objects.requireNonNull(o);
 99     return getObjectSize0(o);
100   }
101 
102   // Runtime
103   // Make sure class name is in the correct format
104   public int countAliveClasses(String name) {
105     return countAliveClasses0(name.replace('.', '/'));
106   }
107   private native int countAliveClasses0(String name);
108 
109   public boolean isClassAlive(String name) {
110     return countAliveClasses(name) != 0;
111   }
112 
113   public  native int getSymbolRefcount(String name);
114 
115   public native boolean deflateIdleMonitors();
116 
117   private native boolean isMonitorInflated0(Object obj);
118   public         boolean isMonitorInflated(Object obj) {
119     Objects.requireNonNull(obj);
120     return isMonitorInflated0(obj);
121   }
122 
123   public native void forceSafepoint();
124 
125   private native long getConstantPool0(Class<?> aClass);
126   public         long getConstantPool(Class<?> aClass) {
127     Objects.requireNonNull(aClass);
128     return getConstantPool0(aClass);
129   }
130 
131   private native int getConstantPoolCacheIndexTag0();
132   public         int getConstantPoolCacheIndexTag() {
133     return getConstantPoolCacheIndexTag0();
134   }
135 
136   private native int getConstantPoolCacheLength0(Class<?> aClass);
137   public         int getConstantPoolCacheLength(Class<?> aClass) {
138     Objects.requireNonNull(aClass);
139     return getConstantPoolCacheLength0(aClass);
140   }
141 
142   private native int remapInstructionOperandFromCPCache0(Class<?> aClass, int index);
143   public         int remapInstructionOperandFromCPCache(Class<?> aClass, int index) {
144     Objects.requireNonNull(aClass);
145     return remapInstructionOperandFromCPCache0(aClass, index);
146   }
147 
148   private native int encodeConstantPoolIndyIndex0(int index);
149   public         int encodeConstantPoolIndyIndex(int index) {
150     return encodeConstantPoolIndyIndex0(index);
151   }
152 
153   // JVMTI
154   private native void addToBootstrapClassLoaderSearch0(String segment);
155   public         void addToBootstrapClassLoaderSearch(String segment){
156     Objects.requireNonNull(segment);
157     addToBootstrapClassLoaderSearch0(segment);
158   }
159 
160   private native void addToSystemClassLoaderSearch0(String segment);
161   public         void addToSystemClassLoaderSearch(String segment) {
162     Objects.requireNonNull(segment);
163     addToSystemClassLoaderSearch0(segment);
164   }
165 
166   // G1
167   public native boolean g1InConcurrentMark();
168   public native boolean g1HasRegionsToUncommit();
169   private native boolean g1IsHumongous0(Object o);
170   public         boolean g1IsHumongous(Object o) {
171     Objects.requireNonNull(o);
172     return g1IsHumongous0(o);
173   }
174 
175   private native boolean g1BelongsToHumongousRegion0(long adr);
176   public         boolean g1BelongsToHumongousRegion(long adr) {
177     if (adr == 0) {
178       throw new IllegalArgumentException("adr argument should not be null");
179     }
180     return g1BelongsToHumongousRegion0(adr);
181   }
182 
183 
184   private native boolean g1BelongsToFreeRegion0(long adr);
185   public         boolean g1BelongsToFreeRegion(long adr) {
186     if (adr == 0) {
187       throw new IllegalArgumentException("adr argument should not be null");
188     }
189     return g1BelongsToFreeRegion0(adr);
190   }
191 
192   public native long    g1NumMaxRegions();
193   public native long    g1NumFreeRegions();
194   public native int     g1RegionSize();
195   public native MemoryUsage g1AuxiliaryMemoryUsage();
196   private  native Object[]    parseCommandLine0(String commandline, char delim, DiagnosticCommand[] args);
197   public          Object[]    parseCommandLine(String commandline, char delim, DiagnosticCommand[] args) {
198     Objects.requireNonNull(args);
199     return parseCommandLine0(commandline, delim, args);
200   }
201 
202   public native int g1ActiveMemoryNodeCount();
203   public native int[] g1MemoryNodeIds();
204 
205   // Parallel GC
206   public native long psVirtualSpaceAlignment();
207   public native long psHeapGenerationAlignment();
208 
209   /**
210    * Enumerates old regions with liveness less than specified and produces some statistics
211    * @param liveness percent of region's liveness (live_objects / total_region_size * 100).
212    * @return long[3] array where long[0] - total count of old regions
213    *                             long[1] - total memory of old regions
214    *                             long[2] - lowest estimation of total memory of old regions to be freed (non-full
215    *                             regions are not included)
216    */
217   public native long[] g1GetMixedGCInfo(int liveness);
218 
219   // NMT
220   public native long NMTMalloc(long size);
221   public native void NMTFree(long mem);
222   public native long NMTReserveMemory(long size);
223   public native long NMTAttemptReserveMemoryAt(long addr, long size);
224   public native void NMTCommitMemory(long addr, long size);
225   public native void NMTUncommitMemory(long addr, long size);
226   public native void NMTReleaseMemory(long addr, long size);
227   public native long NMTMallocWithPseudoStack(long size, int index);
228   public native long NMTMallocWithPseudoStackAndType(long size, int index, int type);
229   public native boolean NMTChangeTrackingLevel();
230   public native int NMTGetHashSize();
231   public native long NMTNewArena(long initSize);
232   public native void NMTFreeArena(long arena);
233   public native void NMTArenaMalloc(long arena, long size);
234 
235   // Compiler
236   public native boolean isC2OrJVMCIIncluded();
237   public native boolean isJVMCISupportedByGC();
238 
239   public native int     matchesMethod(Executable method, String pattern);
240   public native int     matchesInline(Executable method, String pattern);
241   public native boolean shouldPrintAssembly(Executable method, int comp_level);
242   public native int     deoptimizeFrames(boolean makeNotEntrant);
243   public native boolean isFrameDeoptimized(int depth);
244   public native void    deoptimizeAll();
245 
246   public        boolean isMethodCompiled(Executable method) {
247     return isMethodCompiled(method, false /*not osr*/);
248   }
249   private native boolean isMethodCompiled0(Executable method, boolean isOsr);
250   public         boolean isMethodCompiled(Executable method, boolean isOsr){
251     Objects.requireNonNull(method);
252     return isMethodCompiled0(method, isOsr);
253   }
254   public        boolean isMethodCompilable(Executable method) {
255     return isMethodCompilable(method, -1 /*any*/);
256   }
257   public        boolean isMethodCompilable(Executable method, int compLevel) {
258     return isMethodCompilable(method, compLevel, false /*not osr*/);
259   }
260   private native boolean isMethodCompilable0(Executable method, int compLevel, boolean isOsr);
261   public         boolean isMethodCompilable(Executable method, int compLevel, boolean isOsr) {
262     Objects.requireNonNull(method);
263     return isMethodCompilable0(method, compLevel, isOsr);
264   }
265   private native boolean isMethodQueuedForCompilation0(Executable method);
266   public         boolean isMethodQueuedForCompilation(Executable method) {
267     Objects.requireNonNull(method);
268     return isMethodQueuedForCompilation0(method);
269   }
270   // Determine if the compiler corresponding to the compilation level 'compLevel'
271   // and to the compilation context 'compilation_context' provides an intrinsic
272   // for the method 'method'. An intrinsic is available for method 'method' if:
273   //  - the intrinsic is enabled (by using the appropriate command-line flag) and
274   //  - the platform on which the VM is running provides the instructions necessary
275   //    for the compiler to generate the intrinsic code.
276   //
277   // The compilation context is related to using the DisableIntrinsic flag on a
278   // per-method level, see hotspot/src/share/vm/compiler/abstractCompiler.hpp
279   // for more details.
280   public boolean isIntrinsicAvailable(Executable method,
281                                       Executable compilationContext,
282                                       int compLevel) {
283       Objects.requireNonNull(method);
284       return isIntrinsicAvailable0(method, compilationContext, compLevel);
285   }
286   // If usage of the DisableIntrinsic flag is not expected (or the usage can be ignored),
287   // use the below method that does not require the compilation context as argument.
288   public boolean isIntrinsicAvailable(Executable method, int compLevel) {
289       return isIntrinsicAvailable(method, null, compLevel);
290   }
291   private native boolean isIntrinsicAvailable0(Executable method,
292                                                Executable compilationContext,
293                                                int compLevel);
294   public        int     deoptimizeMethod(Executable method) {
295     return deoptimizeMethod(method, false /*not osr*/);
296   }
297   private native int     deoptimizeMethod0(Executable method, boolean isOsr);
298   public         int     deoptimizeMethod(Executable method, boolean isOsr) {
299     Objects.requireNonNull(method);
300     return deoptimizeMethod0(method, isOsr);
301   }
302   public        void    makeMethodNotCompilable(Executable method) {
303     makeMethodNotCompilable(method, -1 /*any*/);
304   }
305   public        void    makeMethodNotCompilable(Executable method, int compLevel) {
306     makeMethodNotCompilable(method, compLevel, false /*not osr*/);
307   }
308   private native void    makeMethodNotCompilable0(Executable method, int compLevel, boolean isOsr);
309   public         void    makeMethodNotCompilable(Executable method, int compLevel, boolean isOsr) {
310     Objects.requireNonNull(method);
311     makeMethodNotCompilable0(method, compLevel, isOsr);
312   }
313   public        int     getMethodCompilationLevel(Executable method) {
314     return getMethodCompilationLevel(method, false /*not osr*/);
315   }
316   private native int     getMethodCompilationLevel0(Executable method, boolean isOsr);
317   public         int     getMethodCompilationLevel(Executable method, boolean isOsr) {
318     Objects.requireNonNull(method);
319     return getMethodCompilationLevel0(method, isOsr);
320   }
321   private native boolean testSetDontInlineMethod0(Executable method, boolean value);
322   public         boolean testSetDontInlineMethod(Executable method, boolean value) {
323     Objects.requireNonNull(method);
324     return testSetDontInlineMethod0(method, value);
325   }
326   public        int     getCompileQueuesSize() {
327     return getCompileQueueSize(-1 /*any*/);
328   }
329   public native int     getCompileQueueSize(int compLevel);
330   private native boolean testSetForceInlineMethod0(Executable method, boolean value);
331   public         boolean testSetForceInlineMethod(Executable method, boolean value) {
332     Objects.requireNonNull(method);
333     return testSetForceInlineMethod0(method, value);
334   }
335   public        boolean enqueueMethodForCompilation(Executable method, int compLevel) {
336     return enqueueMethodForCompilation(method, compLevel, -1 /*InvocationEntryBci*/);
337   }
338   private native boolean enqueueMethodForCompilation0(Executable method, int compLevel, int entry_bci);
339   public  boolean enqueueMethodForCompilation(Executable method, int compLevel, int entry_bci) {
340     Objects.requireNonNull(method);
341     return enqueueMethodForCompilation0(method, compLevel, entry_bci);
342   }
343   private native boolean enqueueInitializerForCompilation0(Class<?> aClass, int compLevel);
344   public  boolean enqueueInitializerForCompilation(Class<?> aClass, int compLevel) {
345     Objects.requireNonNull(aClass);
346     return enqueueInitializerForCompilation0(aClass, compLevel);
347   }
348   private native void    clearMethodState0(Executable method);
349   public  native void    markMethodProfiled(Executable method);
350   public         void    clearMethodState(Executable method) {
351     Objects.requireNonNull(method);
352     clearMethodState0(method);
353   }
354   public native void    lockCompilation();
355   public native void    unlockCompilation();
356   private native int     getMethodEntryBci0(Executable method);
357   public         int     getMethodEntryBci(Executable method) {
358     Objects.requireNonNull(method);
359     return getMethodEntryBci0(method);
360   }
361   private native Object[] getNMethod0(Executable method, boolean isOsr);
362   public         Object[] getNMethod(Executable method, boolean isOsr) {
363     Objects.requireNonNull(method);
364     return getNMethod0(method, isOsr);
365   }
366   public native long    allocateCodeBlob(int size, int type);
367   public        long    allocateCodeBlob(long size, int type) {
368       int intSize = (int) size;
369       if ((long) intSize != size || size < 0) {
370           throw new IllegalArgumentException(
371                 "size argument has illegal value " + size);
372       }
373       return allocateCodeBlob( intSize, type);
374   }
375   public native void    freeCodeBlob(long addr);
376   public native void    forceNMethodSweep();
377   public native Object[] getCodeHeapEntries(int type);
378   public native int     getCompilationActivityMode();
379   private native long getMethodData0(Executable method);
380   public         long getMethodData(Executable method) {
381     Objects.requireNonNull(method);
382     return getMethodData0(method);
383   }
384   public native Object[] getCodeBlob(long addr);
385 
386   private native void clearInlineCaches0(boolean preserve_static_stubs);
387   public void clearInlineCaches() {
388     clearInlineCaches0(false);
389   }
390   public void clearInlineCaches(boolean preserve_static_stubs) {
391     clearInlineCaches0(preserve_static_stubs);
392   }
393 
394   // Intered strings
395   public native boolean isInStringTable(String str);
396 
397   // Memory
398   public native void readReservedMemory();
399   public native long allocateMetaspace(ClassLoader classLoader, long size);
400   public native long incMetaspaceCapacityUntilGC(long increment);
401   public native long metaspaceCapacityUntilGC();
402   public native long metaspaceSharedRegionAlignment();
403 
404   // Metaspace Arena Tests
405   public native long createMetaspaceTestContext(long commit_limit, long reserve_limit);
406   public native void destroyMetaspaceTestContext(long context);
407   public native void purgeMetaspaceTestContext(long context);
408   public native void printMetaspaceTestContext(long context);
409   public native long getTotalCommittedWordsInMetaspaceTestContext(long context);
410   public native long getTotalUsedWordsInMetaspaceTestContext(long context);
411   public native long createArenaInTestContext(long context, boolean is_micro);
412   public native void destroyMetaspaceTestArena(long arena);
413   public native long allocateFromMetaspaceTestArena(long arena, long word_size);
414   public native void deallocateToMetaspaceTestArena(long arena, long p, long word_size);
415 
416   public native long maxMetaspaceAllocationSize();
417 
418   // Don't use these methods directly
419   // Use sun.hotspot.gc.GC class instead.
420   public native boolean isGCSupported(int name);
421   public native boolean isGCSupportedByJVMCICompiler(int name);
422   public native boolean isGCSelected(int name);
423   public native boolean isGCSelectedErgonomically();
424 
425   // Force Young GC
426   public native void youngGC();
427 
428   // Force Full GC
429   public native void fullGC();
430 
431   // Returns true if the current GC supports concurrent collection control.
432   public native boolean supportsConcurrentGCBreakpoints();
433 
434   private void checkConcurrentGCBreakpointsSupported() {
435     if (!supportsConcurrentGCBreakpoints()) {
436       throw new UnsupportedOperationException("Concurrent GC breakpoints not supported");
437     }
438   }
439 
440   private native void concurrentGCAcquireControl0();
441   private native void concurrentGCReleaseControl0();
442   private native void concurrentGCRunToIdle0();
443   private native boolean concurrentGCRunTo0(String breakpoint);
444 
445   private static boolean concurrentGCIsControlled = false;
446   private void checkConcurrentGCIsControlled() {
447     if (!concurrentGCIsControlled) {
448       throw new IllegalStateException("Not controlling concurrent GC");
449     }
450   }
451 
452   // All collectors supporting concurrent GC breakpoints are expected
453   // to provide at least the following breakpoints.
454   public final String AFTER_MARKING_STARTED = "AFTER MARKING STARTED";
455   public final String BEFORE_MARKING_COMPLETED = "BEFORE MARKING COMPLETED";
456 
457   // Collectors supporting concurrent GC breakpoints that do reference
458   // processing concurrently should provide the following breakpoint.
459   public final String AFTER_CONCURRENT_REFERENCE_PROCESSING_STARTED =
460     "AFTER CONCURRENT REFERENCE PROCESSING STARTED";
461 
462   public void concurrentGCAcquireControl() {
463     checkConcurrentGCBreakpointsSupported();
464     if (concurrentGCIsControlled) {
465       throw new IllegalStateException("Already controlling concurrent GC");
466     }
467     concurrentGCAcquireControl0();
468     concurrentGCIsControlled = true;
469   }
470 
471   public void concurrentGCReleaseControl() {
472     checkConcurrentGCBreakpointsSupported();
473     concurrentGCReleaseControl0();
474     concurrentGCIsControlled = false;
475   }
476 
477   // Keep concurrent GC idle.  Release from breakpoint.
478   public void concurrentGCRunToIdle() {
479     checkConcurrentGCBreakpointsSupported();
480     checkConcurrentGCIsControlled();
481     concurrentGCRunToIdle0();
482   }
483 
484   // Allow concurrent GC to run to breakpoint.
485   // Throws IllegalStateException if reached end of cycle first.
486   public void concurrentGCRunTo(String breakpoint) {
487     concurrentGCRunTo(breakpoint, true);
488   }
489 
490   // Allow concurrent GC to run to breakpoint.
491   // Returns true if reached breakpoint.  If reached end of cycle first,
492   // then throws IllegalStateException if errorIfFail is true, returning
493   // false otherwise.
494   public boolean concurrentGCRunTo(String breakpoint, boolean errorIfFail) {
495     checkConcurrentGCBreakpointsSupported();
496     checkConcurrentGCIsControlled();
497     if (breakpoint == null) {
498       throw new NullPointerException("null breakpoint");
499     } else if (concurrentGCRunTo0(breakpoint)) {
500       return true;
501     } else if (errorIfFail) {
502       throw new IllegalStateException("Missed requested breakpoint \"" + breakpoint + "\"");
503     } else {
504       return false;
505     }
506   }
507 
508   // Method tries to start concurrent mark cycle.
509   // It returns false if CM Thread is always in concurrent cycle.
510   public native boolean g1StartConcMarkCycle();
511 
512   // Tests on ReservedSpace/VirtualSpace classes
513   public native int stressVirtualSpaceResize(long reservedSpaceSize, long magnitude, long iterations);
514   public native void readFromNoaccessArea();
515   public native long getThreadStackSize();
516   public native long getThreadRemainingStackSize();
517 
518   // CPU features
519   public native String getCPUFeatures();
520 
521   // VM flags
522   public native boolean isConstantVMFlag(String name);
523   public native boolean isLockedVMFlag(String name);
524   public native void    setBooleanVMFlag(String name, boolean value);
525   public native void    setIntVMFlag(String name, long value);
526   public native void    setUintVMFlag(String name, long value);
527   public native void    setIntxVMFlag(String name, long value);
528   public native void    setUintxVMFlag(String name, long value);
529   public native void    setUint64VMFlag(String name, long value);
530   public native void    setSizeTVMFlag(String name, long value);
531   public native void    setStringVMFlag(String name, String value);
532   public native void    setDoubleVMFlag(String name, double value);
533   public native Boolean getBooleanVMFlag(String name);
534   public native Long    getIntVMFlag(String name);
535   public native Long    getUintVMFlag(String name);
536   public native Long    getIntxVMFlag(String name);
537   public native Long    getUintxVMFlag(String name);
538   public native Long    getUint64VMFlag(String name);
539   public native Long    getSizeTVMFlag(String name);
540   public native String  getStringVMFlag(String name);
541   public native Double  getDoubleVMFlag(String name);
542   private final List<Function<String,Object>> flagsGetters = Arrays.asList(
543     this::getBooleanVMFlag, this::getIntVMFlag, this::getUintVMFlag,
544     this::getIntxVMFlag, this::getUintxVMFlag, this::getUint64VMFlag,
545     this::getSizeTVMFlag, this::getStringVMFlag, this::getDoubleVMFlag);
546 
547   public Object getVMFlag(String name) {
548     return flagsGetters.stream()
549                        .map(f -> f.apply(name))
550                        .filter(x -> x != null)
551                        .findAny()
552                        .orElse(null);
553   }
554 
555   // Jigsaw
556   public native void DefineModule(Object module, boolean is_open, String version,
557                                   String location, Object[] packages);
558   public native void AddModuleExports(Object from_module, String pkg, Object to_module);
559   public native void AddReadsModule(Object from_module, Object source_module);
560   public native void AddModuleExportsToAllUnnamed(Object module, String pkg);
561   public native void AddModuleExportsToAll(Object module, String pkg);
562 
563   public native int getCDSOffsetForName0(String name);
564   public int getCDSOffsetForName(String name) throws Exception {
565     int offset = getCDSOffsetForName0(name);
566     if (offset == -1) {
567       throw new RuntimeException(name + " not found");
568     }
569     return offset;
570   }
571   public native int getCDSConstantForName0(String name);
572   public int getCDSConstantForName(String name) throws Exception {
573     int constant = getCDSConstantForName0(name);
574     if (constant == -1) {
575       throw new RuntimeException(name + " not found");
576     }
577     return constant;
578   }
579   public native Boolean getMethodBooleanOption(Executable method, String name);
580   public native Long    getMethodIntxOption(Executable method, String name);
581   public native Long    getMethodUintxOption(Executable method, String name);
582   public native Double  getMethodDoubleOption(Executable method, String name);
583   public native String  getMethodStringOption(Executable method, String name);
584   private final List<BiFunction<Executable,String,Object>> methodOptionGetters
585       = Arrays.asList(this::getMethodBooleanOption, this::getMethodIntxOption,
586           this::getMethodUintxOption, this::getMethodDoubleOption,
587           this::getMethodStringOption);
588 
589   public Object getMethodOption(Executable method, String name) {
590     return methodOptionGetters.stream()
591                               .map(f -> f.apply(method, name))
592                               .filter(x -> x != null)
593                               .findAny()
594                               .orElse(null);
595   }
596 
597   // Sharing & archiving
598   public native String  getDefaultArchivePath();
599   public native boolean cdsMemoryMappingFailed();
600   public native boolean isSharingEnabled();
601   public native boolean isShared(Object o);
602   public native boolean isSharedClass(Class<?> c);
603   public native boolean areSharedStringsMapped();
604   public native boolean isSharedInternedString(String s);
605   public native boolean isCDSIncluded();
606   public native boolean isJFRIncluded();
607   public native boolean canWriteJavaHeapArchive();
608   public native Object  getResolvedReferences(Class<?> c);
609   public native void    linkClass(Class<?> c);
610   public native boolean areOpenArchiveHeapObjectsMapped();
611 
612   // Compiler Directive
613   public native int addCompilerDirective(String compDirect);
614   public native void removeCompilerDirective(int count);
615 
616   // Handshakes
617   public native int handshakeWalkStack(Thread t, boolean all_threads);
618   public native boolean handshakeReadMonitors(Thread t);
619   public native void asyncHandshakeWalkStack(Thread t);
620 
621   public native void lockAndBlock(boolean suspender);
622 
623   // Returns true on linux if library has the noexecstack flag set.
624   public native boolean checkLibSpecifiesNoexecstack(String libfilename);
625 
626   // Container testing
627   public native boolean isContainerized();
628   public native int validateCgroup(String procCgroups,
629                                    String procSelfCgroup,
630                                    String procSelfMountinfo);
631   public native void printOsInfo();
632 
633   // Decoder
634   public native void disableElfSectionCache();
635 
636   // Resolved Method Table
637   public native long resolvedMethodItemsCount();
638 
639   // Protection Domain Table
640   public native int protectionDomainRemovedCount();
641 
642   public native int getKlassMetadataSize(Class<?> c);
643 
644   // ThreadSMR GC safety check for threadObj
645   public native void checkThreadObjOfTerminatingThread(Thread target);
646 
647   // libc name
648   public native String getLibcName();
649 
650   // Walk stack frames of current thread
651   public native void verifyFrames(boolean log, boolean updateRegisterMap);
652 
653   public native boolean isJVMTIIncluded();
654 
655   public native void waitUnsafe(int time_ms);
656 
657   public native void lockCritical();
658 
659   public native void unlockCritical();
660 }