ldr.h@ 96407

Last change on this file since 96407 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 25.6 KB

Line
1	/* $Id: ldr.h 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* IPRT - Loader Internals.
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37	#ifndef IPRT_INCLUDED_INTERNAL_ldr_h
38	#define IPRT_INCLUDED_INTERNAL_ldr_h
39	#ifndef RT_WITHOUT_PRAGMA_ONCE
40	# pragma once
41	#endif
42
43	#include <iprt/types.h>
44	#include "internal/magics.h"
45
46	RT_C_DECLS_BEGIN
47
48
49	/*******************************************************************************
50	* Defined Constants And Macros *
51	*******************************************************************************/
52	#ifdef DOXYGEN_RUNNING
53	/** @def LDR_WITH_NATIVE
54	* Define this to get native support. */
55	# define LDR_WITH_NATIVE
56
57	/** @def LDR_WITH_ELF32
58	* Define this to get 32-bit ELF support. */
59	# define LDR_WITH_ELF32
60
61	/** @def LDR_WITH_ELF64
62	* Define this to get 64-bit ELF support. */
63	# define LDR_WITH_ELF64
64
65	/** @def LDR_WITH_PE
66	* Define this to get 32-bit and 64-bit PE support. */
67	# define LDR_WITH_PE
68
69	/** @def LDR_WITH_LX
70	* Define this to get LX support. */
71	# define LDR_WITH_LX
72
73	/** @def LDR_WITH_MACHO
74	* Define this to get mach-o support (not implemented yet). */
75	# define LDR_WITH_MACHO
76	#endif /* DOXYGEN_RUNNING */
77
78	#if defined(LDR_WITH_ELF32) \|\| defined(LDR_WITH_ELF64)
79	/** @def LDR_WITH_ELF
80	* This is defined if any of the ELF versions is requested.
81	*/
82	# define LDR_WITH_ELF
83	#endif
84
85	/* These two may clash with winnt.h. */
86	#undef IMAGE_DOS_SIGNATURE
87	#undef IMAGE_NT_SIGNATURE
88	#undef IMAGE_LX_SIGNATURE
89
90
91	/** Little endian uint32_t ELF signature ("\x7fELF"). */
92	#define IMAGE_ELF_SIGNATURE (0x7f \| ('E' << 8) \| ('L' << 16) \| ('F' << 24))
93	/** Little endian uint32_t PE signature ("PE\0\0"). */
94	#define IMAGE_NT_SIGNATURE 0x00004550
95	/** Little endian uint16_t LX signature ("LX") */
96	#define IMAGE_LX_SIGNATURE ('L' \| ('X' << 8))
97	/** Little endian uint16_t LE signature ("LE") */
98	#define IMAGE_LE_SIGNATURE ('L' \| ('E' << 8))
99	/** Little endian uint16_t NE signature ("NE") */
100	#define IMAGE_NE_SIGNATURE ('N' \| ('E' << 8))
101	/** Little endian uint16_t MZ signature ("MZ"). */
102	#define IMAGE_DOS_SIGNATURE ('M' \| ('Z' << 8))
103
104
105	/** Kind of missing flag. */
106	#define RTMEM_PROT_WRITECOPY RTMEM_PROT_WRITE
107
108
109	/** @name Load symbol kind flags (from kStuff, expose later).
110	* @{ */
111	/** The bitness doesn't matter. */
112	#define RTLDRSYMKIND_NO_BIT UINT32_C(0x00000000)
113	/** 16-bit symbol. */
114	#define RTLDRSYMKIND_16BIT UINT32_C(0x00000001)
115	/** 32-bit symbol. */
116	#define RTLDRSYMKIND_32BIT UINT32_C(0x00000002)
117	/** 64-bit symbol. */
118	#define RTLDRSYMKIND_64BIT UINT32_C(0x00000003)
119	/** Mask out the bit.*/
120	#define RTLDRSYMKIND_BIT_MASK UINT32_C(0x00000003)
121	/** We don't know the type of symbol. */
122	#define RTLDRSYMKIND_NO_TYPE UINT32_C(0x00000000)
123	/** The symbol is a code object (method/function/procedure/whateveryouwannacallit). */
124	#define RTLDRSYMKIND_CODE UINT32_C(0x00000010)
125	/** The symbol is a data object. */
126	#define RTLDRSYMKIND_DATA UINT32_C(0x00000020)
127	/** Mask out the symbol type. */
128	#define RTLDRSYMKIND_TYPE_MASK UINT32_C(0x00000030)
129	/** Valid symbol kind mask. */
130	#define RTLDRSYMKIND_MASK UINT32_C(0x00000033)
131	/** Weak symbol. */
132	#define RTLDRSYMKIND_WEAK UINT32_C(0x00000100)
133	/** Forwarder symbol. */
134	#define RTLDRSYMKIND_FORWARDER UINT32_C(0x00000200)
135	/** Request a flat symbol address. */
136	#define RTLDRSYMKIND_REQ_FLAT UINT32_C(0x00000000)
137	/** Request a segmented symbol address. */
138	#define RTLDRSYMKIND_REQ_SEGMENTED UINT32_C(0x40000000)
139	/** Request type mask. */
140	#define RTLDRSYMKIND_REQ_TYPE_MASK UINT32_C(0x40000000)
141	/** @} */
142
143	/** Align a RTLDRADDR value. */
144	#define RTLDR_ALIGN_ADDR(val, align) ( ((val) + ((align) - 1)) & ~(RTLDRADDR)((align) - 1) )
145
146	/** Special base address value alias for the link address.
147	* Consider propagating... */
148	#define RTLDR_BASEADDRESS_LINK (~(RTLDRADDR)1)
149
150
151
152	/*******************************************************************************
153	* Structures and Typedefs *
154	*******************************************************************************/
155	/**
156	* Loader state.
157	*/
158	typedef enum RTLDRSTATE
159	{
160	/** Invalid. */
161	LDR_STATE_INVALID = 0,
162	/** Opened. */
163	LDR_STATE_OPENED,
164	/** The image can no longer be relocated. */
165	LDR_STATE_DONE,
166	/** The image was loaded, not opened. */
167	LDR_STATE_LOADED,
168	/** The usual 32-bit hack. */
169	LDR_STATE_32BIT_HACK = 0x7fffffff
170	} RTLDRSTATE;
171
172
173	/**
174	* CPU models (from kStuff, expose later some time).
175	*/
176	typedef enum RTLDRCPU
177	{
178	/** The usual invalid cpu. */
179	RTLDRCPU_INVALID = 0,
180
181	/** @name K_ARCH_X86_16
182	* @{ */
183	RTLDRCPU_I8086,
184	RTLDRCPU_I8088,
185	RTLDRCPU_I80186,
186	RTLDRCPU_I80286,
187	RTLDRCPU_I386_16,
188	RTLDRCPU_I486_16,
189	RTLDRCPU_I486SX_16,
190	RTLDRCPU_I586_16,
191	RTLDRCPU_I686_16,
192	RTLDRCPU_P4_16,
193	RTLDRCPU_CORE2_16,
194	RTLDRCPU_K6_16,
195	RTLDRCPU_K7_16,
196	RTLDRCPU_K8_16,
197	RTLDRCPU_FIRST_X86_16 = RTLDRCPU_I8086,
198	RTLDRCPU_LAST_X86_16 = RTLDRCPU_K8_16,
199	/** @} */
200
201	/** @name K_ARCH_X86_32
202	* @{ */
203	RTLDRCPU_X86_32_BLEND,
204	RTLDRCPU_I386,
205	RTLDRCPU_I486,
206	RTLDRCPU_I486SX,
207	RTLDRCPU_I586,
208	RTLDRCPU_I686,
209	RTLDRCPU_P4,
210	RTLDRCPU_CORE2_32,
211	RTLDRCPU_K6,
212	RTLDRCPU_K7,
213	RTLDRCPU_K8_32,
214	RTLDRCPU_FIRST_X86_32 = RTLDRCPU_I386,
215	RTLDRCPU_LAST_X86_32 = RTLDRCPU_K8_32,
216	/** @} */
217
218	/** @name K_ARCH_AMD64
219	* @{ */
220	RTLDRCPU_AMD64_BLEND,
221	RTLDRCPU_K8,
222	RTLDRCPU_P4_64,
223	RTLDRCPU_CORE2,
224	RTLDRCPU_FIRST_AMD64 = RTLDRCPU_K8,
225	RTLDRCPU_LAST_AMD64 = RTLDRCPU_CORE2,
226	/** @} */
227
228	/** @name K_ARCH_ARM64
229	* @{ */
230	RTLDRCPU_ARM64_BLEND,
231	RTLDRCPU_ARM64_V8,
232	RTLDRCPU_ARM64E,
233	RTLDRCPU_FIRST_ARM64 = RTLDRCPU_ARM64_V8,
234	RTLDRCPU_LAST_ARM64 = RTLDRCPU_ARM64E,
235	/** @} */
236
237	/** The end of the valid cpu values (exclusive). */
238	RTLDRCPU_END,
239	/** Hack to blow the type up to 32-bit. */
240	RTLDRCPU_32BIT_HACK = 0x7fffffff
241	} RTLDRCPU;
242
243
244	/** Pointer to a loader item. */
245	typedef struct RTLDRMODINTERNAL *PRTLDRMODINTERNAL;
246
247	/**
248	* Loader module operations.
249	*/
250	typedef struct RTLDROPS
251	{
252	/** The name of the executable format. */
253	const char *pszName;
254
255	/**
256	* Release any resources attached to the module.
257	* The caller will do RTMemFree on pMod on return.
258	*
259	* @returns iprt status code.
260	* @param pMod Pointer to the loader module structure.
261	* @remark Compulsory entry point.
262	*/
263	DECLCALLBACKMEMBER(int, pfnClose,(PRTLDRMODINTERNAL pMod));
264
265	/**
266	* Gets a simple symbol.
267	* This entrypoint can be omitted if RTLDROPS::pfnGetSymbolEx() is provided.
268	*
269	* @returns iprt status code.
270	* @param pMod Pointer to the loader module structure.
271	* @param pszSymbol The symbol name.
272	* @param ppvValue Where to store the symbol value.
273	*/
274	DECLCALLBACKMEMBER(int, pfnGetSymbol,(PRTLDRMODINTERNAL pMod, const char pszSymbol, void *ppvValue));
275
276	/**
277	* Called when we're done with getting bits and relocating them.
278	* This is used to release resources used by the loader to support those actions.
279	*
280	* After this call none of the extended loader functions can be called.
281	*
282	* @returns iprt status code.
283	* @param pMod Pointer to the loader module structure.
284	* @remark This is an optional entry point.
285	*/
286	DECLCALLBACKMEMBER(int, pfnDone,(PRTLDRMODINTERNAL pMod));
287
288	/**
289	* Enumerates the symbols exported by the module.
290	*
291	* @returns iprt status code, which might have been returned by pfnCallback.
292	* @param pMod Pointer to the loader module structure.
293	* @param fFlags Flags indicating what to return and such.
294	* @param pvBits Pointer to the bits returned by RTLDROPS::pfnGetBits(), optional.
295	* @param BaseAddress The image base addressto use when calculating the symbol values.
296	* @param pfnCallback The callback function which each symbol is to be
297	* fed to.
298	* @param pvUser User argument to pass to the enumerator.
299	* @remark This is an optional entry point.
300	*/
301	DECLCALLBACKMEMBER(int, pfnEnumSymbols,(PRTLDRMODINTERNAL pMod, unsigned fFlags, const void *pvBits, RTUINTPTR BaseAddress,
302	PFNRTLDRENUMSYMS pfnCallback, void *pvUser));
303
304
305	/* extended functions: */
306
307	/**
308	* Gets the size of the loaded image (i.e. in memory).
309	*
310	* @returns in memory size, in bytes.
311	* @returns ~(size_t)0 if it's not an extended image.
312	* @param pMod Pointer to the loader module structure.
313	* @remark Extended loader feature.
314	*/
315	DECLCALLBACKMEMBER(size_t, pfnGetImageSize,(PRTLDRMODINTERNAL pMod));
316
317	/**
318	* Gets the image bits fixed up for a specified address.
319	*
320	* @returns iprt status code.
321	* @param pMod Pointer to the loader module structure.
322	* @param pvBits Where to store the bits. The size of this buffer is equal or
323	* larger to the value returned by pfnGetImageSize().
324	* @param BaseAddress The base address which the image should be fixed up to.
325	* @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
326	* @param pvUser User argument to pass to the callback.
327	* @remark Extended loader feature.
328	*/
329	DECLCALLBACKMEMBER(int, pfnGetBits,(PRTLDRMODINTERNAL pMod, void pvBits, RTUINTPTR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void pvUser));
330
331	/**
332	* Relocate bits obtained using pfnGetBits to a new address.
333	*
334	* @returns iprt status code.
335	* @param pMod Pointer to the loader module structure.
336	* @param pvBits Where to store the bits. The size of this buffer is equal or
337	* larger to the value returned by pfnGetImageSize().
338	* @param NewBaseAddress The base address which the image should be fixed up to.
339	* @param OldBaseAddress The base address which the image is currently fixed up to.
340	* @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
341	* @param pvUser User argument to pass to the callback.
342	* @remark Extended loader feature.
343	*/
344	DECLCALLBACKMEMBER(int, pfnRelocate,(PRTLDRMODINTERNAL pMod, void pvBits, RTUINTPTR NewBaseAddress, RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void pvUser));
345
346	/**
347	* Gets a symbol with special base address and stuff.
348	* This entrypoint can be omitted if RTLDROPS::pfnGetSymbolEx() is provided and the special BaseAddress feature isn't supported.
349	*
350	* @returns iprt status code.
351	* @retval VERR_LDR_FORWARDER forwarder, use pfnQueryForwarderInfo. Buffer size
352	* in @a pValue.
353	* @param pMod Pointer to the loader module structure.
354	* @param pvBits Pointer to bits returned by RTLDROPS::pfnGetBits(), optional.
355	* @param BaseAddress The image base address to use when calculating the symbol value.
356	* @param iOrdinal Symbol table ordinal, UINT32_MAX if the symbol name
357	* should be used.
358	* @param pszSymbol The symbol name.
359	* @param pValue Where to store the symbol value.
360	* @remark Extended loader feature.
361	*/
362	DECLCALLBACKMEMBER(int, pfnGetSymbolEx,(PRTLDRMODINTERNAL pMod, const void *pvBits, RTUINTPTR BaseAddress,
363	uint32_t iOrdinal, const char pszSymbol, RTUINTPTR pValue));
364
365	/**
366	* Query forwarder information on the specified symbol.
367	*
368	* This is an optional entrypoint.
369	*
370	* @returns iprt status code.
371	* @param pMod Pointer to the loader module structure.
372	* @param pvBits Pointer to bits returned by RTLDROPS::pfnGetBits(),
373	* optional.
374	* @param iOrdinal Symbol table ordinal of the forwarded symbol to query.
375	* UINT32_MAX if the symbol name should be used.
376	* @param pszSymbol The symbol name of the forwarded symbol to query.
377	* @param pInfo Where to return the forwarder information.
378	* @param cbInfo The size of the pInfo buffer. The pfnGetSymbolEx
379	* entrypoint returns the required size in @a pValue when
380	* the return code is VERR_LDR_FORWARDER.
381	* @remark Extended loader feature.
382	*/
383	DECLCALLBACKMEMBER(int, pfnQueryForwarderInfo,(PRTLDRMODINTERNAL pMod, const void *pvBits, uint32_t iOrdinal,
384	const char *pszSymbol, PRTLDRIMPORTINFO pInfo, size_t cbInfo));
385
386	/**
387	* Enumerates the debug info contained in the module.
388	*
389	* @returns iprt status code, which might have been returned by pfnCallback.
390	* @param pMod Pointer to the loader module structure.
391	* @param pvBits Pointer to the bits returned by RTLDROPS::pfnGetBits(), optional.
392	* @param pfnCallback The callback function which each debug info part is
393	* to be fed to.
394	* @param pvUser User argument to pass to the enumerator.
395	* @remark This is an optional entry point that can be NULL.
396	*/
397	DECLCALLBACKMEMBER(int, pfnEnumDbgInfo,(PRTLDRMODINTERNAL pMod, const void *pvBits,
398	PFNRTLDRENUMDBG pfnCallback, void *pvUser));
399
400	/**
401	* Enumerates the segments in the module.
402	*
403	* @returns iprt status code, which might have been returned by pfnCallback.
404	* @param pMod Pointer to the loader module structure.
405	* @param pfnCallback The callback function which each debug info part is
406	* to be fed to.
407	* @param pvUser User argument to pass to the enumerator.
408	* @remark This is an optional entry point that can be NULL.
409	*/
410	DECLCALLBACKMEMBER(int, pfnEnumSegments,(PRTLDRMODINTERNAL pMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser));
411
412	/**
413	* Converts a link address to a segment:offset address.
414	*
415	* @returns IPRT status code.
416	*
417	* @param pMod Pointer to the loader module structure.
418	* @param LinkAddress The link address to convert.
419	* @param piSeg Where to return the segment index.
420	* @param poffSeg Where to return the segment offset.
421	* @remark This is an optional entry point that can be NULL.
422	*/
423	DECLCALLBACKMEMBER(int, pfnLinkAddressToSegOffset,(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress,
424	uint32_t *piSeg, PRTLDRADDR poffSeg));
425
426	/**
427	* Converts a link address to a RVA.
428	*
429	* @returns IPRT status code.
430	*
431	* @param pMod Pointer to the loader module structure.
432	* @param LinkAddress The link address to convert.
433	* @param pRva Where to return the RVA.
434	* @remark This is an optional entry point that can be NULL.
435	*/
436	DECLCALLBACKMEMBER(int, pfnLinkAddressToRva,(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva));
437
438	/**
439	* Converts a segment:offset to a RVA.
440	*
441	* @returns IPRT status code.
442	*
443	* @param pMod Pointer to the loader module structure.
444	* @param iSeg The segment index.
445	* @param offSeg The segment offset.
446	* @param pRva Where to return the RVA.
447	* @remark This is an optional entry point that can be NULL.
448	*/
449	DECLCALLBACKMEMBER(int, pfnSegOffsetToRva,(PRTLDRMODINTERNAL pMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva));
450
451	/**
452	* Converts a RVA to a segment:offset.
453	*
454	* @returns IPRT status code.
455	*
456	* @param pMod Pointer to the loader module structure.
457	* @param Rva The RVA to convert.
458	* @param piSeg Where to return the segment index.
459	* @param poffSeg Where to return the segment offset.
460	* @remark This is an optional entry point that can be NULL.
461	*/
462	DECLCALLBACKMEMBER(int, pfnRvaToSegOffset,(PRTLDRMODINTERNAL pMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg));
463
464	/**
465	* Reads a debug info part (section) from the image.
466	*
467	* This is primarily needed for getting DWARF sections in ELF image with fixups
468	* applied and won't be required by most other loader backends.
469	*
470	* @returns IPRT status code.
471	*
472	* @param pMod Pointer to the loader module structure.
473	* @param pvBuf The buffer to read into.
474	* @param iDbgInfo The debug info ordinal number if the request
475	* corresponds exactly to a debug info part from
476	* pfnEnumDbgInfo. Otherwise, pass UINT32_MAX.
477	* @param off The offset into the image file.
478	* @param cb The number of bytes to read.
479	*/
480	DECLCALLBACKMEMBER(int, pfnReadDbgInfo,(PRTLDRMODINTERNAL pMod, uint32_t iDbgInfo, RTFOFF off, size_t cb, void *pvBuf));
481
482	/**
483	* Generic method for querying image properties.
484	*
485	* @returns IPRT status code.
486	* @retval VERR_NOT_SUPPORTED if the property query isn't supported (either all
487	* or that specific property).
488	* @retval VERR_NOT_FOUND the property was not found in the module.
489	*
490	* @param pMod Pointer to the loader module structure.
491	* @param enmProp The property to query (valid).
492	* @param pvBits Pointer to the bits returned by
493	* RTLDROPS::pfnGetBits(), optional.
494	* @param pvBuf Pointer to the input / output buffer. This is valid.
495	* Normally only used for returning data, but in some
496	* cases it also holds input.
497	* @param cbBuf The size of the buffer (valid as per
498	* property).
499	* @param pcbRet The number of bytes actually returned. If
500	* VERR_BUFFER_OVERFLOW is returned, this is set to the
501	* required buffer size.
502	*/
503	DECLCALLBACKMEMBER(int, pfnQueryProp,(PRTLDRMODINTERNAL pMod, RTLDRPROP enmProp, void const *pvBits,
504	void pvBuf, size_t cbBuf, size_t pcbRet));
505
506	/**
507	* Verify the image signature.
508	*
509	* This may permform additional integrity checks on the image structures that
510	* was not done when opening the image.
511	*
512	* @returns IPRT status code.
513	* @retval VERR_LDRVI_NOT_SIGNED if not signed.
514	*
515	* @param pMod Pointer to the loader module structure.
516	* @param pfnCallback Callback that does the signature and certificate
517	* verification.
518	* @param pvUser User argument for the callback.
519	* @param pErrInfo Pointer to an error info buffer. Optional.
520	*/
521	DECLCALLBACKMEMBER(int, pfnVerifySignature,(PRTLDRMODINTERNAL pMod, PFNRTLDRVALIDATESIGNEDDATA pfnCallback, void *pvUser,
522	PRTERRINFO pErrInfo));
523
524	/**
525	* Calculate the image hash according the image signing rules.
526	*
527	* @returns IPRT status code.
528	* @param pMod The module handle.
529	* @param enmDigest Which kind of digest.
530	* @param pabHash Where to store the image hash.
531	* @param cbHash Size of the buffer @a pabHash points at. This has
532	* been validated to be at least the required size.
533	*/
534	DECLCALLBACKMEMBER(int, pfnHashImage,(PRTLDRMODINTERNAL pMod, RTDIGESTTYPE enmDigest, uint8_t *pabHash, size_t cbHash));
535
536	/**
537	* Try use unwind information to unwind one frame.
538	*
539	* @returns IPRT status code. Last informational status from stack reader callback.
540	* @retval VERR_DBG_NO_UNWIND_INFO if the module contains no unwind information.
541	* @retval VERR_DBG_UNWIND_INFO_NOT_FOUND if no unwind information was found
542	* for the location given by iSeg:off.
543	*
544	* @param pMod Pointer to the module structure.
545	* @param pvBits Pointer to the bits returned by
546	* RTLDROPS::pfnGetBits(), optional.
547	* @param iSeg The segment number of the program counter. UINT32_MAX for RVA.
548	* @param off The offset into @a iSeg. Together with @a iSeg
549	* this corresponds to the RTDBGUNWINDSTATE::uPc
550	* value pointed to by @a pState.
551	* @param pState The unwind state to work.
552	*
553	* @sa RTLdrUnwindFrame, RTDbgModUnwindFrame
554	*/
555	DECLCALLBACKMEMBER(int, pfnUnwindFrame,(PRTLDRMODINTERNAL pMod, void const *pvBits, uint32_t iSeg, RTUINTPTR off,
556	PRTDBGUNWINDSTATE pState));
557
558	/** Dummy entry to make sure we've initialized it all. */
559	RTUINT uDummy;
560	} RTLDROPS;
561	typedef RTLDROPS *PRTLDROPS;
562	typedef const RTLDROPS *PCRTLDROPS;
563
564
565	/**
566	* Loader module core.
567	*/
568	typedef struct RTLDRMODINTERNAL
569	{
570	/** The loader magic value (RTLDRMOD_MAGIC). */
571	uint32_t u32Magic;
572	/** State. */
573	RTLDRSTATE eState;
574	/** Loader ops. */
575	PCRTLDROPS pOps;
576	/** Pointer to the reader instance. This is NULL for native image. */
577	PRTLDRREADER pReader;
578	/** Image format. */
579	RTLDRFMT enmFormat;
580	/** Image type. */
581	RTLDRTYPE enmType;
582	/** Image endianness. */
583	RTLDRENDIAN enmEndian;
584	/** Image target architecture. */
585	RTLDRARCH enmArch;
586	} RTLDRMODINTERNAL;
587
588
589	/**
590	* Validates that a loader module handle is valid.
591	*
592	* @returns true if valid.
593	* @returns false if invalid.
594	* @param hLdrMod The loader module handle.
595	*/
596	DECLINLINE(bool) rtldrIsValid(RTLDRMOD hLdrMod)
597	{
598	return RT_VALID_PTR(hLdrMod)
599	&& ((PRTLDRMODINTERNAL)hLdrMod)->u32Magic == RTLDRMOD_MAGIC;
600	}
601
602
603	/**
604	* Native loader module.
605	*/
606	typedef struct RTLDRMODNATIVE
607	{
608	/** The core structure. */
609	RTLDRMODINTERNAL Core;
610	/** The native handle. */
611	uintptr_t hNative;
612	/** The load flags (RTLDRLOAD_FLAGS_XXX). */
613	uint32_t fFlags;
614	} RTLDRMODNATIVE;
615	/** Pointer to a native module. */
616	typedef RTLDRMODNATIVE *PRTLDRMODNATIVE;
617
618	/** @copydoc RTLDROPS::pfnGetSymbol */
619	DECLCALLBACK(int) rtldrNativeGetSymbol(PRTLDRMODINTERNAL pMod, const char pszSymbol, void *ppvValue);
620	/** @copydoc RTLDROPS::pfnClose */
621	DECLCALLBACK(int) rtldrNativeClose(PRTLDRMODINTERNAL pMod);
622
623	/**
624	* Load a native module using the native loader.
625	*
626	* @returns iprt status code.
627	* @param pszFilename The image filename.
628	* @param phHandle Where to store the module handle on success.
629	* @param fFlags RTLDRLOAD_FLAGS_XXX.
630	* @param pErrInfo Where to return extended error information. Optional.
631	*/
632	DECLHIDDEN(int) rtldrNativeLoad(const char pszFilename, uintptr_t phHandle, uint32_t fFlags, PRTERRINFO pErrInfo);
633
634	/**
635	* Load a system library.
636	*
637	* @returns iprt status code.
638	* @param pszFilename The image filename.
639	* @param pszExt Extension to add. NULL if none.
640	* @param fFlags RTLDRLOAD_FLAGS_XXX.
641	* @param phLdrMod Where to return the module handle on success.
642	*/
643	DECLHIDDEN(int) rtldrNativeLoadSystem(const char pszFilename, const char pszExt, uint32_t fFlags, PRTLDRMOD phLdrMod);
644
645	DECLHIDDEN(int) rtldrPEOpen(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, RTFOFF offNtHdrs, PRTLDRMOD phLdrMod, PRTERRINFO pErrInfo);
646	DECLHIDDEN(int) rtldrELFOpen(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod, PRTERRINFO pErrInfo);
647	DECLHIDDEN(int) rtldrLXOpen(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, RTFOFF offLxHdr, PRTLDRMOD phLdrMod, PRTERRINFO pErrInfo);
648	DECLHIDDEN(int) rtldrMachOOpen(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, RTFOFF offImage, PRTLDRMOD phLdrMod, PRTERRINFO pErrInfo);
649	DECLHIDDEN(int) rtldrFatOpen(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod, PRTERRINFO pErrInfo);
650	DECLHIDDEN(int) rtldrkLdrOpen(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod, PRTERRINFO pErrInfo);
651
652
653	DECLHIDDEN(int) rtLdrReadAt(RTLDRMOD hLdrMod, void *pvBuf, uint32_t iDbgInfo, RTFOFF off, size_t cb);
654
655	RT_C_DECLS_END
656
657	#endif /* !IPRT_INCLUDED_INTERNAL_ldr_h */
658

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

source: vbox/trunk/src/VBox/Runtime/include/internal/ldr.h@ 96407

Download in other formats: