[hwasan] Remove untagging of kernel-consumed memory

[hctim]

Summary

Now that page aliasing for x64 has landed, we don't need to worry about
passing tagged pointers to libc, and thus D98875 removed it.
Unfortunately, we still test on aarch64 devices that don't have the
kernel tagged address ABI (https://reviews.llvm.org/D98875#2649269).

All the memory that we pass to the kernel in these tests is from global
variables. Instead of having architecture-specific untagging mechanisms
for this memory, let's just not tag the globals.

[morehouse]

LGTM

[eugenis]

LGTM

compiler-rt/test/hwasan/TestCases/Linux/decorate-proc-maps.c

-// RUN: %clang_hwasan -g %s -o %t
+// RUN: %clang_hwasan -mllvm -hwasan-globals=0  -g %s -o %t
 // RUN: %env_hwasan_opts=decorate_proc_maps=1 %run %t 2>&1 | FileCheck %s --check-prefix=A
 // RUN: %env_hwasan_opts=decorate_proc_maps=1 %run %t 2>&1 | FileCheck %s --check-prefix=B
 
 // A:      rw-p {{.*}}hwasan threads]
 // A-NEXT: ---p {{.*}}shadow gap]
 // A-NEXT: rw-p {{.*}}low shadow]
 // A-NEXT: ---p {{.*}}shadow gap]
 // A-NEXT: rw-p {{.*}}high shadow]
 
 // B-DAG: rw-p {{.*}}SizeClassAllocator: region info]
 // B-DAG: rw-p {{.*}}LargeMmapAllocator]
 // B-DAG: rw-p {{.*}}stack depot]
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <pthread.h>
-#include <stdlib.h>
-
-#include "utils.h"
 
 void CopyFdToFd(int in_fd, int out_fd) {
   const size_t kBufSize = 0x10000;
   static char buf[kBufSize];
   while (1) {
-    ssize_t got = read(in_fd, UNTAG(buf), kBufSize);
+    ssize_t got = read(in_fd, buf, kBufSize);
     if (got > 0) {
-      write(out_fd, UNTAG(buf), got);
+      write(out_fd, buf, got);
     } else if (got == 0) {
       break;
     } else if (errno != EAGAIN || errno != EWOULDBLOCK || errno != EINTR) {
       fprintf(stderr, "error reading file, errno %d\n", errno);
       abort();
     }
   }
 }
 
 void *ThreadFn(void *arg) {
   (void)arg;
-  int fd = open(UNTAG("/proc/self/maps"), O_RDONLY);
+  int fd = open("/proc/self/maps", O_RDONLY);
   CopyFdToFd(fd, 2);
   close(fd);
   return NULL;
 }
 
 int main(void) {
   pthread_t t;
   void * volatile res = malloc(100);
   void * volatile res2 = malloc(100000);
   pthread_create(&t, 0, ThreadFn, 0);
   pthread_join(t, 0);
   return (int)(size_t)res;
 }

compiler-rt/test/hwasan/TestCases/Linux/release-shadow.c

 // Test that tagging a large region to 0 reduces RSS.
-// RUN: %clang_hwasan -mllvm -hwasan-instrument-stack=0 %s -o %t && %run %t 2>&1
+// RUN: %clang_hwasan -mllvm -hwasan-globals=0 -mllvm -hwasan-instrument-stack=0 %s -o %t && %run %t 2>&1
 
 #include <assert.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <sanitizer/hwasan_interface.h>
 
-#include "utils.h"
-
 const unsigned char kTag = 42;
 const size_t kNumShadowPages = 256;
 const size_t kNumPages = 16 * kNumShadowPages;
 const size_t kPageSize = 4096;
 const size_t kMapSize = kNumPages * kPageSize;
 
 void sync_rss() {
   char *page = (char *)mmap(0, kPageSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
   // Linux kernel updates RSS counters after a set number of page faults.
   for (int i = 0; i < 1000; ++i) {
     page[0] = 42;
     madvise(page, kPageSize, MADV_DONTNEED);
   }
   munmap(page, kPageSize);
 }
 
 size_t current_rss() {
   sync_rss();
-  int statm_fd = open(UNTAG("/proc/self/statm"), O_RDONLY);
+  int statm_fd = open("/proc/self/statm", O_RDONLY);
   assert(statm_fd >= 0);
 
   char buf[100];
   assert(read(statm_fd, &buf, sizeof(buf)) > 0);
   size_t size, rss;
   assert(sscanf(buf, "%zu %zu", &size, &rss) == 2);
 
   close(statm_fd);

compiler-rt/test/hwasan/TestCases/Linux/reuse-threads.cpp

 // Test that Thread objects are reused.
-// RUN: %clangxx_hwasan -mllvm -hwasan-instrument-stack=0 %s -o %t && %env_hwasan_opts=verbose_threads=1 %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_hwasan -mllvm -hwasan-globals=0 -mllvm -hwasan-instrument-stack=0 %s -o %t && %env_hwasan_opts=verbose_threads=1 %run %t 2>&1 | FileCheck %s
 
 #include <assert.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <sanitizer/hwasan_interface.h>
 
-#include "utils.h"
-
 pthread_barrier_t bar;
 
 void *threadfn(void *) {
-  pthread_barrier_wait(UNTAG(&bar));
+  pthread_barrier_wait(&bar);
   return nullptr;
 }
 
 void start_stop_threads() {
   constexpr int N = 2;
   pthread_t threads[N];
 
-  pthread_barrier_init(UNTAG(&bar), nullptr, N + 1);
+  pthread_barrier_init(&bar, nullptr, N + 1);
   for (auto &t : threads)
     pthread_create(&t, nullptr, threadfn, nullptr);
 
-  pthread_barrier_wait(UNTAG(&bar));
+  pthread_barrier_wait(&bar);
 
   for (auto &t : threads)
     pthread_join(t, nullptr);
-  pthread_barrier_destroy(UNTAG(&bar));
+  pthread_barrier_destroy(&bar);
 }
 
 int main() {
   // Cut off initial threads.
   // CHECK: === test start ===
   fprintf(stderr, "=== test start ===\n");
 
   // CHECK: Creating  : T{{[0-9]+}} [[A:0x[0-9a-f]+]] stack:

compiler-rt/test/hwasan/TestCases/Linux/utils.h

-#pragma once
-
-#include <stdint.h>
-
-#if defined(__x86_64__)
-#define UNTAG(x) (x)
-#else
-#define UNTAG(x) (typeof((x) + 0))(((uintptr_t)(x)) & 0xffffffffffffff)
-#endif