LCOV - code coverage report
Current view: top level - include/llvm/IR - TrackingMDRef.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 49 49 100.0 %
Date: 2017-09-14 15:23:50 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/IR/TrackingMDRef.h - Tracking Metadata references ---*- 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             : // References to metadata that track RAUW.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_IR_TRACKINGMDREF_H
      15             : #define LLVM_IR_TRACKINGMDREF_H
      16             : 
      17             : #include "llvm/IR/Metadata.h"
      18             : #include <algorithm>
      19             : #include <cassert>
      20             : 
      21             : namespace llvm {
      22             : 
      23             : /// \brief Tracking metadata reference.
      24             : ///
      25             : /// This class behaves like \a TrackingVH, but for metadata.
      26             : class TrackingMDRef {
      27             :   Metadata *MD = nullptr;
      28             : 
      29             : public:
      30    24584775 :   TrackingMDRef() = default;
      31     7762797 :   explicit TrackingMDRef(Metadata *MD) : MD(MD) { track(); }
      32             : 
      33    62740942 :   TrackingMDRef(TrackingMDRef &&X) : MD(X.MD) { retrack(X); }
      34   280176825 :   TrackingMDRef(const TrackingMDRef &X) : MD(X.MD) { track(); }
      35             : 
      36    57931756 :   TrackingMDRef &operator=(TrackingMDRef &&X) {
      37    57931756 :     if (&X == this)
      38             :       return *this;
      39             : 
      40    57931756 :     untrack();
      41    57931756 :     MD = X.MD;
      42             :     retrack(X);
      43             :     return *this;
      44             :   }
      45             : 
      46     5891220 :   TrackingMDRef &operator=(const TrackingMDRef &X) {
      47     5891220 :     if (&X == this)
      48             :       return *this;
      49             : 
      50     5889770 :     untrack();
      51     5889770 :     MD = X.MD;
      52             :     track();
      53             :     return *this;
      54             :   }
      55             : 
      56   189360079 :   ~TrackingMDRef() { untrack(); }
      57             : 
      58   202630440 :   Metadata *get() const { return MD; }
      59      224098 :   operator Metadata *() const { return get(); }
      60             :   Metadata *operator->() const { return get(); }
      61             :   Metadata &operator*() const { return *get(); }
      62             : 
      63             :   void reset() {
      64           1 :     untrack();
      65           1 :     MD = nullptr;
      66             :   }
      67      215714 :   void reset(Metadata *MD) {
      68      215762 :     untrack();
      69      215762 :     this->MD = MD;
      70      215762 :     track();
      71      215714 :   }
      72             : 
      73             :   /// \brief Check whether this has a trivial destructor.
      74             :   ///
      75             :   /// If \c MD isn't replaceable, the destructor will be a no-op.
      76             :   bool hasTrivialDestructor() const {
      77             :     return !MD || !MetadataTracking::isReplaceable(*MD);
      78             :   }
      79             : 
      80     1537095 :   bool operator==(const TrackingMDRef &X) const { return MD == X.MD; }
      81     2379051 :   bool operator!=(const TrackingMDRef &X) const { return MD != X.MD; }
      82             : 
      83             : private:
      84             :   void track() {
      85   148927332 :     if (MD)
      86    99268836 :       MetadataTracking::track(MD);
      87             :   }
      88             : 
      89             :   void untrack() {
      90   253313671 :     if (MD)
      91    87679859 :       MetadataTracking::untrack(MD);
      92             :   }
      93             : 
      94             :   void retrack(TrackingMDRef &X) {
      95             :     assert(MD == X.MD && "Expected values to match");
      96    89506553 :     if (X.MD) {
      97   121542650 :       MetadataTracking::retrack(X.MD, MD);
      98    60770503 :       X.MD = nullptr;
      99             :     }
     100             :   }
     101             : };
     102             : 
     103             : /// \brief Typed tracking ref.
     104             : ///
     105             : /// Track refererences of a particular type.  It's useful to use this for \a
     106             : /// MDNode and \a ValueAsMetadata.
     107   378082848 : template <class T> class TypedTrackingMDRef {
     108             :   TrackingMDRef Ref;
     109             : 
     110             : public:
     111    62412449 :   TypedTrackingMDRef() = default;
     112     7710059 :   explicit TypedTrackingMDRef(T *MD) : Ref(static_cast<Metadata *>(MD)) {}
     113             : 
     114    62470939 :   TypedTrackingMDRef(TypedTrackingMDRef &&X) : Ref(std::move(X.Ref)) {}
     115   280165802 :   TypedTrackingMDRef(const TypedTrackingMDRef &X) : Ref(X.Ref) {}
     116             : 
     117             :   TypedTrackingMDRef &operator=(TypedTrackingMDRef &&X) {
     118    57931756 :     Ref = std::move(X.Ref);
     119             :     return *this;
     120             :   }
     121             : 
     122             :   TypedTrackingMDRef &operator=(const TypedTrackingMDRef &X) {
     123     5891220 :     Ref = X.Ref;
     124             :     return *this;
     125             :   }
     126             : 
     127   398467927 :   T *get() const { return (T *)Ref.get(); }
     128   180175477 :   operator T *() const { return get(); }
     129       58841 :   T *operator->() const { return get(); }
     130             :   T &operator*() const { return *get(); }
     131             : 
     132     3074190 :   bool operator==(const TypedTrackingMDRef &X) const { return Ref == X.Ref; }
     133     4758900 :   bool operator!=(const TypedTrackingMDRef &X) const { return Ref != X.Ref; }
     134             : 
     135           2 :   void reset() { Ref.reset(); }
     136       81048 :   void reset(T *MD) { Ref.reset(static_cast<Metadata *>(MD)); }
     137             : 
     138             :   /// \brief Check whether this has a trivial destructor.
     139             :   bool hasTrivialDestructor() const { return Ref.hasTrivialDestructor(); }
     140             : };
     141             : 
     142             : using TrackingMDNodeRef = TypedTrackingMDRef<MDNode>;
     143             : using TrackingValueAsMetadataRef = TypedTrackingMDRef<ValueAsMetadata>;
     144             : 
     145             : // Expose the underlying metadata to casting.
     146             : template <> struct simplify_type<TrackingMDRef> {
     147             :   using SimpleType = Metadata *;
     148             : 
     149       13449 :   static SimpleType getSimplifiedValue(TrackingMDRef &MD) { return MD.get(); }
     150             : };
     151             : 
     152             : template <> struct simplify_type<const TrackingMDRef> {
     153             :   using SimpleType = Metadata *;
     154             : 
     155             :   static SimpleType getSimplifiedValue(const TrackingMDRef &MD) {
     156       11536 :     return MD.get();
     157             :   }
     158             : };
     159             : 
     160             : template <class T> struct simplify_type<TypedTrackingMDRef<T>> {
     161             :   using SimpleType = T *;
     162             : 
     163             :   static SimpleType getSimplifiedValue(TypedTrackingMDRef<T> &MD) {
     164      937037 :     return MD.get();
     165             :   }
     166             : };
     167             : 
     168             : template <class T> struct simplify_type<const TypedTrackingMDRef<T>> {
     169             :   using SimpleType = T *;
     170             : 
     171             :   static SimpleType getSimplifiedValue(const TypedTrackingMDRef<T> &MD) {
     172         105 :     return MD.get();
     173             :   }
     174             : };
     175             : 
     176             : } // end namespace llvm
     177             : 
     178             : #endif // LLVM_IR_TRACKINGMDREF_H

Generated by: LCOV version 1.13