| 1 | /* $Id: DBGPlugInCommonELFTmpl.cpp.h 98103 2023-01-17 14:15:46Z vboxsync $ */
|
|---|
| 2 | /** @file
|
|---|
| 3 | * DBGPlugInCommonELF - Code Template for dealing with one kind of ELF.
|
|---|
| 4 | */
|
|---|
| 5 |
|
|---|
| 6 | /*
|
|---|
| 7 | * Copyright (C) 2008-2023 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 | * SPDX-License-Identifier: GPL-3.0-only
|
|---|
| 26 | */
|
|---|
| 27 |
|
|---|
| 28 | #if ELF_MODE == 32
|
|---|
| 29 | # define Elf_Ehdr Elf32_Ehdr
|
|---|
| 30 | # define Elf_Shdr Elf32_Shdr
|
|---|
| 31 | # define Elf_Phdr Elf32_Phdr
|
|---|
| 32 | # define Elf_Sym Elf32_Sym
|
|---|
| 33 | # define MY_ELFCLASS ELFCLASS32
|
|---|
| 34 | # define ELF_ST_BIND ELF32_ST_BIND
|
|---|
| 35 | # define DBGDiggerCommonParseElfMod DBGDiggerCommonParseElf32Mod
|
|---|
| 36 | #else
|
|---|
| 37 | # define Elf_Ehdr Elf64_Ehdr
|
|---|
| 38 | # define Elf_Shdr Elf64_Shdr
|
|---|
| 39 | # define Elf_Phdr Elf64_Phdr
|
|---|
| 40 | # define Elf_Sym Elf64_Sym
|
|---|
| 41 | # define MY_ELFCLASS ELFCLASS64
|
|---|
| 42 | # define ELF_ST_BIND ELF64_ST_BIND
|
|---|
| 43 | # define DBGDiggerCommonParseElfMod DBGDiggerCommonParseElf64Mod
|
|---|
| 44 | #endif
|
|---|
| 45 |
|
|---|
| 46 |
|
|---|
| 47 | /**
|
|---|
| 48 | * Common ELF module parser.
|
|---|
| 49 | *
|
|---|
| 50 | * It takes the essential bits of the ELF module (elf header, section headers,
|
|---|
| 51 | * symbol table and string table), and inserts/updates the module and symbols.
|
|---|
| 52 | *
|
|---|
| 53 | *
|
|---|
| 54 | * @returns VBox status code.
|
|---|
| 55 | *
|
|---|
| 56 | * @param pUVM The user mode VM handle.
|
|---|
| 57 | * @param pVMM The VMM function table.
|
|---|
| 58 | * @param pszModName The module name.
|
|---|
| 59 | * @param pszFilename The filename. optional.
|
|---|
| 60 | * @param fFlags Flags.
|
|---|
| 61 | * @param pEhdr Pointer to the ELF header.
|
|---|
| 62 | * @param paShdrs Pointer to the section headers. The caller must verify that
|
|---|
| 63 | * the e_shnum member of the ELF header is within the bounds of
|
|---|
| 64 | * this table. The caller should also adjust the section addresses
|
|---|
| 65 | * so these correspond to actual load addresses.
|
|---|
| 66 | * @param paSyms Pointer to the symbol table.
|
|---|
| 67 | * @param cMaxSyms The maximum number of symbols paSyms may hold. This isn't
|
|---|
| 68 | * the exact count, it's just a cap for avoiding SIGSEGVs
|
|---|
| 69 | * and general corruption.
|
|---|
| 70 | * @param pbStrings Pointer to the string table.
|
|---|
| 71 | * @param cbMaxStrings The size of the memory pbStrings points to. This doesn't
|
|---|
| 72 | * have to match the string table size exactly, it's just to
|
|---|
| 73 | * avoid SIGSEGV when a bad string index is encountered.
|
|---|
| 74 | * @param MinAddr Min address to care about.
|
|---|
| 75 | * @param MaxAddr Max address to care about (inclusive). Together
|
|---|
| 76 | * with MinAddr this forms a valid address range for
|
|---|
| 77 | * symbols and sections that we care about. Anything
|
|---|
| 78 | * outside the range is ignored, except when doing
|
|---|
| 79 | * sanity checks..
|
|---|
| 80 | * @param uModTag Module tag. Pass 0 if tagging is of no interest.
|
|---|
| 81 | */
|
|---|
| 82 | int DBGDiggerCommonParseElfMod(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszModName, const char *pszFilename, uint32_t fFlags,
|
|---|
| 83 | Elf_Ehdr const *pEhdr, Elf_Shdr const *paShdrs,
|
|---|
| 84 | Elf_Sym const *paSyms, size_t cMaxSyms,
|
|---|
| 85 | char const *pbStrings, size_t cbMaxStrings,
|
|---|
| 86 | RTGCPTR MinAddr, RTGCPTR MaxAddr, uint64_t uModTag)
|
|---|
| 87 | {
|
|---|
| 88 | AssertPtrReturn(pUVM, VERR_INVALID_POINTER);
|
|---|
| 89 | AssertPtrReturn(pVMM, VERR_INVALID_POINTER);
|
|---|
| 90 | AssertPtrReturn(pszModName, VERR_INVALID_POINTER);
|
|---|
| 91 | AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
|
|---|
| 92 | AssertReturn(!(fFlags & ~DBG_DIGGER_ELF_MASK), VERR_INVALID_PARAMETER);
|
|---|
| 93 | AssertReturn((fFlags & (DBG_DIGGER_ELF_FUNNY_SHDRS | DBG_DIGGER_ELF_ADJUST_SYM_VALUE))
|
|---|
| 94 | != (DBG_DIGGER_ELF_FUNNY_SHDRS | DBG_DIGGER_ELF_ADJUST_SYM_VALUE), VERR_INVALID_PARAMETER);
|
|---|
| 95 | AssertPtrReturn(paShdrs, VERR_INVALID_POINTER);
|
|---|
| 96 | AssertPtrReturn(paSyms, VERR_INVALID_POINTER);
|
|---|
| 97 | AssertPtrReturn(pbStrings, VERR_INVALID_POINTER);
|
|---|
| 98 |
|
|---|
| 99 | /*
|
|---|
| 100 | * Validate the ELF header.
|
|---|
| 101 | */
|
|---|
| 102 | if ( pEhdr->e_ident[EI_MAG0] != ELFMAG0
|
|---|
| 103 | || pEhdr->e_ident[EI_MAG1] != ELFMAG1
|
|---|
| 104 | || pEhdr->e_ident[EI_MAG2] != ELFMAG2
|
|---|
| 105 | || pEhdr->e_ident[EI_MAG3] != ELFMAG3)
|
|---|
| 106 | return VERR_INVALID_EXE_SIGNATURE;
|
|---|
| 107 | if (pEhdr->e_ident[EI_CLASS] != MY_ELFCLASS)
|
|---|
| 108 | return VERR_LDRELF_MACHINE;
|
|---|
| 109 |
|
|---|
| 110 | if (pEhdr->e_ident[EI_DATA] != ELFDATA2LSB)
|
|---|
| 111 | return VERR_LDRELF_ODD_ENDIAN;
|
|---|
| 112 | if (pEhdr->e_ident[EI_VERSION] != EV_CURRENT)
|
|---|
| 113 | return VERR_LDRELF_VERSION;
|
|---|
| 114 | if (pEhdr->e_version != EV_CURRENT)
|
|---|
| 115 | return VERR_LDRELF_VERSION;
|
|---|
| 116 | if (pEhdr->e_ehsize != sizeof(*pEhdr))
|
|---|
| 117 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 118 |
|
|---|
| 119 | #if ELF_MODE == 32
|
|---|
| 120 | if ( pEhdr->e_machine != EM_386
|
|---|
| 121 | && pEhdr->e_machine != EM_486)
|
|---|
| 122 | return VERR_LDRELF_MACHINE;
|
|---|
| 123 | #else
|
|---|
| 124 | if (pEhdr->e_machine != EM_X86_64)
|
|---|
| 125 | return VERR_LDRELF_MACHINE;
|
|---|
| 126 | #endif
|
|---|
| 127 |
|
|---|
| 128 | if ( pEhdr->e_type != ET_DYN
|
|---|
| 129 | && pEhdr->e_type != ET_REL
|
|---|
| 130 | && pEhdr->e_type != ET_EXEC) //??
|
|---|
| 131 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 132 | if ( pEhdr->e_phentsize != sizeof(Elf_Phdr)
|
|---|
| 133 | && pEhdr->e_phentsize) //??
|
|---|
| 134 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 135 | if (pEhdr->e_shentsize != sizeof(Elf_Shdr))
|
|---|
| 136 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 137 | if (pEhdr->e_shentsize != sizeof(Elf_Shdr))
|
|---|
| 138 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 139 | if (!ASMMemIsZero(&pEhdr->e_ident[EI_PAD], EI_NIDENT - EI_PAD)) //??
|
|---|
| 140 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 141 |
|
|---|
| 142 | /*
|
|---|
| 143 | * Validate the section headers, finding the string and symbol table
|
|---|
| 144 | * headers and the load address while at it.
|
|---|
| 145 | */
|
|---|
| 146 | uint64_t uLoadAddr = UINT64_MAX;
|
|---|
| 147 | const Elf_Shdr *pSymShdr = NULL;
|
|---|
| 148 | const Elf_Shdr *pStrShdr = NULL;
|
|---|
| 149 | for (unsigned iSh = fFlags & DBG_DIGGER_ELF_FUNNY_SHDRS ? 1 : 0; iSh < pEhdr->e_shnum; iSh++)
|
|---|
| 150 | {
|
|---|
| 151 | /* Minimal validation. */
|
|---|
| 152 | if (paShdrs[iSh].sh_link >= pEhdr->e_shnum)
|
|---|
| 153 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 154 |
|
|---|
| 155 | /* Is it the symbol table?*/
|
|---|
| 156 | if (paShdrs[iSh].sh_type == SHT_SYMTAB)
|
|---|
| 157 | {
|
|---|
| 158 | if (pSymShdr)
|
|---|
| 159 | return VERR_LDRELF_MULTIPLE_SYMTABS;
|
|---|
| 160 | pSymShdr = &paShdrs[iSh];
|
|---|
| 161 | if (pSymShdr->sh_entsize != sizeof(Elf32_Sym))
|
|---|
| 162 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 163 | pStrShdr = &paShdrs[paShdrs[iSh].sh_link];
|
|---|
| 164 | }
|
|---|
| 165 | if (uLoadAddr > paShdrs[iSh].sh_addr)
|
|---|
| 166 | uLoadAddr = paShdrs[iSh].sh_addr;
|
|---|
| 167 | }
|
|---|
| 168 |
|
|---|
| 169 | /*
|
|---|
| 170 | * Validate the symbol table and determine the max section index
|
|---|
| 171 | * when DBG_DIGGER_ELF_FUNNY_SHDRS is flagged.
|
|---|
| 172 | */
|
|---|
| 173 | uint32_t uMaxShIdx = fFlags & DBG_DIGGER_ELF_FUNNY_SHDRS ? 0 : pEhdr->e_shnum - 1;
|
|---|
| 174 | size_t const cbStrings = pStrShdr ? pStrShdr->sh_size : cbMaxStrings;
|
|---|
| 175 | size_t const cSyms = pSymShdr
|
|---|
| 176 | ? RT_MIN(cMaxSyms, pSymShdr->sh_size / sizeof(Elf_Sym))
|
|---|
| 177 | : cMaxSyms;
|
|---|
| 178 | for (size_t iSym = 1; iSym < cSyms; iSym++)
|
|---|
| 179 | {
|
|---|
| 180 | if (paSyms[iSym].st_name >= cbStrings)
|
|---|
| 181 | return VERR_LDRELF_INVALID_SYMBOL_NAME_OFFSET;
|
|---|
| 182 | if (fFlags & DBG_DIGGER_ELF_FUNNY_SHDRS)
|
|---|
| 183 | {
|
|---|
| 184 | if ( paSyms[iSym].st_shndx > uMaxShIdx
|
|---|
| 185 | && paSyms[iSym].st_shndx < SHN_LORESERVE)
|
|---|
| 186 | uMaxShIdx = paSyms[iSym].st_shndx;
|
|---|
| 187 | }
|
|---|
| 188 | else if ( paSyms[iSym].st_shndx >= pEhdr->e_shnum
|
|---|
| 189 | && paSyms[iSym].st_shndx != SHN_UNDEF
|
|---|
| 190 | && ( paSyms[iSym].st_shndx < SHN_LORESERVE
|
|---|
| 191 | /*|| paSyms[iSym].st_shndx > SHN_HIRESERVE*/
|
|---|
| 192 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL
|
|---|
| 193 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_WEAK) )
|
|---|
| 194 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 195 | }
|
|---|
| 196 | if (uMaxShIdx > 4096)
|
|---|
| 197 | return VERR_BAD_EXE_FORMAT;
|
|---|
| 198 |
|
|---|
| 199 | /*
|
|---|
| 200 | * Create new module.
|
|---|
| 201 | * The funny ELF section headers on solaris makes this very complicated.
|
|---|
| 202 | */
|
|---|
| 203 | uint32_t cSegs = uMaxShIdx + 1;
|
|---|
| 204 | PDBGDIGGERELFSEG paSegs = (PDBGDIGGERELFSEG)alloca(sizeof(paSegs[0]) * cSegs);
|
|---|
| 205 | for (uint32_t i = 0; i < cSegs; i++)
|
|---|
| 206 | {
|
|---|
| 207 | paSegs[i].uLoadAddr = RTGCPTR_MAX;
|
|---|
| 208 | paSegs[i].uLastAddr = 0;
|
|---|
| 209 | paSegs[i].iSeg = NIL_RTDBGSEGIDX;
|
|---|
| 210 | }
|
|---|
| 211 |
|
|---|
| 212 | RTDBGMOD hMod;
|
|---|
| 213 | int rc = RTDbgModCreate(&hMod, pszModName, 0 /*cbSeg*/, 0 /*fFlags*/);
|
|---|
| 214 | if (RT_FAILURE(rc))
|
|---|
| 215 | return rc;
|
|---|
| 216 | rc = RTDbgModSetTag(hMod, uModTag); AssertRC(rc);
|
|---|
| 217 |
|
|---|
| 218 | if (fFlags & DBG_DIGGER_ELF_FUNNY_SHDRS)
|
|---|
| 219 | {
|
|---|
| 220 | /* Seek out the min and max symbol values for each section. */
|
|---|
| 221 | for (uint32_t iSym = 1; iSym < cSyms; iSym++)
|
|---|
| 222 | {
|
|---|
| 223 | /* Ignore undefined, absolute and weak symbols in this pass,
|
|---|
| 224 | but include local ones as well as nameless. */
|
|---|
| 225 | uint32_t iSh = paSyms[iSym].st_shndx;
|
|---|
| 226 | if ( iSh != SHN_UNDEF
|
|---|
| 227 | && iSh < cSegs
|
|---|
| 228 | && ( ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL
|
|---|
| 229 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_LOCAL))
|
|---|
| 230 | {
|
|---|
| 231 | /* Calc the address and check that it doesn't wrap with the size. */
|
|---|
| 232 | RTGCUINTPTR Address = paSyms[iSym].st_value;
|
|---|
| 233 | RTGCUINTPTR AddressLast = Address + RT_MAX(paSyms[iSym].st_size, 1) - 1;
|
|---|
| 234 | if (AddressLast < Address)
|
|---|
| 235 | continue;
|
|---|
| 236 | if ( Address < MinAddr
|
|---|
| 237 | || AddressLast > MaxAddr)
|
|---|
| 238 | continue;
|
|---|
| 239 |
|
|---|
| 240 | /* update min/max. */
|
|---|
| 241 | if (Address < paSegs[iSh].uLoadAddr)
|
|---|
| 242 | paSegs[iSh].uLoadAddr = Address;
|
|---|
| 243 | if (AddressLast > paSegs[iSh].uLastAddr)
|
|---|
| 244 | paSegs[iSh].uLastAddr = AddressLast;
|
|---|
| 245 | }
|
|---|
| 246 | }
|
|---|
| 247 |
|
|---|
| 248 | /* Add the segments and fill in the translation table. */
|
|---|
| 249 | RTGCPTR uRvaNext = 0;
|
|---|
| 250 | for (unsigned i = 0; i < cSegs; i++)
|
|---|
| 251 | if (paSegs[i].uLastAddr != 0)
|
|---|
| 252 | {
|
|---|
| 253 | char szSeg[32];
|
|---|
| 254 | RTStrPrintf(szSeg, sizeof(szSeg), "sec%02u", i);
|
|---|
| 255 | RTGCPTR cbSeg = paSegs[i].uLastAddr - paSegs[i].uLoadAddr + 1;
|
|---|
| 256 | rc = RTDbgModSegmentAdd(hMod, uRvaNext, cbSeg, szSeg, 0 /*fFlags*/, &paSegs[i].iSeg);
|
|---|
| 257 | if (RT_FAILURE(rc))
|
|---|
| 258 | break;
|
|---|
| 259 | uRvaNext += RT_ALIGN_T(cbSeg, 32, RTGCPTR);
|
|---|
| 260 | }
|
|---|
| 261 | }
|
|---|
| 262 | else
|
|---|
| 263 | {
|
|---|
| 264 | /* Add the segments and fill in the translation table. */
|
|---|
| 265 | for (unsigned i = 0; i < cSegs; i++)
|
|---|
| 266 | if (paShdrs[i].sh_flags & SHF_ALLOC)
|
|---|
| 267 | {
|
|---|
| 268 | char szSeg[32];
|
|---|
| 269 | RTStrPrintf(szSeg, sizeof(szSeg), "sec%02u", i);
|
|---|
| 270 | rc = RTDbgModSegmentAdd(hMod, paShdrs[i].sh_addr - uLoadAddr, paShdrs[i].sh_size, szSeg, 0 /*fFlags*/, &paSegs[i].iSeg);
|
|---|
| 271 | if (RT_FAILURE(rc))
|
|---|
| 272 | break;
|
|---|
| 273 | paSegs[i].uLoadAddr = paShdrs[i].sh_addr;
|
|---|
| 274 | paSegs[i].uLastAddr = paShdrs[i].sh_addr + paShdrs[i].sh_size - 1;
|
|---|
| 275 | }
|
|---|
| 276 | }
|
|---|
| 277 | if (RT_FAILURE(rc))
|
|---|
| 278 | {
|
|---|
| 279 | RTDbgModRelease(hMod);
|
|---|
| 280 | return rc;
|
|---|
| 281 | }
|
|---|
| 282 |
|
|---|
| 283 |
|
|---|
| 284 | /*
|
|---|
| 285 | * Add all relevant symbols in the module
|
|---|
| 286 | */
|
|---|
| 287 | for (uint32_t iSym = 1; iSym < cSyms; iSym++)
|
|---|
| 288 | {
|
|---|
| 289 | /* Undefined symbols are not exports, they are imports. */
|
|---|
| 290 | RTDBGSEGIDX iSeg = paSyms[iSym].st_shndx;
|
|---|
| 291 | if ( iSeg != SHN_UNDEF
|
|---|
| 292 | && ( ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL
|
|---|
| 293 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_LOCAL
|
|---|
| 294 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_WEAK))
|
|---|
| 295 | {
|
|---|
| 296 | /* Get the symbol name. */
|
|---|
| 297 | if (paSyms[iSym].st_name >= cbMaxStrings)
|
|---|
| 298 | continue;
|
|---|
| 299 | const char *pszSymbol = pbStrings + paSyms[iSym].st_name;
|
|---|
| 300 | if (!*pszSymbol)
|
|---|
| 301 | continue;
|
|---|
| 302 |
|
|---|
| 303 | /* Calc the address (value) and size. */
|
|---|
| 304 | RTGCUINTPTR cbSym = paSyms[iSym].st_size;
|
|---|
| 305 | RTGCUINTPTR offSeg = paSyms[iSym].st_value;
|
|---|
| 306 | if (iSeg == SHN_ABS)
|
|---|
| 307 | iSeg = RTDBGSEGIDX_ABS; /* absolute symbols are not subject to any relocation. */
|
|---|
| 308 | else
|
|---|
| 309 | {
|
|---|
| 310 | Assert(iSeg < cSegs);
|
|---|
| 311 | if (fFlags & (DBG_DIGGER_ELF_FUNNY_SHDRS | DBG_DIGGER_ELF_ADJUST_SYM_VALUE))
|
|---|
| 312 | offSeg -= paSegs[iSeg].uLoadAddr;
|
|---|
| 313 | iSeg = paSegs[iSeg].iSeg;
|
|---|
| 314 | if (iSeg == NIL_RTDBGSEGIDX)
|
|---|
| 315 | continue;
|
|---|
| 316 | }
|
|---|
| 317 | if (offSeg + cbSym < offSeg)
|
|---|
| 318 | continue;
|
|---|
| 319 |
|
|---|
| 320 | rc = RTDbgModSymbolAdd(hMod, pszSymbol, iSeg, offSeg, cbSym, 0 /*fFlags*/, NULL);
|
|---|
| 321 | Log(("%02x:%RGv %RGv %s!%s (rc=%Rrc)\n", paSyms[iSym].st_shndx, offSeg, cbSym, pszModName, pszSymbol, rc));
|
|---|
| 322 | }
|
|---|
| 323 | /*else: silently ignore */
|
|---|
| 324 | }
|
|---|
| 325 |
|
|---|
| 326 | /*
|
|---|
| 327 | * Link it into the address space.
|
|---|
| 328 | */
|
|---|
| 329 | RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
|
|---|
| 330 | if (hAs != NIL_RTDBGAS)
|
|---|
| 331 | rc = dbgDiggerCommonLinkElfSegs(hAs, hMod, paSegs, cSegs);
|
|---|
| 332 | else
|
|---|
| 333 | rc = VERR_INTERNAL_ERROR;
|
|---|
| 334 | RTDbgModRelease(hMod);
|
|---|
| 335 | RTDbgAsRelease(hAs);
|
|---|
| 336 | return rc;
|
|---|
| 337 | }
|
|---|
| 338 |
|
|---|
| 339 |
|
|---|
| 340 | #undef Elf_Ehdr
|
|---|
| 341 | #undef Elf_Shdr
|
|---|
| 342 | #undef Elf_Phdr
|
|---|
| 343 | #undef Elf_Sym
|
|---|
| 344 | #undef MY_ELFCLASS
|
|---|
| 345 | #undef ELF_ST_BIND
|
|---|
| 346 | #undef DBGDiggerCommonParseElfMod
|
|---|
| 347 |
|
|---|
