Merged main:11b9ec5f240e into amd-gfx:121ddb486b15

Local branch amd-gfx 121ddb4 Merged main:a5a008ff4f59 into amd-gfx:40bdeb2e3eb6
Remote branch main 11b9ec5 [sanitizer] Add more internal symbolizer tests

Author: SC llvm team

clang/lib/Driver/ToolChains/Gnu.cpp

@@ -3100,6 +3100,8 @@ Generic_GCC::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
                                    llvm::opt::ArgStringList &CC1Args) const {
   const Driver &D = getDriver();
   std::string SysRoot = computeSysRoot();
+  if (SysRoot.empty())
+    SysRoot = llvm::sys::path::get_separator();
 
   auto AddIncludePath = [&](StringRef Path, bool TargetDirRequired = false) {
     std::string Version = detectLibcxxVersion(Path);

clang/unittests/Driver/ToolChainTest.cpp

@@ -19,10 +19,12 @@
 #include "clang/Driver/Driver.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <memory>
 
@@ -316,6 +318,52 @@ TEST(ToolChainTest, VFSSolarisMultiGCCInstallation) {
   }
 }
 
+MATCHER_P(jobHasArgs, Substr, "") {
+  const driver::Command &C = arg;
+  std::string Args = "";
+  llvm::ListSeparator Sep(" ");
+  for (const char *Arg : C.getArguments()) {
+    Args += Sep;
+    Args += Arg;
+  }
+  if (is_style_windows(llvm::sys::path::Style::native))
+    std::replace(Args.begin(), Args.end(), '\\', '/');
+  if (llvm::StringRef(Args).contains(Substr))
+    return true;
+  *result_listener << "whose args are '" << Args << "'";
+  return false;
+}
+
+TEST(ToolChainTest, VFSGnuLibcxxPathNoSysroot) {
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  struct TestDiagnosticConsumer : public DiagnosticConsumer {};
+  IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
+      new llvm::vfs::InMemoryFileSystem);
+
+  const char *EmptyFiles[] = {
+      "foo.cpp",
+      "/bin/clang",
+      "/usr/include/c++/v1/cstdio",
+  };
+
+  for (const char *Path : EmptyFiles)
+    InMemoryFileSystem->addFile(Path, 0,
+                                llvm::MemoryBuffer::getMemBuffer("\n"));
+
+  {
+    DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
+    Driver TheDriver("/bin/clang", "x86_64-unknown-linux-gnu", Diags,
+                     "clang LLVM compiler", InMemoryFileSystem);
+    std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
+        {"/bin/clang", "-fsyntax-only", "-stdlib=libc++", "foo.cpp"}));
+    ASSERT_TRUE(C);
+    EXPECT_THAT(C->getJobs(), testing::ElementsAre(jobHasArgs(
+                                  "-internal-isystem /usr/include/c++/v1")));
+  }
+}
+
 TEST(ToolChainTest, DefaultDriverMode) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 

compiler-rt/lib/hwasan/CMakeLists.txt

@@ -164,8 +164,7 @@ function(add_hwasan_runtimes arch use_aliases)
                 RTSanitizerCommonLibc
                 RTSanitizerCommonCoverage
                 RTSanitizerCommonSymbolizer
-                # FIXME: disable tagging when in symbolizer.
-                # RTSanitizerCommonSymbolizerInternal
+                RTSanitizerCommonSymbolizerInternal
                 RTLSanCommon
                 RTUbsan
     CFLAGS ${hwasan_rtl_flags}
@@ -203,8 +202,7 @@ function(add_hwasan_runtimes arch use_aliases)
             RTSanitizerCommonLibc
             RTSanitizerCommonCoverage
             RTSanitizerCommonSymbolizer
-            # FIXME: disable tagging when in symbolizer.
-            # RTSanitizerCommonSymbolizerInternal
+            RTSanitizerCommonSymbolizerInternal
             RTLSanCommon
             RTUbsan
             RTUbsan_cxx

compiler-rt/lib/hwasan/hwasan_allocator.cpp

@@ -234,28 +234,23 @@ static void *HwasanAllocate(StackTrace *stack, uptr orig_size, uptr alignment,
   }
 
   void *user_ptr = allocated;
-  // Tagging can only be skipped when both tag_in_malloc and tag_in_free are
-  // false. When tag_in_malloc = false and tag_in_free = true malloc needs to
-  // retag to 0.
   if (InTaggableRegion(reinterpret_cast<uptr>(user_ptr)) &&
-      (flags()->tag_in_malloc || flags()->tag_in_free) &&
-      atomic_load_relaxed(&hwasan_allocator_tagging_enabled)) {
-    if (flags()->tag_in_malloc && malloc_bisect(stack, orig_size)) {
-      tag_t tag = t ? t->GenerateRandomTag() : kFallbackAllocTag;
-      uptr tag_size = orig_size ? orig_size : 1;
-      uptr full_granule_size = RoundDownTo(tag_size, kShadowAlignment);
-      user_ptr =
-          (void *)TagMemoryAligned((uptr)user_ptr, full_granule_size, tag);
-      if (full_granule_size != tag_size) {
-        u8 *short_granule =
-            reinterpret_cast<u8 *>(allocated) + full_granule_size;
-        TagMemoryAligned((uptr)short_granule, kShadowAlignment,
-                         tag_size % kShadowAlignment);
-        short_granule[kShadowAlignment - 1] = tag;
-      }
-    } else {
-      user_ptr = (void *)TagMemoryAligned((uptr)user_ptr, size, 0);
+      atomic_load_relaxed(&hwasan_allocator_tagging_enabled) &&
+      flags()->tag_in_malloc && malloc_bisect(stack, orig_size)) {
+    tag_t tag = t ? t->GenerateRandomTag() : kFallbackAllocTag;
+    uptr tag_size = orig_size ? orig_size : 1;
+    uptr full_granule_size = RoundDownTo(tag_size, kShadowAlignment);
+    user_ptr = (void *)TagMemoryAligned((uptr)user_ptr, full_granule_size, tag);
+    if (full_granule_size != tag_size) {
+      u8 *short_granule = reinterpret_cast<u8 *>(allocated) + full_granule_size;
+      TagMemoryAligned((uptr)short_granule, kShadowAlignment,
+                       tag_size % kShadowAlignment);
+      short_granule[kShadowAlignment - 1] = tag;
     }
+  } else {
+    // Tagging can not be completely skipped. If it's disabled, we need to tag
+    // with zeros.
+    user_ptr = (void *)TagMemoryAligned((uptr)user_ptr, size, 0);
   }
 
   Metadata *meta =

compiler-rt/test/hwasan/TestCases/enable-disable.c

@@ -0,0 +1,42 @@
+// Test that disabling/enabling tagging does not trigger false reports on
+// allocations happened in a different state.
+
+// RUN: %clang_hwasan -O1 %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <sanitizer/hwasan_interface.h>
+#include <stdlib.h>
+
+enum {
+  COUNT = 5,
+  SZ = 10,
+};
+void *x[COUNT];
+
+int main() {
+  __hwasan_enable_allocator_tagging();
+  for (unsigned i = 0; i < COUNT; ++i) {
+    x[i] = malloc(SZ);
+    assert(__hwasan_test_shadow(x[i], SZ) == -1);
+  }
+  for (unsigned i = 0; i < COUNT; ++i)
+    free(x[i]);
+
+  __hwasan_disable_allocator_tagging();
+  for (unsigned i = 0; i < COUNT; ++i) {
+    x[i] = malloc(SZ);
+    assert(__hwasan_tag_pointer(x[i], 0) == x[i]);
+    assert(__hwasan_test_shadow(x[i], SZ) == -1);
+  }
+  for (unsigned i = 0; i < COUNT; ++i)
+    free(x[i]);
+
+  __hwasan_enable_allocator_tagging();
+  for (unsigned i = 0; i < COUNT; ++i) {
+    x[i] = malloc(SZ);
+    assert(__hwasan_test_shadow(x[i], SZ) == -1);
+  }
+  for (unsigned i = 0; i < COUNT; ++i)
+    free(x[i]);
+  return 0;
+}

compiler-rt/test/sanitizer_common/TestCases/Linux/internal_symbolizer.cpp

@@ -0,0 +1,142 @@
+// RUN: %clangxx %s -o %t && %run %t
+
+// REQUIRES: internal_symbolizer
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <link.h>
+#include <sanitizer/msan_interface.h>
+#include <string.h>
+
+#include <string>
+#include <vector>
+
+extern "C" {
+bool __sanitizer_symbolize_code(const char *ModuleName, uint64_t ModuleOffset,
+                                char *Buffer, int MaxLength,
+                                bool SymbolizeInlineFrames);
+bool __sanitizer_symbolize_data(const char *ModuleName, uint64_t ModuleOffset,
+                                char *Buffer, int MaxLength);
+void __sanitizer_print_stack_trace();
+bool __sanitizer_symbolize_demangle(const char *Name, char *Buffer,
+                                    int MaxLength);
+}
+
+struct ScopedInSymbolizer {
+#if defined(__has_feature)
+#  if __has_feature(memory_sanitizer)
+  ScopedInSymbolizer() { __msan_scoped_disable_interceptor_checks(); }
+  ~ScopedInSymbolizer() { __msan_scoped_enable_interceptor_checks(); }
+#  endif
+#endif
+};
+
+struct FrameInfo {
+  int line;
+  std::string file;
+  std::string function;
+  void *address;
+};
+
+__attribute__((noinline)) void *GetPC() { return __builtin_return_address(0); }
+
+__attribute__((always_inline)) FrameInfo InlineFunction() {
+  void *address = GetPC();
+  return {__LINE__ - 1, __FILE__, __FUNCTION__,
+          reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(address) - 1)};
+}
+
+__attribute__((noinline)) FrameInfo NoInlineFunction() {
+  void *address = GetPC();
+  return {__LINE__ - 1, __FILE__, __FUNCTION__,
+          reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(address) - 1)};
+}
+
+template <int N> struct A {
+  template <class T> FrameInfo RecursiveTemplateFunction(const T &t);
+};
+
+template <int N>
+template <class T>
+__attribute__((noinline)) FrameInfo A<N>::RecursiveTemplateFunction(const T &) {
+  std::vector<T> t;
+  return A<N - 1>().RecursiveTemplateFunction(t);
+}
+
+template <>
+template <class T>
+__attribute__((noinline)) FrameInfo A<0>::RecursiveTemplateFunction(const T &) {
+  return NoInlineFunction();
+}
+
+__attribute__((no_sanitize_memory)) std::pair<const char *, uint64_t>
+GetModuleAndOffset(void *address) {
+  Dl_info di;
+  link_map *lm = nullptr;
+  assert(
+      dladdr1(address, &di, reinterpret_cast<void **>(&lm), RTLD_DL_LINKMAP));
+  return {di.dli_fname, reinterpret_cast<uint64_t>(address) - lm->l_addr};
+}
+
+std::string Symbolize(FrameInfo frame) {
+  auto modul_offset = GetModuleAndOffset(frame.address);
+  char buffer[1024] = {};
+  ScopedInSymbolizer in_symbolizer;
+  __sanitizer_symbolize_code(modul_offset.first, modul_offset.second, buffer,
+                             std::size(buffer), true);
+  return buffer;
+}
+
+std::string GetRegex(const FrameInfo &frame) {
+  return frame.function + "[^\\n]*\\n[^\\n]*" + frame.file + ":" +
+         std::to_string(frame.line);
+}
+
+void TestInline() {
+  auto frame = InlineFunction();
+  fprintf(stderr, "%s: %s\n", __FUNCTION__, Symbolize(frame).c_str());
+}
+
+void TestNoInline() {
+  auto frame = NoInlineFunction();
+  fprintf(stderr, "%s: %s\n", __FUNCTION__, Symbolize(frame).c_str());
+}
+
+void TestLongFunctionNames() {
+  auto frame = A<10>().RecursiveTemplateFunction(0);
+  fprintf(stderr, "%s: %s\n", __FUNCTION__, Symbolize(frame).c_str());
+}
+
+std::string SymbolizeStaticVar() {
+  static int var = 1;
+  auto modul_offset = GetModuleAndOffset(&var);
+  char buffer[1024] = {};
+  ScopedInSymbolizer in_symbolizer;
+  __sanitizer_symbolize_data(modul_offset.first, modul_offset.second, buffer,
+                             std::size(buffer));
+  return buffer;
+}
+
+void TestData() {
+  fprintf(stderr, "%s: %s\n", __FUNCTION__, SymbolizeStaticVar().c_str());
+}
+
+void TestDemangle() {
+  char out[128];
+  assert(!__sanitizer_symbolize_demangle("1A", out, sizeof(out)));
+
+  const char name[] = "_Z3fooi";
+  for (int i = 1; i < sizeof(out); ++i) {
+    memset(out, 1, sizeof(out));
+    assert(__sanitizer_symbolize_demangle(name, out, i) == (i > 8));
+    assert(i < 9 || 0 == strncmp(out, "foo(int)", i - 1));
+  }
+}
+
+int main() {
+  TestInline();
+  TestNoInline();
+  TestLongFunctionNames();
+  TestData();
+  TestDemangle();
+}

compiler-rt/test/sanitizer_common/TestCases/demangle_internal.cpp

@@ -1779,7 +1779,7 @@ Metadata
 ========
 
 '``coro.outside.frame``' Metadata
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+---------------------------------
 
 ``coro.outside.frame`` metadata may be attached to an alloca instruction to
 to signify that it shouldn't be promoted to the coroutine frame, useful for

llvm/docs/Coroutines.rst

@@ -16,7 +16,7 @@
 
 /* Indicate that this is LLVM compiled from the amd-gfx branch. */
 #define LLVM_HAVE_BRANCH_AMD_GFX
-#define LLVM_MAIN_REVISION 475679
+#define LLVM_MAIN_REVISION 475700
 
 /* Define if LLVM_ENABLE_DUMP is enabled */
 #cmakedefine LLVM_ENABLE_DUMP

llvm/include/llvm/Config/llvm-config.h.cmake

@@ -988,7 +988,7 @@ SizeOffsetType ObjectSizeOffsetVisitor::combineSizeOffset(SizeOffsetType LHS,
     return (getSizeWithOverflow(LHS).eq(getSizeWithOverflow(RHS))) ? LHS
                                                                    : unknown();
   case ObjectSizeOpts::Mode::ExactUnderlyingSizeAndOffset:
-    return LHS == RHS && LHS.second.eq(RHS.second) ? LHS : unknown();
+    return LHS == RHS ? LHS : unknown();
   }
   llvm_unreachable("missing an eval mode");
 }

llvm/lib/Analysis/MemoryBuiltins.cpp

@@ -37,6 +37,11 @@ static cl::opt<bool>
     EnableTrapUnreachable("trap-unreachable", cl::Hidden,
                           cl::desc("Enable generating trap for unreachable"));
 
+static cl::opt<bool> EnableNoTrapAfterNoreturn(
+    "no-trap-after-noreturn", cl::Hidden,
+    cl::desc("Do not emit a trap instruction for 'unreachable' IR instructions "
+             "after noreturn calls, even if --trap-unreachable is set."));
+
 void LLVMTargetMachine::initAsmInfo() {
   MRI.reset(TheTarget.createMCRegInfo(getTargetTriple().str()));
   assert(MRI && "Unable to create reg info");
@@ -95,6 +100,8 @@ LLVMTargetMachine::LLVMTargetMachine(const Target &T,
 
   if (EnableTrapUnreachable)
     this->Options.TrapUnreachable = true;
+  if (EnableNoTrapAfterNoreturn)
+    this->Options.NoTrapAfterNoreturn = true;
 }
 
 TargetTransformInfo