asm-mem.h@ 103014

Last change on this file since 103014 was 103014, checked in by vboxsync, 15 months ago
iprt/asm-mem.h: Eliminated the ASMMemZeroPage function, replaced the three actual uses in PGMPool with RT_BZERO/PAGE_SIZE.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 12.1 KB

Line
1	/** @file
2	* IPRT - Assembly Memory Functions.
3	*/
4
5	/*
6	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
7	*
8	* This file is part of VirtualBox base platform packages, as
9	* available from https://www.virtualbox.org.
10	*
11	* This program is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU General Public License
13	* as published by the Free Software Foundation, in version 3 of the
14	* License.
15	*
16	* This program is distributed in the hope that it will be useful, but
17	* WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19	* General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, see <https://www.gnu.org/licenses>.
23	*
24	* The contents of this file may alternatively be used under the terms
25	* of the Common Development and Distribution License Version 1.0
26	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
27	* in the VirtualBox distribution, in which case the provisions of the
28	* CDDL are applicable instead of those of the GPL.
29	*
30	* You may elect to license modified versions of this file under the
31	* terms and conditions of either the GPL or the CDDL or both.
32	*
33	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
34	*/
35
36	#ifndef IPRT_INCLUDED_asm_mem_h
37	#define IPRT_INCLUDED_asm_mem_h
38	#ifndef RT_WITHOUT_PRAGMA_ONCE
39	# pragma once
40	#endif
41
42	#include <iprt/cdefs.h>
43	#include <iprt/types.h>
44	#include <iprt/assert.h>
45
46	#if defined(_MSC_VER) && RT_INLINE_ASM_USES_INTRIN
47	/* Emit the intrinsics at all optimization levels. */
48	# include <iprt/sanitized/intrin.h>
49	# pragma intrinsic(__cpuid)
50	# pragma intrinsic(__stosd)
51	# pragma intrinsic(__stosw)
52	# pragma intrinsic(__stosb)
53	# ifdef RT_ARCH_AMD64
54	# pragma intrinsic(__stosq)
55	# endif
56	#endif
57
58
59	/*
60	* Undefine all symbols we have Watcom C/C++ #pragma aux'es for.
61	*/
62	#if defined(__WATCOMC__) && ARCH_BITS == 16 && defined(RT_ARCH_X86)
63	# include "asm-mem-watcom-x86-16.h"
64	#elif defined(__WATCOMC__) && ARCH_BITS == 32 && defined(RT_ARCH_X86)
65	# include "asm-mem-watcom-x86-32.h"
66	#endif
67
68
69
70	/** @defgroup grp_rt_asm_mem ASM - Memory Assembly Routines
71	* @ingroup grp_rt_asm
72	* @{
73	*/
74
75	#if defined(DOXYGEN_RUNNING) \|\| defined(RT_ASM_INCLUDE_PAGE_SIZE)
76	/** @def RT_ASM_PAGE_SIZE
77	* We try avoid dragging in iprt/param.h here.
78	* @internal
79	*/
80	# if defined(RT_ARCH_SPARC64)
81	# define RT_ASM_PAGE_SIZE 0x2000
82	# if defined(PAGE_SIZE) && !defined(NT_INCLUDED)
83	# if PAGE_SIZE != 0x2000
84	# error "PAGE_SIZE is not 0x2000!"
85	# endif
86	# endif
87	# elif defined(RT_ARCH_ARM64) && defined(RT_OS_DARWIN)
88	# define RT_ASM_PAGE_SIZE 0x4000
89	# if defined(PAGE_SIZE) && !defined(NT_INCLUDED) && !defined(_MACH_ARM_VM_PARAM_H_)
90	# if PAGE_SIZE != 0x4000
91	# error "PAGE_SIZE is not 0x4000!"
92	# endif
93	# endif
94	# else
95	# define RT_ASM_PAGE_SIZE 0x1000
96	# if defined(PAGE_SIZE) && !defined(NT_INCLUDED) && !defined(RT_OS_LINUX) && !defined(RT_ARCH_ARM64)
97	# if PAGE_SIZE != 0x1000
98	# error "PAGE_SIZE is not 0x1000!"
99	# endif
100	# endif
101	# endif
102	#endif
103
104
105	/**
106	* Zeros a memory block with a 32-bit aligned size.
107	*
108	* @param pv Pointer to the memory block.
109	* @param cb Number of bytes in the block. This MUST be aligned on 32-bit!
110	*/
111	#if (RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN) \|\| (!defined(RT_ARCH_AMD64) && !defined(RT_ARCH_X86))
112	RT_ASM_DECL_PRAGMA_WATCOM(void) ASMMemZero32(volatile void RT_FAR *pv, size_t cb) RT_NOTHROW_PROTO;
113	#else
114	DECLINLINE(void) ASMMemZero32(volatile void RT_FAR *pv, size_t cb) RT_NOTHROW_DEF
115	{
116	# if RT_INLINE_ASM_USES_INTRIN
117	# ifdef RT_ARCH_AMD64
118	if (!(cb & 7))
119	__stosq((unsigned __int64 RT_FAR *)pv, 0, cb / 8);
120	else
121	# endif
122	__stosd((unsigned long RT_FAR *)pv, 0, cb / 4);
123
124	# elif RT_INLINE_ASM_GNU_STYLE
125	__asm__ __volatile__("rep stosl"
126	: "=D" (pv),
127	"=c" (cb)
128	: "0" (pv),
129	"1" (cb >> 2),
130	"a" (0)
131	: "memory");
132	# else
133	__asm
134	{
135	xor eax, eax
136	# ifdef RT_ARCH_AMD64
137	mov rcx, [cb]
138	shr rcx, 2
139	mov rdi, [pv]
140	# else
141	mov ecx, [cb]
142	shr ecx, 2
143	mov edi, [pv]
144	# endif
145	rep stosd
146	}
147	# endif
148	}
149	#endif
150
151
152	/**
153	* Fills a memory block with a 32-bit aligned size.
154	*
155	* @param pv Pointer to the memory block.
156	* @param cb Number of bytes in the block. This MUST be aligned on 32-bit!
157	* @param u32 The value to fill with.
158	*/
159	#if (RT_INLINE_ASM_EXTERNAL && !RT_INLINE_ASM_USES_INTRIN) \|\| (!defined(RT_ARCH_AMD64) && !defined(RT_ARCH_X86))
160	RT_ASM_DECL_PRAGMA_WATCOM(void) ASMMemFill32(volatile void RT_FAR *pv, size_t cb, uint32_t u32) RT_NOTHROW_PROTO;
161	#else
162	DECLINLINE(void) ASMMemFill32(volatile void RT_FAR *pv, size_t cb, uint32_t u32) RT_NOTHROW_DEF
163	{
164	# if RT_INLINE_ASM_USES_INTRIN
165	# ifdef RT_ARCH_AMD64
166	if (!(cb & 7))
167	__stosq((unsigned __int64 RT_FAR *)pv, RT_MAKE_U64(u32, u32), cb / 8);
168	else
169	# endif
170	__stosd((unsigned long RT_FAR *)pv, u32, cb / 4);
171
172	# elif RT_INLINE_ASM_GNU_STYLE
173	__asm__ __volatile__("rep stosl"
174	: "=D" (pv),
175	"=c" (cb)
176	: "0" (pv),
177	"1" (cb >> 2),
178	"a" (u32)
179	: "memory");
180	# else
181	__asm
182	{
183	# ifdef RT_ARCH_AMD64
184	mov rcx, [cb]
185	shr rcx, 2
186	mov rdi, [pv]
187	# else
188	mov ecx, [cb]
189	shr ecx, 2
190	mov edi, [pv]
191	# endif
192	mov eax, [u32]
193	rep stosd
194	}
195	# endif
196	}
197	#endif
198
199
200	/**
201	* Checks if a memory block is all zeros.
202	*
203	* @returns Pointer to the first non-zero byte.
204	* @returns NULL if all zero.
205	*
206	* @param pv Pointer to the memory block.
207	* @param cb Number of bytes in the block.
208	*/
209	#if !defined(RDESKTOP) && (!defined(RT_OS_LINUX) \|\| !defined(__KERNEL__))
210	DECLASM(void RT_FAR ) ASMMemFirstNonZero(void const RT_FAR pv, size_t cb) RT_NOTHROW_PROTO;
211	#else
212	DECLINLINE(void RT_FAR ) ASMMemFirstNonZero(void const RT_FAR pv, size_t cb) RT_NOTHROW_DEF
213	{
214	/** @todo replace with ASMMemFirstNonZero-generic.cpp in kernel modules. */
215	uint8_t const pb = (uint8_t const RT_FAR )pv;
216	for (; cb; cb--, pb++)
217	if (RT_LIKELY(*pb == 0))
218	{ /* likely */ }
219	else
220	return (void RT_FAR *)pb;
221	return NULL;
222	}
223	#endif
224
225
226	/**
227	* Checks if a memory block is all zeros.
228	*
229	* @returns true if zero, false if not.
230	*
231	* @param pv Pointer to the memory block.
232	* @param cb Number of bytes in the block.
233	*
234	* @sa ASMMemFirstNonZero
235	*/
236	DECLINLINE(bool) ASMMemIsZero(void const RT_FAR *pv, size_t cb) RT_NOTHROW_DEF
237	{
238	return ASMMemFirstNonZero(pv, cb) == NULL;
239	}
240
241
242	/**
243	* Checks if a memory block is filled with the specified byte, returning the
244	* first mismatch.
245	*
246	* This is sort of an inverted memchr.
247	*
248	* @returns Pointer to the byte which doesn't equal u8.
249	* @returns NULL if all equal to u8.
250	*
251	* @param pv Pointer to the memory block.
252	* @param cb Number of bytes in the block.
253	* @param u8 The value it's supposed to be filled with.
254	*
255	* @remarks No alignment requirements.
256	*/
257	#if (!defined(RT_OS_LINUX) \|\| !defined(__KERNEL__)) \
258	&& (!defined(RT_OS_FREEBSD) \|\| !defined(_KERNEL))
259	DECLASM(void ) ASMMemFirstMismatchingU8(void const RT_FAR pv, size_t cb, uint8_t u8) RT_NOTHROW_PROTO;
260	#else
261	DECLINLINE(void ) ASMMemFirstMismatchingU8(void const RT_FAR pv, size_t cb, uint8_t u8) RT_NOTHROW_DEF
262	{
263	/** @todo replace with ASMMemFirstMismatchingU8-generic.cpp in kernel modules. */
264	uint8_t const pb = (uint8_t const RT_FAR )pv;
265	for (; cb; cb--, pb++)
266	if (RT_LIKELY(*pb == u8))
267	{ /* likely */ }
268	else
269	return (void *)pb;
270	return NULL;
271	}
272	#endif
273
274
275	/**
276	* Checks if a memory block is filled with the specified byte.
277	*
278	* @returns true if all matching, false if not.
279	*
280	* @param pv Pointer to the memory block.
281	* @param cb Number of bytes in the block.
282	* @param u8 The value it's supposed to be filled with.
283	*
284	* @remarks No alignment requirements.
285	*/
286	DECLINLINE(bool) ASMMemIsAllU8(void const RT_FAR *pv, size_t cb, uint8_t u8) RT_NOTHROW_DEF
287	{
288	return ASMMemFirstMismatchingU8(pv, cb, u8) == NULL;
289	}
290
291
292	/**
293	* Checks if a memory block is filled with the specified 32-bit value.
294	*
295	* This is a sort of inverted memchr.
296	*
297	* @returns Pointer to the first value which doesn't equal u32.
298	* @returns NULL if all equal to u32.
299	*
300	* @param pv Pointer to the memory block.
301	* @param cb Number of bytes in the block. This MUST be aligned on 32-bit!
302	* @param u32 The value it's supposed to be filled with.
303	*/
304	DECLINLINE(uint32_t RT_FAR ) ASMMemFirstMismatchingU32(void const RT_FAR pv, size_t cb, uint32_t u32) RT_NOTHROW_DEF
305	{
306	/** @todo rewrite this in inline assembly? */
307	uint32_t const RT_FAR pu32 = (uint32_t const RT_FAR )pv;
308	for (; cb; cb -= 4, pu32++)
309	if (RT_LIKELY(*pu32 == u32))
310	{ /* likely */ }
311	else
312	return (uint32_t RT_FAR *)pu32;
313	return NULL;
314	}
315
316
317	/**
318	* Probes a byte pointer for read access.
319	*
320	* While the function will not fault if the byte is not read accessible,
321	* the idea is to do this in a safe place like before acquiring locks
322	* and such like.
323	*
324	* Also, this functions guarantees that an eager compiler is not going
325	* to optimize the probing away.
326	*
327	* @param pvByte Pointer to the byte.
328	*/
329	#if RT_INLINE_ASM_EXTERNAL_TMP_ARM
330	RT_ASM_DECL_PRAGMA_WATCOM(uint8_t) ASMProbeReadByte(const void RT_FAR *pvByte) RT_NOTHROW_PROTO;
331	#else
332	DECLINLINE(uint8_t) ASMProbeReadByte(const void RT_FAR *pvByte) RT_NOTHROW_DEF
333	{
334	# if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
335	uint8_t u8;
336	# if RT_INLINE_ASM_GNU_STYLE
337	__asm__ __volatile__("movb %1, %0\n\t"
338	: "=q" (u8)
339	: "m" ((const uint8_t )pvByte));
340	# else
341	__asm
342	{
343	# ifdef RT_ARCH_AMD64
344	mov rax, [pvByte]
345	mov al, [rax]
346	# else
347	mov eax, [pvByte]
348	mov al, [eax]
349	# endif
350	mov [u8], al
351	}
352	# endif
353	return u8;
354
355	# elif defined(RT_ARCH_ARM64) \|\| defined(RT_ARCH_ARM32)
356	uint32_t u32;
357	__asm__ __volatile__("Lstart_ASMProbeReadByte_%=:\n\t"
358	# if defined(RT_ARCH_ARM64)
359	"ldxrb %w[uDst], %[pMem]\n\t"
360	# else
361	"ldrexb %[uDst], %[pMem]\n\t"
362	# endif
363	: [uDst] "=&r" (u32)
364	: [pMem] "Q" ((uint8_t const )pvByte));
365	return (uint8_t)u32;
366
367	# else
368	# error "Port me"
369	# endif
370	}
371	#endif
372
373	#ifdef RT_ASM_PAGE_SIZE
374	/**
375	* Probes a buffer for read access page by page.
376	*
377	* While the function will fault if the buffer is not fully read
378	* accessible, the idea is to do this in a safe place like before
379	* acquiring locks and such like.
380	*
381	* Also, this functions guarantees that an eager compiler is not going
382	* to optimize the probing away.
383	*
384	* @param pvBuf Pointer to the buffer.
385	* @param cbBuf The size of the buffer in bytes. Must be >= 1.
386	*/
387	DECLINLINE(void) ASMProbeReadBuffer(const void RT_FAR *pvBuf, size_t cbBuf) RT_NOTHROW_DEF
388	{
389	/** @todo verify that the compiler actually doesn't optimize this away. (intel & gcc) */
390	/* the first byte */
391	const uint8_t RT_FAR pu8 = (const uint8_t RT_FAR )pvBuf;
392	ASMProbeReadByte(pu8);
393
394	/* the pages in between pages. */
395	while (cbBuf > RT_ASM_PAGE_SIZE)
396	{
397	ASMProbeReadByte(pu8);
398	cbBuf -= RT_ASM_PAGE_SIZE;
399	pu8 += RT_ASM_PAGE_SIZE;
400	}
401
402	/* the last byte */
403	ASMProbeReadByte(pu8 + cbBuf - 1);
404	}
405	#endif
406
407	/** @} */
408
409	/*
410	* Include #pragma aux definitions for Watcom C/C++.
411	*/
412	#if defined(__WATCOMC__) && ARCH_BITS == 16 && defined(RT_ARCH_X86)
413	# define IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
414	# undef IPRT_INCLUDED_asm_mem_watcom_x86_16_h
415	# include "asm-mem-watcom-x86-16.h"
416	#elif defined(__WATCOMC__) && ARCH_BITS == 32 && defined(RT_ARCH_X86)
417	# define IPRT_ASM_WATCOM_X86_32_WITH_PRAGMAS
418	# undef IPRT_INCLUDED_asm_mem_watcom_x86_32_h
419	# include "asm-mem-watcom-x86-32.h"
420	#endif
421
422	#endif /* !IPRT_INCLUDED_asm_mem_h */
423

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/include/iprt/asm-mem.h@ 103014

Download in other formats: