class Array: public MetaspaceObj {
friend class MetadataFactory;
friend class VMStructs;
friend class MethodHandleCompiler; // special case
friend class WhiteBox;
protected:
int _length; // the number of array elements
T _data[1]; // the array memory
void initialize(int length) {
_length = length;
}
private:
Array(const Array<T>&);
void operator=(const Array<T>&);
void* operator new(size_t size, ClassLoaderData* loader_data, int length, bool read_only, TRAPS) throw() {
size_t word_size = Array::size(length);
return (void*) Metaspace::allocate(loader_data, word_size, read_only,
MetaspaceObj::array_type(sizeof(T)), THREAD);
}
static size_t byte_sizeof(int length) { return sizeof(Array<T>) + MAX2(length - 1, 0) * sizeof(T); }
static int bytes_to_length(size_t bytes) {
assert(is_size_aligned(bytes, BytesPerWord), "Must be, for now");
if (sizeof(Array<T>) >= bytes) {
return 0;
}
size_t left = bytes - sizeof(Array<T>);
assert(is_size_aligned(left, sizeof(T)), "Must be");
size_t elements = left / sizeof(T);
assert(elements <= (size_t)INT_MAX, err_msg("number of elements " SIZE_FORMAT "doesn't fit into an int.", elements));
int length = (int)elements;
assert((size_t)size(length) * BytesPerWord == bytes,
err_msg("Expected: " SIZE_FORMAT " got: " SIZE_FORMAT,
bytes, (size_t)size(length) * BytesPerWord));
return length;
}
explicit Array(int length) : _length(length) {
assert(length >= 0, "illegal length");
}
Array(int length, T init) : _length(length) {
assert(length >= 0, "illegal length");
for (int i = 0; i < length; i++) {
_data[i] = init;
}
}
public:
int length() const { return _length; }
T* data() { return _data; }
bool is_empty() const { return length() == 0; }
int index_of(const T& x) const {
int i = length();
while (i-- > 0 && _data[i] != x) ;
return i;
}
bool contains(const T& x) const { return index_of(x) >= 0; }
T at(int i) const { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); return _data[i]; }
void at_put(const int i, const T& x) { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); _data[i] = x; }
T* adr_at(const int i) { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); return &_data[i]; }
int find(const T& x) { return index_of(x); }
T at_acquire(const int which) { return OrderAccess::load_acquire(adr_at(which)); }
void release_at_put(int which, T contents) { OrderAccess::release_store(adr_at(which), contents); }
static int size(int length) {
return align_size_up(byte_sizeof(length), BytesPerWord) / BytesPerWord;
}
int size() {
return size(_length);
}
static int length_offset_in_bytes() { return (int) (offset_of(Array<T>, _length)); }
static int base_offset_in_bytes() { return (int) (offset_of(Array<T>, _data)); };
void print_value_on(outputStream* st) const {
st->print("Array<T>(" INTPTR_FORMAT ")", p2i(this));
}
#ifndef PRODUCT
void print(outputStream* st) {
for (int i = 0; i< _length; i++) {
st->print_cr("%d: " INTPTR_FORMAT, i, (intptr_t)at(i));
}
}
void print() { print(tty); }
#endif // PRODUCT
};
#endif // SHARE_VM_UTILITIES_ARRAY_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/bitMap.cpp
#include "precompiled.hpp"
#include "memory/allocation.inline.hpp"
#include "utilities/bitMap.inline.hpp"
#include "utilities/copy.hpp"
#ifdef TARGET_OS_FAMILY_linux
# include "os_linux.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_solaris
# include "os_solaris.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_windows
# include "os_windows.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_aix
# include "os_aix.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_bsd
# include "os_bsd.inline.hpp"
#endif
BitMap::BitMap(bm_word_t* map, idx_t size_in_bits) :
_map(map), _size(size_in_bits), _map_allocator(false)
{
assert(sizeof(bm_word_t) == BytesPerWord, "Implementation assumption.");
assert(size_in_bits >= 0, "just checking");
}
BitMap::BitMap(idx_t size_in_bits, bool in_resource_area) :
_map(NULL), _size(0), _map_allocator(false)
{
assert(sizeof(bm_word_t) == BytesPerWord, "Implementation assumption.");
resize(size_in_bits, in_resource_area);
}
void BitMap::resize(idx_t size_in_bits, bool in_resource_area) {
assert(size_in_bits >= 0, "just checking");
idx_t old_size_in_words = size_in_words();
bm_word_t* old_map = map();
_size = size_in_bits;
idx_t new_size_in_words = size_in_words();
if (in_resource_area) {
_map = NEW_RESOURCE_ARRAY(bm_word_t, new_size_in_words);
} else {
if (old_map != NULL) {
_map_allocator.free();
}
_map = _map_allocator.allocate(new_size_in_words);
}
Copy::disjoint_words((HeapWord*)old_map, (HeapWord*) _map,
MIN2(old_size_in_words, new_size_in_words));
if (new_size_in_words > old_size_in_words) {
clear_range_of_words(old_size_in_words, size_in_words());
}
}
void BitMap::set_range_within_word(idx_t beg, idx_t end) {
if (beg != end) {
bm_word_t mask = inverted_bit_mask_for_range(beg, end);
}
}
void BitMap::clear_range_within_word(idx_t beg, idx_t end) {
if (beg != end) {
bm_word_t mask = inverted_bit_mask_for_range(beg, end);
}
}
void BitMap::par_put_range_within_word(idx_t beg, idx_t end, bool value) {
assert(value == 0 || value == 1, "0 for clear, 1 for set");
if (beg != end) {
intptr_t* pw = (intptr_t*)word_addr(beg);
intptr_t w = *pw;
intptr_t mr = (intptr_t)inverted_bit_mask_for_range(beg, end);
intptr_t nw = value ? (w | ~mr) : (w & mr);
while (true) {
intptr_t res = Atomic::cmpxchg_ptr(nw, pw, w);
if (res == w) break;
w = res;
nw = value ? (w | ~mr) : (w & mr);
}
}
}
void BitMap::set_range(idx_t beg, idx_t end) {
verify_range(beg, end);
idx_t beg_full_word = word_index_round_up(beg);
idx_t end_full_word = word_index(end);
if (beg_full_word < end_full_word) {
set_range_within_word(beg, bit_index(beg_full_word));
set_range_of_words(beg_full_word, end_full_word);
set_range_within_word(bit_index(end_full_word), end);
} else {
idx_t boundary = MIN2(bit_index(beg_full_word), end);
set_range_within_word(beg, boundary);
set_range_within_word(boundary, end);
}
}
void BitMap::clear_range(idx_t beg, idx_t end) {
verify_range(beg, end);
idx_t beg_full_word = word_index_round_up(beg);
idx_t end_full_word = word_index(end);
if (beg_full_word < end_full_word) {
clear_range_within_word(beg, bit_index(beg_full_word));
clear_range_of_words(beg_full_word, end_full_word);
clear_range_within_word(bit_index(end_full_word), end);
} else {
idx_t boundary = MIN2(bit_index(beg_full_word), end);
clear_range_within_word(beg, boundary);
clear_range_within_word(boundary, end);
}
}
bool BitMap::is_small_range_of_words(idx_t beg_full_word, idx_t end_full_word) {
STATIC_ASSERT(small_range_words >= 1);
return (beg_full_word + small_range_words >= end_full_word);
}
void BitMap::set_large_range(idx_t beg, idx_t end) {
verify_range(beg, end);
idx_t beg_full_word = word_index_round_up(beg);
idx_t end_full_word = word_index(end);
if (is_small_range_of_words(beg_full_word, end_full_word)) {
set_range(beg, end);
return;
}
set_range_within_word(beg, bit_index(beg_full_word));
set_large_range_of_words(beg_full_word, end_full_word);
set_range_within_word(bit_index(end_full_word), end);
}
void BitMap::clear_large_range(idx_t beg, idx_t end) {
verify_range(beg, end);
idx_t beg_full_word = word_index_round_up(beg);
idx_t end_full_word = word_index(end);
if (is_small_range_of_words(beg_full_word, end_full_word)) {
clear_range(beg, end);
return;
}
clear_range_within_word(beg, bit_index(beg_full_word));
clear_large_range_of_words(beg_full_word, end_full_word);
clear_range_within_word(bit_index(end_full_word), end);
}
void BitMap::at_put(idx_t offset, bool value) {
if (value) {
set_bit(offset);
} else {
clear_bit(offset);
}
}
bool BitMap::par_at_put(idx_t bit, bool value) {
return value ? par_set_bit(bit) : par_clear_bit(bit);
}
void BitMap::at_put_grow(idx_t offset, bool value) {
if (offset >= size()) {
resize(2 * MAX2(size(), offset));
}
at_put(offset, value);
}
void BitMap::at_put_range(idx_t start_offset, idx_t end_offset, bool value) {
if (value) {
set_range(start_offset, end_offset);
} else {
clear_range(start_offset, end_offset);
}
}
void BitMap::par_at_put_range(idx_t beg, idx_t end, bool value) {
verify_range(beg, end);
idx_t beg_full_word = word_index_round_up(beg);
idx_t end_full_word = word_index(end);
if (beg_full_word < end_full_word) {
par_put_range_within_word(beg, bit_index(beg_full_word), value);
if (value) {
set_range_of_words(beg_full_word, end_full_word);
} else {
clear_range_of_words(beg_full_word, end_full_word);
}
par_put_range_within_word(bit_index(end_full_word), end, value);
} else {
idx_t boundary = MIN2(bit_index(beg_full_word), end);
par_put_range_within_word(beg, boundary, value);
par_put_range_within_word(boundary, end, value);
}
}
void BitMap::at_put_large_range(idx_t beg, idx_t end, bool value) {
if (value) {
set_large_range(beg, end);
} else {
clear_large_range(beg, end);
}
}
void BitMap::par_at_put_large_range(idx_t beg, idx_t end, bool value) {
verify_range(beg, end);
idx_t beg_full_word = word_index_round_up(beg);
idx_t end_full_word = word_index(end);
if (is_small_range_of_words(beg_full_word, end_full_word)) {
par_at_put_range(beg, end, value);
return;
}
par_put_range_within_word(beg, bit_index(beg_full_word), value);
if (value) {
set_large_range_of_words(beg_full_word, end_full_word);
} else {
clear_large_range_of_words(beg_full_word, end_full_word);
}
par_put_range_within_word(bit_index(end_full_word), end, value);
}
bool BitMap::contains(const BitMap other) const {
assert(size() == other.size(), "must have same size");
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size_in_words(); index++) {
bm_word_t word_union = dest_map[index] | other_map[index];
if (word_union != dest_map[index]) return false;
}
return true;
}
bool BitMap::intersects(const BitMap other) const {
assert(size() == other.size(), "must have same size");
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size_in_words(); index++) {
if ((dest_map[index] & other_map[index]) != 0) return true;
}
return false;
}
void BitMap::set_union(BitMap other) {
assert(size() == other.size(), "must have same size");
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size_in_words(); index++) {
dest_map[index] = dest_map[index] | other_map[index];
}
}
void BitMap::set_difference(BitMap other) {
assert(size() == other.size(), "must have same size");
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size_in_words(); index++) {
dest_map[index] = dest_map[index] & ~(other_map[index]);
}
}
void BitMap::set_intersection(BitMap other) {
assert(size() == other.size(), "must have same size");
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
dest_map[index] = dest_map[index] & other_map[index];
}
}
void BitMap::set_intersection_at_offset(BitMap other, idx_t offset) {
assert(other.size() >= offset, "offset not in range");
assert(other.size() - offset >= size(), "other not large enough");
guarantee((offset % (sizeof(bm_word_t) * BitsPerByte)) == 0,
"Only handle aligned cases so far.");
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t offset_word_ind = word_index(offset);
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
dest_map[index] = dest_map[index] & other_map[offset_word_ind + index];
}
}
bool BitMap::set_union_with_result(BitMap other) {
assert(size() == other.size(), "must have same size");
bool changed = false;
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
idx_t temp = map(index) | other_map[index];
changed = changed || (temp != map(index));
map()[index] = temp;
}
return changed;
}
bool BitMap::set_difference_with_result(BitMap other) {
assert(size() == other.size(), "must have same size");
bool changed = false;
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
bm_word_t temp = dest_map[index] & ~(other_map[index]);
changed = changed || (temp != dest_map[index]);
dest_map[index] = temp;
}
return changed;
}
bool BitMap::set_intersection_with_result(BitMap other) {
assert(size() == other.size(), "must have same size");
bool changed = false;
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
bm_word_t orig = dest_map[index];
bm_word_t temp = orig & other_map[index];
changed = changed || (temp != orig);
dest_map[index] = temp;
}
return changed;
}
void BitMap::set_from(BitMap other) {
assert(size() == other.size(), "must have same size");
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
dest_map[index] = other_map[index];
}
}
bool BitMap::is_same(BitMap other) {
assert(size() == other.size(), "must have same size");
bm_word_t* dest_map = map();
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
if (dest_map[index] != other_map[index]) return false;
}
return true;
}
bool BitMap::is_full() const {
bm_word_t* word = map();
idx_t rest = size();
for (; rest >= (idx_t) BitsPerWord; rest -= BitsPerWord) {
if (*word != (bm_word_t) AllBits) return false;
word++;
}
return rest == 0 || (*word | ~right_n_bits((int)rest)) == (bm_word_t) AllBits;
}
bool BitMap::is_empty() const {
bm_word_t* word = map();
idx_t rest = size();
for (; rest >= (idx_t) BitsPerWord; rest -= BitsPerWord) {
if (*word != (bm_word_t) NoBits) return false;
word++;
}
return rest == 0 || (*word & right_n_bits((int)rest)) == (bm_word_t) NoBits;
}
void BitMap::clear_large() {
clear_large_range_of_words(0, size_in_words());
}
bool BitMap::iterate(BitMapClosure* blk, idx_t leftOffset, idx_t rightOffset) {
verify_range(leftOffset, rightOffset);
idx_t startIndex = word_index(leftOffset);
idx_t endIndex = MIN2(word_index(rightOffset) + 1, size_in_words());
for (idx_t index = startIndex, offset = leftOffset;
offset < rightOffset && index < endIndex;
offset = (++index) << LogBitsPerWord) {
idx_t rest = map(index) >> (offset & (BitsPerWord - 1));
for (; offset < rightOffset && rest != (bm_word_t)NoBits; offset++) {
if (rest & 1) {
if (!blk->do_bit(offset)) return false;
rest = map(index) >> (offset & (BitsPerWord -1));
}
rest = rest >> 1;
}
}
return true;
}
BitMap::idx_t* BitMap::_pop_count_table = NULL;
void BitMap::init_pop_count_table() {
if (_pop_count_table == NULL) {
BitMap::idx_t *table = NEW_C_HEAP_ARRAY(idx_t, 256, mtInternal);
for (uint i = 0; i < 256; i++) {
table[i] = num_set_bits(i);
}
intptr_t res = Atomic::cmpxchg_ptr((intptr_t) table,
(intptr_t*) &_pop_count_table,
(intptr_t) NULL_WORD);
if (res != NULL_WORD) {
guarantee( _pop_count_table == (void*) res, "invariant" );
FREE_C_HEAP_ARRAY(bm_word_t, table, mtInternal);
}
}
}
BitMap::idx_t BitMap::num_set_bits(bm_word_t w) {
idx_t bits = 0;
while (w != 0) {
while ((w & 1) == 0) {
w >>= 1;
}
bits++;
w >>= 1;
}
return bits;
}
BitMap::idx_t BitMap::num_set_bits_from_table(unsigned char c) {
assert(_pop_count_table != NULL, "precondition");
return _pop_count_table[c];
}
BitMap::idx_t BitMap::count_one_bits() const {
init_pop_count_table(); // If necessary.
idx_t sum = 0;
typedef unsigned char uchar;
for (idx_t i = 0; i < size_in_words(); i++) {
bm_word_t w = map()[i];
for (size_t j = 0; j < sizeof(bm_word_t); j++) {
sum += num_set_bits_from_table(uchar(w & 255));
w >>= 8;
}
}
return sum;
}
void BitMap::print_on_error(outputStream* st, const char* prefix) const {
st->print_cr("%s[" PTR_FORMAT ", " PTR_FORMAT ")",
prefix, p2i(map()), p2i((char*)map() + (size() >> LogBitsPerByte)));
}
#ifndef PRODUCT
void BitMap::print_on(outputStream* st) const {
tty->print("Bitmap(" SIZE_FORMAT "):", size());
for (idx_t index = 0; index < size(); index++) {
tty->print("%c", at(index) ? '1' : '0');
}
tty->cr();
}
#endif
BitMap2D::BitMap2D(bm_word_t* map, idx_t size_in_slots, idx_t bits_per_slot)
: _bits_per_slot(bits_per_slot)
, _map(map, size_in_slots * bits_per_slot)
{
}
BitMap2D::BitMap2D(idx_t size_in_slots, idx_t bits_per_slot)
: _bits_per_slot(bits_per_slot)
, _map(size_in_slots * bits_per_slot)
{
}
C:\hotspot-69087d08d473\src\share\vm/utilities/bitMap.hpp
#ifndef SHARE_VM_UTILITIES_BITMAP_HPP
#define SHARE_VM_UTILITIES_BITMAP_HPP
#include "memory/allocation.hpp"
#include "utilities/top.hpp"
class BitMapClosure;
class BitMap VALUE_OBJ_CLASS_SPEC {
friend class BitMap2D;
public:
typedef size_t idx_t; // Type used for bit and word indices.
typedef uintptr_t bm_word_t; // Element type of array that represents
typedef enum {
unknown_range, small_range, large_range
} RangeSizeHint;
private:
ArrayAllocator<bm_word_t, mtInternal> _map_allocator;
bm_word_t* _map; // First word in bitmap
idx_t _size; // Size of bitmap (in bits)
void at_put_grow(idx_t index, bool value);
static const size_t small_range_words = 32;
protected:
static idx_t bit_in_word(idx_t bit) { return bit & (BitsPerWord - 1); }
static bm_word_t bit_mask(idx_t bit) { return (bm_word_t)1 << bit_in_word(bit); }
static idx_t word_index(idx_t bit) { return bit >> LogBitsPerWord; }
static idx_t bit_index(idx_t word) { return word << LogBitsPerWord; }
bm_word_t* map() const { return _map; }
bm_word_t map(idx_t word) const { return _map[word]; }
bm_word_t* word_addr(idx_t bit) const { return map() + word_index(bit); }
void set_word (idx_t word, bm_word_t val) { _map[word] = val; }
void set_word (idx_t word) { set_word(word, ~(uintptr_t)0); }
void clear_word(idx_t word) { _map[word] = 0; }
bm_word_t inverted_bit_mask_for_range(idx_t beg, idx_t end) const;
void set_range_within_word (idx_t beg, idx_t end);
void clear_range_within_word (idx_t beg, idx_t end);
void par_put_range_within_word (idx_t beg, idx_t end, bool value);
void set_range_of_words (idx_t beg, idx_t end);
void clear_range_of_words (idx_t beg, idx_t end);
void set_large_range_of_words (idx_t beg, idx_t end);
void clear_large_range_of_words (idx_t beg, idx_t end);
static bool is_small_range_of_words(idx_t beg_full_word, idx_t end_full_word);
idx_t word_index_round_up(idx_t bit) const;
inline void verify_index(idx_t index) const NOT_DEBUG_RETURN;
inline void verify_range(idx_t beg_index, idx_t end_index) const
NOT_DEBUG_RETURN;
static idx_t* _pop_count_table;
static void init_pop_count_table();
static idx_t num_set_bits(bm_word_t w);
static idx_t num_set_bits_from_table(unsigned char c);
public:
BitMap() : _map(NULL), _size(0), _map_allocator(false) {}
BitMap(bm_word_t* map, idx_t size_in_bits);
BitMap(idx_t size_in_bits, bool in_resource_area = true);
void set_map(bm_word_t* map) { _map = map; }
void set_size(idx_t size_in_bits) { _size = size_in_bits; }
void resize(idx_t size_in_bits, bool in_resource_area = true);
idx_t size() const { return _size; }
idx_t size_in_words() const {
return word_index(size() + BitsPerWord - 1);
}
bool at(idx_t index) const {
verify_index(index);
return (*word_addr(index) & bit_mask(index)) != 0;
}
static idx_t word_align_up(idx_t bit) {
return align_size_up(bit, BitsPerWord);
}
static idx_t word_align_down(idx_t bit) {
return align_size_down(bit, BitsPerWord);
}
static bool is_word_aligned(idx_t bit) {
return word_align_up(bit) == bit;
}
inline void set_bit(idx_t bit);
inline void clear_bit(idx_t bit);
inline bool par_set_bit(idx_t bit);
inline bool par_clear_bit(idx_t bit);
void at_put(idx_t index, bool value);
bool par_at_put(idx_t index, bool value);
void set_range (idx_t beg, idx_t end);
void clear_range (idx_t beg, idx_t end);
void set_large_range (idx_t beg, idx_t end);
void clear_large_range (idx_t beg, idx_t end);
void at_put_range(idx_t beg, idx_t end, bool value);
void par_at_put_range(idx_t beg, idx_t end, bool value);
void at_put_large_range(idx_t beg, idx_t end, bool value);
void par_at_put_large_range(idx_t beg, idx_t end, bool value);
void set_range(idx_t beg, idx_t end, RangeSizeHint hint);
void clear_range(idx_t beg, idx_t end, RangeSizeHint hint);
void par_set_range(idx_t beg, idx_t end, RangeSizeHint hint);
void par_clear_range (idx_t beg, idx_t end, RangeSizeHint hint);
void clear_large();
inline void clear();
bool iterate(BitMapClosure* blk, idx_t leftIndex, idx_t rightIndex);
bool iterate(BitMapClosure* blk) {
return iterate(blk, 0, size());
}
idx_t get_next_one_offset_inline (idx_t l_index, idx_t r_index) const;
idx_t get_next_zero_offset_inline(idx_t l_index, idx_t r_index) const;
idx_t get_next_one_offset_inline_aligned_right(idx_t l_index,
idx_t r_index) const;
idx_t get_next_one_offset (idx_t l_index, idx_t r_index) const;
idx_t get_next_zero_offset(idx_t l_index, idx_t r_index) const;
idx_t get_next_one_offset(idx_t offset) const {
return get_next_one_offset(offset, size());
}
idx_t get_next_zero_offset(idx_t offset) const {
return get_next_zero_offset(offset, size());
}
idx_t count_one_bits() const;
void set_union(BitMap bits);
void set_difference(BitMap bits);
void set_intersection(BitMap bits);
bool contains(const BitMap bits) const;
bool intersects(const BitMap bits) const;
bool set_union_with_result(BitMap bits);
bool set_difference_with_result(BitMap bits);
bool set_intersection_with_result(BitMap bits);
void set_intersection_at_offset(BitMap bits, idx_t offset);
void set_from(BitMap bits);
bool is_same(BitMap bits);
bool is_full() const;
bool is_empty() const;
void print_on_error(outputStream* st, const char* prefix) const;
#ifndef PRODUCT
public:
void print_on(outputStream* st) const;
#endif
};
class BitMap2D VALUE_OBJ_CLASS_SPEC {
public:
typedef BitMap::idx_t idx_t; // Type used for bit and word indices.
typedef BitMap::bm_word_t bm_word_t; // Element type of array that
private:
BitMap _map;
idx_t _bits_per_slot;
idx_t bit_index(idx_t slot_index, idx_t bit_within_slot_index) const {
return slot_index * _bits_per_slot + bit_within_slot_index;
}
void verify_bit_within_slot_index(idx_t index) const {
assert(index < _bits_per_slot, "bit_within_slot index out of bounds");
}
public:
BitMap2D(bm_word_t* map, idx_t size_in_slots, idx_t bits_per_slot);
BitMap2D(idx_t size_in_slots, idx_t bits_per_slot);
idx_t size_in_bits() {
return _map.size();
}
idx_t size_in_slots() {
return _map.size() / _bits_per_slot;
}
bool is_valid_index(idx_t slot_index, idx_t bit_within_slot_index) {
verify_bit_within_slot_index(bit_within_slot_index);
return (bit_index(slot_index, bit_within_slot_index) < size_in_bits());
}
bool at(idx_t slot_index, idx_t bit_within_slot_index) const {
verify_bit_within_slot_index(bit_within_slot_index);
return _map.at(bit_index(slot_index, bit_within_slot_index));
}
void set_bit(idx_t slot_index, idx_t bit_within_slot_index) {
verify_bit_within_slot_index(bit_within_slot_index);
_map.set_bit(bit_index(slot_index, bit_within_slot_index));
}
void clear_bit(idx_t slot_index, idx_t bit_within_slot_index) {
verify_bit_within_slot_index(bit_within_slot_index);
_map.clear_bit(bit_index(slot_index, bit_within_slot_index));
}
void at_put(idx_t slot_index, idx_t bit_within_slot_index, bool value) {
verify_bit_within_slot_index(bit_within_slot_index);
_map.at_put(bit_index(slot_index, bit_within_slot_index), value);
}
void at_put_grow(idx_t slot_index, idx_t bit_within_slot_index, bool value) {
verify_bit_within_slot_index(bit_within_slot_index);
_map.at_put_grow(bit_index(slot_index, bit_within_slot_index), value);
}
void clear();
};
class BitMapClosure VALUE_OBJ_CLASS_SPEC {
public:
virtual bool do_bit(BitMap::idx_t offset) = 0;
};
#endif // SHARE_VM_UTILITIES_BITMAP_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/bitMap.inline.hpp
#ifndef SHARE_VM_UTILITIES_BITMAP_INLINE_HPP
#define SHARE_VM_UTILITIES_BITMAP_INLINE_HPP
#include "runtime/atomic.inline.hpp"
#include "utilities/bitMap.hpp"
#ifdef ASSERT
inline void BitMap::verify_index(idx_t index) const {
assert(index < _size, "BitMap index out of bounds");
}
inline void BitMap::verify_range(idx_t beg_index, idx_t end_index) const {
assert(beg_index <= end_index, "BitMap range error");
if (end_index != _size) verify_index(end_index);
}
#endif // #ifdef ASSERT
inline void BitMap::set_bit(idx_t bit) {
verify_index(bit);
}
inline void BitMap::clear_bit(idx_t bit) {
verify_index(bit);
}
inline bool BitMap::par_set_bit(idx_t bit) {
verify_index(bit);
volatile bm_word_t* const addr = word_addr(bit);
const bm_word_t mask = bit_mask(bit);
bm_word_t old_val = *addr;
do {
const bm_word_t new_val = old_val | mask;
if (new_val == old_val) {
return false; // Someone else beat us to it.
}
const bm_word_t cur_val = (bm_word_t) Atomic::cmpxchg_ptr((void*) new_val,
(volatile void*) addr,
(void*) old_val);
if (cur_val == old_val) {
return true; // Success.
}
old_val = cur_val; // The value changed, try again.
} while (true);
}
inline bool BitMap::par_clear_bit(idx_t bit) {
verify_index(bit);
volatile bm_word_t* const addr = word_addr(bit);
const bm_word_t mask = ~bit_mask(bit);
bm_word_t old_val = *addr;
do {
const bm_word_t new_val = old_val & mask;
if (new_val == old_val) {
return false; // Someone else beat us to it.
}
const bm_word_t cur_val = (bm_word_t) Atomic::cmpxchg_ptr((void*) new_val,
(volatile void*) addr,
(void*) old_val);
if (cur_val == old_val) {
return true; // Success.
}
old_val = cur_val; // The value changed, try again.
} while (true);
}
inline void BitMap::set_range(idx_t beg, idx_t end, RangeSizeHint hint) {
if (hint == small_range && end - beg == 1) {
set_bit(beg);
} else {
if (hint == large_range) {
set_large_range(beg, end);
} else {
set_range(beg, end);
}
}
}
inline void BitMap::clear_range(idx_t beg, idx_t end, RangeSizeHint hint) {
if (hint == small_range && end - beg == 1) {
clear_bit(beg);
} else {
if (hint == large_range) {
clear_large_range(beg, end);
} else {
clear_range(beg, end);
}
}
}
inline void BitMap::par_set_range(idx_t beg, idx_t end, RangeSizeHint hint) {
if (hint == small_range && end - beg == 1) {
par_at_put(beg, true);
} else {
if (hint == large_range) {
par_at_put_large_range(beg, end, true);
} else {
par_at_put_range(beg, end, true);
}
}
}
inline void BitMap::set_range_of_words(idx_t beg, idx_t end) {
bm_word_t* map = _map;
for (idx_t i = beg; i < end; ++i) map[i] = ~(uintptr_t)0;
}
inline void BitMap::clear_range_of_words(idx_t beg, idx_t end) {
bm_word_t* map = _map;
for (idx_t i = beg; i < end; ++i) map[i] = 0;
}
inline void BitMap::clear() {
clear_range_of_words(0, size_in_words());
}
inline void BitMap::par_clear_range(idx_t beg, idx_t end, RangeSizeHint hint) {
if (hint == small_range && end - beg == 1) {
par_at_put(beg, false);
} else {
if (hint == large_range) {
par_at_put_large_range(beg, end, false);
} else {
par_at_put_range(beg, end, false);
}
}
}
inline BitMap::idx_t
BitMap::get_next_one_offset_inline(idx_t l_offset, idx_t r_offset) const {
assert(l_offset <= size(), "BitMap index out of bounds");
assert(r_offset <= size(), "BitMap index out of bounds");
assert(l_offset <= r_offset, "l_offset > r_offset ?");
if (l_offset == r_offset) {
return l_offset;
}
idx_t index = word_index(l_offset);
idx_t r_index = word_index(r_offset-1) + 1;
idx_t res_offset = l_offset;
idx_t pos = bit_in_word(res_offset);
idx_t res = map(index) >> pos;
if (res != (uintptr_t)NoBits) {
for (; !(res & 1); res_offset++) {
res = res >> 1;
}
#ifdef ASSERT
idx_t limit = is_word_aligned(r_offset) ? r_offset : size();
assert(res_offset >= l_offset && res_offset < limit, "just checking");
#endif // ASSERT
return MIN2(res_offset, r_offset);
}
for (index++; index < r_index; index++) {
res = map(index);
if (res != (uintptr_t)NoBits) {
for (res_offset = bit_index(index); !(res & 1); res_offset++) {
res = res >> 1;
}
assert(res & 1, "tautology; see loop condition");
assert(res_offset >= l_offset, "just checking");
return MIN2(res_offset, r_offset);
}
}
return r_offset;
}
inline BitMap::idx_t
BitMap::get_next_zero_offset_inline(idx_t l_offset, idx_t r_offset) const {
assert(l_offset <= size(), "BitMap index out of bounds");
assert(r_offset <= size(), "BitMap index out of bounds");
assert(l_offset <= r_offset, "l_offset > r_offset ?");
if (l_offset == r_offset) {
return l_offset;
}
idx_t index = word_index(l_offset);
idx_t r_index = word_index(r_offset-1) + 1;
idx_t res_offset = l_offset;
idx_t pos = res_offset & (BitsPerWord - 1);
idx_t res = (map(index) >> pos) | left_n_bits((int)pos);
if (res != (uintptr_t)AllBits) {
for (; res & 1; res_offset++) {
res = res >> 1;
}
assert(res_offset >= l_offset, "just checking");
return MIN2(res_offset, r_offset);
}
for (index++; index < r_index; index++) {
res = map(index);
if (res != (uintptr_t)AllBits) {
for (res_offset = index << LogBitsPerWord; res & 1;
res_offset++) {
res = res >> 1;
}
assert(!(res & 1), "tautology; see loop condition");
assert(res_offset >= l_offset, "just checking");
return MIN2(res_offset, r_offset);
}
}
return r_offset;
}
inline BitMap::idx_t
BitMap::get_next_one_offset_inline_aligned_right(idx_t l_offset,
idx_t r_offset) const
{
verify_range(l_offset, r_offset);
assert(bit_in_word(r_offset) == 0, "r_offset not word-aligned");
if (l_offset == r_offset) {
return l_offset;
}
idx_t index = word_index(l_offset);
idx_t r_index = word_index(r_offset);
idx_t res_offset = l_offset;
idx_t res = map(index) >> bit_in_word(res_offset);
if (res != (uintptr_t)NoBits) {
for (; !(res & 1); res_offset++) {
res = res >> 1;
}
assert(res_offset >= l_offset &&
res_offset < r_offset, "just checking");
return res_offset;
}
for (index++; index < r_index; index++) {
res = map(index);
if (res != (uintptr_t)NoBits) {
for (res_offset = bit_index(index); !(res & 1); res_offset++) {
res = res >> 1;
}
assert(res & 1, "tautology; see loop condition");
assert(res_offset >= l_offset && res_offset < r_offset, "just checking");
return res_offset;
}
}
return r_offset;
}
inline BitMap::bm_word_t
BitMap::inverted_bit_mask_for_range(idx_t beg, idx_t end) const {
assert(end != 0, "does not work when end == 0");
assert(beg == end || word_index(beg) == word_index(end - 1),
"must be a single-word range");
bm_word_t mask = bit_mask(beg) - 1; // low (right) bits
if (bit_in_word(end) != 0) {
mask |= ~(bit_mask(end) - 1); // high (left) bits
}
return mask;
}
inline void BitMap::set_large_range_of_words(idx_t beg, idx_t end) {
assert(beg <= end, "underflow");
memset(_map + beg, ~(unsigned char)0, (end - beg) * sizeof(uintptr_t));
}
inline void BitMap::clear_large_range_of_words(idx_t beg, idx_t end) {
assert(beg <= end, "underflow");
memset(_map + beg, 0, (end - beg) * sizeof(uintptr_t));
}
inline BitMap::idx_t BitMap::word_index_round_up(idx_t bit) const {
idx_t bit_rounded_up = bit + (BitsPerWord - 1);
return bit_rounded_up > bit ? word_index(bit_rounded_up) : size_in_words();
}
inline BitMap::idx_t BitMap::get_next_one_offset(idx_t l_offset,
idx_t r_offset) const {
return get_next_one_offset_inline(l_offset, r_offset);
}
inline BitMap::idx_t BitMap::get_next_zero_offset(idx_t l_offset,
idx_t r_offset) const {
return get_next_zero_offset_inline(l_offset, r_offset);
}
inline void BitMap2D::clear() {
_map.clear();
}
#endif // SHARE_VM_UTILITIES_BITMAP_INLINE_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/chunkedList.cpp
#include "precompiled.hpp"
#include "utilities/chunkedList.hpp"
#include "utilities/debug.hpp"
#ifndef PRODUCT
template <typename T>
class TestChunkedList {
typedef ChunkedList<T, mtOther> ChunkedListT;
public:
static void testEmpty() {
ChunkedListT buffer;
assert(buffer.size() == 0, "assert");
}
static void testFull() {
ChunkedListT buffer;
for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
buffer.push((T)i);
}
assert(buffer.size() == ChunkedListT::BufferSize, "assert");
assert(buffer.is_full(), "assert");
}
static void testSize() {
ChunkedListT buffer;
for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
assert(buffer.size() == i, "assert");
buffer.push((T)i);
assert(buffer.size() == i + 1, "assert");
}
}
static void testClear() {
ChunkedListT buffer;
buffer.clear();
assert(buffer.size() == 0, "assert");
for (uintptr_t i = 0; i < ChunkedListT::BufferSize / 2; i++) {
buffer.push((T)i);
}
buffer.clear();
assert(buffer.size() == 0, "assert");
for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
buffer.push((T)i);
}
buffer.clear();
assert(buffer.size() == 0, "assert");
}
static void testAt() {
ChunkedListT buffer;
for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
buffer.push((T)i);
assert(buffer.at(i) == (T)i, "assert");
}
for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
assert(buffer.at(i) == (T)i, "assert");
}
}
static void test() {
testEmpty();
testFull();
testSize();
testClear();
testAt();
}
};
class Metadata;
void TestChunkedList_test() {
TestChunkedList<Metadata*>::test();
TestChunkedList<size_t>::test();
}
#endif
C:\hotspot-69087d08d473\src\share\vm/utilities/chunkedList.hpp
#ifndef SHARE_VM_UTILITIES_CHUNKED_LIST_HPP
#define SHARE_VM_UTILITIES_CHUNKED_LIST_HPP
#include "memory/allocation.hpp"
#include "utilities/debug.hpp"
template <class T, MEMFLAGS F> class ChunkedList : public CHeapObj<F> {
template <class U> friend class TestChunkedList;
static const size_t BufferSize = 64;
T _values[BufferSize];
T* _top;
ChunkedList<T, F>* _next_used;
ChunkedList<T, F>* _next_free;
T const * end() const {
return &_values[BufferSize];
}
public:
ChunkedList<T, F>() : _top(_values), _next_used(NULL), _next_free(NULL) {}
bool is_full() const {
return _top == end();
}
void clear() {
_top = _values;
}
void push(T m) {
assert(!is_full(), "Buffer is full");
_top++;
}
void set_next_used(ChunkedList<T, F>* buffer) { _next_used = buffer; }
void set_next_free(ChunkedList<T, F>* buffer) { _next_free = buffer; }
ChunkedList<T, F>* next_used() const { return _next_used; }
ChunkedList<T, F>* next_free() const { return _next_free; }
size_t size() const {
return pointer_delta(_top, _values, sizeof(T));
}
T at(size_t i) {
assert(i < size(), err_msg("IOOBE i: " SIZE_FORMAT " size(): " SIZE_FORMAT, i, size()));
return _values[i];
}
};
#endif // SHARE_VM_UTILITIES_CHUNKED_LIST_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/constantTag.cpp
#include "precompiled.hpp"
#include "utilities/constantTag.hpp"
#ifndef PRODUCT
void constantTag::print_on(outputStream* st) const {
st->print("%s", internal_name());
}
#endif // PRODUCT
BasicType constantTag::basic_type() const {
switch (_tag) {
case JVM_CONSTANT_Integer :
return T_INT;
case JVM_CONSTANT_Float :
return T_FLOAT;
case JVM_CONSTANT_Long :
return T_LONG;
case JVM_CONSTANT_Double :
return T_DOUBLE;
case JVM_CONSTANT_Class :
case JVM_CONSTANT_String :
case JVM_CONSTANT_UnresolvedClass :
case JVM_CONSTANT_UnresolvedClassInError :
case JVM_CONSTANT_ClassIndex :
case JVM_CONSTANT_StringIndex :
case JVM_CONSTANT_MethodHandle :
case JVM_CONSTANT_MethodHandleInError :
case JVM_CONSTANT_MethodType :
case JVM_CONSTANT_MethodTypeInError :
return T_OBJECT;
default:
ShouldNotReachHere();
return T_ILLEGAL;
}
}
jbyte constantTag::non_error_value() const {
switch (_tag) {
case JVM_CONSTANT_UnresolvedClassInError:
return JVM_CONSTANT_UnresolvedClass;
case JVM_CONSTANT_MethodHandleInError:
return JVM_CONSTANT_MethodHandle;
case JVM_CONSTANT_MethodTypeInError:
return JVM_CONSTANT_MethodType;
default:
return _tag;
}
}
jbyte constantTag::error_value() const {
switch (_tag) {
case JVM_CONSTANT_UnresolvedClass:
return JVM_CONSTANT_UnresolvedClassInError;
case JVM_CONSTANT_MethodHandle:
return JVM_CONSTANT_MethodHandleInError;
case JVM_CONSTANT_MethodType:
return JVM_CONSTANT_MethodTypeInError;
default:
ShouldNotReachHere();
return JVM_CONSTANT_Invalid;
}
}
const char* constantTag::internal_name() const {
switch (_tag) {
case JVM_CONSTANT_Invalid :
return "Invalid index";
case JVM_CONSTANT_Class :
return "Class";
case JVM_CONSTANT_Fieldref :
return "Field";
case JVM_CONSTANT_Methodref :
return "Method";
case JVM_CONSTANT_InterfaceMethodref :
return "InterfaceMethod";
case JVM_CONSTANT_String :
return "String";
case JVM_CONSTANT_Integer :
return "Integer";
case JVM_CONSTANT_Float :
return "Float";
case JVM_CONSTANT_Long :
return "Long";
case JVM_CONSTANT_Double :
return "Double";
case JVM_CONSTANT_NameAndType :
return "NameAndType";
case JVM_CONSTANT_MethodHandle :
return "MethodHandle";
case JVM_CONSTANT_MethodHandleInError :
return "MethodHandle Error";
case JVM_CONSTANT_MethodType :
return "MethodType";
case JVM_CONSTANT_MethodTypeInError :
return "MethodType Error";
case JVM_CONSTANT_InvokeDynamic :
return "InvokeDynamic";
case JVM_CONSTANT_Utf8 :
return "Utf8";
case JVM_CONSTANT_UnresolvedClass :
return "Unresolved Class";
case JVM_CONSTANT_UnresolvedClassInError :
return "Unresolved Class Error";
case JVM_CONSTANT_ClassIndex :
return "Unresolved Class Index";
case JVM_CONSTANT_StringIndex :
return "Unresolved String Index";
default:
ShouldNotReachHere();
return "Illegal";
}
}
C:\hotspot-69087d08d473\src\share\vm/utilities/constantTag.hpp
#ifndef SHARE_VM_UTILITIES_CONSTANTTAG_HPP
#define SHARE_VM_UTILITIES_CONSTANTTAG_HPP
#include "prims/jvm.h"
#include "utilities/top.hpp"
enum {
JVM_CONSTANT_Invalid = 0, // For bad value initialization
JVM_CONSTANT_InternalMin = 100, // First implementation tag (aside from bad value of course)
JVM_CONSTANT_UnresolvedClass = 100, // Temporary tag until actual use
JVM_CONSTANT_ClassIndex = 101, // Temporary tag while constructing constant pool
JVM_CONSTANT_StringIndex = 102, // Temporary tag while constructing constant pool
JVM_CONSTANT_UnresolvedClassInError = 103, // Error tag due to resolution error
JVM_CONSTANT_MethodHandleInError = 104, // Error tag due to resolution error
JVM_CONSTANT_MethodTypeInError = 105, // Error tag due to resolution error
JVM_CONSTANT_InternalMax = 105 // Last implementation tag
};
class constantTag VALUE_OBJ_CLASS_SPEC {
private:
jbyte _tag;
public:
bool is_klass() const { return _tag == JVM_CONSTANT_Class; }
bool is_field () const { return _tag == JVM_CONSTANT_Fieldref; }
bool is_method() const { return _tag == JVM_CONSTANT_Methodref; }
bool is_interface_method() const { return _tag == JVM_CONSTANT_InterfaceMethodref; }
bool is_string() const { return _tag == JVM_CONSTANT_String; }
bool is_int() const { return _tag == JVM_CONSTANT_Integer; }
bool is_float() const { return _tag == JVM_CONSTANT_Float; }
bool is_long() const { return _tag == JVM_CONSTANT_Long; }
bool is_double() const { return _tag == JVM_CONSTANT_Double; }
bool is_name_and_type() const { return _tag == JVM_CONSTANT_NameAndType; }
bool is_utf8() const { return _tag == JVM_CONSTANT_Utf8; }
bool is_invalid() const { return _tag == JVM_CONSTANT_Invalid; }
bool is_unresolved_klass() const {
return _tag == JVM_CONSTANT_UnresolvedClass || _tag == JVM_CONSTANT_UnresolvedClassInError;
}
bool is_unresolved_klass_in_error() const {
return _tag == JVM_CONSTANT_UnresolvedClassInError;
}
bool is_method_handle_in_error() const {
return _tag == JVM_CONSTANT_MethodHandleInError;
}
bool is_method_type_in_error() const {
return _tag == JVM_CONSTANT_MethodTypeInError;
}
bool is_klass_index() const { return _tag == JVM_CONSTANT_ClassIndex; }
bool is_string_index() const { return _tag == JVM_CONSTANT_StringIndex; }
bool is_klass_reference() const { return is_klass_index() || is_unresolved_klass(); }
bool is_klass_or_reference() const{ return is_klass() || is_klass_reference(); }
bool is_field_or_method() const { return is_field() || is_method() || is_interface_method(); }
bool is_symbol() const { return is_utf8(); }
bool is_method_type() const { return _tag == JVM_CONSTANT_MethodType; }
bool is_method_handle() const { return _tag == JVM_CONSTANT_MethodHandle; }
bool is_invoke_dynamic() const { return _tag == JVM_CONSTANT_InvokeDynamic; }
bool is_loadable_constant() const {
return ((_tag >= JVM_CONSTANT_Integer && _tag <= JVM_CONSTANT_String) ||
is_method_type() || is_method_handle() ||
is_unresolved_klass());
}
constantTag() {
_tag = JVM_CONSTANT_Invalid;
}
constantTag(jbyte tag) {
assert((tag >= 0 && tag <= JVM_CONSTANT_NameAndType) ||
(tag >= JVM_CONSTANT_MethodHandle && tag <= JVM_CONSTANT_InvokeDynamic) ||
(tag >= JVM_CONSTANT_InternalMin && tag <= JVM_CONSTANT_InternalMax), "Invalid constant tag");
_tag = tag;
}
jbyte value() const { return _tag; }
jbyte error_value() const;
jbyte non_error_value() const;
BasicType basic_type() const; // if used with ldc, what kind of value gets pushed?
const char* internal_name() const; // for error reporting
void print_on(outputStream* st) const PRODUCT_RETURN;
};
#endif // SHARE_VM_UTILITIES_CONSTANTTAG_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/copy.cpp
#include "precompiled.hpp"
#include "runtime/sharedRuntime.hpp"
#include "utilities/copy.hpp"
void Copy::conjoint_memory_atomic(void* from, void* to, size_t size) {
address src = (address) from;
address dst = (address) to;
uintptr_t bits = (uintptr_t) src | (uintptr_t) dst | (uintptr_t) size;
if (bits % sizeof(jlong) == 0) {
Copy::conjoint_jlongs_atomic((jlong*) src, (jlong*) dst, size / sizeof(jlong));
} else if (bits % sizeof(jint) == 0) {
Copy::conjoint_jints_atomic((jint*) src, (jint*) dst, size / sizeof(jint));
} else if (bits % sizeof(jshort) == 0) {
Copy::conjoint_jshorts_atomic((jshort*) src, (jshort*) dst, size / sizeof(jshort));
} else {
Copy::conjoint_jbytes((void*) src, (void*) dst, size);
}
}
class CopySwap : AllStatic {
public:
static void conjoint_swap(address src, address dst, size_t byte_count, size_t elem_size) {
assert(src != NULL, "address must not be NULL");
assert(dst != NULL, "address must not be NULL");
assert(elem_size == 2 || elem_size == 4 || elem_size == 8,
err_msg("incorrect element size: " SIZE_FORMAT, elem_size));
assert(is_size_aligned(byte_count, elem_size),
err_msg("byte_count " SIZE_FORMAT " must be multiple of element size " SIZE_FORMAT, byte_count, elem_size));
address src_end = src + byte_count;
if (dst <= src || dst >= src_end) {
do_conjoint_swap<RIGHT>(src, dst, byte_count, elem_size);
} else {
do_conjoint_swap<LEFT>(src, dst, byte_count, elem_size);
}
}
private:
static uint16_t byte_swap(uint16_t x) {
return (x << 8) | (x >> 8);
}
static uint32_t byte_swap(uint32_t x) {
uint16_t lo = (uint16_t)x;
uint16_t hi = (uint16_t)(x >> 16);
return ((uint32_t)byte_swap(lo) << 16) | (uint32_t)byte_swap(hi);
}
static uint64_t byte_swap(uint64_t x) {
uint32_t lo = (uint32_t)x;
uint32_t hi = (uint32_t)(x >> 32);
return ((uint64_t)byte_swap(lo) << 32) | (uint64_t)byte_swap(hi);
}
enum CopyDirection {
RIGHT, // lower -> higher address
LEFT // higher -> lower address
};
template <typename T, CopyDirection D, bool is_src_aligned, bool is_dst_aligned>
static void do_conjoint_swap(address src, address dst, size_t byte_count) {
address cur_src, cur_dst;
switch (D) {
case RIGHT:
cur_src = src;
cur_dst = dst;
break;
case LEFT:
cur_src = src + byte_count - sizeof(T);
cur_dst = dst + byte_count - sizeof(T);
break;
}
for (size_t i = 0; i < byte_count / sizeof(T); i++) {
T tmp;
if (is_src_aligned) {
tmp = *(T*)cur_src;
} else {
memcpy(&tmp, cur_src, sizeof(T));
}
tmp = byte_swap(tmp);
if (is_dst_aligned) {
} else {
memcpy(cur_dst, &tmp, sizeof(T));
}
switch (D) {
case RIGHT:
cur_src += sizeof(T);
cur_dst += sizeof(T);
break;
case LEFT:
cur_src -= sizeof(T);
cur_dst -= sizeof(T);
break;
}
}
}
template <typename T, CopyDirection direction>
static void do_conjoint_swap(address src, address dst, size_t byte_count) {
if (is_ptr_aligned(src, sizeof(T))) {
if (is_ptr_aligned(dst, sizeof(T))) {
do_conjoint_swap<T,direction,true,true>(src, dst, byte_count);
} else {
do_conjoint_swap<T,direction,true,false>(src, dst, byte_count);
}
} else {
if (is_ptr_aligned(dst, sizeof(T))) {
do_conjoint_swap<T,direction,false,true>(src, dst, byte_count);
} else {
do_conjoint_swap<T,direction,false,false>(src, dst, byte_count);
}
}
}
template <CopyDirection D>
static void do_conjoint_swap(address src, address dst, size_t byte_count, size_t elem_size) {
switch (elem_size) {
case 2: do_conjoint_swap<uint16_t,D>(src, dst, byte_count); break;
case 4: do_conjoint_swap<uint32_t,D>(src, dst, byte_count); break;
case 8: do_conjoint_swap<uint64_t,D>(src, dst, byte_count); break;
default: guarantee(false, err_msg("do_conjoint_swap: Invalid elem_size %zd\n", elem_size));
}
}
};
void Copy::conjoint_swap(address src, address dst, size_t byte_count, size_t elem_size) {
CopySwap::conjoint_swap(src, dst, byte_count, elem_size);
}
void Copy::fill_to_memory_atomic(void* to, size_t size, jubyte value) {
address dst = (address) to;
uintptr_t bits = (uintptr_t) to | (uintptr_t) size;
if (bits % sizeof(jlong) == 0) {
jlong fill = (julong)( (jubyte)value ); // zero-extend
if (fill != 0) {
fill += fill << 8;
fill += fill << 16;
fill += fill << 32;
}
for (uintptr_t off = 0; off < size; off += sizeof(jlong)) {
}
} else if (bits % sizeof(jint) == 0) {
jint fill = (juint)( (jubyte)value ); // zero-extend
if (fill != 0) {
fill += fill << 8;
fill += fill << 16;
}
for (uintptr_t off = 0; off < size; off += sizeof(jint)) {
}
} else if (bits % sizeof(jshort) == 0) {
jshort fill = (jushort)( (jubyte)value ); // zero-extend
fill += fill << 8;
for (uintptr_t off = 0; off < size; off += sizeof(jshort)) {
}
} else {
Copy::fill_to_bytes(dst, size, value);
}
}
C:\hotspot-69087d08d473\src\share\vm/utilities/copy.hpp
#ifndef SHARE_VM_UTILITIES_COPY_HPP
#define SHARE_VM_UTILITIES_COPY_HPP
#include "runtime/stubRoutines.hpp"
extern "C" {
void _Copy_conjoint_words(HeapWord* from, HeapWord* to, size_t count);
void _Copy_disjoint_words(HeapWord* from, HeapWord* to, size_t count);
void _Copy_conjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count);
void _Copy_disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count);
void _Copy_aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count);
void _Copy_aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count);
void _Copy_conjoint_bytes(void* from, void* to, size_t count);
void _Copy_conjoint_bytes_atomic (void* from, void* to, size_t count);
void _Copy_conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count);
void _Copy_conjoint_jints_atomic (jint* from, jint* to, size_t count);
void _Copy_conjoint_jlongs_atomic (jlong* from, jlong* to, size_t count);
void _Copy_conjoint_oops_atomic (oop* from, oop* to, size_t count);
void _Copy_arrayof_conjoint_bytes (HeapWord* from, HeapWord* to, size_t count);
void _Copy_arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count);
void _Copy_arrayof_conjoint_jints (HeapWord* from, HeapWord* to, size_t count);
void _Copy_arrayof_conjoint_jlongs (HeapWord* from, HeapWord* to, size_t count);
void _Copy_arrayof_conjoint_oops (HeapWord* from, HeapWord* to, size_t count);
}
class Copy : AllStatic {
public:
static void conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
assert_params_ok(from, to, LogHeapWordSize);
pd_conjoint_words(from, to, count);
}
static void disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
assert_params_ok(from, to, LogHeapWordSize);
assert_disjoint(from, to, count);
pd_disjoint_words(from, to, count);
}
static void disjoint_words_atomic(HeapWord* from, HeapWord* to, size_t count) {
assert_params_ok(from, to, LogHeapWordSize);
assert_disjoint(from, to, count);
pd_disjoint_words_atomic(from, to, count);
}
static void aligned_conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
assert_params_aligned(from, to);
pd_aligned_conjoint_words(from, to, count);
}
static void aligned_disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
assert_params_aligned(from, to);
assert_disjoint(from, to, count);
pd_aligned_disjoint_words(from, to, count);
}
static void conjoint_jbytes(void* from, void* to, size_t count) {
pd_conjoint_bytes(from, to, count);
}
static void conjoint_jbytes_atomic(void* from, void* to, size_t count) {
pd_conjoint_bytes(from, to, count);
}
static void conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) {
assert_params_ok(from, to, LogBytesPerShort);
pd_conjoint_jshorts_atomic(from, to, count);
}
static void conjoint_jints_atomic(jint* from, jint* to, size_t count) {
assert_params_ok(from, to, LogBytesPerInt);
pd_conjoint_jints_atomic(from, to, count);
}
static void conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) {
assert_params_ok(from, to, LogBytesPerLong);
pd_conjoint_jlongs_atomic(from, to, count);
}
static void conjoint_oops_atomic(oop* from, oop* to, size_t count) {
assert_params_ok(from, to, LogBytesPerHeapOop);
pd_conjoint_oops_atomic(from, to, count);
}
static void conjoint_oops_atomic(narrowOop* from, narrowOop* to, size_t count) {
assert(sizeof(narrowOop) == sizeof(jint), "this cast is wrong");
assert_params_ok(from, to, LogBytesPerInt);
pd_conjoint_jints_atomic((jint*)from, (jint*)to, count);
}
static void conjoint_memory_atomic(void* from, void* to, size_t size);
static void arrayof_conjoint_jbytes(HeapWord* from, HeapWord* to, size_t count) {
pd_arrayof_conjoint_bytes(from, to, count);
}
static void arrayof_conjoint_jshorts(HeapWord* from, HeapWord* to, size_t count) {
assert_params_ok(from, to, LogBytesPerShort);
pd_arrayof_conjoint_jshorts(from, to, count);
}
static void arrayof_conjoint_jints(HeapWord* from, HeapWord* to, size_t count) {
assert_params_ok(from, to, LogBytesPerInt);
pd_arrayof_conjoint_jints(from, to, count);
}
static void arrayof_conjoint_jlongs(HeapWord* from, HeapWord* to, size_t count) {
assert_params_ok(from, to, LogBytesPerLong);
pd_arrayof_conjoint_jlongs(from, to, count);
}
static void arrayof_conjoint_oops(HeapWord* from, HeapWord* to, size_t count) {
assert_params_ok(from, to, LogBytesPerHeapOop);
pd_arrayof_conjoint_oops(from, to, count);
}
inline static void conjoint_words_to_lower(HeapWord* from, HeapWord* to, size_t byte_count) {
assert_params_ok(from, to, LogHeapWordSize);
assert_byte_count_ok(byte_count, HeapWordSize);
size_t count = (size_t)round_to(byte_count, HeapWordSize) >> LogHeapWordSize;
assert(to <= from || from + count <= to, "do not overwrite source data");
while (count-- > 0) {
}
}
inline static void conjoint_words_to_higher(HeapWord* from, HeapWord* to, size_t byte_count) {
assert_params_ok(from, to, LogHeapWordSize);
assert_byte_count_ok(byte_count, HeapWordSize);
size_t count = (size_t)round_to(byte_count, HeapWordSize) >> LogHeapWordSize;
assert(from <= to || to + count <= from, "do not overwrite source data");
from += count - 1;
to += count - 1;
while (count-- > 0) {
}
}
static void conjoint_swap(address src, address dst, size_t byte_count, size_t elem_size);
static void fill_to_words(HeapWord* to, size_t count, juint value = 0) {
assert_params_ok(to, LogHeapWordSize);
pd_fill_to_words(to, count, value);
}
static void fill_to_aligned_words(HeapWord* to, size_t count, juint value = 0) {
assert_params_aligned(to);
pd_fill_to_aligned_words(to, count, value);
}
static void fill_to_bytes(void* to, size_t count, jubyte value = 0) {
pd_fill_to_bytes(to, count, value);
}
static void fill_to_memory_atomic(void* to, size_t size, jubyte value = 0);
static void zero_to_words(HeapWord* to, size_t count) {
assert_params_ok(to, LogHeapWordSize);
pd_zero_to_words(to, count);
}
static void zero_to_bytes(void* to, size_t count) {
pd_zero_to_bytes(to, count);
}
private:
static bool params_disjoint(HeapWord* from, HeapWord* to, size_t count) {
if (from < to) {
return pointer_delta(to, from) >= count;
}
return pointer_delta(from, to) >= count;
}
static void assert_disjoint(HeapWord* from, HeapWord* to, size_t count) {
#ifdef ASSERT
if (!params_disjoint(from, to, count))
basic_fatal("source and dest overlap");
#endif
}
static void assert_params_ok(void* from, void* to, intptr_t log_align) {
#ifdef ASSERT
if (mask_bits((uintptr_t)from, right_n_bits(log_align)) != 0)
basic_fatal("not aligned");
if (mask_bits((uintptr_t)to, right_n_bits(log_align)) != 0)
basic_fatal("not aligned");
#endif
}
static void assert_params_ok(HeapWord* to, intptr_t log_align) {
#ifdef ASSERT
if (mask_bits((uintptr_t)to, right_n_bits(log_align)) != 0)
basic_fatal("not word aligned");
#endif
}
static void assert_params_aligned(HeapWord* from, HeapWord* to) {
#ifdef ASSERT
if (mask_bits((uintptr_t)from, BytesPerLong-1) != 0)
basic_fatal("not long aligned");
if (mask_bits((uintptr_t)to, BytesPerLong-1) != 0)
basic_fatal("not long aligned");
#endif
}
static void assert_params_aligned(HeapWord* to) {
#ifdef ASSERT
if (mask_bits((uintptr_t)to, BytesPerLong-1) != 0)
basic_fatal("not long aligned");
#endif
}
static void assert_byte_count_ok(size_t byte_count, size_t unit_size) {
#ifdef ASSERT
if ((size_t)round_to(byte_count, unit_size) != byte_count) {
basic_fatal("byte count must be aligned");
}
#endif
}
#ifdef TARGET_ARCH_x86
# include "copy_x86.hpp"
#endif
#ifdef TARGET_ARCH_aarch64
# include "copy_aarch64.hpp"
#endif
#ifdef TARGET_ARCH_sparc
# include "copy_sparc.hpp"
#endif
#ifdef TARGET_ARCH_zero
# include "copy_zero.hpp"
#endif
#ifdef TARGET_ARCH_arm
# include "copy_arm.hpp"
#endif
#ifdef TARGET_ARCH_ppc
# include "copy_ppc.hpp"
#endif
};
#endif // SHARE_VM_UTILITIES_COPY_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/debug.cpp
#include "precompiled.hpp"
#include "classfile/systemDictionary.hpp"
#include "code/codeCache.hpp"
#include "code/icBuffer.hpp"
#include "code/nmethod.hpp"
#include "code/vtableStubs.hpp"
#include "compiler/compileBroker.hpp"
#include "compiler/disassembler.hpp"
#include "gc_implementation/shared/markSweep.hpp"
#include "gc_interface/collectedHeap.hpp"
#include "interpreter/bytecodeHistogram.hpp"
#include "interpreter/interpreter.hpp"
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
#include "oops/oop.inline.hpp"
#include "prims/privilegedStack.hpp"
#include "runtime/arguments.hpp"
#include "runtime/frame.hpp"
#include "runtime/java.hpp"
#include "runtime/sharedRuntime.hpp"
#include "runtime/stubCodeGenerator.hpp"
#include "runtime/stubRoutines.hpp"
#include "runtime/thread.inline.hpp"
#include "runtime/vframe.hpp"
#include "services/heapDumper.hpp"
#include "utilities/defaultStream.hpp"
#include "utilities/events.hpp"
#include "utilities/top.hpp"
#include "utilities/vmError.hpp"
#ifdef TARGET_OS_FAMILY_linux
# include "os_linux.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_solaris
# include "os_solaris.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_windows
# include "os_windows.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_bsd
# include "os_bsd.inline.hpp"
#endif
#ifndef ASSERT
# ifdef _DEBUG
ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging
functions that do not slow down the system too much and thus can be left in optimized code.
On the other hand, the code should not be included in a production version.
# endif // _DEBUG
#endif // ASSERT
#ifdef _DEBUG
# ifndef ASSERT
configuration error: ASSERT must be defined in debug version
# endif // ASSERT
#endif // _DEBUG
#ifdef PRODUCT
# if -defined _DEBUG || -defined ASSERT
configuration error: ASSERT et al. must not be defined in PRODUCT version
# endif
#endif // PRODUCT
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
FormatBufferResource::FormatBufferResource(const char * format, ...)
: FormatBufferBase((char*)resource_allocate_bytes(RES_BUFSZ)) {
va_list argp;
va_start(argp, format);
jio_vsnprintf(_buf, RES_BUFSZ, format, argp);
va_end(argp);
}
ATTRIBUTE_PRINTF(1, 2)
void warning(const char* format, ...) {
if (PrintWarnings) {
FILE* const err = defaultStream::error_stream();
jio_fprintf(err, "%s warning: ", VM_Version::vm_name());
va_list ap;
va_start(ap, format);
vfprintf(err, format, ap);
va_end(ap);
fputc('\n', err);
}
if (BreakAtWarning) BREAKPOINT;
}
#ifndef PRODUCT
#define is_token_break(ch) (isspace(ch) || (ch) == ',')
static const char* last_file_name = NULL;
static int last_line_no = -1;
bool error_is_suppressed(const char* file_name, int line_no) {
if (file_name == last_file_name && line_no == last_line_no) return true;
int file_name_len = (int)strlen(file_name);
char separator = os::file_separator()[0];
const char* base_name = strrchr(file_name, separator);
if (base_name == NULL)
base_name = file_name;
const char* cp = SuppressErrorAt;
for (;;) {
const char* sfile;
int sfile_len;
int sline;
bool noisy;
while ((*cp) != '\0' && is_token_break(*cp)) cp++;
if ((*cp) == '\0') break;
sfile = cp;
while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++;
sfile_len = cp - sfile;
if ((*cp) == ':') cp++;
sline = 0;
while ((*cp) != '\0' && isdigit(*cp)) {
sline *= 10;
sline += (*cp) - '0';
cp++;
}
noisy = ((*cp) == '!');
while ((*cp) != '\0' && !is_token_break(*cp)) cp++;
if (sline != 0) {
if (sline != line_no) continue;
}
if (sfile_len > 0) {
const char* look = file_name;
const char* look_max = file_name + file_name_len - sfile_len;
const char* foundp;
bool match = false;
while (!match
&& (foundp = strchr(look, sfile[0])) != NULL
&& foundp <= look_max) {
match = true;
for (int i = 1; i < sfile_len; i++) {
if (sfile[i] != foundp[i]) {
match = false;
break;
}
}
look = foundp + 1;
}
if (!match) continue;
}
if (noisy) {
fdStream out(defaultStream::output_fd());
out.print_raw("[error suppressed at ");
out.print_raw(base_name);
char buf[16];
jio_snprintf(buf, sizeof(buf), ":%d]", line_no);
out.print_raw_cr(buf);
} else {
last_file_name = file_name;
last_line_no = line_no;
}
return true;
}
if (!is_error_reported()) {
fdStream out(defaultStream::output_fd());
out.print_raw_cr("# To suppress the following error report, specify this argument");
out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt=");
out.print_raw (base_name);
char buf[16];
jio_snprintf(buf, sizeof(buf), ":%d", line_no);
out.print_raw_cr(buf);
}
return false;
}
#undef is_token_break
#else
#define error_is_suppressed(file_name, line_no) (false)
#endif // !PRODUCT
void report_vm_error(const char* file, int line, const char* error_msg,
const char* detail_msg)
{
if (Debugging || error_is_suppressed(file, line)) return;
Thread* const thread = ThreadLocalStorage::get_thread_slow();
VMError err(thread, file, line, error_msg, detail_msg);
err.report_and_die();
}
void report_fatal(const char* file, int line, const char* message)
{
report_vm_error(file, line, "fatal error", message);
}
void report_vm_out_of_memory(const char* file, int line, size_t size,
VMErrorType vm_err_type, const char* message) {
if (Debugging) return;
Thread* thread = ThreadLocalStorage::get_thread_slow();
VMError(thread, file, line, size, vm_err_type, message).report_and_die();
guarantee(false, "report_and_die() should not return here");
}
void report_should_not_call(const char* file, int line) {
report_vm_error(file, line, "ShouldNotCall()");
}
void report_should_not_reach_here(const char* file, int line) {
report_vm_error(file, line, "ShouldNotReachHere()");
}
void report_unimplemented(const char* file, int line) {
report_vm_error(file, line, "Unimplemented()");
}
void report_untested(const char* file, int line, const char* message) {
#ifndef PRODUCT
warning("Untested: %s in %s: %d\n", message, file, line);
#endif // !PRODUCT
}
void report_out_of_shared_space(SharedSpaceType shared_space) {
static const char* name[] = {
"native memory for metadata",
"shared read only space",
"shared read write space",
"shared miscellaneous data space",
"shared miscellaneous code space"
};
static const char* flag[] = {
"Metaspace",
"SharedReadOnlySize",
"SharedReadWriteSize",
"SharedMiscDataSize",
"SharedMiscCodeSize"
};
warning("\nThe %s is not large enough\n"
"to preload requested classes. Use -XX:%s=<size>\n"
"to increase the initial size of %s.\n",
name[shared_space], flag[shared_space], name[shared_space]);
exit(2);
}
void report_java_out_of_memory(const char* message) {
static jint out_of_memory_reported = 0;
if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) {
if (HeapDumpOnOutOfMemoryError) {
tty->print_cr("java.lang.OutOfMemoryError: %s", message);
HeapDumper::dump_heap_from_oome();
}
if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
VMError err(message);
err.report_java_out_of_memory();
}
if (CrashOnOutOfMemoryError) {
tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message);
fatal(err_msg("OutOfMemory encountered: %s", message));
}
if (ExitOnOutOfMemoryError) {
tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message);
exit(3);
}
}
}
void report_insufficient_metaspace(size_t required_size) {
warning("\nThe MaxMetaspaceSize of " SIZE_FORMAT " bytes is not large enough.\n"
"Either don't specify the -XX:MaxMetaspaceSize=<size>\n"
"or increase the size to at least " SIZE_FORMAT ".\n",
MaxMetaspaceSize, required_size);
exit(2);
}
static bool error_reported = false;
void set_error_reported() {
error_reported = true;
}
bool is_error_reported() {
return error_reported;
}
#ifndef PRODUCT
#include <signal.h>
void test_error_handler() {
uintx test_num = ErrorHandlerTest;
if (test_num == 0) return;
size_t n = test_num;
NOT_DEBUG(if (n <= 2) n += 2);
const char* const str = "hello";
const size_t num = (size_t)os::vm_page_size();
const char* const eol = os::line_separator();
const char* const msg = "this message should be truncated during formatting";
char * const dataPtr = NULL; // bad data pointer
const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer
switch (n) {
case 1: assert(str == NULL, "expected null");
case 2: assert(num == 1023 && *str == 'X',
err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 3: guarantee(str == NULL, "expected null");
case 4: guarantee(num == 1023 && *str == 'X',
err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 5: fatal("expected null");
case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# "
"%s%s# %s%s# %s%s# %s%s# %s%s# "
"%s%s# %s%s# %s%s# %s%s# %s",
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
msg, eol, msg, eol, msg, eol, msg, eol, msg));
case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate");
case 9: ShouldNotCallThis();
case 10: ShouldNotReachHere();
case 11: Unimplemented();
case 12: *dataPtr = '\0'; break;
case 13: (*funcPtr)(); break;
default: tty->print_cr("ERROR: %d: unexpected test_num value.", n);
}
ShouldNotReachHere();
}
#endif // !PRODUCT
class Command : public StackObj {
private:
ResourceMark rm;
ResetNoHandleMark rnhm;
HandleMark hm;
bool debug_save;
public:
static int level;
Command(const char* str) {
debug_save = Debugging;
Debugging = true;
if (level++ > 0) return;
tty->cr();
tty->print_cr("\"Executing %s\"", str);
}
~Command() {
tty->flush();
Debugging = debug_save;
level--;
}
};
int Command::level = 0;
#ifndef PRODUCT
extern "C" void blob(CodeBlob* cb) {
Command c("blob");
cb->print();
}
extern "C" void dump_vtable(address p) {
Command c("dump_vtable");
Klass* k = (Klass*)p;
InstanceKlass::cast(k)->vtable()->print();
}
extern "C" void nm(intptr_t p) {
Command c("nm");
CodeBlob* cb = CodeCache::find_blob((address)p);
if (cb == NULL) {
tty->print_cr("NULL");
} else {
cb->print();
}
}
extern "C" void disnm(intptr_t p) {
Command c("disnm");
CodeBlob* cb = CodeCache::find_blob((address) p);
if (cb != NULL) {
nmethod* nm = cb->as_nmethod_or_null();
if (nm != NULL) {
nm->print();
} else {
cb->print();
}
Disassembler::decode(cb);
}
}
extern "C" void printnm(intptr_t p) {
char buffer[256];
sprintf(buffer, "printnm: " INTPTR_FORMAT, p);
Command c(buffer);
CodeBlob* cb = CodeCache::find_blob((address) p);
if (cb->is_nmethod()) {
nmethod* nm = (nmethod*)cb;
nm->print_nmethod(true);
}
}
extern "C" void universe() {
Command c("universe");
Universe::print();
}
extern "C" void verify() {
Command c("universe verify");
bool safe = SafepointSynchronize::is_at_safepoint();
if (!safe) {
tty->print_cr("warning: not at safepoint -- verify may fail");
SafepointSynchronize::set_is_at_safepoint();
}
Universe::heap()->prepare_for_verify();
Universe::verify();
if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
}
extern "C" void pp(void* p) {
Command c("pp");
FlagSetting fl(PrintVMMessages, true);
FlagSetting f2(DisplayVMOutput, true);
if (Universe::heap()->is_in(p)) {
oop obj = oop(p);
obj->print();
} else {
tty->print(PTR_FORMAT, p);
}
}
extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); }
extern "C" void findpc(intptr_t x);
#endif // !PRODUCT
extern "C" void ps() { // print stack
if (Thread::current() == NULL) return;
Command c("ps");
JavaThread* p = JavaThread::active();
tty->print(" for thread: ");
p->print();
tty->cr();
if (p->has_last_Java_frame()) {
#ifdef PRODUCT
p->print_stack();
} else {
tty->print_cr("Cannot find the last Java frame, printing stack disabled.");
#else // !PRODUCT
p->trace_stack();
} else {
frame f = os::current_frame();
RegisterMap reg_map(p);
f = f.sender(®_map);
tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id());
p->trace_stack_from(vframe::new_vframe(&f, ®_map, p));
pd_ps(f);
#endif // PRODUCT
}
}
extern "C" void pfl() {
Command c("pfl");
JavaThread* p = JavaThread::active();
tty->print(" for thread: ");
p->print();
tty->cr();
if (p->has_last_Java_frame()) {
p->print_frame_layout();
}
}
#ifndef PRODUCT
extern "C" void psf() { // print stack frames
{
Command c("psf");
JavaThread* p = JavaThread::active();
tty->print(" for thread: ");
p->print();
tty->cr();
if (p->has_last_Java_frame()) {
p->trace_frames();
}
}
}
extern "C" void threads() {
Command c("threads");
Threads::print(false, true);
}
extern "C" void psd() {
Command c("psd");
SystemDictionary::print();
}
extern "C" void safepoints() {
Command c("safepoints");
SafepointSynchronize::print_state();
}
#endif // !PRODUCT
extern "C" void pss() { // print all stacks
if (Thread::current() == NULL) return;
Command c("pss");
Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true));
}
#ifndef PRODUCT
extern "C" void debug() { // to set things up for compiler debugging
Command c("debug");
WizardMode = true;
PrintVMMessages = PrintCompilation = true;
PrintInlining = PrintAssembly = true;
tty->flush();
}
extern "C" void ndebug() { // undo debug()
Command c("ndebug");
PrintCompilation = false;
PrintInlining = PrintAssembly = false;
tty->flush();
}
extern "C" void flush() {
Command c("flush");
tty->flush();
}
extern "C" void events() {
Command c("events");
Events::print();
}
extern "C" Method* findm(intptr_t pc) {
Command c("findm");
nmethod* nm = CodeCache::find_nmethod((address)pc);
return (nm == NULL) ? (Method*)NULL : nm->method();
}
extern "C" nmethod* findnm(intptr_t addr) {
Command c("findnm");
return CodeCache::find_nmethod((address)addr);
}
extern "C" void hsfind(intptr_t x) {
Command c("hsfind");
os::print_location(tty, x, false);
}
extern "C" void find(intptr_t x) {
Command c("find");
os::print_location(tty, x, false);
}
extern "C" void findpc(intptr_t x) {
Command c("findpc");
os::print_location(tty, x, true);
}
extern "C" void findbcp(intptr_t method, intptr_t bcp) {
Command c("findbcp");
Method* mh = (Method*)method;
if (!mh->is_native()) {
tty->print_cr("bci_from(%p) = %d; print_codes():",
mh, mh->bci_from(address(bcp)));
mh->print_codes_on(tty);
}
}
void pp(intptr_t p) { pp((void*)p); }
void pp(oop p) { pp((void*)p); }
void help() {
Command c("help");
tty->print_cr("basic");
tty->print_cr(" pp(void* p) - try to make sense of p");
tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()");
tty->print_cr(" ps() - print current thread stack");
tty->print_cr(" pss() - print all thread stacks");
tty->print_cr(" pm(int pc) - print Method* given compiled PC");
tty->print_cr(" findm(intptr_t pc) - finds Method*");
tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g.");
tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or");
tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or");
tty->print_cr(" pns($sp, $fp, $pc) on Linux/AArch64 or");
tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or");
tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC");
tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()");
tty->print_cr(" - in dbx do 'frame 1' before calling pns()");
tty->print_cr("misc.");
tty->print_cr(" flush() - flushes the log file");
tty->print_cr(" events() - dump events from ring buffers");
tty->print_cr("compiler debugging");
tty->print_cr(" debug() - to set things up for compiler debugging");
tty->print_cr(" ndebug() - undo debug");
}
#endif // !PRODUCT
void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) {
if (fr.pc()) {
st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
int count = 0;
while (count++ < StackPrintLimit) {
fr.print_on_error(st, buf, buf_size);
st->cr();
if (t && t->is_Java_thread()) {
if (!t->on_local_stack((address)(fr.real_fp() + 1))) {
break;
}
if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) {
RegisterMap map((JavaThread*)t, false); // No update
fr = fr.sender(&map);
} else {
fr = os::get_sender_for_C_frame(&fr);
}
} else {
if (os::is_first_C_frame(&fr)) break;
fr = os::get_sender_for_C_frame(&fr);
}
}
if (count > StackPrintLimit) {
st->print_cr("...<more frames>...");
}
st->cr();
}
}
#ifndef PRODUCT
extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack
Command c("pns");
static char buf[O_BUFLEN];
Thread* t = ThreadLocalStorage::get_thread_slow();
frame fr(sp, fp, pc);
print_native_stack(tty, fr, t, buf, sizeof(buf));
}
#endif // !PRODUCT
C:\hotspot-69087d08d473\src\share\vm/utilities/debug.hpp
#ifndef SHARE_VM_UTILITIES_DEBUG_HPP
#define SHARE_VM_UTILITIES_DEBUG_HPP
#include "utilities/globalDefinitions.hpp"
#include "prims/jvm.h"
#include <stdarg.h>
class FormatBufferBase {
protected:
char* _buf;
inline FormatBufferBase(char* buf) : _buf(buf) {}
public:
operator const char *() const { return _buf; }
};
#define RES_BUFSZ 256
class FormatBufferResource : public FormatBufferBase {
public:
FormatBufferResource(const char * format, ...) ATTRIBUTE_PRINTF(2, 3);
};
template <size_t bufsz = 256>
class FormatBuffer : public FormatBufferBase {
public:
inline FormatBuffer(const char * format, ...) ATTRIBUTE_PRINTF(2, 3);
inline void append(const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
inline void print(const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
inline void printv(const char* format, va_list ap) ATTRIBUTE_PRINTF(2, 0);
char* buffer() { return _buf; }
int size() { return bufsz; }
private:
FormatBuffer(const FormatBuffer &); // prevent copies
char _buffer[bufsz];
protected:
inline FormatBuffer();
};
template <size_t bufsz>
FormatBuffer<bufsz>::FormatBuffer(const char * format, ...) : FormatBufferBase(_buffer) {
va_list argp;
va_start(argp, format);
jio_vsnprintf(_buf, bufsz, format, argp);
va_end(argp);
}
template <size_t bufsz>
FormatBuffer<bufsz>::FormatBuffer() : FormatBufferBase(_buffer) {
_buf[0] = '\0';
}
template <size_t bufsz>
void FormatBuffer<bufsz>::print(const char * format, ...) {
va_list argp;
va_start(argp, format);
jio_vsnprintf(_buf, bufsz, format, argp);
va_end(argp);
}
template <size_t bufsz>
void FormatBuffer<bufsz>::printv(const char * format, va_list argp) {
jio_vsnprintf(_buf, bufsz, format, argp);
}
template <size_t bufsz>
void FormatBuffer<bufsz>::append(const char* format, ...) {
size_t len = strlen(_buf);
char* buf_end = _buf + len;
va_list argp;
va_start(argp, format);
jio_vsnprintf(buf_end, bufsz - len, format, argp);
va_end(argp);
}
typedef FormatBuffer<> err_msg;
typedef FormatBufferResource err_msg_res;
#ifdef ASSERT
#ifndef USE_REPEATED_ASSERTS
#define assert(p, msg) \
do { \
if (!(p)) { \
report_vm_error(__FILE__, __LINE__, "assert(" #p ") failed", msg); \
BREAKPOINT; \
} \
} while (0)
#else // #ifndef USE_REPEATED_ASSERTS
#define assert(p, msg)
do { \
for (int __i = 0; __i < AssertRepeat; __i++) { \
if (!(p)) { \
report_vm_error(__FILE__, __LINE__, "assert(" #p ") failed", msg); \
BREAKPOINT; \
} \
} \
} while (0)
#endif // #ifndef USE_REPEATED_ASSERTS
#define assert_status(p, status, msg) \
do { \
if (!(p)) { \
report_vm_error(__FILE__, __LINE__, "assert(" #p ") failed", \
err_msg("error %s(%d) %s", strerror(status), \
status, msg)); \
BREAKPOINT; \
} \
} while (0)
#define assert_if_no_error(cond,msg) assert((cond) || is_error_reported(), msg)
#else // #ifdef ASSERT
#define assert(p,msg)
#define assert_status(p,status,msg)
#define assert_if_no_error(cond,msg)
#endif // #ifdef ASSERT
#define precond(p) assert(p, "precond")
#define postcond(p) assert(p, "postcond")
#define guarantee(p, msg) \
do { \
if (!(p)) { \
report_vm_error(__FILE__, __LINE__, "guarantee(" #p ") failed", msg); \
BREAKPOINT; \
} \
} while (0)
#define fatal(msg) \
do { \
report_fatal(__FILE__, __LINE__, msg); \
BREAKPOINT; \
} while (0)
#define vm_exit_out_of_memory(size, vm_err_type, msg) \
do { \
report_vm_out_of_memory(__FILE__, __LINE__, size, vm_err_type, msg); \
BREAKPOINT; \
} while (0)
#define ShouldNotCallThis() \
do { \
report_should_not_call(__FILE__, __LINE__); \
BREAKPOINT; \
} while (0)
#define ShouldNotReachHere() \
do { \
report_should_not_reach_here(__FILE__, __LINE__); \
BREAKPOINT; \
} while (0)
#define Unimplemented() \
do { \
report_unimplemented(__FILE__, __LINE__); \
BREAKPOINT; \
} while (0)
#define Untested(msg) \
do { \
report_untested(__FILE__, __LINE__, msg); \
BREAKPOINT; \
} while (0);
enum VMErrorType {
INTERNAL_ERROR = 0xe0000000,
OOM_MALLOC_ERROR = 0xe0000001,
OOM_MMAP_ERROR = 0xe0000002
};
void report_vm_error(const char* file, int line, const char* error_msg,
const char* detail_msg = NULL);
void report_fatal(const char* file, int line, const char* message);
void report_vm_out_of_memory(const char* file, int line, size_t size,
VMErrorType vm_err_type, const char* message);
void report_should_not_call(const char* file, int line);
void report_should_not_reach_here(const char* file, int line);
void report_unimplemented(const char* file, int line);
void report_untested(const char* file, int line, const char* message);
void report_insufficient_metaspace(size_t required_size);
void warning(const char* format, ...) ATTRIBUTE_PRINTF(1, 2);
#ifdef ASSERT
template <bool> struct StaticAssert;
template <> struct StaticAssert<true> {};
#define STATIC_ASSERT(cond) \
do { \
StaticAssert<(cond)> DUMMY_STATIC_ASSERT; \
(void)DUMMY_STATIC_ASSERT; /* ignore */ \
} while (false)
#else
#define STATIC_ASSERT(cond)
#endif
enum SharedSpaceType {
SharedPermGen,
SharedReadOnly,
SharedReadWrite,
SharedMiscData,
SharedMiscCode
};
void report_out_of_shared_space(SharedSpaceType space_type);
void report_java_out_of_memory(const char* message);
bool is_error_reported();
void set_error_reported();
NOT_PRODUCT(void test_error_handler();)
void pd_ps(frame f);
void pd_obfuscate_location(char *buf, size_t buflen);
class outputStream;
void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size);
#endif // SHARE_VM_UTILITIES_DEBUG_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/decoder.cpp
#include "precompiled.hpp"
#include "prims/jvm.h"
#include "runtime/os.hpp"
#include "utilities/decoder.hpp"
#include "utilities/vmError.hpp"
#if defined(_WINDOWS)
#include "decoder_windows.hpp"
#elif defined(__APPLE__)
#include "decoder_machO.hpp"
#elif defined(AIX)
#include "decoder_aix.hpp"
#else
#include "decoder_elf.hpp"
#endif
AbstractDecoder* Decoder::_shared_decoder = NULL;
AbstractDecoder* Decoder::_error_handler_decoder = NULL;
NullDecoder Decoder::_do_nothing_decoder;
Mutex* Decoder::_shared_decoder_lock = new Mutex(Mutex::native,
"SharedDecoderLock");
AbstractDecoder* Decoder::get_shared_instance() {
assert(_shared_decoder_lock != NULL && _shared_decoder_lock->owned_by_self(),
"Require DecoderLock to enter");
if (_shared_decoder == NULL) {
_shared_decoder = create_decoder();
}
return _shared_decoder;
}
AbstractDecoder* Decoder::get_error_handler_instance() {
if (_error_handler_decoder == NULL) {
_error_handler_decoder = create_decoder();
}
return _error_handler_decoder;
}
AbstractDecoder* Decoder::create_decoder() {
AbstractDecoder* decoder;
#if defined(_WINDOWS)
decoder = new (std::nothrow) WindowsDecoder();
#elif defined (__APPLE__)
decoder = new (std::nothrow)MachODecoder();
#elif defined(AIX)
decoder = new (std::nothrow)AIXDecoder();
#else
decoder = new (std::nothrow)ElfDecoder();
#endif
if (decoder == NULL || decoder->has_error()) {
if (decoder != NULL) {
delete decoder;
}
decoder = &_do_nothing_decoder;
}
return decoder;
}
inline bool DecoderLocker::is_first_error_thread() {
return (os::current_thread_id() == VMError::get_first_error_tid());
}
DecoderLocker::DecoderLocker() :
MutexLockerEx(DecoderLocker::is_first_error_thread() ?
NULL : Decoder::shared_decoder_lock(), true) {
_decoder = is_first_error_thread() ?
Decoder::get_error_handler_instance() : Decoder::get_shared_instance();
assert(_decoder != NULL, "null decoder");
}
Mutex* Decoder::shared_decoder_lock() {
assert(_shared_decoder_lock != NULL, "Just check");
return _shared_decoder_lock;
}
bool Decoder::decode(address addr, char* buf, int buflen, int* offset, const char* modulepath) {
assert(_shared_decoder_lock != NULL, "Just check");
bool error_handling_thread = os::current_thread_id() == VMError::first_error_tid;
MutexLockerEx locker(error_handling_thread ? NULL : _shared_decoder_lock, true);
AbstractDecoder* decoder = error_handling_thread ?
get_error_handler_instance(): get_shared_instance();
assert(decoder != NULL, "null decoder");
return decoder->decode(addr, buf, buflen, offset, modulepath);
}
bool Decoder::decode(address addr, char* buf, int buflen, int* offset, const void* base) {
assert(_shared_decoder_lock != NULL, "Just check");
bool error_handling_thread = os::current_thread_id() == VMError::first_error_tid;
MutexLockerEx locker(error_handling_thread ? NULL : _shared_decoder_lock, true);
AbstractDecoder* decoder = error_handling_thread ?
get_error_handler_instance(): get_shared_instance();
assert(decoder != NULL, "null decoder");
return decoder->decode(addr, buf, buflen, offset, base);
}
bool Decoder::demangle(const char* symbol, char* buf, int buflen) {
assert(_shared_decoder_lock != NULL, "Just check");
bool error_handling_thread = os::current_thread_id() == VMError::first_error_tid;
MutexLockerEx locker(error_handling_thread ? NULL : _shared_decoder_lock, true);
AbstractDecoder* decoder = error_handling_thread ?
get_error_handler_instance(): get_shared_instance();
assert(decoder != NULL, "null decoder");
return decoder->demangle(symbol, buf, buflen);
}
bool Decoder::can_decode_C_frame_in_vm() {
assert(_shared_decoder_lock != NULL, "Just check");
bool error_handling_thread = os::current_thread_id() == VMError::first_error_tid;
MutexLockerEx locker(error_handling_thread ? NULL : _shared_decoder_lock, true);
AbstractDecoder* decoder = error_handling_thread ?
get_error_handler_instance(): get_shared_instance();
assert(decoder != NULL, "null decoder");
return decoder->can_decode_C_frame_in_vm();
}
void Decoder::shutdown() {
assert(_shared_decoder_lock != NULL, "Just check");
MutexLockerEx locker(_shared_decoder_lock, true);
if (_shared_decoder != NULL &&
_shared_decoder != &_do_nothing_decoder) {
delete _shared_decoder;
}
_shared_decoder = &_do_nothing_decoder;
}
C:\hotspot-69087d08d473\src\share\vm/utilities/decoder.hpp
#ifndef SHARE_VM_UTILITIES_DECODER_HPP
#define SHARE_VM_UTILITIES_DECODER_HPP
#include "memory/allocation.hpp"
#include "runtime/mutex.hpp"
#include "runtime/mutexLocker.hpp"
class AbstractDecoder : public CHeapObj<mtInternal> {
public:
virtual ~AbstractDecoder() {}
enum decoder_status {
not_available = -10, // real decoder is not available
no_error = 0, // successfully decoded frames
out_of_memory, // out of memory
file_invalid, // invalid elf file
file_not_found, // could not found symbol file (on windows), such as jvm.pdb or jvm.map
helper_not_found, // could not load dbghelp.dll (Windows only)
helper_func_error, // decoding functions not found (Windows only)
helper_init_error // SymInitialize failed (Windows only)
};
virtual bool decode(address pc, char* buf, int buflen, int* offset,
const char* modulepath = NULL) = 0;
virtual bool decode(address pc, char* buf, int buflen, int* offset, const void* base) = 0;
virtual bool demangle(const char* symbol, char* buf, int buflen) = 0;
virtual bool can_decode_C_frame_in_vm() const = 0;
virtual decoder_status status() const {
return _decoder_status;
}
virtual bool has_error() const {
return is_error(_decoder_status);
}
static bool is_error(decoder_status status) {
return (status > 0);
}
protected:
decoder_status _decoder_status;
};
class NullDecoder : public AbstractDecoder {
public:
NullDecoder() {
_decoder_status = not_available;
}
virtual ~NullDecoder() {};
virtual bool decode(address pc, char* buf, int buflen, int* offset,
const char* modulepath = NULL) {
return false;
}
virtual bool decode(address pc, char* buf, int buflen, int* offset, const void* base) {
return false;
}
virtual bool demangle(const char* symbol, char* buf, int buflen) {
return false;
}
virtual bool can_decode_C_frame_in_vm() const {
return false;
}
};
class Decoder : AllStatic {
public:
static bool decode(address pc, char* buf, int buflen, int* offset, const char* modulepath = NULL);
static bool decode(address pc, char* buf, int buflen, int* offset, const void* base);
static bool demangle(const char* symbol, char* buf, int buflen);
static bool can_decode_C_frame_in_vm();
static void shutdown();
protected:
static AbstractDecoder* get_shared_instance();
static AbstractDecoder* get_error_handler_instance();
static AbstractDecoder* create_decoder();
private:
static AbstractDecoder* _shared_decoder;
static AbstractDecoder* _error_handler_decoder;
static NullDecoder _do_nothing_decoder;
protected:
static Mutex* _shared_decoder_lock;
static Mutex* shared_decoder_lock();
friend class DecoderLocker;
};
class DecoderLocker : public MutexLockerEx {
AbstractDecoder* _decoder;
inline bool is_first_error_thread();
public:
DecoderLocker();
AbstractDecoder* decoder() {
return _decoder;
}
};
#endif // SHARE_VM_UTILITIES_DECODER_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/decoder_elf.cpp
#include "precompiled.hpp"
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "decoder_elf.hpp"
ElfDecoder::~ElfDecoder() {
if (_opened_elf_files != NULL) {
delete _opened_elf_files;
_opened_elf_files = NULL;
}
}
bool ElfDecoder::decode(address addr, char *buf, int buflen, int* offset, const char* filepath) {
assert(filepath, "null file path");
assert(buf != NULL && buflen > 0, "Invalid buffer");
if (has_error()) return false;
ElfFile* file = get_elf_file(filepath);
if (file == NULL) {
return false;
}
if (!file->decode(addr, buf, buflen, offset)) {
return false;
}
if (buf[0] != '\0') {
demangle(buf, buf, buflen);
}
return true;
}
ElfFile* ElfDecoder::get_elf_file(const char* filepath) {
ElfFile* file;
file = _opened_elf_files;
while (file != NULL) {
if (file->same_elf_file(filepath)) {
return file;
}
file = file->next();
}
file = new (std::nothrow)ElfFile(filepath);
if (file != NULL) {
if (_opened_elf_files != NULL) {
file->set_next(_opened_elf_files);
}
_opened_elf_files = file;
}
return file;
}
#endif // !_WINDOWS && !__APPLE__
C:\hotspot-69087d08d473\src\share\vm/utilities/decoder_elf.hpp
#ifndef SHARE_VM_UTILITIES_DECODER_ELF_HPP
#define SHARE_VM_UTILITIES_DECODER_ELF_HPP
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "utilities/decoder.hpp"
#include "utilities/elfFile.hpp"
class ElfDecoder : public AbstractDecoder {
public:
ElfDecoder() {
_opened_elf_files = NULL;
_decoder_status = no_error;
}
virtual ~ElfDecoder();
bool can_decode_C_frame_in_vm() const { return true; }
bool demangle(const char* symbol, char *buf, int buflen);
bool decode(address addr, char *buf, int buflen, int* offset, const char* filepath = NULL);
bool decode(address addr, char *buf, int buflen, int* offset, const void *base) {
ShouldNotReachHere();
return false;
}
private:
ElfFile* get_elf_file(const char* filepath);
private:
ElfFile* _opened_elf_files;
};
#endif // !_WINDOWS && !__APPLE__
#endif // SHARE_VM_UTILITIES_DECODER_ELF_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/defaultStream.hpp
#ifndef SHARE_VM_UTILITIES_DEFAULTSTREAM_HPP
#define SHARE_VM_UTILITIES_DEFAULTSTREAM_HPP
#include "utilities/xmlstream.hpp"
class defaultStream : public xmlTextStream {
friend void ostream_abort();
public:
enum { NO_WRITER = -1 };
private:
bool _inited;
fileStream* _log_file; // XML-formatted file shared by all threads
static int _output_fd;
static int _error_fd;
static FILE* _output_stream;
static FILE* _error_stream;
void init();
void init_log();
fileStream* open_file(const char* log_name);
void start_log();
void finish_log();
void finish_log_on_error(char *buf, int buflen);
public:
defaultStream() {
_log_file = NULL;
_inited = false;
_writer = -1;
_last_writer = -1;
}
~defaultStream() {
if (has_log_file()) finish_log();
}
static inline FILE* output_stream() {
return DisplayVMOutputToStderr ? _error_stream : _output_stream;
}
static inline FILE* error_stream() {
return DisplayVMOutputToStdout ? _output_stream : _error_stream;
}
static inline int output_fd() {
return DisplayVMOutputToStderr ? _error_fd : _output_fd;
}
static inline int error_fd() {
return DisplayVMOutputToStdout ? _output_fd : _error_fd;
}
virtual void write(const char* s, size_t len);
void flush() {
xmlTextStream::flush();
fflush(output_stream());
if (has_log_file()) _log_file->flush();
}
private:
intx _writer; // thread_id with current rights to output
intx _last_writer;
public:
intx hold(intx writer_id);
void release(intx holder);
intx writer() { return _writer; }
bool has_log_file();
static defaultStream* instance; // sole instance
};
#endif // SHARE_VM_UTILITIES_DEFAULTSTREAM_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/dtrace.hpp
#ifndef SHARE_VM_UTILITIES_DTRACE_HPP
#define SHARE_VM_UTILITIES_DTRACE_HPP
#if defined(DTRACE_ENABLED)
#include <sys/sdt.h>
#define DTRACE_ONLY(x) x
#define NOT_DTRACE(x)
#if defined(SOLARIS)
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG() \
do { volatile size_t dtrace_workaround_tail_call_bug = 1; } while (0)
#define USDT1 1
#elif defined(LINUX)
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG()
#define USDT1 1
#elif defined(__APPLE__)
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG()
#define USDT2 1
#include <sys/types.h>
#include "dtracefiles/hotspot.h"
#include "dtracefiles/hotspot_jni.h"
#include "dtracefiles/hs_private.h"
#else
#error "dtrace enabled for unknown os"
#endif /* defined(SOLARIS) */
#else /* defined(DTRACE_ENABLED) */
#define DTRACE_ONLY(x)
#define NOT_DTRACE(x) x
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG()
#ifndef USDT2
#define DTRACE_PROBE(a,b) {;}
#define DTRACE_PROBE1(a,b,c) {;}
#define DTRACE_PROBE2(a,b,c,d) {;}
#define DTRACE_PROBE3(a,b,c,d,e) {;}
#define DTRACE_PROBE4(a,b,c,d,e,f) {;}
#define DTRACE_PROBE5(a,b,c,d,e,f,g) {;}
#define DTRACE_PROBE6(a,b,c,d,e,f,g,h) {;}
#define DTRACE_PROBE7(a,b,c,d,e,f,g,h,i) {;}
#define DTRACE_PROBE8(a,b,c,d,e,f,g,h,i,j) {;}
#define DTRACE_PROBE9(a,b,c,d,e,f,g,h,i,j,k) {;}
#define DTRACE_PROBE10(a,b,c,d,e,f,g,h,i,j,k,l) {;}
#else /* USDT2 */
#include "dtrace_usdt2_disabled.hpp"
#endif /* USDT2 */
#endif /* defined(DTRACE_ENABLED) */
#ifndef USDT2
#define HS_DTRACE_PROBE_FN(provider,name)\
__dtrace_##provider##___##name
#ifdef SOLARIS
#define HS_DTRACE_PROBE_DECL_N(provider,name,args) \
DTRACE_ONLY(extern "C" void HS_DTRACE_PROBE_FN(provider,name) args)
#define HS_DTRACE_PROBE_CDECL_N(provider,name,args) \
DTRACE_ONLY(extern void HS_DTRACE_PROBE_FN(provider,name) args)
#else
#define HS_DTRACE_PROBE_DECL_N(provider,name,args)
#define HS_DTRACE_PROBE_CDECL_N(provider,name,args)
#endif
#define HS_DTRACE_PROBE_DECL(provider,name) \
HS_DTRACE_PROBE_DECL0(provider,name)
#define HS_DTRACE_PROBE_DECL0(provider,name)\
HS_DTRACE_PROBE_DECL_N(provider,name,(void))
#define HS_DTRACE_PROBE_DECL1(provider,name,t0)\
HS_DTRACE_PROBE_DECL_N(provider,name,(uintptr_t))
#define HS_DTRACE_PROBE_DECL2(provider,name,t0,t1)\
HS_DTRACE_PROBE_DECL_N(provider,name,(uintptr_t,uintptr_t))
#define HS_DTRACE_PROBE_DECL3(provider,name,t0,t1,t2)\
HS_DTRACE_PROBE_DECL_N(provider,name,(uintptr_t,uintptr_t,uintptr_t))
#define HS_DTRACE_PROBE_DECL4(provider,name,t0,t1,t2,t3)\
HS_DTRACE_PROBE_DECL_N(provider,name,(uintptr_t,uintptr_t,uintptr_t,\
uintptr_t))
#define HS_DTRACE_PROBE_DECL5(provider,name,t0,t1,t2,t3,t4)\
HS_DTRACE_PROBE_DECL_N(provider,name,(\
uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t))
#define HS_DTRACE_PROBE_DECL6(provider,name,t0,t1,t2,t3,t4,t5)\
HS_DTRACE_PROBE_DECL_N(provider,name,(\
uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t))
#define HS_DTRACE_PROBE_DECL7(provider,name,t0,t1,t2,t3,t4,t5,t6)\
HS_DTRACE_PROBE_DECL_N(provider,name,(\
uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t))
#define HS_DTRACE_PROBE_DECL8(provider,name,t0,t1,t2,t3,t4,t5,t6,t7)\
HS_DTRACE_PROBE_DECL_N(provider,name,(\
uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,\
uintptr_t))
#define HS_DTRACE_PROBE_DECL9(provider,name,t0,t1,t2,t3,t4,t5,t6,t7,t8)\
HS_DTRACE_PROBE_DECL_N(provider,name,(\
uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,\
uintptr_t,uintptr_t))
#define HS_DTRACE_PROBE_DECL10(provider,name,t0,t1,t2,t3,t4,t5,t6,t7,t8,t9)\
HS_DTRACE_PROBE_DECL_N(provider,name,(\
uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,\
uintptr_t,uintptr_t,uintptr_t))
#if defined(SOLARIS)
#define HS_DTRACE_PROBE_N(provider,name, args) \
DTRACE_ONLY(HS_DTRACE_PROBE_FN(provider,name) args)
#define HS_DTRACE_PROBE(provider,name) HS_DTRACE_PROBE0(provider,name)
#define HS_DTRACE_PROBE0(provider,name)\
HS_DTRACE_PROBE_N(provider,name,())
#define HS_DTRACE_PROBE1(provider,name,a0)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0))
#define HS_DTRACE_PROBE2(provider,name,a0,a1)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1))
#define HS_DTRACE_PROBE3(provider,name,a0,a1,a2)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2))
#define HS_DTRACE_PROBE4(provider,name,a0,a1,a2,a3)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\
(uintptr_t)a3))
#define HS_DTRACE_PROBE5(provider,name,a0,a1,a2,a3,a4)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\
(uintptr_t)a3,(uintptr_t)a4))
#define HS_DTRACE_PROBE6(provider,name,a0,a1,a2,a3,a4,a5)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\
(uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5))
#define HS_DTRACE_PROBE7(provider,name,a0,a1,a2,a3,a4,a5,a6)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\
(uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6))
#define HS_DTRACE_PROBE8(provider,name,a0,a1,a2,a3,a4,a5,a6,a7)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\
(uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6,(uintptr_t)a7))
#define HS_DTRACE_PROBE9(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\
(uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6,(uintptr_t)a7,\
(uintptr_t)a8))
#define HS_DTRACE_PROBE10(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)\
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\
(uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6,(uintptr_t)a7,\
(uintptr_t)a8,(uintptr_t)a9))
#else
#define HS_DTRACE_PROBE(provider,name) HS_DTRACE_PROBE0(provider,name)
#define HS_DTRACE_PROBE0(provider,name)\
DTRACE_PROBE(provider,name)
#define HS_DTRACE_PROBE1(provider,name,a0)\
DTRACE_PROBE1(provider,name,a0)
#define HS_DTRACE_PROBE2(provider,name,a0,a1)\
DTRACE_PROBE2(provider,name,a0,a1)
#define HS_DTRACE_PROBE3(provider,name,a0,a1,a2)\
DTRACE_PROBE3(provider,name,a0,a1,a2)
#define HS_DTRACE_PROBE4(provider,name,a0,a1,a2,a3)\
DTRACE_PROBE4(provider,name,a0,a1,a2,a3)
#define HS_DTRACE_PROBE5(provider,name,a0,a1,a2,a3,a4)\
DTRACE_PROBE5(provider,name,a0,a1,a2,a3,a4)
#define HS_DTRACE_PROBE6(provider,name,a0,a1,a2,a3,a4,a5)\
DTRACE_PROBE6(provider,name,a0,a1,a2,a3,a4,a5)
#define HS_DTRACE_PROBE7(provider,name,a0,a1,a2,a3,a4,a5,a6)\
DTRACE_PROBE7(provider,name,a0,a1,a2,a3,a4,a5,a6)
#define HS_DTRACE_PROBE8(provider,name,a0,a1,a2,a3,a4,a5,a6,a7)\
DTRACE_PROBE8(provider,name,a0,a1,a2,a3,a4,a5,a6,a7)
#define HS_DTRACE_PROBE9(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8)\
DTRACE_PROBE9(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8)
#define HS_DTRACE_PROBE10(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)\
DTRACE_PROBE10(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)
#endif
#endif /* !USDT2 */
#endif // SHARE_VM_UTILITIES_DTRACE_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/dtrace_usdt2_disabled.hpp
#ifndef SHARE_VM_UTILITIES_DTRACE_USDT2_DISABLED_HPP
#define SHARE_VM_UTILITIES_DTRACE_USDT2_DISABLED_HPP
#if !defined(DTRACE_ENABLED)
#ifdef USDT2
#define HOTSPOT_CLASS_LOADED(arg0, arg1, arg2, arg3)
#define HOTSPOT_CLASS_LOADED_ENABLED() 0
#define HOTSPOT_CLASS_UNLOADED(arg0, arg1, arg2, arg3)
#define HOTSPOT_CLASS_UNLOADED_ENABLED() 0
#define HOTSPOT_CLASS_INITIALIZATION_REQUIRED(arg0, arg1, arg2, arg3)
#define HOTSPOT_CLASS_INITIALIZATION_REQUIRED_ENABLED() 0
#define HOTSPOT_CLASS_INITIALIZATION_RECURSIVE(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_CLASS_INITIALIZATION_RECURSIVE_ENABLED() 0
#define HOTSPOT_CLASS_INITIALIZATION_CONCURRENT(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_CLASS_INITIALIZATION_CONCURRENT_ENABLED() 0
#define HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS_ENABLED() 0
#define HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED_ENABLED() 0
#define HOTSPOT_CLASS_INITIALIZATION_CLINIT(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_CLASS_INITIALIZATION_CLINIT_ENABLED() 0
#define HOTSPOT_CLASS_INITIALIZATION_ERROR(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_CLASS_INITIALIZATION_ERROR_ENABLED() 0
#define HOTSPOT_CLASS_INITIALIZATION_END(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_CLASS_INITIALIZATION_END_ENABLED() 0
#define HOTSPOT_COMPILED_METHOD_LOAD(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
#define HOTSPOT_COMPILED_METHOD_LOAD_ENABLED() 0
#define HOTSPOT_COMPILED_METHOD_UNLOAD(arg0, arg1, arg2, arg3, arg4, arg5)
#define HOTSPOT_COMPILED_METHOD_UNLOAD_ENABLED() 0
#define HOTSPOT_GC_BEGIN(arg0)
#define HOTSPOT_GC_BEGIN_ENABLED() 0
#define HOTSPOT_GC_END()
#define HOTSPOT_GC_END_ENABLED() 0
#define HOTSPOT_MEM_POOL_GC_BEGIN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
#define HOTSPOT_MEM_POOL_GC_BEGIN_ENABLED() 0
#define HOTSPOT_MEM_POOL_GC_END(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
#define HOTSPOT_MEM_POOL_GC_END_ENABLED() 0
#define HOTSPOT_METHOD_COMPILE_BEGIN(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
#define HOTSPOT_METHOD_COMPILE_BEGIN_ENABLED() 0
#define HOTSPOT_METHOD_COMPILE_END(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
#define HOTSPOT_METHOD_COMPILE_END_ENABLED() 0
#define HOTSPOT_METHOD_ENTRY(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
#define HOTSPOT_METHOD_ENTRY_ENABLED() 0
#define HOTSPOT_METHOD_RETURN(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
#define HOTSPOT_METHOD_RETURN_ENABLED() 0
#define HOTSPOT_MONITOR_CONTENDED_ENTER(arg0, arg1, arg2, arg3)
#define HOTSPOT_MONITOR_CONTENDED_ENTER_ENABLED() 0
#define HOTSPOT_MONITOR_CONTENDED_ENTERED(arg0, arg1, arg2, arg3)
#define HOTSPOT_MONITOR_CONTENDED_ENTERED_ENABLED() 0
#define HOTSPOT_MONITOR_CONTENDED_EXIT(arg0, arg1, arg2, arg3)
#define HOTSPOT_MONITOR_CONTENDED_EXIT_ENABLED() 0
#define HOTSPOT_MONITOR_NOTIFY(arg0, arg1, arg2, arg3)
#define HOTSPOT_MONITOR_NOTIFY_ENABLED() 0
#define HOTSPOT_MONITOR_NOTIFYALL(arg0, arg1, arg2, arg3)
#define HOTSPOT_MONITOR_NOTIFYALL_ENABLED() 0
#define HOTSPOT_MONITOR_WAIT(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_MONITOR_WAIT_ENABLED() 0
#define HOTSPOT_MONITOR_WAIT_PROBE(arg0, arg1, arg2, arg3)
#define HOTSPOT_MONITOR_WAIT_PROBE_ENABLED() 0
#define HOTSPOT_MONITOR_WAITED(arg0, arg1, arg2, arg3)
#define HOTSPOT_MONITOR_WAITED_ENABLED() 0
#define HOTSPOT_OBJECT_ALLOC(arg0, arg1, arg2, arg3)
#define HOTSPOT_OBJECT_ALLOC_ENABLED() 0
#define HOTSPOT_THREAD_START(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_THREAD_START_ENABLED() 0
#define HOTSPOT_THREAD_STOP(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_THREAD_STOP_ENABLED() 0
#define HOTSPOT_THREAD_SLEEP_BEGIN(arg0)
#define HOTSPOT_THREAD_SLEEP_BEGIN_ENABLED() 0
#define HOTSPOT_THREAD_SLEEP_END(arg0)
#define HOTSPOT_THREAD_SLEEP_END_ENABLED() 0
#define HOTSPOT_THREAD_YIELD()
#define HOTSPOT_THREAD_YIELD_ENABLED() 0
#define HOTSPOT_THREAD_PARK_BEGIN(arg0, arg1, arg2)
#define HOTSPOT_THREAD_PARK_BEGIN_ENABLED() 0
#define HOTSPOT_THREAD_PARK_END(arg0)
#define HOTSPOT_THREAD_PARK_END_ENABLED() 0
#define HOTSPOT_THREAD_UNPARK()
#define HOTSPOT_THREAD_UNPARK_ENABLED() 0
#define HOTSPOT_VM_INIT_BEGIN()
#define HOTSPOT_VM_INIT_BEGIN_ENABLED() 0
#define HOTSPOT_VM_INIT_END()
#define HOTSPOT_VM_INIT_END_ENABLED() 0
#define HOTSPOT_VM_SHUTDOWN()
#define HOTSPOT_VM_SHUTDOWN_ENABLED() 0
#define HOTSPOT_VMOPS_REQUEST(arg0, arg1, arg2)
#define HOTSPOT_VMOPS_REQUEST_ENABLED() 0
#define HOTSPOT_VMOPS_BEGIN(arg0, arg1, arg2)
#define HOTSPOT_VMOPS_BEGIN_ENABLED() 0
#define HOTSPOT_VMOPS_END(arg0, arg1, arg2)
#define HOTSPOT_VMOPS_END_ENABLED() 0
#define HS_PRIVATE_CMS_INITMARK_BEGIN()
#define HS_PRIVATE_CMS_INITMARK_BEGIN_ENABLED() 0
#define HS_PRIVATE_CMS_INITMARK_END()
#define HS_PRIVATE_CMS_INITMARK_END_ENABLED() 0
#define HS_PRIVATE_CMS_REMARK_BEGIN()
#define HS_PRIVATE_CMS_REMARK_BEGIN_ENABLED() 0
#define HS_PRIVATE_CMS_REMARK_END()
#define HS_PRIVATE_CMS_REMARK_END_ENABLED() 0
#define HS_PRIVATE_HASHTABLE_NEW_ENTRY(arg0, arg1, arg2, arg3)
#define HS_PRIVATE_HASHTABLE_NEW_ENTRY_ENABLED() 0
#define HS_PRIVATE_SAFEPOINT_BEGIN()
#define HS_PRIVATE_SAFEPOINT_BEGIN_ENABLED() 0
#define HS_PRIVATE_SAFEPOINT_END()
#define HS_PRIVATE_SAFEPOINT_END_ENABLED() 0
#define HOTSPOT_JNI_ALLOCOBJECT_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_ALLOCOBJECT_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_ALLOCOBJECT_RETURN(arg0)
#define HOTSPOT_JNI_ALLOCOBJECT_RETURN_ENABLED() 0
#define HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(arg0)
#define HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(arg0)
#define HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLBYTEMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLBYTEMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLBYTEMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLBYTEMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLBYTEMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLCHARMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLCHARMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLCHARMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLCHARMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLCHARMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLCHARMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLCHARMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLCHARMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLCHARMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLCHARMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLCHARMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()
#define HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN()
#define HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN()
#define HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()
#define HOTSPOT_JNI_CALLFLOATMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLFLOATMETHODA_RETURN()
#define HOTSPOT_JNI_CALLFLOATMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLFLOATMETHODV_RETURN()
#define HOTSPOT_JNI_CALLFLOATMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLINTMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLINTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLINTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLINTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLINTMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLINTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLINTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLINTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLINTMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLINTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLINTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLINTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLLONGMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLLONGMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLLONGMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLLONGMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLLONGMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLLONGMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLLONGMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLLONGMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLLONGMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLLONGMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLLONGMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN()
#define HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLSHORTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSHORTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLSHORTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSHORTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLSHORTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBYTEMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICBYTEMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBYTEMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICBYTEMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBYTEMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICBYTEMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBYTEMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICBYTEMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICCHARMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICCHARMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICCHARMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICCHARMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICCHARMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICCHARMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICCHARMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICCHARMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN()
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_RETURN()
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_RETURN()
#define HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICFLOATMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICFLOATMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICFLOATMETHOD_RETURN()
#define HOTSPOT_JNI_CALLSTATICFLOATMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICFLOATMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICFLOATMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICFLOATMETHODA_RETURN()
#define HOTSPOT_JNI_CALLSTATICFLOATMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICFLOATMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICFLOATMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICFLOATMETHODV_RETURN()
#define HOTSPOT_JNI_CALLSTATICFLOATMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICINTMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICINTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICINTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICINTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICINTMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICINTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICINTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICINTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICINTMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICINTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICINTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICINTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICLONGMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICLONGMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICLONGMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICLONGMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICLONGMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICLONGMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICLONGMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICLONGMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICLONGMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICLONGMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICLONGMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICLONGMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICSHORTMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICSHORTMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICSHORTMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICSHORTMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICSHORTMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICSHORTMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICSHORTMETHODA_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICSHORTMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(arg0)
#define HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN()
#define HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN()
#define HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN()
#define HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLVOIDMETHOD_RETURN()
#define HOTSPOT_JNI_CALLVOIDMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLVOIDMETHODA_RETURN()
#define HOTSPOT_JNI_CALLVOIDMETHODA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CALLVOIDMETHODV_RETURN()
#define HOTSPOT_JNI_CALLVOIDMETHODV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_CREATEJAVAVM_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_CREATEJAVAVM_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_CREATEJAVAVM_RETURN(arg0)
#define HOTSPOT_JNI_CREATEJAVAVM_RETURN_ENABLED() 0
#define HOTSPOT_JNI_DEFINECLASS_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_DEFINECLASS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_DEFINECLASS_RETURN(arg0)
#define HOTSPOT_JNI_DEFINECLASS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_DELETEGLOBALREF_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_DELETEGLOBALREF_RETURN()
#define HOTSPOT_JNI_DELETEGLOBALREF_RETURN_ENABLED() 0
#define HOTSPOT_JNI_DELETELOCALREF_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_DELETELOCALREF_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_DELETELOCALREF_RETURN()
#define HOTSPOT_JNI_DELETELOCALREF_RETURN_ENABLED() 0
#define HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN()
#define HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN_ENABLED() 0
#define HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(arg0)
#define HOTSPOT_JNI_DESTROYJAVAVM_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_DESTROYJAVAVM_RETURN(arg0)
#define HOTSPOT_JNI_DESTROYJAVAVM_RETURN_ENABLED() 0
#define HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(arg0)
#define HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(arg0)
#define HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(arg0)
#define HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(arg0)
#define HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(arg0)
#define HOTSPOT_JNI_EXCEPTIONCHECK_RETURN_ENABLED() 0
#define HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(arg0)
#define HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN()
#define HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN_ENABLED() 0
#define HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(arg0)
#define HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN()
#define HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN_ENABLED() 0
#define HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(arg0)
#define HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(arg0)
#define HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN_ENABLED() 0
#define HOTSPOT_JNI_FATALERROR_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_FATALERROR_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_FINDCLASS_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_FINDCLASS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_FINDCLASS_RETURN(arg0)
#define HOTSPOT_JNI_FINDCLASS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN(arg0)
#define HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETARRAYLENGTH_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETARRAYLENGTH_RETURN(arg0)
#define HOTSPOT_JNI_GETARRAYLENGTH_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_RETURN(arg0)
#define HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETBOOLEANARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETBOOLEANARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETBOOLEANARRAYREGION_RETURN()
#define HOTSPOT_JNI_GETBOOLEANARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETBOOLEANFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETBOOLEANFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETBOOLEANFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETBOOLEANFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETBYTEARRAYELEMENTS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETBYTEARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETBYTEARRAYELEMENTS_RETURN(arg0)
#define HOTSPOT_JNI_GETBYTEARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETBYTEARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETBYTEARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETBYTEARRAYREGION_RETURN()
#define HOTSPOT_JNI_GETBYTEARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETBYTEFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETBYTEFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETBYTEFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETBYTEFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETCHARARRAYELEMENTS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETCHARARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETCHARARRAYELEMENTS_RETURN(arg0)
#define HOTSPOT_JNI_GETCHARARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETCHARARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETCHARARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETCHARARRAYREGION_RETURN()
#define HOTSPOT_JNI_GETCHARARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETCHARFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETCHARFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETCHARFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETCHARFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(arg0)
#define HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(arg0)
#define HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(arg0)
#define HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN(arg0)
#define HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(arg0)
#define HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(arg0)
#define HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN()
#define HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETDOUBLEFIELD_RETURN()
#define HOTSPOT_JNI_GETDOUBLEFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETENV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETENV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETENV_RETURN(arg0)
#define HOTSPOT_JNI_GETENV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETFIELDID_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_GETFIELDID_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETFIELDID_RETURN(arg0)
#define HOTSPOT_JNI_GETFIELDID_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(arg0)
#define HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN()
#define HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETFLOATFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETFLOATFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETFLOATFIELD_RETURN()
#define HOTSPOT_JNI_GETFLOATFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETINTARRAYELEMENTS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETINTARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETINTARRAYELEMENTS_RETURN(arg0)
#define HOTSPOT_JNI_GETINTARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETINTARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETINTARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETINTARRAYREGION_RETURN()
#define HOTSPOT_JNI_GETINTARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETINTFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETINTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETINTFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETINTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETJAVAVM_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETJAVAVM_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETJAVAVM_RETURN(arg0)
#define HOTSPOT_JNI_GETJAVAVM_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETLONGARRAYELEMENTS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETLONGARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETLONGARRAYELEMENTS_RETURN(arg0)
#define HOTSPOT_JNI_GETLONGARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETLONGARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETLONGARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETLONGARRAYREGION_RETURN()
#define HOTSPOT_JNI_GETLONGARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETLONGFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETLONGFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETLONGFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETLONGFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETMETHODID_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_GETMETHODID_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETMETHODID_RETURN(arg0)
#define HOTSPOT_JNI_GETMETHODID_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(arg0)
#define HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETOBJECTCLASS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETOBJECTCLASS_RETURN(arg0)
#define HOTSPOT_JNI_GETOBJECTCLASS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETOBJECTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETOBJECTFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETOBJECTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN(arg0)
#define HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(arg0)
#define HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSHORTARRAYELEMENTS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSHORTARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSHORTARRAYELEMENTS_RETURN(arg0)
#define HOTSPOT_JNI_GETSHORTARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSHORTARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETSHORTARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSHORTARRAYREGION_RETURN()
#define HOTSPOT_JNI_GETSHORTARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSHORTFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSHORTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSHORTFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETSHORTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICBOOLEANFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICBOOLEANFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICBOOLEANFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICBOOLEANFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICBYTEFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICBYTEFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICBYTEFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICBYTEFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICCHARFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICCHARFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICCHARFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICCHARFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN()
#define HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_GETSTATICFIELDID_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICFIELDID_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICFIELDID_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN()
#define HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICINTFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICINTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICINTFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICINTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICLONGFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICLONGFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICLONGFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICLONGFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_GETSTATICMETHODID_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICMETHODID_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICMETHODID_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICSHORTFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTATICSHORTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTATICSHORTFIELD_RETURN(arg0)
#define HOTSPOT_JNI_GETSTATICSHORTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTRINGCHARS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGCHARS_RETURN(arg0)
#define HOTSPOT_JNI_GETSTRINGCHARS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN(arg0)
#define HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(arg0)
#define HOTSPOT_JNI_GETSTRINGLENGTH_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETSTRINGREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGREGION_RETURN()
#define HOTSPOT_JNI_GETSTRINGREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(arg0)
#define HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(arg0)
#define HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN()
#define HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETSUPERCLASS_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_GETSUPERCLASS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETSUPERCLASS_RETURN(arg0)
#define HOTSPOT_JNI_GETSUPERCLASS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_GETVERSION_ENTRY(arg0)
#define HOTSPOT_JNI_GETVERSION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_GETVERSION_RETURN(arg0)
#define HOTSPOT_JNI_GETVERSION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(arg0)
#define HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN_ENABLED() 0
#define HOTSPOT_JNI_ISINSTANCEOF_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_ISINSTANCEOF_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_ISINSTANCEOF_RETURN(arg0)
#define HOTSPOT_JNI_ISINSTANCEOF_RETURN_ENABLED() 0
#define HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_ISSAMEOBJECT_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_ISSAMEOBJECT_RETURN(arg0)
#define HOTSPOT_JNI_ISSAMEOBJECT_RETURN_ENABLED() 0
#define HOTSPOT_JNI_MONITORENTER_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_MONITORENTER_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_MONITORENTER_RETURN(arg0)
#define HOTSPOT_JNI_MONITORENTER_RETURN_ENABLED() 0
#define HOTSPOT_JNI_MONITOREXIT_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_MONITOREXIT_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_MONITOREXIT_RETURN(arg0)
#define HOTSPOT_JNI_MONITOREXIT_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWBYTEARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWBYTEARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWBYTEARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWCHARARRAY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWCHARARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWCHARARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWCHARARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(arg0)
#define HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWFLOATARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWFLOATARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWFLOATARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWGLOBALREF_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWGLOBALREF_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWGLOBALREF_RETURN(arg0)
#define HOTSPOT_JNI_NEWGLOBALREF_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWINTARRAY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWINTARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWINTARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWINTARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWLOCALREF_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWLOCALREF_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWLOCALREF_RETURN(arg0)
#define HOTSPOT_JNI_NEWLOCALREF_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWLONGARRAY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWLONGARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWLONGARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWLONGARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWOBJECT_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_NEWOBJECT_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWOBJECT_RETURN(arg0)
#define HOTSPOT_JNI_NEWOBJECT_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWOBJECTA_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_NEWOBJECTA_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWOBJECTA_RETURN(arg0)
#define HOTSPOT_JNI_NEWOBJECTA_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWOBJECTARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWOBJECTV_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_NEWOBJECTV_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWOBJECTV_RETURN(arg0)
#define HOTSPOT_JNI_NEWOBJECTV_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWSHORTARRAY_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWSHORTARRAY_RETURN(arg0)
#define HOTSPOT_JNI_NEWSHORTARRAY_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWSTRING_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_NEWSTRING_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWSTRING_RETURN(arg0)
#define HOTSPOT_JNI_NEWSTRING_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWSTRINGUTF_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWSTRINGUTF_RETURN(arg0)
#define HOTSPOT_JNI_NEWSTRINGUTF_RETURN_ENABLED() 0
#define HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(arg0)
#define HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN_ENABLED() 0
#define HOTSPOT_JNI_POPLOCALFRAME_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_POPLOCALFRAME_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_POPLOCALFRAME_RETURN(arg0)
#define HOTSPOT_JNI_POPLOCALFRAME_RETURN_ENABLED() 0
#define HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(arg0)
#define HOTSPOT_JNI_PUSHLOCALFRAME_RETURN_ENABLED() 0
#define HOTSPOT_JNI_REGISTERNATIVES_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_REGISTERNATIVES_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_REGISTERNATIVES_RETURN(arg0)
#define HOTSPOT_JNI_REGISTERNATIVES_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_RETURN()
#define HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_RETURN()
#define HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_RETURN()
#define HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN()
#define HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN()
#define HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_RETURN()
#define HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_RETURN()
#define HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN()
#define HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_RETURN()
#define HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN()
#define HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN()
#define HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN_ENABLED() 0
#define HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN()
#define HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETBOOLEANARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_SETBOOLEANARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETBOOLEANARRAYREGION_RETURN()
#define HOTSPOT_JNI_SETBOOLEANARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETBOOLEANFIELD_RETURN()
#define HOTSPOT_JNI_SETBOOLEANFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETBYTEARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_SETBYTEARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETBYTEARRAYREGION_RETURN()
#define HOTSPOT_JNI_SETBYTEARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETBYTEFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETBYTEFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETBYTEFIELD_RETURN()
#define HOTSPOT_JNI_SETBYTEFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETCHARARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_SETCHARARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETCHARARRAYREGION_RETURN()
#define HOTSPOT_JNI_SETCHARARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETCHARFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETCHARFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETCHARFIELD_RETURN()
#define HOTSPOT_JNI_SETCHARFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN()
#define HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETDOUBLEFIELD_RETURN()
#define HOTSPOT_JNI_SETDOUBLEFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN()
#define HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETFLOATFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_SETFLOATFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETFLOATFIELD_RETURN()
#define HOTSPOT_JNI_SETFLOATFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETINTARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_SETINTARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETINTARRAYREGION_RETURN()
#define HOTSPOT_JNI_SETINTARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETINTFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETINTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETINTFIELD_RETURN()
#define HOTSPOT_JNI_SETINTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETLONGARRAYREGION_RETURN()
#define HOTSPOT_JNI_SETLONGARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETLONGFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETLONGFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETLONGFIELD_RETURN()
#define HOTSPOT_JNI_SETLONGFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN()
#define HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETOBJECTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETOBJECTFIELD_RETURN()
#define HOTSPOT_JNI_SETOBJECTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSHORTARRAYREGION_ENTRY(arg0, arg1, arg2, arg3, arg4)
#define HOTSPOT_JNI_SETSHORTARRAYREGION_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSHORTARRAYREGION_RETURN()
#define HOTSPOT_JNI_SETSHORTARRAYREGION_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSHORTFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETSHORTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSHORTFIELD_RETURN()
#define HOTSPOT_JNI_SETSHORTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICBOOLEANFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETSTATICBOOLEANFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICBOOLEANFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICBOOLEANFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICCHARFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETSTATICCHARFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICCHARFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICCHARFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICINTFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETSTATICINTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICINTFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICINTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICLONGFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETSTATICLONGFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICLONGFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICLONGFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICSHORTFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_SETSTATICSHORTFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_SETSTATICSHORTFIELD_RETURN()
#define HOTSPOT_JNI_SETSTATICSHORTFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_THROW_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_THROW_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_THROW_RETURN(arg0)
#define HOTSPOT_JNI_THROW_RETURN_ENABLED() 0
#define HOTSPOT_JNI_THROWNEW_ENTRY(arg0, arg1, arg2)
#define HOTSPOT_JNI_THROWNEW_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_THROWNEW_RETURN(arg0)
#define HOTSPOT_JNI_THROWNEW_RETURN_ENABLED() 0
#define HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(arg0)
#define HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(arg0, arg1, arg2, arg3)
#define HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(arg0)
#define HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN_ENABLED() 0
#define HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(arg0, arg1)
#define HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY_ENABLED() 0
#define HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(arg0)
#define HOTSPOT_JNI_UNREGISTERNATIVES_RETURN_ENABLED() 0
#else /* USDT2 */
#error This file should only be included for USDT2
#endif /* USDT2 */
#else /* !defined(DTRACE_ENABLED) */
#error This file should only be included when dtrace is not enabled
#end /* !defined(DTRACE_ENABLED) */
#endif // SHARE_VM_UTILITIES_DTRACE_USDT2_DISABLED_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/elfFile.cpp
#include "precompiled.hpp"
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include <string.h>
#include <stdio.h>
#include <limits.h>
#include <new>
#include "memory/allocation.inline.hpp"
#include "utilities/decoder.hpp"
#include "utilities/elfFile.hpp"
#include "utilities/elfFuncDescTable.hpp"
#include "utilities/elfStringTable.hpp"
#include "utilities/elfSymbolTable.hpp"
ElfFile::ElfFile(const char* filepath) {
assert(filepath, "null file path");
memset(&m_elfHdr, 0, sizeof(m_elfHdr));
m_string_tables = NULL;
m_symbol_tables = NULL;
m_funcDesc_table = NULL;
m_next = NULL;
m_status = NullDecoder::no_error;
int len = strlen(filepath) + 1;
m_filepath = (const char*)os::malloc(len * sizeof(char), mtInternal);
if (m_filepath != NULL) {
strcpy((char*)m_filepath, filepath);
m_file = fopen(filepath, "r");
if (m_file != NULL) {
load_tables();
} else {
m_status = NullDecoder::file_not_found;
}
} else {
m_status = NullDecoder::out_of_memory;
}
}
ElfFile::~ElfFile() {
if (m_string_tables != NULL) {
delete m_string_tables;
}
if (m_symbol_tables != NULL) {
delete m_symbol_tables;
}
if (m_file != NULL) {
fclose(m_file);
}
if (m_filepath != NULL) {
os::free((void*)m_filepath);
}
if (m_next != NULL) {
delete m_next;
}
};
bool ElfFile::is_elf_file(Elf_Ehdr& hdr) {
return (ELFMAG0 == hdr.e_ident[EI_MAG0] &&
ELFMAG1 == hdr.e_ident[EI_MAG1] &&
ELFMAG2 == hdr.e_ident[EI_MAG2] &&
ELFMAG3 == hdr.e_ident[EI_MAG3] &&
ELFCLASSNONE != hdr.e_ident[EI_CLASS] &&
ELFDATANONE != hdr.e_ident[EI_DATA]);
}
bool ElfFile::load_tables() {
assert(m_file, "file not open");
assert(!NullDecoder::is_error(m_status), "already in error");
if (fread(&m_elfHdr, sizeof(m_elfHdr), 1, m_file) != 1) {
m_status = NullDecoder::file_invalid;
return false;
}
if (!is_elf_file(m_elfHdr)) {
m_status = NullDecoder::file_invalid;
return false;
}
Elf_Shdr shdr;
if (!fseek(m_file, m_elfHdr.e_shoff, SEEK_SET)) {
if (NullDecoder::is_error(m_status)) return false;
for (int index = 0; index < m_elfHdr.e_shnum; index ++) {
if (fread((void*)&shdr, sizeof(Elf_Shdr), 1, m_file) != 1) {
m_status = NullDecoder::file_invalid;
return false;
}
if (shdr.sh_type == SHT_STRTAB) {
ElfStringTable* table = new (std::nothrow) ElfStringTable(m_file, shdr, index);
if (table == NULL) {
m_status = NullDecoder::out_of_memory;
return false;
}
add_string_table(table);
} else if (shdr.sh_type == SHT_SYMTAB || shdr.sh_type == SHT_DYNSYM) {
ElfSymbolTable* table = new (std::nothrow) ElfSymbolTable(m_file, shdr);
if (table == NULL) {
m_status = NullDecoder::out_of_memory;
return false;
}
add_symbol_table(table);
}
}
#if defined(PPC64) && !defined(ABI_ELFv2)
if (fseek(m_file, m_elfHdr.e_shoff, SEEK_SET)) {
m_status = NullDecoder::file_invalid;
return false;
}
for (int index = 0; index < m_elfHdr.e_shnum; index ++) {
if (fread((void*)&shdr, sizeof(Elf_Shdr), 1, m_file) != 1) {
m_status = NullDecoder::file_invalid;
return false;
}
if (m_elfHdr.e_shstrndx != SHN_UNDEF && shdr.sh_type == SHT_PROGBITS) {
ElfStringTable* string_table = get_string_table(m_elfHdr.e_shstrndx);
if (string_table == NULL) {
m_status = NullDecoder::file_invalid;
return false;
}
char buf[8]; // '8' is enough because we only want to read ".opd"
if (string_table->string_at(shdr.sh_name, buf, sizeof(buf)) && !strncmp(".opd", buf, 4)) {
m_funcDesc_table = new (std::nothrow) ElfFuncDescTable(m_file, shdr, index);
if (m_funcDesc_table == NULL) {
m_status = NullDecoder::out_of_memory;
return false;
}
break;
}
}
}
#endif
}
return true;
}
bool ElfFile::decode(address addr, char* buf, int buflen, int* offset) {
if (NullDecoder::is_error(m_status)) {
return false;
}
ElfSymbolTable* symbol_table = m_symbol_tables;
int string_table_index;
int pos_in_string_table;
int off = INT_MAX;
bool found_symbol = false;
while (symbol_table != NULL) {
if (symbol_table->lookup(addr, &string_table_index, &pos_in_string_table, &off, m_funcDesc_table)) {
found_symbol = true;
break;
}
symbol_table = symbol_table->m_next;
}
if (!found_symbol) return false;
ElfStringTable* string_table = get_string_table(string_table_index);
if (string_table == NULL) {
m_status = NullDecoder::file_invalid;
return false;
}
if (offset) *offset = off;
return string_table->string_at(pos_in_string_table, buf, buflen);
}
void ElfFile::add_symbol_table(ElfSymbolTable* table) {
if (m_symbol_tables == NULL) {
m_symbol_tables = table;
} else {
table->m_next = m_symbol_tables;
m_symbol_tables = table;
}
}
void ElfFile::add_string_table(ElfStringTable* table) {
if (m_string_tables == NULL) {
m_string_tables = table;
} else {
table->m_next = m_string_tables;
m_string_tables = table;
}
}
ElfStringTable* ElfFile::get_string_table(int index) {
ElfStringTable* p = m_string_tables;
while (p != NULL) {
if (p->index() == index) return p;
p = p->m_next;
}
return NULL;
}
#ifdef LINUX
bool ElfFile::specifies_noexecstack() {
Elf_Phdr phdr;
if (!m_file) return true;
if (!fseek(m_file, m_elfHdr.e_phoff, SEEK_SET)) {
for (int index = 0; index < m_elfHdr.e_phnum; index ++) {
if (fread((void*)&phdr, sizeof(Elf_Phdr), 1, m_file) != 1) {
m_status = NullDecoder::file_invalid;
return false;
}
if (phdr.p_type == PT_GNU_STACK) {
if (phdr.p_flags == (PF_R | PF_W)) {
return true;
} else {
return false;
}
}
}
}
#ifdef AARCH64
return true;
#else
return false;
#endif
}
#endif
#endif // !_WINDOWS && !__APPLE__
C:\hotspot-69087d08d473\src\share\vm/utilities/elfFile.hpp
#ifndef SHARE_VM_UTILITIES_ELF_FILE_HPP
#define SHARE_VM_UTILITIES_ELF_FILE_HPP
#if !defined(_WINDOWS) && !defined(__APPLE__)
#if defined(__OpenBSD__)
#include <sys/exec_elf.h>
#else
#include <elf.h>
#endif
#include <stdio.h>
#ifdef _LP64
typedef Elf64_Half Elf_Half;
typedef Elf64_Word Elf_Word;
typedef Elf64_Off Elf_Off;
typedef Elf64_Addr Elf_Addr;
typedef Elf64_Ehdr Elf_Ehdr;
typedef Elf64_Shdr Elf_Shdr;
typedef Elf64_Phdr Elf_Phdr;
typedef Elf64_Sym Elf_Sym;
#if !defined(_ALLBSD_SOURCE) || defined(__APPLE__)
#define ELF_ST_TYPE ELF64_ST_TYPE
#endif
#else
typedef Elf32_Half Elf_Half;
typedef Elf32_Word Elf_Word;
typedef Elf32_Off Elf_Off;
typedef Elf32_Addr Elf_Addr;
typedef Elf32_Ehdr Elf_Ehdr;
typedef Elf32_Shdr Elf_Shdr;
typedef Elf32_Phdr Elf_Phdr;
typedef Elf32_Sym Elf_Sym;
#if !defined(_ALLBSD_SOURCE) || defined(__APPLE__)
#define ELF_ST_TYPE ELF32_ST_TYPE
#endif
#endif
#include "globalDefinitions.hpp"
#include "memory/allocation.hpp"
#include "utilities/decoder.hpp"
class ElfStringTable;
class ElfSymbolTable;
class ElfFuncDescTable;
class ElfFile: public CHeapObj<mtInternal> {
friend class ElfDecoder;
public:
ElfFile(const char* filepath);
~ElfFile();
bool decode(address addr, char* buf, int buflen, int* offset);
const char* filepath() {
return m_filepath;
}
bool same_elf_file(const char* filepath) {
assert(filepath, "null file path");
assert(m_filepath, "already out of memory");
return (m_filepath && !strcmp(filepath, m_filepath));
}
NullDecoder::decoder_status get_status() {
return m_status;
}
private:
bool is_elf_file(Elf_Ehdr&);
bool load_tables();
void add_string_table(ElfStringTable* table);
void add_symbol_table(ElfSymbolTable* table);
ElfStringTable* get_string_table(int index);
protected:
ElfFile* next() const { return m_next; }
void set_next(ElfFile* file) { m_next = file; }
public:
bool specifies_noexecstack() NOT_LINUX({ return false; });
protected:
ElfFile* m_next;
private:
const char* m_filepath;
FILE* m_file;
Elf_Ehdr m_elfHdr;
ElfSymbolTable* m_symbol_tables;
ElfStringTable* m_string_tables;
ElfFuncDescTable* m_funcDesc_table;
NullDecoder::decoder_status m_status;
};
#endif // !_WINDOWS && !__APPLE__
#endif // SHARE_VM_UTILITIES_ELF_FILE_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/elfFuncDescTable.cpp
#include "precompiled.hpp"
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "memory/allocation.inline.hpp"
#include "utilities/elfFuncDescTable.hpp"
ElfFuncDescTable::ElfFuncDescTable(FILE* file, Elf_Shdr shdr, int index) {
assert(file, "null file handle");
m_funcDescs = NULL;
m_file = file;
m_index = index;
m_status = NullDecoder::no_error;
long cur_offset = ftell(file);
if (cur_offset != -1) {
m_funcDescs = (address*)os::malloc(shdr.sh_size, mtInternal);
if (m_funcDescs) {
if (fseek(file, shdr.sh_offset, SEEK_SET) ||
fread((void*)m_funcDescs, shdr.sh_size, 1, file) != 1 ||
fseek(file, cur_offset, SEEK_SET)) {
m_status = NullDecoder::file_invalid;
os::free(m_funcDescs);
m_funcDescs = NULL;
}
}
if (!NullDecoder::is_error(m_status)) {
memcpy(&m_shdr, &shdr, sizeof(Elf_Shdr));
}
} else {
m_status = NullDecoder::file_invalid;
}
}
ElfFuncDescTable::~ElfFuncDescTable() {
if (m_funcDescs != NULL) {
os::free(m_funcDescs);
}
}
address ElfFuncDescTable::lookup(Elf_Word index) {
if (NullDecoder::is_error(m_status)) {
return NULL;
}
if (m_funcDescs != NULL) {
if (m_shdr.sh_size > 0 && m_shdr.sh_addr <= index && index <= m_shdr.sh_addr + m_shdr.sh_size) {
return m_funcDescs[(index - m_shdr.sh_addr) / sizeof(address)];
}
return NULL;
} else {
long cur_pos;
address addr;
if (!(m_shdr.sh_size > 0 && m_shdr.sh_addr <= index && index <= m_shdr.sh_addr + m_shdr.sh_size)) {
return NULL;
}
if ((cur_pos = ftell(m_file)) == -1 ||
fseek(m_file, m_shdr.sh_offset + index - m_shdr.sh_addr, SEEK_SET) ||
fread(&addr, sizeof(addr), 1, m_file) != 1 ||
fseek(m_file, cur_pos, SEEK_SET)) {
m_status = NullDecoder::file_invalid;
return NULL;
}
return addr;
}
}
#endif // !_WINDOWS && !__APPLE__
C:\hotspot-69087d08d473\src\share\vm/utilities/elfFuncDescTable.hpp
#ifndef SHARE_VM_UTILITIES_ELF_FUNC_DESC_TABLE_HPP
#define SHARE_VM_UTILITIES_ELF_FUNC_DESC_TABLE_HPP
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "memory/allocation.hpp"
#include "utilities/decoder.hpp"
#include "utilities/elfFile.hpp"
On PowerPC-64 (and other architectures like for example IA64) a pointer to a
function is not just a plain code address, but instead a pointer to a so called
function descriptor (which is simply a structure containing 3 pointers).
This fact is also reflected in the ELF ABI for PowerPC-64.
On architectures like x86 or SPARC, the ELF symbol table contains the start
address and size of an object. So for example for a function object (i.e. type
'STT_FUNC') the symbol table's 'st_value' and 'st_size' fields directly
represent the starting address and size of that function. On PPC64 however, the
symbol table's 'st_value' field only contains an index into another, PPC64
specific '.opd' (official procedure descriptors) section, while the 'st_size'
field still holds the size of the corresponding function. In order to get the
actual start address of a function, it is necessary to read the corresponding
function descriptor entry in the '.opd' section at the corresponding index and
extract the start address from there.
That's exactly what this 'ElfFuncDescTable' class is used for. If the HotSpot
runs on a PPC64 machine, and the corresponding ELF files contains an '.opd'
section (which is actually mandatory on PPC64) it will be read into an object
of type 'ElfFuncDescTable' just like the string and symbol table sections.
Later on, during symbol lookup in 'ElfSymbolTable::lookup()' this function
descriptor table will be used if available to find the real function address.
All this is how things work today (2013) on contemporary Linux distributions
(i.e. SLES 10) and new version of GCC (i.e. > 4.0). However there is a history,
and it goes like this:
In SLES 9 times (sometimes before GCC 3.4) gcc/ld on PPC64 generated two
entries in the symbol table for every function. The value of the symbol with
the name of the function was the address of the function descriptor while the
dot '.' prefixed name was reserved to hold the actual address of that function
(http://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi-1.9.html#FUNC-DES).
For a C-function 'foo' this resulted in two symbol table entries like this
(extracted from the output of 'readelf -a <lib.so>'):
Section Headers:
[ 9] .text PROGBITS 0000000000000a20 00000a20
00000000000005a0 0000000000000000 AX 0 0 16
[21] .opd PROGBITS 00000000000113b8 000013b8
0000000000000138 0000000000000000 WA 0 0 8
Symbol table '.symtab' contains 86 entries:
Num: Value Size Type Bind Vis Ndx Name
76: 00000000000114c0 24 FUNC GLOBAL DEFAULT 21 foo
78: 0000000000000bb0 76 FUNC GLOBAL DEFAULT 9 .foo
You can see now that the '.foo' entry actually points into the '.text' segment
('Ndx'=9) and its value and size fields represent the functions actual address
and size. On the other hand, the entry for plain 'foo' points into the '.opd'
section ('Ndx'=21) and its value and size fields are the index into the '.opd'
section and the size of the corresponding '.opd' section entry (3 pointers on
PPC64).
These so called 'dot symbols' were dropped around gcc 3.4 from GCC and BINUTILS,
see http://gcc.gnu.org/ml/gcc-patches/2004-08/msg00557.html.
But nevertheless it may still be necessary to support both formats because we
either run on an old system or because it is possible at any time that functions
appear in the stack trace which come from old-style libraries.
Therefore we not only have to check for the presence of the function descriptor
table during symbol lookup in 'ElfSymbolTable::lookup()'. We additionally have
to check that the symbol table entry references the '.opd' section. Only in
that case we can resolve the actual function address from there. Otherwise we
use the plain 'st_value' field from the symbol table as function address. This
way we can also lookup the symbols in old-style ELF libraries (although we get
the 'dotted' versions in that case). However, if present, the 'dot' will be
conditionally removed on PPC64 from the symbol in 'ElfDecoder::demangle()' in
decoder_linux.cpp.
Notice that we can not reliably get the function address from old-style
libraries because the 'st_value' field of the symbol table entries which point
into the '.opd' section denote the size of the corresponding '.opd' entry and
not that of the corresponding function. This has changed for the symbol table
entries in new-style libraries as described at the beginning of this
documentation.
class ElfFuncDescTable: public CHeapObj<mtInternal> {
friend class ElfFile;
public:
ElfFuncDescTable(FILE* file, Elf_Shdr shdr, int index);
~ElfFuncDescTable();
address lookup(Elf_Word index);
int get_index() { return m_index; };
NullDecoder::decoder_status get_status() { return m_status; };
protected:
address* m_funcDescs;
FILE* m_file;
Elf_Shdr m_shdr;
int m_index;
NullDecoder::decoder_status m_status;
};
#endif // !_WINDOWS && !__APPLE__
#endif // SHARE_VM_UTILITIES_ELF_FUNC_DESC_TABLE_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/elfStringTable.cpp
#include "precompiled.hpp"
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "memory/allocation.inline.hpp"
#include "runtime/os.hpp"
#include "utilities/elfStringTable.hpp"
ElfStringTable::ElfStringTable(FILE* file, Elf_Shdr shdr, int index) {
assert(file, "null file handle");
m_table = NULL;
m_index = index;
m_next = NULL;
m_file = file;
m_status = NullDecoder::no_error;
long cur_offset = ftell(file);
m_table = (char*)os::malloc(sizeof(char) * shdr.sh_size, mtInternal);
if (m_table != NULL) {
if (fseek(file, shdr.sh_offset, SEEK_SET) ||
fread((void*)m_table, shdr.sh_size, 1, file) != 1 ||
fseek(file, cur_offset, SEEK_SET)) {
m_status = NullDecoder::file_invalid;
os::free((void*)m_table);
m_table = NULL;
}
} else {
memcpy(&m_shdr, &shdr, sizeof(Elf_Shdr));
}
}
ElfStringTable::~ElfStringTable() {
if (m_table != NULL) {
os::free((void*)m_table);
}
if (m_next != NULL) {
delete m_next;
}
}
bool ElfStringTable::string_at(int pos, char* buf, int buflen) {
if (NullDecoder::is_error(m_status)) {
return false;
}
if (m_table != NULL) {
jio_snprintf(buf, buflen, "%s", (const char*)(m_table + pos));
return true;
} else {
long cur_pos = ftell(m_file);
if (cur_pos == -1 ||
fseek(m_file, m_shdr.sh_offset + pos, SEEK_SET) ||
fread(buf, 1, buflen, m_file) <= 0 ||
fseek(m_file, cur_pos, SEEK_SET)) {
m_status = NullDecoder::file_invalid;
return false;
}
return true;
}
}
#endif // !_WINDOWS && !__APPLE__
C:\hotspot-69087d08d473\src\share\vm/utilities/elfStringTable.hpp
#ifndef SHARE_VM_UTILITIES_ELF_STRING_TABLE_HPP
#define SHARE_VM_UTILITIES_ELF_STRING_TABLE_HPP
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "memory/allocation.hpp"
#include "utilities/decoder.hpp"
#include "utilities/elfFile.hpp"
class ElfStringTable: CHeapObj<mtInternal> {
friend class ElfFile;
public:
ElfStringTable(FILE* file, Elf_Shdr shdr, int index);
~ElfStringTable();
int index() { return m_index; };
bool string_at(int offset, char* buf, int buflen);
NullDecoder::decoder_status get_status() { return m_status; };
protected:
ElfStringTable* m_next;
int m_index;
const char* m_table;
FILE* m_file;
Elf_Shdr m_shdr;
NullDecoder::decoder_status m_status;
};
#endif // !_WINDOWS && !__APPLE__
#endif // SHARE_VM_UTILITIES_ELF_STRING_TABLE_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/elfSymbolTable.cpp
#include "precompiled.hpp"
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "memory/allocation.inline.hpp"
#include "utilities/elfFuncDescTable.hpp"
#include "utilities/elfSymbolTable.hpp"
ElfSymbolTable::ElfSymbolTable(FILE* file, Elf_Shdr shdr) {
assert(file, "null file handle");
m_symbols = NULL;
m_next = NULL;
m_file = file;
m_status = NullDecoder::no_error;
long cur_offset = ftell(file);
if (cur_offset != -1) {
m_symbols = (Elf_Sym*)os::malloc(shdr.sh_size, mtInternal);
if (m_symbols) {
if (fseek(file, shdr.sh_offset, SEEK_SET) ||
fread((void*)m_symbols, shdr.sh_size, 1, file) != 1 ||
fseek(file, cur_offset, SEEK_SET)) {
m_status = NullDecoder::file_invalid;
os::free(m_symbols);
m_symbols = NULL;
}
}
if (!NullDecoder::is_error(m_status)) {
memcpy(&m_shdr, &shdr, sizeof(Elf_Shdr));
}
} else {
m_status = NullDecoder::file_invalid;
}
}
ElfSymbolTable::~ElfSymbolTable() {
if (m_symbols != NULL) {
os::free(m_symbols);
}
if (m_next != NULL) {
delete m_next;
}
}
bool ElfSymbolTable::lookup(address addr, int* stringtableIndex, int* posIndex, int* offset, ElfFuncDescTable* funcDescTable) {
assert(stringtableIndex, "null string table index pointer");
assert(posIndex, "null string table offset pointer");
assert(offset, "null offset pointer");
if (NullDecoder::is_error(m_status)) {
return false;
}
size_t sym_size = sizeof(Elf_Sym);
assert((m_shdr.sh_size % sym_size) == 0, "check size");
int count = m_shdr.sh_size / sym_size;
if (m_symbols != NULL) {
for (int index = 0; index < count; index ++) {
if (STT_FUNC == ELF_ST_TYPE(m_symbols[index].st_info)) {
Elf_Word st_size = m_symbols[index].st_size;
address sym_addr;
if (funcDescTable != NULL && funcDescTable->get_index() == m_symbols[index].st_shndx) {
sym_addr = funcDescTable->lookup(m_symbols[index].st_value);
} else {
sym_addr = (address)m_symbols[index].st_value;
}
if (sym_addr <= addr && (Elf_Word)(addr - sym_addr) < st_size) {
return true;
}
}
}
} else {
long cur_pos;
if ((cur_pos = ftell(m_file)) == -1 ||
fseek(m_file, m_shdr.sh_offset, SEEK_SET)) {
m_status = NullDecoder::file_invalid;
return false;
}
Elf_Sym sym;
for (int index = 0; index < count; index ++) {
if (fread(&sym, sym_size, 1, m_file) == 1) {
if (STT_FUNC == ELF_ST_TYPE(sym.st_info)) {
Elf_Word st_size = sym.st_size;
address sym_addr;
if (funcDescTable != NULL && funcDescTable->get_index() == sym.st_shndx) {
sym_addr = funcDescTable->lookup(sym.st_value);
} else {
sym_addr = (address)sym.st_value;
}
if (sym_addr <= addr && (Elf_Word)(addr - sym_addr) < st_size) {
return true;
}
}
} else {
m_status = NullDecoder::file_invalid;
return false;
}
}
fseek(m_file, cur_pos, SEEK_SET);
}
return true;
}
#endif // !_WINDOWS && !__APPLE__
C:\hotspot-69087d08d473\src\share\vm/utilities/elfSymbolTable.hpp
#ifndef SHARE_VM_UTILITIES_ELF_SYMBOL_TABLE_HPP
#define SHARE_VM_UTILITIES_ELF_SYMBOL_TABLE_HPP
#if !defined(_WINDOWS) && !defined(__APPLE__)
#include "memory/allocation.hpp"
#include "utilities/decoder.hpp"
#include "utilities/elfFile.hpp"
class ElfSymbolTable: public CHeapObj<mtInternal> {
friend class ElfFile;
public:
ElfSymbolTable(FILE* file, Elf_Shdr shdr);
~ElfSymbolTable();
bool lookup(address addr, int* stringtableIndex, int* posIndex, int* offset, ElfFuncDescTable* funcDescTable);
NullDecoder::decoder_status get_status() { return m_status; };
protected:
ElfSymbolTable* m_next;
Elf_Sym* m_symbols;
FILE* m_file;
Elf_Shdr m_shdr;
NullDecoder::decoder_status m_status;
};
#endif // !_WINDOWS and !__APPLE__
#endif // SHARE_VM_UTILITIES_ELF_SYMBOL_TABLE_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/errorReporter.cpp
#include "precompiled.hpp"
#include "utilities/errorReporter.hpp"
ErrorReporter::ErrorReporter() {}
void ErrorReporter::call(FILE* fd, char* buffer, int length) {
}
C:\hotspot-69087d08d473\src\share\vm/utilities/errorReporter.hpp
#ifndef SHARE_VM_UTILITIES_ERRORREPORTER_HPP
#define SHARE_VM_UTILITIES_ERRORREPORTER_HPP
#include "utilities/globalDefinitions.hpp"
#include "memory/allocation.hpp"
class ErrorReporter : public StackObj {
public:
ErrorReporter();
~ErrorReporter(){};
void call(FILE* fd, char *buffer, int length);
};
#endif // ndef SHARE_VM_UTILITIES_ERRORREPORTER_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/events.cpp
#include "precompiled.hpp"
#include "memory/allocation.inline.hpp"
#include "runtime/mutexLocker.hpp"
#include "runtime/osThread.hpp"
#include "runtime/thread.inline.hpp"
#include "runtime/threadCritical.hpp"
#include "runtime/threadLocalStorage.hpp"
#include "runtime/timer.hpp"
#include "utilities/events.hpp"
EventLog* Events::_logs = NULL;
StringEventLog* Events::_messages = NULL;
StringEventLog* Events::_exceptions = NULL;
StringEventLog* Events::_redefinitions = NULL;
StringEventLog* Events::_deopt_messages = NULL;
EventLog::EventLog() {
ThreadCritical tc;
_next = Events::_logs;
Events::_logs = this;
}
void Events::print_all(outputStream* out) {
EventLog* log = _logs;
while (log != NULL) {
log->print_log_on(out);
log = log->next();
}
}
void Events::print() {
print_all(tty);
}
void Events::init() {
if (LogEvents) {
_messages = new StringEventLog("Events");
_exceptions = new StringEventLog("Internal exceptions");
_redefinitions = new StringEventLog("Classes redefined");
_deopt_messages = new StringEventLog("Deoptimization events");
}
}
void eventlog_init() {
Events::init();
}
EventMark::EventMark(const char* format, ...) {
if (LogEvents) {
va_list ap;
va_start(ap, format);
_buffer.printv(format, ap);
Events::log(NULL, "%s", _buffer.buffer());
va_end(ap);
}
}
EventMark::~EventMark() {
if (LogEvents) {
_buffer.append(" done");
Events::log(NULL, "%s", _buffer.buffer());
}
}
C:\hotspot-69087d08d473\src\share\vm/utilities/events.hpp
#ifndef SHARE_VM_UTILITIES_EVENTS_HPP
#define SHARE_VM_UTILITIES_EVENTS_HPP
#include "memory/allocation.hpp"
#include "runtime/mutexLocker.hpp"
#include "runtime/thread.hpp"
#include "utilities/top.hpp"
#include "utilities/vmError.hpp"
class EventLog : public CHeapObj<mtInternal> {
friend class Events;
private:
EventLog* _next;
EventLog* next() const { return _next; }
public:
EventLog();
virtual void print_log_on(outputStream* out) = 0;
};
template <class T> class EventLogBase : public EventLog {
template <class X> class EventRecord : public CHeapObj<mtInternal> {
public:
double timestamp;
Thread* thread;
X data;
};
protected:
Mutex _mutex;
const char* _name;
int _length;
int _index;
int _count;
EventRecord<T>* _records;
public:
EventLogBase<T>(const char* name, int length = LogEventsBufferEntries):
_name(name),
_length(length),
_count(0),
_index(0),
_mutex(Mutex::event, name) {
_records = new EventRecord<T>[length];
}
double fetch_timestamp() {
return os::elapsedTime();
}
int compute_log_index() {
int index = _index;
if (_count < _length) _count++;
_index++;
if (_index >= _length) _index = 0;
return index;
}
bool should_log() {
return !VMError::fatal_error_in_progress();
}
void print_log_on(outputStream* out);
private:
void print_log_impl(outputStream* out);
void print(outputStream* out, T& e);
void print(outputStream* out, EventRecord<T>& e) {
out->print("Event: %.3f ", e.timestamp);
if (e.thread != NULL) {
out->print("Thread " INTPTR_FORMAT " ", p2i(e.thread));
}
print(out, e.data);
}
};
class StringLogMessage : public FormatBuffer<256> {
public:
stringStream stream() {
return stringStream(_buf, size());
}
};
class StringEventLog : public EventLogBase<StringLogMessage> {
public:
StringEventLog(const char* name, int count = LogEventsBufferEntries) : EventLogBase<StringLogMessage>(name, count) {}
void logv(Thread* thread, const char* format, va_list ap) ATTRIBUTE_PRINTF(3, 0) {
if (!should_log()) return;
double timestamp = fetch_timestamp();
MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);
int index = compute_log_index();
_records[index].thread = thread;
_records[index].timestamp = timestamp;
_records[index].data.printv(format, ap);
}
void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(3, 4) {
va_list ap;
va_start(ap, format);
logv(thread, format, ap);
va_end(ap);
}
};
class Events : AllStatic {
friend class EventLog;
private:
static EventLog* _logs;
static StringEventLog* _messages;
static StringEventLog* _exceptions;
static StringEventLog* _deopt_messages;
static StringEventLog* _redefinitions;
public:
static void print_all(outputStream* out);
static void print();
static void log(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
static void log_exception(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
static void log_redefinition(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
static void log_deopt_message(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
static void init();
};
inline void Events::log(Thread* thread, const char* format, ...) {
if (LogEvents) {
va_list ap;
va_start(ap, format);
_messages->logv(thread, format, ap);
va_end(ap);
}
}
inline void Events::log_exception(Thread* thread, const char* format, ...) {
if (LogEvents) {
va_list ap;
va_start(ap, format);
_exceptions->logv(thread, format, ap);
va_end(ap);
}
}
inline void Events::log_redefinition(Thread* thread, const char* format, ...) {
if (LogEvents) {
va_list ap;
va_start(ap, format);
_redefinitions->logv(thread, format, ap);
va_end(ap);
}
}
inline void Events::log_deopt_message(Thread* thread, const char* format, ...) {
if (LogEvents) {
va_list ap;
va_start(ap, format);
_deopt_messages->logv(thread, format, ap);
va_end(ap);
}
}
template <class T>
inline void EventLogBase<T>::print_log_on(outputStream* out) {
if (ThreadLocalStorage::get_thread_slow() == NULL) {
print_log_impl(out);
} else {
MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);
print_log_impl(out);
}
}
template <class T>
inline void EventLogBase<T>::print_log_impl(outputStream* out) {
out->print_cr("%s (%d events):", _name, _count);
if (_count == 0) {
out->print_cr("No events");
out->cr();
return;
}
if (_count < _length) {
for (int i = 0; i < _count; i++) {
print(out, _records[i]);
}
} else {
for (int i = _index; i < _length; i++) {
print(out, _records[i]);
}
for (int i = 0; i < _index; i++) {
print(out, _records[i]);
}
}
out->cr();
}
template <>
inline void EventLogBase<StringLogMessage>::print(outputStream* out, StringLogMessage& lm) {
out->print_raw(lm);
out->cr();
}
class EventMark : public StackObj {
StringLogMessage _buffer;
public:
EventMark(const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
~EventMark();
};
#endif // SHARE_VM_UTILITIES_EVENTS_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/exceptions.cpp
#include "precompiled.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/vmSymbols.hpp"
#include "compiler/compileBroker.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/init.hpp"
#include "runtime/java.hpp"
#include "runtime/javaCalls.hpp"
#include "runtime/os.hpp"
#include "runtime/thread.inline.hpp"
#include "runtime/threadCritical.hpp"
#include "utilities/events.hpp"
#include "utilities/exceptions.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
void check_ThreadShadow() {
const ByteSize offset1 = byte_offset_of(ThreadShadow, _pending_exception);
const ByteSize offset2 = Thread::pending_exception_offset();
if (offset1 != offset2) fatal("ThreadShadow::_pending_exception is not positioned correctly");
}
void ThreadShadow::set_pending_exception(oop exception, const char* file, int line) {
assert(exception != NULL && exception->is_oop(), "invalid exception oop");
_pending_exception = exception;
_exception_file = file;
_exception_line = line;
}
void ThreadShadow::clear_pending_exception() {
if (TraceClearedExceptions) {
if (_pending_exception != NULL) {
tty->print_cr("Thread::clear_pending_exception: cleared exception:");
_pending_exception->print();
}
}
_pending_exception = NULL;
_exception_file = NULL;
_exception_line = 0;
}
bool Exceptions::special_exception(Thread* thread, const char* file, int line, Handle h_exception) {
if (!Universe::is_fully_initialized()) {
vm_exit_during_initialization(h_exception);
ShouldNotReachHere();
}
#ifdef ASSERT
if (h_exception()->klass() == SystemDictionary::StackOverflowError_klass()) {
InstanceKlass* ik = InstanceKlass::cast(h_exception->klass());
assert(ik->is_initialized(),
"need to increase min_stack_allowed calculation");
}
#endif // ASSERT
if (thread->is_VM_thread()
|| thread->is_Compiler_thread()
|| DumpSharedSpaces ) {
thread->set_pending_exception(Universe::vm_exception(), file, line);
return true;
}
return false;
}
bool Exceptions::special_exception(Thread* thread, const char* file, int line, Symbol* h_name, const char* message) {
if (!Universe::is_fully_initialized()) {
if (h_name == NULL) {
vm_exit_during_initialization("Exception", message);
} else {
vm_exit_during_initialization(h_name, message);
}
ShouldNotReachHere();
}
if (thread->is_VM_thread()
|| thread->is_Compiler_thread()
|| DumpSharedSpaces ) {
thread->set_pending_exception(Universe::vm_exception(), file, line);
return true;
}
return false;
}
void Exceptions::_throw_oop(Thread* thread, const char* file, int line, oop exception) {
assert(exception != NULL, "exception should not be NULL");
Handle h_exception = Handle(thread, exception);
_throw(thread, file, line, h_exception);
}
void Exceptions::_throw(Thread* thread, const char* file, int line, Handle h_exception, const char* message) {
ResourceMark rm;
assert(h_exception() != NULL, "exception should not be NULL");
if (TraceExceptions) {
ttyLocker ttyl;
tty->print_cr("Exception <%s%s%s> (" INTPTR_FORMAT ") \n"
"thrown [%s, line %d]\nfor thread " INTPTR_FORMAT,
h_exception->print_value_string(),
message ? ": " : "", message ? message : "",
(address)h_exception(), file, line, thread);
}
NOT_PRODUCT(Exceptions::debug_check_abort(h_exception, message));
if (special_exception(thread, file, line, h_exception)) {
return;
}
if (h_exception->is_a(SystemDictionary::OutOfMemoryError_klass())) {
count_out_of_memory_exceptions(h_exception);
}
assert(h_exception->is_a(SystemDictionary::Throwable_klass()), "exception is not a subclass of java/lang/Throwable");
thread->set_pending_exception(h_exception(), file, line);
Events::log_exception(thread, "Exception <%s%s%s> (" INTPTR_FORMAT ") thrown at [%s, line %d]",
h_exception->print_value_string(), message ? ": " : "", message ? message : "",
(address)h_exception(), file, line);
}
void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message,
Handle h_loader, Handle h_protection_domain) {
if (special_exception(thread, file, line, name, message)) return;
Handle h_cause(thread, NULL);
Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain);
_throw(thread, file, line, h_exception, message);
}
void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause,
Handle h_loader, Handle h_protection_domain) {
if (special_exception(thread, file, line, name, message)) return;
Handle h_exception = new_exception(thread, name, message, h_cause, h_loader, h_protection_domain);
_throw(thread, file, line, h_exception, message);
}
void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause,
Handle h_loader, Handle h_protection_domain) {
if (special_exception(thread, file, line, h_cause)) return;
Handle h_exception = new_exception(thread, name, h_cause, h_loader, h_protection_domain);
_throw(thread, file, line, h_exception, NULL);
}
void Exceptions::_throw_args(Thread* thread, const char* file, int line, Symbol* name, Symbol* signature, JavaCallArguments *args) {
if (special_exception(thread, file, line, name, NULL)) return;
Handle h_loader(thread, NULL);
Handle h_prot(thread, NULL);
Handle exception = new_exception(thread, name, signature, args, h_loader, h_prot);
_throw(thread, file, line, exception);
}
void Exceptions::_throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause) {
_throw_msg_cause(thread, file, line, name, message, h_cause, Handle(thread, NULL), Handle(thread, NULL));
}
void Exceptions::_throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message) {
_throw_msg(thread, file, line, name, message, Handle(thread, NULL), Handle(thread, NULL));
}
void Exceptions::_throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause) {
_throw_cause(thread, file, line, name, h_cause, Handle(thread, NULL), Handle(thread, NULL));
}
void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file, int line, methodHandle method) {
Handle exception;
if (!THREAD->has_pending_exception()) {
Klass* k = SystemDictionary::StackOverflowError_klass();
oop e = InstanceKlass::cast(k)->allocate_instance(CHECK);
exception = Handle(THREAD, e); // fill_in_stack trace does gc
assert(InstanceKlass::cast(k)->is_initialized(), "need to increase min_stack_allowed calculation");
if (StackTraceInThrowable) {
java_lang_Throwable::fill_in_stack_trace(exception, method());
}
Atomic::inc(&Exceptions::_stack_overflow_errors);
} else {
exception = Handle(THREAD, THREAD->pending_exception());
}
_throw(THREAD, file, line, exception);
}
void Exceptions::fthrow(Thread* thread, const char* file, int line, Symbol* h_name, const char* format, ...) {
const int max_msg_size = 1024;
va_list ap;
va_start(ap, format);
char msg[max_msg_size];
os::vsnprintf(msg, max_msg_size, format, ap);
va_end(ap);
_throw_msg(thread, file, line, h_name, msg);
}
Handle Exceptions::new_exception(Thread *thread, Symbol* name,
Symbol* signature, JavaCallArguments *args,
Handle h_loader, Handle h_protection_domain) {
assert(Universe::is_fully_initialized(),
"cannot be called during initialization");
assert(thread->is_Java_thread(), "can only be called by a Java thread");
assert(!thread->has_pending_exception(), "already has exception");
Handle h_exception;
Klass* ik = SystemDictionary::resolve_or_fail(name, h_loader, h_protection_domain, true, thread);
instanceKlassHandle klass(thread, ik);
if (!thread->has_pending_exception()) {
assert(klass.not_null(), "klass must exist");
klass->initialize(thread);
if (!thread->has_pending_exception()) {
h_exception = klass->allocate_instance_handle(thread);
if (!thread->has_pending_exception()) {
JavaValue result(T_VOID);
args->set_receiver(h_exception);
JavaCalls::call_special(&result, klass,
vmSymbols::object_initializer_name(),
signature,
args,
thread);
}
}
}
if (thread->has_pending_exception()) {
h_exception = Handle(thread, thread->pending_exception());
thread->clear_pending_exception();
}
return h_exception;
}
Handle Exceptions::new_exception(Thread *thread, Symbol* name,
Symbol* signature, JavaCallArguments *args,
Handle h_cause,
Handle h_loader, Handle h_protection_domain) {
Handle h_exception = new_exception(thread, name, signature, args, h_loader, h_protection_domain);
if (h_cause.not_null()) {
assert(h_cause->is_a(SystemDictionary::Throwable_klass()),
"exception cause is not a subclass of java/lang/Throwable");
JavaValue result1(T_OBJECT);
JavaCallArguments args1;
args1.set_receiver(h_exception);
args1.push_oop(h_cause);
JavaCalls::call_virtual(&result1, h_exception->klass(),
vmSymbols::initCause_name(),
vmSymbols::throwable_throwable_signature(),
&args1,
thread);
}
if (thread->has_pending_exception()) {
h_exception = Handle(thread, thread->pending_exception());
thread->clear_pending_exception();
}
return h_exception;
}
Handle Exceptions::new_exception(Thread* thread, Symbol* name,
Handle h_cause,
Handle h_loader, Handle h_protection_domain,
ExceptionMsgToUtf8Mode to_utf8_safe) {
JavaCallArguments args;
Symbol* signature = NULL;
if (h_cause.is_null()) {
signature = vmSymbols::void_method_signature();
} else {
signature = vmSymbols::throwable_void_signature();
args.push_oop(h_cause);
}
return new_exception(thread, name, signature, &args, h_loader, h_protection_domain);
}
Handle Exceptions::new_exception(Thread* thread, Symbol* name,
const char* message, Handle h_cause,
Handle h_loader, Handle h_protection_domain,
ExceptionMsgToUtf8Mode to_utf8_safe) {
JavaCallArguments args;
Symbol* signature = NULL;
if (message == NULL) {
signature = vmSymbols::void_method_signature();
} else {
Handle incoming_exception(thread, NULL);
if (thread->has_pending_exception()) {
incoming_exception = Handle(thread, thread->pending_exception());
thread->clear_pending_exception();
}
Handle msg;
if (to_utf8_safe == safe_to_utf8) {
msg = java_lang_String::create_from_str(message, thread);
} else {
msg = java_lang_String::create_from_platform_dependent_str(message, thread);
}
if (thread->has_pending_exception()) {
Handle exception(thread, thread->pending_exception());
thread->clear_pending_exception();
return exception;
}
if (incoming_exception.not_null()) {
return incoming_exception;
}
args.push_oop(msg);
signature = vmSymbols::string_void_signature();
}
return new_exception(thread, name, signature, &args, h_cause, h_loader, h_protection_domain);
}
Handle Exceptions::new_exception(Thread* thread, Symbol* name,
const char* message,
ExceptionMsgToUtf8Mode to_utf8_safe) {
Handle h_loader(thread, NULL);
Handle h_prot(thread, NULL);
Handle h_cause(thread, NULL);
return Exceptions::new_exception(thread, name, message, h_cause, h_loader,
h_prot, to_utf8_safe);
}
volatile int Exceptions::_stack_overflow_errors = 0;
volatile int Exceptions::_out_of_memory_error_java_heap_errors = 0;
volatile int Exceptions::_out_of_memory_error_metaspace_errors = 0;
volatile int Exceptions::_out_of_memory_error_class_metaspace_errors = 0;
void Exceptions::count_out_of_memory_exceptions(Handle exception) {
if (exception() == Universe::out_of_memory_error_metaspace()) {
Atomic::inc(&_out_of_memory_error_metaspace_errors);
} else if (exception() == Universe::out_of_memory_error_class_metaspace()) {
Atomic::inc(&_out_of_memory_error_class_metaspace_errors);
} else {
Atomic::inc(&_out_of_memory_error_java_heap_errors);
}
}
void print_oom_count(outputStream* st, const char *err, int count) {
if (count > 0) {
st->print_cr("OutOfMemoryError %s=%d", err, count);
}
}
bool Exceptions::has_exception_counts() {
return (_stack_overflow_errors + _out_of_memory_error_java_heap_errors +
_out_of_memory_error_metaspace_errors + _out_of_memory_error_class_metaspace_errors) > 0;
}
void Exceptions::print_exception_counts_on_error(outputStream* st) {
print_oom_count(st, "java_heap_errors", _out_of_memory_error_java_heap_errors);
print_oom_count(st, "metaspace_errors", _out_of_memory_error_metaspace_errors);
print_oom_count(st, "class_metaspace_errors", _out_of_memory_error_class_metaspace_errors);
if (_stack_overflow_errors > 0) {
st->print_cr("StackOverflowErrors=%d", _stack_overflow_errors);
}
}
ExceptionMark::ExceptionMark(Thread*& thread) {
thread = Thread::current();
_thread = thread;
if (_thread->has_pending_exception()) {
oop exception = _thread->pending_exception();
_thread->clear_pending_exception(); // Needed to avoid infinite recursion
exception->print();
fatal("ExceptionMark constructor expects no pending exceptions");
}
}
ExceptionMark::~ExceptionMark() {
if (_thread->has_pending_exception()) {
Handle exception(_thread, _thread->pending_exception());
_thread->clear_pending_exception(); // Needed to avoid infinite recursion
if (is_init_completed()) {
exception->print();
fatal("ExceptionMark destructor expects no pending exceptions");
} else {
vm_exit_during_initialization(exception);
}
}
}
#ifndef PRODUCT
void Exceptions::debug_check_abort(const char *value_string, const char* message) {
if (AbortVMOnException != NULL && value_string != NULL &&
strstr(value_string, AbortVMOnException)) {
if (AbortVMOnExceptionMessage == NULL || message == NULL ||
strcmp(message, AbortVMOnExceptionMessage) == 0) {
fatal(err_msg("Saw %s, aborting", value_string));
}
}
}
void Exceptions::debug_check_abort(Handle exception, const char* message) {
if (AbortVMOnException != NULL) {
ResourceMark rm;
if (message == NULL && exception->is_a(SystemDictionary::Throwable_klass())) {
oop msg = java_lang_Throwable::message(exception);
if (msg != NULL) {
message = java_lang_String::as_utf8_string(msg);
}
}
debug_check_abort(InstanceKlass::cast(exception()->klass())->external_name(), message);
}
}
#endif
C:\hotspot-69087d08d473\src\share\vm/utilities/exceptions.hpp
#ifndef SHARE_VM_UTILITIES_EXCEPTIONS_HPP
#define SHARE_VM_UTILITIES_EXCEPTIONS_HPP
#include "memory/allocation.hpp"
#include "oops/oopsHierarchy.hpp"
#include "utilities/sizes.hpp"
class Thread;
class Handle;
class Symbol;
class JavaCallArguments;
class ThreadShadow: public CHeapObj<mtThread> {
friend class VMStructs;
protected:
oop _pending_exception; // Thread has gc actions.
const char* _exception_file; // file information for exception (debugging only)
int _exception_line; // line information for exception (debugging only)
friend void check_ThreadShadow(); // checks _pending_exception offset
virtual void unused_initial_virtual() { }
public:
oop pending_exception() const { return _pending_exception; }
bool has_pending_exception() const { return _pending_exception != NULL; }
const char* exception_file() const { return _exception_file; }
int exception_line() const { return _exception_line; }
static ByteSize pending_exception_offset() { return byte_offset_of(ThreadShadow, _pending_exception); }
void set_pending_exception(oop exception, const char* file, int line);
void clear_pending_exception();
ThreadShadow() : _pending_exception(NULL),
_exception_file(NULL), _exception_line(0) {}
};
class Exceptions {
static bool special_exception(Thread *thread, const char* file, int line, Handle exception);
static bool special_exception(Thread* thread, const char* file, int line, Symbol* name, const char* message);
static volatile int _out_of_memory_error_java_heap_errors;
static volatile int _out_of_memory_error_metaspace_errors;
static volatile int _out_of_memory_error_class_metaspace_errors;
public:
typedef enum {
safe_to_utf8 = 0,
unsafe_to_utf8 = 1
} ExceptionMsgToUtf8Mode;
static void _throw_oop(Thread* thread, const char* file, int line, oop exception);
static void _throw(Thread* thread, const char* file, int line, Handle exception, const char* msg = NULL);
static void _throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message);
static void _throw_msg(Thread* thread, const char* file, int line, Symbol* name, const char* message,
Handle loader, Handle protection_domain);
static void _throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause);
static void _throw_msg_cause(Thread* thread, const char* file, int line, Symbol* name, const char* message, Handle h_cause,
Handle h_loader, Handle h_protection_domain);
static void _throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause);
static void _throw_cause(Thread* thread, const char* file, int line, Symbol* name, Handle h_cause,
Handle h_loader, Handle h_protection_domain);
static void _throw_args(Thread* thread, const char* file, int line,
Symbol* name, Symbol* signature,
JavaCallArguments* args);
static void fthrow(Thread* thread, const char* file, int line, Symbol* name,
const char* format, ...) ATTRIBUTE_PRINTF(5, 6);
static Handle new_exception(Thread* thread, Symbol* name,
Symbol* signature, JavaCallArguments* args,
Handle loader, Handle protection_domain);
static Handle new_exception(Thread* thread, Symbol* name,
Symbol* signature, JavaCallArguments* args,
Handle cause,
Handle loader, Handle protection_domain);
static Handle new_exception(Thread* thread, Symbol* name,
Handle cause,
Handle loader, Handle protection_domain,
ExceptionMsgToUtf8Mode to_utf8_safe = safe_to_utf8);
static Handle new_exception(Thread* thread, Symbol* name,
const char* message, Handle cause,
Handle loader, Handle protection_domain,
ExceptionMsgToUtf8Mode to_utf8_safe = safe_to_utf8);
static Handle new_exception(Thread* thread, Symbol* name,
const char* message,
ExceptionMsgToUtf8Mode to_utf8_safe = safe_to_utf8);
static void throw_stack_overflow_exception(Thread* thread, const char* file, int line, methodHandle method);
static volatile int _stack_overflow_errors;
static bool has_exception_counts();
static void count_out_of_memory_exceptions(Handle exception);
static void print_exception_counts_on_error(outputStream* st);
NOT_PRODUCT(static void debug_check_abort(Handle exception, const char* message = NULL);)
NOT_PRODUCT(static void debug_check_abort(const char *value_string, const char* message = NULL);)
};
#define THREAD __the_thread__
#define TRAPS Thread* THREAD
#define PENDING_EXCEPTION (((ThreadShadow*)THREAD)->pending_exception())
#define HAS_PENDING_EXCEPTION (((ThreadShadow*)THREAD)->has_pending_exception())
#define CLEAR_PENDING_EXCEPTION (((ThreadShadow*)THREAD)->clear_pending_exception())
#define CHECK THREAD); if (HAS_PENDING_EXCEPTION) return ; (void)(0
#define CHECK_(result) THREAD); if (HAS_PENDING_EXCEPTION) return result; (void)(0
#define CHECK_0 CHECK_(0)
#define CHECK_NH CHECK_(Handle())
#define CHECK_NULL CHECK_(NULL)
#define CHECK_false CHECK_(false)
#define CHECK_AND_CLEAR THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; return; } (void)(0
#define CHECK_AND_CLEAR_(result) THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; return result; } (void)(0
#define CHECK_AND_CLEAR_0 CHECK_AND_CLEAR_(0)
#define CHECK_AND_CLEAR_NH CHECK_AND_CLEAR_(Handle())
#define CHECK_AND_CLEAR_NULL CHECK_AND_CLEAR_(NULL)
#define CHECK_AND_CLEAR_false CHECK_AND_CLEAR_(false)
#define THREAD_AND_LOCATION THREAD, __FILE__, __LINE__
#define THROW_OOP(e) \
{ Exceptions::_throw_oop(THREAD_AND_LOCATION, e); return; }
#define THROW_HANDLE(e) \
{ Exceptions::_throw(THREAD_AND_LOCATION, e); return; }
#define THROW(name) \
{ Exceptions::_throw_msg(THREAD_AND_LOCATION, name, NULL); return; }
#define THROW_MSG(name, message) \
{ Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message); return; }
#define THROW_CAUSE(name, cause) \
{ Exceptions::_throw_cause(THREAD_AND_LOCATION, name, cause); return; }
#define THROW_MSG_LOADER(name, message, loader, protection_domain) \
{ Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message, loader, protection_domain); return; }
#define THROW_ARG(name, signature, args) \
{ Exceptions::_throw_args(THREAD_AND_LOCATION, name, signature, args); return; }
#define THROW_OOP_(e, result) \
{ Exceptions::_throw_oop(THREAD_AND_LOCATION, e); return result; }
#define THROW_HANDLE_(e, result) \
{ Exceptions::_throw(THREAD_AND_LOCATION, e); return result; }
#define THROW_(name, result) \
{ Exceptions::_throw_msg(THREAD_AND_LOCATION, name, NULL); return result; }
#define THROW_MSG_(name, message, result) \
{ Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message); return result; }
#define THROW_MSG_LOADER_(name, message, loader, protection_domain, result) \
{ Exceptions::_throw_msg(THREAD_AND_LOCATION, name, message, loader, protection_domain); return result; }
#define THROW_ARG_(name, signature, args, result) \
{ Exceptions::_throw_args(THREAD_AND_LOCATION, name, signature, args); return result; }
#define THROW_MSG_CAUSE(name, message, cause) \
{ Exceptions::_throw_msg_cause(THREAD_AND_LOCATION, name, message, cause); return; }
#define THROW_MSG_CAUSE_(name, message, cause, result) \
{ Exceptions::_throw_msg_cause(THREAD_AND_LOCATION, name, message, cause); return result; }
#define THROW_OOP_0(e) THROW_OOP_(e, 0)
#define THROW_HANDLE_0(e) THROW_HANDLE_(e, 0)
#define THROW_0(name) THROW_(name, 0)
#define THROW_MSG_0(name, message) THROW_MSG_(name, message, 0)
#define THROW_WRAPPED_0(name, oop_to_wrap) THROW_WRAPPED_(name, oop_to_wrap, 0)
#define THROW_ARG_0(name, signature, arg) THROW_ARG_(name, signature, arg, 0)
#define THROW_MSG_CAUSE_0(name, message, cause) THROW_MSG_CAUSE_(name, message, cause, 0)
#define THROW_MSG_CAUSE_NULL(name, message, cause) THROW_MSG_CAUSE_(name, message, cause, NULL)
#define THROW_NULL(name) THROW_(name, NULL)
#define THROW_MSG_NULL(name, message) THROW_MSG_(name, message, NULL)
#define CATCH \
THREAD); if (HAS_PENDING_EXCEPTION) { \
oop ex = PENDING_EXCEPTION; \
CLEAR_PENDING_EXCEPTION; \
ex->print(); \
ShouldNotReachHere(); \
} (void)(0
class ExceptionMark {
private:
Thread* _thread;
public:
ExceptionMark(Thread*& thread);
~ExceptionMark();
};
#define EXCEPTION_MARK Thread* THREAD = NULL; ExceptionMark __em(THREAD);
#endif // SHARE_VM_UTILITIES_EXCEPTIONS_HPP
C:\hotspot-69087d08d473\src\share\vm/utilities/globalDefinitions.cpp
#include "precompiled.hpp"
#include "runtime/os.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/top.hpp"
int heapOopSize = 0;
int LogBytesPerHeapOop = 0;
int LogBitsPerHeapOop = 0;
int BytesPerHeapOop = 0;
int BitsPerHeapOop = 0;
int MinObjAlignment = -1;
int MinObjAlignmentInBytes = -1;
int MinObjAlignmentInBytesMask = 0;
int LogMinObjAlignment = -1;
int LogMinObjAlignmentInBytes = -1;
uint64_t OopEncodingHeapMax = 0;
void basic_fatal(const char* msg) {
fatal(msg);
}
void basic_types_init() {
#ifdef ASSERT
#ifdef _LP64
assert(min_intx == (intx)CONST64(0x8000000000000000), "correct constant");
assert(max_intx == CONST64(0x7FFFFFFFFFFFFFFF), "correct constant");
assert(max_uintx == CONST64(0xFFFFFFFFFFFFFFFF), "correct constant");
assert( 8 == sizeof( intx), "wrong size for basic type");
assert( 8 == sizeof( jobject), "wrong size for basic type");
#else
assert(min_intx == (intx)0x80000000, "correct constant");
assert(max_intx == 0x7FFFFFFF, "correct constant");
assert(max_uintx == 0xFFFFFFFF, "correct constant");
assert( 4 == sizeof( intx), "wrong size for basic type");
assert( 4 == sizeof( jobject), "wrong size for basic type");
#endif
assert( (~max_juint) == 0, "max_juint has all its bits");
assert( (~max_uintx) == 0, "max_uintx has all its bits");
assert( (~max_julong) == 0, "max_julong has all its bits");
assert( 1 == sizeof( jbyte), "wrong size for basic type");
assert( 2 == sizeof( jchar), "wrong size for basic type");
assert( 2 == sizeof( jshort), "wrong size for basic type");
assert( 4 == sizeof( juint), "wrong size for basic type");
assert( 4 == sizeof( jint), "wrong size for basic type");
assert( 1 == sizeof( jboolean), "wrong size for basic type");
assert( 8 == sizeof( jlong), "wrong size for basic type");
assert( 4 == sizeof( jfloat), "wrong size for basic type");
assert( 8 == sizeof( jdouble), "wrong size for basic type");
assert( 1 == sizeof( u1), "wrong size for basic type");
assert( 2 == sizeof( u2), "wrong size for basic type");
assert( 4 == sizeof( u4), "wrong size for basic type");
int num_type_chars = 0;
for (int i = 0; i < 99; i++) {
if (type2char((BasicType)i) != 0) {
assert(char2type(type2char((BasicType)i)) == i, "proper inverses");
num_type_chars++;
}
}
assert(num_type_chars == 11, "must have tested the right number of mappings");
assert(char2type(0) == T_ILLEGAL, "correct illegality");
{
for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) {
BasicType vt = (BasicType)i;
BasicType ft = type2field[vt];
switch (vt) {
case T_BOOLEAN:
case T_BYTE:
case T_CHAR:
case T_SHORT:
case T_INT:
case T_FLOAT:
case T_DOUBLE:
case T_LONG:
case T_OBJECT:
case T_ADDRESS: // random raw pointer
case T_METADATA: // metadata pointer
case T_NARROWOOP: // compressed pointer
case T_NARROWKLASS: // compressed klass pointer
case T_CONFLICT: // might as well support a bottom type
case T_VOID: // padding or other unaddressed word
assert(vt == ft, "");
break;
default:
assert(vt != ft, "");
assert(ft == type2field[ft], "");
}
assert(type2size[vt] == type2size[ft], "");
}
}
assert(is_power_of_2(sizeof(juint)), "juint must be power of 2");
assert(is_power_of_2(HeapWordSize), "HeapWordSize must be power of 2");
assert((size_t)HeapWordSize >= sizeof(juint),
"HeapWord should be at least as large as juint");
assert(sizeof(NULL) == sizeof(char*), "NULL must be same size as pointer");
#endif
if( JavaPriority1_To_OSPriority != -1 )
os::java_to_os_priority[1] = JavaPriority1_To_OSPriority;
if( JavaPriority2_To_OSPriority != -1 )
os::java_to_os_priority[2] = JavaPriority2_To_OSPriority;
if( JavaPriority3_To_OSPriority != -1 )
os::java_to_os_priority[3] = JavaPriority3_To_OSPriority;
if( JavaPriority4_To_OSPriority != -1 )
os::java_to_os_priority[4] = JavaPriority4_To_OSPriority;
if( JavaPriority5_To_OSPriority != -1 )
os::java_to_os_priority[5] = JavaPriority5_To_OSPriority;
if( JavaPriority6_To_OSPriority != -1 )
os::java_to_os_priority[6] = JavaPriority6_To_OSPriority;
if( JavaPriority7_To_OSPriority != -1 )
os::java_to_os_priority[7] = JavaPriority7_To_OSPriority;
if( JavaPriority8_To_OSPriority != -1 )
os::java_to_os_priority[8] = JavaPriority8_To_OSPriority;
if( JavaPriority9_To_OSPriority != -1 )
os::java_to_os_priority[9] = JavaPriority9_To_OSPriority;
if(JavaPriority10_To_OSPriority != -1 )
os::java_to_os_priority[10] = JavaPriority10_To_OSPriority;
if (UseCompressedOops) {
heapOopSize = jintSize;
LogBytesPerHeapOop = LogBytesPerInt;
LogBitsPerHeapOop = LogBitsPerInt;
BytesPerHeapOop = BytesPerInt;
BitsPerHeapOop = BitsPerInt;
} else {
heapOopSize = oopSize;
LogBytesPerHeapOop = LogBytesPerWord;
LogBitsPerHeapOop = LogBitsPerWord;
BytesPerHeapOop = BytesPerWord;
BitsPerHeapOop = BitsPerWord;
}
_type2aelembytes[T_OBJECT] = heapOopSize;
_type2aelembytes[T_ARRAY] = heapOopSize;
}
char type2char_tab[T_CONFLICT+1]={ 0, 0, 0, 0, 'Z', 'C', 'F', 'D', 'B', 'S', 'I', 'J', 'L', '[', 'V', 0, 0, 0, 0, 0};
const char* type2name_tab[T_CONFLICT+1] = {
NULL, NULL, NULL, NULL,
"boolean",
"char",
"float",
"double",
"byte",
"short",
"int",
"long",
"object",
"array",
"void",
"*address*",
"*narrowoop*",
"*metadata*",
"*narrowklass*",
"*conflict*"
};
BasicType name2type(const char* name) {
for (int i = T_BOOLEAN; i <= T_VOID; i++) {
BasicType t = (BasicType)i;
if (type2name_tab[t] != NULL && 0 == strcmp(type2name_tab[t], name))
return t;
}
return T_ILLEGAL;
}
int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, -1};
BasicType type2field[T_CONFLICT+1] = {
(BasicType)0, // 0,
(BasicType)0, // 1,
(BasicType)0, // 2,
(BasicType)0, // 3,
T_BOOLEAN, // T_BOOLEAN = 4,
T_CHAR, // T_CHAR = 5,
T_FLOAT, // T_FLOAT = 6,
T_DOUBLE, // T_DOUBLE = 7,
T_BYTE, // T_BYTE = 8,
T_SHORT, // T_SHORT = 9,
T_INT, // T_INT = 10,
T_LONG, // T_LONG = 11,
T_OBJECT, // T_OBJECT = 12,
T_OBJECT, // T_ARRAY = 13,
T_VOID, // T_VOID = 14,
T_ADDRESS, // T_ADDRESS = 15,
T_NARROWOOP, // T_NARROWOOP= 16,
T_METADATA, // T_METADATA = 17,
T_NARROWKLASS, // T_NARROWKLASS = 18,
T_CONFLICT // T_CONFLICT = 19,
};
BasicType type2wfield[T_CONFLICT+1] = {
(BasicType)0, // 0,
(BasicType)0, // 1,
(BasicType)0, // 2,
(BasicType)0, // 3,
T_INT, // T_BOOLEAN = 4,
T_INT, // T_CHAR = 5,
T_FLOAT, // T_FLOAT = 6,
T_DOUBLE, // T_DOUBLE = 7,
T_INT, // T_BYTE = 8,
T_INT, // T_SHORT = 9,
T_INT, // T_INT = 10,
T_LONG, // T_LONG = 11,
T_OBJECT, // T_OBJECT = 12,
T_OBJECT, // T_ARRAY = 13,
T_VOID, // T_VOID = 14,
T_ADDRESS, // T_ADDRESS = 15,
T_NARROWOOP, // T_NARROWOOP = 16,
T_METADATA, // T_METADATA = 17,
T_NARROWKLASS, // T_NARROWKLASS = 18,
T_CONFLICT // T_CONFLICT = 19,
};
int _type2aelembytes[T_CONFLICT+1] = {
0, // 0
0, // 1
0, // 2
0, // 3
T_BOOLEAN_aelem_bytes, // T_BOOLEAN = 4,
T_CHAR_aelem_bytes, // T_CHAR = 5,
T_FLOAT_aelem_bytes, // T_FLOAT = 6,
T_DOUBLE_aelem_bytes, // T_DOUBLE = 7,
T_BYTE_aelem_bytes, // T_BYTE = 8,
T_SHORT_aelem_bytes, // T_SHORT = 9,
T_INT_aelem_bytes, // T_INT = 10,
T_LONG_aelem_bytes, // T_LONG = 11,
T_OBJECT_aelem_bytes, // T_OBJECT = 12,
T_ARRAY_aelem_bytes, // T_ARRAY = 13,
0, // T_VOID = 14,
T_OBJECT_aelem_bytes, // T_ADDRESS = 15,
T_NARROWOOP_aelem_bytes, // T_NARROWOOP= 16,
T_OBJECT_aelem_bytes, // T_METADATA = 17,
T_NARROWKLASS_aelem_bytes, // T_NARROWKLASS= 18,
0 // T_CONFLICT = 19,
};
09-02
07-02
2949
2949
11-01
66
66
02-07
53
53
07-14
06-15
05-08
324
324
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
