aeabi.h revision 1.3
1 /* $NetBSD: aeabi.h,v 1.3 2013/01/24 10:14:17 matt Exp $ */ 2 3 /*- 4 * Copyright (c) 2012 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Matt Thomas of 3am Software Foundry. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 #ifndef _ARM_AEABI_H_ 32 #define _ARM_AEABI_H_ 33 34 #ifdef _KERNEL 35 #include <sys/types.h> 36 #else 37 #include <stddef.h> 38 #endif 39 40 #define __value_in_regs /* nothing */ 41 42 /* 43 * Standard double precision floating-point arithmetic helper functions 44 */ 45 double __aeabi_dadd(double, double); // double-precision addition 46 double __aeabi_ddiv(double n, double d); // double-precision division, n / d 47 double __aeabi_dmul(double, double); // double-precision multiplication 48 double __aeabi_drsub(double x, double y); // double-precision reverse subtraction, y - x 49 double __aeabi_dsub(double x, double y); // double-precision subtraction, x - y 50 double __aeabi_dneg(double); // double-precision negation (obsolete, to be removed in r2.09) 51 52 /* 53 * Double precision floating-point comparison helper functions 54 */ 55 void __aeabi_cdcmpeq(double, double); // non-excepting equality comparison [1], result in PSR ZC flags 56 void __aeabi_cdcmple(double, double); // 3-way (<, =, >) compare [1], result in PSR ZC flags 57 void __aeabi_cdrcmple(double, double); // reversed 3-way (<, =, >) compare [1], result in PSR ZC flags 58 int __aeabi_dcmpeq(double, double); // result (1, 0) denotes (=, <>) [2], use for C == and != 59 int __aeabi_dcmplt(double, double); // result (1, 0) denotes (<, >=) [2], use for C < 60 int __aeabi_dcmple(double, double); // result (1, 0) denotes (<=, >) [2], use for C <= 61 int __aeabi_dcmpge(double, double); // result (1, 0) denotes (>=, <) [2], use for C >= 62 int __aeabi_dcmpgt(double, double); // result (1, 0) denotes (>, <=) [2], use for C > 63 int __aeabi_dcmpun(double, double); // result (1, 0) denotes (?, <=>) [2], use for C99 isunordered() 64 65 /* 66 * Standard single precision floating-point arithmetic helper functions 67 */ 68 float __aeabi_fadd(float, float); // single-precision addition 69 float __aeabi_fdiv(float n, float d); // single-precision division, n / d 70 float __aeabi_fmul(float, float); // single-precision multiplication 71 float __aeabi_frsub(float x, float y); // single-precision reverse subtraction, y - x 72 float __aeabi_fsub(float x, float y); // single-precision subtraction, x - y 73 float __aeabi_fneg(float); // single-precision negation (obsolete, to be removed in r2.09) 74 75 /* 76 * Standard single precision floating-point comparison helper functions 77 */ 78 void __aeabi_cfcmpeq(float, float); // non-excepting equality comparison [1], result in PSR ZC flags 79 void __aeabi_cfcmple(float, float); // 3-way (<, =, ?>) compare [1], result in PSR ZC flags 80 void __aeabi_cfrcmple(float, float); // reversed 3-way (<, =, ?>) compare [1], result in PSR ZC flags 81 int __aeabi_fcmpeq(float, float); // result (1, 0) denotes (=, <>) [2], use for C == and != 82 int __aeabi_fcmplt(float, float); // result (1, 0) denotes (<, >=) [2], use for C < 83 int __aeabi_fcmple(float, float); // result (1, 0) denotes (<=, >) [2], use for C <= 84 int __aeabi_fcmpge(float, float); // result (1, 0) denotes (>=, <) [2], use for C >= 85 int __aeabi_fcmpgt(float, float); // result (1, 0) denotes (>, <=) [2], use for C > 86 int __aeabi_fcmpun(float, float); // result (1, 0) denotes (?, <=>) [2], use for C99 isunordered() 87 88 /* 89 * Standard conversions between floating types 90 */ 91 float __aeabi_d2f(double); // double to float (single precision) conversion 92 double __aeabi_f2d(float); // float (single precision) to double conversion 93 float __aeabi_h2f(short hf); // IEEE 754 binary16 storage format (VFP half precision) to binary32 (float) conversion [4, 5] 94 short __aeabi_f2h(float f); // IEEE 754 binary32 (float) to binary16 storage format (VFP half precision) conversion [4, 6] 95 float __aeabi_h2f_alt(short hf); // __aeabi_h2f_alt converts from VFP alternative format [7]. 96 short __aeabi_f2h_alt(float f); // __aeabi_f2h_alt converts to VFP alternative format [8]. 97 98 /* 99 * Standard floating-point to integer conversions 100 */ 101 int __aeabi_d2iz(double); // double to integer C-style conversion [3] 102 unsigned __aeabi_d2uiz(double); // double to unsigned C-style conversion [3] 103 long long __aeabi_d2lz(double); // double to long long C-style conversion [3] 104 unsigned long long __aeabi_d2ulz(double); // double to unsigned long long C-style conversion [3] 105 int __aeabi_f2iz(float); // float (single precision) to integer C-style conversion [3] 106 unsigned __aeabi_f2uiz(float); // float (single precision) to unsigned C-style conversion [3] 107 long long __aeabi_f2lz(float); // float (single precision) to long long C-style conversion [3] 108 unsigned long long __aeabi_f2ulz(float); // float to unsigned long long C-style conversion [3] 109 110 /* 111 * Standard integer to floating-point conversions 112 */ 113 double __aeabi_i2d(int); // integer to double conversion 114 double __aeabi_ui2d(unsigned); // unsigned to double conversion 115 double __aeabi_l2d(long long); // long long to double conversion 116 double __aeabi_ul2d(unsigned long long); // unsigned long long to double conversion 117 float __aeabi_i2f(int); // integer to float (single precision) conversion 118 float __aeabi_ui2f(unsigned); // unsigned to float (single precision) conversion 119 float __aeabi_l2f(long long); // long long to float (single precision) conversion 120 float __aeabi_ul2f(unsigned long long); // unsigned long long to float (single precision) conversion 121 122 /* 123 * Long long functions 124 */ 125 long long __aeabi_lmul(long long, long long); // multiplication 126 127 /* 128 * A pair of (unsigned) long longs is returned in {{r0, r1}, {r2, r3}}, 129 * the quotient in {r0, r1}, and the remainder in {r2, r3}. 130 */ 131 typedef struct { long long quot; long long rem; } lldiv_t; 132 __value_in_regs lldiv_t __aeabi_ldivmod(long long n, long long d); // signed long long division and remainder, {q, r} = n / d [2] 133 134 typedef struct { unsigned long long quot; unsigned long long rem; } ulldiv_t; 135 __value_in_regs ulldiv_t __aeabi_uldivmod(unsigned long long n, unsigned long long d); // unsigned signed ll division, remainder, {q, r} = n / d [2] 136 137 /* 138 * Because of 2's complement number representation, these functions work 139 * identically with long long replaced uniformly by unsigned long long. 140 * Each returns its result in {r0, r1}, as specified by the [AAPCS]. 141 */ 142 long long __aeabi_llsl(long long, int); // logical shift left [1] 143 long long __aeabi_llsr(long long, int); // logical shift right [1] 144 long long __aeabi_lasr(long long, int); // arithmetic shift right [1] 145 146 /* 147 * The comparison functions return negative, zero, or a positive integer 148 * according to whether the comparison result is <, ==, or >, respectively 149 * (like strcmp). 150 */ 151 int __aeabi_lcmp(long long, long long); // signed long long comparison 152 int __aeabi_ulcmp(unsigned long long, unsigned long long); // unsigned long long comparison 153 154 int __aeabi_idiv(int numerator, int denominator); 155 unsigned __aeabi_uidiv(unsigned numerator, unsigned denominator); 156 typedef struct { int quot, rem; } idiv_return; 157 typedef struct { unsigned int quot, rem; } uidiv_return; 158 __value_in_regs idiv_return __aeabi_idivmod(int, int); 159 __value_in_regs uidiv_return __aeabi_uidivmod(unsigned int, unsigned int); 160 161 /* 162 * Division by zero 163 * 164 * If an integer or long long division helper function is called upon to 165 * divide by 0, it should return as quotient the value returned by a call 166 * to __aeabi_idiv0 or __aeabi_ldiv0, respectively. A *divmod helper should 167 * return as remainder either 0 or the original numerator. 168 */ 169 int __aeabi_idiv0(int); 170 long long __aeabi_ldiv0(long long); 171 172 /* 173 * These functions read and write 4-byte and 8-byte values at arbitrarily 174 * aligned addresses. Write functions return the value written, 175 * read functions the value read. 176 */ 177 int __aeabi_uread4(void *); 178 int __aeabi_uwrite4(int, void *); 179 long long __aeabi_uread8(void *); 180 long long __aeabi_uwrite8(long long, void *); 181 182 /* 183 * Memory copying, clearing, and setting 184 */ 185 void __aeabi_memcpy8(void *, const void *, size_t); 186 void __aeabi_memcpy4(void *, const void *, size_t); 187 void __aeabi_memcpy(void *, const void *, size_t); 188 void __aeabi_memmove8(void *, const void *, size_t); 189 void __aeabi_memmove4(void *, const void *, size_t); 190 void __aeabi_memmove(void *, const void *, size_t); 191 192 /* 193 * Memory clearing and setting 194 */ 195 void __aeabi_memset8(void *, size_t, int); 196 void __aeabi_memset4(void *, size_t, int); 197 void __aeabi_memset(void *, size_t, int); 198 void __aeabi_memclr8(void *, size_t); 199 void __aeabi_memclr4(void *, size_t); 200 void __aeabi_memclr(void *, size_t); 201 202 void *__aeabi_read_tp(void); // return the value of $tp 203 204 #endif /* _ARM_AEABI_H_ */ 205
Indexes created Tue Sep 23 02:09:52 GMT 2025