#define ATOMIC_EXCHANGE_USES_CAS 0
/* Compare and exchange.
- For all "bool" routines, we return FALSE if exchange succesful. */
+ For all "bool" routines, we return FALSE if exchange successful. */
# define __arch_compare_and_exchange_bool_8_int(mem, newval, oldval, model) \
({ \
sub count, dstend, dst
/*
- * Adjust count and bias for loop. By substracting extra 1 from count,
+ * Adjust count and bias for loop. By subtracting extra 1 from count,
* it is easy to use tbz instruction to check whether loop tailing
- * count is less than 33 bytes, so as to bypass 2 unneccesary stps.
+ * count is less than 33 bytes, so as to bypass 2 unnecessary stps.
*/
sub count, count, 64+16+1
sub count, dstend, dst
/*
- * Adjust count and bias for loop. By substracting extra 1 from count,
+ * Adjust count and bias for loop. By subtracting extra 1 from count,
* it is easy to use tbz instruction to check whether loop tailing
- * count is less than 33 bytes, so as to bypass 2 unneccesary stps.
+ * count is less than 33 bytes, so as to bypass 2 unnecessary stps.
*/
sub count, count, 128+64+64+1
add dst, dst, 128
cmpbge zero, t0, t1 # E : bits set iff byte == zero
cmpbge zero, t2, t3 # E : bits set iff byte == c
- beq t1, $loop # U : if we havnt seen a null, loop
+ beq t1, $loop # U : if we haven't seen a null, loop
nop
/* Mask out character matches after terminator */
: "memory"); \
})
-/* For all "bool" routines, we return FALSE if exchange succesful. */
+/* For all "bool" routines, we return FALSE if exchange successful. */
#define __arch_compare_and_exchange_bool_8_int(mem, new, old, mb1, mb2) \
({ unsigned long __prev; int __cmp; \
convert back to integer.
When the dividend is outside the range for which we can compute exact
- results, we use the fp quotent as an estimate from which we begin refining
+ results, we use the fp quotient as an estimate from which we begin refining
an exact integral value. This reduces the number of iterations in the
shift-and-subtract loop significantly.
convert back to integer.
When the dividend is outside the range for which we can compute exact
- results, we use the fp quotent as an estimate from which we begin refining
+ results, we use the fp quotient as an estimate from which we begin refining
an exact integral value. This reduces the number of iterations in the
shift-and-subtract loop significantly.
FE_ALL_EXCEPT
};
-/* Alpha chips support all four defined rouding modes.
+/* Alpha chips support all four defined rounding modes.
Note that code must be compiled to use dynamic rounding (/d) instructions
to see these changes. For gcc this is -mfp-rounding-mode=d; for DEC cc
/* Install new environment. */
__fesetenv (envp);
- /* Raise the saved exception. Incidently for us the implementation
+ /* Raise the saved exception. Incidentally for us the implementation
defined format of the values in objects of type fexcept_t is the
same as the ones specified using the FE_* constants. */
__feraiseexcept (tmp & SWCR_STATUS_MASK);
#include "local-soft-fp.h"
/* Should never actually be used, since we've more bits of precision
- than the incomming long, but needed for linkage. */
+ than the incoming long, but needed for linkage. */
#undef FP_ROUNDMODE
#define FP_ROUNDMODE FP_RND_ZERO
#include "local-soft-fp.h"
/* Should never actually be used, since we've more bits of precision
- than the incomming long, but needed for linkage. */
+ than the incoming long, but needed for linkage. */
#undef FP_ROUNDMODE
#define FP_ROUNDMODE FP_RND_ZERO
convert back to integer.
When the dividend is outside the range for which we can compute exact
- results, we use the fp quotent as an estimate from which we begin refining
+ results, we use the fp quotient as an estimate from which we begin refining
an exact integral value. This reduces the number of iterations in the
shift-and-subtract loop significantly.
convert back to integer.
When the dividend is outside the range for which we can compute exact
- results, we use the fp quotent as an estimate from which we begin refining
+ results, we use the fp quotient as an estimate from which we begin refining
an exact integral value. This reduces the number of iterations in the
shift-and-subtract loop significantly.
or t2, t8, t2 # e0 : clear the bits between the last
or t3, t10, t3 # .. e1 : written byte and the last byte in
andnot t3, t2, t3 # e0 : COUNT
- cmovne t4, t5, v0 # .. e1 : if last written wasnt null, inc v0
+ cmovne t4, t5, v0 # .. e1 : if last written wasn't null, inc v0
zap t0, t3, t0 # e0 :
stq_u t0, 0(a0) # e1 :
ret # .. e1 :
xor t0, a1, t2 # e0 :
cmpbge zero, t0, t1 # .. e1 : bits set iff byte == zero
cmpbge zero, t2, t3 # e0 : bits set iff byte == c
- beq t1, $loop # .. e1 : if we havnt seen a null, loop
+ beq t1, $loop # .. e1 : if we haven't seen a null, loop
/* Mask out character matches after terminator */
$eos:
-/* Install given floating-point environment (doesnot raise exceptions).
+/* Install given floating-point environment (does not raise exceptions).
Copyright (C) 2020-2023 Free Software Foundation, Inc.
This file is part of the GNU C Library.
cmpne r2, r1 @ ... or C
bne 1b
- @ Disambiguate the exit possibilites above
+ @ Disambiguate the exit possibilities above
cmp r2, r1 @ Found C
it eq
bxeq lr
@ Loop until we find ...
1: ldrb r2, [r0, #1]!
- subs r3, r3, #1 @ ... the aligment point
+ subs r3, r3, #1 @ ... the alignment point
it ne
cmpne r2, r1 @ ... or the character
it ne
cmpne r2, #0 @ ... or EOS
bne 1b
- @ Disambiguate the exit possibilites above
+ @ Disambiguate the exit possibilities above
cmp r2, r1 @ Found the character
it ne
cmpne r2, #0 @ Found EOS
cmpne r2, #0 @ ... or EOS
bne 1b
- @ Disambiguate the exit possibilites above
+ @ Disambiguate the exit possibilities above
cmp r2, #0 @ Found EOS
beq .Lreturn
pld [r0, #64]
pld [r1, #64]
- @ For longer strings, we actaully need a stack frame.
+ @ For longer strings, we actually need a stack frame.
push { r4, r5, r6, r7 }
cfi_adjust_cfa_offset (16)
cfi_rel_offset (r4, 0)
@ Loop until we find ...
1: ldrb r2, [r0, #1]!
- subs r3, r3, #1 @ ... the aligment point
+ subs r3, r3, #1 @ ... the alignment point
it ne
cmpne r2, #0 @ ... or EOS
bne 1b
- @ Disambiguate the exit possibilites above
+ @ Disambiguate the exit possibilities above
cmp r2, #0 @ Found EOS
beq 99f
add r0, r0, #1
-/* strrchr -- find the last occurence of C in a nul-terminated string
+/* strrchr -- find the last occurrence of C in a nul-terminated string
Copyright (C) 2013-2023 Free Software Foundation, Inc.
This file is part of the GNU C Library.
cmp r2, #0 @ Find EOS
it eq
bxeq lr
- tst r3, #7 @ Find the aligment point
+ tst r3, #7 @ Find the alignment point
bne 1b
@ So now we're aligned. Now we actually need a stack frame.
mem, new, old, __ATOMIC_RELEASE)
/* Compare and exchange.
- For all "bool" routines, we return FALSE if exchange succesful. */
+ For all "bool" routines, we return FALSE if exchange successful. */
# define __arch_compare_and_exchange_bool_8_int(mem, newval, oldval, model) \
({__arm_link_error (); 0; })
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; witout even the implied warranty of
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
};
-/* Callback to determins if the PC lies within an object, and remember the
+/* Callback to determines if the PC lies within an object, and remember the
location of the exception index table if it does. */
static int
# This test relies on compiling part of the binary with EH information,
# part without, and unwinding through. The .ARM.exidx tables have
# start addresses for EH regions, but no end addresses. Every
-# region an exception needs to propogate through must have unwind
+# region an exception needs to propagate through must have unwind
# information, or a previous function's unwind table may be used
# by mistake.
tests := $(filter-out tst-cleanupx4,$(tests))
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
-/* The default "nor" constraint produces unparseable memory references
+/* The default "nor" constraint produces unparsable memory references
for constants. Omit the problematic "o" constraint. See bug 24164
and GCC PR 89146. */
#define STAP_SDT_ARG_CONSTRAINT nr
/* Install new environment. */
__fesetenv (envp);
- /* Raise the safed exception. Incidently for us the implementation
+ /* Raise the saved exception. Incidentally for us the implementation
defined format of the values in objects of type fexcept_t is the
same as the ones specified using the FE_* constants. */
feraiseexcept (temp);
EXTERN size_t _dl_nns;
/* During the program run we must not modify the global data of
- loaded shared object simultanously in two threads. Therefore we
+ loaded shared object simultaneously in two threads. Therefore we
protect `_dl_open' and `_dl_close' in dl-close.c.
This must be a recursive lock since the initializer function of
# endif
#endif
-/* Perform early memory allocation, avoding a TCB dependency.
+/* Perform early memory allocation, avoiding a TCB dependency.
Terminate the process if allocation fails. May attempt to use
brk. */
void *_dl_early_allocate (size_t size) attribute_hidden;
# endif
#endif
-/* Makros to generate eh_frame unwind information. */
+/* Macros to generate eh_frame unwind information. */
#ifdef __ASSEMBLER__
# define cfi_startproc .cfi_startproc
# define cfi_endproc .cfi_endproc
data->dbase = NULL;
if (p_dynamic)
{
- /* For dynamicly linked executables and shared libraries,
+ /* For dynamically linked executables and shared libraries,
DT_PLTGOT is the gp value for that object. */
ElfW(Dyn) *dyn = (ElfW(Dyn) *)(p_dynamic->p_vaddr + load_base);
for (; dyn->d_tag != DT_NULL ; dyn++)
#define TCP_DEFER_ACCEPT 9 /* Wake up listener only when data arrive */
#define TCP_WINDOW_CLAMP 10 /* Bound advertised window */
#define TCP_INFO 11 /* Information about this connection. */
-#define TCP_QUICKACK 12 /* Bock/reenable quick ACKs. */
+#define TCP_QUICKACK 12 /* Bock/re-enable quick ACKs. */
#define TCP_CONGESTION 13 /* Congestion control algorithm. */
#define TCP_MD5SIG 14 /* TCP MD5 Signature (RFC2385) */
#define TCP_COOKIE_TRANSACTIONS 15 /* TCP Cookie Transactions */
# define TCPI_OPT_TIMESTAMPS 1
# define TCPI_OPT_SACK 2
# define TCPI_OPT_WSCALE 4
-# define TCPI_OPT_ECN 8 /* ECN was negociated at TCP session init */
+# define TCPI_OPT_ECN 8 /* ECN was negotiated at TCP session init */
# define TCPI_OPT_ECN_SEEN 16 /* we received at least one packet with ECT */
# define TCPI_OPT_SYN_DATA 32 /* SYN-ACK acked data in SYN sent or rcvd */
/* Flags for both getsockopt and setsockopt */
#define TCP_COOKIE_IN_ALWAYS (1 << 0) /* Discard SYN without cookie */
#define TCP_COOKIE_OUT_NEVER (1 << 1) /* Prohibit outgoing cookies,
- * supercedes everything. */
+ * supersedes everything. */
/* Flags for getsockopt */
#define TCP_S_DATA_IN (1 << 2) /* Was data received? */
"ldw 76(%1), %%r30\n\t"
/* Load return pointer. */
"ldw 80(%1), %%rp\n\t"
- /* Ues a spare caller saves register. */
+ /* Use a spare caller saves register. */
"ldo 88(%1),%%r25\n\t"
/* Load callee saves from fr12 to fr21. */
"fldds,ma 8(%%r25), %%fr12\n\t"
if (__builtin_expect (COMPARE_AND_SWAP (&ftab[symidx], (ElfW(Addr)) NULL,
fdesc), 1))
{
- /* Noone has updated the entry and the new function
+ /* No one has updated the entry and the new function
descriptor has been installed. */
#if 0
const char *strtab
addi 63, %r28, %r28
depi 0, 27, 6, %r28
- /* Calcualte start of stack copy */
+ /* Calculate start of stack copy */
ldo -192(%sp),%r2
/* Increate the stack by *framesizep */
/* Save stack pointer */
stw %r1, -4(%sp)
- /* Single byte copy of prevous stack onto newly allocated stack */
+ /* Single byte copy of previous stack onto newly allocated stack */
1: ldb %r28(%r2), %r1
add %r28, %sp, %r26
stb %r1, 0(%r26)
addi,< -1,%r28,%r28
b,n 1b
- /* Retore r28 and r27 and r2 already points at -192(%sp) */
+ /* Restore r28 and r27 and r2 already points at -192(%sp) */
ldw 0(%r2),%r28
ldw 84(%r2),%r26
/* Unwind the stack */
ldo 192(%sp),%sp
- /* Retore callers rp */
+ /* Restore callers rp */
ldw -20(%sp),%rp
/* Return */
bv,n 0(%r2)
/* KIND must stay at this position in the structure to maintain
binary compatibility with static initializers. */
int __kind;
- /* The old 4-word 16-byte aligned lock. This is initalized
+ /* The old 4-word 16-byte aligned lock. This is initialized
to all ones by the Linuxthreads PTHREAD_MUTEX_INITIALIZER.
Unused in NPTL. */
int __glibc_compat_padding[4];
-/* Cancelation. Generic version.
+/* Cancellation. Generic version.
Copyright (C) 2002-2023 Free Software Foundation, Inc.
This file is part of the GNU C Library.
}
else
{
- /* We're still in the list of waiters. Noone attempted to wake us up,
+ /* We're still in the list of waiters. No one attempted to wake us up,
i.e. we timed out. */
assert (err == ETIMEDOUT);
__pthread_dequeue (self);
-/* pthread_key internal declatations for the Hurd version.
+/* pthread_key internal declarations for the Hurd version.
Copyright (C) 2002-2023 Free Software Foundation, Inc.
This file is part of the GNU C Library.
drain = err ? 1 : 0;
else
{
- /* We're still in the queue. Noone attempted to wake us up, i.e. we
+ /* We're still in the queue. No one attempted to wake us up, i.e. we
timed out. */
__pthread_dequeue (self);
drain = 0;
drain = err ? 1 : 0;
else
{
- /* We're still in the queue. Noone attempted to wake us up, i.e. we
+ /* We're still in the queue. No one attempted to wake us up, i.e. we
timed out. */
__pthread_dequeue (self);
drain = 0;
}
- /* Noone is waiting. Just unlock it. */
+ /* No one is waiting. Just unlock it. */
__pthread_spin_unlock (&rwlock->__held);
__pthread_spin_unlock (&rwlock->__lock);
int *__restrict __pshared)
__THROW __nonnull ((1, 2));
-/* Set the value of the process shared atrribute in *ATTR to
+/* Set the value of the process shared attribute in *ATTR to
PSHARED. */
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
int __pshared)
# include <bits/types/struct___pthread_rwlock.h>
# define PTHREAD_RWLOCK_INITIALIZER __PTHREAD_RWLOCK_INITIALIZER
-/* Create a rwlock object with attributes given by ATTR and strore the
+/* Create a rwlock object with attributes given by ATTR and store the
result in *RWLOCK. */
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
const pthread_rwlockattr_t *__restrict __attr)
\f
-/* Cancelation. */
+/* Cancellation. */
/* Register a cleanup handler. */
extern void pthread_cleanup_push (void (*__routine) (void *), void *__arg);
int *__restrict __pshared)
__THROW __nonnull ((1, 2));
-/* Set the value of the process shared atrribute in *ATTR to
+/* Set the value of the process shared attribute in *ATTR to
PSHARED. */
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
int __pshared)
/* Scheduling. */
-/* Return thread THREAD's scheduling paramters. */
+/* Return thread THREAD's scheduling parameters. */
extern int pthread_getschedparam (pthread_t __thr, int *__restrict __policy,
struct sched_param *__restrict __param)
__THROW __nonnull ((2, 3));
-/* Set thread THREAD's scheduling paramters. */
+/* Set thread THREAD's scheduling parameters. */
extern int pthread_setschedparam (pthread_t __thr, int __policy,
const struct sched_param *__param)
__THROW __nonnull ((3));
/* Global lock to protect operation on the lists. */
pthread_mutex_t __timer_mutex = PTHREAD_MUTEX_INITIALIZER;
-/* Variable to protext initialization. */
+/* Variable to protect initialization. */
pthread_once_t __timer_init_once_control = PTHREAD_ONCE_INIT;
/* Nonzero if initialization of timer implementation failed. */
/* Install new environment. */
__fesetenv (envp);
- /* Raise the saved exception. Incidently for us the implementation
+ /* Raise the saved exception. Incidentally for us the implementation
defined format of the values in objects of type fexcept_t is the
same as the ones specified using the FE_* constants. */
__feraiseexcept ((int) temp);
-/* Compute hash alue for given string according to ELF standard.
+/* Compute hash value for given string according to ELF standard.
Copyright (C) 1998-2023 Free Software Foundation, Inc.
This file is part of the GNU C Library.
/* Warning!
wmemcmp has to use SIGNED comparison for elements.
- memcmp has to use UNSIGNED comparison for elemnts.
+ memcmp has to use UNSIGNED comparison for elements.
*/
.section .text.sse4.2,"ax",@progbits
/* Warning!
wmemcmp has to use SIGNED comparison for elements.
- memcmp has to use UNSIGNED comparison for elemnts.
+ memcmp has to use UNSIGNED comparison for elements.
*/
atom_text_section
movl - 4 byte
movlpd - 8 byte
movaps - 16 byte - requires 16 byte alignment
- of sourse and destination adresses.
+ of source and destination addresses.
*/
.text
-/* strcspn (str, ss) -- Return the length of the initial segement of STR
+/* strcspn (str, ss) -- Return the length of the initial segment of STR
which contains no characters from SS.
For Intel 80x86, x>=3.
Copyright (C) 1994-2023 Free Software Foundation, Inc.
{ .mmi
and r15 = -16, r15
;;
- /* We don't copy the 16byte scatch area. Prepare r16/r17 as
+ /* We don't copy the 16byte scratch area. Prepare r16/r17 as
destination. */
sub r16 = r12, r15
sub r17 = r12, r15
;;
}
{ .mii
- /* Skip the 16byte scatch area. Prepare r2/r3 as source. */
+ /* Skip the 16byte scratch area. Prepare r2/r3 as source. */
adds r2 = 16, loc10
adds r3 = 24, loc10
mov ar.lc = r15
//=========================================
// The acos function computes the principal value of the arc cosine of x.
// acos(0) returns Pi/2, acos(1) returns 0, acos(-1) returns Pi.
-// A doman error occurs for arguments not in the range [-1,+1].
+// A domain error occurs for arguments not in the range [-1,+1].
//
// The acos function returns the arc cosine in the range [0, Pi] radians.
//
// Return acos(1.0) = 0.0, acos(-1.0) = Pi
//
// 5. 1.0 < |x| <= +INF
-// A doman error occurs for arguments not in the range [-1,+1]
+// A domain error occurs for arguments not in the range [-1,+1]
//
// 6. x = [S,Q]NaN
// Return acos(x) = QNaN
// Description
//=========================================
// The acosf function computes the principle value of the arc sine of x.
-// A doman error occurs for arguments not in the range [-1,+1].
+// A domain error occurs for arguments not in the range [-1,+1].
// The acosf function returns the arc cosine in the range [0, +pi] radians.
// acos(1) returns +0
//=========================================
// The asin function computes the principal value of the arc sine of x.
// asin(0) returns 0, asin(1) returns pi/2, asin(-1) returns -pi/2.
-// A doman error occurs for arguments not in the range [-1,+1].
+// A domain error occurs for arguments not in the range [-1,+1].
//
// The asin function returns the arc sine in the range [-pi/2, +pi/2] radians.
//
// Return asin(x) = sign(x)*Pi/2
//
// 5. 1.0 < |x| <= +INF
-// A doman error occurs for arguments not in the range [-1,+1]
+// A domain error occurs for arguments not in the range [-1,+1]
//
// 6. x = [S,Q]NaN
// Return asin(x) = QNaN
// Description
//=========================================
// The asinf function computes the arc sine of x in the range [-pi,+pi].
-// A doman error occurs for arguments not in the range [-1,+1].
+// A domain error occurs for arguments not in the range [-1,+1].
// asinf(+-0) returns +-0
// asinf(x) returns a Nan and raises the invalid exception for |x| >1
// The acosf function returns the arc cosine in the range [0, +pi] radians.
-// A doman error occurs for arguments not in the range [-1,+1].
+// A domain error occurs for arguments not in the range [-1,+1].
// acosf(1) returns +0
// acosf(x) returns a Nan and raises the invalid exception for |x| >1
// L2 = 1.0/log(10)
//
// So common code with two different entry points those set pointers
-// to the base address of coresponding data sets containing values
+// to the base address of corresponding data sets containing values
// of L2,T and prepare integer representation of L1 needed for following
// setf instruction.
//
// L2 = 1.0/log(10)
//
// So common code with two different entry points those set pointers
-// to the base address of coresponding data sets containing values
+// to the base address of corresponding data sets containing values
// of L2,T and prepare integer representation of L1 needed for following
// setf instruction can be used.
//
// 0xFFFEFF00000000000000 and 0xFFFF8080000000000000 correspondingly.
// As far as biased exponent of x here can be equal only to 0xFFFE or
// 0xFFFF we need to test only last bit of it. Also signifigand always
-// has implicit bit set to 1 that can be exluded from comparison.
+// has implicit bit set to 1 that can be excluded from comparison.
// Thus it's quite enough to generate 64-bit integer bits of that are
// ix[63] = biased_exponent_of_x[0] and ix[62-0] = significand_of_x[62-0]
// and compare it with 0x7F00000000000000 and 0x80800000000000000 (those
//
// Log(1/Cm) = log(1/frcpa(1+m/256)) where m goes from 0 to 255.
//
-// We tabluate as two doubles, T and t, where T +t is the value itself.
+// We tabulate as two doubles, T and t, where T +t is the value itself.
//
// Log(x) = (K Log(2)_hi + T) + (Log(2)_hi + t) + Log( 1 + (Bx-1))
// Log(x) = G + delta + Log( 1 + (Bx-1))
// +0 -inf +inf error 27 33 divide-by-zero
// -0 -inf +inf error 27 33 divide-by-zero
-// X zero Y positve
+// X zero Y positive
// +0 +odd integer +0
// -0 +odd integer -0
// +0 !+odd integer +0
}
;;
-// Note POW_Xm1 and POW_r1 are used interchangably
+// Note POW_Xm1 and POW_r1 are used interchangeably
{ .mfi
alloc r32=ar.pfs,2,19,4,0
fms.s1 POW_r = POW_B, POW_NORM_X,f1
//
// Log(1/Cm) = log(1/frcpa(1+m/256)) where m goes from 0 to 255.
//
-// We tabluate as one double, T for single precision power
+// We tabulate as one double, T for single precision power
//
// Log(x) = (K Log(2)_hi + T) + (K Log(2)_lo) + Log( 1 + (Bx-1))
// Log(x) = G + delta + Log( 1 + (Bx-1))
// +0 -inf +inf error 27 33 divide-by-zero
// -0 -inf +inf error 27 33 divide-by-zero
-// X zero Y positve
+// X zero Y positive
// +0 +odd integer +0
// -0 +odd integer -0
// +0 !+odd integer +0
fclass.m p14,p0 = f8, 0x07
nop.i 999
}
-// Note POW_Xm1 and POW_r1 are used interchangably
+// Note POW_Xm1 and POW_r1 are used interchangeably
{ .mfb
nop.m 999
(p8) fnma.s1 POW_Xm1 = POW_Xp1,f1,f0
// precision number.
//
//
-// Claculation of logarithm
+// Calculation of logarithm
// ------------------------
// Consider x = 2^N * xf so
// ln(x) = ln(frcpa(x)*x/frcpa(x))
// EDP_Root is the exact value of the corresponding root rounded to double
// extended precision. So, we have 35 different polynomials which make our
// table rather big. We may hope that x falls in root "neighbourhood"
-// quite rarely -> ther might be no need in frequent use of different
+// quite rarely -> there might be no need in frequent use of different
// polynomials.
// A0, A1, A2, A3 are represented as pairs of double precision numbers,
// A4, A5 are long doubles, and to decrease the size of the table we
adds rPolDataPtr = 3440, rTbl3Addr
}
{ .mfi
- // (i*16)*4 + (i*16)*8 - offsett of polynomial on range [-6.0, -0.75]
+ // (i*16)*4 + (i*16)*8 - offset of polynomial on range [-6.0, -0.75]
shladd rTmpPtr = rIndexPol, 2, rIndexPol
fma.s1 fXSqr = FR_FracX, FR_FracX, f0 // y^2
// point to left "near root" bound
{ .mfi
ldfpd fLnSin34, fLnSin36 = [rTmpPtr3], 16
fma.s1 fRcpX = fInvX, fRcpX, fRcpX // end of 2nd NR iteration
- // add special offsett if -4 < x <= -3.0
+ // add special offset if -4 < x <= -3.0
(p6) adds rPolDataPtr = 640, rPolDataPtr
}
{ .mfi
// left bound of "near root" range
(p12) ld8 rLeftBound = [rRootsBndAddr]
fmerge.se fNormDx = f1, fDx // significand of DeltaX
- // base address + offsett for polynomial coeff. on range [-6.0, -0.75]
+ // base address + offset for polynomial coeff. on range [-6.0, -0.75]
add rPolDataPtr = rPolDataPtr, rTmpPtr
}
{ .mfi
nop.i 0
}
{ .mfi
- add rPolDataPtr = rPolDataPtr, rTmpPtr // begin + offsett
+ add rPolDataPtr = rPolDataPtr, rTmpPtr // begin + offset
nop.f 0
nop.i 0
}
// ==============
//
// This describes the algorithm in the most natural way using
-// unsigned interger multiplication. The implementation section
+// unsigned integer multiplication. The implementation section
// describes how the integer arithmetic is simulated.
//
// STEP 0. Initialization
//
// P_1 = b b b ... b
//
-// each b can be 0 or 1. Also, let P_0 be the two bits correspoding to
+// each b can be 0 or 1. Also, let P_0 be the two bits corresponding to
// bit positions L+2 and L+1. So, when each of the P_j is interpreted
// with appropriate scaling, we have
//
{ .mfi
nop.m 999
//
-// For big s: r = s - w: No futher reduction is necessary
+// For big s: r = s - w: No further reduction is necessary
// For small s: w = N * P_3 (change sign) More reduction
//
(p6) fcmp.lt.unc.s1 p8, p9 = FR_r, FR_Two_to_M3
};;
//
-// For big s: r = s - w: No futher reduction is necessary
+// For big s: r = s - w: No further reduction is necessary
// For small s: w = N * P_3 (change sign) More reduction
//
{ .mfi
;;
//
-// For big s: r = s - w: No futher reduction is necessary
+// For big s: r = s - w: No further reduction is necessary
// For small s: w = N * P_3 (change sign) More reduction
//
{ .mfi
{ .mfi
ldfe FR_A12 = [GR_P_POINT_1], -64
nop.f 0
- extr GR_K = GR_N_fix, 12, 32 // Extract limite range K
+ extr GR_K = GR_N_fix, 12, 32 // Extract limit range K
}
{ .mfi
ldfe FR_A13 = [GR_P_POINT_2], -64
nop.i 999 ;;
}
-// p11 <== SMALL, no integer part, fraction is everyting
+// p11 <== SMALL, no integer part, fraction is everything
// p9 <== HUGE, no fraction part, integer is everything
// p12 <== NORMAL, fraction part and integer part
{ .mii
nop.i 999 ;;
}
-// p11 <== SMALL, no integer part, fraction is everyting
+// p11 <== SMALL, no integer part, fraction is everything
// p9 <== HUGE, no fraction part, integer is everything
// p12 <== NORMAL, fraction part and integer part
{ .mii
nop.i 999 ;;
}
-// p11 <== SMALL, no integer part, fraction is everyting
+// p11 <== SMALL, no integer part, fraction is everything
// p9 <== HUGE, no fraction part, integer is everything
// p12 <== NORMAL, fraction part and integer part
{ .mii
//
// This branch is cut off by one fclass operation.
// Then zeros+nans, infinities and denormals processed separately.
-// For denormals we use simple fma operaton x+x*x (- for +denorms)
+// For denormals we use simple fma operation x+x*x (- for +denorms)
//
// 2. [0;1/8] path: 0.0 < |x| < 1/8
//
// Step 3: Division
// ----------------
// To calculate 1/(x*GAMMA(x)*S21(r)) we use frcpa instruction
-// with following Newton-Raphson interations.
+// with following Newton-Raphson iterations.
//
//
//*********************************************************************
LOCAL_OBJECT_START(tgamma_data)
data8 0x406573FAE561F648 // overflow boundary (171.624376956302739927196)
-data8 0x3FDD8B618D5AF8FE // point of local minium (0.461632144968362356785)
+data8 0x3FDD8B618D5AF8FE // point of local minimum (0.461632144968362356785)
//
//[2; 3]
data8 0xEF0E85C9AE40ABE2,0x00004000 // C01
// Step 3: Division
// ----------------
// To calculate 1/x and 1/(GAMMA(x)*S12(rs)) we use frcpa
-// instruction with following Newton-Raphson interations.
+// instruction with following Newton-Raphson iterations.
//
//
//*********************************************************************
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
-/* Return: the address of the first occurence of chr in str or NULL
+/* Return: the address of the first occurrence of chr in str or NULL
Inputs:
in0: str
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
-/* Return: the address of the first occurence of chr in str or NULL
+/* Return: the address of the first occurrence of chr in str or NULL
Inputs:
in0: str
t=(b-s)+bb;
*a=s;
*aa=t;
- return ((int) sum)&3; /* return quater of unit circle */
+ return ((int) sum)&3; /* return quarter of unit circle */
}
* = log(6.3*5.3) + lgamma(5.3)
* = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3)
* 2. Polynomial approximation of lgamma around its
- * minimun ymin=1.461632144968362245 to maintain monotonicity.
+ * minimum ymin=1.461632144968362245 to maintain monotonicity.
* On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use
* Let z = x-ymin;
* lgamma(x) = -1.214862905358496078218 + z^2*poly(z)
/* The high double may be rounded and the low double reflects the
difference between the long double and the rounded high double
- value. This is indicated by a differnce between the signs of the
+ value. This is indicated by a difference between the signs of the
high and low doubles. */
if (u.d[0].ieee.negative != u.d[1].ieee.negative
&& lo != 0)
* = log(6.3*5.3) + lgamma(5.3)
* = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3)
* 2. Polynomial approximation of lgamma around its
- * minimun ymin=1.461632144968362245 to maintain monotonicity.
+ * minimum ymin=1.461632144968362245 to maintain monotonicity.
* On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use
* Let z = x-ymin;
* lgamma(x) = -1.214862905358496078218 + z^2*poly(z)
dnl We need a GAS supporting explicit reloc (older GAS produces stack-based
dnl reloc and triggers an internal error in the linker). And, we need GCC to
dnl pass the correct linker flags for static PIE. GCC >= 13 and GAS >= 2.40
-dnl satisify the requirement, but a distro may backport static PIE support into
+dnl satisfy the requirement, but a distro may backport static PIE support into
dnl earlier GCC or Binutils releases as well.
AC_CACHE_CHECK([if the toolchain is sufficient to build static PIE on LoongArch],
libc_cv_static_pie_on_loongarch, [
/* Install new environment. */
__fesetenv (envp);
- /* Raise the safed exception. Incidently for us the implementation
+ /* Raise the saved exception. Incidentally for us the implementation
defined format of the values in objects of type fexcept_t is the
same as the ones specified using the FE_* constants. */
__feraiseexcept (temp);
/* Install new environment. */
__fesetenv (envp);
- /* Raise the saved exception. Incidently for us the implementation
+ /* Raise the saved exception. Incidentally for us the implementation
defined format of the values in objects of type fexcept_t is the
same as the ones specified using the FE_* constants. */
__feraiseexcept ((int) fpsr);
assert (local.ptr__Unwind_GetGR != NULL); \
PTR_MANGLE (local.ptr__Unwind_GetGR);
-/* This is overriden by the m680x0 variant. */
+/* This is overridden by the m680x0 variant. */
#define UNWIND_LINK_FRAME_STATE_FOR 0
#endif /* _ARCH_UNWIND_LINK_H */
return 0;
}
-/* Allocate any resouces for THREAD. The new kernel thread should not
+/* Allocate any resources for THREAD. The new kernel thread should not
be eligible to be scheduled. */
int
__pthread_thread_alloc (struct __pthread *thread)
$(mach-errnos-deps) $(common-objpfx)errnos.d
mkdir -p $(hurd-objpfx)bits
$(AWK) -f $^ > $(hurd-objpfx)bits/errno.h-tmp
-# Make it unwritable so noone will edit it by mistake.
+# Make it unwritable so no one will edit it by mistake.
-chmod a-w $(hurd-objpfx)bits/errno.h-tmp
$(move-if-change) $(hurd-objpfx)bits/errno.h-tmp $(hurd)/bits/errno.h
touch $@
/* We support user-defined stacks. */
#define _POSIX_THREAD_ATTR_STACKADDR 200809L
-/* We do not support priority inheritence. */
+/* We do not support priority inheritance. */
#define _POSIX_THREAD_PRIO_INHERIT -1
/* We do not support priority protection. */
#define _POSIX_THREAD_PRIO_PROTECT -1
#ifdef __USE_XOPEN2K8
-/* We do not support priority inheritence for robust mutexes. */
+/* We do not support priority inheritance for robust mutexes. */
# define _POSIX_THREAD_ROBUST_PRIO_INHERIT -1
/* We do not support priority protection for robust mutexes. */
/* rtld can not access TLS too early, thus rtld_errno.
Instead of making __open/__close pass errno from TLS to rtld_errno, simply
- use a weak __errno_location using rtld_errno, which will be overriden by the
+ use a weak __errno_location using rtld_errno, which will be overridden by the
libc definition. */
static int rtld_errno;
int * weak_function
#define __PTHREAD_MUTEX_INITIALIZER \
{ 0, 0, 0, 0, __PTHREAD_MUTEX_TIMED, 0, { { 0, 0 } } }
-/* The +1 is to mantain binary compatibility with the old
+/* The +1 is to maintain binary compatibility with the old
* libpthread implementation. */
#define __PTHREAD_ERRORCHECK_MUTEX_INITIALIZER \
{ 0, 0, 0, 0, __PTHREAD_MUTEX_ERRORCHECK + 1, 0, { { 0, 0 } } }
drain = err ? 1 : 0;
else
{
- /* We're still in the list of waiters. Noone attempted to wake us
+ /* We're still in the list of waiters. No one attempted to wake us
up, i.e. we timed out. */
__pthread_dequeue (self);
drain = 0;
libc.so: realloc + REL R_386_GLOB_DAT
libm.so: matherr + REL R_386_GLOB_DAT
# The dynamic linker has its own versions of basic functions for initial loading
-# of shared libraries. These need to be overriden by libc once loaded.
+# of shared libraries. These need to be overridden by libc once loaded.
ld.so: __open ?
ld.so: __open64 ?
ld.so: __open_nocancel
int ttype;
if (HURD_DPORT_USE (fd, __term_get_bottom_type (port, &ttype)) == 0)
- /* get_bottom_type suceeded, this is the slave side. */
+ /* get_bottom_type succeeded, this is the slave side. */
return __hurd_fail (ENOTTY), ENOTTY;
if (err = HURD_DPORT_USE (fd, __term_get_peername (port, peername)))
#include <sysdep-cancel.h>
/* Read N bytes into BUF through socket FD.
- If ADDR is not NULL, fill in *ADDR_LEN bytes of it with tha address of
+ If ADDR is not NULL, fill in *ADDR_LEN bytes of it with the address of
the sender, and store the actual size of the address in *ADDR_LEN.
Returns the number of bytes read or -1 for errors. */
ssize_t
error_t return_code;
} msg;
- /* Wait for a message on a port that noone sends to. The purpose is
+ /* Wait for a message on a port that no one sends to. The purpose is
the receive timeout. Notice interrupts so that if we are
thread_abort'd, we will loop around and fetch new values from
_hurd_itimerval. */
#endif
/* Compare and exchange.
- For all "bool" routines, we return FALSE if exchange succesful. */
+ For all "bool" routines, we return FALSE if exchange successful. */
#define __arch_compare_and_exchange_bool_8_int(mem, newval, oldval, model) \
(abort (), 0)
typedef struct La_mips_64_regs
{
uint64_t lr_reg[8]; /* $a0 through $a7 */
- double lr_fpreg[8]; /* $f12 throgh $f19 */
+ double lr_fpreg[8]; /* $f12 through $f19 */
uint64_t lr_ra;
uint64_t lr_sp;
} La_mips_64_regs;
/* Install new environment. */
__fesetenv (envp);
- /* Raise the safed exception. Incidently for us the implementation
+ /* Raise the saved exception. Incidentally for us the implementation
defined format of the values in objects of type fexcept_t is the
same as the ones specified using the FE_* constants. */
__feraiseexcept (temp);
/*
* Using PREFETCH_HINT_LOAD_STREAMED instead of PREFETCH_LOAD on load
- * prefetches appears to offer a slight preformance advantage.
+ * prefetches appear to offer a slight performance advantage.
*
* Using PREFETCH_HINT_PREPAREFORSTORE instead of PREFETCH_STORE
* or PREFETCH_STORE_STREAMED offers a large performance advantage
andi a3,a3,(NSIZE-1) /* copy a3 bytes to align a0/a1 */
beq a3,zero,L(aligned) /* if a3=0, it is already aligned */
- PTR_SUBU a2,a2,a3 /* a2 is the remining bytes count */
+ PTR_SUBU a2,a2,a3 /* a2 is the remaining bytes count */
C_LDHI t8,0(a1)
PTR_ADDU a1,a1,a3
L(unaligned):
andi a3,a3,(NSIZE-1) /* copy a3 bytes to align a0/a1 */
beqz a3,L(ua_chk16w) /* if a3=0, it is already aligned */
- PTR_SUBU a2,a2,a3 /* a2 is the remining bytes count */
+ PTR_SUBU a2,a2,a3 /* a2 is the remaining bytes count */
C_LDHI v1,UNIT(0)(a1)
C_LDLO v1,UNITM1(1)(a1)
L(aligned):
/* If USE_DOUBLE is not set we may still want to align the data on a 16
- byte boundry instead of an 8 byte boundry to maximize the opportunity
+ byte boundary instead of an 8 byte boundary to maximize the opportunity
of proAptiv chips to do memory bonding (combining two sequential 4
byte stores into one 8 byte store). We know there are at least 4 bytes
left to store or we would have jumped to L(lastb) earlier in the code. */
...
NULL
ra ($31) The return address register is set to zero so that programs
- that search backword through stack frames recognize the last
+ that search backward through stack frames recognize the last
stack frame.
*/
TEXT(msg)
/*
- * Print formated string
+ * Print formatted string
*/
#define PRINT(string) \
.set push; \
return true;
}
-/* Load every permuation of OBJECTS. */
+/* Load every permutation of OBJECTS. */
static bool
test_permutations (enum fp_obj objects[], int count)
{
if ((uintptr_t) pc & 0x3)
return addr;
- /* The vDSO containes either
+ /* The vDSO contains either
24021061 li v0, 0x1061 (rt_sigreturn)
0000000c syscall
ldw r2, %got(_dl_argc)(r22)\n\
ldw r5, 0(r2)\n\
\n\
- /* Load adjsuted argv. */\n\
+ /* Load adjusted argv. */\n\
ldw r2, %got(_dl_argv)(r22)\n\
ldw r6, 0(r2)\n\
\n\
Unspecified High Addresses
Referenced strings, etc. Varies
Unspecified
- Null auxilliary vector entry 4bytes
- Auxilliary vector entries 8bytes each
+ Null auxiliary vector entry 4bytes
+ Auxiliary vector entries 8bytes each
NULL terminator for envp 4bytes
Environment pointers sp+8+4*argc 4bytes each
NULL terminator for argv sp+4+4*argc 4bytes
The contents of all other registers are unspecified. User code should
set fp to zero to mark the end of the frame chain.
- The auxilliary vector is a series of pairs of 32-bit tag and 32-bit
+ The auxiliary vector is a series of pairs of 32-bit tag and 32-bit
value, terminated by an AT_NULL tag.
*/
/* This should be a compile-time constant, but the current
infrastructure makes it difficult to determine its value. Not
all targets support __thread_pointer, so set __rseq_offset only
- if thre rseq registration may have happened because RSEQ_SIG is
+ if the rseq registration may have happened because RSEQ_SIG is
defined. */
extern ptrdiff_t offset __asm__ ("__rseq_offset");
offset = (char *) &pd->rseq_area - (char *) __thread_pointer ();
exception in C++ code. If cancellation is implemented by unwinding
this is necessary to have the compiler generate the unwind information. */
-/* Set cancelability state of current thread to STATE, returning old
+/* Set cancellability state of current thread to STATE, returning old
state in *OLDSTATE if OLDSTATE is not NULL. */
extern int pthread_setcancelstate (int __state, int *__oldstate);
__THROWNL __nonnull ((1));
# ifdef __USE_XOPEN2K
-/* Try to acquire read lock for RWLOCK or return after specfied time. */
+/* Try to acquire read lock for RWLOCK or return after specified time. */
# ifndef __USE_TIME_BITS64
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__THROWNL __nonnull ((1));
# ifdef __USE_XOPEN2K
-/* Try to acquire write lock for RWLOCK or return after specfied time. */
+/* Try to acquire write lock for RWLOCK or return after specified time. */
# ifndef __USE_TIME_BITS64
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
{
pltgot = (ElfW(Addr) *) D_PTR (l, l_info[DT_PLTGOT]);
- /* Fill in initial entrys of the plt */
+ /* Fill in initial entries of the plt */
/* Register the link_map address in the plt at pltgot[1].
This will also be used in the resolver for accessing the
a struct pthread. Again, TP points to after tcbhead_t, compensate with
TLS_INIT_TCB_SIZE.
- I regard this is a seperate system from the "normal" TLS. */
+ I regard this is a separate system from the "normal" TLS. */
# define THREAD_SELF \
((struct pthread *) ((char *) __thread_self - TLS_INIT_TCB_SIZE \
-/* C11 threads conditional wait implementaiton.
+/* C11 threads conditional wait implementation.
Copyright (C) 2018-2023 Free Software Foundation, Inc.
This file is part of the GNU C Library.
/* Global lock to protect operation on the lists. */
extern pthread_mutex_t __timer_mutex;
-/* Variable to protext initialization. */
+/* Variable to protect initialization. */
extern pthread_once_t __timer_init_once_control;
/* Nonzero if initialization of timer implementation failed. */
/* Threads functions. */
/* Create a new thread executing the function __FUNC. Arguments for __FUNC
- are passed through __ARG. If succesful, __THR is set to new thread
+ are passed through __ARG. If successful, __THR is set to new thread
identifier. */
extern int thrd_create (thrd_t *__thr, thrd_start_t __func, void *__arg);
}
/* A value higher than 0 will check for uncontended pthread cancellation,
- where the sem_wait operation will return immediatelly. */
+ where the sem_wait operation will return immediately. */
if (sem_init (&sem, 0, 1) != 0)
{
puts ("error: sem_init failed");
if (sysconf (_SC_THREAD_CPUTIME) >= 0)
# endif
{
- puts ("cpuclock advertized, but cannot get ID");
+ puts ("cpuclock advertised, but cannot get ID");
exit (1);
}
}
return 1;
}
- puts ("get lock outselves");
+ puts ("get lock ourselves");
err = pthread_mutex_lock (&mut);
if (err != 0)
{
pthread_key_t *key = (pthread_key_t *) arg;
- /* Use an arbirary but valid pointer to avoid GCC warnings. */
+ /* Use an arbitrary but valid pointer to avoid GCC warnings. */
if (pthread_setspecific (*key, arg) != 0)
{
write_message ("setspecific failed\n");
There was a race in FORCE_ELISION macro which leads to either
pthread_mutex_destroy returning EBUSY as the owner was recorded
by pthread_mutex_lock - in "normal mutex" code path - but was not
- resetted in pthread_mutex_unlock - in "elision" code path.
+ reset in pthread_mutex_unlock - in "elision" code path.
Or it leads to the assertion in nptl/pthread_mutex_lock.c:
assert (mutex->__data.__owner == 0);
Please ensure that the test is run with lock elision:
e = pthread_mutex_trylock (&m);
if (e == 0)
{
- puts ("child: 1st trylock suceeded");
+ puts ("child: 1st trylock succeeded");
exit (1);
}
if (e != EBUSY)
391 r ^ PTHREAD_RWLOCK_WRPHASE))
392 {
- And then attemps to start the read phase.
+ And then attempts to start the read phase.
Assume there happens to be a tryrdlock at this point, noting
that PTHREAD_RWLOCK_WRLOCKED is clear, and PTHREAD_RWLOCK_WRPHASE
- is 1. So the try lock attemps to start the read phase.
+ is 1. So the try lock attempts to start the read phase.
In __pthread_rwlock_tryrdlock:
readers might indeed be waiting, and they are.
The atomic_store_relaxed throws away PTHREAD_RWLOCK_FUTEX_USED,
- and the waiting reader is never worken becuase as noted
+ and the waiting reader is never worken because as noted
above it is conditional on the futex being used.
The solution is for the trylock thread to inspect
If we did not install the write phase then the readers may already
be waiting on the futex, the original writer wrote 1 to __wrphase_futex
as part of starting the write phase, and we cannot also write 1
- without loosing the PTHREAD_RWLOCK_FUTEX_USED bit.
+ without losing the PTHREAD_RWLOCK_FUTEX_USED bit.
---
Summary for the pthread_rwlock_trywrlock() stall:
The stall is caused by pthread_rwlock_trywrlock setting
- __wrphase_futex futex to 1 and loosing the
+ __wrphase_futex futex to 1 and losing the
PTHREAD_RWLOCK_FUTEX_USED bit.
The fix for bug 23844 ensures that waiters on __wrphase_futex are
pthread_key_t key = (pthread_key_t) (long int) arg;
int err;
- /* Use an arbirary but valid pointer to avoid GCC warnings. */
+ /* Use an arbitrary but valid pointer to avoid GCC warnings. */
err = pthread_setspecific (key, &result);
if (err != 0)
result = 3;
aghi %r5,16
.Llastcmp:
- /* Use comparision result only if located within first n characters.
+ /* Use comparison result only if located within first n characters.
%r5: current_len;
%r4: n;
(current_len - n): [0...16[
LGR %r2,%r1 # destination address
LGR %r3,%r5 # destination length = source length
.L_MVCLE_1:
- mvcle %r2,%r4,0 # thats it, MVCLE is your friend
+ mvcle %r2,%r4,0 # that's it, MVCLE is your friend
jo .L_MVCLE_1
LGR %r2,%r0 # return destination address
br %r14
lgr %r3,%r4 # move length to r3
sgr %r4,%r4 # no source for MVCLE, only a pad byte
sgr %r5,%r5
-.L0: mvcle %r2,%r4,0(%r1) # thats it, MVCLE is your friend
+.L0: mvcle %r2,%r4,0(%r1) # that's it, MVCLE is your friend
jo .L0
lgr %r2,%r0 # return value is source address
.L1:
# undef from_generic
# undef to_generic
-/* Generate the converion routines with vector instructions. The vector
+/* Generate the conversion routines with vector instructions. The vector
routines can only be used with charsets where the maximum UCS4 value
fits in 1 byte size. Then the hardware translate-instruction is used
to translate between multiple generic characters and "1 byte UCS4"
ASM_CLOBBER_VR ("v21") ASM_CLOBBER_VR ("v22") \
ASM_CLOBBER_VR ("v23") ASM_CLOBBER_VR ("v24") \
); \
- /* Error occured? */ \
+ /* Error occurred? */ \
if (loop_count != 0) \
{ \
/* Found an invalid character! */ \
ASM_CLOBBER_VR ("v20") ASM_CLOBBER_VR ("v21") \
ASM_CLOBBER_VR ("v22") \
); \
- /* Error occured in step 1? An error (ch >= max || ch == 0) \
- occured, if remaining_loop_count > 0. The error occured \
+ /* Error occurred in step 1? An error (ch >= max || ch == 0) \
+ occurred, if remaining_loop_count > 0. The error occurred \
at character-index (index) after already processed blocks. */ \
loop_count -= remaining_loop_count; \
if (loop_count > 0) \
ASM_CLOBBER_VR ("v16") \
ASM_CLOBBER_VR ("v17") \
); \
- /* Error occured in processed bytes of step 2? \
- Thus possible error in step 1 is obselete.*/ \
+ /* Error occurred in processed bytes of step 2? \
+ Thus possible error in step 1 is obsolete.*/ \
if (tmp < 16) \
{ \
index = tmp; \
inptr -= loop_count * 64; \
} \
} \
- /* Error occured in step 1/2? */ \
+ /* Error occurred in step 1/2? */ \
if (index < 16) \
{ \
/* Found an invalid character (see step 2) or zero \
/* We include the BSD entry points here as well. */
ENTRY (setjmp)
lhi %r3,1 /* second argument of one */
- j .Linternal_sigsetjmp /* branch relativ to __sigsetjmp */
+ j .Linternal_sigsetjmp /* branch relative to __sigsetjmp */
END (setjmp)
/* Binary compatibility entry point. */
ENTRY(_setjmp)
lhi %r3,0 /* second argument of zero */
- j .Linternal_sigsetjmp /* branch relativ to __sigsetjmp */
+ j .Linternal_sigsetjmp /* branch relative to __sigsetjmp */
END (_setjmp)
#if NEED_COMPAT_SYMBOLS
strong_alias (_setjmp, __GI__setjmp)
ENTRY(__setjmp)
lhi %r3,0 /* second argument of zero */
- j .Linternal_sigsetjmp /* branch relativ to __sigsetjmp */
+ j .Linternal_sigsetjmp /* branch relative to __sigsetjmp */
END (__setjmp)
ENTRY(__sigsetjmp)
/* Usually the auxiliary vector can be expected directly after
the environment variables. But we have to skip extra zeros
- because the loader might have removed unsecure variables for
+ because the loader might have removed insecure variables for
setuid programs. */
.L26: l %r5,0(%r6)
/* We include the BSD entry points here as well. */
ENTRY (setjmp)
lghi %r3,1 /* Second argument of one. */
- j .Linternal_sigsetjmp /* Branch relativ to __sigsetjmp. */
+ j .Linternal_sigsetjmp /* Branch relative to __sigsetjmp. */
END (setjmp)
/* Binary compatibility entry point. */
ENTRY(_setjmp)
slgr %r3,%r3 /* Second argument of zero. */
- j .Linternal_sigsetjmp /* Branch relativ to __sigsetjmp. */
+ j .Linternal_sigsetjmp /* Branch relative to __sigsetjmp. */
END (_setjmp)
#if NEED_COMPAT_SYMBOLS
strong_alias (_setjmp, __GI__setjmp)
ENTRY(__setjmp)
slgr %r3,%r3 /* Second argument of zero. */
- j .Linternal_sigsetjmp /* Branch relativ to __sigsetjmp. */
+ j .Linternal_sigsetjmp /* Branch relative to __sigsetjmp. */
END (__setjmp)
ENTRY(__sigsetjmp)
jz .L8
icm %r0,2,6(%r3) # seventh byte
jz .L9
- icm %r0,1,7(%r3) # eigth byte
+ icm %r0,1,7(%r3) # eighth byte
jz .L10
stg %r0,0(%r2,%r3) # store all eight to dest.
la %r3,8(%r3)
lgr %r0,%r2 /* Save return-pointer to found zero. */
clgije %r4,1,.Lend /* Skip zero-filling, if found zero is last
possible character.
- (1 is substracted from r4 below!). */
+ (1 is subtracted from r4 below!). */
aghi %r4,-2 /* mvc with exrl needs count - 1.
(additional -1, see remaining bytes above) */
srlg %r6,%r4,8 /* Split into 256 byte blocks. */
character in this part of reject
is a zero. */
/* r8>0 -> zero found in this acc-part. */
- vrepb %v18,%v17,0 /* Replicate first char accross all chars. */
+ vrepb %v18,%v17,0 /* Replicate first char across all chars. */
vceqb %v22,%v20,%v17 /* Create a mask (v22) of null chars
by comparing with 0 (v20). */
vsel %v17,%v18,%v17,%v22 /* Replace null chars with first char. */
j .Lloop
.Llastcmp:
- /* Use comparision result only if located within first n characters.
+ /* Use comparison result only if located within first n characters.
%r0: loaded byte count in vreg;
%r5: current_len;
%r4: n;
if first char in this part of accept
is a zero. */
/* r8>0 -> zero found in this acc-part. */
- vrepb %v18,%v17,0 /* Replicate first char accross all chars. */
+ vrepb %v18,%v17,0 /* Replicate first char across all chars. */
vceqb %v22,%v20,%v17 /* Create a mask (v22) of null chars
by comparing with 0 (v20). */
vsel %v17,%v18,%v17,%v22 /* Replace null chars with first char. */
Register usage:
-r0=loaded bytes in first part of s.
- -r1=pointer to last occurence of c or NULL if not found.
+ -r1=pointer to last occurrence of c or NULL if not found.
-r2=s
-r3=c
-r4=tmp
-v16=part of s
-v17=index of found element
-v18=replicated c
- -v19=part of s with last occurence of c.
+ -v19=part of s with last occurrence of c.
-v20=permute pattern
*/
ENTRY(STRRCHR_Z13)
j .Lloop
.Lfound_first_part:
- /* This code is only executed if the found c/zero is whithin loaded
+ /* This code is only executed if the found c/zero is within loaded
bytes. If no c/zero was found (cc==3) the found index = 16, thus
this code is not called.
Resulting condition code of vector find element equal:
clije %r8,0,.Lslow_add_lbc_end /* End if zero is first character
in this part of accept-string. */
/* r8>0 -> zero found in this acc-part. */
- vrepb %v18,%v17,0 /* Replicate first char accross all chars. */
+ vrepb %v18,%v17,0 /* Replicate first char across all chars. */
vceqb %v22,%v20,%v17 /* Create a mask (v22) of null chars
by comparing with 0 (v20). */
vsel %v17,%v18,%v17,%v22 /* Replace null chars with first char. */
" slgr %[R_OUTLEN],%[R_TMP3]\n\t" \
/* Handles UTF16 surrogates with convert instruction. */ \
"20: cu24 %[R_OUT],%[R_IN],1\n\t" \
- " jo 0b\n\t" /* Try vector implemenation again. */ \
+ " jo 0b\n\t" /* Try vector implementation again. */ \
" lochil %[R_RES],%[RES_OUT_FULL]\n\t" /* cc == 1. */ \
" lochih %[R_RES],%[RES_IN_ILL]\n\t" /* cc == 2. */ \
".machine pop" \
" slgr %[R_OUTLEN],%[R_TMP3]\n\t" \
/* Handles UTF16 surrogates with convert instruction. */ \
"20: cu42 %[R_OUT],%[R_IN]\n\t" \
- " jo 0b\n\t" /* Try vector implemenation again. */ \
+ " jo 0b\n\t" /* Try vector implementation again. */ \
" lochil %[R_RES],%[RES_OUT_FULL]\n\t" /* cc == 1. */ \
" lochih %[R_RES],%[RES_IN_ILL]\n\t" /* cc == 2. */ \
".machine pop" \
" slgr %[R_OUTLEN],%[R_TMP3]\n\t" \
/* Handle multibyte utf8-char with convert instruction. */ \
"20: cu12 %[R_OUT],%[R_IN],1\n\t" \
- " jo 0b\n\t" /* Try vector implemenation again. */ \
+ " jo 0b\n\t" /* Try vector implementation again. */ \
" lochil %[R_RES],%[RES_OUT_FULL]\n\t" /* cc == 1. */ \
" lochih %[R_RES],%[RES_IN_ILL]\n\t" /* cc == 2. */ \
".machine pop" \
" slgr %[R_OUTLEN],%[R_TMP3]\n\t" \
/* Handles UTF16 surrogates with convert instruction. */ \
"20: cu21 %[R_OUT],%[R_IN],1\n\t" \
- " jo 0b\n\t" /* Try vector implemenation again. */ \
+ " jo 0b\n\t" /* Try vector implementation again. */ \
" lochil %[R_RES],%[RES_OUT_FULL]\n\t" /* cc == 1. */ \
" lochih %[R_RES],%[RES_IN_ILL]\n\t" /* cc == 2. */ \
".machine pop" \
" slgr %[R_OUTLEN],%[R_TMP3]\n\t" \
/* Handle multibyte utf8-char with convert instruction. */ \
"20: cu14 %[R_OUT],%[R_IN],1\n\t" \
- " jo 0b\n\t" /* Try vector implemenation again. */ \
+ " jo 0b\n\t" /* Try vector implementation again. */ \
" lochil %[R_RES],%[RES_OUT_FULL]\n\t" /* cc == 1. */ \
" lochih %[R_RES],%[RES_IN_ILL]\n\t" /* cc == 2. */ \
".machine pop" \
" slgr %[R_INLEN],%[R_I]\n\t" \
/* Handle multibyte utf8-char with convert instruction. */ \
"20: cu41 %[R_OUT],%[R_IN]\n\t" \
- " jo 0b\n\t" /* Try vector implemenation again. */ \
+ " jo 0b\n\t" /* Try vector implementation again. */ \
" lochil %[R_RES],%[RES_OUT_FULL]\n\t" /* cc == 1. */ \
" lochih %[R_RES],%[RES_IN_ILL]\n\t" /* cc == 2. */ \
".machine pop" \
lay %r0,-3(%r2) /* Save return-pointer to found zero. */
clgije %r4,1,.Lend /* Skip zero-filling, if found-zero is last
possible character.
- (1 is substracted from r4 below!). */
+ (1 is subtracted from r4 below!). */
aghi %r4,-2 /* mvc with exrl needs count - 1.
(additional -1, see remaining bytes above) */
srlg %r6,%r4,8 /* Split into 256 byte blocks. */
vlef %v16,0(%r5,%r2),0 /* Load one character. */
vlef %v17,0(%r5,%r3),0
lghi %r1,4 /* Loaded byte count is 4. */
- j .Llt_cmp /* Proceed with comparision. */
+ j .Llt_cmp /* Proceed with comparison. */
.Llt16_1:
lcbb %r4,0(%r5,%r3),6 /* Get loaded byte count of s2. */
character in this part of reject
is a zero. */
/* r8>0 -> zero found in this acc-part. */
- vrepf %v18,%v17,0 /* Replicate first char accross all chars. */
+ vrepf %v18,%v17,0 /* Replicate first char across all chars. */
vceqf %v22,%v20,%v17 /* Create a mask (v22) of null chars
by comparing with 0 (v20). */
vsel %v17,%v18,%v17,%v22 /* Replace null chars with first char. */
vlef %v16,0(%r5,%r2),0 /* Load one character. */
lghi %r0,4 /* Loaded byte count is 4. */
vlef %v17,0(%r5,%r3),0
- j .Llt_cmp /* Proceed with comparision. */
+ j .Llt_cmp /* Proceed with comparison. */
.Llastcmp:
- /* Use comparision result only if located within first n characters.
+ /* Use comparison result only if located within first n characters.
%r0: loaded byte count in vreg;
%r5: current_len;
%r4: n;
If first char in this part of accept
is a zero. */
/* r8>0 -> zero found in this acc-part. */
- vrepf %v18,%v17,0 /* Replicate first char accross all chars. */
+ vrepf %v18,%v17,0 /* Replicate first char across all chars. */
vceqf %v22,%v20,%v17 /* Create a mask (v22) of null chars
by comparing with 0 (v20). */
vsel %v17,%v18,%v17,%v22 /* Replace null chars with first char. */
Register usage:
-r0=loaded bytes in first part of s.
- -r1=pointer to last occurence of c or NULL if not found.
+ -r1=pointer to last occurrence of c or NULL if not found.
-r2=s
-r3=c
-r4=tmp
-v16=part of s
-v17=index of found element
-v18=replicated c
- -v19=part of s with last occurence of c.
+ -v19=part of s with last occurrence of c.
-v20=permute pattern
*/
ENTRY(WCSRCHR_Z13)
j .Lloop
.Lfound_first_part:
- /* This code is only executed if the found c/zero is whithin loaded
+ /* This code is only executed if the found c/zero is within loaded
bytes. If no c/zero was found (cc==3) the found index = 16, thus
this code is not called.
Resulting condition code of vector find element equal:
clije %r8,0,.Lslow_add_lbc_end /* End if zero is first character
in this part of accept-string. */
/* r8>0 -> zero found in this acc-part. */
- vrepf %v18,%v17,0 /* Replicate first char accross all chars. */
+ vrepf %v18,%v17,0 /* Replicate first char across all chars. */
vceqf %v22,%v20,%v17 /* Create a mask (v22) of null chars
by comparing with 0 (v20). */
vsel %v17,%v18,%v17,%v22 /* Replace null chars with first char. */
aghi %r5,16
.Llastcmp:
- /* Use comparision result only if located within first n characters.
+ /* Use comparison result only if located within first n characters.
%r5: current_len;
%r4: n;
(current_len - n): [0...16[
_FPU_GETCW (temp);
temp = (temp & FE_ALL_EXCEPT);
- /* Raise the saved exception. Incidently for us the implementation
+ /* Raise the saved exception. Incidentally for us the implementation
defined format of the values in objects of type fexcept_t is the
same as the ones specified using the FE_* constants. */
__fesetenv (envp);
#define ATOMIC_EXCHANGE_USES_CAS __HAVE_64B_ATOMICS
/* Compare and exchange.
- For all "bool" routines, we return FALSE if exchange succesful. */
+ For all "bool" routines, we return FALSE if exchange successful. */
#define __arch_compare_and_exchange_val_int(mem, newval, oldval, model) \
({ \
/* Install new environment. */
__fesetenv (envp);
- /* Raise the safed exception. Incidently for us the implementation
+ /* Raise the saved exception. Incidentally for us the implementation
defined format of the values in objects of type fexcept_t is the
same as the ones specified using the FE_* constants. */
__feraiseexcept ((int) tmp);
/*
* Sparc v9 has divide.
* As divx takes 68 cycles and sdivcc only 36,
- * we use sdivcc eventhough it is deprecated.
+ * we use sdivcc even though it is deprecated.
*/
#include <sysdep.h>
/*
* Sparc v9 has divide.
* As divx takes 68 cycles and sdivcc only 36,
- * we use sdivcc eventhough it is deprecated.
+ * we use sdivcc even though it is deprecated.
*/
#include <sysdep.h>
/*
* Sparc v9 has divide.
* As divx takes 68 cycles and udiv only 37,
- * we use udiv eventhough it is deprecated.
+ * we use udiv even though it is deprecated.
*/
#include <sysdep.h>
/*
* Sparc v9 has divide.
* As divx takes 68 cycles and udiv only 37,
- * we use udiv eventhough it is deprecated.
+ * we use udiv even though it is deprecated.
*/
#include <sysdep.h>
inc 2, %o1
srl %o3, 8, %o4
stb %o4, [%o0] /* have to do bytes, */
- stb %o3, [%o0 + 1] /* don't know dst alingment */
+ stb %o3, [%o0 + 1] /* don't know dst alignment */
inc 2, %o0
dec 2, %o2
update_active (struct cpu_features *cpu_features)
{
/* Copy the cpuid bits to active bits for CPU featuress whose usability
- in user space can be detected without additonal OS support. */
+ in user space can be detected without additional OS support. */
CPU_FEATURE_SET_ACTIVE (cpu_features, SSE3);
CPU_FEATURE_SET_ACTIVE (cpu_features, PCLMULQDQ);
CPU_FEATURE_SET_ACTIVE (cpu_features, SSSE3);
if (l->l_property != lc_property_unknown)
return;
- /* The NT_GNU_PROPERTY_TYPE_0 note must be aliged to 4 bytes in
+ /* The NT_GNU_PROPERTY_TYPE_0 note must be aligned to 4 bytes in
32-bit objects and to 8 bytes in 64-bit objects. Skip notes
with incorrect alignment. */
if (align != (__ELF_NATIVE_CLASS / 8))
/* That's quite simple. Use the `rdtsc' instruction. Note that the value
might not be 100% accurate since there might be some more instructions
running in this moment. This could be changed by using a barrier like
- 'cpuid' right before the `rdtsc' instruciton. But we are not interested
+ 'cpuid' right before the `rdtsc' instruction. But we are not interested
in accurate clock cycles here so we don't do this.
NB: Use __builtin_ia32_rdtsc directly since including <x86intrin.h>
projects / platform / upstream / glibc.git / commitdiff