1 | /* $Id: ldrELFRelocatable.cpp.h 52213 2014-07-28 17:52:58Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT - Binary Image Loader, Template for ELF Relocatable Images.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2006-2012 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | *
|
---|
17 | * The contents of this file may alternatively be used under the terms
|
---|
18 | * of the Common Development and Distribution License Version 1.0
|
---|
19 | * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
|
---|
20 | * VirtualBox OSE distribution, in which case the provisions of the
|
---|
21 | * CDDL are applicable instead of those of the GPL.
|
---|
22 | *
|
---|
23 | * You may elect to license modified versions of this file under the
|
---|
24 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
25 | */
|
---|
26 |
|
---|
27 |
|
---|
28 | /*******************************************************************************
|
---|
29 | * Defined Constants And Macros *
|
---|
30 | *******************************************************************************/
|
---|
31 | #if ELF_MODE == 32
|
---|
32 | #define RTLDRELF_NAME(name) rtldrELF32##name
|
---|
33 | #define RTLDRELF_SUFF(name) name##32
|
---|
34 | #define RTLDRELF_MID(pre,suff) pre##32##suff
|
---|
35 | #define FMT_ELF_ADDR "%08RX32"
|
---|
36 | #define FMT_ELF_HALF "%04RX16"
|
---|
37 | #define FMT_ELF_OFF "%08RX32"
|
---|
38 | #define FMT_ELF_SIZE "%08RX32"
|
---|
39 | #define FMT_ELF_SWORD "%RI32"
|
---|
40 | #define FMT_ELF_WORD "%08RX32"
|
---|
41 | #define FMT_ELF_XWORD "%08RX32"
|
---|
42 | #define FMT_ELF_SXWORD "%RI32"
|
---|
43 |
|
---|
44 | #elif ELF_MODE == 64
|
---|
45 | #define RTLDRELF_NAME(name) rtldrELF64##name
|
---|
46 | #define RTLDRELF_SUFF(name) name##64
|
---|
47 | #define RTLDRELF_MID(pre,suff) pre##64##suff
|
---|
48 | #define FMT_ELF_ADDR "%016RX64"
|
---|
49 | #define FMT_ELF_HALF "%04RX16"
|
---|
50 | #define FMT_ELF_SHALF "%RI16"
|
---|
51 | #define FMT_ELF_OFF "%016RX64"
|
---|
52 | #define FMT_ELF_SIZE "%016RX64"
|
---|
53 | #define FMT_ELF_SWORD "%RI32"
|
---|
54 | #define FMT_ELF_WORD "%08RX32"
|
---|
55 | #define FMT_ELF_XWORD "%016RX64"
|
---|
56 | #define FMT_ELF_SXWORD "%RI64"
|
---|
57 | #endif
|
---|
58 |
|
---|
59 | #define Elf_Ehdr RTLDRELF_MID(Elf,_Ehdr)
|
---|
60 | #define Elf_Phdr RTLDRELF_MID(Elf,_Phdr)
|
---|
61 | #define Elf_Shdr RTLDRELF_MID(Elf,_Shdr)
|
---|
62 | #define Elf_Sym RTLDRELF_MID(Elf,_Sym)
|
---|
63 | #define Elf_Rel RTLDRELF_MID(Elf,_Rel)
|
---|
64 | #define Elf_Rela RTLDRELF_MID(Elf,_Rela)
|
---|
65 | #define Elf_Nhdr RTLDRELF_MID(Elf,_Nhdr)
|
---|
66 | #define Elf_Dyn RTLDRELF_MID(Elf,_Dyn)
|
---|
67 | #define Elf_Addr RTLDRELF_MID(Elf,_Addr)
|
---|
68 | #define Elf_Half RTLDRELF_MID(Elf,_Half)
|
---|
69 | #define Elf_Off RTLDRELF_MID(Elf,_Off)
|
---|
70 | #define Elf_Size RTLDRELF_MID(Elf,_Size)
|
---|
71 | #define Elf_Sword RTLDRELF_MID(Elf,_Sword)
|
---|
72 | #define Elf_Word RTLDRELF_MID(Elf,_Word)
|
---|
73 |
|
---|
74 | #define RTLDRMODELF RTLDRELF_MID(RTLDRMODELF,RT_NOTHING)
|
---|
75 | #define PRTLDRMODELF RTLDRELF_MID(PRTLDRMODELF,RT_NOTHING)
|
---|
76 |
|
---|
77 | #define ELF_R_SYM(info) RTLDRELF_MID(ELF,_R_SYM)(info)
|
---|
78 | #define ELF_R_TYPE(info) RTLDRELF_MID(ELF,_R_TYPE)(info)
|
---|
79 | #define ELF_R_INFO(sym, type) RTLDRELF_MID(ELF,_R_INFO)(sym, type)
|
---|
80 |
|
---|
81 | #define ELF_ST_BIND(info) RTLDRELF_MID(ELF,_ST_BIND)(info)
|
---|
82 |
|
---|
83 |
|
---|
84 |
|
---|
85 | /*******************************************************************************
|
---|
86 | * Structures and Typedefs *
|
---|
87 | *******************************************************************************/
|
---|
88 | /**
|
---|
89 | * The ELF loader structure.
|
---|
90 | */
|
---|
91 | typedef struct RTLDRMODELF
|
---|
92 | {
|
---|
93 | /** Core module structure. */
|
---|
94 | RTLDRMODINTERNAL Core;
|
---|
95 | /** Pointer to readonly mapping of the image bits.
|
---|
96 | * This mapping is provided by the pReader. */
|
---|
97 | const void *pvBits;
|
---|
98 |
|
---|
99 | /** The ELF header. */
|
---|
100 | Elf_Ehdr Ehdr;
|
---|
101 | /** Pointer to our copy of the section headers with sh_addr as RVAs.
|
---|
102 | * The virtual addresses in this array is the 0 based assignments we've given the image.
|
---|
103 | * Not valid if the image is DONE. */
|
---|
104 | Elf_Shdr *paShdrs;
|
---|
105 | /** Unmodified section headers (allocated after paShdrs, so no need to free).
|
---|
106 | * Not valid if the image is DONE. */
|
---|
107 | Elf_Shdr const *paOrgShdrs;
|
---|
108 | /** The size of the loaded image. */
|
---|
109 | size_t cbImage;
|
---|
110 |
|
---|
111 | /** The image base address if it's an EXEC or DYN image. */
|
---|
112 | Elf_Addr LinkAddress;
|
---|
113 |
|
---|
114 | /** The symbol section index. */
|
---|
115 | unsigned iSymSh;
|
---|
116 | /** Number of symbols in the table. */
|
---|
117 | unsigned cSyms;
|
---|
118 | /** Pointer to symbol table within RTLDRMODELF::pvBits. */
|
---|
119 | const Elf_Sym *paSyms;
|
---|
120 |
|
---|
121 | /** The string section index. */
|
---|
122 | unsigned iStrSh;
|
---|
123 | /** Size of the string table. */
|
---|
124 | unsigned cbStr;
|
---|
125 | /** Pointer to string table within RTLDRMODELF::pvBits. */
|
---|
126 | const char *pStr;
|
---|
127 |
|
---|
128 | /** Size of the section header string table. */
|
---|
129 | unsigned cbShStr;
|
---|
130 | /** Pointer to section header string table within RTLDRMODELF::pvBits. */
|
---|
131 | const char *pShStr;
|
---|
132 | } RTLDRMODELF, *PRTLDRMODELF;
|
---|
133 |
|
---|
134 |
|
---|
135 | /**
|
---|
136 | * Maps the image bits into memory and resolve pointers into it.
|
---|
137 | *
|
---|
138 | * @returns iprt status code.
|
---|
139 | * @param pModElf The ELF loader module instance data.
|
---|
140 | * @param fNeedsBits Set if we actually need the pvBits member.
|
---|
141 | * If we don't, we can simply read the string and symbol sections, thus saving memory.
|
---|
142 | */
|
---|
143 | static int RTLDRELF_NAME(MapBits)(PRTLDRMODELF pModElf, bool fNeedsBits)
|
---|
144 | {
|
---|
145 | NOREF(fNeedsBits);
|
---|
146 | if (pModElf->pvBits)
|
---|
147 | return VINF_SUCCESS;
|
---|
148 | int rc = pModElf->Core.pReader->pfnMap(pModElf->Core.pReader, &pModElf->pvBits);
|
---|
149 | if (RT_SUCCESS(rc))
|
---|
150 | {
|
---|
151 | const uint8_t *pu8 = (const uint8_t *)pModElf->pvBits;
|
---|
152 | if (pModElf->iSymSh != ~0U)
|
---|
153 | pModElf->paSyms = (const Elf_Sym *)(pu8 + pModElf->paShdrs[pModElf->iSymSh].sh_offset);
|
---|
154 | if (pModElf->iStrSh != ~0U)
|
---|
155 | pModElf->pStr = (const char *)(pu8 + pModElf->paShdrs[pModElf->iStrSh].sh_offset);
|
---|
156 | pModElf->pShStr = (const char *)(pu8 + pModElf->paShdrs[pModElf->Ehdr.e_shstrndx].sh_offset);
|
---|
157 | }
|
---|
158 | return rc;
|
---|
159 | }
|
---|
160 |
|
---|
161 |
|
---|
162 | /*
|
---|
163 | *
|
---|
164 | * EXEC & DYN.
|
---|
165 | * EXEC & DYN.
|
---|
166 | * EXEC & DYN.
|
---|
167 | * EXEC & DYN.
|
---|
168 | * EXEC & DYN.
|
---|
169 | *
|
---|
170 | */
|
---|
171 |
|
---|
172 |
|
---|
173 | /**
|
---|
174 | * Applies the fixups for a section in an executable image.
|
---|
175 | *
|
---|
176 | * @returns iprt status code.
|
---|
177 | * @param pModElf The ELF loader module instance data.
|
---|
178 | * @param BaseAddr The base address which the module is being fixedup to.
|
---|
179 | * @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
|
---|
180 | * @param pvUser User argument to pass to the callback.
|
---|
181 | * @param SecAddr The section address. This is the address the relocations are relative to.
|
---|
182 | * @param cbSec The section size. The relocations must be inside this.
|
---|
183 | * @param pu8SecBaseR Where we read section bits from.
|
---|
184 | * @param pu8SecBaseW Where we write section bits to.
|
---|
185 | * @param pvRelocs Pointer to where we read the relocations from.
|
---|
186 | * @param cbRelocs Size of the relocations.
|
---|
187 | */
|
---|
188 | static int RTLDRELF_NAME(RelocateSectionExecDyn)(PRTLDRMODELF pModElf, Elf_Addr BaseAddr,
|
---|
189 | PFNRTLDRIMPORT pfnGetImport, void *pvUser,
|
---|
190 | const Elf_Addr SecAddr, Elf_Size cbSec,
|
---|
191 | const uint8_t *pu8SecBaseR, uint8_t *pu8SecBaseW,
|
---|
192 | const void *pvRelocs, Elf_Size cbRelocs)
|
---|
193 | {
|
---|
194 | #if ELF_MODE != 32
|
---|
195 | NOREF(pu8SecBaseR);
|
---|
196 | #endif
|
---|
197 |
|
---|
198 | /*
|
---|
199 | * Iterate the relocations.
|
---|
200 | * The relocations are stored in an array of Elf32_Rel records and covers the entire relocation section.
|
---|
201 | */
|
---|
202 | const Elf_Addr offDelta = BaseAddr - pModElf->LinkAddress;
|
---|
203 | const Elf_Reloc *paRels = (const Elf_Reloc *)pvRelocs;
|
---|
204 | const unsigned iRelMax = (unsigned)(cbRelocs / sizeof(paRels[0]));
|
---|
205 | AssertMsgReturn(iRelMax == cbRelocs / sizeof(paRels[0]), (FMT_ELF_SIZE "\n", cbRelocs / sizeof(paRels[0])),
|
---|
206 | VERR_IMAGE_TOO_BIG);
|
---|
207 | for (unsigned iRel = 0; iRel < iRelMax; iRel++)
|
---|
208 | {
|
---|
209 | /*
|
---|
210 | * Skip R_XXX_NONE entries early to avoid confusion in the symbol
|
---|
211 | * getter code.
|
---|
212 | */
|
---|
213 | #if ELF_MODE == 32
|
---|
214 | if (ELF_R_TYPE(paRels[iRel].r_info) == R_386_NONE)
|
---|
215 | continue;
|
---|
216 | #elif ELF_MODE == 64
|
---|
217 | if (ELF_R_TYPE(paRels[iRel].r_info) == R_X86_64_NONE)
|
---|
218 | continue;
|
---|
219 | #endif
|
---|
220 |
|
---|
221 | /*
|
---|
222 | * Validate and find the symbol, resolve undefined ones.
|
---|
223 | */
|
---|
224 | Elf_Size iSym = ELF_R_SYM(paRels[iRel].r_info);
|
---|
225 | if (iSym >= pModElf->cSyms)
|
---|
226 | {
|
---|
227 | AssertMsgFailed(("iSym=%d is an invalid symbol index!\n", iSym));
|
---|
228 | return VERR_LDRELF_INVALID_SYMBOL_INDEX;
|
---|
229 | }
|
---|
230 | const Elf_Sym *pSym = &pModElf->paSyms[iSym];
|
---|
231 | if (pSym->st_name >= pModElf->cbStr)
|
---|
232 | {
|
---|
233 | AssertMsgFailed(("iSym=%d st_name=%d str sh_size=%d\n", iSym, pSym->st_name, pModElf->cbStr));
|
---|
234 | return VERR_LDRELF_INVALID_SYMBOL_NAME_OFFSET;
|
---|
235 | }
|
---|
236 |
|
---|
237 | Elf_Addr SymValue = 0;
|
---|
238 | if (pSym->st_shndx == SHN_UNDEF)
|
---|
239 | {
|
---|
240 | /* Try to resolve the symbol. */
|
---|
241 | const char *pszName = ELF_STR(pModElf, pSym->st_name);
|
---|
242 | RTUINTPTR ExtValue;
|
---|
243 | int rc = pfnGetImport(&pModElf->Core, "", pszName, ~0, &ExtValue, pvUser);
|
---|
244 | AssertMsgRCReturn(rc, ("Failed to resolve '%s' rc=%Rrc\n", pszName, rc), rc);
|
---|
245 | SymValue = (Elf_Addr)ExtValue;
|
---|
246 | AssertMsgReturn((RTUINTPTR)SymValue == ExtValue, ("Symbol value overflowed! '%s'\n", pszName),
|
---|
247 | VERR_SYMBOL_VALUE_TOO_BIG);
|
---|
248 | Log2(("rtldrELF: #%-3d - UNDEF " FMT_ELF_ADDR " '%s'\n", iSym, SymValue, pszName));
|
---|
249 | }
|
---|
250 | else
|
---|
251 | {
|
---|
252 | AssertReturn(pSym->st_shndx < pModElf->cSyms || pSym->st_shndx == SHN_ABS, ("%#x\n", pSym->st_shndx));
|
---|
253 | #if ELF_MODE == 64
|
---|
254 | SymValue = pSym->st_value;
|
---|
255 | #endif
|
---|
256 | }
|
---|
257 |
|
---|
258 | #if ELF_MODE == 64
|
---|
259 | /* Calc the value. */
|
---|
260 | Elf_Addr Value;
|
---|
261 | if (pSym->st_shndx < pModElf->cSyms)
|
---|
262 | Value = SymValue + offDelta;
|
---|
263 | else
|
---|
264 | Value = SymValue + paRels[iRel].r_addend;
|
---|
265 | #endif
|
---|
266 |
|
---|
267 | /*
|
---|
268 | * Apply the fixup.
|
---|
269 | */
|
---|
270 | AssertMsgReturn(paRels[iRel].r_offset < cbSec, (FMT_ELF_ADDR " " FMT_ELF_SIZE "\n", paRels[iRel].r_offset, cbSec), VERR_LDRELF_INVALID_RELOCATION_OFFSET);
|
---|
271 | #if ELF_MODE == 32
|
---|
272 | const Elf_Addr *pAddrR = (const Elf_Addr *)(pu8SecBaseR + paRels[iRel].r_offset); /* Where to read the addend. */
|
---|
273 | #endif
|
---|
274 | Elf_Addr *pAddrW = (Elf_Addr *)(pu8SecBaseW + paRels[iRel].r_offset); /* Where to write the fixup. */
|
---|
275 | switch (ELF_R_TYPE(paRels[iRel].r_info))
|
---|
276 | {
|
---|
277 | #if ELF_MODE == 32
|
---|
278 | /*
|
---|
279 | * Absolute addressing.
|
---|
280 | */
|
---|
281 | case R_386_32:
|
---|
282 | {
|
---|
283 | Elf_Addr Value;
|
---|
284 | if (pSym->st_shndx < pModElf->Ehdr.e_shnum)
|
---|
285 | Value = *pAddrR + offDelta; /* Simplified. */
|
---|
286 | else if (pSym->st_shndx == SHN_ABS)
|
---|
287 | continue; /* Internal fixup, no need to apply it. */
|
---|
288 | else if (pSym->st_shndx == SHN_UNDEF)
|
---|
289 | Value = SymValue + *pAddrR;
|
---|
290 | else
|
---|
291 | AssertFailedReturn(VERR_LDR_GENERAL_FAILURE); /** @todo SHN_COMMON */
|
---|
292 | *(uint32_t *)pAddrW = Value;
|
---|
293 | Log4((FMT_ELF_ADDR": R_386_32 Value=" FMT_ELF_ADDR "\n", SecAddr + paRels[iRel].r_offset + BaseAddr, Value));
|
---|
294 | break;
|
---|
295 | }
|
---|
296 |
|
---|
297 | /*
|
---|
298 | * PC relative addressing.
|
---|
299 | */
|
---|
300 | case R_386_PC32:
|
---|
301 | {
|
---|
302 | Elf_Addr Value;
|
---|
303 | if (pSym->st_shndx < pModElf->Ehdr.e_shnum)
|
---|
304 | continue; /* Internal fixup, no need to apply it. */
|
---|
305 | else if (pSym->st_shndx == SHN_ABS)
|
---|
306 | Value = *pAddrR + offDelta; /* Simplified. */
|
---|
307 | else if (pSym->st_shndx == SHN_UNDEF)
|
---|
308 | {
|
---|
309 | const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
|
---|
310 | Value = SymValue + *(uint32_t *)pAddrR - SourceAddr;
|
---|
311 | *(uint32_t *)pAddrW = Value;
|
---|
312 | }
|
---|
313 | else
|
---|
314 | AssertFailedReturn(VERR_LDR_GENERAL_FAILURE); /** @todo SHN_COMMON */
|
---|
315 | Log4((FMT_ELF_ADDR": R_386_PC32 Value=" FMT_ELF_ADDR "\n", SecAddr + paRels[iRel].r_offset + BaseAddr, Value));
|
---|
316 | break;
|
---|
317 | }
|
---|
318 |
|
---|
319 | #elif ELF_MODE == 64
|
---|
320 |
|
---|
321 | /*
|
---|
322 | * Absolute addressing
|
---|
323 | */
|
---|
324 | case R_X86_64_64:
|
---|
325 | {
|
---|
326 | *(uint64_t *)pAddrW = Value;
|
---|
327 | Log4((FMT_ELF_ADDR": R_X86_64_64 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
328 | SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
|
---|
329 | break;
|
---|
330 | }
|
---|
331 |
|
---|
332 | /*
|
---|
333 | * Truncated 32-bit value (zero-extendedable to the 64-bit value).
|
---|
334 | */
|
---|
335 | case R_X86_64_32:
|
---|
336 | {
|
---|
337 | *(uint32_t *)pAddrW = (uint32_t)Value;
|
---|
338 | Log4((FMT_ELF_ADDR": R_X86_64_32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
339 | SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
|
---|
340 | AssertMsgReturn((Elf_Addr)*(uint32_t *)pAddrW == SymValue, ("Value=" FMT_ELF_ADDR "\n", SymValue),
|
---|
341 | VERR_SYMBOL_VALUE_TOO_BIG);
|
---|
342 | break;
|
---|
343 | }
|
---|
344 |
|
---|
345 | /*
|
---|
346 | * Truncated 32-bit value (sign-extendedable to the 64-bit value).
|
---|
347 | */
|
---|
348 | case R_X86_64_32S:
|
---|
349 | {
|
---|
350 | *(int32_t *)pAddrW = (int32_t)Value;
|
---|
351 | Log4((FMT_ELF_ADDR": R_X86_64_32S Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
352 | SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
|
---|
353 | AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
|
---|
354 | break;
|
---|
355 | }
|
---|
356 |
|
---|
357 | /*
|
---|
358 | * PC relative addressing.
|
---|
359 | */
|
---|
360 | case R_X86_64_PC32:
|
---|
361 | {
|
---|
362 | const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
|
---|
363 | Value -= SourceAddr;
|
---|
364 | *(int32_t *)pAddrW = (int32_t)Value;
|
---|
365 | Log4((FMT_ELF_ADDR": R_X86_64_PC32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
366 | SourceAddr, Value, SymValue));
|
---|
367 | AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
|
---|
368 | break;
|
---|
369 | }
|
---|
370 | #endif
|
---|
371 |
|
---|
372 | default:
|
---|
373 | AssertMsgFailed(("Unknown relocation type: %d (iRel=%d iRelMax=%d)\n",
|
---|
374 | ELF_R_TYPE(paRels[iRel].r_info), iRel, iRelMax));
|
---|
375 | return VERR_LDRELF_RELOCATION_NOT_SUPPORTED;
|
---|
376 | }
|
---|
377 | }
|
---|
378 |
|
---|
379 | return VINF_SUCCESS;
|
---|
380 | }
|
---|
381 |
|
---|
382 |
|
---|
383 |
|
---|
384 | /*
|
---|
385 | *
|
---|
386 | * REL
|
---|
387 | * REL
|
---|
388 | * REL
|
---|
389 | * REL
|
---|
390 | * REL
|
---|
391 | *
|
---|
392 | */
|
---|
393 |
|
---|
394 | /**
|
---|
395 | * Get the symbol and symbol value.
|
---|
396 | *
|
---|
397 | * @returns iprt status code.
|
---|
398 | * @param pModElf The ELF loader module instance data.
|
---|
399 | * @param BaseAddr The base address which the module is being fixedup to.
|
---|
400 | * @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
|
---|
401 | * @param pvUser User argument to pass to the callback.
|
---|
402 | * @param iSym The symbol to get.
|
---|
403 | * @param ppSym Where to store the symbol pointer on success. (read only)
|
---|
404 | * @param pSymValue Where to store the symbol value on success.
|
---|
405 | */
|
---|
406 | static int RTLDRELF_NAME(Symbol)(PRTLDRMODELF pModElf, Elf_Addr BaseAddr, PFNRTLDRIMPORT pfnGetImport, void *pvUser,
|
---|
407 | Elf_Size iSym, const Elf_Sym **ppSym, Elf_Addr *pSymValue)
|
---|
408 | {
|
---|
409 | /*
|
---|
410 | * Validate and find the symbol.
|
---|
411 | */
|
---|
412 | if (iSym >= pModElf->cSyms)
|
---|
413 | {
|
---|
414 | AssertMsgFailed(("iSym=%d is an invalid symbol index!\n", iSym));
|
---|
415 | return VERR_LDRELF_INVALID_SYMBOL_INDEX;
|
---|
416 | }
|
---|
417 | const Elf_Sym *pSym = &pModElf->paSyms[iSym];
|
---|
418 | *ppSym = pSym;
|
---|
419 |
|
---|
420 | if (pSym->st_name >= pModElf->cbStr)
|
---|
421 | {
|
---|
422 | AssertMsgFailed(("iSym=%d st_name=%d str sh_size=%d\n", iSym, pSym->st_name, pModElf->cbStr));
|
---|
423 | return VERR_LDRELF_INVALID_SYMBOL_NAME_OFFSET;
|
---|
424 | }
|
---|
425 | const char *pszName = ELF_STR(pModElf, pSym->st_name);
|
---|
426 |
|
---|
427 | /*
|
---|
428 | * Determine the symbol value.
|
---|
429 | *
|
---|
430 | * Symbols needs different treatment depending on which section their are in.
|
---|
431 | * Undefined and absolute symbols goes into special non-existing sections.
|
---|
432 | */
|
---|
433 | switch (pSym->st_shndx)
|
---|
434 | {
|
---|
435 | /*
|
---|
436 | * Undefined symbol, needs resolving.
|
---|
437 | *
|
---|
438 | * Since ELF has no generic concept of importing from specific module (the OS/2 ELF format
|
---|
439 | * has but that's a OS extension and only applies to programs and dlls), we'll have to ask
|
---|
440 | * the resolver callback to do a global search.
|
---|
441 | */
|
---|
442 | case SHN_UNDEF:
|
---|
443 | {
|
---|
444 | /* Try to resolve the symbol. */
|
---|
445 | RTUINTPTR Value;
|
---|
446 | int rc = pfnGetImport(&pModElf->Core, "", pszName, ~0, &Value, pvUser);
|
---|
447 | if (RT_FAILURE(rc))
|
---|
448 | {
|
---|
449 | AssertMsgFailed(("Failed to resolve '%s' rc=%Rrc\n", pszName, rc));
|
---|
450 | return rc;
|
---|
451 | }
|
---|
452 | *pSymValue = (Elf_Addr)Value;
|
---|
453 | if ((RTUINTPTR)*pSymValue != Value)
|
---|
454 | {
|
---|
455 | AssertMsgFailed(("Symbol value overflowed! '%s'\n", pszName));
|
---|
456 | return VERR_SYMBOL_VALUE_TOO_BIG;
|
---|
457 | }
|
---|
458 |
|
---|
459 | Log2(("rtldrELF: #%-3d - UNDEF " FMT_ELF_ADDR " '%s'\n", iSym, *pSymValue, pszName));
|
---|
460 | break;
|
---|
461 | }
|
---|
462 |
|
---|
463 | /*
|
---|
464 | * Absolute symbols needs no fixing since they are, well, absolute.
|
---|
465 | */
|
---|
466 | case SHN_ABS:
|
---|
467 | *pSymValue = pSym->st_value;
|
---|
468 | Log2(("rtldrELF: #%-3d - ABS " FMT_ELF_ADDR " '%s'\n", iSym, *pSymValue, pszName));
|
---|
469 | break;
|
---|
470 |
|
---|
471 | /*
|
---|
472 | * All other symbols are addressed relative to their section and need to be fixed up.
|
---|
473 | */
|
---|
474 | default:
|
---|
475 | if (pSym->st_shndx >= pModElf->Ehdr.e_shnum)
|
---|
476 | {
|
---|
477 | /* what about common symbols? */
|
---|
478 | AssertMsg(pSym->st_shndx < pModElf->Ehdr.e_shnum,
|
---|
479 | ("iSym=%d st_shndx=%d e_shnum=%d pszName=%s\n", iSym, pSym->st_shndx, pModElf->Ehdr.e_shnum, pszName));
|
---|
480 | return VERR_BAD_EXE_FORMAT;
|
---|
481 | }
|
---|
482 | *pSymValue = pSym->st_value + pModElf->paShdrs[pSym->st_shndx].sh_addr + BaseAddr;
|
---|
483 | Log2(("rtldrELF: #%-3d - %5d " FMT_ELF_ADDR " '%s'\n", iSym, pSym->st_shndx, *pSymValue, pszName));
|
---|
484 | break;
|
---|
485 | }
|
---|
486 |
|
---|
487 | return VINF_SUCCESS;
|
---|
488 | }
|
---|
489 |
|
---|
490 |
|
---|
491 | /**
|
---|
492 | * Applies the fixups for a sections.
|
---|
493 | *
|
---|
494 | * @returns iprt status code.
|
---|
495 | * @param pModElf The ELF loader module instance data.
|
---|
496 | * @param BaseAddr The base address which the module is being fixedup to.
|
---|
497 | * @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
|
---|
498 | * @param pvUser User argument to pass to the callback.
|
---|
499 | * @param SecAddr The section address. This is the address the relocations are relative to.
|
---|
500 | * @param cbSec The section size. The relocations must be inside this.
|
---|
501 | * @param pu8SecBaseR Where we read section bits from.
|
---|
502 | * @param pu8SecBaseW Where we write section bits to.
|
---|
503 | * @param pvRelocs Pointer to where we read the relocations from.
|
---|
504 | * @param cbRelocs Size of the relocations.
|
---|
505 | */
|
---|
506 | static int RTLDRELF_NAME(RelocateSection)(PRTLDRMODELF pModElf, Elf_Addr BaseAddr, PFNRTLDRIMPORT pfnGetImport, void *pvUser,
|
---|
507 | const Elf_Addr SecAddr, Elf_Size cbSec, const uint8_t *pu8SecBaseR, uint8_t *pu8SecBaseW,
|
---|
508 | const void *pvRelocs, Elf_Size cbRelocs)
|
---|
509 | {
|
---|
510 | #if ELF_MODE != 32
|
---|
511 | NOREF(pu8SecBaseR);
|
---|
512 | #endif
|
---|
513 |
|
---|
514 | /*
|
---|
515 | * Iterate the relocations.
|
---|
516 | * The relocations are stored in an array of Elf32_Rel records and covers the entire relocation section.
|
---|
517 | */
|
---|
518 | const Elf_Reloc *paRels = (const Elf_Reloc *)pvRelocs;
|
---|
519 | const unsigned iRelMax = (unsigned)(cbRelocs / sizeof(paRels[0]));
|
---|
520 | AssertMsgReturn(iRelMax == cbRelocs / sizeof(paRels[0]), (FMT_ELF_SIZE "\n", cbRelocs / sizeof(paRels[0])), VERR_IMAGE_TOO_BIG);
|
---|
521 | for (unsigned iRel = 0; iRel < iRelMax; iRel++)
|
---|
522 | {
|
---|
523 | /*
|
---|
524 | * Skip R_XXX_NONE entries early to avoid confusion in the symbol
|
---|
525 | * getter code.
|
---|
526 | */
|
---|
527 | #if ELF_MODE == 32
|
---|
528 | if (ELF_R_TYPE(paRels[iRel].r_info) == R_386_NONE)
|
---|
529 | continue;
|
---|
530 | #elif ELF_MODE == 64
|
---|
531 | if (ELF_R_TYPE(paRels[iRel].r_info) == R_X86_64_NONE)
|
---|
532 | continue;
|
---|
533 | #endif
|
---|
534 |
|
---|
535 |
|
---|
536 | /*
|
---|
537 | * Get the symbol.
|
---|
538 | */
|
---|
539 | const Elf_Sym *pSym = NULL; /* shut up gcc */
|
---|
540 | Elf_Addr SymValue = 0; /* shut up gcc-4 */
|
---|
541 | int rc = RTLDRELF_NAME(Symbol)(pModElf, BaseAddr, pfnGetImport, pvUser, ELF_R_SYM(paRels[iRel].r_info), &pSym, &SymValue);
|
---|
542 | if (RT_FAILURE(rc))
|
---|
543 | return rc;
|
---|
544 |
|
---|
545 | Log3(("rtldrELF: " FMT_ELF_ADDR " %02x %06x - " FMT_ELF_ADDR " %3d %02x %s\n",
|
---|
546 | paRels[iRel].r_offset, ELF_R_TYPE(paRels[iRel].r_info), (unsigned)ELF_R_SYM(paRels[iRel].r_info),
|
---|
547 | SymValue, (unsigned)pSym->st_shndx, pSym->st_info, ELF_STR(pModElf, pSym->st_name)));
|
---|
548 |
|
---|
549 | /*
|
---|
550 | * Apply the fixup.
|
---|
551 | */
|
---|
552 | AssertMsgReturn(paRels[iRel].r_offset < cbSec, (FMT_ELF_ADDR " " FMT_ELF_SIZE "\n", paRels[iRel].r_offset, cbSec), VERR_LDRELF_INVALID_RELOCATION_OFFSET);
|
---|
553 | #if ELF_MODE == 32
|
---|
554 | const Elf_Addr *pAddrR = (const Elf_Addr *)(pu8SecBaseR + paRels[iRel].r_offset); /* Where to read the addend. */
|
---|
555 | #endif
|
---|
556 | Elf_Addr *pAddrW = (Elf_Addr *)(pu8SecBaseW + paRels[iRel].r_offset); /* Where to write the fixup. */
|
---|
557 | switch (ELF_R_TYPE(paRels[iRel].r_info))
|
---|
558 | {
|
---|
559 | #if ELF_MODE == 32
|
---|
560 | /*
|
---|
561 | * Absolute addressing.
|
---|
562 | */
|
---|
563 | case R_386_32:
|
---|
564 | {
|
---|
565 | const Elf_Addr Value = SymValue + *pAddrR;
|
---|
566 | *(uint32_t *)pAddrW = Value;
|
---|
567 | Log4((FMT_ELF_ADDR": R_386_32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
568 | SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
|
---|
569 | break;
|
---|
570 | }
|
---|
571 |
|
---|
572 | /*
|
---|
573 | * PC relative addressing.
|
---|
574 | */
|
---|
575 | case R_386_PC32:
|
---|
576 | {
|
---|
577 | const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
|
---|
578 | const Elf_Addr Value = SymValue + *(uint32_t *)pAddrR - SourceAddr;
|
---|
579 | *(uint32_t *)pAddrW = Value;
|
---|
580 | Log4((FMT_ELF_ADDR": R_386_PC32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
581 | SourceAddr, Value, SymValue));
|
---|
582 | break;
|
---|
583 | }
|
---|
584 |
|
---|
585 | /* ignore */
|
---|
586 | case R_386_NONE:
|
---|
587 | break;
|
---|
588 |
|
---|
589 | #elif ELF_MODE == 64
|
---|
590 |
|
---|
591 | /*
|
---|
592 | * Absolute addressing
|
---|
593 | */
|
---|
594 | case R_X86_64_64:
|
---|
595 | {
|
---|
596 | const Elf_Addr Value = SymValue + paRels[iRel].r_addend;
|
---|
597 | *(uint64_t *)pAddrW = Value;
|
---|
598 | Log4((FMT_ELF_ADDR": R_X86_64_64 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
599 | SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
|
---|
600 | break;
|
---|
601 | }
|
---|
602 |
|
---|
603 | /*
|
---|
604 | * Truncated 32-bit value (zero-extendedable to the 64-bit value).
|
---|
605 | */
|
---|
606 | case R_X86_64_32:
|
---|
607 | {
|
---|
608 | const Elf_Addr Value = SymValue + paRels[iRel].r_addend;
|
---|
609 | *(uint32_t *)pAddrW = (uint32_t)Value;
|
---|
610 | Log4((FMT_ELF_ADDR": R_X86_64_32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
611 | SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
|
---|
612 | AssertMsgReturn((Elf_Addr)*(uint32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG);
|
---|
613 | break;
|
---|
614 | }
|
---|
615 |
|
---|
616 | /*
|
---|
617 | * Truncated 32-bit value (sign-extendedable to the 64-bit value).
|
---|
618 | */
|
---|
619 | case R_X86_64_32S:
|
---|
620 | {
|
---|
621 | const Elf_Addr Value = SymValue + paRels[iRel].r_addend;
|
---|
622 | *(int32_t *)pAddrW = (int32_t)Value;
|
---|
623 | Log4((FMT_ELF_ADDR": R_X86_64_32S Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
624 | SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
|
---|
625 | AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
|
---|
626 | break;
|
---|
627 | }
|
---|
628 |
|
---|
629 | /*
|
---|
630 | * PC relative addressing.
|
---|
631 | */
|
---|
632 | case R_X86_64_PC32:
|
---|
633 | {
|
---|
634 | const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
|
---|
635 | const Elf_Addr Value = SymValue + paRels[iRel].r_addend - SourceAddr;
|
---|
636 | *(int32_t *)pAddrW = (int32_t)Value;
|
---|
637 | Log4((FMT_ELF_ADDR": R_X86_64_PC32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
|
---|
638 | SourceAddr, Value, SymValue));
|
---|
639 | AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
|
---|
640 | break;
|
---|
641 | }
|
---|
642 |
|
---|
643 | /* ignore */
|
---|
644 | case R_X86_64_NONE:
|
---|
645 | break;
|
---|
646 | #endif
|
---|
647 |
|
---|
648 | default:
|
---|
649 | AssertMsgFailed(("Unknown relocation type: %d (iRel=%d iRelMax=%d)\n",
|
---|
650 | ELF_R_TYPE(paRels[iRel].r_info), iRel, iRelMax));
|
---|
651 | return VERR_LDRELF_RELOCATION_NOT_SUPPORTED;
|
---|
652 | }
|
---|
653 | }
|
---|
654 |
|
---|
655 | return VINF_SUCCESS;
|
---|
656 | }
|
---|
657 |
|
---|
658 |
|
---|
659 |
|
---|
660 | /** @copydoc RTLDROPS::pfnClose */
|
---|
661 | static DECLCALLBACK(int) RTLDRELF_NAME(Close)(PRTLDRMODINTERNAL pMod)
|
---|
662 | {
|
---|
663 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
664 |
|
---|
665 | if (pModElf->paShdrs)
|
---|
666 | {
|
---|
667 | RTMemFree(pModElf->paShdrs);
|
---|
668 | pModElf->paShdrs = NULL;
|
---|
669 | }
|
---|
670 |
|
---|
671 | pModElf->pvBits = NULL;
|
---|
672 |
|
---|
673 | return VINF_SUCCESS;
|
---|
674 | }
|
---|
675 |
|
---|
676 |
|
---|
677 | /** @copydoc RTLDROPS::Done */
|
---|
678 | static DECLCALLBACK(int) RTLDRELF_NAME(Done)(PRTLDRMODINTERNAL pMod)
|
---|
679 | {
|
---|
680 | NOREF(pMod); /*PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;*/
|
---|
681 | /** @todo Have to think more about this .... */
|
---|
682 | return -1;
|
---|
683 | }
|
---|
684 |
|
---|
685 |
|
---|
686 | /** @copydoc RTLDROPS::EnumSymbols */
|
---|
687 | static DECLCALLBACK(int) RTLDRELF_NAME(EnumSymbols)(PRTLDRMODINTERNAL pMod, unsigned fFlags, const void *pvBits, RTUINTPTR BaseAddress,
|
---|
688 | PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
|
---|
689 | {
|
---|
690 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
691 | NOREF(pvBits);
|
---|
692 |
|
---|
693 | /*
|
---|
694 | * Validate the input.
|
---|
695 | */
|
---|
696 | Elf_Addr BaseAddr = (Elf_Addr)BaseAddress;
|
---|
697 | AssertMsgReturn((RTUINTPTR)BaseAddr == BaseAddress, ("#RTptr", BaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
|
---|
698 |
|
---|
699 | /*
|
---|
700 | * Make sure we've got the string and symbol tables. (We don't need the pvBits.)
|
---|
701 | */
|
---|
702 | int rc = RTLDRELF_NAME(MapBits)(pModElf, false);
|
---|
703 | if (RT_FAILURE(rc))
|
---|
704 | return rc;
|
---|
705 |
|
---|
706 | /*
|
---|
707 | * Enumerate the symbol table.
|
---|
708 | */
|
---|
709 | const Elf_Sym *paSyms = pModElf->paSyms;
|
---|
710 | unsigned cSyms = pModElf->cSyms;
|
---|
711 | for (unsigned iSym = 1; iSym < cSyms; iSym++)
|
---|
712 | {
|
---|
713 | /*
|
---|
714 | * Skip imports (undefined).
|
---|
715 | */
|
---|
716 | if (paSyms[iSym].st_shndx != SHN_UNDEF)
|
---|
717 | {
|
---|
718 | /*
|
---|
719 | * Calc value and get name.
|
---|
720 | */
|
---|
721 | Elf_Addr Value;
|
---|
722 | if (paSyms[iSym].st_shndx == SHN_ABS)
|
---|
723 | /* absolute symbols are not subject to any relocation. */
|
---|
724 | Value = paSyms[iSym].st_value;
|
---|
725 | else if (paSyms[iSym].st_shndx < pModElf->Ehdr.e_shnum)
|
---|
726 | {
|
---|
727 | if (pModElf->Ehdr.e_type == ET_REL)
|
---|
728 | /* relative to the section. */
|
---|
729 | Value = BaseAddr + paSyms[iSym].st_value + pModElf->paShdrs[paSyms[iSym].st_shndx].sh_addr;
|
---|
730 | else /* Fixed up for link address. */
|
---|
731 | Value = BaseAddr + paSyms[iSym].st_value - pModElf->LinkAddress;
|
---|
732 | }
|
---|
733 | else
|
---|
734 | {
|
---|
735 | AssertMsgFailed(("Arg! paSyms[%u].st_shndx=" FMT_ELF_HALF "\n", iSym, paSyms[iSym].st_shndx));
|
---|
736 | return VERR_BAD_EXE_FORMAT;
|
---|
737 | }
|
---|
738 | const char *pszName = ELF_STR(pModElf, paSyms[iSym].st_name);
|
---|
739 | if ( (pszName && *pszName)
|
---|
740 | && ( (fFlags & RTLDR_ENUM_SYMBOL_FLAGS_ALL)
|
---|
741 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL)
|
---|
742 | )
|
---|
743 | {
|
---|
744 | /*
|
---|
745 | * Call back.
|
---|
746 | */
|
---|
747 | AssertMsgReturn(Value == (RTUINTPTR)Value, (FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG);
|
---|
748 | rc = pfnCallback(pMod, pszName, ~0, (RTUINTPTR)Value, pvUser);
|
---|
749 | if (rc)
|
---|
750 | return rc;
|
---|
751 | }
|
---|
752 | }
|
---|
753 | }
|
---|
754 |
|
---|
755 | return VINF_SUCCESS;
|
---|
756 | }
|
---|
757 |
|
---|
758 |
|
---|
759 | /** @copydoc RTLDROPS::GetImageSize */
|
---|
760 | static DECLCALLBACK(size_t) RTLDRELF_NAME(GetImageSize)(PRTLDRMODINTERNAL pMod)
|
---|
761 | {
|
---|
762 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
763 |
|
---|
764 | return pModElf->cbImage;
|
---|
765 | }
|
---|
766 |
|
---|
767 |
|
---|
768 | /** @copydoc RTLDROPS::GetBits */
|
---|
769 | static DECLCALLBACK(int) RTLDRELF_NAME(GetBits)(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
|
---|
770 | {
|
---|
771 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
772 |
|
---|
773 | /*
|
---|
774 | * This operation is currently only available on relocatable images.
|
---|
775 | */
|
---|
776 | switch (pModElf->Ehdr.e_type)
|
---|
777 | {
|
---|
778 | case ET_REL:
|
---|
779 | break;
|
---|
780 | case ET_EXEC:
|
---|
781 | Log(("RTLdrELF: %s: Executable images are not supported yet!\n", pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader)));
|
---|
782 | return VERR_LDRELF_EXEC;
|
---|
783 | case ET_DYN:
|
---|
784 | Log(("RTLdrELF: %s: Dynamic images are not supported yet!\n", pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader)));
|
---|
785 | return VERR_LDRELF_DYN;
|
---|
786 | default: AssertFailedReturn(VERR_BAD_EXE_FORMAT);
|
---|
787 | }
|
---|
788 |
|
---|
789 | /*
|
---|
790 | * Load the bits into pvBits.
|
---|
791 | */
|
---|
792 | const Elf_Shdr *paShdrs = pModElf->paShdrs;
|
---|
793 | for (unsigned iShdr = 0; iShdr < pModElf->Ehdr.e_shnum; iShdr++)
|
---|
794 | {
|
---|
795 | if (paShdrs[iShdr].sh_flags & SHF_ALLOC)
|
---|
796 | {
|
---|
797 | AssertMsgReturn((size_t)paShdrs[iShdr].sh_size == (size_t)paShdrs[iShdr].sh_size, (FMT_ELF_SIZE "\n", paShdrs[iShdr].sh_size), VERR_IMAGE_TOO_BIG);
|
---|
798 | switch (paShdrs[iShdr].sh_type)
|
---|
799 | {
|
---|
800 | case SHT_NOBITS:
|
---|
801 | memset((uint8_t *)pvBits + paShdrs[iShdr].sh_addr, 0, (size_t)paShdrs[iShdr].sh_size);
|
---|
802 | break;
|
---|
803 |
|
---|
804 | case SHT_PROGBITS:
|
---|
805 | default:
|
---|
806 | {
|
---|
807 | int rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, (uint8_t *)pvBits + paShdrs[iShdr].sh_addr,
|
---|
808 | (size_t)paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_offset);
|
---|
809 | if (RT_FAILURE(rc))
|
---|
810 | {
|
---|
811 | Log(("RTLdrELF: %s: Read error when reading " FMT_ELF_SIZE " bytes at " FMT_ELF_OFF ", iShdr=%d\n",
|
---|
812 | pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader),
|
---|
813 | paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_offset, iShdr));
|
---|
814 | return rc;
|
---|
815 | }
|
---|
816 | }
|
---|
817 | }
|
---|
818 | }
|
---|
819 | }
|
---|
820 |
|
---|
821 | /*
|
---|
822 | * Relocate the image.
|
---|
823 | */
|
---|
824 | return pModElf->Core.pOps->pfnRelocate(pMod, pvBits, BaseAddress, ~(RTUINTPTR)0, pfnGetImport, pvUser);
|
---|
825 | }
|
---|
826 |
|
---|
827 |
|
---|
828 | /** @copydoc RTLDROPS::Relocate */
|
---|
829 | static DECLCALLBACK(int) RTLDRELF_NAME(Relocate)(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR NewBaseAddress,
|
---|
830 | RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
|
---|
831 | {
|
---|
832 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
833 | #ifdef LOG_ENABLED
|
---|
834 | const char *pszLogName = pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader);
|
---|
835 | #endif
|
---|
836 | NOREF(OldBaseAddress);
|
---|
837 |
|
---|
838 | /*
|
---|
839 | * This operation is currently only available on relocatable images.
|
---|
840 | */
|
---|
841 | switch (pModElf->Ehdr.e_type)
|
---|
842 | {
|
---|
843 | case ET_REL:
|
---|
844 | break;
|
---|
845 | case ET_EXEC:
|
---|
846 | Log(("RTLdrELF: %s: Executable images are not supported yet!\n", pszLogName));
|
---|
847 | return VERR_LDRELF_EXEC;
|
---|
848 | case ET_DYN:
|
---|
849 | Log(("RTLdrELF: %s: Dynamic images are not supported yet!\n", pszLogName));
|
---|
850 | return VERR_LDRELF_DYN;
|
---|
851 | default: AssertFailedReturn(VERR_BAD_EXE_FORMAT);
|
---|
852 | }
|
---|
853 |
|
---|
854 | /*
|
---|
855 | * Validate the input.
|
---|
856 | */
|
---|
857 | Elf_Addr BaseAddr = (Elf_Addr)NewBaseAddress;
|
---|
858 | AssertMsgReturn((RTUINTPTR)BaseAddr == NewBaseAddress, ("#RTptr", NewBaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
|
---|
859 |
|
---|
860 | /*
|
---|
861 | * Map the image bits if not already done and setup pointer into it.
|
---|
862 | */
|
---|
863 | int rc = RTLDRELF_NAME(MapBits)(pModElf, true);
|
---|
864 | if (RT_FAILURE(rc))
|
---|
865 | return rc;
|
---|
866 |
|
---|
867 | /*
|
---|
868 | * Iterate the sections looking for interesting SHT_REL[A] sections.
|
---|
869 | * SHT_REL[A] sections have the section index of the section they contain fixups
|
---|
870 | * for in the sh_info member.
|
---|
871 | */
|
---|
872 | const Elf_Shdr *paShdrs = pModElf->paShdrs;
|
---|
873 | Log2(("rtLdrElf: %s: Fixing up image\n", pszLogName));
|
---|
874 | for (unsigned iShdr = 0; iShdr < pModElf->Ehdr.e_shnum; iShdr++)
|
---|
875 | {
|
---|
876 | const Elf_Shdr *pShdrRel = &paShdrs[iShdr];
|
---|
877 |
|
---|
878 | /*
|
---|
879 | * Skip sections without interest to us.
|
---|
880 | */
|
---|
881 | #if ELF_MODE == 32
|
---|
882 | if (pShdrRel->sh_type != SHT_REL)
|
---|
883 | #else
|
---|
884 | if (pShdrRel->sh_type != SHT_RELA)
|
---|
885 | #endif
|
---|
886 | continue;
|
---|
887 | if (pShdrRel->sh_info >= pModElf->Ehdr.e_shnum)
|
---|
888 | continue;
|
---|
889 | const Elf_Shdr *pShdr = &paShdrs[pShdrRel->sh_info]; /* the section to fixup. */
|
---|
890 | if (!(pShdr->sh_flags & SHF_ALLOC))
|
---|
891 | continue;
|
---|
892 |
|
---|
893 | /*
|
---|
894 | * Relocate the section.
|
---|
895 | */
|
---|
896 | Log2(("rtldrELF: %s: Relocation records for #%d [%s] (sh_info=%d sh_link=%d) found in #%d [%s] (sh_info=%d sh_link=%d)\n",
|
---|
897 | pszLogName, (int)pShdrRel->sh_info, ELF_SH_STR(pModElf, pShdr->sh_name), (int)pShdr->sh_info, (int)pShdr->sh_link,
|
---|
898 | iShdr, ELF_SH_STR(pModElf, pShdrRel->sh_name), (int)pShdrRel->sh_info, (int)pShdrRel->sh_link));
|
---|
899 |
|
---|
900 | /** @todo Make RelocateSection a function pointer so we can select the one corresponding to the machine when opening the image. */
|
---|
901 | if (pModElf->Ehdr.e_type == ET_REL)
|
---|
902 | rc = RTLDRELF_NAME(RelocateSection)(pModElf, BaseAddr, pfnGetImport, pvUser,
|
---|
903 | pShdr->sh_addr,
|
---|
904 | pShdr->sh_size,
|
---|
905 | (const uint8_t *)pModElf->pvBits + pShdr->sh_offset,
|
---|
906 | (uint8_t *)pvBits + pShdr->sh_addr,
|
---|
907 | (const uint8_t *)pModElf->pvBits + pShdrRel->sh_offset,
|
---|
908 | pShdrRel->sh_size);
|
---|
909 | else
|
---|
910 | rc = RTLDRELF_NAME(RelocateSectionExecDyn)(pModElf, BaseAddr, pfnGetImport, pvUser,
|
---|
911 | pShdr->sh_addr,
|
---|
912 | pShdr->sh_size,
|
---|
913 | (const uint8_t *)pModElf->pvBits + pShdr->sh_offset,
|
---|
914 | (uint8_t *)pvBits + pShdr->sh_addr,
|
---|
915 | (const uint8_t *)pModElf->pvBits + pShdrRel->sh_offset,
|
---|
916 | pShdrRel->sh_size);
|
---|
917 | if (RT_FAILURE(rc))
|
---|
918 | return rc;
|
---|
919 | }
|
---|
920 | return VINF_SUCCESS;
|
---|
921 | }
|
---|
922 |
|
---|
923 |
|
---|
924 | /**
|
---|
925 | * Worker for pfnGetSymbolEx.
|
---|
926 | */
|
---|
927 | static int RTLDRELF_NAME(ReturnSymbol)(PRTLDRMODELF pThis, const Elf_Sym *pSym, Elf_Addr uBaseAddr, PRTUINTPTR pValue)
|
---|
928 | {
|
---|
929 | Elf_Addr Value;
|
---|
930 | if (pSym->st_shndx == SHN_ABS)
|
---|
931 | /* absolute symbols are not subject to any relocation. */
|
---|
932 | Value = pSym->st_value;
|
---|
933 | else if (pSym->st_shndx < pThis->Ehdr.e_shnum)
|
---|
934 | {
|
---|
935 | if (pThis->Ehdr.e_type == ET_REL)
|
---|
936 | /* relative to the section. */
|
---|
937 | Value = uBaseAddr + pSym->st_value + pThis->paShdrs[pSym->st_shndx].sh_addr;
|
---|
938 | else /* Fixed up for link address. */
|
---|
939 | Value = uBaseAddr + pSym->st_value - pThis->LinkAddress;
|
---|
940 | }
|
---|
941 | else
|
---|
942 | {
|
---|
943 | AssertMsgFailed(("Arg! pSym->st_shndx=%d\n", pSym->st_shndx));
|
---|
944 | return VERR_BAD_EXE_FORMAT;
|
---|
945 | }
|
---|
946 | AssertMsgReturn(Value == (RTUINTPTR)Value, (FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG);
|
---|
947 | *pValue = (RTUINTPTR)Value;
|
---|
948 | return VINF_SUCCESS;
|
---|
949 | }
|
---|
950 |
|
---|
951 |
|
---|
952 | /** @copydoc RTLDROPS::pfnGetSymbolEx */
|
---|
953 | static DECLCALLBACK(int) RTLDRELF_NAME(GetSymbolEx)(PRTLDRMODINTERNAL pMod, const void *pvBits, RTUINTPTR BaseAddress,
|
---|
954 | uint32_t iOrdinal, const char *pszSymbol, RTUINTPTR *pValue)
|
---|
955 | {
|
---|
956 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
957 | NOREF(pvBits);
|
---|
958 |
|
---|
959 | /*
|
---|
960 | * Validate the input.
|
---|
961 | */
|
---|
962 | Elf_Addr uBaseAddr = (Elf_Addr)BaseAddress;
|
---|
963 | AssertMsgReturn((RTUINTPTR)uBaseAddr == BaseAddress, ("#RTptr", BaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
|
---|
964 |
|
---|
965 | /*
|
---|
966 | * Map the image bits if not already done and setup pointer into it.
|
---|
967 | */
|
---|
968 | int rc = RTLDRELF_NAME(MapBits)(pModElf, true);
|
---|
969 | if (RT_FAILURE(rc))
|
---|
970 | return rc;
|
---|
971 |
|
---|
972 | /*
|
---|
973 | * Calc all kinds of pointers before we start iterating the symbol table.
|
---|
974 | */
|
---|
975 | const Elf_Sym *paSyms = pModElf->paSyms;
|
---|
976 | unsigned cSyms = pModElf->cSyms;
|
---|
977 | if (iOrdinal == UINT32_MAX)
|
---|
978 | {
|
---|
979 | const char *pStr = pModElf->pStr;
|
---|
980 | for (unsigned iSym = 1; iSym < cSyms; iSym++)
|
---|
981 | {
|
---|
982 | /* Undefined symbols are not exports, they are imports. */
|
---|
983 | if ( paSyms[iSym].st_shndx != SHN_UNDEF
|
---|
984 | && ( ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL
|
---|
985 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_WEAK))
|
---|
986 | {
|
---|
987 | /* Validate the name string and try match with it. */
|
---|
988 | if (paSyms[iSym].st_name < pModElf->cbStr)
|
---|
989 | {
|
---|
990 | if (!strcmp(pszSymbol, pStr + paSyms[iSym].st_name))
|
---|
991 | {
|
---|
992 | /* matched! */
|
---|
993 | return RTLDRELF_NAME(ReturnSymbol)(pModElf, &paSyms[iSym], uBaseAddr, pValue);
|
---|
994 | }
|
---|
995 | }
|
---|
996 | else
|
---|
997 | {
|
---|
998 | AssertMsgFailed(("String outside string table! iSym=%d paSyms[iSym].st_name=%#x\n", iSym, paSyms[iSym].st_name));
|
---|
999 | return VERR_LDRELF_INVALID_SYMBOL_NAME_OFFSET;
|
---|
1000 | }
|
---|
1001 | }
|
---|
1002 | }
|
---|
1003 | }
|
---|
1004 | else if (iOrdinal < cSyms)
|
---|
1005 | {
|
---|
1006 | if ( paSyms[iOrdinal].st_shndx != SHN_UNDEF
|
---|
1007 | && ( ELF_ST_BIND(paSyms[iOrdinal].st_info) == STB_GLOBAL
|
---|
1008 | || ELF_ST_BIND(paSyms[iOrdinal].st_info) == STB_WEAK))
|
---|
1009 | return RTLDRELF_NAME(ReturnSymbol)(pModElf, &paSyms[iOrdinal], uBaseAddr, pValue);
|
---|
1010 | }
|
---|
1011 |
|
---|
1012 | return VERR_SYMBOL_NOT_FOUND;
|
---|
1013 | }
|
---|
1014 |
|
---|
1015 |
|
---|
1016 | /** @copydoc RTLDROPS::pfnEnumDbgInfo */
|
---|
1017 | static DECLCALLBACK(int) RTLDRELF_NAME(EnumDbgInfo)(PRTLDRMODINTERNAL pMod, const void *pvBits,
|
---|
1018 | PFNRTLDRENUMDBG pfnCallback, void *pvUser)
|
---|
1019 | {
|
---|
1020 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
1021 |
|
---|
1022 | /*
|
---|
1023 | * Map the image bits if not already done and setup pointer into it.
|
---|
1024 | */
|
---|
1025 | int rc = RTLDRELF_NAME(MapBits)(pModElf, true);
|
---|
1026 | if (RT_FAILURE(rc))
|
---|
1027 | return rc;
|
---|
1028 |
|
---|
1029 | /*
|
---|
1030 | * Do the enumeration.
|
---|
1031 | */
|
---|
1032 | const Elf_Shdr *paShdrs = pModElf->paOrgShdrs;
|
---|
1033 | for (unsigned iShdr = 0; iShdr < pModElf->Ehdr.e_shnum; iShdr++)
|
---|
1034 | {
|
---|
1035 | /* Debug sections are expected to be PROGBITS and not allocated. */
|
---|
1036 | if (paShdrs[iShdr].sh_type != SHT_PROGBITS)
|
---|
1037 | continue;
|
---|
1038 | if (paShdrs[iShdr].sh_flags & SHF_ALLOC)
|
---|
1039 | continue;
|
---|
1040 |
|
---|
1041 | RTLDRDBGINFO DbgInfo;
|
---|
1042 | const char *pszSectName = ELF_SH_STR(pModElf, paShdrs[iShdr].sh_name);
|
---|
1043 | if ( !strncmp(pszSectName, RT_STR_TUPLE(".debug_"))
|
---|
1044 | || !strcmp(pszSectName, ".WATCOM_references") )
|
---|
1045 | {
|
---|
1046 | RT_ZERO(DbgInfo.u);
|
---|
1047 | DbgInfo.enmType = RTLDRDBGINFOTYPE_DWARF;
|
---|
1048 | DbgInfo.pszExtFile = NULL;
|
---|
1049 | DbgInfo.offFile = paShdrs[iShdr].sh_offset;
|
---|
1050 | DbgInfo.cb = paShdrs[iShdr].sh_size;
|
---|
1051 | DbgInfo.u.Dwarf.pszSection = pszSectName;
|
---|
1052 | }
|
---|
1053 | else if (!strcmp(pszSectName, ".gnu_debuglink"))
|
---|
1054 | {
|
---|
1055 | if ((paShdrs[iShdr].sh_size & 3) || paShdrs[iShdr].sh_size < 8)
|
---|
1056 | return VERR_BAD_EXE_FORMAT;
|
---|
1057 |
|
---|
1058 | RT_ZERO(DbgInfo.u);
|
---|
1059 | DbgInfo.enmType = RTLDRDBGINFOTYPE_DWARF_DWO;
|
---|
1060 | DbgInfo.pszExtFile = (const char *)((uintptr_t)pModElf->pvBits + (uintptr_t)paShdrs[iShdr].sh_offset);
|
---|
1061 | if (!RTStrEnd(DbgInfo.pszExtFile, paShdrs[iShdr].sh_size))
|
---|
1062 | return VERR_BAD_EXE_FORMAT;
|
---|
1063 | DbgInfo.u.Dwo.uCrc32 = *(uint32_t *)((uintptr_t)DbgInfo.pszExtFile + (uintptr_t)paShdrs[iShdr].sh_size
|
---|
1064 | - sizeof(uint32_t));
|
---|
1065 | DbgInfo.offFile = -1;
|
---|
1066 | DbgInfo.cb = 0;
|
---|
1067 | }
|
---|
1068 | else
|
---|
1069 | continue;
|
---|
1070 |
|
---|
1071 | DbgInfo.LinkAddress = NIL_RTLDRADDR;
|
---|
1072 | DbgInfo.iDbgInfo = iShdr - 1;
|
---|
1073 |
|
---|
1074 | rc = pfnCallback(pMod, &DbgInfo, pvUser);
|
---|
1075 | if (rc != VINF_SUCCESS)
|
---|
1076 | return rc;
|
---|
1077 |
|
---|
1078 | }
|
---|
1079 |
|
---|
1080 | return VINF_SUCCESS;
|
---|
1081 | }
|
---|
1082 |
|
---|
1083 |
|
---|
1084 | /**
|
---|
1085 | * Helper that locates the first allocated section.
|
---|
1086 | *
|
---|
1087 | * @returns Pointer to the section header if found, NULL if none.
|
---|
1088 | * @param pShdr The section header to start searching at.
|
---|
1089 | * @param cLeft The number of section headers left to search. Can be 0.
|
---|
1090 | */
|
---|
1091 | static const Elf_Shdr *RTLDRELF_NAME(GetFirstAllocatedSection)(const Elf_Shdr *pShdr, unsigned cLeft)
|
---|
1092 | {
|
---|
1093 | while (cLeft-- > 0)
|
---|
1094 | {
|
---|
1095 | if (pShdr->sh_flags & SHF_ALLOC)
|
---|
1096 | return pShdr;
|
---|
1097 | pShdr++;
|
---|
1098 | }
|
---|
1099 | return NULL;
|
---|
1100 | }
|
---|
1101 |
|
---|
1102 | /** @copydoc RTLDROPS::pfnEnumSegments. */
|
---|
1103 | static DECLCALLBACK(int) RTLDRELF_NAME(EnumSegments)(PRTLDRMODINTERNAL pMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser)
|
---|
1104 | {
|
---|
1105 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
1106 |
|
---|
1107 | /*
|
---|
1108 | * Map the image bits if not already done and setup pointer into it.
|
---|
1109 | */
|
---|
1110 | int rc = RTLDRELF_NAME(MapBits)(pModElf, true);
|
---|
1111 | if (RT_FAILURE(rc))
|
---|
1112 | return rc;
|
---|
1113 |
|
---|
1114 | /*
|
---|
1115 | * Do the enumeration.
|
---|
1116 | */
|
---|
1117 | char szName[32];
|
---|
1118 | Elf_Addr uPrevMappedRva = 0;
|
---|
1119 | const Elf_Shdr *paShdrs = pModElf->paShdrs;
|
---|
1120 | const Elf_Shdr *paOrgShdrs = pModElf->paOrgShdrs;
|
---|
1121 | for (unsigned iShdr = 1; iShdr < pModElf->Ehdr.e_shnum; iShdr++)
|
---|
1122 | {
|
---|
1123 | RTLDRSEG Seg;
|
---|
1124 | Seg.pszName = ELF_SH_STR(pModElf, paShdrs[iShdr].sh_name);
|
---|
1125 | Seg.cchName = (uint32_t)strlen(Seg.pszName);
|
---|
1126 | if (Seg.cchName == 0)
|
---|
1127 | {
|
---|
1128 | Seg.pszName = szName;
|
---|
1129 | Seg.cchName = (uint32_t)RTStrPrintf(szName, sizeof(szName), "UnamedSect%02u", iShdr);
|
---|
1130 | }
|
---|
1131 | Seg.SelFlat = 0;
|
---|
1132 | Seg.Sel16bit = 0;
|
---|
1133 | Seg.fFlags = 0;
|
---|
1134 | Seg.fProt = RTMEM_PROT_READ;
|
---|
1135 | if (paShdrs[iShdr].sh_flags & SHF_WRITE)
|
---|
1136 | Seg.fProt |= RTMEM_PROT_WRITE;
|
---|
1137 | if (paShdrs[iShdr].sh_flags & SHF_EXECINSTR)
|
---|
1138 | Seg.fProt |= RTMEM_PROT_EXEC;
|
---|
1139 | Seg.cb = paShdrs[iShdr].sh_size;
|
---|
1140 | Seg.Alignment = paShdrs[iShdr].sh_addralign;
|
---|
1141 | if (paShdrs[iShdr].sh_flags & SHF_ALLOC)
|
---|
1142 | {
|
---|
1143 | Seg.LinkAddress = paOrgShdrs[iShdr].sh_addr;
|
---|
1144 | Seg.RVA = paShdrs[iShdr].sh_addr;
|
---|
1145 | const Elf_Shdr *pShdr2 = RTLDRELF_NAME(GetFirstAllocatedSection)(&paShdrs[iShdr + 1],
|
---|
1146 | pModElf->Ehdr.e_shnum - iShdr - 1);
|
---|
1147 | if ( pShdr2
|
---|
1148 | && pShdr2->sh_addr >= paShdrs[iShdr].sh_addr
|
---|
1149 | && Seg.RVA >= uPrevMappedRva)
|
---|
1150 | Seg.cbMapped = pShdr2->sh_addr - paShdrs[iShdr].sh_addr;
|
---|
1151 | else
|
---|
1152 | Seg.cbMapped = RT_MAX(paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_addralign);
|
---|
1153 | uPrevMappedRva = Seg.RVA;
|
---|
1154 | }
|
---|
1155 | else
|
---|
1156 | {
|
---|
1157 | Seg.LinkAddress = NIL_RTLDRADDR;
|
---|
1158 | Seg.RVA = NIL_RTLDRADDR;
|
---|
1159 | Seg.cbMapped = NIL_RTLDRADDR;
|
---|
1160 | }
|
---|
1161 | if (paShdrs[iShdr].sh_type != SHT_NOBITS)
|
---|
1162 | {
|
---|
1163 | Seg.offFile = paShdrs[iShdr].sh_offset;
|
---|
1164 | Seg.cbFile = paShdrs[iShdr].sh_size;
|
---|
1165 | }
|
---|
1166 | else
|
---|
1167 | {
|
---|
1168 | Seg.offFile = -1;
|
---|
1169 | Seg.cbFile = 0;
|
---|
1170 | }
|
---|
1171 |
|
---|
1172 | rc = pfnCallback(pMod, &Seg, pvUser);
|
---|
1173 | if (rc != VINF_SUCCESS)
|
---|
1174 | return rc;
|
---|
1175 | }
|
---|
1176 |
|
---|
1177 | return VINF_SUCCESS;
|
---|
1178 | }
|
---|
1179 |
|
---|
1180 |
|
---|
1181 | /** @copydoc RTLDROPS::pfnLinkAddressToSegOffset. */
|
---|
1182 | static DECLCALLBACK(int) RTLDRELF_NAME(LinkAddressToSegOffset)(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress,
|
---|
1183 | uint32_t *piSeg, PRTLDRADDR poffSeg)
|
---|
1184 | {
|
---|
1185 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
1186 |
|
---|
1187 | const Elf_Shdr *pShdrEnd = NULL;
|
---|
1188 | unsigned cLeft = pModElf->Ehdr.e_shnum - 1;
|
---|
1189 | const Elf_Shdr *pShdr = &pModElf->paOrgShdrs[cLeft];
|
---|
1190 | while (cLeft-- > 0)
|
---|
1191 | {
|
---|
1192 | if (pShdr->sh_flags & SHF_ALLOC)
|
---|
1193 | {
|
---|
1194 | RTLDRADDR offSeg = LinkAddress - pShdr->sh_addr;
|
---|
1195 | if (offSeg < pShdr->sh_size)
|
---|
1196 | {
|
---|
1197 | *poffSeg = offSeg;
|
---|
1198 | *piSeg = cLeft;
|
---|
1199 | return VINF_SUCCESS;
|
---|
1200 | }
|
---|
1201 | if (offSeg == pShdr->sh_size)
|
---|
1202 | pShdrEnd = pShdr;
|
---|
1203 | }
|
---|
1204 | pShdr--;
|
---|
1205 | }
|
---|
1206 |
|
---|
1207 | if (pShdrEnd)
|
---|
1208 | {
|
---|
1209 | *poffSeg = pShdrEnd->sh_size;
|
---|
1210 | *piSeg = pShdrEnd - pModElf->paOrgShdrs - 1;
|
---|
1211 | return VINF_SUCCESS;
|
---|
1212 | }
|
---|
1213 |
|
---|
1214 | return VERR_LDR_INVALID_LINK_ADDRESS;
|
---|
1215 | }
|
---|
1216 |
|
---|
1217 |
|
---|
1218 | /** @copydoc RTLDROPS::pfnLinkAddressToRva. */
|
---|
1219 | static DECLCALLBACK(int) RTLDRELF_NAME(LinkAddressToRva)(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva)
|
---|
1220 | {
|
---|
1221 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
1222 | uint32_t iSeg;
|
---|
1223 | RTLDRADDR offSeg;
|
---|
1224 | int rc = RTLDRELF_NAME(LinkAddressToSegOffset)(pMod, LinkAddress, &iSeg, &offSeg);
|
---|
1225 | if (RT_SUCCESS(rc))
|
---|
1226 | *pRva = pModElf->paShdrs[iSeg + 1].sh_addr + offSeg;
|
---|
1227 | return rc;
|
---|
1228 | }
|
---|
1229 |
|
---|
1230 |
|
---|
1231 | /** @copydoc RTLDROPS::pfnSegOffsetToRva. */
|
---|
1232 | static DECLCALLBACK(int) RTLDRELF_NAME(SegOffsetToRva)(PRTLDRMODINTERNAL pMod, uint32_t iSeg, RTLDRADDR offSeg,
|
---|
1233 | PRTLDRADDR pRva)
|
---|
1234 | {
|
---|
1235 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
1236 | if (iSeg >= pModElf->Ehdr.e_shnum - 1U)
|
---|
1237 | return VERR_LDR_INVALID_SEG_OFFSET;
|
---|
1238 |
|
---|
1239 | iSeg++; /* skip section 0 */
|
---|
1240 | if (offSeg > pModElf->paShdrs[iSeg].sh_size)
|
---|
1241 | {
|
---|
1242 | const Elf_Shdr *pShdr2 = RTLDRELF_NAME(GetFirstAllocatedSection)(&pModElf->paShdrs[iSeg + 1],
|
---|
1243 | pModElf->Ehdr.e_shnum - iSeg - 1);
|
---|
1244 | if ( !pShdr2
|
---|
1245 | || offSeg > (pShdr2->sh_addr - pModElf->paShdrs[iSeg].sh_addr))
|
---|
1246 | return VERR_LDR_INVALID_SEG_OFFSET;
|
---|
1247 | }
|
---|
1248 |
|
---|
1249 | if (!(pModElf->paShdrs[iSeg].sh_flags & SHF_ALLOC))
|
---|
1250 | return VERR_LDR_INVALID_SEG_OFFSET;
|
---|
1251 |
|
---|
1252 | *pRva = pModElf->paShdrs[iSeg].sh_addr;
|
---|
1253 | return VINF_SUCCESS;
|
---|
1254 | }
|
---|
1255 |
|
---|
1256 |
|
---|
1257 | /** @copydoc RTLDROPS::pfnRvaToSegOffset. */
|
---|
1258 | static DECLCALLBACK(int) RTLDRELF_NAME(RvaToSegOffset)(PRTLDRMODINTERNAL pMod, RTLDRADDR Rva,
|
---|
1259 | uint32_t *piSeg, PRTLDRADDR poffSeg)
|
---|
1260 | {
|
---|
1261 | PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
|
---|
1262 |
|
---|
1263 | Elf_Addr PrevAddr = 0;
|
---|
1264 | unsigned cLeft = pModElf->Ehdr.e_shnum - 1;
|
---|
1265 | const Elf_Shdr *pShdr = &pModElf->paShdrs[cLeft];
|
---|
1266 | while (cLeft-- > 0)
|
---|
1267 | {
|
---|
1268 | if (pShdr->sh_flags & SHF_ALLOC)
|
---|
1269 | {
|
---|
1270 | Elf_Addr cbSeg = PrevAddr ? PrevAddr - pShdr->sh_addr : pShdr->sh_size;
|
---|
1271 | RTLDRADDR offSeg = Rva - pShdr->sh_addr;
|
---|
1272 | if (offSeg <= cbSeg)
|
---|
1273 | {
|
---|
1274 | *poffSeg = offSeg;
|
---|
1275 | *piSeg = cLeft;
|
---|
1276 | return VINF_SUCCESS;
|
---|
1277 | }
|
---|
1278 | PrevAddr = pShdr->sh_addr;
|
---|
1279 | }
|
---|
1280 | pShdr--;
|
---|
1281 | }
|
---|
1282 |
|
---|
1283 | return VERR_LDR_INVALID_RVA;
|
---|
1284 | }
|
---|
1285 |
|
---|
1286 |
|
---|
1287 | /** @callback_method_impl{FNRTLDRIMPORT, Stub used by ReadDbgInfo.} */
|
---|
1288 | static DECLCALLBACK(int) RTLDRELF_NAME(GetImportStubCallback)(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol,
|
---|
1289 | unsigned uSymbol, PRTLDRADDR pValue, void *pvUser)
|
---|
1290 | {
|
---|
1291 | return VERR_SYMBOL_NOT_FOUND;
|
---|
1292 | }
|
---|
1293 |
|
---|
1294 |
|
---|
1295 | /** @copydoc RTLDROPS::pfnRvaToSegOffset. */
|
---|
1296 | static DECLCALLBACK(int) RTLDRELF_NAME(ReadDbgInfo)(PRTLDRMODINTERNAL pMod, uint32_t iDbgInfo, RTFOFF off,
|
---|
1297 | size_t cb, void *pvBuf)
|
---|
1298 | {
|
---|
1299 | PRTLDRMODELF pThis = (PRTLDRMODELF)pMod;
|
---|
1300 | LogFlow(("%s: iDbgInfo=%#x off=%RTfoff cb=%#zu\n", __FUNCTION__, iDbgInfo, off, cb));
|
---|
1301 |
|
---|
1302 | /*
|
---|
1303 | * Input validation.
|
---|
1304 | */
|
---|
1305 | AssertReturn(iDbgInfo < pThis->Ehdr.e_shnum && iDbgInfo + 1 < pThis->Ehdr.e_shnum, VERR_INVALID_PARAMETER);
|
---|
1306 | iDbgInfo++;
|
---|
1307 | AssertReturn(!(pThis->paShdrs[iDbgInfo].sh_flags & SHF_ALLOC), VERR_INVALID_PARAMETER);
|
---|
1308 | AssertReturn(pThis->paShdrs[iDbgInfo].sh_type == SHT_PROGBITS, VERR_INVALID_PARAMETER);
|
---|
1309 | AssertReturn(pThis->paShdrs[iDbgInfo].sh_offset == (uint64_t)off, VERR_INVALID_PARAMETER);
|
---|
1310 | AssertReturn(pThis->paShdrs[iDbgInfo].sh_size == cb, VERR_INVALID_PARAMETER);
|
---|
1311 | RTFOFF cbRawImage = pThis->Core.pReader->pfnSize(pThis->Core.pReader);
|
---|
1312 | AssertReturn(cbRawImage >= 0, VERR_INVALID_PARAMETER);
|
---|
1313 | AssertReturn(off >= 0 && cb <= (uint64_t)cbRawImage && (uint64_t)off + cb <= (uint64_t)cbRawImage, VERR_INVALID_PARAMETER);
|
---|
1314 |
|
---|
1315 | /*
|
---|
1316 | * Read it from the file and look for fixup sections.
|
---|
1317 | */
|
---|
1318 | int rc;
|
---|
1319 | if (pThis->pvBits)
|
---|
1320 | memcpy(pvBuf, (const uint8_t *)pThis->pvBits + (size_t)off, cb);
|
---|
1321 | else
|
---|
1322 | {
|
---|
1323 | rc = pThis->Core.pReader->pfnRead(pThis->Core.pReader, pvBuf, cb, off);
|
---|
1324 | if (RT_FAILURE(rc))
|
---|
1325 | return rc;
|
---|
1326 | }
|
---|
1327 |
|
---|
1328 | uint32_t iRelocs = iDbgInfo + 1;
|
---|
1329 | if ( iRelocs >= pThis->Ehdr.e_shnum
|
---|
1330 | || pThis->paShdrs[iRelocs].sh_info != iDbgInfo
|
---|
1331 | || ( pThis->paShdrs[iRelocs].sh_type != SHT_REL
|
---|
1332 | && pThis->paShdrs[iRelocs].sh_type != SHT_RELA) )
|
---|
1333 | {
|
---|
1334 | iRelocs = 0;
|
---|
1335 | while ( iRelocs < pThis->Ehdr.e_shnum
|
---|
1336 | && ( pThis->paShdrs[iRelocs].sh_info != iDbgInfo
|
---|
1337 | || ( pThis->paShdrs[iRelocs].sh_type != SHT_REL
|
---|
1338 | && pThis->paShdrs[iRelocs].sh_type != SHT_RELA)) )
|
---|
1339 | iRelocs++;
|
---|
1340 | }
|
---|
1341 | if ( iRelocs < pThis->Ehdr.e_shnum
|
---|
1342 | && pThis->paShdrs[iRelocs].sh_size > 0)
|
---|
1343 | {
|
---|
1344 | /*
|
---|
1345 | * Load the relocations.
|
---|
1346 | */
|
---|
1347 | uint8_t *pbRelocsBuf = NULL;
|
---|
1348 | const uint8_t *pbRelocs;
|
---|
1349 | if (pThis->pvBits)
|
---|
1350 | pbRelocs = (const uint8_t *)pThis->pvBits + pThis->paShdrs[iRelocs].sh_offset;
|
---|
1351 | else
|
---|
1352 | {
|
---|
1353 | pbRelocs = pbRelocsBuf = (uint8_t *)RTMemTmpAlloc(pThis->paShdrs[iRelocs].sh_size);
|
---|
1354 | if (!pbRelocsBuf)
|
---|
1355 | return VERR_NO_TMP_MEMORY;
|
---|
1356 | rc = pThis->Core.pReader->pfnRead(pThis->Core.pReader, pbRelocsBuf,
|
---|
1357 | pThis->paShdrs[iRelocs].sh_size,
|
---|
1358 | pThis->paShdrs[iRelocs].sh_offset);
|
---|
1359 | if (RT_FAILURE(rc))
|
---|
1360 | {
|
---|
1361 | RTMemTmpFree(pbRelocsBuf);
|
---|
1362 | return rc;
|
---|
1363 | }
|
---|
1364 | }
|
---|
1365 |
|
---|
1366 | /*
|
---|
1367 | * Apply the relocations.
|
---|
1368 | */
|
---|
1369 | if (pThis->Ehdr.e_type == ET_REL)
|
---|
1370 | rc = RTLDRELF_NAME(RelocateSection)(pThis, pThis->LinkAddress,
|
---|
1371 | RTLDRELF_NAME(GetImportStubCallback), NULL /*pvUser*/,
|
---|
1372 | pThis->paShdrs[iDbgInfo].sh_addr,
|
---|
1373 | pThis->paShdrs[iDbgInfo].sh_size,
|
---|
1374 | (const uint8_t *)pvBuf,
|
---|
1375 | (uint8_t *)pvBuf,
|
---|
1376 | pbRelocs,
|
---|
1377 | pThis->paShdrs[iRelocs].sh_size);
|
---|
1378 | else
|
---|
1379 | rc = RTLDRELF_NAME(RelocateSectionExecDyn)(pThis, pThis->LinkAddress,
|
---|
1380 | RTLDRELF_NAME(GetImportStubCallback), NULL /*pvUser*/,
|
---|
1381 | pThis->paShdrs[iDbgInfo].sh_addr,
|
---|
1382 | pThis->paShdrs[iDbgInfo].sh_size,
|
---|
1383 | (const uint8_t *)pvBuf,
|
---|
1384 | (uint8_t *)pvBuf,
|
---|
1385 | pbRelocs,
|
---|
1386 | pThis->paShdrs[iRelocs].sh_size);
|
---|
1387 |
|
---|
1388 | RTMemTmpFree(pbRelocsBuf);
|
---|
1389 | }
|
---|
1390 | else
|
---|
1391 | rc = VINF_SUCCESS;
|
---|
1392 | return rc;
|
---|
1393 | }
|
---|
1394 |
|
---|
1395 |
|
---|
1396 |
|
---|
1397 | /**
|
---|
1398 | * The ELF module operations.
|
---|
1399 | */
|
---|
1400 | static RTLDROPS RTLDRELF_MID(s_rtldrElf,Ops) =
|
---|
1401 | {
|
---|
1402 | #if ELF_MODE == 32
|
---|
1403 | "elf32",
|
---|
1404 | #elif ELF_MODE == 64
|
---|
1405 | "elf64",
|
---|
1406 | #endif
|
---|
1407 | RTLDRELF_NAME(Close),
|
---|
1408 | NULL, /* Get Symbol */
|
---|
1409 | RTLDRELF_NAME(Done),
|
---|
1410 | RTLDRELF_NAME(EnumSymbols),
|
---|
1411 | /* ext: */
|
---|
1412 | RTLDRELF_NAME(GetImageSize),
|
---|
1413 | RTLDRELF_NAME(GetBits),
|
---|
1414 | RTLDRELF_NAME(Relocate),
|
---|
1415 | RTLDRELF_NAME(GetSymbolEx),
|
---|
1416 | NULL /*pfnQueryForwarderInfo*/,
|
---|
1417 | RTLDRELF_NAME(EnumDbgInfo),
|
---|
1418 | RTLDRELF_NAME(EnumSegments),
|
---|
1419 | RTLDRELF_NAME(LinkAddressToSegOffset),
|
---|
1420 | RTLDRELF_NAME(LinkAddressToRva),
|
---|
1421 | RTLDRELF_NAME(SegOffsetToRva),
|
---|
1422 | RTLDRELF_NAME(RvaToSegOffset),
|
---|
1423 | RTLDRELF_NAME(ReadDbgInfo),
|
---|
1424 | NULL /*pfnQueryProp*/,
|
---|
1425 | NULL /*pfnVerifySignature*/,
|
---|
1426 | NULL /*pfnHashImage*/,
|
---|
1427 | 42
|
---|
1428 | };
|
---|
1429 |
|
---|
1430 |
|
---|
1431 |
|
---|
1432 | /**
|
---|
1433 | * Validates the ELF header.
|
---|
1434 | *
|
---|
1435 | * @returns iprt status code.
|
---|
1436 | * @param pEhdr Pointer to the ELF header.
|
---|
1437 | * @param pszLogName The log name.
|
---|
1438 | * @param cbRawImage The size of the raw image.
|
---|
1439 | */
|
---|
1440 | static int RTLDRELF_NAME(ValidateElfHeader)(const Elf_Ehdr *pEhdr, const char *pszLogName, uint64_t cbRawImage,
|
---|
1441 | PRTLDRARCH penmArch)
|
---|
1442 | {
|
---|
1443 | Log3(("RTLdrELF: e_ident: %.*Rhxs\n"
|
---|
1444 | "RTLdrELF: e_type: " FMT_ELF_HALF "\n"
|
---|
1445 | "RTLdrELF: e_version: " FMT_ELF_HALF "\n"
|
---|
1446 | "RTLdrELF: e_entry: " FMT_ELF_ADDR "\n"
|
---|
1447 | "RTLdrELF: e_phoff: " FMT_ELF_OFF "\n"
|
---|
1448 | "RTLdrELF: e_shoff: " FMT_ELF_OFF "\n"
|
---|
1449 | "RTLdrELF: e_flags: " FMT_ELF_WORD "\n"
|
---|
1450 | "RTLdrELF: e_ehsize: " FMT_ELF_HALF "\n"
|
---|
1451 | "RTLdrELF: e_phentsize: " FMT_ELF_HALF "\n"
|
---|
1452 | "RTLdrELF: e_phnum: " FMT_ELF_HALF "\n"
|
---|
1453 | "RTLdrELF: e_shentsize: " FMT_ELF_HALF "\n"
|
---|
1454 | "RTLdrELF: e_shnum: " FMT_ELF_HALF "\n"
|
---|
1455 | "RTLdrELF: e_shstrndx: " FMT_ELF_HALF "\n",
|
---|
1456 | RT_ELEMENTS(pEhdr->e_ident), &pEhdr->e_ident[0], pEhdr->e_type, pEhdr->e_version,
|
---|
1457 | pEhdr->e_entry, pEhdr->e_phoff, pEhdr->e_shoff,pEhdr->e_flags, pEhdr->e_ehsize, pEhdr->e_phentsize,
|
---|
1458 | pEhdr->e_phnum, pEhdr->e_shentsize, pEhdr->e_shnum, pEhdr->e_shstrndx));
|
---|
1459 |
|
---|
1460 | if ( pEhdr->e_ident[EI_MAG0] != ELFMAG0
|
---|
1461 | || pEhdr->e_ident[EI_MAG1] != ELFMAG1
|
---|
1462 | || pEhdr->e_ident[EI_MAG2] != ELFMAG2
|
---|
1463 | || pEhdr->e_ident[EI_MAG3] != ELFMAG3
|
---|
1464 | )
|
---|
1465 | {
|
---|
1466 | Log(("RTLdrELF: %s: Invalid ELF magic (%.*Rhxs)\n", pszLogName, sizeof(pEhdr->e_ident), pEhdr->e_ident)); NOREF(pszLogName);
|
---|
1467 | return VERR_BAD_EXE_FORMAT;
|
---|
1468 | }
|
---|
1469 | if (pEhdr->e_ident[EI_CLASS] != RTLDRELF_SUFF(ELFCLASS))
|
---|
1470 | {
|
---|
1471 | Log(("RTLdrELF: %s: Invalid ELF class (%.*Rhxs)\n", pszLogName, sizeof(pEhdr->e_ident), pEhdr->e_ident));
|
---|
1472 | return VERR_BAD_EXE_FORMAT;
|
---|
1473 | }
|
---|
1474 | if (pEhdr->e_ident[EI_DATA] != ELFDATA2LSB)
|
---|
1475 | {
|
---|
1476 | Log(("RTLdrELF: %s: ELF endian %x is unsupported\n", pEhdr->e_ident[EI_DATA]));
|
---|
1477 | return VERR_LDRELF_ODD_ENDIAN;
|
---|
1478 | }
|
---|
1479 | if (pEhdr->e_version != EV_CURRENT)
|
---|
1480 | {
|
---|
1481 | Log(("RTLdrELF: %s: ELF version %x is unsupported\n", pEhdr->e_version));
|
---|
1482 | return VERR_LDRELF_VERSION;
|
---|
1483 | }
|
---|
1484 |
|
---|
1485 | if (sizeof(Elf_Ehdr) != pEhdr->e_ehsize)
|
---|
1486 | {
|
---|
1487 | Log(("RTLdrELF: %s: Elf header e_ehsize is %d expected %d!\n",
|
---|
1488 | pszLogName, pEhdr->e_ehsize, sizeof(Elf_Ehdr)));
|
---|
1489 | return VERR_BAD_EXE_FORMAT;
|
---|
1490 | }
|
---|
1491 | if ( sizeof(Elf_Phdr) != pEhdr->e_phentsize
|
---|
1492 | && ( pEhdr->e_phnum != 0
|
---|
1493 | || pEhdr->e_type == ET_DYN))
|
---|
1494 | {
|
---|
1495 | Log(("RTLdrELF: %s: Elf header e_phentsize is %d expected %d!\n",
|
---|
1496 | pszLogName, pEhdr->e_phentsize, sizeof(Elf_Phdr)));
|
---|
1497 | return VERR_BAD_EXE_FORMAT;
|
---|
1498 | }
|
---|
1499 | if (sizeof(Elf_Shdr) != pEhdr->e_shentsize)
|
---|
1500 | {
|
---|
1501 | Log(("RTLdrELF: %s: Elf header e_shentsize is %d expected %d!\n",
|
---|
1502 | pszLogName, pEhdr->e_shentsize, sizeof(Elf_Shdr)));
|
---|
1503 | return VERR_BAD_EXE_FORMAT;
|
---|
1504 | }
|
---|
1505 |
|
---|
1506 | switch (pEhdr->e_type)
|
---|
1507 | {
|
---|
1508 | case ET_REL:
|
---|
1509 | case ET_EXEC:
|
---|
1510 | case ET_DYN:
|
---|
1511 | break;
|
---|
1512 | default:
|
---|
1513 | Log(("RTLdrELF: %s: image type %#x is not supported!\n", pszLogName, pEhdr->e_type));
|
---|
1514 | return VERR_BAD_EXE_FORMAT;
|
---|
1515 | }
|
---|
1516 |
|
---|
1517 | switch (pEhdr->e_machine)
|
---|
1518 | {
|
---|
1519 | #if ELF_MODE == 32
|
---|
1520 | case EM_386:
|
---|
1521 | case EM_486:
|
---|
1522 | *penmArch = RTLDRARCH_X86_32;
|
---|
1523 | break;
|
---|
1524 | #elif ELF_MODE == 64
|
---|
1525 | case EM_X86_64:
|
---|
1526 | *penmArch = RTLDRARCH_AMD64;
|
---|
1527 | break;
|
---|
1528 | #endif
|
---|
1529 | default:
|
---|
1530 | Log(("RTLdrELF: %s: machine type %u is not supported!\n", pEhdr->e_machine));
|
---|
1531 | return VERR_LDRELF_MACHINE;
|
---|
1532 | }
|
---|
1533 |
|
---|
1534 | if ( pEhdr->e_phoff < pEhdr->e_ehsize
|
---|
1535 | && !(pEhdr->e_phoff && pEhdr->e_phnum)
|
---|
1536 | && pEhdr->e_phnum)
|
---|
1537 | {
|
---|
1538 | Log(("RTLdrELF: %s: The program headers overlap with the ELF header! e_phoff=" FMT_ELF_OFF "\n",
|
---|
1539 | pszLogName, pEhdr->e_phoff));
|
---|
1540 | return VERR_BAD_EXE_FORMAT;
|
---|
1541 | }
|
---|
1542 | if ( pEhdr->e_phoff + pEhdr->e_phnum * pEhdr->e_phentsize > cbRawImage
|
---|
1543 | || pEhdr->e_phoff + pEhdr->e_phnum * pEhdr->e_phentsize < pEhdr->e_phoff)
|
---|
1544 | {
|
---|
1545 | Log(("RTLdrELF: %s: The program headers extends beyond the file! e_phoff=" FMT_ELF_OFF " e_phnum=" FMT_ELF_HALF "\n",
|
---|
1546 | pszLogName, pEhdr->e_phoff, pEhdr->e_phnum));
|
---|
1547 | return VERR_BAD_EXE_FORMAT;
|
---|
1548 | }
|
---|
1549 |
|
---|
1550 |
|
---|
1551 | if ( pEhdr->e_shoff < pEhdr->e_ehsize
|
---|
1552 | && !(pEhdr->e_shoff && pEhdr->e_shnum))
|
---|
1553 | {
|
---|
1554 | Log(("RTLdrELF: %s: The section headers overlap with the ELF header! e_shoff=" FMT_ELF_OFF "\n",
|
---|
1555 | pszLogName, pEhdr->e_shoff));
|
---|
1556 | return VERR_BAD_EXE_FORMAT;
|
---|
1557 | }
|
---|
1558 | if ( pEhdr->e_shoff + pEhdr->e_shnum * pEhdr->e_shentsize > cbRawImage
|
---|
1559 | || pEhdr->e_shoff + pEhdr->e_shnum * pEhdr->e_shentsize < pEhdr->e_shoff)
|
---|
1560 | {
|
---|
1561 | Log(("RTLdrELF: %s: The section headers extends beyond the file! e_shoff=" FMT_ELF_OFF " e_shnum=" FMT_ELF_HALF "\n",
|
---|
1562 | pszLogName, pEhdr->e_shoff, pEhdr->e_shnum));
|
---|
1563 | return VERR_BAD_EXE_FORMAT;
|
---|
1564 | }
|
---|
1565 |
|
---|
1566 | if (pEhdr->e_shstrndx == 0 || pEhdr->e_shstrndx > pEhdr->e_shnum)
|
---|
1567 | {
|
---|
1568 | Log(("RTLdrELF: %s: The section headers string table is out of bounds! e_shstrndx=" FMT_ELF_HALF " e_shnum=" FMT_ELF_HALF "\n",
|
---|
1569 | pszLogName, pEhdr->e_shstrndx, pEhdr->e_shnum));
|
---|
1570 | return VERR_BAD_EXE_FORMAT;
|
---|
1571 | }
|
---|
1572 |
|
---|
1573 | return VINF_SUCCESS;
|
---|
1574 | }
|
---|
1575 |
|
---|
1576 | /**
|
---|
1577 | * Gets the section header name.
|
---|
1578 | *
|
---|
1579 | * @returns pszName.
|
---|
1580 | * @param pEhdr The elf header.
|
---|
1581 | * @param offName The offset of the section header name.
|
---|
1582 | * @param pszName Where to store the name.
|
---|
1583 | * @param cbName The size of the buffer pointed to by pszName.
|
---|
1584 | */
|
---|
1585 | const char *RTLDRELF_NAME(GetSHdrName)(PRTLDRMODELF pModElf, Elf_Word offName, char *pszName, size_t cbName)
|
---|
1586 | {
|
---|
1587 | RTFOFF off = pModElf->paShdrs[pModElf->Ehdr.e_shstrndx].sh_offset + offName;
|
---|
1588 | int rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, pszName, cbName - 1, off);
|
---|
1589 | if (RT_FAILURE(rc))
|
---|
1590 | {
|
---|
1591 | /* read by for byte. */
|
---|
1592 | for (unsigned i = 0; i < cbName; i++, off++)
|
---|
1593 | {
|
---|
1594 | rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, pszName + i, 1, off);
|
---|
1595 | if (RT_FAILURE(rc))
|
---|
1596 | {
|
---|
1597 | pszName[i] = '\0';
|
---|
1598 | break;
|
---|
1599 | }
|
---|
1600 | }
|
---|
1601 | }
|
---|
1602 |
|
---|
1603 | pszName[cbName - 1] = '\0';
|
---|
1604 | return pszName;
|
---|
1605 | }
|
---|
1606 |
|
---|
1607 |
|
---|
1608 | /**
|
---|
1609 | * Validates a section header.
|
---|
1610 | *
|
---|
1611 | * @returns iprt status code.
|
---|
1612 | * @param pModElf Pointer to the module structure.
|
---|
1613 | * @param iShdr The index of section header which should be validated.
|
---|
1614 | * The section headers are found in the pModElf->paShdrs array.
|
---|
1615 | * @param pszLogName The log name.
|
---|
1616 | * @param cbRawImage The size of the raw image.
|
---|
1617 | */
|
---|
1618 | static int RTLDRELF_NAME(ValidateSectionHeader)(PRTLDRMODELF pModElf, unsigned iShdr, const char *pszLogName, RTFOFF cbRawImage)
|
---|
1619 | {
|
---|
1620 | const Elf_Shdr *pShdr = &pModElf->paShdrs[iShdr];
|
---|
1621 | char szSectionName[80]; NOREF(szSectionName);
|
---|
1622 | Log3(("RTLdrELF: Section Header #%d:\n"
|
---|
1623 | "RTLdrELF: sh_name: " FMT_ELF_WORD " - %s\n"
|
---|
1624 | "RTLdrELF: sh_type: " FMT_ELF_WORD " (%s)\n"
|
---|
1625 | "RTLdrELF: sh_flags: " FMT_ELF_XWORD "\n"
|
---|
1626 | "RTLdrELF: sh_addr: " FMT_ELF_ADDR "\n"
|
---|
1627 | "RTLdrELF: sh_offset: " FMT_ELF_OFF "\n"
|
---|
1628 | "RTLdrELF: sh_size: " FMT_ELF_XWORD "\n"
|
---|
1629 | "RTLdrELF: sh_link: " FMT_ELF_WORD "\n"
|
---|
1630 | "RTLdrELF: sh_info: " FMT_ELF_WORD "\n"
|
---|
1631 | "RTLdrELF: sh_addralign: " FMT_ELF_XWORD "\n"
|
---|
1632 | "RTLdrELF: sh_entsize: " FMT_ELF_XWORD "\n",
|
---|
1633 | iShdr,
|
---|
1634 | pShdr->sh_name, RTLDRELF_NAME(GetSHdrName)(pModElf, pShdr->sh_name, szSectionName, sizeof(szSectionName)),
|
---|
1635 | pShdr->sh_type, rtldrElfGetShdrType(pShdr->sh_type), pShdr->sh_flags, pShdr->sh_addr,
|
---|
1636 | pShdr->sh_offset, pShdr->sh_size, pShdr->sh_link, pShdr->sh_info, pShdr->sh_addralign,
|
---|
1637 | pShdr->sh_entsize));
|
---|
1638 |
|
---|
1639 | if (iShdr == 0)
|
---|
1640 | {
|
---|
1641 | if ( pShdr->sh_name != 0
|
---|
1642 | || pShdr->sh_type != SHT_NULL
|
---|
1643 | || pShdr->sh_flags != 0
|
---|
1644 | || pShdr->sh_addr != 0
|
---|
1645 | || pShdr->sh_size != 0
|
---|
1646 | || pShdr->sh_offset != 0
|
---|
1647 | || pShdr->sh_link != SHN_UNDEF
|
---|
1648 | || pShdr->sh_addralign != 0
|
---|
1649 | || pShdr->sh_entsize != 0 )
|
---|
1650 | {
|
---|
1651 | Log(("RTLdrELF: %s: Bad #0 section: %.*Rhxs\n", pszLogName, sizeof(*pShdr), pShdr ));
|
---|
1652 | return VERR_BAD_EXE_FORMAT;
|
---|
1653 | }
|
---|
1654 | return VINF_SUCCESS;
|
---|
1655 | }
|
---|
1656 |
|
---|
1657 | if (pShdr->sh_name >= pModElf->cbShStr)
|
---|
1658 | {
|
---|
1659 | Log(("RTLdrELF: %s: Shdr #%d: sh_name (%d) is beyond the end of the section header string table (%d)!\n",
|
---|
1660 | pszLogName, iShdr, pShdr->sh_name, pModElf->cbShStr)); NOREF(pszLogName);
|
---|
1661 | return VERR_BAD_EXE_FORMAT;
|
---|
1662 | }
|
---|
1663 |
|
---|
1664 | if (pShdr->sh_link >= pModElf->Ehdr.e_shnum)
|
---|
1665 | {
|
---|
1666 | Log(("RTLdrELF: %s: Shdr #%d: sh_link (%d) is beyond the end of the section table (%d)!\n",
|
---|
1667 | pszLogName, iShdr, pShdr->sh_link, pModElf->Ehdr.e_shnum)); NOREF(pszLogName);
|
---|
1668 | return VERR_BAD_EXE_FORMAT;
|
---|
1669 | }
|
---|
1670 |
|
---|
1671 | switch (pShdr->sh_type)
|
---|
1672 | {
|
---|
1673 | /** @todo find specs and check up which sh_info fields indicates section table entries */
|
---|
1674 | case 12301230:
|
---|
1675 | if (pShdr->sh_info >= pModElf->Ehdr.e_shnum)
|
---|
1676 | {
|
---|
1677 | Log(("RTLdrELF: %s: Shdr #%d: sh_info (%d) is beyond the end of the section table (%d)!\n",
|
---|
1678 | pszLogName, iShdr, pShdr->sh_link, pModElf->Ehdr.e_shnum));
|
---|
1679 | return VERR_BAD_EXE_FORMAT;
|
---|
1680 | }
|
---|
1681 | break;
|
---|
1682 |
|
---|
1683 | case SHT_NULL:
|
---|
1684 | break;
|
---|
1685 | case SHT_PROGBITS:
|
---|
1686 | case SHT_SYMTAB:
|
---|
1687 | case SHT_STRTAB:
|
---|
1688 | case SHT_RELA:
|
---|
1689 | case SHT_HASH:
|
---|
1690 | case SHT_DYNAMIC:
|
---|
1691 | case SHT_NOTE:
|
---|
1692 | case SHT_NOBITS:
|
---|
1693 | case SHT_REL:
|
---|
1694 | case SHT_SHLIB:
|
---|
1695 | case SHT_DYNSYM:
|
---|
1696 | /*
|
---|
1697 | * For these types sh_info doesn't have any special meaning, or anything which
|
---|
1698 | * we need/can validate now.
|
---|
1699 | */
|
---|
1700 | break;
|
---|
1701 |
|
---|
1702 |
|
---|
1703 | default:
|
---|
1704 | Log(("RTLdrELF: %s: Warning, unknown type %d!\n", pszLogName, pShdr->sh_type));
|
---|
1705 | break;
|
---|
1706 | }
|
---|
1707 |
|
---|
1708 | if ( pShdr->sh_type != SHT_NOBITS
|
---|
1709 | && pShdr->sh_size)
|
---|
1710 | {
|
---|
1711 | RTFOFF offEnd = pShdr->sh_offset + pShdr->sh_size;
|
---|
1712 | if ( offEnd > cbRawImage
|
---|
1713 | || offEnd < (RTFOFF)pShdr->sh_offset)
|
---|
1714 | {
|
---|
1715 | Log(("RTLdrELF: %s: Shdr #%d: sh_offset (" FMT_ELF_OFF ") + sh_size (" FMT_ELF_XWORD " = %RTfoff) is beyond the end of the file (%RTfoff)!\n",
|
---|
1716 | pszLogName, iShdr, pShdr->sh_offset, pShdr->sh_size, offEnd, cbRawImage));
|
---|
1717 | return VERR_BAD_EXE_FORMAT;
|
---|
1718 | }
|
---|
1719 | if (pShdr->sh_offset < sizeof(Elf_Ehdr))
|
---|
1720 | {
|
---|
1721 | Log(("RTLdrELF: %s: Shdr #%d: sh_offset (" FMT_ELF_OFF ") + sh_size (" FMT_ELF_XWORD ") is starting in the ELF header!\n",
|
---|
1722 | pszLogName, iShdr, pShdr->sh_offset, pShdr->sh_size, cbRawImage));
|
---|
1723 | return VERR_BAD_EXE_FORMAT;
|
---|
1724 | }
|
---|
1725 | }
|
---|
1726 |
|
---|
1727 | return VINF_SUCCESS;
|
---|
1728 | }
|
---|
1729 |
|
---|
1730 |
|
---|
1731 |
|
---|
1732 | /**
|
---|
1733 | * Opens an ELF image, fixed bitness.
|
---|
1734 | *
|
---|
1735 | * @returns iprt status code.
|
---|
1736 | * @param pReader The loader reader instance which will provide the raw image bits.
|
---|
1737 | * @param fFlags Reserved, MBZ.
|
---|
1738 | * @param enmArch Architecture specifier.
|
---|
1739 | * @param phLdrMod Where to store the handle.
|
---|
1740 | */
|
---|
1741 | static int RTLDRELF_NAME(Open)(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod)
|
---|
1742 | {
|
---|
1743 | const char *pszLogName = pReader->pfnLogName(pReader);
|
---|
1744 | RTFOFF cbRawImage = pReader->pfnSize(pReader);
|
---|
1745 |
|
---|
1746 | /*
|
---|
1747 | * Create the loader module instance.
|
---|
1748 | */
|
---|
1749 | PRTLDRMODELF pModElf = (PRTLDRMODELF)RTMemAllocZ(sizeof(*pModElf));
|
---|
1750 | if (!pModElf)
|
---|
1751 | return VERR_NO_MEMORY;
|
---|
1752 |
|
---|
1753 | pModElf->Core.u32Magic = RTLDRMOD_MAGIC;
|
---|
1754 | pModElf->Core.eState = LDR_STATE_INVALID;
|
---|
1755 | pModElf->Core.pReader = pReader;
|
---|
1756 | pModElf->Core.enmFormat = RTLDRFMT_ELF;
|
---|
1757 | pModElf->Core.enmType = RTLDRTYPE_OBJECT;
|
---|
1758 | pModElf->Core.enmEndian = RTLDRENDIAN_LITTLE;
|
---|
1759 | #if ELF_MODE == 32
|
---|
1760 | pModElf->Core.enmArch = RTLDRARCH_X86_32;
|
---|
1761 | #else
|
---|
1762 | pModElf->Core.enmArch = RTLDRARCH_AMD64;
|
---|
1763 | #endif
|
---|
1764 | //pModElf->pvBits = NULL;
|
---|
1765 | //pModElf->Ehdr = {0};
|
---|
1766 | //pModElf->paShdrs = NULL;
|
---|
1767 | //pModElf->paSyms = NULL;
|
---|
1768 | pModElf->iSymSh = ~0U;
|
---|
1769 | //pModElf->cSyms = 0;
|
---|
1770 | pModElf->iStrSh = ~0U;
|
---|
1771 | //pModElf->cbStr = 0;
|
---|
1772 | //pModElf->cbImage = 0;
|
---|
1773 | //pModElf->LinkAddress = 0;
|
---|
1774 | //pModElf->pStr = NULL;
|
---|
1775 | //pModElf->cbShStr = 0;
|
---|
1776 | //pModElf->pShStr = NULL;
|
---|
1777 |
|
---|
1778 | /*
|
---|
1779 | * Read and validate the ELF header and match up the CPU architecture.
|
---|
1780 | */
|
---|
1781 | int rc = pReader->pfnRead(pReader, &pModElf->Ehdr, sizeof(pModElf->Ehdr), 0);
|
---|
1782 | if (RT_SUCCESS(rc))
|
---|
1783 | {
|
---|
1784 | RTLDRARCH enmArchImage = RTLDRARCH_INVALID; /* shut up gcc */
|
---|
1785 | rc = RTLDRELF_NAME(ValidateElfHeader)(&pModElf->Ehdr, pszLogName, cbRawImage, &enmArchImage);
|
---|
1786 | if (RT_SUCCESS(rc))
|
---|
1787 | {
|
---|
1788 | if ( enmArch != RTLDRARCH_WHATEVER
|
---|
1789 | && enmArch != enmArchImage)
|
---|
1790 | rc = VERR_LDR_ARCH_MISMATCH;
|
---|
1791 | }
|
---|
1792 | }
|
---|
1793 | if (RT_SUCCESS(rc))
|
---|
1794 | {
|
---|
1795 | /*
|
---|
1796 | * Read the section headers, keeping a prestine copy for the module
|
---|
1797 | * introspection methods.
|
---|
1798 | */
|
---|
1799 | size_t const cbShdrs = pModElf->Ehdr.e_shnum * sizeof(Elf_Shdr);
|
---|
1800 | Elf_Shdr *paShdrs = (Elf_Shdr *)RTMemAlloc(cbShdrs * 2);
|
---|
1801 | if (paShdrs)
|
---|
1802 | {
|
---|
1803 | pModElf->paShdrs = paShdrs;
|
---|
1804 | rc = pReader->pfnRead(pReader, paShdrs, cbShdrs, pModElf->Ehdr.e_shoff);
|
---|
1805 | if (RT_SUCCESS(rc))
|
---|
1806 | {
|
---|
1807 | memcpy(&paShdrs[pModElf->Ehdr.e_shnum], paShdrs, cbShdrs);
|
---|
1808 | pModElf->paOrgShdrs = &paShdrs[pModElf->Ehdr.e_shnum];
|
---|
1809 |
|
---|
1810 | pModElf->cbShStr = paShdrs[pModElf->Ehdr.e_shstrndx].sh_size;
|
---|
1811 |
|
---|
1812 | /*
|
---|
1813 | * Validate the section headers and find relevant sections.
|
---|
1814 | */
|
---|
1815 | Elf_Addr uNextAddr = 0;
|
---|
1816 | for (unsigned i = 0; i < pModElf->Ehdr.e_shnum; i++)
|
---|
1817 | {
|
---|
1818 | rc = RTLDRELF_NAME(ValidateSectionHeader)(pModElf, i, pszLogName, cbRawImage);
|
---|
1819 | if (RT_FAILURE(rc))
|
---|
1820 | break;
|
---|
1821 |
|
---|
1822 | /* We're looking for symbol tables. */
|
---|
1823 | if (paShdrs[i].sh_type == SHT_SYMTAB)
|
---|
1824 | {
|
---|
1825 | if (pModElf->iSymSh != ~0U)
|
---|
1826 | {
|
---|
1827 | Log(("RTLdrElf: %s: Multiple symbol tabs! iSymSh=%d i=%d\n", pszLogName, pModElf->iSymSh, i));
|
---|
1828 | rc = VERR_LDRELF_MULTIPLE_SYMTABS;
|
---|
1829 | break;
|
---|
1830 | }
|
---|
1831 | pModElf->iSymSh = i;
|
---|
1832 | pModElf->cSyms = (unsigned)(paShdrs[i].sh_size / sizeof(Elf_Sym));
|
---|
1833 | AssertReturn(pModElf->cSyms == paShdrs[i].sh_size / sizeof(Elf_Sym), VERR_IMAGE_TOO_BIG);
|
---|
1834 | pModElf->iStrSh = paShdrs[i].sh_link;
|
---|
1835 | pModElf->cbStr = (unsigned)paShdrs[pModElf->iStrSh].sh_size;
|
---|
1836 | AssertReturn(pModElf->cbStr == paShdrs[pModElf->iStrSh].sh_size, VERR_IMAGE_TOO_BIG);
|
---|
1837 | }
|
---|
1838 |
|
---|
1839 | /* Special checks for the section string table. */
|
---|
1840 | if (i == pModElf->Ehdr.e_shstrndx)
|
---|
1841 | {
|
---|
1842 | if (paShdrs[i].sh_type != SHT_STRTAB)
|
---|
1843 | {
|
---|
1844 | Log(("RTLdrElf: Section header string table is not a SHT_STRTAB: %#x\n", paShdrs[i].sh_type));
|
---|
1845 | rc = VERR_BAD_EXE_FORMAT;
|
---|
1846 | break;
|
---|
1847 | }
|
---|
1848 | if (paShdrs[i].sh_size == 0)
|
---|
1849 | {
|
---|
1850 | Log(("RTLdrElf: Section header string table is empty\n"));
|
---|
1851 | rc = VERR_BAD_EXE_FORMAT;
|
---|
1852 | break;
|
---|
1853 | }
|
---|
1854 | }
|
---|
1855 |
|
---|
1856 | /* Kluge for the .data..percpu segment in 64-bit linux kernels. */
|
---|
1857 | if (paShdrs[i].sh_flags & SHF_ALLOC)
|
---|
1858 | {
|
---|
1859 | if ( paShdrs[i].sh_addr == 0
|
---|
1860 | && paShdrs[i].sh_addr < uNextAddr)
|
---|
1861 | {
|
---|
1862 | Elf_Addr uAddr = RT_ALIGN_T(uNextAddr, paShdrs[i].sh_addralign, Elf_Addr);
|
---|
1863 | Log(("RTLdrElf: Out of order section #%d; adjusting sh_addr from " FMT_ELF_ADDR " to " FMT_ELF_ADDR "\n",
|
---|
1864 | paShdrs[i].sh_addr, uAddr));
|
---|
1865 | paShdrs[i].sh_addr = uAddr;
|
---|
1866 | }
|
---|
1867 | uNextAddr = paShdrs[i].sh_addr + paShdrs[i].sh_size;
|
---|
1868 | }
|
---|
1869 | } /* for each section header */
|
---|
1870 |
|
---|
1871 | /*
|
---|
1872 | * Calculate the image base address if the image isn't relocatable.
|
---|
1873 | */
|
---|
1874 | if (RT_SUCCESS(rc) && pModElf->Ehdr.e_type != ET_REL)
|
---|
1875 | {
|
---|
1876 | pModElf->LinkAddress = ~(Elf_Addr)0;
|
---|
1877 | for (unsigned i = 0; i < pModElf->Ehdr.e_shnum; i++)
|
---|
1878 | if ( (paShdrs[i].sh_flags & SHF_ALLOC)
|
---|
1879 | && paShdrs[i].sh_addr < pModElf->LinkAddress)
|
---|
1880 | pModElf->LinkAddress = paShdrs[i].sh_addr;
|
---|
1881 | if (pModElf->LinkAddress == ~(Elf_Addr)0)
|
---|
1882 | {
|
---|
1883 | AssertFailed();
|
---|
1884 | rc = VERR_LDR_GENERAL_FAILURE;
|
---|
1885 | }
|
---|
1886 | }
|
---|
1887 |
|
---|
1888 | /*
|
---|
1889 | * Perform allocations / RVA calculations, determine the image size.
|
---|
1890 | */
|
---|
1891 | if (RT_SUCCESS(rc))
|
---|
1892 | for (unsigned i = 0; i < pModElf->Ehdr.e_shnum; i++)
|
---|
1893 | if (paShdrs[i].sh_flags & SHF_ALLOC)
|
---|
1894 | {
|
---|
1895 | if (pModElf->Ehdr.e_type == ET_REL)
|
---|
1896 | paShdrs[i].sh_addr = paShdrs[i].sh_addralign
|
---|
1897 | ? RT_ALIGN_T(pModElf->cbImage, paShdrs[i].sh_addralign, Elf_Addr)
|
---|
1898 | : (Elf_Addr)pModElf->cbImage;
|
---|
1899 | else
|
---|
1900 | paShdrs[i].sh_addr -= pModElf->LinkAddress;
|
---|
1901 | Elf_Addr EndAddr = paShdrs[i].sh_addr + paShdrs[i].sh_size;
|
---|
1902 | if (pModElf->cbImage < EndAddr)
|
---|
1903 | {
|
---|
1904 | pModElf->cbImage = (size_t)EndAddr;
|
---|
1905 | AssertMsgReturn(pModElf->cbImage == EndAddr, (FMT_ELF_ADDR "\n", EndAddr), VERR_IMAGE_TOO_BIG);
|
---|
1906 | }
|
---|
1907 | Log2(("RTLdrElf: %s: Assigned " FMT_ELF_ADDR " to section #%d\n", pszLogName, paShdrs[i].sh_addr, i));
|
---|
1908 | }
|
---|
1909 |
|
---|
1910 | Log2(("RTLdrElf: iSymSh=%u cSyms=%u iStrSh=%u cbStr=%u rc=%Rrc cbImage=%#zx LinkAddress=" FMT_ELF_ADDR "\n",
|
---|
1911 | pModElf->iSymSh, pModElf->cSyms, pModElf->iStrSh, pModElf->cbStr, rc,
|
---|
1912 | pModElf->cbImage, pModElf->LinkAddress));
|
---|
1913 | if (RT_SUCCESS(rc))
|
---|
1914 | {
|
---|
1915 | pModElf->Core.pOps = &RTLDRELF_MID(s_rtldrElf,Ops);
|
---|
1916 | pModElf->Core.eState = LDR_STATE_OPENED;
|
---|
1917 | *phLdrMod = &pModElf->Core;
|
---|
1918 |
|
---|
1919 | LogFlow(("%s: %s: returns VINF_SUCCESS *phLdrMod=%p\n", __FUNCTION__, pszLogName, *phLdrMod));
|
---|
1920 | return VINF_SUCCESS;
|
---|
1921 | }
|
---|
1922 | }
|
---|
1923 |
|
---|
1924 | RTMemFree(paShdrs);
|
---|
1925 | }
|
---|
1926 | else
|
---|
1927 | rc = VERR_NO_MEMORY;
|
---|
1928 | }
|
---|
1929 |
|
---|
1930 | RTMemFree(pModElf);
|
---|
1931 | LogFlow(("%s: returns %Rrc\n", __FUNCTION__, rc));
|
---|
1932 | return rc;
|
---|
1933 | }
|
---|
1934 |
|
---|
1935 |
|
---|
1936 |
|
---|
1937 |
|
---|
1938 | /*******************************************************************************
|
---|
1939 | * Cleanup Constants And Macros *
|
---|
1940 | *******************************************************************************/
|
---|
1941 | #undef RTLDRELF_NAME
|
---|
1942 | #undef RTLDRELF_SUFF
|
---|
1943 | #undef RTLDRELF_MID
|
---|
1944 |
|
---|
1945 | #undef FMT_ELF_ADDR
|
---|
1946 | #undef FMT_ELF_HALF
|
---|
1947 | #undef FMT_ELF_SHALF
|
---|
1948 | #undef FMT_ELF_OFF
|
---|
1949 | #undef FMT_ELF_SIZE
|
---|
1950 | #undef FMT_ELF_SWORD
|
---|
1951 | #undef FMT_ELF_WORD
|
---|
1952 | #undef FMT_ELF_XWORD
|
---|
1953 | #undef FMT_ELF_SXWORD
|
---|
1954 |
|
---|
1955 | #undef Elf_Ehdr
|
---|
1956 | #undef Elf_Phdr
|
---|
1957 | #undef Elf_Shdr
|
---|
1958 | #undef Elf_Sym
|
---|
1959 | #undef Elf_Rel
|
---|
1960 | #undef Elf_Rela
|
---|
1961 | #undef Elf_Reloc
|
---|
1962 | #undef Elf_Nhdr
|
---|
1963 | #undef Elf_Dyn
|
---|
1964 |
|
---|
1965 | #undef Elf_Addr
|
---|
1966 | #undef Elf_Half
|
---|
1967 | #undef Elf_Off
|
---|
1968 | #undef Elf_Size
|
---|
1969 | #undef Elf_Sword
|
---|
1970 | #undef Elf_Word
|
---|
1971 |
|
---|
1972 | #undef RTLDRMODELF
|
---|
1973 | #undef PRTLDRMODELF
|
---|
1974 |
|
---|
1975 | #undef ELF_R_SYM
|
---|
1976 | #undef ELF_R_TYPE
|
---|
1977 | #undef ELF_R_INFO
|
---|
1978 |
|
---|
1979 | #undef ELF_ST_BIND
|
---|
1980 |
|
---|