libc/test/UnitTest/HermeticTestUtils.cpp

   1 //===-- Implementation of libc death test executors -----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "src/__support/common.h"
  10 #include "src/__support/macros/config.h"
  11 #include <stddef.h>
  12 #include <stdint.h>
  13
  14 #ifdef LIBC_TARGET_ARCH_IS_AARCH64
  15 #include "src/sys/auxv/getauxval.h"
  16 #endif
  17
  18 namespace LIBC_NAMESPACE_DECL {
  19
  20 int bcmp(const void *lhs, const void *rhs, size_t count);
  21 void bzero(void *ptr, size_t count);
  22 int memcmp(const void *lhs, const void *rhs, size_t count);
  23 void *memcpy(void *__restrict, const void *__restrict, size_t);
  24 void *memmove(void *dst, const void *src, size_t count);
  25 void *memset(void *ptr, int value, size_t count);
  26 int atexit(void (*func)(void));
  27
  28 // TODO: It seems that some old test frameworks does not use
  29 // add_libc_hermetic_test properly. Such that they won't get correct linkage
  30 // against the object containing this function. We create a dummy function that
  31 // always returns 0 to indicate a failure.
  32 [[gnu::weak]] unsigned long getauxval(unsigned long id) { return 0; }
  33
  34 } // namespace LIBC_NAMESPACE_DECL
  35
  36 namespace {
  37
  38 // Integration tests cannot use the SCUDO standalone allocator as SCUDO pulls
  39 // various other parts of the libc. Since SCUDO development does not use
  40 // LLVM libc build rules, it is very hard to keep track or pull all that SCUDO
  41 // requires. Hence, as a work around for this problem, we use a simple allocator
  42 // which just hands out continuous blocks from a statically allocated chunk of
  43 // memory.
  44 static constexpr uint64_t MEMORY_SIZE = 65336;
  45 static uint8_t memory[MEMORY_SIZE];
  46 static uint8_t *ptr = memory;
  47
  48 } // anonymous namespace
  49
  50 extern "C" {
  51
  52 // Hermetic tests rely on the following memory functions. This is because the
  53 // compiler code generation can emit calls to them. We want to map the external
  54 // entrypoint to the internal implementation of the function used for testing.
  55 // This is done manually as not all targets support aliases.
  56
  57 int bcmp(const void *lhs, const void *rhs, size_t count) {
  58   return LIBC_NAMESPACE::bcmp(lhs, rhs, count);
  59 }
  60 void bzero(void *ptr, size_t count) { LIBC_NAMESPACE::bzero(ptr, count); }
  61 int memcmp(const void *lhs, const void *rhs, size_t count) {
  62   return LIBC_NAMESPACE::memcmp(lhs, rhs, count);
  63 }
  64 void *memcpy(void *__restrict dst, const void *__restrict src, size_t count) {
  65   return LIBC_NAMESPACE::memcpy(dst, src, count);
  66 }
  67 void *memmove(void *dst, const void *src, size_t count) {
  68   return LIBC_NAMESPACE::memmove(dst, src, count);
  69 }
  70 void *memset(void *ptr, int value, size_t count) {
  71   return LIBC_NAMESPACE::memset(ptr, value, count);
  72 }
  73
  74 // This is needed if the test was compiled with '-fno-use-cxa-atexit'.
  75 int atexit(void (*func)(void)) { return LIBC_NAMESPACE::atexit(func); }
  76
  77 constexpr uint64_t ALIGNMENT = alignof(uintptr_t);
  78
  79 void *malloc(size_t s) {
  80   // Keep the bump pointer aligned on an eight byte boundary.
  81   s = ((s + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT;
  82   void *mem = ptr;
  83   ptr += s;
  84   return static_cast<uint64_t>(ptr - memory) >= MEMORY_SIZE ? nullptr : mem;
  85 }
  86
  87 void free(void *) {}
  88
  89 void *realloc(void *mem, size_t s) {
  90   if (mem == nullptr)
  91     return malloc(s);
  92   uint8_t *newmem = reinterpret_cast<uint8_t *>(malloc(s));
  93   if (newmem == nullptr)
  94     return nullptr;
  95   uint8_t *oldmem = reinterpret_cast<uint8_t *>(mem);
  96   // We use a simple for loop to copy the data over.
  97   // If |s| is less the previous alloc size, the copy works as expected.
  98   // If |s| is greater than the previous alloc size, then garbage is copied
  99   // over to the additional part in the new memory block.
 100   for (size_t i = 0; i < s; ++i)
 101     newmem[i] = oldmem[i];
 102   return newmem;
 103 }
 104
 105 // The unit test framework uses pure virtual functions. Since hermetic tests
 106 // cannot depend C++ runtime libraries, implement dummy functions to support
 107 // the virtual function runtime.
 108 void __cxa_pure_virtual() {
 109   // A pure virtual being called is an error so we just trap.
 110   __builtin_trap();
 111 }
 112
 113 // Hermetic tests are linked with -nostdlib. BFD linker expects
 114 // __dso_handle when -nostdlib is used.
 115 void *__dso_handle = nullptr;
 116
 117 #ifdef LIBC_TARGET_ARCH_IS_AARCH64
 118 // Due to historical reasons, libgcc on aarch64 may expect __getauxval to be
 119 // defined. See also https://gcc.gnu.org/pipermail/gcc-cvs/2020-June/300635.html
 120 unsigned long __getauxval(unsigned long id) {
 121   return LIBC_NAMESPACE::getauxval(id);
 122 }
 123 #endif
 124
 125 } // extern "C"
 126
 127 void *operator new(size_t size, void *ptr) { return ptr; }
 128
 129 void *operator new(size_t size) { return malloc(size); }
 130
 131 void *operator new[](size_t size) { return malloc(size); }
 132
 133 void operator delete(void *) {
 134   // The libc runtime should not use the global delete operator. Hence,
 135   // we just trap here to catch any such accidental usages.
 136   __builtin_trap();
 137 }
 138
 139 void operator delete(void *ptr, size_t size) { __builtin_trap(); }
 140
 141 // Defining members in the std namespace is not preferred. But, we do it here
 142 // so that we can use it to define the operator new which takes std::align_val_t
 143 // argument.
 144 namespace std {
 145 enum class align_val_t : size_t {};
 146 } // namespace std
 147
 148 void operator delete(void *mem, std::align_val_t) noexcept { __builtin_trap(); }
 149
 150 void operator delete(void *mem, unsigned int, std::align_val_t) noexcept {
 151   __builtin_trap();
 152 }