vmStructs.hpp revision 1472:c18cbe5936b8 
1/*
2 * Copyright (c) 2000, 2001, 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// This table encapsulates the debugging information required by the
26// serviceability agent in order to run. Specifically, we need to
27// understand the layout of certain C data structures (offsets, in
28// bytes, of their fields.)
29//
30// There are alternatives for the design of this mechanism, including
31// parsing platform-specific debugging symbols from a debug build into
32// a program database. While this current mechanism can be considered
33// to be a workaround for the inability to debug arbitrary C and C++
34// programs at the present time, it does have certain advantages.
35// First, it is platform-independent, which will vastly simplify the
36// initial bringup of the system both now and on future platforms.
37// Second, it is embedded within the VM, as opposed to being in a
38// separate program database; experience has shown that whenever
39// portions of a system are decoupled, version skew is problematic.
40// Third, generating a program database, for example for a product
41// build, would probably require two builds to be done: the desired
42// product build as well as an intermediary build with the PRODUCT
43// flag turned on but also compiled with -g, leading to a doubling of
44// the time required to get a serviceability agent-debuggable product
45// build. Fourth, and very significantly, this table probably
46// preserves more information about field types than stabs do; for
47// example, it preserves the fact that a field is a "jlong" rather
48// than transforming the type according to the typedef in jni_md.h,
49// which allows the Java-side code to identify "Java-sized" fields in
50// C++ data structures. If the symbol parsing mechanism was redone
51// using stabs, it might still be necessary to have a table somewhere
52// containing this information.
53//
54// Do not change the sizes or signedness of the integer values in
55// these data structures; they are fixed over in the serviceability
56// agent's Java code (for bootstrapping).
57
58typedef struct {
59  const char* typeName;            // The type name containing the given field (example: "Klass")
60  const char* fieldName;           // The field name within the type           (example: "_name")
61  const char* typeString;          // Quoted name of the type of this field (example: "symbolOopDesc*";
62                                   // parsed in Java to ensure type correctness
63  int32_t  isStatic;               // Indicates whether following field is an offset or an address
64  uint64_t offset;                 // Offset of field within structure; only used for nonstatic fields
65  void* address;                   // Address of field; only used for static fields
66                                   // ("offset" can not be reused because of apparent SparcWorks compiler bug
67                                   // in generation of initializer data)
68} VMStructEntry;
69
70typedef struct {
71  const char* typeName;            // Type name (example: "methodOopDesc")
72  const char* superclassName;      // Superclass name, or null if none (example: "oopDesc")
73  int32_t isOopType;               // Does this type represent an oop typedef? (i.e., "methodOop" or
74                                   // "klassOop", but NOT "methodOopDesc")
75  int32_t isIntegerType;           // Does this type represent an integer type (of arbitrary size)?
76  int32_t isUnsigned;              // If so, is it unsigned?
77  uint64_t size;                   // Size, in bytes, of the type
78} VMTypeEntry;
79
80typedef struct {
81  const char* name;                // Name of constant (example: "_thread_in_native")
82  int32_t value;                   // Value of constant
83} VMIntConstantEntry;
84
85typedef struct {
86  const char* name;                // Name of constant (example: "_thread_in_native")
87  uint64_t value;                  // Value of constant
88} VMLongConstantEntry;
89
90// This class is a friend of most classes, to be able to access
91// private fields
92class VMStructs {
93public:
94  // The last entry is identified over in the serviceability agent by
95  // the fact that it has a NULL fieldName
96  static VMStructEntry localHotSpotVMStructs[];
97
98  // The last entry is identified over in the serviceability agent by
99  // the fact that it has a NULL typeName
100  static VMTypeEntry   localHotSpotVMTypes[];
101
102  // Table of integer constants required by the serviceability agent.
103  // The last entry is identified over in the serviceability agent by
104  // the fact that it has a NULL typeName
105  static VMIntConstantEntry localHotSpotVMIntConstants[];
106
107  // Table of long constants required by the serviceability agent.
108  // The last entry is identified over in the serviceability agent by
109  // the fact that it has a NULL typeName
110  static VMLongConstantEntry localHotSpotVMLongConstants[];
111
112  // This is used to run any checking code necessary for validation of
113  // the data structure (debug build only)
114  static void init();
115
116private:
117  // Look up a type in localHotSpotVMTypes using strcmp() (debug build only).
118  // Returns 1 if found, 0 if not.
119  //  debug_only(static int findType(const char* typeName);)
120  static int findType(const char* typeName);
121};
122