Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 2000, 2010, 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

 #ifndef VM_STRUCTS_KERNEL

 #include "utilities/debug.hpp"

 #endif

 #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: "methodOopDesc")

   const char* superclassName;      // Superclass name, or null if none (example: "oopDesc")

   int32_t isOopType;               // Does this type represent an oop typedef? (i.e., "methodOop" or

                                    // "klassOop", but NOT "methodOopDesc")

   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();

 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