sal/cpprt/operators_new_delete.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <algorithm>
  21 #include <new>
  22 #include <string.h>
  23 #include <osl/diagnose.h>
  24 #include <rtl/alloc.h>
  25
  26 // =======================================================================
  27 // AllocatorTraits
  28 // =======================================================================
  29
  30 namespace
  31 {
  32
  33 struct AllocatorTraits
  34 {
  35     typedef char const signature_type[8];
  36     const signature_type & m_signature;
  37
  38     explicit AllocatorTraits (signature_type const & s) SAL_THROW(())
  39         : m_signature (s)
  40     {}
  41
  42     std::size_t size (std::size_t n) const SAL_THROW(())
  43     {
  44         n = std::max(n, std::size_t(1));
  45 #if OSL_DEBUG_LEVEL > 0
  46         n += sizeof(signature_type);
  47 #endif  /* OSL_DEBUG_LEVEL  */
  48         return n;
  49     }
  50
  51     void* init (void * p) const SAL_THROW(())
  52     {
  53 #if OSL_DEBUG_LEVEL > 0
  54         memcpy (p, m_signature, sizeof(signature_type));
  55         p = static_cast<char*>(p) + sizeof(signature_type);
  56 #endif  /* OSL_DEBUG_LEVEL */
  57         return p;
  58     }
  59
  60     void* fini (void * p) const SAL_THROW(())
  61     {
  62 #if OSL_DEBUG_LEVEL > 0
  63         p = static_cast<char*>(p) - sizeof(signature_type);
  64         if (memcmp (p, m_signature, sizeof(signature_type)) != 0)
  65         {
  66             OSL_FAIL("operator delete mismatch");
  67         }
  68 #endif  /* OSL_DEBUG_LEVEL */
  69         return p;
  70     }
  71 };
  72
  73 // =======================================================================
  74
  75 struct VectorTraits : public AllocatorTraits
  76 {
  77     static const signature_type g_signature;
  78
  79     VectorTraits() SAL_THROW(())
  80         : AllocatorTraits (g_signature)
  81     {}
  82 };
  83
  84 struct ScalarTraits : public AllocatorTraits
  85 {
  86     static const signature_type g_signature;
  87
  88     ScalarTraits() SAL_THROW(())
  89         : AllocatorTraits (g_signature)
  90     {}
  91 };
  92
  93 const AllocatorTraits::signature_type VectorTraits::g_signature = "new[]()";
  94 const AllocatorTraits::signature_type ScalarTraits::g_signature = "new()  ";
  95
  96 } // anonymous namespace
  97
  98 // =======================================================================
  99 // Allocator
 100 // =======================================================================
 101
 102 static void default_handler (void)
 103 {
 104     // Multithreading race in 'std::set_new_handler()' call sequence below.
 105     throw std::bad_alloc();
 106 }
 107
 108 // =======================================================================
 109
 110 static void* allocate (
 111     std::size_t n, AllocatorTraits const & rTraits)
 112     SAL_THROW((std::bad_alloc))
 113 {
 114     n = rTraits.size (n);
 115     for (;;)
 116     {
 117         void * p = rtl_allocateMemory (sal_Size(n));
 118         if (p != 0)
 119             return rTraits.init (p);
 120
 121         std::new_handler d = default_handler, f = std::set_new_handler (d);
 122         if (f != d)
 123             std::set_new_handler (f);
 124
 125         if (f == 0)
 126             throw std::bad_alloc();
 127         (*f)();
 128     }
 129 }
 130
 131 // =======================================================================
 132
 133 static void* allocate_nothrow (
 134     std::size_t n, AllocatorTraits const & rTraits)
 135     SAL_THROW(())
 136 {
 137     try
 138     {
 139         return allocate (n, rTraits);
 140     }
 141     catch (std::bad_alloc const &)
 142     {
 143         return (0);
 144     }
 145 }
 146
 147 // =======================================================================
 148
 149 static void deallocate (void * p, AllocatorTraits const & rTraits)
 150     SAL_THROW(())
 151 {
 152     if (p)
 153     {
 154         rtl_freeMemory (rTraits.fini(p));
 155     }
 156 }
 157
 158 // =======================================================================
 159 // T * p = new T; delete p;
 160 // =======================================================================
 161
 162 void* SAL_CALL operator new (std::size_t n) throw (std::bad_alloc)
 163 {
 164     return allocate (n, ScalarTraits());
 165 }
 166
 167 // =======================================================================
 168
 169 void SAL_CALL operator delete (void * p) throw ()
 170 {
 171     deallocate (p, ScalarTraits());
 172 }
 173
 174 // =======================================================================
 175 // T * p = new(nothrow) T; delete(nothrow) p;
 176 // =======================================================================
 177
 178 void* SAL_CALL operator new (std::size_t n, std::nothrow_t const &) throw ()
 179 {
 180     return allocate_nothrow (n, ScalarTraits());
 181 }
 182
 183 // =======================================================================
 184
 185 void SAL_CALL operator delete (void * p, std::nothrow_t const &) throw ()
 186 {
 187     deallocate (p, ScalarTraits());
 188 }
 189
 190 // =======================================================================
 191 // T * p = new T[n]; delete[] p;
 192 // =======================================================================
 193
 194 void* SAL_CALL operator new[] (std::size_t n) throw (std::bad_alloc)
 195 {
 196     return allocate (n, VectorTraits());
 197 }
 198
 199 // =======================================================================
 200
 201 void SAL_CALL operator delete[] (void * p) throw ()
 202 {
 203     deallocate (p, VectorTraits());
 204 }
 205
 206 // =======================================================================
 207 // T * p = new(nothrow) T[n]; delete(nothrow)[] p;
 208 // =======================================================================
 209
 210 void* SAL_CALL operator new[] (std::size_t n, std::nothrow_t const &) throw ()
 211 {
 212     return allocate_nothrow (n, VectorTraits());
 213 }
 214
 215 // =======================================================================
 216
 217 void SAL_CALL operator delete[] (void * p, std::nothrow_t const &) throw ()
 218 {
 219     deallocate (p, VectorTraits());
 220 }
 221
 222 // =======================================================================
 223
 224 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */