[lldb] Rename MemoryTagManager RemoveNonAddressBits to RemoveTagBits

[DavidSpickett]

Summary

This better describes the intent of the method. Which for AArch64
is removing the top byte which includes the memory tags.

It does not include pointer signatures, for those we need to use
the ABI plugin. The rename makes this a little more clear.

It's a bit awkward that the memory tag manager is removing the whole
top byte not just the memory tags but it's an improvement for now.

[DavidSpickett]

As promised on https://reviews.llvm.org/D112824.

I hope to get to a point where the tag managers only remove memory tag bits so this is a step toward that.

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

1370

The usage in lldb-server is why I have kept it removing the whole top byte to keep us in line with: https://dri.freedesktop.org/docs/drm/arm64/tagged-address-abi.html

You might wonder if we should remove non-address bits here too but going by that standard I think the answer is no.

lldb/include/lldb/Target/MemoryTagManager.h

public:
   typedef Range<lldb::addr_t, lldb::addr_t> TagRange;
 
   // Extract the logical tag from a pointer
   // The tag is returned as a plain value, with any shifts removed.
   // For example if your tags are stored in bits 56-60 then the logical tag
   // you get will have been shifted down 56 before being returned.
   virtual lldb::addr_t GetLogicalTag(lldb::addr_t addr) const = 0;
 
-  // Remove non address bits from a pointer
-  virtual lldb::addr_t RemoveNonAddressBits(lldb::addr_t addr) const = 0;
+  // Remove tag bits from a pointer
+  virtual lldb::addr_t RemoveTagBits(lldb::addr_t addr) const = 0;
 
   // Return the difference between two addresses, ignoring any logical tags they
   // have. If your tags are just part of a larger set of ignored bits, this
   // should ignore all those bits.
   virtual ptrdiff_t AddressDiff(lldb::addr_t addr1,
                                 lldb::addr_t addr2) const = 0;
 
   // Return the number of bytes a single tag covers

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

if (!details)
     return Status(details.takeError());
 
   // Ignore 0 length read
   if (!len)
     return Status();
 
   // lldb will align the range it requests but it is not required to by
   // the protocol so we'll do it again just in case.
-  // Remove non address bits too. Ptrace calls may work regardless but that
+  // Remove tag bits too. Ptrace calls may work regardless but that
   // is not a guarantee.
-  MemoryTagManager::TagRange range(details->manager->RemoveNonAddressBits(addr),
-                                   len);
+  MemoryTagManager::TagRange range(details->manager->RemoveTagBits(addr), len);
   range = details->manager->ExpandToGranule(range);
 
   // Allocate enough space for all tags to be read
   size_t num_tags = range.GetByteSize() / details->manager->GetGranuleSize();
   tags.resize(num_tags * details->manager->GetTagSizeInBytes());
 
   struct iovec tags_iovec;
   uint8_t *dest = tags.data();
if (!details)
     return Status(details.takeError());
 
   // Ignore 0 length write
   if (!len)
     return Status();
 
   // lldb will align the range it requests but it is not required to by
   // the protocol so we'll do it again just in case.
-  // Remove non address bits too. Ptrace calls may work regardless but that
+  // Remove tag bits too. Ptrace calls may work regardless but that
   // is not a guarantee.
-  MemoryTagManager::TagRange range(details->manager->RemoveNonAddressBits(addr),
-                                   len);
+  MemoryTagManager::TagRange range(details->manager->RemoveTagBits(addr), len);
   range = details->manager->ExpandToGranule(range);
 
   // Not checking number of tags here, we may repeat them below
   llvm::Expected<std::vector<lldb::addr_t>> unpacked_tags_or_err =
       details->manager->UnpackTagsData(tags);
   if (!unpacked_tags_or_err)
     return Status(unpacked_tags_or_err.takeError());
 

lldb/source/Plugins/Process/Utility/MemoryTagManagerAArch64MTE.h

enum MTETagTypes {
     eMTE_allocation = 1,
   };
 
   lldb::addr_t GetGranuleSize() const override;
   int32_t GetAllocationTagType() const override;
   size_t GetTagSizeInBytes() const override;
 
   lldb::addr_t GetLogicalTag(lldb::addr_t addr) const override;
-  lldb::addr_t RemoveNonAddressBits(lldb::addr_t addr) const override;
+  lldb::addr_t RemoveTagBits(lldb::addr_t addr) const override;
   ptrdiff_t AddressDiff(lldb::addr_t addr1, lldb::addr_t addr2) const override;
 
   TagRange ExpandToGranule(TagRange range) const override;
 
   llvm::Expected<TagRange> MakeTaggedRange(
       lldb::addr_t addr, lldb::addr_t end_addr,
       const lldb_private::MemoryRegionInfos &memory_regions) const override;
 

lldb/source/Plugins/Process/Utility/MemoryTagManagerAArch64MTE.cpp

 static const unsigned MTE_GRANULE_SIZE = 16;
 
 lldb::addr_t
 MemoryTagManagerAArch64MTE::GetLogicalTag(lldb::addr_t addr) const {
   return (addr >> MTE_START_BIT) & MTE_TAG_MAX;
 }
 
 lldb::addr_t
-MemoryTagManagerAArch64MTE::RemoveNonAddressBits(lldb::addr_t addr) const {
+MemoryTagManagerAArch64MTE::RemoveTagBits(lldb::addr_t addr) const {
   // Here we're ignoring the whole top byte. If you've got MTE
   // you must also have TBI (top byte ignore).
   // The other 4 bits could contain other extension bits or
   // user metadata.
   return addr & ~((lldb::addr_t)0xFF << MTE_START_BIT);
 }
 
 ptrdiff_t MemoryTagManagerAArch64MTE::AddressDiff(lldb::addr_t addr1,
                                                   lldb::addr_t addr2) const {
-  return RemoveNonAddressBits(addr1) - RemoveNonAddressBits(addr2);
+  return RemoveTagBits(addr1) - RemoveTagBits(addr2);
 }
 
 lldb::addr_t MemoryTagManagerAArch64MTE::GetGranuleSize() const {
   return MTE_GRANULE_SIZE;
 }
 
 int32_t MemoryTagManagerAArch64MTE::GetAllocationTagType() const {
   return eMTE_allocation;
return llvm::createStringError(
         llvm::inconvertibleErrorCode(),
         "End address (0x%" PRIx64
         ") must be greater than the start address (0x%" PRIx64 ")",
         end_addr, addr);
   }
 
   // Region addresses will not have memory tags. So when searching
   // we must use an untagged address.
-  MemoryRegionInfo::RangeType tag_range(RemoveNonAddressBits(addr), len);
+  MemoryRegionInfo::RangeType tag_range(RemoveTagBits(addr), len);
   tag_range = ExpandToGranule(tag_range);
 
   // Make a copy so we can use the original for errors and the final return.
   MemoryRegionInfo::RangeType remaining_range(tag_range);
 
   // While there are parts of the range that don't have a matching tagged memory
   // region
   while (remaining_range.IsValid()) {

lldb/unittests/Process/Utility/MemoryTagManagerAArch64MTETest.cpp

TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRange) {
 
   // If we tag the middle part it succeeds
   memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes);
   got = manager.MakeTaggedRange(0, 0x1000, memory_regions);
   ASSERT_THAT_EXPECTED(got, llvm::Succeeded());
   ASSERT_EQ(*got, expected_range);
 }
 
-TEST(MemoryTagManagerAArch64MTETest, RemoveNonAddressBits) {
+TEST(MemoryTagManagerAArch64MTETest, RemoveTagBits) {
   MemoryTagManagerAArch64MTE manager;
 
   ASSERT_EQ(0, 0);
+  // Removes the whole top byte
   ASSERT_EQ((lldb::addr_t)0x00ffeedd11223344,
-            manager.RemoveNonAddressBits(0x00ffeedd11223344));
+            manager.RemoveTagBits(0x00ffeedd11223344));
   ASSERT_EQ((lldb::addr_t)0x0000000000000000,
-            manager.RemoveNonAddressBits(0xFF00000000000000));
+            manager.RemoveTagBits(0xff00000000000000));
   ASSERT_EQ((lldb::addr_t)0x0055555566666666,
-            manager.RemoveNonAddressBits(0xee55555566666666));
+            manager.RemoveTagBits(0xee55555566666666));
 }
 
 TEST(MemoryTagManagerAArch64MTETest, AddressDiff) {
   MemoryTagManagerAArch64MTE manager;
 
   ASSERT_EQ(0, manager.AddressDiff(0, 0));
   // Result is signed
   ASSERT_EQ(10, manager.AddressDiff(10, 0));