1/*
2 * Copyright (c) 2011, 2017, 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
25#ifndef SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP
26#define SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP
27
28#include "classfile/stringTable.hpp"
29#include "classfile/symbolTable.hpp"
30#include "classfile/systemDictionary.hpp"
31#include "classfile/vmSymbols.hpp"
32#include "runtime/arguments.hpp"
33#include "runtime/os.hpp"
34#include "runtime/vmThread.hpp"
35#include "services/diagnosticArgument.hpp"
36#include "services/diagnosticCommand.hpp"
37#include "services/diagnosticCommand_ext.hpp"
38#include "services/diagnosticFramework.hpp"
39#include "utilities/macros.hpp"
40#include "utilities/ostream.hpp"
41#include "oops/method.hpp"
42
43class HelpDCmd : public DCmdWithParser {
44protected:
45  DCmdArgument<bool> _all;
46  DCmdArgument<char*> _cmd;
47public:
48  HelpDCmd(outputStream* output, bool heap);
49  static const char* name() { return "help"; }
50  static const char* description() {
51    return "For more information about a specific command use 'help <command>'. "
52           "With no argument this will show a list of available commands. "
53           "'help all' will show help for all commands.";
54  }
55  static const char* impact() { return "Low"; }
56  static int num_arguments();
57  virtual void execute(DCmdSource source, TRAPS);
58};
59
60class VersionDCmd : public DCmd {
61public:
62  VersionDCmd(outputStream* output, bool heap) : DCmd(output,heap) { }
63  static const char* name() { return "VM.version"; }
64  static const char* description() {
65    return "Print JVM version information.";
66  }
67  static const char* impact() { return "Low"; }
68  static const JavaPermission permission() {
69    JavaPermission p = {"java.util.PropertyPermission",
70                        "java.vm.version", "read"};
71    return p;
72  }
73  static int num_arguments() { return 0; }
74  virtual void execute(DCmdSource source, TRAPS);
75};
76
77class CommandLineDCmd : public DCmd {
78public:
79  CommandLineDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
80  static const char* name() { return "VM.command_line"; }
81  static const char* description() {
82    return "Print the command line used to start this VM instance.";
83  }
84  static const char* impact() { return "Low"; }
85  static const JavaPermission permission() {
86    JavaPermission p = {"java.lang.management.ManagementPermission",
87                        "monitor", NULL};
88    return p;
89  }
90  static int num_arguments() { return 0; }
91  virtual void execute(DCmdSource source, TRAPS) {
92    Arguments::print_on(_output);
93  }
94};
95
96// See also: get_system_properties in attachListener.cpp
97class PrintSystemPropertiesDCmd : public DCmd {
98public:
99  PrintSystemPropertiesDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
100    static const char* name() { return "VM.system_properties"; }
101    static const char* description() {
102      return "Print system properties.";
103    }
104    static const char* impact() {
105      return "Low";
106    }
107    static const JavaPermission permission() {
108      JavaPermission p = {"java.util.PropertyPermission",
109                          "*", "read"};
110      return p;
111    }
112    static int num_arguments() { return 0; }
113    virtual void execute(DCmdSource source, TRAPS);
114};
115
116// See also: print_flag in attachListener.cpp
117class PrintVMFlagsDCmd : public DCmdWithParser {
118protected:
119  DCmdArgument<bool> _all;
120public:
121  PrintVMFlagsDCmd(outputStream* output, bool heap);
122  static const char* name() { return "VM.flags"; }
123  static const char* description() {
124    return "Print VM flag options and their current values.";
125  }
126  static const char* impact() {
127    return "Low";
128  }
129  static const JavaPermission permission() {
130    JavaPermission p = {"java.lang.management.ManagementPermission",
131                        "monitor", NULL};
132    return p;
133  }
134  static int num_arguments();
135  virtual void execute(DCmdSource source, TRAPS);
136};
137
138class SetVMFlagDCmd : public DCmdWithParser {
139protected:
140  DCmdArgument<char*> _flag;
141  DCmdArgument<char*> _value;
142
143public:
144  SetVMFlagDCmd(outputStream* output, bool heap);
145  static const char* name() { return "VM.set_flag"; }
146  static const char* description() {
147    return "Sets VM flag option using the provided value.";
148  }
149  static const char* impact() {
150    return "Low";
151  }
152  static const JavaPermission permission() {
153    JavaPermission p = {"java.lang.management.ManagementPermission",
154                        "control", NULL};
155    return p;
156  }
157  static int num_arguments();
158  virtual void execute(DCmdSource source, TRAPS);
159};
160
161class JVMTIDataDumpDCmd : public DCmd {
162public:
163  JVMTIDataDumpDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
164  static const char* name() { return "JVMTI.data_dump"; }
165  static const char* description() {
166    return "Signal the JVM to do a data-dump request for JVMTI.";
167  }
168  static const char* impact() {
169    return "High";
170  }
171  static const JavaPermission permission() {
172    JavaPermission p = {"java.lang.management.ManagementPermission",
173                        "monitor", NULL};
174    return p;
175  }
176  static int num_arguments() { return 0; }
177  virtual void execute(DCmdSource source, TRAPS);
178};
179
180#if INCLUDE_SERVICES
181#if INCLUDE_JVMTI
182class JVMTIAgentLoadDCmd : public DCmdWithParser {
183protected:
184  DCmdArgument<char*> _libpath;
185  DCmdArgument<char*> _option;
186public:
187  JVMTIAgentLoadDCmd(outputStream* output, bool heap);
188  static const char* name() { return "JVMTI.agent_load"; }
189  static const char* description() {
190    return "Load JVMTI native agent.";
191  }
192  static const char* impact() { return "Low"; }
193  static const JavaPermission permission() {
194    JavaPermission p = {"java.lang.management.ManagementPermission",
195                        "control", NULL};
196    return p;
197  }
198  static int num_arguments();
199  virtual void execute(DCmdSource source, TRAPS);
200};
201#endif // INCLUDE_JVMTI
202#endif // INCLUDE_SERVICES
203
204class VMDynamicLibrariesDCmd : public DCmd {
205public:
206  VMDynamicLibrariesDCmd(outputStream* output, bool heap);
207  static const char* name() {
208    return "VM.dynlibs";
209  }
210  static const char* description() {
211    return "Print loaded dynamic libraries.";
212  }
213  static const char* impact() {
214    return "Low";
215  }
216  static const JavaPermission permission() {
217    JavaPermission p = {"java.lang.management.ManagementPermission",
218                        "monitor", NULL};
219    return p;
220  }
221  static int num_arguments() {
222    return 0;
223  };
224  virtual void execute(DCmdSource source, TRAPS);
225};
226
227class VMUptimeDCmd : public DCmdWithParser {
228protected:
229  DCmdArgument<bool> _date;
230public:
231  VMUptimeDCmd(outputStream* output, bool heap);
232  static const char* name() { return "VM.uptime"; }
233  static const char* description() {
234    return "Print VM uptime.";
235  }
236  static const char* impact() {
237    return "Low";
238  }
239  static int num_arguments();
240  virtual void execute(DCmdSource source, TRAPS);
241};
242
243class VMInfoDCmd : public DCmd {
244public:
245  VMInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
246  static const char* name() { return "VM.info"; }
247  static const char* description() {
248    return "Print information about JVM environment and status.";
249  }
250  static const char* impact() { return "Low"; }
251  static const JavaPermission permission() {
252    JavaPermission p = {"java.lang.management.ManagementPermission",
253                        "monitor", NULL};
254    return p;
255  }
256  static int num_arguments() { return 0; }
257  virtual void execute(DCmdSource source, TRAPS);
258};
259
260class SystemGCDCmd : public DCmd {
261public:
262  SystemGCDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
263    static const char* name() { return "GC.run"; }
264    static const char* description() {
265      return "Call java.lang.System.gc().";
266    }
267    static const char* impact() {
268      return "Medium: Depends on Java heap size and content.";
269    }
270    static int num_arguments() { return 0; }
271    virtual void execute(DCmdSource source, TRAPS);
272};
273
274class RunFinalizationDCmd : public DCmd {
275public:
276  RunFinalizationDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
277    static const char* name() { return "GC.run_finalization"; }
278    static const char* description() {
279      return "Call java.lang.System.runFinalization().";
280    }
281    static const char* impact() {
282      return "Medium: Depends on Java content.";
283    }
284    static int num_arguments() { return 0; }
285    virtual void execute(DCmdSource source, TRAPS);
286};
287
288class HeapInfoDCmd : public DCmd {
289public:
290  HeapInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
291  static const char* name() { return "GC.heap_info"; }
292  static const char* description() {
293    return "Provide generic Java heap information.";
294  }
295  static const char* impact() {
296    return "Medium";
297  }
298  static int num_arguments() { return 0; }
299  static const JavaPermission permission() {
300    JavaPermission p = {"java.lang.management.ManagementPermission",
301      "monitor", NULL};
302      return p;
303  }
304
305  virtual void execute(DCmdSource source, TRAPS);
306};
307
308class FinalizerInfoDCmd : public DCmd {
309public:
310  FinalizerInfoDCmd(outputStream* output, bool heap) : DCmd(output, heap) { }
311  static const char* name() { return "GC.finalizer_info"; }
312  static const char* description() {
313    return "Provide information about Java finalization queue.";
314  }
315  static const char* impact() {
316    return "Medium";
317  }
318  static int num_arguments() { return 0; }
319  static const JavaPermission permission() {
320    JavaPermission p = {"java.lang.management.ManagementPermission",
321      "monitor", NULL};
322      return p;
323  }
324
325  virtual void execute(DCmdSource source, TRAPS);
326};
327
328#if INCLUDE_SERVICES   // Heap dumping supported
329// See also: dump_heap in attachListener.cpp
330class HeapDumpDCmd : public DCmdWithParser {
331protected:
332  DCmdArgument<char*> _filename;
333  DCmdArgument<bool>  _all;
334public:
335  HeapDumpDCmd(outputStream* output, bool heap);
336  static const char* name() {
337    return "GC.heap_dump";
338  }
339  static const char* description() {
340    return "Generate a HPROF format dump of the Java heap.";
341  }
342  static const char* impact() {
343    return "High: Depends on Java heap size and content. "
344           "Request a full GC unless the '-all' option is specified.";
345  }
346  static const JavaPermission permission() {
347    JavaPermission p = {"java.lang.management.ManagementPermission",
348                        "monitor", NULL};
349    return p;
350  }
351  static int num_arguments();
352  virtual void execute(DCmdSource source, TRAPS);
353};
354#endif // INCLUDE_SERVICES
355
356// See also: inspectheap in attachListener.cpp
357class ClassHistogramDCmd : public DCmdWithParser {
358protected:
359  DCmdArgument<bool> _all;
360public:
361  ClassHistogramDCmd(outputStream* output, bool heap);
362  static const char* name() {
363    return "GC.class_histogram";
364  }
365  static const char* description() {
366    return "Provide statistics about the Java heap usage.";
367  }
368  static const char* impact() {
369    return "High: Depends on Java heap size and content.";
370  }
371  static const JavaPermission permission() {
372    JavaPermission p = {"java.lang.management.ManagementPermission",
373                        "monitor", NULL};
374    return p;
375  }
376  static int num_arguments();
377  virtual void execute(DCmdSource source, TRAPS);
378};
379
380class ClassStatsDCmd : public DCmdWithParser {
381protected:
382  DCmdArgument<bool> _all;
383  DCmdArgument<bool> _csv;
384  DCmdArgument<bool> _help;
385  DCmdArgument<char*> _columns;
386public:
387  ClassStatsDCmd(outputStream* output, bool heap);
388  static const char* name() {
389    return "GC.class_stats";
390  }
391  static const char* description() {
392    return "Provide statistics about Java class meta data.";
393  }
394  static const char* impact() {
395    return "High: Depends on Java heap size and content.";
396  }
397  static int num_arguments();
398  virtual void execute(DCmdSource source, TRAPS);
399};
400
401
402class ClassHierarchyDCmd : public DCmdWithParser {
403protected:
404  DCmdArgument<bool> _print_interfaces; // true if inherited interfaces should be printed.
405  DCmdArgument<bool> _print_subclasses; // true if subclasses of the specified classname should be printed.
406  DCmdArgument<char*> _classname; // Optional single class name whose hierarchy should be printed.
407public:
408  ClassHierarchyDCmd(outputStream* output, bool heap);
409  static const char* name() {
410    return "VM.class_hierarchy";
411  }
412  static const char* description() {
413    return "Print a list of all loaded classes, indented to show the class hiearchy. "
414           "The name of each class is followed by the ClassLoaderData* of its ClassLoader, "
415           "or \"null\" if loaded by the bootstrap class loader.";
416  }
417  static const char* impact() {
418      return "Medium: Depends on number of loaded classes.";
419  }
420  static const JavaPermission permission() {
421    JavaPermission p = {"java.lang.management.ManagementPermission",
422                        "monitor", NULL};
423    return p;
424  }
425  static int num_arguments();
426  virtual void execute(DCmdSource source, TRAPS);
427};
428
429class TouchedMethodsDCmd : public DCmdWithParser {
430public:
431  TouchedMethodsDCmd(outputStream* output, bool heap);
432  static const char* name() {
433    return "VM.print_touched_methods";
434  }
435  static const char* description() {
436    return "Print all methods that have ever been touched during the lifetime of this JVM.";
437  }
438  static const char* impact() {
439    return "Medium: Depends on Java content.";
440  }
441  static int num_arguments();
442  virtual void execute(DCmdSource source, TRAPS);
443};
444
445// See also: thread_dump in attachListener.cpp
446class ThreadDumpDCmd : public DCmdWithParser {
447protected:
448  DCmdArgument<bool> _locks;
449public:
450  ThreadDumpDCmd(outputStream* output, bool heap);
451  static const char* name() { return "Thread.print"; }
452  static const char* description() {
453    return "Print all threads with stacktraces.";
454  }
455  static const char* impact() {
456    return "Medium: Depends on the number of threads.";
457  }
458  static const JavaPermission permission() {
459    JavaPermission p = {"java.lang.management.ManagementPermission",
460                        "monitor", NULL};
461    return p;
462  }
463  static int num_arguments();
464  virtual void execute(DCmdSource source, TRAPS);
465};
466
467// Enhanced JMX Agent support
468
469class JMXStartRemoteDCmd : public DCmdWithParser {
470
471  // Explicitly list all properties that could be
472  // passed to Agent.startRemoteManagementAgent()
473  // com.sun.management is omitted
474
475  DCmdArgument<char *> _config_file;
476  DCmdArgument<char *> _jmxremote_host;
477  DCmdArgument<char *> _jmxremote_port;
478  DCmdArgument<char *> _jmxremote_rmi_port;
479  DCmdArgument<char *> _jmxremote_ssl;
480  DCmdArgument<char *> _jmxremote_registry_ssl;
481  DCmdArgument<char *> _jmxremote_authenticate;
482  DCmdArgument<char *> _jmxremote_password_file;
483  DCmdArgument<char *> _jmxremote_access_file;
484  DCmdArgument<char *> _jmxremote_login_config;
485  DCmdArgument<char *> _jmxremote_ssl_enabled_cipher_suites;
486  DCmdArgument<char *> _jmxremote_ssl_enabled_protocols;
487  DCmdArgument<char *> _jmxremote_ssl_need_client_auth;
488  DCmdArgument<char *> _jmxremote_ssl_config_file;
489
490  // JDP support
491  // Keep autodiscovery char* not bool to pass true/false
492  // as property value to java level.
493  DCmdArgument<char *> _jmxremote_autodiscovery;
494  DCmdArgument<jlong>  _jdp_port;
495  DCmdArgument<char *> _jdp_address;
496  DCmdArgument<char *> _jdp_source_addr;
497  DCmdArgument<jlong>  _jdp_ttl;
498  DCmdArgument<jlong>  _jdp_pause;
499  DCmdArgument<char *> _jdp_name;
500
501public:
502  JMXStartRemoteDCmd(outputStream *output, bool heap_allocated);
503
504  static const char *name() {
505    return "ManagementAgent.start";
506  }
507
508  static const char *description() {
509    return "Start remote management agent.";
510  }
511
512  static int num_arguments();
513
514  virtual void execute(DCmdSource source, TRAPS);
515
516};
517
518class JMXStartLocalDCmd : public DCmd {
519
520  // Explicitly request start of local agent,
521  // it will not be started by start dcmd
522
523
524public:
525  JMXStartLocalDCmd(outputStream *output, bool heap_allocated);
526
527  static const char *name() {
528    return "ManagementAgent.start_local";
529  }
530
531  static const char *description() {
532    return "Start local management agent.";
533  }
534
535  virtual void execute(DCmdSource source, TRAPS);
536
537};
538
539class JMXStopRemoteDCmd : public DCmd {
540public:
541  JMXStopRemoteDCmd(outputStream *output, bool heap_allocated) :
542  DCmd(output, heap_allocated) {
543    // Do Nothing
544  }
545
546  static const char *name() {
547    return "ManagementAgent.stop";
548  }
549
550  static const char *description() {
551    return "Stop remote management agent.";
552  }
553
554  virtual void execute(DCmdSource source, TRAPS);
555};
556
557// Print the JMX system status
558class JMXStatusDCmd : public DCmd {
559public:
560  JMXStatusDCmd(outputStream *output, bool heap_allocated);
561
562  static const char *name() {
563    return "ManagementAgent.status";
564  }
565
566  static const char *description() {
567    return "Print the management agent status.";
568  }
569
570  static const JavaPermission permission() {
571    JavaPermission p = {"java.lang.management.ManagementPermission",
572                        "monitor", NULL};
573    return p;
574  }
575
576  virtual void execute(DCmdSource source, TRAPS);
577
578};
579
580class CompileQueueDCmd : public DCmd {
581public:
582  CompileQueueDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
583  static const char* name() {
584    return "Compiler.queue";
585  }
586  static const char* description() {
587    return "Print methods queued for compilation.";
588  }
589  static const char* impact() {
590    return "Low";
591  }
592  static const JavaPermission permission() {
593    JavaPermission p = {"java.lang.management.ManagementPermission",
594                        "monitor", NULL};
595    return p;
596  }
597  static int num_arguments() { return 0; }
598  virtual void execute(DCmdSource source, TRAPS);
599};
600
601class CodeListDCmd : public DCmd {
602public:
603  CodeListDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
604  static const char* name() {
605    return "Compiler.codelist";
606  }
607  static const char* description() {
608    return "Print all compiled methods in code cache that are alive";
609  }
610  static const char* impact() {
611    return "Medium";
612  }
613  static const JavaPermission permission() {
614    JavaPermission p = {"java.lang.management.ManagementPermission",
615                        "monitor", NULL};
616    return p;
617  }
618  static int num_arguments() { return 0; }
619  virtual void execute(DCmdSource source, TRAPS);
620};
621
622
623class CodeCacheDCmd : public DCmd {
624public:
625  CodeCacheDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
626  static const char* name() {
627    return "Compiler.codecache";
628  }
629  static const char* description() {
630    return "Print code cache layout and bounds.";
631  }
632  static const char* impact() {
633    return "Low";
634  }
635  static const JavaPermission permission() {
636    JavaPermission p = {"java.lang.management.ManagementPermission",
637                        "monitor", NULL};
638    return p;
639  }
640  static int num_arguments() { return 0; }
641  virtual void execute(DCmdSource source, TRAPS);
642};
643
644class CompilerDirectivesPrintDCmd : public DCmd {
645public:
646  CompilerDirectivesPrintDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
647  static const char* name() {
648    return "Compiler.directives_print";
649  }
650  static const char* description() {
651    return "Print all active compiler directives.";
652  }
653  static const char* impact() {
654    return "Low";
655  }
656  static const JavaPermission permission() {
657    JavaPermission p = {"java.lang.management.ManagementPermission",
658                        "monitor", NULL};
659    return p;
660  }
661  static int num_arguments() { return 0; }
662  virtual void execute(DCmdSource source, TRAPS);
663};
664
665class CompilerDirectivesRemoveDCmd : public DCmd {
666public:
667  CompilerDirectivesRemoveDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
668  static const char* name() {
669    return "Compiler.directives_remove";
670  }
671  static const char* description() {
672    return "Remove latest added compiler directive.";
673  }
674  static const char* impact() {
675    return "Low";
676  }
677  static const JavaPermission permission() {
678    JavaPermission p = {"java.lang.management.ManagementPermission",
679                        "monitor", NULL};
680    return p;
681  }
682  static int num_arguments() { return 0; }
683  virtual void execute(DCmdSource source, TRAPS);
684};
685
686class CompilerDirectivesAddDCmd : public DCmdWithParser {
687protected:
688  DCmdArgument<char*> _filename;
689public:
690  CompilerDirectivesAddDCmd(outputStream* output, bool heap);
691  static const char* name() {
692    return "Compiler.directives_add";
693  }
694  static const char* description() {
695    return "Add compiler directives from file.";
696  }
697  static const char* impact() {
698    return "Low";
699  }
700  static const JavaPermission permission() {
701    JavaPermission p = {"java.lang.management.ManagementPermission",
702                        "monitor", NULL};
703    return p;
704  }
705  static int num_arguments();
706  virtual void execute(DCmdSource source, TRAPS);
707};
708
709class CompilerDirectivesClearDCmd : public DCmd {
710public:
711  CompilerDirectivesClearDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
712  static const char* name() {
713    return "Compiler.directives_clear";
714  }
715  static const char* description() {
716    return "Remove all compiler directives.";
717  }
718  static const char* impact() {
719    return "Low";
720  }
721  static const JavaPermission permission() {
722    JavaPermission p = {"java.lang.management.ManagementPermission",
723                        "monitor", NULL};
724    return p;
725  }
726  static int num_arguments() { return 0; }
727  virtual void execute(DCmdSource source, TRAPS);
728};
729
730///////////////////////////////////////////////////////////////////////
731//
732// jcmd command support for symbol table, string table and system dictionary dumping:
733//   VM.symboltable -verbose: for dumping the symbol table
734//   VM.stringtable -verbose: for dumping the string table
735//   VM.systemdictionary -verbose: for dumping the system dictionary table
736//
737class VM_DumpHashtable : public VM_Operation {
738private:
739  outputStream* _out;
740  int _which;
741  bool _verbose;
742public:
743  enum {
744    DumpSymbols = 1 << 0,
745    DumpStrings = 1 << 1,
746    DumpSysDict = 1 << 2  // not implemented yet
747  };
748  VM_DumpHashtable(outputStream* out, int which, bool verbose) {
749    _out = out;
750    _which = which;
751    _verbose = verbose;
752  }
753
754  virtual VMOp_Type type() const { return VMOp_DumpHashtable; }
755
756  virtual void doit() {
757    switch (_which) {
758    case DumpSymbols:
759      SymbolTable::dump(_out, _verbose);
760      break;
761    case DumpStrings:
762      StringTable::dump(_out, _verbose);
763      break;
764    case DumpSysDict:
765      SystemDictionary::dump(_out, _verbose);
766      break;
767    default:
768      ShouldNotReachHere();
769    }
770  }
771};
772
773class SymboltableDCmd : public DCmdWithParser {
774protected:
775  DCmdArgument<bool> _verbose;
776public:
777  SymboltableDCmd(outputStream* output, bool heap);
778  static const char* name() {
779    return "VM.symboltable";
780  }
781  static const char* description() {
782    return "Dump symbol table.";
783  }
784  static const char* impact() {
785    return "Medium: Depends on Java content.";
786  }
787  static const JavaPermission permission() {
788    JavaPermission p = {"java.lang.management.ManagementPermission",
789                        "monitor", NULL};
790    return p;
791  }
792  static int num_arguments();
793  virtual void execute(DCmdSource source, TRAPS);
794};
795
796class StringtableDCmd : public DCmdWithParser {
797protected:
798  DCmdArgument<bool> _verbose;
799public:
800  StringtableDCmd(outputStream* output, bool heap);
801  static const char* name() {
802    return "VM.stringtable";
803  }
804  static const char* description() {
805    return "Dump string table.";
806  }
807  static const char* impact() {
808    return "Medium: Depends on Java content.";
809  }
810  static const JavaPermission permission() {
811    JavaPermission p = {"java.lang.management.ManagementPermission",
812                        "monitor", NULL};
813    return p;
814  }
815  static int num_arguments();
816  virtual void execute(DCmdSource source, TRAPS);
817};
818
819class SystemDictionaryDCmd : public DCmdWithParser {
820protected:
821  DCmdArgument<bool> _verbose;
822public:
823  SystemDictionaryDCmd(outputStream* output, bool heap);
824  static const char* name() {
825    return "VM.systemdictionary";
826  }
827  static const char* description() {
828    return "Prints the statistics for dictionary hashtable sizes and bucket length";
829  }
830  static const char* impact() {
831      return "Medium: Depends on Java content.";
832  }
833  static const JavaPermission permission() {
834    JavaPermission p = {"java.lang.management.ManagementPermission",
835                        "monitor", NULL};
836    return p;
837  }
838  static int num_arguments();
839  virtual void execute(DCmdSource source, TRAPS);
840};
841
842#endif // SHARE_VM_SERVICES_DIAGNOSTICCOMMAND_HPP
843