1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29#if defined(__clang__) 30// clang interprets -fno-builtin more loosely than you might expect, 31// and thinks it's okay to still substitute builtins as long as they're 32// named __aeabi_* rather than __builtin_*, which causes infinite 33// recursion if we have the fortified memcpy visible in this file. 34#undef _FORTIFY_SOURCE 35#endif 36 37#include <stddef.h> 38#include <string.h> 39 40extern int __cxa_atexit(void (*)(void*), void*, void*); 41 42// All of these are weak symbols to avoid multiple definition errors when 43// linking with libstdc++-v3 or compiler-rt. 44 45/* The "C++ ABI for ARM" document states that static C++ constructors, 46 * which are called from the .init_array, should manually call 47 * __aeabi_atexit() to register static destructors explicitly. 48 * 49 * Note that 'dso_handle' is the address of a magic linker-generate 50 * variable from the shared object that contains the constructor/destructor 51 */ 52 53int __attribute__((weak)) 54__aeabi_atexit_impl(void *object, void (*destructor) (void *), void *dso_handle) { 55 return __cxa_atexit(destructor, object, dso_handle); 56} 57 58int __attribute__((weak)) 59__aeabi_atexit_impl2(void *object, void (*destructor) (void *), void *dso_handle) { 60 return __cxa_atexit(destructor, object, dso_handle); 61} 62 63 64void __attribute__((weak)) __aeabi_memcpy8_impl(void *dest, const void *src, size_t n) { 65 memcpy(dest, src, n); 66} 67 68void __attribute__((weak)) __aeabi_memcpy4_impl(void *dest, const void *src, size_t n) { 69 memcpy(dest, src, n); 70} 71 72void __attribute__((weak)) __aeabi_memcpy_impl(void *dest, const void *src, size_t n) { 73 memcpy(dest, src, n); 74} 75 76void __attribute__((weak)) __aeabi_memcpy8_impl2(void *dest, const void *src, size_t n) { 77 memcpy(dest, src, n); 78} 79 80void __attribute__((weak)) __aeabi_memcpy4_impl2(void *dest, const void *src, size_t n) { 81 memcpy(dest, src, n); 82} 83 84void __attribute__((weak)) __aeabi_memcpy_impl2(void *dest, const void *src, size_t n) { 85 memcpy(dest, src, n); 86} 87 88 89void __attribute__((weak)) __aeabi_memmove8_impl(void *dest, const void *src, size_t n) { 90 memmove(dest, src, n); 91} 92 93void __attribute__((weak)) __aeabi_memmove4_impl(void *dest, const void *src, size_t n) { 94 memmove(dest, src, n); 95} 96 97void __attribute__((weak)) __aeabi_memmove_impl(void *dest, const void *src, size_t n) { 98 memmove(dest, src, n); 99} 100 101void __attribute__((weak)) __aeabi_memmove8_impl2(void *dest, const void *src, size_t n) { 102 memmove(dest, src, n); 103} 104 105void __attribute__((weak)) __aeabi_memmove4_impl2(void *dest, const void *src, size_t n) { 106 memmove(dest, src, n); 107} 108 109void __attribute__((weak)) __aeabi_memmove_impl2(void *dest, const void *src, size_t n) { 110 memmove(dest, src, n); 111} 112 113/* 114 * __aeabi_memset has the order of its second and third arguments reversed. 115 * This allows __aeabi_memclr to tail-call __aeabi_memset 116 */ 117 118void __attribute__((weak)) __aeabi_memset8_impl(void *dest, size_t n, int c) { 119 memset(dest, c, n); 120} 121 122void __attribute__((weak)) __aeabi_memset4_impl(void *dest, size_t n, int c) { 123 memset(dest, c, n); 124} 125 126void __attribute__((weak)) __aeabi_memset_impl(void *dest, size_t n, int c) { 127 memset(dest, c, n); 128} 129 130void __attribute__((weak)) __aeabi_memset8_impl2(void *dest, size_t n, int c) { 131 memset(dest, c, n); 132} 133 134void __attribute__((weak)) __aeabi_memset4_impl2(void *dest, size_t n, int c) { 135 memset(dest, c, n); 136} 137 138void __attribute__((weak)) __aeabi_memset_impl2(void *dest, size_t n, int c) { 139 memset(dest, c, n); 140} 141 142 143void __attribute__((weak)) __aeabi_memclr8_impl(void *dest, size_t n) { 144 __aeabi_memset8_impl(dest, n, 0); 145} 146 147void __attribute__((weak)) __aeabi_memclr4_impl(void *dest, size_t n) { 148 __aeabi_memset4_impl(dest, n, 0); 149} 150 151void __attribute__((weak)) __aeabi_memclr_impl(void *dest, size_t n) { 152 __aeabi_memset_impl(dest, n, 0); 153} 154 155void __attribute__((weak)) __aeabi_memclr8_impl2(void *dest, size_t n) { 156 __aeabi_memset8_impl(dest, n, 0); 157} 158 159void __attribute__((weak)) __aeabi_memclr4_impl2(void *dest, size_t n) { 160 __aeabi_memset4_impl(dest, n, 0); 161} 162 163void __attribute__((weak)) __aeabi_memclr_impl2(void *dest, size_t n) { 164 __aeabi_memset_impl(dest, n, 0); 165} 166 167#define __AEABI_SYMVERS(fn_name) \ 168__asm__(".symver " #fn_name "_impl, " #fn_name "@@LIBC_N"); \ 169__asm__(".symver " #fn_name "_impl2, " #fn_name "@LIBC_PRIVATE") 170 171__AEABI_SYMVERS(__aeabi_atexit); 172__AEABI_SYMVERS(__aeabi_memcpy8); 173__AEABI_SYMVERS(__aeabi_memcpy4); 174__AEABI_SYMVERS(__aeabi_memcpy); 175__AEABI_SYMVERS(__aeabi_memmove8); 176__AEABI_SYMVERS(__aeabi_memmove4); 177__AEABI_SYMVERS(__aeabi_memmove); 178__AEABI_SYMVERS(__aeabi_memset8); 179__AEABI_SYMVERS(__aeabi_memset4); 180__AEABI_SYMVERS(__aeabi_memset); 181__AEABI_SYMVERS(__aeabi_memclr8); 182__AEABI_SYMVERS(__aeabi_memclr4); 183__AEABI_SYMVERS(__aeabi_memclr); 184 185#undef __AEABI_SYMVERS 186