jdk-sandbox: comparison hotspot/src/share/vm/runtime/virtualspace.cpp

equal deleted inserted replaced

-:c4256e927bed
+:df347ffafa0d
 /*
-* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 assert(addr != NULL, "sanity");
 const size_t required_size = prefix_size + suffix_size;
 assert(len >= required_size, "len too small");
 const size_t s = size_t(addr);
-const size_t beg_ofs = s + prefix_size & suffix_align - 1;
+const size_t beg_ofs = (s + prefix_size) & (suffix_align - 1);
 const size_t beg_delta = beg_ofs == 0 ? 0 : suffix_align - beg_ofs;
 if (len < beg_delta + required_size) {
 return NULL; // Cannot do proper alignment.
 }
 const size_t raw = size_t(raw_addr);
 const size_t res = size_t(result);
 assert(res >= raw, "alignment decreased start addr");
 assert(res + prefix_size + suffix_size <= raw + reserve_size,
 "alignment increased end addr");
-assert((res & prefix_align - 1) == 0, "bad alignment of prefix");
+assert((res & (prefix_align - 1)) == 0, "bad alignment of prefix");
-assert((res + prefix_size & suffix_align - 1) == 0,
+assert(((res + prefix_size) & (suffix_align - 1)) == 0,
 "bad alignment of suffix");
 }
 #endif
 return result;
 // Different reserve address may be acceptable in other cases
 // but for compressed oops heap should be at requested address.
 assert(UseCompressedOops, "currently requested address used only for compressed oops");
 if (PrintCompressedOopsMode) {
 tty->cr();
-tty->print_cr("Reserved memory at not requested address: " PTR_FORMAT " vs " PTR_FORMAT, base, requested_address);
+tty->print_cr("Reserved memory not at requested address: " PTR_FORMAT " vs " PTR_FORMAT, base, requested_address);
 }
 // OS ignored requested address. Try different address.
 if (special) {
 if (!os::release_memory_special(base, size)) {
 fatal("os::release_memory_special failed");
 {
 assert(prefix_size != 0, "sanity");
 assert(prefix_align != 0, "sanity");
 assert(suffix_size != 0, "sanity");
 assert(suffix_align != 0, "sanity");
-assert((prefix_size & prefix_align - 1) == 0,
+assert((prefix_size & (prefix_align - 1)) == 0,
 "prefix_size not divisible by prefix_align");
-assert((suffix_size & suffix_align - 1) == 0,
+assert((suffix_size & (suffix_align - 1)) == 0,
 "suffix_size not divisible by suffix_align");
-assert((suffix_align & prefix_align - 1) == 0,
+assert((suffix_align & (prefix_align - 1)) == 0,
 "suffix_align not divisible by prefix_align");
 // Assert that if noaccess_prefix is used, it is the same as prefix_align.
 assert(noaccess_prefix == 0 ||
 noaccess_prefix == prefix_align, "noaccess prefix wrong");
 addr = os::reserve_memory(size, NULL, prefix_align);
 }
 if (addr == NULL) return;
 // Check whether the result has the needed alignment (unlikely unless
-// prefix_align == suffix_align).
+// prefix_align < suffix_align).
-const size_t ofs = size_t(addr) + adjusted_prefix_size & suffix_align - 1;
+const size_t ofs = (size_t(addr) + adjusted_prefix_size) & (suffix_align - 1);
 if (ofs != 0) {
 // Wrong alignment.  Release, allocate more space and do manual alignment.
 //
 // On most operating systems, another allocation with a somewhat larger size
 // will return an address "close to" that of the previous allocation.  The
 if (addr == NULL) {
 // Try an even larger region.  If this fails, address space is exhausted.
 addr = reserve_and_align(size + suffix_align, adjusted_prefix_size,
 prefix_align, suffix_size, suffix_align);
 }
+if (requested_address != 0 &&
+failed_to_reserve_as_requested(addr, requested_address, size, false)) {
+// As a result of the alignment constraints, the allocated addr differs
+// from the requested address. Return back to the caller who can
+// take remedial action (like try again without a requested address).
+assert(_base == NULL, "should be");
+return;
+}
 }
 _base = addr;
 _size = size;
 _alignment = prefix_align;
 void ReservedSpace::initialize(size_t size, size_t alignment, bool large,
 char* requested_address,
 const size_t noaccess_prefix,
 bool executable) {
 const size_t granularity = os::vm_allocation_granularity();
-assert((size & granularity - 1) == 0,
+assert((size & (granularity - 1)) == 0,
 "size not aligned to os::vm_allocation_granularity()");
-assert((alignment & granularity - 1) == 0,
+assert((alignment & (granularity - 1)) == 0,
 "alignment not aligned to os::vm_allocation_granularity()");
 assert(alignment == 0 || is_power_of_2((intptr_t)alignment),
 "not a power of 2");
+alignment = MAX2(alignment, (size_t)os::vm_page_size());
+// Assert that if noaccess_prefix is used, it is the same as alignment.
+assert(noaccess_prefix == 0 ||
+noaccess_prefix == alignment, "noaccess prefix wrong");
 _base = NULL;
 _size = 0;
 _special = false;
 _executable = executable;
 if (failed_to_reserve_as_requested(base, requested_address, size, true)) {
 // OS ignored requested address. Try different address.
 return;
 }
 // Check alignment constraints
-if (alignment > 0) {
+assert((uintptr_t) base % alignment == 0,
-assert((uintptr_t) base % alignment == 0,
+"Large pages returned a non-aligned address");
-"Large pages returned a non-aligned address");
-}
 _special = true;
 } else {
 // failed; try to reserve regular memory below
 if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) ||
 !FLAG_IS_DEFAULT(LargePageSizeInBytes))) {
 }
 if (base == NULL) return;
 // Check alignment constraints
-if (alignment > 0 && ((size_t)base & alignment - 1) != 0) {
+if ((((size_t)base + noaccess_prefix) & (alignment - 1)) != 0) {
 // Base not aligned, retry
 if (!os::release_memory(base, size)) fatal("os::release_memory failed");
 // Reserve size large enough to do manual alignment and
 // increase size to a multiple of the desired alignment
 size = align_size_up(size, alignment);
 assert(base >= extra_base, "just checking");
 // Re-reserve the region at the aligned base address.
 os::release_memory(extra_base, extra_size);
 base = os::reserve_memory(size, base);
 } while (base == NULL);
+if (requested_address != 0 &&
+failed_to_reserve_as_requested(base, requested_address, size, false)) {
+// As a result of the alignment constraints, the allocated base differs
+// from the requested address. Return back to the caller who can
+// take remedial action (like try again without a requested address).
+assert(_base == NULL, "should be");
+return;
+}
 }
 }
 // Done
 _base = base;
 _size = size;
-_alignment = MAX2(alignment, (size_t) os::vm_page_size());
+_alignment = alignment;
 _noaccess_prefix = noaccess_prefix;
 // Assert that if noaccess_prefix is used, it is the same as alignment.
 assert(noaccess_prefix == 0 ||
 noaccess_prefix == _alignment, "noaccess prefix wrong");

changeset 10237	df347ffafa0d
parent 7397	5b173b4ca846
child 10565	dc90c239f4ec