[ptr-traits] Merge the MetadataTracking helpers into the Metadata

header.

This is part of a series of patches to allow LLVM to check for complete
pointee types when computing its pointer traits. This is absolutely
necessary to get correct (or reproducible) results for things like how
many low bits are guaranteed to be zero.

The MetadataTracking helpers aren't actually independent. They rely on
constructing a PointerUnion between Metadata and MetadataAsValue
pointers, which requires know the alignment of pointers to those types
which requires them to be complete.

The .cpp file even defined a method declared in Metadata.h! These really
don't seem like something that is separable, and there is no real
layering problem with just placing them together.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@256531 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/IR/Metadata.h b/include/llvm/IR/Metadata.h
index 2e9dc457bb00e0777428b5cf182a67f50f7989c5..2ea591383f82543d22fe42233e8593f044857770 100644 (file)
--- a/include/llvm/IR/Metadata.h
+++ b/include/llvm/IR/Metadata.h
@@ -18,10 +18,11 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Constant.h"
-#include "llvm/IR/MetadataTracking.h"
+#include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <type_traits>
@@ -196,6 +197,77 @@ private:
   void untrack();
 };
 
+/// \brief API for tracking metadata references through RAUW and deletion.
+///
+/// Shared API for updating \a Metadata pointers in subclasses that support
+/// RAUW.
+///
+/// This API is not meant to be used directly.  See \a TrackingMDRef for a
+/// user-friendly tracking reference.
+class MetadataTracking {
+public:
+  /// \brief Track the reference to metadata.
+  ///
+  /// Register \c MD with \c *MD, if the subclass supports tracking.  If \c *MD
+  /// gets RAUW'ed, \c MD will be updated to the new address.  If \c *MD gets
+  /// deleted, \c MD will be set to \c nullptr.
+  ///
+  /// If tracking isn't supported, \c *MD will not change.
+  ///
+  /// \return true iff tracking is supported by \c MD.
+  static bool track(Metadata *&MD) {
+    return track(&MD, *MD, static_cast<Metadata *>(nullptr));
+  }
+
+  /// \brief Track the reference to metadata for \a Metadata.
+  ///
+  /// As \a track(Metadata*&), but with support for calling back to \c Owner to
+  /// tell it that its operand changed.  This could trigger \c Owner being
+  /// re-uniqued.
+  static bool track(void *Ref, Metadata &MD, Metadata &Owner) {
+    return track(Ref, MD, &Owner);
+  }
+
+  /// \brief Track the reference to metadata for \a MetadataAsValue.
+  ///
+  /// As \a track(Metadata*&), but with support for calling back to \c Owner to
+  /// tell it that its operand changed.  This could trigger \c Owner being
+  /// re-uniqued.
+  static bool track(void *Ref, Metadata &MD, MetadataAsValue &Owner) {
+    return track(Ref, MD, &Owner);
+  }
+
+  /// \brief Stop tracking a reference to metadata.
+  ///
+  /// Stops \c *MD from tracking \c MD.
+  static void untrack(Metadata *&MD) { untrack(&MD, *MD); }
+  static void untrack(void *Ref, Metadata &MD);
+
+  /// \brief Move tracking from one reference to another.
+  ///
+  /// Semantically equivalent to \c untrack(MD) followed by \c track(New),
+  /// except that ownership callbacks are maintained.
+  ///
+  /// Note: it is an error if \c *MD does not equal \c New.
+  ///
+  /// \return true iff tracking is supported by \c MD.
+  static bool retrack(Metadata *&MD, Metadata *&New) {
+    return retrack(&MD, *MD, &New);
+  }
+  static bool retrack(void *Ref, Metadata &MD, void *New);
+
+  /// \brief Check whether metadata is replaceable.
+  static bool isReplaceable(const Metadata &MD);
+
+  typedef PointerUnion<MetadataAsValue *, Metadata *> OwnerTy;
+
+private:
+  /// \brief Track a reference to metadata for an owner.
+  ///
+  /// Generalized version of tracking.
+  static bool track(void *Ref, Metadata &MD, OwnerTy Owner);
+};
+
 /// \brief Shared implementation of use-lists for replaceable metadata.
 ///
 /// Most metadata cannot be RAUW'ed.  This is a shared implementation of

diff --git a/include/llvm/IR/MetadataTracking.h b/include/llvm/IR/MetadataTracking.h
deleted file mode 100644 (file)
index 541d9b3..0000000
--- a/include/llvm/IR/MetadataTracking.h
+++ /dev/null
@@ -1,99 +0,0 @@
-//===- llvm/IR/MetadataTracking.h - Metadata tracking ---------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Low-level functions to enable tracking of metadata that could RAUW.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_IR_METADATATRACKING_H
-#define LLVM_IR_METADATATRACKING_H
-
-#include "llvm/ADT/PointerUnion.h"
-#include "llvm/Support/Casting.h"
-#include <type_traits>
-
-namespace llvm {
-
-class Metadata;
-class MetadataAsValue;
-
-/// \brief API for tracking metadata references through RAUW and deletion.
-///
-/// Shared API for updating \a Metadata pointers in subclasses that support
-/// RAUW.
-///
-/// This API is not meant to be used directly.  See \a TrackingMDRef for a
-/// user-friendly tracking reference.
-class MetadataTracking {
-public:
-  /// \brief Track the reference to metadata.
-  ///
-  /// Register \c MD with \c *MD, if the subclass supports tracking.  If \c *MD
-  /// gets RAUW'ed, \c MD will be updated to the new address.  If \c *MD gets
-  /// deleted, \c MD will be set to \c nullptr.
-  ///
-  /// If tracking isn't supported, \c *MD will not change.
-  ///
-  /// \return true iff tracking is supported by \c MD.
-  static bool track(Metadata *&MD) {
-    return track(&MD, *MD, static_cast<Metadata *>(nullptr));
-  }
-
-  /// \brief Track the reference to metadata for \a Metadata.
-  ///
-  /// As \a track(Metadata*&), but with support for calling back to \c Owner to
-  /// tell it that its operand changed.  This could trigger \c Owner being
-  /// re-uniqued.
-  static bool track(void *Ref, Metadata &MD, Metadata &Owner) {
-    return track(Ref, MD, &Owner);
-  }
-
-  /// \brief Track the reference to metadata for \a MetadataAsValue.
-  ///
-  /// As \a track(Metadata*&), but with support for calling back to \c Owner to
-  /// tell it that its operand changed.  This could trigger \c Owner being
-  /// re-uniqued.
-  static bool track(void *Ref, Metadata &MD, MetadataAsValue &Owner) {
-    return track(Ref, MD, &Owner);
-  }
-
-  /// \brief Stop tracking a reference to metadata.
-  ///
-  /// Stops \c *MD from tracking \c MD.
-  static void untrack(Metadata *&MD) { untrack(&MD, *MD); }
-  static void untrack(void *Ref, Metadata &MD);
-
-  /// \brief Move tracking from one reference to another.
-  ///
-  /// Semantically equivalent to \c untrack(MD) followed by \c track(New),
-  /// except that ownership callbacks are maintained.
-  ///
-  /// Note: it is an error if \c *MD does not equal \c New.
-  ///
-  /// \return true iff tracking is supported by \c MD.
-  static bool retrack(Metadata *&MD, Metadata *&New) {
-    return retrack(&MD, *MD, &New);
-  }
-  static bool retrack(void *Ref, Metadata &MD, void *New);
-
-  /// \brief Check whether metadata is replaceable.
-  static bool isReplaceable(const Metadata &MD);
-
-  typedef PointerUnion<MetadataAsValue *, Metadata *> OwnerTy;
-
-private:
-  /// \brief Track a reference to metadata for an owner.
-  ///
-  /// Generalized version of tracking.
-  static bool track(void *Ref, Metadata &MD, OwnerTy Owner);
-};
-
-} // end namespace llvm
-
-#endif

diff --git a/include/llvm/IR/TrackingMDRef.h b/include/llvm/IR/TrackingMDRef.h
index e24112154e1608f60f7649af4fc43a1287b36bff..97efaff7a3771386757eeef25d4d67ef5f9b6152 100644 (file)
--- a/include/llvm/IR/TrackingMDRef.h
+++ b/include/llvm/IR/TrackingMDRef.h
@@ -14,15 +14,11 @@
 #ifndef LLVM_IR_TRACKINGMDREF_H
 #define LLVM_IR_TRACKINGMDREF_H
 
-#include "llvm/IR/MetadataTracking.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/Support/Casting.h"
 
 namespace llvm {
 
-class Metadata;
-class MDNode;
-class ValueAsMetadata;
-
 /// \brief Tracking metadata reference.
 ///
 /// This class behaves like \a TrackingVH, but for metadata.

diff --git a/lib/IR/CMakeLists.txt b/lib/IR/CMakeLists.txt
index eb67c525ce21c78dc9710b65604d49673ea00cd4..40b4ec65e22be14bf17be2e405468444c4f4da63 100644 (file)
--- a/lib/IR/CMakeLists.txt
+++ b/lib/IR/CMakeLists.txt
@@ -36,7 +36,6 @@ add_llvm_library(LLVMCore
   MDBuilder.cpp
   Mangler.cpp
   Metadata.cpp
-  MetadataTracking.cpp
   Module.cpp
   Operator.cpp
   Pass.cpp

diff --git a/lib/IR/Metadata.cpp b/lib/IR/Metadata.cpp
index b1da0301ecfcf02573875e52d00d6583529ada2b..ab1ba5e2035bc6ff3bed2439d4a0dc7c9083c983 100644 (file)
--- a/lib/IR/Metadata.cpp
+++ b/lib/IR/Metadata.cpp
@@ -120,6 +120,38 @@ void MetadataAsValue::untrack() {
     MetadataTracking::untrack(MD);
 }
 
+bool MetadataTracking::track(void *Ref, Metadata &MD, OwnerTy Owner) {
+  assert(Ref && "Expected live reference");
+  assert((Owner || *static_cast<Metadata **>(Ref) == &MD) &&
+         "Reference without owner must be direct");
+  if (auto *R = ReplaceableMetadataImpl::get(MD)) {
+    R->addRef(Ref, Owner);
+    return true;
+  }
+  return false;
+}
+
+void MetadataTracking::untrack(void *Ref, Metadata &MD) {
+  assert(Ref && "Expected live reference");
+  if (auto *R = ReplaceableMetadataImpl::get(MD))
+    R->dropRef(Ref);
+}
+
+bool MetadataTracking::retrack(void *Ref, Metadata &MD, void *New) {
+  assert(Ref && "Expected live reference");
+  assert(New && "Expected live reference");
+  assert(Ref != New && "Expected change");
+  if (auto *R = ReplaceableMetadataImpl::get(MD)) {
+    R->moveRef(Ref, New, MD);
+    return true;
+  }
+  return false;
+}
+
+bool MetadataTracking::isReplaceable(const Metadata &MD) {
+  return ReplaceableMetadataImpl::get(const_cast<Metadata &>(MD));
+}
+
 void ReplaceableMetadataImpl::addRef(void *Ref, OwnerTy Owner) {
   bool WasInserted =
       UseMap.insert(std::make_pair(Ref, std::make_pair(Owner, NextIndex)))
@@ -239,6 +271,12 @@ void ReplaceableMetadataImpl::resolveAllUses(bool ResolveUsers) {
   }
 }
 
+ReplaceableMetadataImpl *ReplaceableMetadataImpl::get(Metadata &MD) {
+  if (auto *N = dyn_cast<MDNode>(&MD))
+    return N->Context.getReplaceableUses();
+  return dyn_cast<ValueAsMetadata>(&MD);
+}
+
 static Function *getLocalFunction(Value *V) {
   assert(V && "Expected value");
   if (auto *A = dyn_cast<Argument>(V))

diff --git a/lib/IR/MetadataTracking.cpp b/lib/IR/MetadataTracking.cpp
deleted file mode 100644 (file)
index 47f0b93..0000000
--- a/lib/IR/MetadataTracking.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//===- MetadataTracking.cpp - Implement metadata tracking -----------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements Metadata tracking.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/IR/MetadataTracking.h"
-#include "llvm/IR/Metadata.h"
-
-using namespace llvm;
-
-ReplaceableMetadataImpl *ReplaceableMetadataImpl::get(Metadata &MD) {
-  if (auto *N = dyn_cast<MDNode>(&MD))
-    return N->Context.getReplaceableUses();
-  return dyn_cast<ValueAsMetadata>(&MD);
-}
-
-bool MetadataTracking::track(void *Ref, Metadata &MD, OwnerTy Owner) {
-  assert(Ref && "Expected live reference");
-  assert((Owner || *static_cast<Metadata **>(Ref) == &MD) &&
-         "Reference without owner must be direct");
-  if (auto *R = ReplaceableMetadataImpl::get(MD)) {
-    R->addRef(Ref, Owner);
-    return true;
-  }
-  return false;
-}
-
-void MetadataTracking::untrack(void *Ref, Metadata &MD) {
-  assert(Ref && "Expected live reference");
-  if (auto *R = ReplaceableMetadataImpl::get(MD))
-    R->dropRef(Ref);
-}
-
-bool MetadataTracking::retrack(void *Ref, Metadata &MD, void *New) {
-  assert(Ref && "Expected live reference");
-  assert(New && "Expected live reference");
-  assert(Ref != New && "Expected change");
-  if (auto *R = ReplaceableMetadataImpl::get(MD)) {
-    R->moveRef(Ref, New, MD);
-    return true;
-  }
-  return false;
-}
-
-bool MetadataTracking::isReplaceable(const Metadata &MD) {
-  return ReplaceableMetadataImpl::get(const_cast<Metadata &>(MD));
-}