1/* $NetBSD: aeabi.h,v 1.6 2021/10/06 05:33:15 skrll 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#if defined(_KERNEL) || defined(_STANDALONE)
35#include <sys/types.h>
36#else
37#include <stddef.h>
38#endif
39
40#define __value_in_regs /* nothing */
41#define __aapcs __attribute__((__pcs__("aapcs")))
42
43/*
44 * Standard double precision floating-point arithmetic helper functions
45 */
46double __aeabi_dadd(double, double) __aapcs; // double-precision addition
47double __aeabi_ddiv(double n, double d) __aapcs; // double-precision division, n / d
48double __aeabi_dmul(double, double) __aapcs; // double-precision multiplication
49double __aeabi_drsub(double x, double y) __aapcs; // double-precision reverse subtraction, y - x
50double __aeabi_dsub(double x, double y) __aapcs; // double-precision subtraction, x - y
51double __aeabi_dneg(double) __aapcs; // double-precision negation (obsolete, to be removed in r2.09)
52
53/*
54 * Double precision floating-point comparison helper functions
55 */
56void __aeabi_cdcmpeq(double, double) __aapcs; // non-excepting equality comparison [1], result in PSR ZC flags
57void __aeabi_cdcmple(double, double) __aapcs; // 3-way (<, =, >) compare [1], result in PSR ZC flags
58void __aeabi_cdrcmple(double, double) __aapcs; // reversed 3-way (<, =, >) compare [1], result in PSR ZC flags
59int __aeabi_dcmpeq(double, double) __aapcs; // result (1, 0) denotes (=, <>) [2], use for C == and !=
60int __aeabi_dcmplt(double, double) __aapcs; // result (1, 0) denotes (<, >=) [2], use for C <
61int __aeabi_dcmple(double, double) __aapcs; // result (1, 0) denotes (<=, >) [2], use for C <=
62int __aeabi_dcmpge(double, double) __aapcs; // result (1, 0) denotes (>=, <) [2], use for C >=
63int __aeabi_dcmpgt(double, double) __aapcs; // result (1, 0) denotes (>, <=) [2], use for C >
64int __aeabi_dcmpun(double, double) __aapcs; // result (1, 0) denotes (?, <=>) [2], use for C99 isunordered()
65
66/*
67 * Standard single precision floating-point arithmetic helper functions
68 */
69float __aeabi_fadd(float, float) __aapcs; // single-precision addition
70float __aeabi_fdiv(float n, float d) __aapcs; // single-precision division, n / d
71float __aeabi_fmul(float, float) __aapcs; // single-precision multiplication
72float __aeabi_frsub(float x, float y) __aapcs; // single-precision reverse subtraction, y - x
73float __aeabi_fsub(float x, float y) __aapcs; // single-precision subtraction, x - y
74float __aeabi_fneg(float) __aapcs; // single-precision negation (obsolete, to be removed in r2.09)
75
76/*
77 * Standard single precision floating-point comparison helper functions
78 */
79void __aeabi_cfcmpeq(float, float) __aapcs; // non-excepting equality comparison [1], result in PSR ZC flags
80void __aeabi_cfcmple(float, float) __aapcs; // 3-way (<, =, ?>) compare [1], result in PSR ZC flags
81void __aeabi_cfrcmple(float, float) __aapcs; // reversed 3-way (<, =, ?>) compare [1], result in PSR ZC flags
82int __aeabi_fcmpeq(float, float) __aapcs; // result (1, 0) denotes (=, <>) [2], use for C == and !=
83int __aeabi_fcmplt(float, float) __aapcs; // result (1, 0) denotes (<, >=) [2], use for C <
84int __aeabi_fcmple(float, float) __aapcs; // result (1, 0) denotes (<=, >) [2], use for C <=
85int __aeabi_fcmpge(float, float) __aapcs; // result (1, 0) denotes (>=, <) [2], use for C >=
86int __aeabi_fcmpgt(float, float) __aapcs; // result (1, 0) denotes (>, <=) [2], use for C >
87int __aeabi_fcmpun(float, float) __aapcs; // result (1, 0) denotes (?, <=>) [2], use for C99 isunordered()
88
89/*
90 * Standard conversions between floating types
91 */
92float __aeabi_d2f(double) __aapcs; // double to float (single precision) conversion
93double __aeabi_f2d(float) __aapcs; // float (single precision) to double conversion
94float __aeabi_h2f(short hf) __aapcs; // IEEE 754 binary16 storage format (VFP half precision) to binary32 (float) conversion [4, 5]
95short __aeabi_f2h(float f) __aapcs; // IEEE 754 binary32 (float) to binary16 storage format (VFP half precision) conversion [4, 6]
96float __aeabi_h2f_alt(short hf) __aapcs; // __aeabi_h2f_alt converts from VFP alternative format [7].
97short __aeabi_f2h_alt(float f) __aapcs; // __aeabi_f2h_alt converts to VFP alternative format [8].
98
99/*
100 * Standard floating-point to integer conversions
101 */
102int __aeabi_d2iz(double) __aapcs; // double to integer C-style conversion [3]
103unsigned __aeabi_d2uiz(double) __aapcs; // double to unsigned C-style conversion [3]
104long long __aeabi_d2lz(double) __aapcs; // double to long long C-style conversion [3]
105unsigned long long __aeabi_d2ulz(double) __aapcs; // double to unsigned long long C-style conversion [3]
106int __aeabi_f2iz(float) __aapcs; // float (single precision) to integer C-style conversion [3]
107unsigned __aeabi_f2uiz(float) __aapcs; // float (single precision) to unsigned C-style conversion [3]
108long long __aeabi_f2lz(float) __aapcs; // float (single precision) to long long C-style conversion [3]
109unsigned long long __aeabi_f2ulz(float) __aapcs; // float to unsigned long long C-style conversion [3]
110
111/*
112 * Standard integer to floating-point conversions
113 */
114double __aeabi_i2d(int) __aapcs; // integer to double conversion
115double __aeabi_ui2d(unsigned) __aapcs; // unsigned to double conversion
116double __aeabi_l2d(long long) __aapcs; // long long to double conversion
117double __aeabi_ul2d(unsigned long long) __aapcs; // unsigned long long to double conversion
118float __aeabi_i2f(int) __aapcs; // integer to float (single precision) conversion
119float __aeabi_ui2f(unsigned) __aapcs; // unsigned to float (single precision) conversion
120float __aeabi_l2f(long long) __aapcs; // long long to float (single precision) conversion
121float __aeabi_ul2f(unsigned long long) __aapcs; // unsigned long long to float (single precision) conversion
122
123/*
124 * Long long functions
125 */
126long long __aeabi_lmul(long long, long long); // multiplication
127
128/*
129 * A pair of (unsigned) long longs is returned in {{r0, r1}, {r2, r3}},
130 * the quotient in {r0, r1}, and the remainder in {r2, r3}.
131 */
132typedef struct { long long quot; long long rem; } lldiv_t;
133__value_in_regs lldiv_t __aeabi_ldivmod(long long n, long long d); // signed long long division and remainder, {q, r} = n / d [2]
134
135typedef struct { unsigned long long quot; unsigned long long rem; } ulldiv_t;
136__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]
137
138/*
139 * Because of 2's complement number representation, these functions work
140 * identically with long long replaced uniformly by unsigned long long.
141 * Each returns its result in {r0, r1}, as specified by the [AAPCS].
142 */
143long long __aeabi_llsl(long long, int); // logical shift left [1]
144long long __aeabi_llsr(long long, int); // logical shift right [1]
145long long __aeabi_lasr(long long, int); // arithmetic shift right [1]
146
147/*
148 * The comparison functions return negative, zero, or a positive integer
149 * according to whether the comparison result is <, ==, or >, respectively
150 * (like strcmp).
151 */
152int __aeabi_lcmp(long long, long long); // signed long long comparison
153int __aeabi_ulcmp(unsigned long long, unsigned long long); // unsigned long long comparison
154
155int __aeabi_idiv(int numerator, int denominator);
156unsigned __aeabi_uidiv(unsigned numerator, unsigned denominator);
157typedef struct { int quot, rem; } idiv_return;
158typedef struct { unsigned int quot, rem; } uidiv_return;
159__value_in_regs idiv_return __aeabi_idivmod(int, int);
160__value_in_regs uidiv_return __aeabi_uidivmod(unsigned int, unsigned int);
161
162/*
163 * Division by zero
164 *
165 * If an integer or long long division helper function is called upon to
166 * divide by 0, it should return as quotient the value returned by a call
167 * to __aeabi_idiv0 or __aeabi_ldiv0, respectively. A *divmod helper should
168 * return as remainder either 0 or the original numerator.
169 */
170int __aeabi_idiv0(int);
171long long __aeabi_ldiv0(long long);
172
173/*
174 * These functions read and write 4-byte and 8-byte values at arbitrarily
175 * aligned addresses. Write functions return the value written,
176 * read functions the value read.
177 */
178int __aeabi_uread4(void *);
179int __aeabi_uwrite4(int, void *);
180long long __aeabi_uread8(void *);
181long long __aeabi_uwrite8(long long, void *);
182
183/*
184 * Memory copying, clearing, and setting
185 */
186void __aeabi_memcpy8(void *, const void *, size_t);
187void __aeabi_memcpy4(void *, const void *, size_t);
188void __aeabi_memcpy(void *, const void *, size_t);
189void __aeabi_memmove8(void *, const void *, size_t);
190void __aeabi_memmove4(void *, const void *, size_t);
191void __aeabi_memmove(void *, const void *, size_t);
192
193/*
194 * Memory clearing and setting
195 */
196void __aeabi_memset8(void *, size_t, int);
197void __aeabi_memset4(void *, size_t, int);
198void __aeabi_memset(void *, size_t, int);
199void __aeabi_memclr8(void *, size_t);
200void __aeabi_memclr4(void *, size_t);
201void __aeabi_memclr(void *, size_t);
202
203void *__aeabi_read_tp(void); // return the value of $tp
204
205#undef __aapcs
206
207#endif /* _ARM_AEABI_H_ */