contrib/llvm/tools/lldb/include/lldb/Utility/SharingPtr.h

   1 //===---------------------SharingPtr.h --------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef utility_SharingPtr_h_
  11 #define utility_SharingPtr_h_
  12
  13 #include <algorithm>
  14 #include <memory>
  15
  16 //#define ENABLE_SP_LOGGING 1 // DON'T CHECK THIS LINE IN UNLESS COMMENTED OUT
  17 #if defined (ENABLE_SP_LOGGING)
  18
  19 extern "C" void track_sp (void *sp_this, void *ptr, long count);
  20
  21 #endif
  22
  23 namespace lldb_private {
  24
  25 namespace imp {
  26
  27 template <class T>
  28 inline T
  29 increment(T& t)
  30 {
  31     return __sync_add_and_fetch(&t, 1);
  32 }
  33
  34 template <class T>
  35 inline T
  36 decrement(T& t)
  37 {
  38     return __sync_add_and_fetch(&t, -1);
  39 }
  40
  41 class shared_count
  42 {
  43     shared_count(const shared_count&);
  44     shared_count& operator=(const shared_count&);
  45
  46 protected:
  47     long shared_owners_;
  48     virtual ~shared_count();
  49 private:
  50     virtual void on_zero_shared() = 0;
  51
  52 public:
  53     explicit shared_count(long refs = 0)
  54         : shared_owners_(refs) {}
  55
  56     void add_shared();
  57     void release_shared();
  58     long use_count() const {return shared_owners_ + 1;}
  59 };
  60
  61 template <class T>
  62 class shared_ptr_pointer
  63     : public shared_count
  64 {
  65     T data_;
  66 public:
  67     shared_ptr_pointer(T p)
  68         :  data_(p) {}
  69
  70 private:
  71     virtual void on_zero_shared();
  72
  73     // Outlaw copy constructor and assignment operator to keep effictive C++
  74     // warnings down to a minumum
  75     shared_ptr_pointer (const shared_ptr_pointer &);
  76     shared_ptr_pointer & operator=(const shared_ptr_pointer &);
  77 };
  78
  79 template <class T>
  80 void
  81 shared_ptr_pointer<T>::on_zero_shared()
  82 {
  83     delete data_;
  84 }
  85
  86 template <class T>
  87 class shared_ptr_emplace
  88     : public shared_count
  89 {
  90     T data_;
  91 public:
  92
  93     shared_ptr_emplace()
  94         :  data_() {}
  95
  96     template <class A0>
  97         shared_ptr_emplace(A0& a0)
  98             :  data_(a0) {}
  99
 100     template <class A0, class A1>
 101         shared_ptr_emplace(A0& a0, A1& a1)
 102             :  data_(a0, a1) {}
 103
 104     template <class A0, class A1, class A2>
 105         shared_ptr_emplace(A0& a0, A1& a1, A2& a2)
 106             :  data_(a0, a1, a2) {}
 107
 108     template <class A0, class A1, class A2, class A3>
 109         shared_ptr_emplace(A0& a0, A1& a1, A2& a2, A3& a3)
 110             :  data_(a0, a1, a2, a3) {}
 111
 112     template <class A0, class A1, class A2, class A3, class A4>
 113         shared_ptr_emplace(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4)
 114             :  data_(a0, a1, a2, a3, a4) {}
 115
 116 private:
 117     virtual void on_zero_shared();
 118 public:
 119     T* get() {return &data_;}
 120 };
 121
 122 template <class T>
 123 void
 124 shared_ptr_emplace<T>::on_zero_shared()
 125 {
 126 }
 127
 128 }  // namespace
 129
 130 template<class T>
 131 class SharingPtr
 132 {
 133 public:
 134     typedef T element_type;
 135 private:
 136     element_type*      ptr_;
 137     imp::shared_count* cntrl_;
 138
 139     struct nat {int for_bool_;};
 140 public:
 141     SharingPtr();
 142     template<class Y> explicit SharingPtr(Y* p);
 143     template<class Y> explicit SharingPtr(Y* p, imp::shared_count *ctrl_block);
 144     template<class Y> SharingPtr(const SharingPtr<Y>& r, element_type *p);
 145     SharingPtr(const SharingPtr& r);
 146     template<class Y>
 147         SharingPtr(const SharingPtr<Y>& r);
 148
 149     ~SharingPtr();
 150
 151     SharingPtr& operator=(const SharingPtr& r);
 152     template<class Y> SharingPtr& operator=(const SharingPtr<Y>& r);
 153
 154     void swap(SharingPtr& r);
 155     void reset();
 156     template<class Y> void reset(Y* p);
 157
 158     element_type* get() const {return ptr_;}
 159     element_type& operator*() const {return *ptr_;}
 160     element_type* operator->() const {return ptr_;}
 161     long use_count() const {return cntrl_ ? cntrl_->use_count() : 0;}
 162     bool unique() const {return use_count() == 1;}
 163     bool empty() const {return cntrl_ == 0;}
 164     operator nat*() const {return (nat*)get();}
 165
 166     static SharingPtr<T> make_shared();
 167
 168     template<class A0>
 169         static SharingPtr<T> make_shared(A0&);
 170
 171     template<class A0, class A1>
 172         static SharingPtr<T> make_shared(A0&, A1&);
 173
 174     template<class A0, class A1, class A2>
 175         static SharingPtr<T> make_shared(A0&, A1&, A2&);
 176
 177     template<class A0, class A1, class A2, class A3>
 178         static SharingPtr<T> make_shared(A0&, A1&, A2&, A3&);
 179
 180     template<class A0, class A1, class A2, class A3, class A4>
 181         static SharingPtr<T> make_shared(A0&, A1&, A2&, A3&, A4&);
 182
 183 private:
 184
 185     template <class U> friend class SharingPtr;
 186 };
 187
 188 template<class T>
 189 inline
 190 SharingPtr<T>::SharingPtr()
 191     : ptr_(0),
 192       cntrl_(0)
 193 {
 194 }
 195
 196 template<class T>
 197 template<class Y>
 198 SharingPtr<T>::SharingPtr(Y* p)
 199     : ptr_(p), cntrl_(0)
 200 {
 201     std::unique_ptr<Y> hold(p);
 202     typedef imp::shared_ptr_pointer<Y*> _CntrlBlk;
 203     cntrl_ = new _CntrlBlk(p);
 204     hold.release();
 205 }
 206
 207 template<class T>
 208 template<class Y>
 209 SharingPtr<T>::SharingPtr(Y* p, imp::shared_count *cntrl_block)
 210     : ptr_(p), cntrl_(cntrl_block)
 211 {
 212 }
 213
 214 template<class T>
 215 template<class Y>
 216 inline
 217 SharingPtr<T>::SharingPtr(const SharingPtr<Y>& r, element_type *p)
 218     : ptr_(p),
 219       cntrl_(r.cntrl_)
 220 {
 221     if (cntrl_)
 222         cntrl_->add_shared();
 223 }
 224
 225 template<class T>
 226 inline
 227 SharingPtr<T>::SharingPtr(const SharingPtr& r)
 228     : ptr_(r.ptr_),
 229       cntrl_(r.cntrl_)
 230 {
 231     if (cntrl_)
 232         cntrl_->add_shared();
 233 }
 234
 235 template<class T>
 236 template<class Y>
 237 inline
 238 SharingPtr<T>::SharingPtr(const SharingPtr<Y>& r)
 239     : ptr_(r.ptr_),
 240       cntrl_(r.cntrl_)
 241 {
 242     if (cntrl_)
 243         cntrl_->add_shared();
 244 }
 245
 246 template<class T>
 247 SharingPtr<T>::~SharingPtr()
 248 {
 249     if (cntrl_)
 250         cntrl_->release_shared();
 251 }
 252
 253 template<class T>
 254 inline
 255 SharingPtr<T>&
 256 SharingPtr<T>::operator=(const SharingPtr& r)
 257 {
 258     SharingPtr(r).swap(*this);
 259     return *this;
 260 }
 261
 262 template<class T>
 263 template<class Y>
 264 inline
 265 SharingPtr<T>&
 266 SharingPtr<T>::operator=(const SharingPtr<Y>& r)
 267 {
 268     SharingPtr(r).swap(*this);
 269     return *this;
 270 }
 271
 272 template<class T>
 273 inline
 274 void
 275 SharingPtr<T>::swap(SharingPtr& r)
 276 {
 277     std::swap(ptr_, r.ptr_);
 278     std::swap(cntrl_, r.cntrl_);
 279 }
 280
 281 template<class T>
 282 inline
 283 void
 284 SharingPtr<T>::reset()
 285 {
 286     SharingPtr().swap(*this);
 287 }
 288
 289 template<class T>
 290 template<class Y>
 291 inline
 292 void
 293 SharingPtr<T>::reset(Y* p)
 294 {
 295     SharingPtr(p).swap(*this);
 296 }
 297
 298 template<class T>
 299 SharingPtr<T>
 300 SharingPtr<T>::make_shared()
 301 {
 302     typedef imp::shared_ptr_emplace<T> CntrlBlk;
 303     SharingPtr<T> r;
 304     r.cntrl_ = new CntrlBlk();
 305     r.ptr_ = static_cast<CntrlBlk*>(r.cntrl_)->get();
 306     return r;
 307 }
 308
 309 template<class T>
 310 template<class A0>
 311 SharingPtr<T>
 312 SharingPtr<T>::make_shared(A0& a0)
 313 {
 314     typedef imp::shared_ptr_emplace<T> CntrlBlk;
 315     SharingPtr<T> r;
 316     r.cntrl_ = new CntrlBlk(a0);
 317     r.ptr_ = static_cast<CntrlBlk*>(r.cntrl_)->get();
 318     return r;
 319 }
 320
 321 template<class T>
 322 template<class A0, class A1>
 323 SharingPtr<T>
 324 SharingPtr<T>::make_shared(A0& a0, A1& a1)
 325 {
 326     typedef imp::shared_ptr_emplace<T> CntrlBlk;
 327     SharingPtr<T> r;
 328     r.cntrl_ = new CntrlBlk(a0, a1);
 329     r.ptr_ = static_cast<CntrlBlk*>(r.cntrl_)->get();
 330     return r;
 331 }
 332
 333 template<class T>
 334 template<class A0, class A1, class A2>
 335 SharingPtr<T>
 336 SharingPtr<T>::make_shared(A0& a0, A1& a1, A2& a2)
 337 {
 338     typedef imp::shared_ptr_emplace<T> CntrlBlk;
 339     SharingPtr<T> r;
 340     r.cntrl_ = new CntrlBlk(a0, a1, a2);
 341     r.ptr_ = static_cast<CntrlBlk*>(r.cntrl_)->get();
 342     return r;
 343 }
 344
 345 template<class T>
 346 template<class A0, class A1, class A2, class A3>
 347 SharingPtr<T>
 348 SharingPtr<T>::make_shared(A0& a0, A1& a1, A2& a2, A3& a3)
 349 {
 350     typedef imp::shared_ptr_emplace<T> CntrlBlk;
 351     SharingPtr<T> r;
 352     r.cntrl_ = new CntrlBlk(a0, a1, a2, a3);
 353     r.ptr_ = static_cast<CntrlBlk*>(r.cntrl_)->get();
 354     return r;
 355 }
 356
 357 template<class T>
 358 template<class A0, class A1, class A2, class A3, class A4>
 359 SharingPtr<T>
 360 SharingPtr<T>::make_shared(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4)
 361 {
 362     typedef imp::shared_ptr_emplace<T> CntrlBlk;
 363     SharingPtr<T> r;
 364     r.cntrl_ = new CntrlBlk(a0, a1, a2, a3, a4);
 365     r.ptr_ = static_cast<CntrlBlk*>(r.cntrl_)->get();
 366     return r;
 367 }
 368
 369 template<class T>
 370 inline
 371 SharingPtr<T>
 372 make_shared()
 373 {
 374     return SharingPtr<T>::make_shared();
 375 }
 376
 377 template<class T, class A0>
 378 inline
 379 SharingPtr<T>
 380 make_shared(A0& a0)
 381 {
 382     return SharingPtr<T>::make_shared(a0);
 383 }
 384
 385 template<class T, class A0, class A1>
 386 inline
 387 SharingPtr<T>
 388 make_shared(A0& a0, A1& a1)
 389 {
 390     return SharingPtr<T>::make_shared(a0, a1);
 391 }
 392
 393 template<class T, class A0, class A1, class A2>
 394 inline
 395 SharingPtr<T>
 396 make_shared(A0& a0, A1& a1, A2& a2)
 397 {
 398     return SharingPtr<T>::make_shared(a0, a1, a2);
 399 }
 400
 401 template<class T, class A0, class A1, class A2, class A3>
 402 inline
 403 SharingPtr<T>
 404 make_shared(A0& a0, A1& a1, A2& a2, A3& a3)
 405 {
 406     return SharingPtr<T>::make_shared(a0, a1, a2, a3);
 407 }
 408
 409 template<class T, class A0, class A1, class A2, class A3, class A4>
 410 inline
 411 SharingPtr<T>
 412 make_shared(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4)
 413 {
 414     return SharingPtr<T>::make_shared(a0, a1, a2, a3, a4);
 415 }
 416
 417
 418 template<class T, class U>
 419 inline
 420 bool
 421 operator==(const SharingPtr<T>& __x, const SharingPtr<U>& __y)
 422 {
 423     return __x.get() == __y.get();
 424 }
 425
 426 template<class T, class U>
 427 inline
 428 bool
 429 operator!=(const SharingPtr<T>& __x, const SharingPtr<U>& __y)
 430 {
 431     return !(__x == __y);
 432 }
 433
 434 template<class T, class U>
 435 inline
 436 bool
 437 operator<(const SharingPtr<T>& __x, const SharingPtr<U>& __y)
 438 {
 439     return __x.get() < __y.get();
 440 }
 441
 442 template<class T>
 443 inline
 444 void
 445 swap(SharingPtr<T>& __x, SharingPtr<T>& __y)
 446 {
 447     __x.swap(__y);
 448 }
 449
 450 template<class T, class U>
 451 inline
 452 SharingPtr<T>
 453 static_pointer_cast(const SharingPtr<U>& r)
 454 {
 455     return SharingPtr<T>(r, static_cast<T*>(r.get()));
 456 }
 457
 458 template<class T, class U>
 459 SharingPtr<T>
 460 const_pointer_cast(const SharingPtr<U>& r)
 461 {
 462     return SharingPtr<T>(r, const_cast<T*>(r.get()));
 463 }
 464
 465 template <class T>
 466 class LoggingSharingPtr
 467     : public SharingPtr<T>
 468 {
 469     typedef SharingPtr<T> base;
 470
 471 public:
 472     typedef void (*Callback)(void*, const LoggingSharingPtr&, bool action);
 473     // action:  false means increment just happened
 474     //          true  means decrement is about to happen
 475
 476 private:
 477     Callback cb_;
 478     void* baton_;
 479
 480 public:
 481     LoggingSharingPtr() : cb_(0), baton_(0) {}
 482     LoggingSharingPtr(Callback cb, void* baton)
 483         : cb_(cb), baton_(baton)
 484     {
 485         if (cb_)
 486             cb_(baton_, *this, false);
 487     }
 488
 489     template <class Y>
 490     LoggingSharingPtr(Y* p)
 491         : base(p), cb_(0), baton_(0) {}
 492
 493     template <class Y>
 494     LoggingSharingPtr(Y* p, Callback cb, void* baton)
 495         : base(p), cb_(cb), baton_(baton)
 496     {
 497         if (cb_)
 498             cb_(baton_, *this, false);
 499     }
 500
 501     ~LoggingSharingPtr()
 502     {
 503         if (cb_)
 504             cb_(baton_, *this, true);
 505     }
 506
 507     LoggingSharingPtr(const LoggingSharingPtr& p)
 508         : base(p), cb_(p.cb_), baton_(p.baton_)
 509     {
 510         if (cb_)
 511             cb_(baton_, *this, false);
 512     }
 513
 514     LoggingSharingPtr& operator=(const LoggingSharingPtr& p)
 515     {
 516         if (cb_)
 517             cb_(baton_, *this, true);
 518         base::operator=(p);
 519         cb_ = p.cb_;
 520         baton_ = p.baton_;
 521         if (cb_)
 522             cb_(baton_, *this, false);
 523         return *this;
 524     }
 525
 526     void reset()
 527     {
 528         if (cb_)
 529             cb_(baton_, *this, true);
 530         base::reset();
 531     }
 532
 533     template <class Y>
 534     void reset(Y* p)
 535     {
 536         if (cb_)
 537             cb_(baton_, *this, true);
 538         base::reset(p);
 539         if (cb_)
 540             cb_(baton_, *this, false);
 541     }
 542
 543     void SetCallback(Callback cb, void* baton)
 544     {
 545         cb_ = cb;
 546         baton_ = baton;
 547     }
 548
 549     void ClearCallback()
 550     {
 551         cb_ = 0;
 552         baton_ = 0;
 553     }
 554 };
 555
 556
 557 template <class T>
 558 class IntrusiveSharingPtr;
 559
 560 template <class T>
 561 class ReferenceCountedBase
 562 {
 563 public:
 564     explicit ReferenceCountedBase()
 565         : shared_owners_(-1)
 566     {
 567     }
 568
 569     void
 570     add_shared();
 571
 572     void
 573     release_shared();
 574
 575     long
 576     use_count() const
 577     {
 578         return shared_owners_ + 1;
 579     }
 580
 581 protected:
 582     long shared_owners_;
 583
 584     friend class IntrusiveSharingPtr<T>;
 585
 586 private:
 587     ReferenceCountedBase(const ReferenceCountedBase&);
 588     ReferenceCountedBase& operator=(const ReferenceCountedBase&);
 589 };
 590
 591     template <class T>
 592     void
 593     lldb_private::ReferenceCountedBase<T>::add_shared()
 594     {
 595         imp::increment(shared_owners_);
 596     }
 597
 598     template <class T>
 599     void
 600     lldb_private::ReferenceCountedBase<T>::release_shared()
 601     {
 602         if (imp::decrement(shared_owners_) == -1)
 603             delete static_cast<T*>(this);
 604     }
 605
 606
 607 template <class T>
 608 class ReferenceCountedBaseVirtual : public imp::shared_count
 609 {
 610 public:
 611     explicit ReferenceCountedBaseVirtual () :
 612         imp::shared_count(-1)
 613     {
 614     }
 615
 616     virtual
 617     ~ReferenceCountedBaseVirtual ()
 618     {
 619     }
 620
 621     virtual void on_zero_shared ();
 622
 623 };
 624
 625 template <class T>
 626 void
 627 ReferenceCountedBaseVirtual<T>::on_zero_shared()
 628 {
 629 }
 630
 631 template <typename T>
 632 class IntrusiveSharingPtr
 633 {
 634 public:
 635     typedef T element_type;
 636
 637     explicit
 638     IntrusiveSharingPtr () :
 639         ptr_(0)
 640     {
 641     }
 642
 643     explicit
 644     IntrusiveSharingPtr (T* ptr) :
 645         ptr_(ptr)
 646     {
 647         add_shared();
 648     }
 649
 650     IntrusiveSharingPtr (const IntrusiveSharingPtr& rhs) :
 651         ptr_(rhs.ptr_)
 652     {
 653         add_shared();
 654     }
 655
 656     template <class X>
 657     IntrusiveSharingPtr (const IntrusiveSharingPtr<X>& rhs)
 658         : ptr_(rhs.get())
 659     {
 660         add_shared();
 661     }
 662
 663     IntrusiveSharingPtr&
 664     operator= (const IntrusiveSharingPtr& rhs)
 665     {
 666         reset(rhs.get());
 667         return *this;
 668     }
 669
 670     template <class X> IntrusiveSharingPtr&
 671     operator= (const IntrusiveSharingPtr<X>& rhs)
 672     {
 673         reset(rhs.get());
 674         return *this;
 675     }
 676
 677     IntrusiveSharingPtr&
 678     operator= (T *ptr)
 679     {
 680         reset(ptr);
 681         return *this;
 682     }
 683
 684     ~IntrusiveSharingPtr()
 685     {
 686         release_shared();
 687 #if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
 688         // NULL out the pointer in objects which can help with leaks detection.
 689         // We don't enable this for LLDB_CONFIGURATION_BUILD_AND_INTEGRATION or
 690         // when none of the LLDB_CONFIGURATION_XXX macros are defined since
 691         // those would be builds for release. But for debug and release builds
 692         // that are for development, we NULL out the pointers to catch potential
 693         // issues.
 694         ptr_ = NULL;
 695 #endif  // #if defined (LLDB_CONFIGURATION_DEBUG) || defined (LLDB_CONFIGURATION_RELEASE)
 696     }
 697
 698     T&
 699     operator*() const
 700     {
 701         return *ptr_;
 702     }
 703
 704     T*
 705     operator->() const
 706     {
 707         return ptr_;
 708     }
 709
 710     T*
 711     get() const
 712     {
 713         return ptr_;
 714     }
 715
 716     operator bool() const
 717     {
 718         return ptr_ != 0;
 719     }
 720
 721     void
 722     swap (IntrusiveSharingPtr& rhs)
 723     {
 724         std::swap(ptr_, rhs.ptr_);
 725 #if defined (ENABLE_SP_LOGGING)
 726         track_sp (this, ptr_, use_count());
 727         track_sp (&rhs, rhs.ptr_, rhs.use_count());
 728 #endif
 729     }
 730
 731     void
 732     reset(T* ptr = NULL)
 733     {
 734         IntrusiveSharingPtr(ptr).swap(*this);
 735     }
 736
 737     long
 738     use_count () const
 739     {
 740         if (ptr_)
 741             return ptr_->use_count();
 742         return 0;
 743     }
 744
 745     bool
 746     unique () const
 747     {
 748         return use_count () == 1;
 749     }
 750
 751 private:
 752     element_type *ptr_;
 753
 754     void
 755     add_shared()
 756     {
 757         if (ptr_)
 758         {
 759             ptr_->add_shared();
 760 #if defined (ENABLE_SP_LOGGING)
 761             track_sp (this, ptr_, ptr_->use_count());
 762 #endif
 763         }
 764     }
 765     void
 766     release_shared()
 767     {
 768         if (ptr_)
 769         {
 770 #if defined (ENABLE_SP_LOGGING)
 771             track_sp (this, NULL, ptr_->use_count() - 1);
 772 #endif
 773             ptr_->release_shared();
 774         }
 775     }
 776 };
 777
 778 template<class T, class U>
 779 inline bool operator== (const IntrusiveSharingPtr<T>& lhs, const IntrusiveSharingPtr<U>& rhs)
 780 {
 781     return lhs.get() == rhs.get();
 782 }
 783
 784 template<class T, class U>
 785 inline bool operator!= (const IntrusiveSharingPtr<T>& lhs, const IntrusiveSharingPtr<U>& rhs)
 786 {
 787     return lhs.get() != rhs.get();
 788 }
 789
 790 template<class T, class U>
 791 inline bool operator== (const IntrusiveSharingPtr<T>& lhs, U* rhs)
 792 {
 793     return lhs.get() == rhs;
 794 }
 795
 796 template<class T, class U>
 797 inline bool operator!= (const IntrusiveSharingPtr<T>& lhs, U* rhs)
 798 {
 799     return lhs.get() != rhs;
 800 }
 801
 802 template<class T, class U>
 803 inline bool operator== (T* lhs, const IntrusiveSharingPtr<U>& rhs)
 804 {
 805     return lhs == rhs.get();
 806 }
 807
 808 template<class T, class U>
 809 inline bool operator!= (T* lhs, const IntrusiveSharingPtr<U>& rhs)
 810 {
 811     return lhs != rhs.get();
 812 }
 813
 814 } // namespace lldb_private
 815
 816 #endif  // utility_SharingPtr_h_