[sanitizer] Use architecture/slice information when symbolizing fat Mach-O files on Darwin

[kubamracek]

Summary

This patch starts passing architecture information about a module to llvm-symbolizer and into text reports. This fixed the longstanding x86_64/x86_64h mismatch issue on Darwin. See also https://reviews.llvm.org/D27378.

[filcab]

This incremental change looks good. I'd rather let @kcc chime in in case he'd rather have it done another way, though.
But in the end, I'm not sure if this applies elsewhere, since most OS we support don't really have fat binaries.

lib/sanitizer_common/sanitizer_common.h

684 ↗

(On Diff #80198)

I'm guessing you added this to two reviews so you commit either first but you'll merge the definitions later, right?

lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

340 ↗

(On Diff #80198)

Maybe return buf && ParseSymbolizePCOutput(buf, stack); instead of the if?
Same thing below.

test/asan/TestCases/Darwin/haswell-symbolication.cc

51 ↗

(On Diff #80198)

Why?

[kubamracek]

lib/sanitizer_common/sanitizer_common.h

684 ↗

(On Diff #80198)

Right.

lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

340 ↗

(On Diff #80198)

I think that would be less readable.

test/asan/TestCases/Darwin/haswell-symbolication.cc

51 ↗

(On Diff #80198)

Yeah, the "REQUIRES: shell" doesn't make sense here. I misunderstood what it's used for.

[filcab]

lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

340 ↗

(On Diff #80198)

OK with me.

[kubamracek]

Updating patch, addressing review comments. Added comments that point to other places that have a list of architectures.

compiler-rt/trunk/lib/sanitizer_common/sanitizer_stacktrace_printer.h

void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
                  const char *strip_path_prefix = "",
                  const char *strip_func_prefix = "");
 
 void RenderSourceLocation(InternalScopedString *buffer, const char *file,
                           int line, int column, bool vs_style,
                           const char *strip_path_prefix);
 
 void RenderModuleLocation(InternalScopedString *buffer, const char *module,
-                          uptr offset, const char *strip_path_prefix);
+                          uptr offset, ModuleArch arch,
+                          const char *strip_path_prefix);
 
 // Same as RenderFrame, but for data section (global variables).
 // Accepts %s, %l from above.
 // Also accepts:
 //   %g - name of the global variable.
 void RenderData(InternalScopedString *buffer, const char *format,
                 const DataInfo *DI, const char *strip_path_prefix = "");
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_STACKTRACE_PRINTER_H

compiler-rt/trunk/lib/sanitizer_common/sanitizer_stacktrace_printer.cc

case 'S':
       break;
     case 'L':
       // Source location, or module location.
       if (info.file) {
         RenderSourceLocation(buffer, info.file, info.line, info.column,
                              vs_style, strip_path_prefix);
       } else if (info.module) {
         RenderModuleLocation(buffer, info.module, info.module_offset,
-                             strip_path_prefix);
+                             info.module_arch, strip_path_prefix);
       } else {
         buffer->append("(<unknown module>)");
       }
       break;
     case 'M':
       // Module basename and offset, or PC.
       if (info.address & kExternalPCBit)
         {} // There PCs are not meaningful.
       else if (info.module)
-        buffer->append("(%s+%p)", StripModuleName(info.module),
-                       (void *)info.module_offset);
+        // Always strip the module name for %M.
+        RenderModuleLocation(buffer, StripModuleName(info.module),
+                             info.module_offset, info.module_arch, "");
       else
         buffer->append("(%p)", (void *)info.address);
       break;
     default:
       Report("Unsupported specifier in stack frame format: %c (0x%zx)!\n", *p,
              *p);
       Die();
     }
void RenderSourceLocation(InternalScopedString *buffer, const char *file,
   if (line > 0) {
     buffer->append(":%d", line);
     if (column > 0)
       buffer->append(":%d", column);
   }
 }
 
 void RenderModuleLocation(InternalScopedString *buffer, const char *module,
-                          uptr offset, const char *strip_path_prefix) {
-  buffer->append("(%s+0x%zx)", StripPathPrefix(module, strip_path_prefix),
-                 offset);
+                          uptr offset, ModuleArch arch,
+                          const char *strip_path_prefix) {
+  buffer->append("(%s", StripPathPrefix(module, strip_path_prefix));
+  if (arch != kModuleArchUnknown) {
+    buffer->append(":%s", ModuleArchToString(arch));
+  }
+  buffer->append("+0x%zx)", offset);
 }
 
 } // namespace __sanitizer

compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer.h

 
 struct AddressInfo {
   // Owns all the string members. Storage for them is
   // (de)allocated using sanitizer internal allocator.
   uptr address;
 
   char *module;
   uptr module_offset;
+  ModuleArch module_arch;
 
   static const uptr kUnknown = ~(uptr)0;
   char *function;
   uptr function_offset;
 
   char *file;
   int line;
   int column;
 
   AddressInfo();
   // Deletes all strings and resets all fields.
   void Clear();
-  void FillModuleInfo(const char *mod_name, uptr mod_offset);
+  void FillModuleInfo(const char *mod_name, uptr mod_offset, ModuleArch arch);
 };
 
 // Linked list of symbolized frames (each frame is described by AddressInfo).
 struct SymbolizedStack {
   SymbolizedStack *next;
   AddressInfo info;
   static SymbolizedStack *New(uptr addr);
   // Deletes current, and all subsequent frames in the linked list.
   // The object cannot be accessed after the call to this function.
   void ClearAll();
 
  private:
   SymbolizedStack();
 };
 
 // For now, DataInfo is used to describe global variable.
 struct DataInfo {
   // Owns all the string members. Storage for them is
   // (de)allocated using sanitizer internal allocator.
   char *module;
   uptr module_offset;
+  ModuleArch module_arch;
+
   char *file;
   uptr line;
   char *name;
   uptr start;
   uptr size;
 
   DataInfo();
   void Clear();
private:
 
     BlockingMutex *mu_;
   } module_names_;
 
   /// Platform-specific function for creating a Symbolizer object.
   static Symbolizer *PlatformInit();
 
   bool FindModuleNameAndOffsetForAddress(uptr address, const char **module_name,
-                                         uptr *module_offset);
+                                         uptr *module_offset,
+                                         ModuleArch *module_arch);
   ListOfModules modules_;
   // If stale, need to reload the modules before looking up addresses.
   bool modules_fresh_;
 
   // Platform-specific default demangler, must not return nullptr.
   const char *PlatformDemangle(const char *name);
   void PlatformPrepareForSandboxing();
 

compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer.cc

 void AddressInfo::Clear() {
   InternalFree(module);
   InternalFree(function);
   InternalFree(file);
   internal_memset(this, 0, sizeof(AddressInfo));
   function_offset = kUnknown;
 }
 
-void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset) {
+void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset,
+                                 ModuleArch mod_arch) {
   module = internal_strdup(mod_name);
   module_offset = mod_offset;
+  module_arch = mod_arch;
 }
 
 SymbolizedStack::SymbolizedStack() : next(nullptr), info() {}
 
 SymbolizedStack *SymbolizedStack::New(uptr addr) {
   void *mem = InternalAlloc(sizeof(SymbolizedStack));
   SymbolizedStack *res = new(mem) SymbolizedStack();
   res->info.address = addr;

compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_internal.h

  public:
   explicit LLVMSymbolizer(const char *path, LowLevelAllocator *allocator);
 
   bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
 
   bool SymbolizeData(uptr addr, DataInfo *info) override;
 
  private:
-  const char *SendCommand(bool is_data, const char *module_name,
-                          uptr module_offset);
+  const char *FormatAndSendCommand(bool is_data, const char *module_name,
+                                   uptr module_offset, ModuleArch arch);
 
   LLVMSymbolizerProcess *symbolizer_process_;
   static const uptr kBufferSize = 16 * 1024;
   char buffer_[kBufferSize];
 };
 
 // Parses one or more two-line strings in the following format:
 //   <function_name>

compiler-rt/trunk/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
   if (*prefix_end != '\0') prefix_end += internal_strlen(delimiter);
   return prefix_end;
 }
 
 SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
   BlockingMutexLock l(&mu_);
   const char *module_name;
   uptr module_offset;
+  ModuleArch arch;
   SymbolizedStack *res = SymbolizedStack::New(addr);
-  if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
+  if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset,
+                                         &arch))
     return res;
   // Always fill data about module name and offset.
-  res->info.FillModuleInfo(module_name, module_offset);
+  res->info.FillModuleInfo(module_name, module_offset, arch);
   for (auto &tool : tools_) {
     SymbolizerScope sym_scope(this);
     if (tool.SymbolizePC(addr, res)) {
       return res;
     }
   }
   return res;
 }
 
 bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
   BlockingMutexLock l(&mu_);
   const char *module_name;
   uptr module_offset;
-  if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
+  ModuleArch arch;
+  if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset,
+                                         &arch))
     return false;
   info->Clear();
   info->module = internal_strdup(module_name);
   info->module_offset = module_offset;
+  info->module_arch = arch;
   for (auto &tool : tools_) {
     SymbolizerScope sym_scope(this);
     if (tool.SymbolizeData(addr, info)) {
       return true;
     }
   }
   return true;
 }
 
 bool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
                                              uptr *module_address) {
   BlockingMutexLock l(&mu_);
   const char *internal_module_name = nullptr;
+  ModuleArch arch;
   if (!FindModuleNameAndOffsetForAddress(pc, &internal_module_name,
-                                         module_address))
+                                         module_address, &arch))
     return false;
 
   if (module_name)
     *module_name = module_names_.GetOwnedCopy(internal_module_name);
   return true;
 }
 
 void Symbolizer::Flush() {

 
 void Symbolizer::PrepareForSandboxing() {
   BlockingMutexLock l(&mu_);
   PlatformPrepareForSandboxing();
 }
 
 bool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address,
                                                    const char **module_name,
-                                                   uptr *module_offset) {
+                                                   uptr *module_offset,
+                                                   ModuleArch *module_arch) {
   const LoadedModule *module = FindModuleForAddress(address);
   if (module == nullptr)
     return false;
   *module_name = module->full_name();
   *module_offset = address - module->base_address();
+  *module_arch = module->arch();
   return true;
 }
 
 const LoadedModule *Symbolizer::FindModuleForAddress(uptr address) {
   bool modules_were_reloaded = false;
   if (!modules_fresh_) {
     modules_.init();
     RAW_CHECK(modules_.size() > 0);

 
  private:
   bool ReachedEndOfOutput(const char *buffer, uptr length) const override {
     // Empty line marks the end of llvm-symbolizer output.
     return length >= 2 && buffer[length - 1] == '\n' &&
            buffer[length - 2] == '\n';
   }
 
+  // When adding a new architecture, don't forget to also update
+  // script/asan_symbolize.py and sanitizer_common.h.
   void GetArgV(const char *path_to_binary,
                const char *(&argv)[kArgVMax]) const override {
 #if defined(__x86_64h__)
     const char* const kSymbolizerArch = "--default-arch=x86_64h";
 #elif defined(__x86_64__)
     const char* const kSymbolizerArch = "--default-arch=x86_64";
 #elif defined(__i386__)
     const char* const kSymbolizerArch = "--default-arch=i386";
if (function_name[0] == '\0') {
       break;
     }
     SymbolizedStack *cur;
     if (top_frame) {
       cur = res;
       top_frame = false;
     } else {
       cur = SymbolizedStack::New(res->info.address);
-      cur->info.FillModuleInfo(res->info.module, res->info.module_offset);
+      cur->info.FillModuleInfo(res->info.module, res->info.module_offset,
+                               res->info.module_arch);
       last->next = cur;
       last = cur;
     }
 
     AddressInfo *info = &cur->info;
     info->function = function_name;
     str = ParseFileLineInfo(info, str);
 

 // Used by LLVMSymbolizer and InternalSymbolizer.
 void ParseSymbolizeDataOutput(const char *str, DataInfo *info) {
   str = ExtractToken(str, "\n", &info->name);
   str = ExtractUptr(str, " ", &info->start);
   str = ExtractUptr(str, "\n", &info->size);
 }
 
 bool LLVMSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
-  if (const char *buf = SendCommand(/*is_data*/ false, stack->info.module,
-                                    stack->info.module_offset)) {
+  AddressInfo *info = &stack->info;
+  const char *buf = FormatAndSendCommand(
+      /*is_data*/ false, info->module, info->module_offset, info->module_arch);
+  if (buf) {
     ParseSymbolizePCOutput(buf, stack);
     return true;
   }
   return false;
 }
 
 bool LLVMSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
-  if (const char *buf =
-          SendCommand(/*is_data*/ true, info->module, info->module_offset)) {
+  const char *buf = FormatAndSendCommand(
+      /*is_data*/ true, info->module, info->module_offset, info->module_arch);
+  if (buf) {
     ParseSymbolizeDataOutput(buf, info);
     info->start += (addr - info->module_offset); // Add the base address.
     return true;
   }
   return false;
 }
 
-const char *LLVMSymbolizer::SendCommand(bool is_data, const char *module_name,
-                                        uptr module_offset) {
+const char *LLVMSymbolizer::FormatAndSendCommand(bool is_data,
+                                                 const char *module_name,
+                                                 uptr module_offset,
+                                                 ModuleArch arch) {
   CHECK(module_name);
-  internal_snprintf(buffer_, kBufferSize, "%s\"%s\" 0x%zx\n",
-                    is_data ? "DATA " : "", module_name, module_offset);
+  const char *is_data_str = is_data ? "DATA " : "";
+  if (arch == kModuleArchUnknown) {
+    internal_snprintf(buffer_, kBufferSize, "%s\"%s\" 0x%zx\n", is_data_str,
+                      module_name, module_offset);
+  } else {
+    internal_snprintf(buffer_, kBufferSize, "%s\"%s:%s\" 0x%zx\n", is_data_str,
+                      module_name, ModuleArchToString(arch), module_offset);
+  }
   return symbolizer_process_->SendCommand(buffer_);
 }
 
 SymbolizerProcess::SymbolizerProcess(const char *path, bool use_forkpty)
     : path_(path),
       input_fd_(kInvalidFd),
       output_fd_(kInvalidFd),
       times_restarted_(0),

compiler-rt/trunk/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cc

TEST(SanitizerStacktracePrinter, RenderSourceLocation) {
 
   str.clear();
   RenderSourceLocation(&str, "/dir/file.cc", 10, 5, true, "/dir/");
   EXPECT_STREQ("file.cc(10,5)", str.data());
 }
 
 TEST(SanitizerStacktracePrinter, RenderModuleLocation) {
   InternalScopedString str(128);
-  RenderModuleLocation(&str, "/dir/exe", 0x123, "");
+  RenderModuleLocation(&str, "/dir/exe", 0x123, kModuleArchUnknown, "");
   EXPECT_STREQ("(/dir/exe+0x123)", str.data());
 
   // Check that we strip file prefix if necessary.
   str.clear();
-  RenderModuleLocation(&str, "/dir/exe", 0x123, "/dir/");
+  RenderModuleLocation(&str, "/dir/exe", 0x123, kModuleArchUnknown, "/dir/");
   EXPECT_STREQ("(exe+0x123)", str.data());
+
+  // Check that we render the arch.
+  str.clear();
+  RenderModuleLocation(&str, "/dir/exe", 0x123, kModuleArchX86_64H, "/dir/");
+  EXPECT_STREQ("(exe:x86_64h+0x123)", str.data());
 }
 
 TEST(SanitizerStacktracePrinter, RenderFrame) {
   int frame_no = 42;
   AddressInfo info;
   info.address = 0x400000;
   info.module = internal_strdup("/path/to/my/module");
   info.module_offset = 0x200;

compiler-rt/trunk/lib/ubsan/ubsan_diag.cc

static void RenderLocation(InternalScopedString *Buffer, Location Loc) {
   case Location::LK_Symbolized: {
     const AddressInfo &Info = Loc.getSymbolizedStack()->info;
     if (Info.file)
       RenderSourceLocation(Buffer, Info.file, Info.line, Info.column,
                            common_flags()->symbolize_vs_style,
                            common_flags()->strip_path_prefix);
     else if (Info.module)
       RenderModuleLocation(Buffer, Info.module, Info.module_offset,
-                           common_flags()->strip_path_prefix);
+                           Info.module_arch, common_flags()->strip_path_prefix);
     else
       Buffer->append("%p", Info.address);
     return;
   }
   case Location::LK_Null:
     Buffer->append("<unknown>");
     return;
   }

compiler-rt/trunk/test/asan/TestCases/Darwin/haswell-symbolication.cc

+// RUN: %clangxx_asan -arch x86_64 -arch x86_64h -g -O0 %s -c -o %t.o.fat
+// RUN: %clangxx_asan -arch x86_64 -arch x86_64h -g %t.o.fat -o %t.fat
+
+// RUN: lipo %t.fat -thin    x86_64  -output %t.thin.x86_64  && lipo %t.thin.x86_64  -info | FileCheck %s --check-prefix=CHECK-LIPO-THIN-X86_64
+// RUN: lipo %t.fat -thin    x86_64h -output %t.thin.x86_64h && lipo %t.thin.x86_64h -info | FileCheck %s --check-prefix=CHECK-LIPO-THIN-X86_64H
+// RUN: lipo %t.fat -extract x86_64  -output %t.fat.x86_64   && lipo %t.fat.x86_64   -info | FileCheck %s --check-prefix=CHECK-LIPO-FAT-X86_64
+// RUN: lipo %t.fat -extract x86_64h -output %t.fat.x86_64h  && lipo %t.fat.x86_64h  -info | FileCheck %s --check-prefix=CHECK-LIPO-FAT-X86_64H
+
+// CHECK-LIPO-THIN-X86_64:  Non-fat file: {{.*}} is architecture: x86_64
+// CHECK-LIPO-THIN-X86_64H: Non-fat file: {{.*}} is architecture: x86_64h
+// CHECK-LIPO-FAT-X86_64:   Architectures in the fat file: {{.*}} are: x86_64
+// CHECK-LIPO-FAT-X86_64H:  Architectures in the fat file: {{.*}} are: x86_64h
+
+// RUN: dsymutil %t.thin.x86_64
+// RUN: dsymutil %t.thin.x86_64h
+// RUN: dsymutil %t.fat.x86_64
+// RUN: dsymutil %t.fat.x86_64h
+
+// Check LLVM symbolizer
+// RUN: %env_asan_opts=external_symbolizer_path=$(which llvm-symbolizer) not %run %t.thin.x86_64  2>&1 | FileCheck %s --check-prefixes CHECK,CHECK-LI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path=$(which llvm-symbolizer) not %run %t.thin.x86_64h 2>&1 | FileCheck %s --check-prefixes CHECK,CHECK-LI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path=$(which llvm-symbolizer) not %run %t.fat.x86_64   2>&1 | FileCheck %s --check-prefixes CHECK,CHECK-LI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path=$(which llvm-symbolizer) not %run %t.fat.x86_64h  2>&1 | FileCheck %s --check-prefixes CHECK,CHECK-LI,CHECK-DATA
+
+// Check atos
+// RUN: %env_asan_opts=external_symbolizer_path=$(which atos) not %run %t.thin.x86_64  2>&1 | FileCheck %s --check-prefixes CHECK,CHECK-LI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path=$(which atos) not %run %t.thin.x86_64h 2>&1 | FileCheck %s --check-prefixes CHECK,CHECK-LI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path=$(which atos) not %run %t.fat.x86_64   2>&1 | FileCheck %s --check-prefixes CHECK,CHECK-LI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path=$(which atos) not %run %t.fat.x86_64h  2>&1 | FileCheck %s --check-prefixes CHECK,CHECK-LI,CHECK-DATA
+
+// Check dladdr
+// RUN: %env_asan_opts=external_symbolizer_path= not %run %t.thin.x86_64  2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-NOLI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path= not %run %t.thin.x86_64h 2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-NOLI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path= not %run %t.fat.x86_64   2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-NOLI,CHECK-DATA
+// RUN: %env_asan_opts=external_symbolizer_path= not %run %t.fat.x86_64h  2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-NOLI,CHECK-DATA
+
+// Check asan_symbolize.py with llvm-symbolizer
+// RUN: %env_asan_opts=symbolize=0 not %run %t.thin.x86_64  2>&1 | %asan_symbolize | FileCheck %s --check-prefixes CHECK,CHECK-LI
+// RUN: %env_asan_opts=symbolize=0 not %run %t.thin.x86_64h 2>&1 | %asan_symbolize | FileCheck %s --check-prefixes CHECK,CHECK-LI
+// RUN: %env_asan_opts=symbolize=0 not %run %t.fat.x86_64   2>&1 | %asan_symbolize | FileCheck %s --check-prefixes CHECK,CHECK-LI
+// RUN: %env_asan_opts=symbolize=0 not %run %t.fat.x86_64h  2>&1 | %asan_symbolize | FileCheck %s --check-prefixes CHECK,CHECK-LI
+
+// Check asan_symbolize.py with atos
+// RUN: %env_asan_opts=symbolize=0 not %run %t.thin.x86_64  2>&1 | %asan_symbolize --force-system-symbolizer | FileCheck %s --check-prefixes CHECK,CHECK-LI
+// RUN: %env_asan_opts=symbolize=0 not %run %t.thin.x86_64h 2>&1 | %asan_symbolize --force-system-symbolizer | FileCheck %s --check-prefixes CHECK,CHECK-LI
+// RUN: %env_asan_opts=symbolize=0 not %run %t.fat.x86_64   2>&1 | %asan_symbolize --force-system-symbolizer | FileCheck %s --check-prefixes CHECK,CHECK-LI
+// RUN: %env_asan_opts=symbolize=0 not %run %t.fat.x86_64h  2>&1 | %asan_symbolize --force-system-symbolizer | FileCheck %s --check-prefixes CHECK,CHECK-LI
+
+// REQUIRES: x86-target-arch
+// REQUIRES: x86_64h
+
+#include <sanitizer/common_interface_defs.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if __x86_64h__
+// Unused functions and globals, just to mess up the offsets in x86_64h.
+void dummy(char *a, char *b) {
+  while (*a == *b) {
+    a[0] = b[0];
+    a[1] = b[1];
+    a[2] = b[2];
+    a[3] = b[3];
+    fprintf(stderr, "dummy\n");
+  }
+  fprintf(stderr, "dummy\n");
+}
+long dummy_global;
+long dummy_global2[100];
+#endif
+
+extern "C"
+long faulty_global = 10;
+
+void check_data_symbolication() {
+  char data[100];
+  __sanitizer_symbolize_global(&faulty_global, "%g", data, sizeof(data));
+  fprintf(stderr, "symbolized global: %s\n", data);
+  // CHECK-DATA: symbolized global: faulty_global
+}
+
+extern "C"
+void faulty_func(char *p) {
+  *p = 'x';  // BOOM
+  // CHECK: AddressSanitizer: global-buffer-overflow
+  // CHECK-LI: #0 0x{{.*}} in faulty_func{{.*}} {{.*}}haswell-symbolication.cc:[[@LINE-2]]
+  // CHECK-NOLI: #0 0x{{.*}} in faulty_func{{.*}} {{.*}}haswell-symbolication
+  // CHECK: is located 2 bytes to the right of global variable 'faulty_global'
+  // CHECK-NOT: LLVMSymbolizer: error reading file
+}
+
+int main() {
+  check_data_symbolication();
+
+  char *p = (char *)(void *)&faulty_global;
+  p += 10;
+  faulty_func(p);
+  return 0;
+}

compiler-rt/trunk/test/asan/TestCases/Posix/asan-symbolize-sanity-test.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // Check that asan_symbolize.py script works (for binaries, ASan RTL and
 // shared object files.
 
 // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // RUN: %clangxx_asan -O0 %s %libdl -o %t
 // RUN: %env_asan_opts=symbolize=0 not %run %t 2>&1 | %asan_symbolize | FileCheck %s
-// UNSUPPORTED: x86_64h-darwin,x86_64-darwin
 // REQUIRES: stable-runtime
 
 #if !defined(SHARED_LIB)
 #include <dlfcn.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <string>

compiler-rt/trunk/test/lit.common.cfg

else:
       # The ASAN initialization-bug.cc test should XFAIL on OS X systems
       # older than El Capitan. By marking the test as being unsupported with
       # this "feature", we can pass the test on newer OS X versions and other
       # platforms.
       config.available_features.add('osx-no-ld64-live_support')
   except:
     pass
 
+  # Detect x86_64h
+  try:
+    output = subprocess.check_output(["sysctl", "hw.cpusubtype"])
+    output_re = re.match("^hw.cpusubtype: ([0-9]+)$", output)
+    if output_re:
+      cpu_subtype = int(output_re.group(1))
+      if cpu_subtype == 8: # x86_64h
+        config.available_features.add('x86_64h')
+  except:
+    pass
+
   config.substitutions.append( ("%macos_min_target_10_11", "-mmacosx-version-min=10.11") )
 else:
   config.substitutions.append( ("%macos_min_target_10_11", "") )
 
 sancovcc_path = os.path.join(llvm_tools_dir, "sancov") 
 if os.path.exists(sancovcc_path):
   config.available_features.add("has_sancovcc")
   config.substitutions.append( ("%sancovcc ", sancovcc_path) )

compiler-rt/trunk/test/tsan/simple_stack2.cc

int main() {
   pthread_create(&t, NULL, Thread1, NULL);
   bar2();
   barrier_wait(&barrier);
   pthread_join(t, NULL);
 }
 
 // CHECK:      WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   Write of size 4 at {{.*}} by thread T1:
-// CHECK-NEXT:     #0 foo1{{.*}} {{.*}}simple_stack2.cc:7{{(:10)?}} (simple_stack2.cc.exe+{{.*}})
-// CHECK-NEXT:     #1 bar1{{.*}} {{.*}}simple_stack2.cc:14{{(:3)?}} (simple_stack2.cc.exe+{{.*}})
-// CHECK-NEXT:     #2 Thread1{{.*}} {{.*}}simple_stack2.cc:32{{(:3)?}} (simple_stack2.cc.exe+{{.*}})
+// CHECK-NEXT:     #0 foo1{{.*}} {{.*}}simple_stack2.cc:7{{(:10)?}} ({{.*}})
+// CHECK-NEXT:     #1 bar1{{.*}} {{.*}}simple_stack2.cc:14{{(:3)?}} ({{.*}})
+// CHECK-NEXT:     #2 Thread1{{.*}} {{.*}}simple_stack2.cc:32{{(:3)?}} ({{.*}})
 // CHECK:        Previous read of size 4 at {{.*}} by main thread:
-// CHECK-NEXT:     #0 foo2{{.*}} {{.*}}simple_stack2.cc:18{{(:22)?}} (simple_stack2.cc.exe+{{.*}})
-// CHECK-NEXT:     #1 bar2{{.*}} {{.*}}simple_stack2.cc:27{{(:3)?}} (simple_stack2.cc.exe+{{.*}})
-// CHECK-NEXT:     #2 main{{.*}} {{.*}}simple_stack2.cc:40{{(:3)?}} (simple_stack2.cc.exe+{{.*}})
+// CHECK-NEXT:     #0 foo2{{.*}} {{.*}}simple_stack2.cc:18{{(:22)?}} ({{.*}})
+// CHECK-NEXT:     #1 bar2{{.*}} {{.*}}simple_stack2.cc:27{{(:3)?}} ({{.*}})
+// CHECK-NEXT:     #2 main{{.*}} {{.*}}simple_stack2.cc:40{{(:3)?}} ({{.*}})