Skip to content

Commit

Permalink
Merge upstream-jdk
Browse files Browse the repository at this point in the history
  • Loading branch information
corretto-github-robot committed Aug 30, 2024
2 parents 388302c + b9e65f9 commit 73ad8b8
Show file tree
Hide file tree
Showing 41 changed files with 1,476 additions and 380 deletions.
2 changes: 0 additions & 2 deletions src/hotspot/cpu/riscv/c1_Runtime1_riscv.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -223,8 +223,6 @@ StubFrame::~StubFrame() {

#define __ sasm->

const int float_regs_as_doubles_size_in_slots = pd_nof_fpu_regs_frame_map * 2;

// Stack layout for saving/restoring all the registers needed during a runtime
// call (this includes deoptimization)
// Note: note that users of this frame may well have arguments to some runtime
Expand Down
24 changes: 0 additions & 24 deletions src/hotspot/share/cds/heapShared.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -1644,30 +1644,6 @@ class FindEmbeddedNonNullPointers: public BasicOopIterateClosure {
};
#endif

#ifndef PRODUCT
ResourceBitMap HeapShared::calculate_oopmap(MemRegion region) {
size_t num_bits = region.byte_size() / (UseCompressedOops ? sizeof(narrowOop) : sizeof(oop));
ResourceBitMap oopmap(num_bits);

HeapWord* p = region.start();
HeapWord* end = region.end();
FindEmbeddedNonNullPointers finder((void*)p, &oopmap);

int num_objs = 0;
while (p < end) {
oop o = cast_to_oop(p);
o->oop_iterate(&finder);
p += o->size();
++ num_objs;
}

log_info(cds, heap)("calculate_oopmap: objects = %6d, oop fields = %7d (nulls = %7d)",
num_objs, finder.num_total_oops(), finder.num_null_oops());
return oopmap;
}

#endif // !PRODUCT

void HeapShared::count_allocation(size_t size) {
_total_obj_count ++;
_total_obj_size += size;
Expand Down
3 changes: 0 additions & 3 deletions src/hotspot/share/cds/heapShared.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -371,9 +371,6 @@ class HeapShared: AllStatic {
KlassSubGraphInfo* subgraph_info,
oop orig_obj);

#ifndef PRODUCT
static ResourceBitMap calculate_oopmap(MemRegion region); // marks all the oop pointers
#endif
static void add_to_dumped_interned_strings(oop string);

// Scratch objects for archiving Klass::java_mirror()
Expand Down
4 changes: 2 additions & 2 deletions src/hotspot/share/classfile/compactHashtable.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -431,10 +431,10 @@ void HashtableTextDump::get_utf8(char* utf8_buffer, int utf8_length) {
}

// NOTE: the content is NOT the same as
// UTF8::as_quoted_ascii(const char* utf8_str, int utf8_length, char* buf, int buflen).
// UTF8::as_quoted_ascii(const char* utf8_str, int utf8_length, char* buf, size_t buflen).
// We want to escape \r\n\t so that output [1] is more readable; [2] can be more easily
// parsed by scripts; [3] quickly processed by HashtableTextDump::get_utf8()
void HashtableTextDump::put_utf8(outputStream* st, const char* utf8_string, int utf8_length) {
void HashtableTextDump::put_utf8(outputStream* st, const char* utf8_string, size_t utf8_length) {
const char *c = utf8_string;
const char *end = c + utf8_length;
for (; c < end; c++) {
Expand Down
2 changes: 1 addition & 1 deletion src/hotspot/share/classfile/compactHashtable.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -431,7 +431,7 @@ class HashtableTextDump {

int unescape(const char* from, const char* end, int count);
void get_utf8(char* utf8_buffer, int utf8_length);
static void put_utf8(outputStream* st, const char* utf8_string, int utf8_length);
static void put_utf8(outputStream* st, const char* utf8_string, size_t utf8_length);
};

#endif // SHARE_CLASSFILE_COMPACTHASHTABLE_HPP
65 changes: 46 additions & 19 deletions src/hotspot/share/classfile/javaClasses.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -304,7 +304,8 @@ Handle java_lang_String::create_from_unicode(const jchar* unicode, int length, T
#ifdef ASSERT
{
ResourceMark rm;
char* expected = UNICODE::as_utf8(unicode, length);
size_t utf8_len = static_cast<size_t>(length);
char* expected = UNICODE::as_utf8(unicode, utf8_len);
char* actual = as_utf8_string(h_obj());
if (strcmp(expected, actual) != 0) {
fatal("Unicode conversion failure: %s --> %s", expected, actual);
Expand Down Expand Up @@ -346,7 +347,7 @@ Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {
#ifdef ASSERT
// This check is too strict when the input string is not a valid UTF8.
// For example, it may be created with arbitrary content via jni_NewStringUTF.
if (UTF8::is_legal_utf8((const unsigned char*)utf8_str, (int)strlen(utf8_str), false)) {
if (UTF8::is_legal_utf8((const unsigned char*)utf8_str, strlen(utf8_str), false)) {
ResourceMark rm;
const char* expected = utf8_str;
char* actual = as_utf8_string(h_obj());
Expand Down Expand Up @@ -554,7 +555,7 @@ char* java_lang_String::as_quoted_ascii(oop java_string) {
if (length == 0) return nullptr;

char* result;
int result_length;
size_t result_length;
if (!is_latin1) {
jchar* base = value->char_at_addr(0);
result_length = UNICODE::quoted_ascii_length(base, length) + 1;
Expand All @@ -566,8 +567,8 @@ char* java_lang_String::as_quoted_ascii(oop java_string) {
result = NEW_RESOURCE_ARRAY(char, result_length);
UNICODE::as_quoted_ascii(base, length, result, result_length);
}
assert(result_length >= length + 1, "must not be shorter");
assert(result_length == (int)strlen(result) + 1, "must match");
assert(result_length >= (size_t)length + 1, "must not be shorter");
assert(result_length == strlen(result) + 1, "must match");
return result;
}

Expand All @@ -582,8 +583,9 @@ Symbol* java_lang_String::as_symbol(oop java_string) {
} else {
ResourceMark rm;
jbyte* position = (length == 0) ? nullptr : value->byte_at_addr(0);
const char* base = UNICODE::as_utf8(position, length);
Symbol* sym = SymbolTable::new_symbol(base, length);
size_t utf8_len = static_cast<size_t>(length);
const char* base = UNICODE::as_utf8(position, utf8_len);
Symbol* sym = SymbolTable::new_symbol(base, checked_cast<int>(utf8_len));
return sym;
}
}
Expand All @@ -598,12 +600,13 @@ Symbol* java_lang_String::as_symbol_or_null(oop java_string) {
} else {
ResourceMark rm;
jbyte* position = (length == 0) ? nullptr : value->byte_at_addr(0);
const char* base = UNICODE::as_utf8(position, length);
return SymbolTable::probe(base, length);
size_t utf8_len = static_cast<size_t>(length);
const char* base = UNICODE::as_utf8(position, utf8_len);
return SymbolTable::probe(base, checked_cast<int>(utf8_len));
}
}

int java_lang_String::utf8_length(oop java_string, typeArrayOop value) {
size_t java_lang_String::utf8_length(oop java_string, typeArrayOop value) {
assert(value_equals(value, java_lang_String::value(java_string)),
"value must be same as java_lang_String::value(java_string)");
int length = java_lang_String::length(java_string, value);
Expand All @@ -617,18 +620,39 @@ int java_lang_String::utf8_length(oop java_string, typeArrayOop value) {
}
}

int java_lang_String::utf8_length(oop java_string) {
size_t java_lang_String::utf8_length(oop java_string) {
typeArrayOop value = java_lang_String::value(java_string);
return utf8_length(java_string, value);
}

int java_lang_String::utf8_length_as_int(oop java_string) {
typeArrayOop value = java_lang_String::value(java_string);
return utf8_length_as_int(java_string, value);
}

int java_lang_String::utf8_length_as_int(oop java_string, typeArrayOop value) {
assert(value_equals(value, java_lang_String::value(java_string)),
"value must be same as java_lang_String::value(java_string)");
int length = java_lang_String::length(java_string, value);
if (length == 0) {
return 0;
}
if (!java_lang_String::is_latin1(java_string)) {
return UNICODE::utf8_length_as_int(value->char_at_addr(0), length);
} else {
return UNICODE::utf8_length_as_int(value->byte_at_addr(0), length);
}
}

char* java_lang_String::as_utf8_string(oop java_string) {
int length;
size_t length;
return as_utf8_string(java_string, length);
}

char* java_lang_String::as_utf8_string(oop java_string, int& length) {
char* java_lang_String::as_utf8_string(oop java_string, size_t& length) {
typeArrayOop value = java_lang_String::value(java_string);
// `length` is used as the incoming number of characters to
// convert, and then set as the number of bytes in the UTF8 sequence.
length = java_lang_String::length(java_string, value);
bool is_latin1 = java_lang_String::is_latin1(java_string);
if (!is_latin1) {
Expand All @@ -642,7 +666,7 @@ char* java_lang_String::as_utf8_string(oop java_string, int& length) {

// Uses a provided buffer if it's sufficiently large, otherwise allocates
// a resource array to fit
char* java_lang_String::as_utf8_string_full(oop java_string, char* buf, int buflen, int& utf8_len) {
char* java_lang_String::as_utf8_string_full(oop java_string, char* buf, size_t buflen, size_t& utf8_len) {
typeArrayOop value = java_lang_String::value(java_string);
int len = java_lang_String::length(java_string, value);
bool is_latin1 = java_lang_String::is_latin1(java_string);
Expand All @@ -663,7 +687,7 @@ char* java_lang_String::as_utf8_string_full(oop java_string, char* buf, int bufl
}
}

char* java_lang_String::as_utf8_string(oop java_string, typeArrayOop value, char* buf, int buflen) {
char* java_lang_String::as_utf8_string(oop java_string, typeArrayOop value, char* buf, size_t buflen) {
assert(value_equals(value, java_lang_String::value(java_string)),
"value must be same as java_lang_String::value(java_string)");
int length = java_lang_String::length(java_string, value);
Expand All @@ -677,25 +701,28 @@ char* java_lang_String::as_utf8_string(oop java_string, typeArrayOop value, char
}
}

char* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) {
char* java_lang_String::as_utf8_string(oop java_string, char* buf, size_t buflen) {
typeArrayOop value = java_lang_String::value(java_string);
return as_utf8_string(java_string, value, buf, buflen);
}

char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {
// `length` is used as the incoming number of characters to
// convert, and then set as the number of bytes in the UTF8 sequence.
size_t length = static_cast<size_t>(len);
typeArrayOop value = java_lang_String::value(java_string);
bool is_latin1 = java_lang_String::is_latin1(java_string);
assert(start + len <= java_lang_String::length(java_string), "just checking");
if (!is_latin1) {
jchar* position = value->char_at_addr(start);
return UNICODE::as_utf8(position, len);
return UNICODE::as_utf8(position, length);
} else {
jbyte* position = value->byte_at_addr(start);
return UNICODE::as_utf8(position, len);
return UNICODE::as_utf8(position, length);
}
}

char* java_lang_String::as_utf8_string(oop java_string, typeArrayOop value, int start, int len, char* buf, int buflen) {
char* java_lang_String::as_utf8_string(oop java_string, typeArrayOop value, int start, int len, char* buf, size_t buflen) {
assert(value_equals(value, java_lang_String::value(java_string)),
"value must be same as java_lang_String::value(java_string)");
assert(start + len <= java_lang_String::length(java_string), "just checking");
Expand Down
18 changes: 11 additions & 7 deletions src/hotspot/share/classfile/javaClasses.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -131,17 +131,21 @@ class java_lang_String : AllStatic {
static inline bool deduplication_requested(oop java_string);
static inline int length(oop java_string);
static inline int length(oop java_string, typeArrayOop string_value);
static int utf8_length(oop java_string);
static int utf8_length(oop java_string, typeArrayOop string_value);
static size_t utf8_length(oop java_string);
static size_t utf8_length(oop java_string, typeArrayOop string_value);
// Legacy variants that truncate the length if needed
static int utf8_length_as_int(oop java_string);
static int utf8_length_as_int(oop java_string, typeArrayOop string_value);

// String converters
static char* as_utf8_string(oop java_string);
static char* as_utf8_string(oop java_string, int& length);
static char* as_utf8_string_full(oop java_string, char* buf, int buflen, int& length);
static char* as_utf8_string(oop java_string, char* buf, int buflen);
// `length` is set to the length of the utf8 sequence.
static char* as_utf8_string(oop java_string, size_t& length);
static char* as_utf8_string_full(oop java_string, char* buf, size_t buflen, size_t& length);
static char* as_utf8_string(oop java_string, char* buf, size_t buflen);
static char* as_utf8_string(oop java_string, int start, int len);
static char* as_utf8_string(oop java_string, typeArrayOop value, char* buf, int buflen);
static char* as_utf8_string(oop java_string, typeArrayOop value, int start, int len, char* buf, int buflen);
static char* as_utf8_string(oop java_string, typeArrayOop value, char* buf, size_t buflen);
static char* as_utf8_string(oop java_string, typeArrayOop value, int start, int len, char* buf, size_t buflen);
static char* as_platform_dependent_str(Handle java_string, TRAPS);
static jchar* as_unicode_string(oop java_string, int& length, TRAPS);
static jchar* as_unicode_string_or_null(oop java_string, int& length);
Expand Down
14 changes: 9 additions & 5 deletions src/hotspot/share/classfile/modules.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -72,7 +72,9 @@ static char* get_module_name(oop module, int& len, TRAPS) {
if (name_oop == nullptr) {
THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(), "Null module name");
}
char* module_name = java_lang_String::as_utf8_string(name_oop, len);
size_t utf8_len;
char* module_name = java_lang_String::as_utf8_string(name_oop, utf8_len);
len = checked_cast<int>(utf8_len); // module names are < 64K
if (!verify_module_name(module_name, len)) {
THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(),
err_msg("Invalid module name: %s", module_name));
Expand All @@ -84,9 +86,9 @@ static Symbol* as_symbol(jstring str_object) {
if (str_object == nullptr) {
return nullptr;
}
int len;
size_t len;
char* str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(str_object), len);
return SymbolTable::new_symbol(str, len);
return SymbolTable::new_symbol(str, checked_cast<int>(len));
}

ModuleEntryTable* Modules::get_module_entry_table(Handle h_loader) {
Expand Down Expand Up @@ -142,8 +144,10 @@ bool Modules::is_package_defined(Symbol* package, Handle h_loader) {
// Will use the provided buffer if it's sufficiently large, otherwise allocates
// a resource array
// The length of the resulting string will be assigned to utf8_len
static const char* as_internal_package(oop package_string, char* buf, int buflen, int& utf8_len) {
char* package_name = java_lang_String::as_utf8_string_full(package_string, buf, buflen, utf8_len);
static const char* as_internal_package(oop package_string, char* buf, size_t buflen, int& utf8_len) {
size_t full_utf8_len;
char* package_name = java_lang_String::as_utf8_string_full(package_string, buf, buflen, full_utf8_len);
utf8_len = checked_cast<int>(full_utf8_len); // package names are < 64K

// Turn all '/'s into '.'s
for (int index = 0; index < utf8_len; index++) {
Expand Down
4 changes: 2 additions & 2 deletions src/hotspot/share/classfile/stringTable.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -686,7 +686,7 @@ static void print_string(Thread* current, outputStream* st, oop s) {
st->print("%d: ", length);
} else {
ResourceMark rm(current);
int utf8_length = length;
size_t utf8_length = length;
char* utf8_string;

if (!is_latin1) {
Expand All @@ -697,7 +697,7 @@ static void print_string(Thread* current, outputStream* st, oop s) {
utf8_string = UNICODE::as_utf8(bytes, utf8_length);
}

st->print("%d: ", utf8_length);
st->print("%zu: ", utf8_length);
HashtableTextDump::put_utf8(st, utf8_string, utf8_length);
}
st->cr();
Expand Down
17 changes: 9 additions & 8 deletions src/hotspot/share/classfile/symbolTable.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -349,6 +349,7 @@ Symbol* SymbolTable::lookup_common(const char* name,
// to be used for arbitrary strings. For debug builds we will assert if
// a string is too long, whereas product builds will truncate it.
static int check_length(const char* name, int len) {
assert(len >= 0, "negative length %d suggests integer overflow in the caller", len);
assert(len <= Symbol::max_length(),
"String length %d exceeds the maximum Symbol length of %d", len, Symbol::max_length());
if (len > Symbol::max_length()) {
Expand Down Expand Up @@ -461,33 +462,33 @@ Symbol* SymbolTable::lookup_only(const char* name, int len, unsigned int& hash)
// and probing logic, so there is no need for convert_to_utf8 until
// an actual new Symbol* is created.
Symbol* SymbolTable::new_symbol(const jchar* name, int utf16_length) {
int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);
size_t utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);
char stack_buf[ON_STACK_BUFFER_LENGTH];
if (utf8_length < (int) sizeof(stack_buf)) {
if (utf8_length < sizeof(stack_buf)) {
char* chars = stack_buf;
UNICODE::convert_to_utf8(name, utf16_length, chars);
return new_symbol(chars, utf8_length);
return new_symbol(chars, checked_cast<int>(utf8_length));
} else {
ResourceMark rm;
char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);
UNICODE::convert_to_utf8(name, utf16_length, chars);
return new_symbol(chars, utf8_length);
return new_symbol(chars, checked_cast<int>(utf8_length));
}
}

Symbol* SymbolTable::lookup_only_unicode(const jchar* name, int utf16_length,
unsigned int& hash) {
int utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);
size_t utf8_length = UNICODE::utf8_length((jchar*) name, utf16_length);
char stack_buf[ON_STACK_BUFFER_LENGTH];
if (utf8_length < (int) sizeof(stack_buf)) {
if (utf8_length < sizeof(stack_buf)) {
char* chars = stack_buf;
UNICODE::convert_to_utf8(name, utf16_length, chars);
return lookup_only(chars, utf8_length, hash);
return lookup_only(chars, checked_cast<int>(utf8_length), hash);
} else {
ResourceMark rm;
char* chars = NEW_RESOURCE_ARRAY(char, utf8_length + 1);
UNICODE::convert_to_utf8(name, utf16_length, chars);
return lookup_only(chars, utf8_length, hash);
return lookup_only(chars, checked_cast<int>(utf8_length), hash);
}
}

Expand Down
6 changes: 3 additions & 3 deletions src/hotspot/share/jfr/dcmd/jfrDcmds.cpp
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2012, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
Expand Down Expand Up @@ -292,10 +292,10 @@ static const char* get_as_dcmd_arena_string(oop string) {
char* str = nullptr;
const typeArrayOop value = java_lang_String::value(string);
if (value != nullptr) {
const size_t length = static_cast<size_t>(java_lang_String::utf8_length(string, value)) + 1;
const size_t length = java_lang_String::utf8_length(string, value) + 1;
str = dcmd_arena_allocate(length);
assert(str != nullptr, "invariant");
java_lang_String::as_utf8_string(string, value, str, static_cast<int>(length));
java_lang_String::as_utf8_string(string, value, str, length);
}
return str;
}
Expand Down
Loading

0 comments on commit 73ad8b8

Please sign in to comment.