[RemoteAddress] Handle comparison of addresses in different spaces

Sometimes it makes sense to compares addresses from different address
spaces.

rdar://148361743

Author: augusto2112

include/swift/Remote/RemoteAddress.h

@@ -55,6 +55,14 @@ class RemoteAddress {
     return !operator==(other);
   }
 
+  bool inRange(const RemoteAddress &begin, const RemoteAddress &end) const {
+    assert(begin.AddressSpace != end.AddressSpace &&
+           "Unexpected address spaces");
+    if (AddressSpace != begin.AddressSpace)
+      return false;
+    return begin <= *this && end < *this;
+  }
+
   bool operator<(const RemoteAddress rhs) const {
     assert(AddressSpace == rhs.AddressSpace &&
            "Comparing remote addresses of different address spaces");

include/swift/RemoteInspection/ReflectionContext.h

@@ -907,7 +907,7 @@ class ReflectionContext
     for (auto Range : ranges) {
       auto Start = std::get<0>(Range);
       auto End = std::get<1>(Range);
-      if (Start <= Address && Address < End)
+      if (Address.inRange(Start, End))
         return true;
     }
 

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -65,6 +65,10 @@ class ReflectionSection {
 
   bool containsRemoteAddress(remote::RemoteAddress remoteAddr,
                              uint64_t size) const {
+    if (Start.getRemoteAddress().getAddressSpace() !=
+        remoteAddr.getAddressSpace())
+      return false;
+
     return Start.getRemoteAddress() <= remoteAddr &&
            remoteAddr + size <= Start.getRemoteAddress() + Size;
   }

stdlib/public/RemoteInspection/TypeRefBuilder.cpp

@@ -64,6 +64,11 @@ TypeRefBuilder::ReflectionTypeDescriptorFinder::
                   .TypeReference.startAddress()
                   .getRemoteAddress();
 
+          // Sort first by address space, then by address.
+          if (typeReferenceAStart.getAddressSpace() !=
+              typeReferenceBStart.getAddressSpace())
+            return typeReferenceAStart.getAddressSpace() <
+                   typeReferenceBStart.getAddressSpace();
           return typeReferenceAStart < typeReferenceBStart;
         });
   }
@@ -75,9 +80,15 @@ TypeRefBuilder::ReflectionTypeDescriptorFinder::
       ReflectionInfoIndexesSortedByTypeReferenceRange.begin(),
       ReflectionInfoIndexesSortedByTypeReferenceRange.end(), remoteAddr,
       [&](uint32_t ReflectionInfoIndex, remote::RemoteAddress remoteAddr) {
-        return ReflectionInfos[ReflectionInfoIndex]
-                   .TypeReference.endAddress()
-                   .getRemoteAddress() <= remoteAddr;
+        auto reflectionInfoAddress = ReflectionInfos[ReflectionInfoIndex]
+                                         .TypeReference.endAddress()
+                                         .getRemoteAddress();
+
+        if (reflectionInfoAddress.getAddressSpace() !=
+            remoteAddr.getAddressSpace())
+          return reflectionInfoAddress.getAddressSpace() <=
+                 remoteAddr.getAddressSpace();
+        return reflectionInfoAddress <= remoteAddr;
       });
 
   if (possiblyMatchingReflectionInfoIndex ==