Mercurial > hg > truffle
comparison src/share/vm/memory/allocation.cpp @ 12146:9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
Summary: declare all user-defined operator new()s within Hotspot code with the empty throw() exception specification
Reviewed-by: coleenp, twisti, dholmes, hseigel, dcubed, kvn, ccheung
Contributed-by: lois.foltan@oracle.com
author | coleenp |
---|---|
date | Thu, 29 Aug 2013 18:56:29 -0400 |
parents | cf9d71d3e474 |
children | ce86c36b8921 183bd5c00828 2b8e28fdf503 |
comparison
equal
deleted
inserted
replaced
12145:cef1e56a4d88 | 12146:9758d9f36299 |
---|---|
47 #endif | 47 #endif |
48 #ifdef TARGET_OS_FAMILY_bsd | 48 #ifdef TARGET_OS_FAMILY_bsd |
49 # include "os_bsd.inline.hpp" | 49 # include "os_bsd.inline.hpp" |
50 #endif | 50 #endif |
51 | 51 |
52 void* StackObj::operator new(size_t size) { ShouldNotCallThis(); return 0; } | 52 void* StackObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; } |
53 void StackObj::operator delete(void* p) { ShouldNotCallThis(); } | 53 void StackObj::operator delete(void* p) { ShouldNotCallThis(); } |
54 void* StackObj::operator new [](size_t size) { ShouldNotCallThis(); return 0; } | 54 void* StackObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; } |
55 void StackObj::operator delete [](void* p) { ShouldNotCallThis(); } | 55 void StackObj::operator delete [](void* p) { ShouldNotCallThis(); } |
56 | 56 |
57 void* _ValueObj::operator new(size_t size) { ShouldNotCallThis(); return 0; } | 57 void* _ValueObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; } |
58 void _ValueObj::operator delete(void* p) { ShouldNotCallThis(); } | 58 void _ValueObj::operator delete(void* p) { ShouldNotCallThis(); } |
59 void* _ValueObj::operator new [](size_t size) { ShouldNotCallThis(); return 0; } | 59 void* _ValueObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; } |
60 void _ValueObj::operator delete [](void* p) { ShouldNotCallThis(); } | 60 void _ValueObj::operator delete [](void* p) { ShouldNotCallThis(); } |
61 | 61 |
62 void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data, | 62 void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data, |
63 size_t word_size, bool read_only, | 63 size_t word_size, bool read_only, |
64 MetaspaceObj::Type type, TRAPS) { | 64 MetaspaceObj::Type type, TRAPS) throw() { |
65 // Klass has it's own operator new | 65 // Klass has it's own operator new |
66 return Metaspace::allocate(loader_data, word_size, read_only, | 66 return Metaspace::allocate(loader_data, word_size, read_only, |
67 type, CHECK_NULL); | 67 type, CHECK_NULL); |
68 } | 68 } |
69 | 69 |
78 | 78 |
79 void MetaspaceObj::print_address_on(outputStream* st) const { | 79 void MetaspaceObj::print_address_on(outputStream* st) const { |
80 st->print(" {"INTPTR_FORMAT"}", this); | 80 st->print(" {"INTPTR_FORMAT"}", this); |
81 } | 81 } |
82 | 82 |
83 void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) { | 83 void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) throw() { |
84 address res; | 84 address res; |
85 switch (type) { | 85 switch (type) { |
86 case C_HEAP: | 86 case C_HEAP: |
87 res = (address)AllocateHeap(size, flags, CALLER_PC); | 87 res = (address)AllocateHeap(size, flags, CALLER_PC); |
88 DEBUG_ONLY(set_allocation_type(res, C_HEAP);) | 88 DEBUG_ONLY(set_allocation_type(res, C_HEAP);) |
95 ShouldNotReachHere(); | 95 ShouldNotReachHere(); |
96 } | 96 } |
97 return res; | 97 return res; |
98 } | 98 } |
99 | 99 |
100 void* ResourceObj::operator new [](size_t size, allocation_type type, MEMFLAGS flags) { | 100 void* ResourceObj::operator new [](size_t size, allocation_type type, MEMFLAGS flags) throw() { |
101 return (address) operator new(size, type, flags); | 101 return (address) operator new(size, type, flags); |
102 } | 102 } |
103 | 103 |
104 void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_constant, | 104 void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_constant, |
105 allocation_type type, MEMFLAGS flags) { | 105 allocation_type type, MEMFLAGS flags) throw() { |
106 //should only call this with std::nothrow, use other operator new() otherwise | 106 //should only call this with std::nothrow, use other operator new() otherwise |
107 address res; | 107 address res; |
108 switch (type) { | 108 switch (type) { |
109 case C_HEAP: | 109 case C_HEAP: |
110 res = (address)AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL); | 110 res = (address)AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL); |
119 } | 119 } |
120 return res; | 120 return res; |
121 } | 121 } |
122 | 122 |
123 void* ResourceObj::operator new [](size_t size, const std::nothrow_t& nothrow_constant, | 123 void* ResourceObj::operator new [](size_t size, const std::nothrow_t& nothrow_constant, |
124 allocation_type type, MEMFLAGS flags) { | 124 allocation_type type, MEMFLAGS flags) throw() { |
125 return (address)operator new(size, nothrow_constant, type, flags); | 125 return (address)operator new(size, nothrow_constant, type, flags); |
126 } | 126 } |
127 | 127 |
128 void ResourceObj::operator delete(void* p) { | 128 void ResourceObj::operator delete(void* p) { |
129 assert(((ResourceObj *)p)->allocated_on_C_heap(), | 129 assert(((ResourceObj *)p)->allocated_on_C_heap(), |
368 }; | 368 }; |
369 | 369 |
370 //-------------------------------------------------------------------------------------- | 370 //-------------------------------------------------------------------------------------- |
371 // Chunk implementation | 371 // Chunk implementation |
372 | 372 |
373 void* Chunk::operator new (size_t requested_size, AllocFailType alloc_failmode, size_t length) { | 373 void* Chunk::operator new (size_t requested_size, AllocFailType alloc_failmode, size_t length) throw() { |
374 // requested_size is equal to sizeof(Chunk) but in order for the arena | 374 // requested_size is equal to sizeof(Chunk) but in order for the arena |
375 // allocations to come out aligned as expected the size must be aligned | 375 // allocations to come out aligned as expected the size must be aligned |
376 // to expected arena alignment. | 376 // to expected arena alignment. |
377 // expect requested_size but if sizeof(Chunk) doesn't match isn't proper size we must align it. | 377 // expect requested_size but if sizeof(Chunk) doesn't match isn't proper size we must align it. |
378 assert(ARENA_ALIGN(requested_size) == aligned_overhead_size(), "Bad alignment"); | 378 assert(ARENA_ALIGN(requested_size) == aligned_overhead_size(), "Bad alignment"); |
476 Arena::~Arena() { | 476 Arena::~Arena() { |
477 destruct_contents(); | 477 destruct_contents(); |
478 NOT_PRODUCT(Atomic::dec(&_instance_count);) | 478 NOT_PRODUCT(Atomic::dec(&_instance_count);) |
479 } | 479 } |
480 | 480 |
481 void* Arena::operator new(size_t size) { | 481 void* Arena::operator new(size_t size) throw() { |
482 assert(false, "Use dynamic memory type binding"); | 482 assert(false, "Use dynamic memory type binding"); |
483 return NULL; | 483 return NULL; |
484 } | 484 } |
485 | 485 |
486 void* Arena::operator new (size_t size, const std::nothrow_t& nothrow_constant) { | 486 void* Arena::operator new (size_t size, const std::nothrow_t& nothrow_constant) throw() { |
487 assert(false, "Use dynamic memory type binding"); | 487 assert(false, "Use dynamic memory type binding"); |
488 return NULL; | 488 return NULL; |
489 } | 489 } |
490 | 490 |
491 // dynamic memory type binding | 491 // dynamic memory type binding |
492 void* Arena::operator new(size_t size, MEMFLAGS flags) { | 492 void* Arena::operator new(size_t size, MEMFLAGS flags) throw() { |
493 #ifdef ASSERT | 493 #ifdef ASSERT |
494 void* p = (void*)AllocateHeap(size, flags|otArena, CALLER_PC); | 494 void* p = (void*)AllocateHeap(size, flags|otArena, CALLER_PC); |
495 if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p); | 495 if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p); |
496 return p; | 496 return p; |
497 #else | 497 #else |
498 return (void *) AllocateHeap(size, flags|otArena, CALLER_PC); | 498 return (void *) AllocateHeap(size, flags|otArena, CALLER_PC); |
499 #endif | 499 #endif |
500 } | 500 } |
501 | 501 |
502 void* Arena::operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) { | 502 void* Arena::operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) throw() { |
503 #ifdef ASSERT | 503 #ifdef ASSERT |
504 void* p = os::malloc(size, flags|otArena, CALLER_PC); | 504 void* p = os::malloc(size, flags|otArena, CALLER_PC); |
505 if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p); | 505 if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p); |
506 return p; | 506 return p; |
507 #else | 507 #else |
686 // from jdk source and causing data corruption. Such as | 686 // from jdk source and causing data corruption. Such as |
687 // Java_sun_security_ec_ECKeyPairGenerator_generateECKeyPair | 687 // Java_sun_security_ec_ECKeyPairGenerator_generateECKeyPair |
688 // define ALLOW_OPERATOR_NEW_USAGE for platform on which global operator new allowed. | 688 // define ALLOW_OPERATOR_NEW_USAGE for platform on which global operator new allowed. |
689 // | 689 // |
690 #ifndef ALLOW_OPERATOR_NEW_USAGE | 690 #ifndef ALLOW_OPERATOR_NEW_USAGE |
691 void* operator new(size_t size){ | 691 void* operator new(size_t size) throw() { |
692 assert(false, "Should not call global operator new"); | 692 assert(false, "Should not call global operator new"); |
693 return 0; | 693 return 0; |
694 } | 694 } |
695 | 695 |
696 void* operator new [](size_t size){ | 696 void* operator new [](size_t size) throw() { |
697 assert(false, "Should not call global operator new[]"); | 697 assert(false, "Should not call global operator new[]"); |
698 return 0; | 698 return 0; |
699 } | 699 } |
700 | 700 |
701 void* operator new(size_t size, const std::nothrow_t& nothrow_constant){ | 701 void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() { |
702 assert(false, "Should not call global operator new"); | 702 assert(false, "Should not call global operator new"); |
703 return 0; | 703 return 0; |
704 } | 704 } |
705 | 705 |
706 void* operator new [](size_t size, std::nothrow_t& nothrow_constant){ | 706 void* operator new [](size_t size, std::nothrow_t& nothrow_constant) throw() { |
707 assert(false, "Should not call global operator new[]"); | 707 assert(false, "Should not call global operator new[]"); |
708 return 0; | 708 return 0; |
709 } | 709 } |
710 | 710 |
711 void operator delete(void* p) { | 711 void operator delete(void* p) { |