Merge "libc: -x some assembly files" into main
diff --git a/TEST_MAPPING b/TEST_MAPPING
index 60a4f61..e98c2ff 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -88,6 +88,12 @@
},
{
"name": "toybox-tests"
+ },
+ {
+ "name": "hwasan_test"
+ },
+ {
+ "name": "hwasan_test_static"
}
],
"kernel-presubmit": [
diff --git a/libc/bionic/jemalloc_wrapper.cpp b/libc/bionic/jemalloc_wrapper.cpp
index 1bbdb29..63c9fab 100644
--- a/libc/bionic/jemalloc_wrapper.cpp
+++ b/libc/bionic/jemalloc_wrapper.cpp
@@ -15,6 +15,7 @@
*/
#include <errno.h>
+#include <inttypes.h>
#include <malloc.h>
#include <sys/param.h>
#include <unistd.h>
@@ -30,6 +31,7 @@
size_t je_mallinfo_nbins();
struct mallinfo je_mallinfo_arena_info(size_t);
struct mallinfo je_mallinfo_bin_info(size_t, size_t);
+void je_stats_arena(size_t arena_index, void (*callback)(size_t, size_t, size_t));
__END_DECLS
@@ -136,29 +138,24 @@
}
return 1;
} else if (param == M_LOG_STATS) {
+ size_t total_bytes = 0;
for (size_t i = 0; i < je_mallinfo_narenas(); i++) {
struct mallinfo mi = je_mallinfo_arena_info(i);
- if (mi.hblkhd != 0) {
- async_safe_format_log(ANDROID_LOG_INFO, "jemalloc",
- "Arena %zu: large bytes %zu huge bytes %zu bin bytes %zu", i,
- mi.ordblks, mi.uordblks, mi.fsmblks);
+ size_t arena_bytes = mi.fsmblks + mi.ordblks + mi.uordblks;
+ async_safe_format_log(ANDROID_LOG_INFO, "jemalloc",
+ "Arena %zu: bin bytes=%zu large bytes=%zu total bytes=%zu", i,
+ mi.fsmblks, mi.ordblks, arena_bytes);
- for (size_t j = 0; j < je_mallinfo_nbins(); j++) {
- struct mallinfo mi = je_mallinfo_bin_info(i, j);
- if (mi.ordblks != 0) {
- size_t total_allocs = 1;
- if (mi.uordblks > mi.fordblks) {
- total_allocs = mi.uordblks - mi.fordblks;
- }
- size_t bin_size = mi.ordblks / total_allocs;
- async_safe_format_log(
- ANDROID_LOG_INFO, "jemalloc",
- " Bin %zu (%zu bytes): allocated bytes %zu nmalloc %zu ndalloc %zu", j, bin_size,
- mi.ordblks, mi.uordblks, mi.fordblks);
- }
+ je_stats_arena(i, [](size_t index, size_t size, size_t allocs) {
+ if (allocs != 0) {
+ async_safe_format_log(ANDROID_LOG_INFO, "jemalloc",
+ " Size Class %zu(%zu bytes): allocs=%zu total bytes=%zu", index,
+ size, allocs, allocs * size);
}
- }
+ });
+ total_bytes += arena_bytes;
}
+ async_safe_format_log(ANDROID_LOG_INFO, "jemalloc", "Total Bytes=%zu", total_bytes);
return 1;
}
diff --git a/libc/bionic/wctype.cpp b/libc/bionic/wctype.cpp
index 403d2fb..94597d9 100644
--- a/libc/bionic/wctype.cpp
+++ b/libc/bionic/wctype.cpp
@@ -159,6 +159,7 @@
wctrans_t wctrans(const char* name) {
if (strcmp(name, "tolower") == 0) return wctrans_tolower;
if (strcmp(name, "toupper") == 0) return wctrans_toupper;
+ errno = EINVAL;
return nullptr;
}
__strong_alias(wctrans_l, wctrans);
@@ -167,6 +168,6 @@
if (t == wctrans_tolower) return towlower(c);
if (t == wctrans_toupper) return towupper(c);
errno = EINVAL;
- return 0;
+ return c;
}
__strong_alias(towctrans_l, towctrans);
diff --git a/tests/Android.bp b/tests/Android.bp
index deb2843..6aecb40 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -389,6 +389,7 @@
"bug_26110743_test.cpp",
"byteswap_test.cpp",
"complex_test.cpp",
+ "cpu_target_features_test.cpp",
"ctype_test.cpp",
"dirent_test.cpp",
"elf_test.cpp",
@@ -1083,8 +1084,8 @@
],
}
-cc_test {
- name: "hwasan_test",
+cc_defaults {
+ name: "hwasan_test_defaults",
enabled: false,
// This does not use bionic_tests_defaults because it is not supported on
// host.
@@ -1099,9 +1100,6 @@
srcs: [
"hwasan_test.cpp",
],
- shared_libs: [
- "libbase",
- ],
data_libs: [
"libtest_simple_hwasan",
"libtest_simple_hwasan_nohwasan",
@@ -1111,6 +1109,24 @@
}
cc_test {
+ name: "hwasan_test",
+ defaults: ["hwasan_test_defaults"],
+ shared_libs: [
+ "libbase",
+ ],
+}
+
+cc_test {
+ name: "hwasan_test_static",
+ defaults: ["hwasan_test_defaults"],
+ static_libs: [
+ "libbase",
+ ],
+ static_executable: true,
+ cflags: ["-DHWASAN_TEST_STATIC"],
+}
+
+cc_test {
name: "memtag_stack_dlopen_test",
enabled: false,
// This does not use bionic_tests_defaults because it is not supported on
diff --git a/tests/cpu_target_features_test.cpp b/tests/cpu_target_features_test.cpp
new file mode 100644
index 0000000..3458bca
--- /dev/null
+++ b/tests/cpu_target_features_test.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <gtest/gtest.h>
+#include <stdlib.h>
+
+#include "utils.h"
+
+TEST(cpu_target_features, has_expected_x86_compiler_values) {
+#if defined(__x86_64__) || defined(__i386__)
+ ExecTestHelper eth;
+ char* const argv[] = {nullptr};
+ const auto invocation = [&] { execvp("cpu-target-features", argv); };
+ eth.Run(invocation, 0, "(^|\n)__AES__=1($|\n)");
+ eth.Run(invocation, 0, "(^|\n)__CRC32__=1($|\n)");
+#else
+ GTEST_SKIP() << "Not targeting an x86 architecture.";
+#endif
+}
+
+TEST(cpu_target_features, has_expected_aarch64_compiler_values) {
+#if defined(__aarch64__)
+ ExecTestHelper eth;
+ char* const argv[] = {nullptr};
+ const auto invocation = [&] { execvp("cpu-target-features", argv); };
+ eth.Run(invocation, 0, "(^|\n)__ARM_FEATURE_AES=1($|\n)");
+ eth.Run(invocation, 0, "(^|\n)__ARM_FEATURE_CRC32=1($|\n)");
+#else
+ GTEST_SKIP() << "Not targeting an aarch64 architecture.";
+#endif
+}
+
+TEST(cpu_target_features, has_expected_arm_compiler_values) {
+#if defined(__arm__)
+ ExecTestHelper eth;
+ char* const argv[] = {nullptr};
+ const auto invocation = [&] { execvp("cpu-target-features", argv); };
+ eth.Run(invocation, 0, "(^|\n)__ARM_FEATURE_AES=1($|\n)");
+ eth.Run(invocation, 0, "(^|\n)__ARM_FEATURE_CRC32=1($|\n)");
+#else
+ GTEST_SKIP() << "Not targeting an arm architecture.";
+#endif
+}
diff --git a/tests/hwasan_test.cpp b/tests/hwasan_test.cpp
index e32534e..ddf84cb 100644
--- a/tests/hwasan_test.cpp
+++ b/tests/hwasan_test.cpp
@@ -36,7 +36,18 @@
using HwasanDeathTest = SilentDeathTest;
-TEST_F(HwasanDeathTest, UseAfterFree) {
+
+#ifdef HWASAN_TEST_STATIC
+#define MAYBE_DlopenAbsolutePath DISABLED_DlopenAbsolutePath
+// TODO(fmayer): figure out why uaf is misclassified as out of bounds for
+// static executables.
+#define MAYBE_UseAfterFree DISABLED_UseAfterFree
+#else
+#define MAYBE_DlopenAbsolutePath DlopenAbsolutePath
+#define MAYBE_UseAfterFree UseAfterFree
+#endif
+
+TEST_F(HwasanDeathTest, MAYBE_UseAfterFree) {
EXPECT_DEATH(
{
void* m = malloc(1);
@@ -59,7 +70,7 @@
}
// Check whether dlopen of /foo/bar.so checks /foo/hwasan/bar.so first.
-TEST(HwasanTest, DlopenAbsolutePath) {
+TEST(HwasanTest, MAYBE_DlopenAbsolutePath) {
std::string path = android::base::GetExecutableDirectory() + "/libtest_simple_hwasan.so";
ASSERT_EQ(0, access(path.c_str(), F_OK)); // Verify test setup.
std::string hwasan_path =
diff --git a/tests/stdatomic_test.cpp b/tests/stdatomic_test.cpp
index f5c6bb1..1c51b11 100644
--- a/tests/stdatomic_test.cpp
+++ b/tests/stdatomic_test.cpp
@@ -37,7 +37,7 @@
}
TEST(stdatomic, init) {
- atomic_int v = ATOMIC_VAR_INIT(123);
+ atomic_int v = 123;
ASSERT_EQ(123, atomic_load(&v));
atomic_init(&v, 456);
@@ -145,35 +145,35 @@
}
TEST(stdatomic, atomic_fetch_add) {
- atomic_int i = ATOMIC_VAR_INIT(123);
+ atomic_int i = 123;
ASSERT_EQ(123, atomic_fetch_add(&i, 1));
ASSERT_EQ(124, atomic_fetch_add_explicit(&i, 1, memory_order_relaxed));
ASSERT_EQ(125, atomic_load(&i));
}
TEST(stdatomic, atomic_fetch_sub) {
- atomic_int i = ATOMIC_VAR_INIT(123);
+ atomic_int i = 123;
ASSERT_EQ(123, atomic_fetch_sub(&i, 1));
ASSERT_EQ(122, atomic_fetch_sub_explicit(&i, 1, memory_order_relaxed));
ASSERT_EQ(121, atomic_load(&i));
}
TEST(stdatomic, atomic_fetch_or) {
- atomic_int i = ATOMIC_VAR_INIT(0x100);
+ atomic_int i = 0x100;
ASSERT_EQ(0x100, atomic_fetch_or(&i, 0x020));
ASSERT_EQ(0x120, atomic_fetch_or_explicit(&i, 0x003, memory_order_relaxed));
ASSERT_EQ(0x123, atomic_load(&i));
}
TEST(stdatomic, atomic_fetch_xor) {
- atomic_int i = ATOMIC_VAR_INIT(0x100);
+ atomic_int i = 0x100;
ASSERT_EQ(0x100, atomic_fetch_xor(&i, 0x120));
ASSERT_EQ(0x020, atomic_fetch_xor_explicit(&i, 0x103, memory_order_relaxed));
ASSERT_EQ(0x123, atomic_load(&i));
}
TEST(stdatomic, atomic_fetch_and) {
- atomic_int i = ATOMIC_VAR_INIT(0x123);
+ atomic_int i = 0x123;
ASSERT_EQ(0x123, atomic_fetch_and(&i, 0x00f));
ASSERT_EQ(0x003, atomic_fetch_and_explicit(&i, 0x2, memory_order_relaxed));
ASSERT_EQ(0x002, atomic_load(&i));
diff --git a/tests/wctype_test.cpp b/tests/wctype_test.cpp
index 38d26ca..f4b7a8f 100644
--- a/tests/wctype_test.cpp
+++ b/tests/wctype_test.cpp
@@ -226,34 +226,64 @@
EXPECT_EQ(0, iswctype_l(WEOF, wctype_l("alnum", l.l), l.l));
}
-TEST(wctype, towctrans) {
+TEST(wctype, wctrans) {
EXPECT_TRUE(wctrans("tolower") != nullptr);
EXPECT_TRUE(wctrans("toupper") != nullptr);
+ errno = 0;
EXPECT_TRUE(wctrans("monkeys") == nullptr);
-}
-
-TEST(wctype, towctrans_l) {
- UtfLocale l;
- EXPECT_TRUE(wctrans_l("tolower", l.l) != nullptr);
- EXPECT_TRUE(wctrans_l("toupper", l.l) != nullptr);
-
- EXPECT_TRUE(wctrans_l("monkeys", l.l) == nullptr);
-}
-
-TEST(wctype, wctrans) {
- EXPECT_EQ(wint_t('a'), towctrans(L'A', wctrans("tolower")));
- EXPECT_EQ(WEOF, towctrans(WEOF, wctrans("tolower")));
-
- EXPECT_EQ(wint_t('A'), towctrans(L'a', wctrans("toupper")));
- EXPECT_EQ(WEOF, towctrans(WEOF, wctrans("toupper")));
+ #if defined(__BIONIC__)
+ // Android/FreeBSD/iOS set errno, but musl/glibc don't.
+ EXPECT_ERRNO(EINVAL);
+ #endif
}
TEST(wctype, wctrans_l) {
UtfLocale l;
- EXPECT_EQ(wint_t('a'), towctrans_l(L'A', wctrans_l("tolower", l.l), l.l));
- EXPECT_EQ(WEOF, towctrans_l(WEOF, wctrans_l("tolower", l.l), l.l));
+ EXPECT_TRUE(wctrans_l("tolower", l.l) != nullptr);
+ EXPECT_TRUE(wctrans_l("toupper", l.l) != nullptr);
- EXPECT_EQ(wint_t('A'), towctrans_l(L'a', wctrans_l("toupper", l.l), l.l));
- EXPECT_EQ(WEOF, towctrans_l(WEOF, wctrans_l("toupper", l.l), l.l));
+ errno = 0;
+ EXPECT_TRUE(wctrans_l("monkeys", l.l) == nullptr);
+ #if defined(__BIONIC__)
+ // Android/FreeBSD/iOS set errno, but musl/glibc don't.
+ EXPECT_ERRNO(EINVAL);
+ #endif
+}
+
+TEST(wctype, towctrans) {
+ wctrans_t lower = wctrans("tolower");
+ EXPECT_EQ(wint_t('a'), towctrans(L'A', lower));
+ EXPECT_EQ(WEOF, towctrans(WEOF, lower));
+
+ wctrans_t upper = wctrans("toupper");
+ EXPECT_EQ(wint_t('A'), towctrans(L'a', upper));
+ EXPECT_EQ(WEOF, towctrans(WEOF, upper));
+
+ wctrans_t invalid = wctrans("monkeys");
+ errno = 0;
+ EXPECT_EQ(wint_t('a'), towctrans(L'a', invalid));
+ #if defined(__BIONIC__)
+ // Android/FreeBSD/iOS set errno, but musl/glibc don't.
+ EXPECT_ERRNO(EINVAL);
+ #endif
+}
+
+TEST(wctype, towctrans_l) {
+ UtfLocale l;
+ wctrans_t lower = wctrans_l("tolower", l.l);
+ EXPECT_EQ(wint_t('a'), towctrans_l(L'A', lower, l.l));
+ EXPECT_EQ(WEOF, towctrans_l(WEOF, lower, l.l));
+
+ wctrans_t upper = wctrans_l("toupper", l.l);
+ EXPECT_EQ(wint_t('A'), towctrans_l(L'a', upper, l.l));
+ EXPECT_EQ(WEOF, towctrans_l(WEOF, upper, l.l));
+
+ wctrans_t invalid = wctrans_l("monkeys", l.l);
+ errno = 0;
+ EXPECT_EQ(wint_t('a'), towctrans_l(L'a', invalid, l.l));
+ #if defined(__BIONIC__)
+ // Android/FreeBSD/iOS set errno, but musl/glibc don't.
+ EXPECT_ERRNO(EINVAL);
+ #endif
}