[scudo/standalone] Use .arch_extension memtag, not mte

[mcgrathr]

Summary

GNU binutils accepts only .arch_extension memtag while Clang
accepts either that or .arch_extension mte to mean the same thing.

[cryptoad]

AFAICT it's fine, but I'd rather have @pcc give the LGTM

[pcc]

LGTM

compiler-rt/lib/scudo/standalone/memtag.h

 
 inline bool systemSupportsMemoryTagging() { return false; }
 
 inline bool systemDetectsMemoryTagFaultsTestOnly() { return false; }
 
 #endif // SCUDO_LINUX
 
 inline void disableMemoryTagChecksTestOnly() {
-  __asm__ __volatile__(".arch_extension mte; msr tco, #1");
+  __asm__ __volatile__(".arch_extension memtag; msr tco, #1");
 }
 
 inline void enableMemoryTagChecksTestOnly() {
-  __asm__ __volatile__(".arch_extension mte; msr tco, #0");
+  __asm__ __volatile__(".arch_extension memtag; msr tco, #0");
 }
 
 class ScopedDisableMemoryTagChecks {
   size_t PrevTCO;
 
 public:
   ScopedDisableMemoryTagChecks() {
-    __asm__ __volatile__(".arch_extension mte; mrs %0, tco; msr tco, #1"
+    __asm__ __volatile__(".arch_extension memtag; mrs %0, tco; msr tco, #1"
                          : "=r"(PrevTCO));
   }
 
   ~ScopedDisableMemoryTagChecks() {
-    __asm__ __volatile__(".arch_extension mte; msr tco, %0" : : "r"(PrevTCO));
+    __asm__ __volatile__(".arch_extension memtag; msr tco, %0"
+                         :
+                         : "r"(PrevTCO));
   }
 };
 
 inline uptr selectRandomTag(uptr Ptr, uptr ExcludeMask) {
   uptr TaggedPtr;
   __asm__ __volatile__(
-      ".arch_extension mte; irg %[TaggedPtr], %[Ptr], %[ExcludeMask]"
+      ".arch_extension memtag; irg %[TaggedPtr], %[Ptr], %[ExcludeMask]"
       : [TaggedPtr] "=r"(TaggedPtr)
       : [Ptr] "r"(Ptr), [ExcludeMask] "r"(ExcludeMask));
   return TaggedPtr;
 }
 
 inline uptr storeTags(uptr Begin, uptr End) {
   DCHECK(Begin % 16 == 0);
   if (Begin != End) {
     __asm__ __volatile__(
         R"(
-      .arch_extension mte
+      .arch_extension memtag
 
     1:
       stzg %[Cur], [%[Cur]], #16
       cmp %[Cur], %[End]
       b.lt 1b
     )"
         : [Cur] "+&r"(Begin)
         : [End] "r"(End)
         : "memory");
   }
   return Begin;
 }
 
 inline void *prepareTaggedChunk(void *Ptr, uptr Size, uptr ExcludeMask,
                                 uptr BlockEnd) {
   // Prepare the granule before the chunk to store the chunk header by setting
   // its tag to 0. Normally its tag will already be 0, but in the case where a
   // chunk holding a low alignment allocation is reused for a higher alignment
   // allocation, the chunk may already have a non-zero tag from the previous
   // allocation.
-  __asm__ __volatile__(".arch_extension mte; stg %0, [%0, #-16]"
+  __asm__ __volatile__(".arch_extension memtag; stg %0, [%0, #-16]"
                        :
                        : "r"(Ptr)
                        : "memory");
 
   uptr TaggedBegin, TaggedEnd;
   setRandomTag(Ptr, Size, ExcludeMask, &TaggedBegin, &TaggedEnd);
 
   // Finally, set the tag of the granule past the end of the allocation to 0,
   // to catch linear overflows even if a previous larger allocation used the
   // same block and tag. Only do this if the granule past the end is in our
   // block, because this would otherwise lead to a SEGV if the allocation
   // covers the entire block and our block is at the end of a mapping. The tag
   // of the next block's header granule will be set to 0, so it will serve the
   // purpose of catching linear overflows in this case.
   uptr UntaggedEnd = untagPointer(TaggedEnd);
   if (UntaggedEnd != BlockEnd)
-    __asm__ __volatile__(".arch_extension mte; stg %0, [%0]"
+    __asm__ __volatile__(".arch_extension memtag; stg %0, [%0]"
                          :
                          : "r"(UntaggedEnd)
                          : "memory");
   return reinterpret_cast<void *>(TaggedBegin);
 }
 
 inline void resizeTaggedChunk(uptr OldPtr, uptr NewPtr, uptr BlockEnd) {
   uptr RoundOldPtr = roundUpTo(OldPtr, 16);
   if (RoundOldPtr >= NewPtr) {
     // If the allocation is shrinking we just need to set the tag past the end
     // of the allocation to 0. See explanation in prepareTaggedChunk above.
     uptr RoundNewPtr = untagPointer(roundUpTo(NewPtr, 16));
     if (RoundNewPtr != BlockEnd)
-      __asm__ __volatile__(".arch_extension mte; stg %0, [%0]"
+      __asm__ __volatile__(".arch_extension memtag; stg %0, [%0]"
                            :
                            : "r"(RoundNewPtr)
                            : "memory");
     return;
   }
 
   __asm__ __volatile__(R"(
-    .arch_extension mte
+    .arch_extension memtag
 
     // Set the memory tag of the region
     // [roundUpTo(OldPtr, 16), roundUpTo(NewPtr, 16))
     // to the pointer tag stored in OldPtr.
   1:
     stzg %[Cur], [%[Cur]], #16
     cmp %[Cur], %[End]
     b.lt 1b
 
     // Finally, set the tag of the granule past the end of the allocation to 0.
     and %[Cur], %[Cur], #(1 << 56) - 1
     cmp %[Cur], %[BlockEnd]
     b.eq 2f
     stg %[Cur], [%[Cur]]
 
   2:
   )"
                        : [Cur] "+&r"(RoundOldPtr), [End] "+&r"(NewPtr)
                        : [BlockEnd] "r"(BlockEnd)
                        : "memory");
 }
 
 inline uptr loadTag(uptr Ptr) {
   uptr TaggedPtr = Ptr;
-  __asm__ __volatile__(".arch_extension mte; ldg %0, [%0]"
+  __asm__ __volatile__(".arch_extension memtag; ldg %0, [%0]"
                        : "+r"(TaggedPtr)
                        :
                        : "memory");
   return TaggedPtr;
 }
 
 #else