137 lines
6.2 KiB
C++
137 lines
6.2 KiB
C++
/*
|
|
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*
|
|
*/
|
|
|
|
#ifndef SHARE_VM_RUNTIME_VMSTRUCTS_HPP
|
|
#define SHARE_VM_RUNTIME_VMSTRUCTS_HPP
|
|
|
|
#include "utilities/debug.hpp"
|
|
#ifdef COMPILER1
|
|
#include "c1/c1_Runtime1.hpp"
|
|
#endif
|
|
|
|
// This table encapsulates the debugging information required by the
|
|
// serviceability agent in order to run. Specifically, we need to
|
|
// understand the layout of certain C data structures (offsets, in
|
|
// bytes, of their fields.)
|
|
//
|
|
// There are alternatives for the design of this mechanism, including
|
|
// parsing platform-specific debugging symbols from a debug build into
|
|
// a program database. While this current mechanism can be considered
|
|
// to be a workaround for the inability to debug arbitrary C and C++
|
|
// programs at the present time, it does have certain advantages.
|
|
// First, it is platform-independent, which will vastly simplify the
|
|
// initial bringup of the system both now and on future platforms.
|
|
// Second, it is embedded within the VM, as opposed to being in a
|
|
// separate program database; experience has shown that whenever
|
|
// portions of a system are decoupled, version skew is problematic.
|
|
// Third, generating a program database, for example for a product
|
|
// build, would probably require two builds to be done: the desired
|
|
// product build as well as an intermediary build with the PRODUCT
|
|
// flag turned on but also compiled with -g, leading to a doubling of
|
|
// the time required to get a serviceability agent-debuggable product
|
|
// build. Fourth, and very significantly, this table probably
|
|
// preserves more information about field types than stabs do; for
|
|
// example, it preserves the fact that a field is a "jlong" rather
|
|
// than transforming the type according to the typedef in jni_md.h,
|
|
// which allows the Java-side code to identify "Java-sized" fields in
|
|
// C++ data structures. If the symbol parsing mechanism was redone
|
|
// using stabs, it might still be necessary to have a table somewhere
|
|
// containing this information.
|
|
//
|
|
// Do not change the sizes or signedness of the integer values in
|
|
// these data structures; they are fixed over in the serviceability
|
|
// agent's Java code (for bootstrapping).
|
|
|
|
typedef struct {
|
|
const char* typeName; // The type name containing the given field (example: "Klass")
|
|
const char* fieldName; // The field name within the type (example: "_name")
|
|
const char* typeString; // Quoted name of the type of this field (example: "Symbol*";
|
|
// parsed in Java to ensure type correctness
|
|
int32_t isStatic; // Indicates whether following field is an offset or an address
|
|
uint64_t offset; // Offset of field within structure; only used for nonstatic fields
|
|
void* address; // Address of field; only used for static fields
|
|
// ("offset" can not be reused because of apparent SparcWorks compiler bug
|
|
// in generation of initializer data)
|
|
} VMStructEntry;
|
|
|
|
typedef struct {
|
|
const char* typeName; // Type name (example: "Method")
|
|
const char* superclassName; // Superclass name, or null if none (example: "oopDesc")
|
|
int32_t isOopType; // Does this type represent an oop typedef? (i.e., "Method*" or
|
|
// "Klass*", but NOT "Method")
|
|
int32_t isIntegerType; // Does this type represent an integer type (of arbitrary size)?
|
|
int32_t isUnsigned; // If so, is it unsigned?
|
|
uint64_t size; // Size, in bytes, of the type
|
|
} VMTypeEntry;
|
|
|
|
typedef struct {
|
|
const char* name; // Name of constant (example: "_thread_in_native")
|
|
int32_t value; // Value of constant
|
|
} VMIntConstantEntry;
|
|
|
|
typedef struct {
|
|
const char* name; // Name of constant (example: "_thread_in_native")
|
|
uint64_t value; // Value of constant
|
|
} VMLongConstantEntry;
|
|
|
|
// This class is a friend of most classes, to be able to access
|
|
// private fields
|
|
class VMStructs {
|
|
public:
|
|
// The last entry is identified over in the serviceability agent by
|
|
// the fact that it has a NULL fieldName
|
|
static VMStructEntry localHotSpotVMStructs[];
|
|
|
|
// The last entry is identified over in the serviceability agent by
|
|
// the fact that it has a NULL typeName
|
|
static VMTypeEntry localHotSpotVMTypes[];
|
|
|
|
// Table of integer constants required by the serviceability agent.
|
|
// The last entry is identified over in the serviceability agent by
|
|
// the fact that it has a NULL typeName
|
|
static VMIntConstantEntry localHotSpotVMIntConstants[];
|
|
|
|
// Table of long constants required by the serviceability agent.
|
|
// The last entry is identified over in the serviceability agent by
|
|
// the fact that it has a NULL typeName
|
|
static VMLongConstantEntry localHotSpotVMLongConstants[];
|
|
|
|
// This is used to run any checking code necessary for validation of
|
|
// the data structure (debug build only)
|
|
static void init();
|
|
|
|
#ifndef PRODUCT
|
|
// Execute unit tests
|
|
static void test();
|
|
#endif
|
|
|
|
private:
|
|
// Look up a type in localHotSpotVMTypes using strcmp() (debug build only).
|
|
// Returns 1 if found, 0 if not.
|
|
// debug_only(static int findType(const char* typeName);)
|
|
static int findType(const char* typeName);
|
|
};
|
|
|
|
#endif // SHARE_VM_RUNTIME_VMSTRUCTS_HPP
|