[scudo] Make MTE inline asm compatible with GNU assembler

[mcgrathr]

Summary

The GNU assembler can't parse .arch_extension ... before a ;.
So instead uniformly use raw string syntax with separate lines
instead of ; separators in the assembly code.

[cryptoad]

Adding @pcc for review.

[pcc]

LGTM

It seems that even with the LLVM assembler the ; character isn't understood everywhere. For example at one point I noticed that ; is treated as a comment character on Mach-O targets, which caused the following instructions to silently disappear. I think we can reasonably count on newline being understood as a delimiter everywhere.

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 memtag; msr tco, #1");
+  __asm__ __volatile__(
+      R"(
+      .arch_extension memtag
+      msr tco, #1
+      )");
 }
 
 inline void enableMemoryTagChecksTestOnly() {
-  __asm__ __volatile__(".arch_extension memtag; msr tco, #0");
+  __asm__ __volatile__(
+      R"(
+      .arch_extension memtag
+      msr tco, #0
+      )");
 }
 
 class ScopedDisableMemoryTagChecks {
   size_t PrevTCO;
 
 public:
   ScopedDisableMemoryTagChecks() {
-    __asm__ __volatile__(".arch_extension memtag; mrs %0, tco; msr tco, #1"
-                         : "=r"(PrevTCO));
+    __asm__ __volatile__(
+        R"(
+        .arch_extension memtag
+        mrs %0, tco
+        msr tco, #1
+        )"
   }
 
   ~ScopedDisableMemoryTagChecks() {
-    __asm__ __volatile__(".arch_extension memtag; msr tco, %0"
-                         :
-                         : "r"(PrevTCO));
+    __asm__ __volatile__(
+        R"(
+        .arch_extension memtag
+        msr tco, %0
+        )"
   }
 };
 
 inline uptr selectRandomTag(uptr Ptr, uptr ExcludeMask) {
   uptr TaggedPtr;
   __asm__ __volatile__(
-      ".arch_extension memtag; irg %[TaggedPtr], %[Ptr], %[ExcludeMask]"
+      R"(
+      .arch_extension memtag
+      irg %[TaggedPtr], %[Ptr], %[ExcludeMask]
+      )"
       : [TaggedPtr] "=r"(TaggedPtr)
       : [Ptr] "r"(Ptr), [ExcludeMask] "r"(ExcludeMask));
   return TaggedPtr;
 }
 
 inline uptr addFixedTag(uptr Ptr, uptr Tag) { return Ptr | (Tag << 56); }
 
 inline uptr storeTags(uptr Begin, uptr End) {
   DCHECK(Begin % 16 == 0);

 
 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 memtag; stg %0, [%0, #-16]"
-                       :
-                       : "r"(Ptr)
-                       : "memory");
+  __asm__ __volatile__(
+      R"(
+      .arch_extension memtag
+      stg %0, [%0, #-16]
+      )"
 
   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 memtag; stg %0, [%0]"
-                         :
-                         : "r"(UntaggedEnd)
-                         : "memory");
+    __asm__ __volatile__(
+        R"(
+        .arch_extension memtag
+        stg %0, [%0]
+        )"
   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 memtag; stg %0, [%0]"
-                           :
-                           : "r"(RoundNewPtr)
-                           : "memory");
+      __asm__ __volatile__(
+          R"(
+          .arch_extension memtag
+          stg %0, [%0]
+          )"
     return;
   }
 
   __asm__ __volatile__(R"(
     .arch_extension memtag
 
     // Set the memory tag of the region
     // [roundUpTo(OldPtr, 16), roundUpTo(NewPtr, 16))
inline void resizeTaggedChunk(uptr OldPtr, uptr NewPtr, uptr BlockEnd) {
   )"
                        : [Cur] "+&r"(RoundOldPtr), [End] "+&r"(NewPtr)
                        : [BlockEnd] "r"(BlockEnd)
                        : "memory");
 }
 
 inline uptr loadTag(uptr Ptr) {
   uptr TaggedPtr = Ptr;
-  __asm__ __volatile__(".arch_extension memtag; ldg %0, [%0]"
-                       : "+r"(TaggedPtr)
-                       :
-                       : "memory");
+  __asm__ __volatile__(
+      R"(
+      .arch_extension memtag
+      ldg %0, [%0]
+      )"
   return TaggedPtr;
 }
 
 #else
 
 inline bool systemSupportsMemoryTagging() {
   UNREACHABLE("memory tagging not supported");
 }