Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

lib/Demangling/RemanglerBase.h

@@ -19,6 +19,7 @@
 
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/NamespaceMacros.h"
+#include "llvm/ADT/PointerIntPair.h"
 #include <unordered_map>
 
 using namespace swift::Demangle;
@@ -37,14 +38,19 @@ SWIFT_BEGIN_INLINE_NAMESPACE
 
 // An entry in the remangler's substitution map.
 class SubstitutionEntry {
-  Node *TheNode = nullptr;
+  llvm::PointerIntPair<Node *, 1, bool> NodeAndTreatAsIdentifier;
   size_t StoredHash = 0;
-  bool treatAsIdentifier = false;
+
+  Node *getNode() const { return NodeAndTreatAsIdentifier.getPointer(); }
+
+  bool getTreatAsIdentifier() const {
+    return NodeAndTreatAsIdentifier.getInt();
+  }
 
 public:
   void setNode(Node *node, bool treatAsIdentifier, size_t hash) {
-    this->treatAsIdentifier = treatAsIdentifier;
-    TheNode = node;
+    NodeAndTreatAsIdentifier.setPointer(node);
+    NodeAndTreatAsIdentifier.setInt(treatAsIdentifier);
     StoredHash = hash;
   }
 
@@ -54,10 +60,10 @@ class SubstitutionEntry {
     }
   };
 
-  bool isEmpty() const { return !TheNode; }
+  bool isEmpty() const { return !getNode(); }
 
   bool matches(Node *node, bool treatAsIdentifier) const {
-    return node == TheNode && treatAsIdentifier == this->treatAsIdentifier;
+    return node == getNode() && treatAsIdentifier == getTreatAsIdentifier();
   }
 
   size_t hash() const { return StoredHash; }
@@ -67,12 +73,12 @@ class SubstitutionEntry {
                          const SubstitutionEntry &rhs) {
     if (lhs.StoredHash != rhs.StoredHash)
       return false;
-    if (lhs.treatAsIdentifier != rhs.treatAsIdentifier)
+    if (lhs.getTreatAsIdentifier() != rhs.getTreatAsIdentifier())
       return false;
-    if (lhs.treatAsIdentifier) {
-      return identifierEquals(lhs.TheNode, rhs.TheNode);
+    if (lhs.getTreatAsIdentifier()) {
+      return identifierEquals(lhs.getNode(), rhs.getNode());
     }
-    return lhs.deepEquals(lhs.TheNode, rhs.TheNode);
+    return lhs.deepEquals(lhs.getNode(), rhs.getNode());
   }
 
   static bool identifierEquals(Node *lhs, Node *rhs);

stdlib/public/runtime/Errors.cpp

@@ -506,11 +506,11 @@ void swift::swift_abortRetainUnowned(const void *object) {
   if (object) {
     swift::fatalError(FatalErrorFlags::ReportBacktrace,
                       "Fatal error: Attempted to read an unowned reference but "
-                      "object %p was already deallocated\n", object);
+                      "object %p was already destroyed\n", object);
   } else {
     swift::fatalError(FatalErrorFlags::ReportBacktrace,
                       "Fatal error: Attempted to read an unowned reference but "
-                      "the object was already deallocated\n");
+                      "the object was already destroyed\n");
   }
 }