| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| /* -*-C++-*- |
| **************************************************************************** |
| * |
| * File: NABasicObject.cpp (previously under /common) |
| * Description: |
| * |
| * Created: 5/6/98 |
| * Language: C++ |
| * |
| * |
| * |
| **************************************************************************** |
| */ |
| |
| #include "Platform.h" |
| |
| #include <iosfwd> |
| using namespace std; |
| #include <stdlib.h> |
| |
| #include "ComASSERT.h" |
| #include "NAMemory.h" |
| #include "HeapLog.h" |
| |
| |
| //#include <cextdecs (DEBUG)> |
| |
| // ----------------------------------------------------------------------- |
| // Methods for NABasicObject |
| // ----------------------------------------------------------------------- |
| |
| // Here we cannot initialize the heap pointer because that would overwrite |
| // the value from the "operator new" below. |
| // Stack or statically allocated objects will just have random garbage in |
| // this field but as long as noone tries to "delete" them (as noone should) |
| // that will not matter (except to the Purify tool which may report UMR errors). |
| NABasicObject::NABasicObject() {} |
| |
| // Note that this just ignores the passed object, which is correct: |
| // we do *not* want to copy its heap pointer! |
| NABasicObject::NABasicObject(const NABasicObject&) {} |
| |
| // Note that this just ignores the passed object, which is correct: |
| // we do *not* want to copy its heap pointer! |
| // Otherwise, a default operator= on a NABasicObject-derived class would |
| // overwrite the heap pointer, a very bad thing. |
| NABasicObject& NABasicObject::operator=(const NABasicObject&) { return *this; } |
| |
| void* NABasicObject::operator new(size_t t, CollHeap* h, NABoolean failureIsFatal) |
| { |
| if (t < sizeof(NABasicObject)) |
| t = sizeof(NABasicObject); // always allocate some size. |
| |
| void* p; |
| |
| if (NOT_CHECK_NAHEAP(h)) |
| { |
| // This is asserted only because the check in 'operator delete' below |
| // depends on it -- but that check is rather half-baked anyway. |
| // So this is ComDEBUG (no-op if Release build) rather than ComABORT. |
| ComDEBUG(h != invalidHeapPtr()); |
| p = h->allocateMemory(t, failureIsFatal); |
| } |
| else |
| { |
| #ifdef NA_LEAK_DETECTION |
| get_caller_location(); |
| #endif |
| |
| |
| p = ::operator new(t); |
| // HEAPLOG_ADD_ENTRY(p, t, NA_HEAP_BASIC, "NABasic Heap") |
| } |
| |
| if (p) |
| ((NABasicObject*)p)->h_ = h; |
| else |
| { |
| if (failureIsFatal) |
| { |
| ComABORT(p); |
| } |
| } |
| |
| return p; |
| } |
| |
| void* NABasicObject::operator new(size_t t, void* loc, NAMemory* h) |
| { |
| if (loc != NULL) |
| { |
| ((NABasicObject*)loc)->h_ = h; |
| return loc; |
| } |
| return 0; |
| } |
| void NABasicObject::operator delete(void* p) |
| { |
| if (p) // "delete NULL;" is legal in C++, obviously a no-op |
| { |
| CollHeap* h = ((NABasicObject*)p)->h_; |
| |
| // ComDEBUG(h != invalidHeapPtr()); |
| if (h == invalidHeapPtr()) |
| { |
| #ifndef NDEBUG |
| cerr << "**WARNING: " << __FILE__ << ": " |
| << "Ignoring attempt to delete pointer twice " |
| << "(possible memory leak at " << p << "; need to run Purify)" |
| << endl; |
| #endif |
| return; |
| } |
| |
| ((NABasicObject*)p)->h_ = invalidHeapPtr(); |
| if (NOT_CHECK_NAHEAP(h)) |
| h->deallocateMemory(p); |
| else |
| { |
| // HEAPLOG_DELETE_ENTRY(p, NA_HEAP_BASIC) |
| ::operator delete(p); |
| } |
| } |
| } |
| |
| |
| void NABasicObject::operator delete(void* p, NAMemory*h, NABoolean f) |
| { |
| if (p) |
| { |
| if (NOT_CHECK_NAHEAP(h)) |
| h->deallocateMemory(p); |
| else |
| ::operator delete(p); |
| } |
| } |
| |
| void NABasicObject::operator delete(void* p, void*, NAMemory*) |
| { |
| // This shouldn't do anything. |
| } |
| |
| void* NABasicObject::operator new[](size_t t, CollHeap* h, NABoolean failureIsFatal) |
| { |
| if (t < sizeof(NABasicObject)) |
| t = sizeof(NABasicObject); // always allocate some size. |
| |
| void* p; |
| |
| if (NOT_CHECK_NAHEAP(h)) |
| { |
| // This is asserted only because the check in 'operator delete' below |
| // depends on it -- but that check is rather half-baked anyway. |
| // So this is ComDEBUG (no-op if Release build) rather than ComABORT. |
| ComDEBUG(h != invalidHeapPtr()); |
| p = h->allocateMemory(t, failureIsFatal); |
| } |
| else |
| { |
| |
| #ifdef NA_LEAK_DETECTION |
| get_caller_location(); |
| #endif |
| |
| |
| |
| p = ::operator new(t); |
| // HEAPLOG_ADD_ENTRY(p, t, NA_HEAP_BASIC, "NABasic Heap") |
| } |
| |
| if (p) |
| ((NABasicObject*)p)->h_ = h; |
| else |
| { |
| if (failureIsFatal) |
| { |
| ComABORT(p); |
| } |
| } |
| |
| return p; |
| } |
| |
| void NABasicObject::operator delete[](void* p) |
| { |
| #if 0 |
| if (p) // "delete NULL;" is legal in C++, obviously a no-op |
| { |
| //NGG CollHeap* h = ((NABasicObject*)p)->h_; |
| NAHeap* h = (NAHeap *) ((NABasicObject*)p)->h_; |
| |
| // ComDEBUG(h != invalidHeapPtr()); |
| if (h == invalidHeapPtr()) |
| { |
| #ifndef NDEBUG |
| cerr << "**WARNING: " << __FILE__ << ": " |
| << "Ignoring attempt to delete pointer twice " |
| << "(possible memory leak at " << p << "; need to run Purify)" |
| << endl; |
| #endif |
| return; |
| } |
| |
| ((NABasicObject*)p)->h_ = invalidHeapPtr(); |
| if (h) |
| h->deallocateMemory(p); |
| else |
| { |
| // HEAPLOG_DELETE_ENTRY(p, NA_HEAP_BASIC) |
| ::operator delete(p); |
| } |
| } |
| #endif |
| ::operator delete(p); |
| |
| } |
| |
| // This function will be called if the constructor throws an exception. |
| void NABasicObject::operator delete[](void* p, NAMemory* h, NABoolean) |
| { |
| if ( p ) { |
| if (NOT_CHECK_NAHEAP(h)) |
| h->deallocateMemory(p); |
| else |
| ::operator delete(p); |
| } |
| } |
| |
| // |
| //void* operator new[](size_t, NAMemory* h, NABoolean failureIsFatal) |
| //{ |
| //return NABasicObject::operator new(t, h, failureIsFatal); |
| //} |
| |
| //void* NABasicObject::operator delete[](void* p /* , another arg; see C++ ARM*/) |
| //{ |
| // We need to call multiple destructors here, one for each object in |
| // the array, and then deallocate ... |
| // NABasicObject::operator delete(p); /*won't work, no dtors called*/ |
| //} |
| |
| // Calls to this debugging method have been put into the getPtr methods in the |
| // optimizer; further bugproofing calls could be placed elsewhere. |
| // |
| // To debug, set a breakpoint at the "return -1", run the program, and see where |
| // you are when the invalid dereference occurs and what object type it is (was). |
| // You can then set a breakpoint in that object class's destructor to see when |
| // that particular instance is being destroyed and being marked invalid/free. |
| // (Although not actually being freed by deallocateMemory() yet -- which is why |
| // Purify can't find this "FMR" error, and also why your code continues to run |
| // okay FOR NOW; it may not on a future platform or future deallocation scheme. |
| // This finds latent bugs.) |
| |
| #if !defined(NDEBUG) |
| Int32 NABasicObject::checkInvalidObject(const void* const referencingObject) |
| { |
| if (this && maybeInvalidObject()) |
| { |
| Lng32 stackVar = (char*)this - (char*)&stackVar; |
| if (stackVar < 0) stackVar = -stackVar; |
| |
| cerr << "**ERROR: Object " << (void*)this; |
| |
| if (stackVar <= 8192) |
| cerr << " may be invalid (may be on stack, currently " |
| << (void*)&stackVar << ")"; |
| else |
| cerr << " is invalid"; |
| |
| if (referencingObject) |
| cerr << " (pointer from " << (void*)referencingObject << ")"; |
| |
| cerr << ".**" << endl; |
| |
| return -1; |
| } |
| return 0; |
| } |
| #endif |
| |
| // ----------------------------------------------------------------------- |
| // overloaded new operator for CollHeap* |
| // ----------------------------------------------------------------------- |
| |
| // The following new/delete operator should follow the rule of new |
| // operator, i.e. |
| // in the case of out of space, it should |
| // - call the new_handler if being set previously |
| // - if still no space, throw the bad_alloc exception. |
| // Since now the new/delete are used by executor, which can not |
| // take any global variables, need to make sure set_new_handler does |
| // not use any globals before using it. |
| // The compiler does not support exception yet. Should be done when |
| // the compiler supports exception. |
| // |
| void* operator new (size_t t, CollHeap* h) |
| { |
| |
| if (NOT_CHECK_NAHEAP(h)) |
| { |
| return h->allocateMemory(t); |
| } else { |
| |
| #ifdef NA_LEAK_DETECTION |
| get_caller_location(); |
| #endif |
| |
| |
| return (::new char[t] ); |
| } |
| |
| } |
| |
| void* operator new[] (size_t t, CollHeap* h) |
| { |
| //return ( (h) ? h->allocateMemory(t) : (::new char[t] ) ); |
| |
| if (NOT_CHECK_NAHEAP(h)) |
| { |
| return h->allocateMemory(t); |
| } else { |
| |
| #ifdef NA_LEAK_DETECTION |
| get_caller_location(); |
| #endif |
| |
| |
| return (::new char[t] ); |
| } |
| |
| } |
| |
| void* operator new[] (size_t t, CollHeap* h, NABoolean failureIsFatal) |
| { |
| if (NOT_CHECK_NAHEAP(h)) |
| { |
| return h->allocateMemory(t, failureIsFatal); |
| } else { |
| |
| #ifdef NA_LEAK_DETECTION |
| get_caller_location(); |
| #endif |
| |
| |
| return (::new char[t] ); |
| } |
| |
| } |
| |
