.

1 files changed, 96 insertions, 86 deletions

diff --git a/ace/Malloc_T.cpp b/ace/Malloc_T.cpp
index 946e026b256..939bbd4d594 100644
--- a/ace/Malloc_T.cpp
+++ b/ace/Malloc_T.cpp
@@ -101,17 +101,18 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::print_stats (void) const
     return;
   this->cb_ptr_->malloc_stats_.dump ();
   ACE_DEBUG ((LM_DEBUG,
-              ASYS_TEXT (" (%P|%t) contents of freelist:\n")));
+              ASYS_TEXT ("(%P|%t) contents of freelist:\n")));
 
-  for (ACE_Malloc_Header::HEADER_PTR currp = this->cb_ptr_->freep_->s_.next_block_;
+  for (ACE_Malloc_Header *currp = ACE_POINTER_CAST (this->cb_ptr_->freep_->s_.next_block_);
        ;
-       currp = currp->s_.next_block_)
+       currp = ACE_POINTER_CAST (currp->s_.next_block_))
     {
       ACE_DEBUG ((LM_DEBUG,
-                  ASYS_TEXT (" (%P|%t) ptr = %u, ACE_Malloc_Header units = %d, byte units = %d\n"),
-                  currp, currp->s_.size_,
+                  ASYS_TEXT ("(%P|%t) ptr = %u, ACE_Malloc_Header units = %d, byte units = %d\n"),
+                  currp,
+                  currp->s_.size_,
                   currp->s_.size_ * sizeof (ACE_Malloc_Header)));
-      if (currp == this->cb_ptr_->freep_)
+      if (currp == ACE_POINTER_CAST (this->cb_ptr_->freep_))
         break;
     }
 }
@@ -150,12 +151,12 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::open (void)
                                      first_time);
   if (this->cb_ptr_ == 0)
     ACE_ERROR_RETURN ((LM_ERROR,
-                       ASYS_TEXT (" (%P|%t) %p\n"),
+                       ASYS_TEXT ("(%P|%t) %p\n"),
                        ASYS_TEXT ("init_acquire failed")),
                       -1);
   else if (first_time)
     {
-      // ACE_DEBUG ((LM_DEBUG, ASYS_TEXT (" (%P|%t) first time in, control block = %u\n"), this->cb_ptr_));
+      // ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%P|%t) first time in, control block = %u\n"), this->cb_ptr_));
 
 #if defined (ACE_HAS_MALLOC_STATS)
       // Call the constructor on the ACE_LOCK, using the placement
@@ -163,23 +164,30 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::open (void)
       new ((void *) &this->cb_ptr_->malloc_stats_) ACE_Malloc_Stats;
 #endif /* ACE_HAS_MALLOC_STATS */
 
+#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
       // Initialize the freelist pointer to point to the dummy
-      // ACE_Malloc_Header.
+      // <ACE_Malloc_Header>.
+      new ((void *) &this->cb_ptr_->freep_) ACE_Malloc_Header::HEADER_PTR (&this->cb_ptr_->base_);
+      new ((void *) &this->cb_ptr_->name_head_) ACE_Based_Pointer<ACE_Name_Node>;
+#else
+      // Initialize the freelist pointer to point to the dummy
+      // <ACE_Malloc_Header>.
       this->cb_ptr_->freep_ = &this->cb_ptr_->base_;
+      // initialize the name list to 0
+#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
 
-      // Initialize the dummy ACE_Malloc_Header to point to itself.
-      this->cb_ptr_->freep_->s_.size_ = 0;
-      this->cb_ptr_->freep_->s_.next_block_ = this->cb_ptr_->freep_;
+      this->cb_ptr_->name_head_ = (ACE_Name_Node *) 0;
 
-      // initialize the name list to 0
-      this->cb_ptr_->name_head_ = 0;
+      // Initialize the dummy <ACE_Malloc_Header> to point to itself.
+      this->cb_ptr_->freep_->s_.size_ = 0;
+      this->cb_ptr_->freep_->s_.next_block_ = ACE_POINTER_CAST (this->cb_ptr_->freep_);
 
       if (rounded_bytes > (sizeof *this->cb_ptr_ + sizeof (ACE_Malloc_Header)))
         {
           // If we've got any extra space at the end of the control
           // block, then skip past the dummy ACE_Malloc_Header to
           // point at the first free block.
-          ACE_Malloc_Header::HEADER_PTR p (this->cb_ptr_->freep_ + 1);
+          ACE_Malloc_Header *p = ACE_POINTER_CAST (this->cb_ptr_->freep_) + 1;
 
           // Why aC++ in 64-bit mode can't grok this, I have no
           // idea... but it ends up with an extra bit set which makes
@@ -197,12 +205,10 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::open (void)
           AMS (++this->cb_ptr_->malloc_stats_.nblocks_);
           AMS (++this->cb_ptr_->malloc_stats_.ninuse_);
 
-          // Skip over the ACE_Malloc_Header when returning pointer.
-          ACE_Malloc_Header::HEADER_PTR tmp (p + 1);
           // Insert the newly allocated chunk of memory into the free
-          // list.  Note that this triggers operator void *() if we're
-          // using the ACE_POSITION_INDEPENDENT_MALLOC configuration.
-          this->shared_free ((void *) tmp);
+          // list.  Skip over the ACE_Malloc_Header when returning
+          // pointer.
+          this->shared_free (p + 1);
         }
     }
   return 0;
@@ -265,7 +271,7 @@ template <ACE_MEM_POOL_1, class ACE_LOCK> int
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::remove (void)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::remove");
-  // ACE_DEBUG ((LM_DEBUG, ASYS_TEXT (" (%P|%t) destroying ACE_Malloc\n")));
+  // ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%P|%t) destroying ACE_Malloc\n")));
   int result = 0;
 
 #if defined (ACE_HAS_MALLOC_STATS)
@@ -298,20 +304,20 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
 
   // Begin the search starting at the place in the freelist where the
   // last block was found.
-  ACE_Malloc_Header::HEADER_PTR prevp = this->cb_ptr_->freep_;
-  ACE_Malloc_Header::HEADER_PTR currp = prevp->s_.next_block_;
+  ACE_Malloc_Header *prevp = ACE_POINTER_CAST (this->cb_ptr_->freep_);
+  ACE_Malloc_Header *currp = ACE_POINTER_CAST (prevp->s_.next_block_);
 
   // Search the freelist to locate a block of the appropriate size.
 
   for (int i = 0;
-       ; i++, prevp = currp, currp = currp->s_.next_block_)
+       ; i++, prevp = currp, currp = ACE_POINTER_CAST (currp->s_.next_block_))
     {
       if (currp->s_.size_ >= nunits) // Big enough
         {
           AMS (++this->cb_ptr_->malloc_stats_.ninuse_);
           if (currp->s_.size_ == nunits)
             // Exact size, just update the pointers.
-            prevp->s_.next_block_ = currp->s_.next_block_;
+            prevp->s_.next_block_ = ACE_POINTER_CAST (currp->s_.next_block_);
           else
             {
               // Remaining chunk is larger than requested block, so
@@ -324,13 +330,9 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
           this->cb_ptr_->freep_ = prevp;
 
           // Skip over the ACE_Malloc_Header when returning pointer.
-          ACE_Malloc_Header::HEADER_PTR tmp (currp + 1);
-          // Insert the newly allocated chunk of memory into the free
-          // list.  Note that this triggers operator void *() if we're
-          // using the ACE_POSITION_INDEPENDENT_MALLOC configuration.
-          return (void *) tmp;
+          return currp + 1;
         }
-      else if (currp == this->cb_ptr_->freep_)
+      else if (currp == ACE_POINTER_CAST (this->cb_ptr_->freep_))
         {
           // We've wrapped around freelist without finding a block.
           // Therefore, we need to ask the memory pool for a new chunk
@@ -338,9 +340,11 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
 
           size_t chunk_bytes = 0;
 
-          if ((currp = (ACE_Malloc_Header *)
-               this->memory_pool_.acquire (nunits * sizeof (ACE_Malloc_Header),
-                                           chunk_bytes)) != 0)
+          currp = (ACE_Malloc_Header *)
+            this->memory_pool_.acquire (nunits * sizeof (ACE_Malloc_Header),
+                                        chunk_bytes);
+
+          if (currp != 0)
             {
               AMS (++this->cb_ptr_->malloc_stats_.nblocks_);
               AMS (++this->cb_ptr_->malloc_stats_.nchunks_);
@@ -349,17 +353,15 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
               // Compute the chunk size in ACE_Malloc_Header units.
               currp->s_.size_ = chunk_bytes / sizeof (ACE_Malloc_Header);
 
-              // Skip over the ACE_Malloc_Header when returning pointer.
-              ACE_Malloc_Header::HEADER_PTR tmp (currp + 1);
-              // Insert the newly allocated chunk of memory into the free
-              // list.  Note that this triggers operator void *() if we're
-              // using the ACE_POSITION_INDEPENDENT_MALLOC configuration.
-              this->shared_free ((void *) tmp);
-              currp = this->cb_ptr_->freep_;
+              // Insert the newly allocated chunk of memory into the
+              // free list.  Skip over the ACE_Malloc_Header when
+              // returning pointer.
+              this->shared_free (currp + 1);
+              currp = ACE_POINTER_CAST (this->cb_ptr_->freep_);
             }
           else
             ACE_ERROR_RETURN ((LM_ERROR,
-                               ASYS_TEXT (" (%P|%t) %p\n"),
+                               ASYS_TEXT ("(%P|%t) %p\n"),
                                ASYS_TEXT ("malloc")),
                               0);
         }
@@ -403,37 +405,38 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_free (void *ap)
     return;
 
   // Adjust AP to point to the block ACE_Malloc_Header
-  ACE_Malloc_Header::HEADER_PTR blockp ((ACE_Malloc_Header *) ap - 1);
-  ACE_Malloc_Header::HEADER_PTR currp = this->cb_ptr_->freep_;
+  ACE_Malloc_Header *blockp = (ACE_Malloc_Header *) ap - 1;
+  ACE_Malloc_Header *currp = ACE_POINTER_CAST (this->cb_ptr_->freep_);
 
   // Search until we find the location where the blocks belongs.  Note
   // that addresses are kept in sorted order.
 
   for (;
-       blockp <= currp || blockp >= currp->s_.next_block_;
-       currp = currp->s_.next_block_)
+       blockp <= currp || blockp >= ACE_POINTER_CAST (currp->s_.next_block_);
+       currp = ACE_POINTER_CAST (currp->s_.next_block_))
     {
-      if (currp >= currp->s_.next_block_
-          && (blockp > currp || blockp < currp->s_.next_block_))
-        // Freed block at the start or the end of the memory pool
+      if (currp >= ACE_POINTER_CAST (currp->s_.next_block_)
+          && (blockp > currp || blockp < ACE_POINTER_CAST (currp->s_.next_block_)))
+        // Freed block at the start or the end of the memory pool.
         break;
     }
 
-  // Join to upper neighbor
-  if (blockp + blockp->s_.size_ == currp->s_.next_block_)
+  // Join to upper neighbor.
+  if (blockp + blockp->s_.size_ == ACE_POINTER_CAST (currp->s_.next_block_))
     {
       AMS (--this->cb_ptr_->malloc_stats_.nblocks_);
       blockp->s_.size_ += currp->s_.next_block_->s_.size_;
-      blockp->s_.next_block_ = currp->s_.next_block_->s_.next_block_;
+      blockp->s_.next_block_ = ACE_POINTER_CAST (currp->s_.next_block_->s_.next_block_);
     }
   else
-    blockp->s_.next_block_ = currp->s_.next_block_;
+    blockp->s_.next_block_ = ACE_POINTER_CAST (currp->s_.next_block_);
 
-  if (currp + currp->s_.size_ == blockp) // Join to lower neighbor
+  // Join to lower neighbor.
+  if (currp + currp->s_.size_ == blockp) 
     {
       AMS (--this->cb_ptr_->malloc_stats_.nblocks_);
       currp->s_.size_ += blockp->s_.size_;
-      currp->s_.next_block_ = blockp->s_.next_block_;
+      currp->s_.next_block_ = ACE_POINTER_CAST (blockp->s_.next_block_);
     }
   else
     currp->s_.next_block_ = blockp;
@@ -452,10 +455,10 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_find (const char *name)
   if (this->cb_ptr_ == 0)
     return 0;
 
-  for (ACE_Name_Node *node = this->cb_ptr_->name_head_;
+  for (ACE_Name_Node *node = ACE_POINTER_CAST (this->cb_ptr_->name_head_);
        node != 0;
-       node = node->next_)
-    if (ACE_OS::strcmp (node->name_,
+       node = ACE_POINTER_CAST (node->next_))
+    if (ACE_OS::strcmp (node->name (),
                         name) == 0)
       return node;
 
@@ -470,28 +473,31 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind (const char *name,
     return -1;
 
   // Combine the two allocations into one to avoid overhead...
-  ACE_Name_Node *new_node;
+  ACE_Name_Node *new_node = 0;
 
   ACE_ALLOCATOR_RETURN (new_node,
                         (ACE_Name_Node *)
                         this->shared_malloc (sizeof (ACE_Name_Node) + ACE_OS::strlen (name) + 1),
                         -1);
 
-  // This is a clever trick ;-)
+  // This is a clever trick that skips over the <ACE_Name_Node> chunk
+  // and points to where the string name goes.
   new_node->name_ = (char *) (new_node + 1);
 
   // Insert new node at the head of the list.  Note that (new_node) is
   // *not* a cast, it's operator placement new.
   ACE_NEW_RETURN (this->cb_ptr_->name_head_,
-                  (new_node) ACE_Name_Node (name, pointer,
-                                            this->cb_ptr_->name_head_),
+                  (new_node) ACE_Name_Node (name,
+                                            ACE_reinterpret_cast (char *,
+                                                                  pointer),
+                                            ACE_POINTER_CAST (this->cb_ptr_->name_head_)),
                   -1);
   return 0;
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::trybind (const char *name,
-                                     void *&pointer)
+                                               void *&pointer)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::trybind");
   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
@@ -503,15 +509,16 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::trybind (const char *name,
   else
     {
       // Found it, so return a copy of the current entry.
-      pointer = node->pointer_;
+      pointer = ACE_reinterpret_cast (void *,
+                                      ACE_POINTER_CAST (node->pointer_));
       return 1;
     }
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::bind (const char *name,
-                                        void *pointer,
-                                        int duplicates)
+                                            void *pointer,
+                                            int duplicates)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::bind");
   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
@@ -528,7 +535,8 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::bind (const char *name,
 }
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
-ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::find (const char *name, void *&pointer)
+ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::find (const char *name,
+                                            void *&pointer)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::find");
 
@@ -540,7 +548,8 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::find (const char *name, void *&pointer)
     return -1;
   else
     {
-      pointer = node->pointer_;
+      pointer = ACE_reinterpret_cast (void *,
+                                      ACE_POINTER_CAST (node->pointer_));
       return 0;
     }
 }
@@ -567,10 +576,10 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::avail_chunks (size_t size) const
   // Avoid dividing by 0...
   size = size == 0 ? 1 : size;
 
-  for (ACE_Malloc_Header::HEADER_PTR currp = this->cb_ptr_->freep_->s_.next_block_;
-       currp != this->cb_ptr_->freep_;
-       currp = currp->s_.next_block_)
-    // calculate how many will fit in this block.
+  for (ACE_Malloc_Header *currp = ACE_POINTER_CAST (this->cb_ptr_->freep_->s_.next_block_);
+       currp != ACE_POINTER_CAST (this->cb_ptr_->freep_);
+       currp = ACE_POINTER_CAST (currp->s_.next_block_))
+    // Calculate how many will fit in this block.
     if (currp->s_.size_ * sizeof (ACE_Malloc_Header) >= size)
       count += currp->s_.size_ * sizeof (ACE_Malloc_Header) / size;
 
@@ -597,18 +606,18 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::unbind (const char *name, void *&pointer)
 
   ACE_Name_Node *prev = 0;
 
-  for (ACE_Name_Node *curr = this->cb_ptr_->name_head_;
+  for (ACE_Name_Node *curr = ACE_POINTER_CAST (this->cb_ptr_->name_head_);
        curr != 0;
-       curr = curr->next_)
+       curr = ACE_POINTER_CAST (curr->next_))
     {
-      if (ACE_OS::strcmp (curr->name_, name) == 0)
+      if (ACE_OS::strcmp (curr->name (), name) == 0)
         {
-          pointer = curr->pointer_;
+          pointer = ACE_POINTER_CAST (curr->pointer_);
 
           if (prev == 0)
-            this->cb_ptr_->name_head_ = curr->next_;
+            this->cb_ptr_->name_head_ = ACE_POINTER_CAST (curr->next_);
           else
-            prev->next_ = curr->next_;
+            prev->next_ = ACE_POINTER_CAST (curr->next_);
 
           // This will free up both the node and the name due to our
           // clever trick in <bind>!
@@ -654,9 +663,10 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Malloc_Iterator (ACE_Malloc<A
 {
   ACE_TRACE ("ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Malloc_Iterator");
   // Cheap trick to make code simple.
+  // @@ Doug, this looks like trouble...
   ACE_Name_Node temp;
   this->curr_ = &temp;
-  this->curr_->next_ = malloc_.cb_ptr_->name_head_;
+  this->curr_->next_ = ACE_POINTER_CAST (malloc_.cb_ptr_->name_head_);
 
   this->advance ();
 }
@@ -669,14 +679,14 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::~ACE_Malloc_Iterator (void)
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::next (void *&next_entry,
-                                                 char *&name)
+                                                     const char *&name)
 {
   ACE_TRACE ("ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::next");
 
   if (this->curr_ != 0)
     {
-      next_entry = this->curr_->pointer_;
-      name = this->curr_->name_;
+      next_entry = ACE_POINTER_CAST (this->curr_->pointer_);
+      name = this->curr_->name ();
       return 1;
     }
   else
@@ -690,7 +700,7 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::next (void *&next_entry)
 
   if (this->curr_ != 0)
     {
-      next_entry = this->curr_->pointer_;
+      next_entry = ACE_POINTER_CAST (this->curr_->pointer_);
       return 1;
     }
   else
@@ -710,14 +720,14 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::advance (void)
 {
   ACE_TRACE ("ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::advance");
 
-  this->curr_ = this->curr_->next_;
+  this->curr_ = ACE_POINTER_CAST (this->curr_->next_);
 
   if (this->name_ == 0)
     return this->curr_ != 0;
 
   while (this->curr_ != 0
-         && ACE_OS::strcmp (this->name_, this->curr_->name_) != 0)
-    this->curr_ = this->curr_->next_;
+         && ACE_OS::strcmp (this->name_, this->curr_->name ()) != 0)
+    this->curr_ = ACE_POINTER_CAST (this->curr_->next_);
 
   return this->curr_ != 0;
 }