Merged main:3b3f8c50b646 into origin/amd-gfx:6124eec093c1

Local branch origin/amd-gfx 6124eec Reapply "DAG: Use phi to create vregs instead of the constant input" (llvm#1274)
Remote branch main 3b3f8c5 [asan] Re-exec without ASLR if needed on 32-bit Linux (llvm#131975)

Author: SC llvm team

clang/lib/CodeGen/CodeGenModule.cpp

@@ -2936,9 +2936,8 @@ void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
                                           bool IsThunk) {
 
   if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
-    // If this is an intrinsic function, set the function's attributes
-    // to the intrinsic's attributes.
-    F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), IID));
+    // If this is an intrinsic function, the attributes will have been set
+    // when the function was created.
     return;
   }
 

compiler-rt/lib/asan/asan_internal.h

@@ -82,6 +82,7 @@ void ReplaceSystemMalloc();
 uptr FindDynamicShadowStart();
 void AsanCheckDynamicRTPrereqs();
 void AsanCheckIncompatibleRT();
+void TryReExecWithoutASLR();
 
 // Unpoisons platform-specific stacks.
 // Returns true if all stacks have been unpoisoned.

compiler-rt/lib/asan/asan_linux.cpp

@@ -21,6 +21,7 @@
 #  include <pthread.h>
 #  include <stdio.h>
 #  include <sys/mman.h>
+#  include <sys/personality.h>
 #  include <sys/resource.h>
 #  include <sys/syscall.h>
 #  include <sys/time.h>
@@ -107,6 +108,37 @@ void FlushUnneededASanShadowMemory(uptr p, uptr size) {
   ReleaseMemoryPagesToOS(MemToShadow(p), MemToShadow(p + size));
 }
 
+void ReExecWithoutASLR() {
+  // ASLR personality check.
+  // Caution: 'personality' is sometimes forbidden by sandboxes, so only call
+  // this function as a last resort (when the memory mapping is incompatible
+  // and ASan would fail anyway).
+  int old_personality = personality(0xffffffff);
+  if (old_personality == -1) {
+    VReport(1, "WARNING: unable to run personality check.\n");
+    return;
+  }
+
+  bool aslr_on = (old_personality & ADDR_NO_RANDOMIZE) == 0;
+
+  if (aslr_on) {
+    // Disable ASLR if the memory layout was incompatible.
+    // Alternatively, we could just keep re-execing until we get lucky
+    // with a compatible randomized layout, but the risk is that if it's
+    // not an ASLR-related issue, we will be stuck in an infinite loop of
+    // re-execing (unless we change ReExec to pass a parameter of the
+    // number of retries allowed.)
+    VReport(1,
+            "WARNING: AddressSanitizer: memory layout is incompatible, "
+            "possibly due to high-entropy ASLR.\n"
+            "Re-execing with fixed virtual address space.\n"
+            "N.B. reducing ASLR entropy is preferable.\n");
+    CHECK_NE(personality(old_personality | ADDR_NO_RANDOMIZE), -1);
+
+    ReExec();
+  }
+}
+
 #  if SANITIZER_ANDROID
 // FIXME: should we do anything for Android?
 void AsanCheckDynamicRTPrereqs() {}

compiler-rt/lib/asan/asan_mac.cpp

@@ -55,6 +55,9 @@ uptr FindDynamicShadowStart() {
                           GetMmapGranularity());
 }
 
+// Not used.
+void TryReExecWithoutASLR() {}
+
 // No-op. Mac does not support static linkage anyway.
 void AsanCheckDynamicRTPrereqs() {}
 

compiler-rt/lib/asan/asan_shadow_setup.cpp

@@ -109,6 +109,13 @@ void InitializeShadowMemory() {
     ProtectGap(kShadowGap2Beg, kShadowGap2End - kShadowGap2Beg + 1);
     ProtectGap(kShadowGap3Beg, kShadowGap3End - kShadowGap3Beg + 1);
   } else {
+    // The shadow mappings can shadow the entire user address space. However,
+    // on 32-bit systems, the maximum ASLR entropy (currently up to 16-bits
+    // == 256MB) is a significant chunk of the address space; reclaiming it by
+    // disabling ASLR might allow chonky binaries to run.
+    if (sizeof(uptr) == 32)
+      TryReExecWithoutASLR();
+
     Report(
         "Shadow memory range interleaves with an existing memory mapping. "
         "ASan cannot proceed correctly. ABORTING.\n");

compiler-rt/lib/asan/asan_win.cpp

@@ -279,6 +279,9 @@ uptr FindDynamicShadowStart() {
                           GetMmapGranularity());
 }
 
+// Not used
+void TryReExecWithoutASLR() {}
+
 void AsanCheckDynamicRTPrereqs() {}
 
 void AsanCheckIncompatibleRT() {}

libclc/cmake/modules/AddLibclc.cmake

@@ -107,9 +107,13 @@ function(link_bc)
     set( LINK_INPUT_ARG "@${RSP_FILE}" )
   endif()
 
+  if( ARG_INTERNALIZE )
+    set( link_flags --internalize --only-needed )
+  endif()
+
   add_custom_command(
     OUTPUT ${ARG_TARGET}.bc
-    COMMAND ${llvm-link_exe} $<$<BOOL:${ARG_INTERNALIZE}>:--internalize> -o ${ARG_TARGET}.bc ${LINK_INPUT_ARG}
+    COMMAND ${llvm-link_exe} ${link_flags} -o ${ARG_TARGET}.bc ${LINK_INPUT_ARG}
     DEPENDS ${llvm-link_target} ${ARG_DEPENDENCIES} ${ARG_INPUTS} ${RSP_FILE}
   )
 

libcxx/test/std/containers/sequences/vector.bool/copy.pass.cpp

@@ -11,12 +11,13 @@
 
 // vector(const vector& v);
 
-#include <vector>
+#include <array>
 #include <cassert>
+#include <vector>
 
-#include "test_macros.h"
-#include "test_allocator.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_macros.h"
 
 template <class C>
 TEST_CONSTEXPR_CXX20 void test(const C& x) {
@@ -25,39 +26,56 @@ TEST_CONSTEXPR_CXX20 void test(const C& x) {
   LIBCPP_ASSERT(c.__invariants());
   assert(c.size() == s);
   assert(c == x);
+#if TEST_STD_VER >= 11
+  assert(c.get_allocator() ==
+         std::allocator_traits<typename C::allocator_type>::select_on_container_copy_construction(x.get_allocator()));
+#endif
 }
 
 TEST_CONSTEXPR_CXX20 bool tests() {
-  {
-    bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
-    bool* an = a + sizeof(a) / sizeof(a[0]);
-    test(std::vector<bool>(a, an));
-  }
-  {
-    std::vector<bool, test_allocator<bool> > v(3, true, test_allocator<bool>(5));
-    std::vector<bool, test_allocator<bool> > v2 = v;
-    assert(v2 == v);
-    assert(v2.get_allocator() == v.get_allocator());
+  std::array<int, 5> a1   = {1, 0, 1, 0, 1};
+  std::array<int, 18> a2  = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
+  std::array<int, 33> a3  = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
+  std::array<int, 65> a4  = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
+  std::array<int, 299> a5 = {};
+  for (unsigned i = 0; i < a5.size(); i += 2)
+    a5[i] = 1;
+
+  // Tests for vector<bool> copy constructor with word size up to 5 (i.e., bit size > 256 on a 64-bit system)
+  { // Test with default std::allocator
+    test(std::vector<bool>(a1.begin(), a1.end()));
+    test(std::vector<bool>(a2.begin(), a2.end()));
+    test(std::vector<bool>(a3.begin(), a3.end()));
+    test(std::vector<bool>(a4.begin(), a4.end()));
+    test(std::vector<bool>(a5.begin(), a5.end()));
   }
-#if TEST_STD_VER >= 11
-  {
-    std::vector<bool, other_allocator<bool> > v(3, true, other_allocator<bool>(5));
-    std::vector<bool, other_allocator<bool> > v2 = v;
-    assert(v2 == v);
-    assert(v2.get_allocator() == other_allocator<bool>(-2));
+  { // Test with test_allocator
+    using A = test_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a1.begin(), a1.end()));
+    test(C(a2.begin(), a2.end()));
+    test(C(a3.begin(), a3.end()));
+    test(C(a4.begin(), a4.end()));
+    test(C(a5.begin(), a5.end()));
   }
-  {
-    bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
-    bool* an = a + sizeof(a) / sizeof(a[0]);
-    test(std::vector<bool, min_allocator<bool>>(a, an));
+  { // Test with other_allocator
+    using A = other_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a1.begin(), a1.end()));
+    test(C(a2.begin(), a2.end()));
+    test(C(a3.begin(), a3.end()));
+    test(C(a4.begin(), a4.end()));
+    test(C(a5.begin(), a5.end()));
   }
-  {
-    std::vector<bool, min_allocator<bool> > v(3, true, min_allocator<bool>());
-    std::vector<bool, min_allocator<bool> > v2 = v;
-    assert(v2 == v);
-    assert(v2.get_allocator() == v.get_allocator());
+  { // Test with min_allocator
+    using A = min_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a1.begin(), a1.end()));
+    test(C(a2.begin(), a2.end()));
+    test(C(a3.begin(), a3.end()));
+    test(C(a4.begin(), a4.end()));
+    test(C(a5.begin(), a5.end()));
   }
-#endif
 
   return true;
 }

libcxx/test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp

@@ -7,15 +7,17 @@
 //===----------------------------------------------------------------------===//
 
 // <vector>
+// vector<bool>
 
 // vector(const vector& v, const allocator_type& a);
 
-#include <vector>
+#include <array>
 #include <cassert>
+#include <vector>
 
-#include "test_macros.h"
-#include "test_allocator.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_macros.h"
 
 template <class C>
 TEST_CONSTEXPR_CXX20 void test(const C& x, const typename C::allocator_type& a) {
@@ -24,39 +26,53 @@ TEST_CONSTEXPR_CXX20 void test(const C& x, const typename C::allocator_type& a)
   LIBCPP_ASSERT(c.__invariants());
   assert(c.size() == s);
   assert(c == x);
+  assert(c.get_allocator() == a);
 }
 
 TEST_CONSTEXPR_CXX20 bool tests() {
-  {
-    bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
-    bool* an = a + sizeof(a) / sizeof(a[0]);
-    test(std::vector<bool>(a, an), std::allocator<bool>());
-  }
-  {
-    std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
-    std::vector<bool, test_allocator<bool> > l2(l, test_allocator<bool>(3));
-    assert(l2 == l);
-    assert(l2.get_allocator() == test_allocator<bool>(3));
+  std::array<int, 5> a1   = {1, 0, 1, 0, 1};
+  std::array<int, 18> a2  = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
+  std::array<int, 33> a3  = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
+  std::array<int, 65> a4  = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
+  std::array<int, 299> a5 = {};
+  for (unsigned i = 0; i < a5.size(); i += 2)
+    a5[i] = 1;
+
+  // Tests for allocator-extended copy constructor with word size up to 5 (i.e., bit size > 256 on a 64-bit system)
+  { // Test with the default std::allocator
+    test(std::vector<bool>(a1.begin(), a1.end()), std::allocator<bool>());
+    test(std::vector<bool>(a2.begin(), a2.end()), std::allocator<bool>());
+    test(std::vector<bool>(a3.begin(), a3.end()), std::allocator<bool>());
+    test(std::vector<bool>(a4.begin(), a4.end()), std::allocator<bool>());
+    test(std::vector<bool>(a5.begin(), a5.end()), std::allocator<bool>());
   }
-  {
-    std::vector<bool, other_allocator<bool> > l(3, true, other_allocator<bool>(5));
-    std::vector<bool, other_allocator<bool> > l2(l, other_allocator<bool>(3));
-    assert(l2 == l);
-    assert(l2.get_allocator() == other_allocator<bool>(3));
+  { // Test with test_allocator
+    using A = test_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a1.begin(), a1.end(), A(5)), A(3));
+    test(C(a2.begin(), a2.end(), A(5)), A(3));
+    test(C(a3.begin(), a3.end(), A(5)), A(3));
+    test(C(a4.begin(), a4.end(), A(5)), A(3));
+    test(C(a5.begin(), a5.end(), A(5)), A(3));
   }
-#if TEST_STD_VER >= 11
-  {
-    bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
-    bool* an = a + sizeof(a) / sizeof(a[0]);
-    test(std::vector<bool, min_allocator<bool>>(a, an), min_allocator<bool>());
+  { // Test with other_allocator
+    using A = other_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a1.begin(), a1.end(), A(5)), A(3));
+    test(C(a2.begin(), a2.end(), A(5)), A(3));
+    test(C(a3.begin(), a3.end(), A(5)), A(3));
+    test(C(a4.begin(), a4.end(), A(5)), A(3));
+    test(C(a5.begin(), a5.end(), A(5)), A(3));
   }
-  {
-    std::vector<bool, min_allocator<bool> > l(3, true, min_allocator<bool>());
-    std::vector<bool, min_allocator<bool> > l2(l, min_allocator<bool>());
-    assert(l2 == l);
-    assert(l2.get_allocator() == min_allocator<bool>());
+  { // Test with min_allocator
+    using A = min_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a1.begin(), a1.end(), A()), A());
+    test(C(a2.begin(), a2.end(), A()), A());
+    test(C(a3.begin(), a3.end(), A()), A());
+    test(C(a4.begin(), a4.end(), A()), A());
+    test(C(a5.begin(), a5.end(), A()), A());
   }
-#endif
 
   return true;
 }