VirtualBox

Changeset 46127 in vbox


Ignore:
Timestamp:
May 16, 2013 2:11:26 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
85818
Message:

Make it possible to load symbols on 64-bit windows 8.

Location:
trunk/src/VBox
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Debugger/DBGCCommands.cpp

    r44528 r46127  
    987987    int rc = DBGFR3OSDetect(pUVM, szName, sizeof(szName));
    988988    if (RT_FAILURE(rc))
    989         return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Executing DBGFR3OSDetect().");
     989        return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Executing DBGFR3OSDetect().\n");
    990990    if (rc == VINF_SUCCESS)
    991991    {
  • trunk/src/VBox/Debugger/DBGPlugInWinNt.cpp

    r46118 r46127  
    8282        uint64_t    Flink;
    8383        uint64_t    Blink;
    84     }               InLoadOrderLinks,
    85                     InMemoryOrderModuleList,
    86                     InInitializationOrderModuleList;
    87     uint64_t        DllBase;
    88     uint64_t        EntryPoint;
    89     uint32_t        SizeOfImage;
    90     uint32_t        Alignment;
     84    }               InLoadOrderLinks,                  /**< 0x00 */
     85                    InMemoryOrderModuleList,           /**< 0x10 */
     86                    InInitializationOrderModuleList;   /**< 0x20 */
     87    uint64_t        DllBase;                           /**< 0x30 */
     88    uint64_t        EntryPoint;                        /**< 0x38 */
     89    uint32_t        SizeOfImage;                       /**< 0x40 */
     90    uint32_t        Alignment;                         /**< 0x44 */
    9191    struct
    9292    {
    93         uint16_t    Length;
    94         uint16_t    MaximumLength;
    95         uint32_t    Alignment;
    96         uint64_t    Buffer;
    97     }               FullDllName,
    98                     BaseDllName;
    99     uint32_t        Flags;
    100     uint16_t        LoadCount;
    101     uint16_t        TlsIndex;
     93        uint16_t    Length;                            /**< 0x48,0x58 */
     94        uint16_t    MaximumLength;                     /**< 0x4a,0x5a */
     95        uint32_t    Alignment;                         /**< 0x4c,0x5c */
     96        uint64_t    Buffer;                            /**< 0x50,0x60 */
     97    }               FullDllName,                       /**< 0x48 */
     98                    BaseDllName;                       /**< 0x58 */
     99    uint32_t        Flags;                             /**< 0x68 */
     100    uint16_t        LoadCount;                         /**< 0x6c */
     101    uint16_t        TlsIndex;                          /**< 0x6e */
    102102    /* ... there is more ... */
    103103} NTMTE64;
     
    261261#define WINNT32_VALID_ADDRESS(Addr)         ((Addr) >         UINT32_C(0x80000000) && (Addr) <         UINT32_C(0xfffff000))
    262262/** Validates a 64-bit Windows NT kernel address */
    263 #define WINNT64_VALID_ADDRESS(Addr)         ((Addr) > UINT64_C(0xffffffff80000000) && (Addr) < UINT64_C(0xfffffffffffff000))
     263 #define WINNT64_VALID_ADDRESS(Addr)         ((Addr) > UINT64_C(0xffff800000000000) && (Addr) < UINT64_C(0xfffffffffffff000))
    264264/** Validates a kernel address. */
    265265#define WINNT_VALID_ADDRESS(pThis, Addr)    ((pThis)->f32Bit ? WINNT32_VALID_ADDRESS(Addr) : WINNT64_VALID_ADDRESS(Addr))
     
    939939    } u;
    940940
     941    union
     942    {
     943        NTMTE32 v32;
     944        NTMTE64 v64;
     945    } uMte, uMte2, uMte3;
     946
    941947    /*
    942948     * Look for the PAGELK section name that seems to be a part of all kernels.
     
    945951     * success.
    946952     */
    947     CPUMMODE enmMode = DBGFR3CpuGetMode(pUVM, 0 /*idCpu*/);
    948     if (enmMode == CPUMMODE_LONG)
    949     {
    950         /** @todo when 32-bit is working, add support for 64-bit windows nt. */
    951     }
    952     else
    953     {
    954         DBGFADDRESS KernelAddr;
    955         for (DBGFR3AddrFromFlat(pUVM, &KernelAddr, UINT32_C(0x80001000));
    956              KernelAddr.FlatPtr < UINT32_C(0xffff0000);
    957              KernelAddr.FlatPtr += PAGE_SIZE)
    958         {
    959             int rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, UINT32_C(0xffff0000) - KernelAddr.FlatPtr,
    960                                    1, "PAGELK\0", sizeof("PAGELK\0"), &KernelAddr);
    961             if (RT_FAILURE(rc))
    962                 break;
    963             DBGFR3AddrSub(&KernelAddr, KernelAddr.FlatPtr & PAGE_OFFSET_MASK);
    964 
    965             /* MZ + PE header. */
    966             rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &KernelAddr, &u, sizeof(u));
    967             if (    RT_SUCCESS(rc)
    968                 &&  u.MzHdr.e_magic == IMAGE_DOS_SIGNATURE
    969                 &&  !(u.MzHdr.e_lfanew & 0x7)
    970                 &&  u.MzHdr.e_lfanew >= 0x080
    971                 &&  u.MzHdr.e_lfanew <= 0x400) /* W8 is at 0x288*/
     953    CPUMMODE        enmMode = DBGFR3CpuGetMode(pUVM, 0 /*idCpu*/);
     954    uint64_t const  uStart  = enmMode == CPUMMODE_LONG ? UINT64_C(0xfffff80000000000) : UINT32_C(0x80001000);
     955    uint64_t const  uEnd    = enmMode == CPUMMODE_LONG ? UINT64_C(0xffffffffffff0000) : UINT32_C(0xffff0000);
     956    DBGFADDRESS     KernelAddr;
     957    for (DBGFR3AddrFromFlat(pUVM, &KernelAddr, uStart);
     958         KernelAddr.FlatPtr < uEnd;
     959         KernelAddr.FlatPtr += PAGE_SIZE)
     960    {
     961        int rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, uEnd - KernelAddr.FlatPtr,
     962                               1, "PAGELK\0", sizeof("PAGELK\0"), &KernelAddr);
     963        if (RT_FAILURE(rc))
     964            break;
     965        DBGFR3AddrSub(&KernelAddr, KernelAddr.FlatPtr & PAGE_OFFSET_MASK);
     966
     967        /* MZ + PE header. */
     968        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &KernelAddr, &u, sizeof(u));
     969        if (    RT_SUCCESS(rc)
     970            &&  u.MzHdr.e_magic == IMAGE_DOS_SIGNATURE
     971            &&  !(u.MzHdr.e_lfanew & 0x7)
     972            &&  u.MzHdr.e_lfanew >= 0x080
     973            &&  u.MzHdr.e_lfanew <= 0x400) /* W8 is at 0x288*/
     974        {
     975            if (enmMode != CPUMMODE_LONG)
    972976            {
    973977                IMAGE_NT_HEADERS32 const *pHdrs = (IMAGE_NT_HEADERS32 const *)&u.au8[u.MzHdr.e_lfanew];
     
    979983                    &&  pHdrs->OptionalHeader.Magic                 == IMAGE_NT_OPTIONAL_HDR32_MAGIC
    980984                    &&  pHdrs->OptionalHeader.NumberOfRvaAndSizes   == IMAGE_NUMBEROF_DIRECTORY_ENTRIES
    981                     /** @todo need more ntoskrnl signs? */
    982985                    )
    983986                {
    984987                    /* Find the MTE. */
    985                     NTMTE32 Mte;
    986                     RT_ZERO(Mte);
    987                     Mte.DllBase     = KernelAddr.FlatPtr;
    988                     Mte.EntryPoint  = KernelAddr.FlatPtr + pHdrs->OptionalHeader.AddressOfEntryPoint;
    989                     Mte.SizeOfImage = pHdrs->OptionalHeader.SizeOfImage;
     988                    RT_ZERO(uMte);
     989                    uMte.v32.DllBase     = KernelAddr.FlatPtr;
     990                    uMte.v32.EntryPoint  = KernelAddr.FlatPtr + pHdrs->OptionalHeader.AddressOfEntryPoint;
     991                    uMte.v32.SizeOfImage = pHdrs->OptionalHeader.SizeOfImage;
    990992                    DBGFADDRESS HitAddr;
    991                     rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, UINT32_MAX - KernelAddr.FlatPtr,
    992                                        4 /*align*/, &Mte.DllBase, 3 * sizeof(uint32_t), &HitAddr);
     993                    rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, uEnd - KernelAddr.FlatPtr,
     994                                       4 /*align*/, &uMte.v32.DllBase, 3 * sizeof(uint32_t), &HitAddr);
    993995                    while (RT_SUCCESS(rc))
    994996                    {
    995997                        /* check the name. */
    996                         NTMTE32 Mte2;
    997998                        DBGFADDRESS MteAddr = HitAddr;
    998999                        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrSub(&MteAddr, RT_OFFSETOF(NTMTE32, DllBase)),
    999                                            &Mte2, sizeof(Mte2));
     1000                                           &uMte2.v32, sizeof(uMte2.v32));
    10001001                        if (    RT_SUCCESS(rc)
    1001                             &&  Mte2.DllBase     == Mte.DllBase
    1002                             &&  Mte2.EntryPoint  == Mte.EntryPoint
    1003                             &&  Mte2.SizeOfImage == Mte.SizeOfImage
    1004                             &&  WINNT32_VALID_ADDRESS(Mte2.InLoadOrderLinks.Flink)
    1005                             &&  Mte2.InLoadOrderLinks.Blink > KernelAddr.FlatPtr    /* list head inside ntoskrnl */
    1006                             &&  Mte2.InLoadOrderLinks.Blink < KernelAddr.FlatPtr + Mte.SizeOfImage
    1007                             &&  WINNT32_VALID_ADDRESS(Mte2.BaseDllName.Buffer)
    1008                             &&  WINNT32_VALID_ADDRESS(Mte2.FullDllName.Buffer)
    1009                             &&  Mte2.BaseDllName.Length <= Mte2.BaseDllName.MaximumLength
    1010                             &&  Mte2.BaseDllName.Length == WINNT_KERNEL_BASE_NAME_LEN * 2
    1011                             &&  Mte2.FullDllName.Length <= Mte2.FullDllName.MaximumLength
    1012                             &&  Mte2.FullDllName.Length <= 256
     1002                            &&  uMte2.v32.DllBase     == uMte.v32.DllBase
     1003                            &&  uMte2.v32.EntryPoint  == uMte.v32.EntryPoint
     1004                            &&  uMte2.v32.SizeOfImage == uMte.v32.SizeOfImage
     1005                            &&  WINNT32_VALID_ADDRESS(uMte2.v32.InLoadOrderLinks.Flink)
     1006                            &&  uMte2.v32.InLoadOrderLinks.Blink > KernelAddr.FlatPtr    /* list head inside ntoskrnl */
     1007                            &&  uMte2.v32.InLoadOrderLinks.Blink < KernelAddr.FlatPtr + uMte.v32.SizeOfImage
     1008                            &&  WINNT32_VALID_ADDRESS(uMte2.v32.BaseDllName.Buffer)
     1009                            &&  WINNT32_VALID_ADDRESS(uMte2.v32.FullDllName.Buffer)
     1010                            &&  uMte2.v32.BaseDllName.Length <= uMte2.v32.BaseDllName.MaximumLength
     1011                            &&  uMte2.v32.BaseDllName.Length == WINNT_KERNEL_BASE_NAME_LEN * 2
     1012                            &&  uMte2.v32.FullDllName.Length <= uMte2.v32.FullDllName.MaximumLength
     1013                            &&  uMte2.v32.FullDllName.Length <= 256
    10131014                           )
    10141015                        {
    1015                             rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, Mte2.BaseDllName.Buffer),
    1016                                                u.wsz, Mte2.BaseDllName.Length);
    1017                             u.wsz[Mte2.BaseDllName.Length / 2] = '\0';
     1016                            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v32.BaseDllName.Buffer),
     1017                                               u.wsz, uMte2.v32.BaseDllName.Length);
     1018                            u.wsz[uMte2.v32.BaseDllName.Length / 2] = '\0';
    10181019                            if (    RT_SUCCESS(rc)
    10191020                                &&  (   !RTUtf16ICmp(u.wsz, g_wszKernelNames[0])
     
    10221023                               )
    10231024                            {
    1024                                 NTMTE32 Mte3;
    1025                                 rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, Mte2.InLoadOrderLinks.Blink),
    1026                                                    &Mte3, RT_SIZEOFMEMB(NTMTE32, InLoadOrderLinks));
     1025                                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
     1026                                                   DBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v32.InLoadOrderLinks.Blink),
     1027                                                   &uMte3.v32, RT_SIZEOFMEMB(NTMTE32, InLoadOrderLinks));
    10271028                                if (   RT_SUCCESS(rc)
    1028                                     && Mte3.InLoadOrderLinks.Flink == MteAddr.FlatPtr
    1029                                     && WINNT32_VALID_ADDRESS(Mte3.InLoadOrderLinks.Blink) )
     1029                                    && uMte3.v32.InLoadOrderLinks.Flink == MteAddr.FlatPtr
     1030                                    && WINNT32_VALID_ADDRESS(uMte3.v32.InLoadOrderLinks.Blink) )
    10301031                                {
    10311032                                    Log(("DigWinNt: MteAddr=%RGv KernelAddr=%RGv SizeOfImage=%x &PsLoadedModuleList=%RGv (32-bit)\n",
    1032                                          MteAddr.FlatPtr, KernelAddr.FlatPtr, Mte2.SizeOfImage, Addr.FlatPtr));
     1033                                         MteAddr.FlatPtr, KernelAddr.FlatPtr, uMte2.v32.SizeOfImage, Addr.FlatPtr));
    10331034                                    pThis->KernelAddr               = KernelAddr;
    10341035                                    pThis->KernelMteAddr            = MteAddr;
     
    10421043                        /* next */
    10431044                        DBGFR3AddrAdd(&HitAddr, 4);
    1044                         if (HitAddr.FlatPtr <= UINT32_C(0xfffff000))
    1045                             rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, UINT32_MAX - HitAddr.FlatPtr,
    1046                                                4 /*align*/, &Mte.DllBase, 3 * sizeof(uint32_t), &HitAddr);
     1045                        if (HitAddr.FlatPtr < uEnd)
     1046                            rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, uEnd - HitAddr.FlatPtr,
     1047                                               4 /*align*/, &uMte.v32.DllBase, 3 * sizeof(uint32_t), &HitAddr);
     1048                        else
     1049                            rc = VERR_DBGF_MEM_NOT_FOUND;
     1050                    }
     1051                }
     1052            }
     1053            else
     1054            {
     1055                IMAGE_NT_HEADERS64 const *pHdrs = (IMAGE_NT_HEADERS64 const *)&u.au8[u.MzHdr.e_lfanew];
     1056                if (    pHdrs->Signature                            == IMAGE_NT_SIGNATURE
     1057                    &&  pHdrs->FileHeader.Machine                   == IMAGE_FILE_MACHINE_AMD64
     1058                    &&  pHdrs->FileHeader.SizeOfOptionalHeader      == sizeof(pHdrs->OptionalHeader)
     1059                    &&  pHdrs->FileHeader.NumberOfSections          >= 10 /* the kernel has lots */
     1060                    &&  (pHdrs->FileHeader.Characteristics & (IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_DLL)) == IMAGE_FILE_EXECUTABLE_IMAGE
     1061                    &&  pHdrs->OptionalHeader.Magic                 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
     1062                    &&  pHdrs->OptionalHeader.NumberOfRvaAndSizes   == IMAGE_NUMBEROF_DIRECTORY_ENTRIES
     1063                    )
     1064                {
     1065                    /* Find the MTE. */
     1066                    RT_ZERO(uMte.v64);
     1067                    uMte.v64.DllBase     = KernelAddr.FlatPtr;
     1068                    uMte.v64.EntryPoint  = KernelAddr.FlatPtr + pHdrs->OptionalHeader.AddressOfEntryPoint;
     1069                    uMte.v64.SizeOfImage = pHdrs->OptionalHeader.SizeOfImage;
     1070                    DBGFADDRESS ScanAddr;
     1071                    DBGFADDRESS HitAddr;
     1072                    rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/,
     1073                                       DBGFR3AddrFromFlat(pUVM, &ScanAddr, uStart),
     1074                                       uEnd - uStart,
     1075                                       4 /*align*/, &uMte.v64.DllBase, 5 * sizeof(uint32_t), &HitAddr);
     1076                    while (RT_SUCCESS(rc))
     1077                    {
     1078                        /* check the name. */
     1079                        DBGFADDRESS MteAddr = HitAddr;
     1080                        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrSub(&MteAddr, RT_OFFSETOF(NTMTE64, DllBase)),
     1081                                           &uMte2.v64, sizeof(uMte2.v64));
     1082                        if (    RT_SUCCESS(rc)
     1083                            &&  uMte2.v64.DllBase     == uMte.v64.DllBase
     1084                            &&  uMte2.v64.EntryPoint  == uMte.v64.EntryPoint
     1085                            &&  uMte2.v64.SizeOfImage == uMte.v64.SizeOfImage
     1086                            &&  WINNT64_VALID_ADDRESS(uMte2.v64.InLoadOrderLinks.Flink)
     1087                            &&  WINNT64_VALID_ADDRESS(uMte2.v64.BaseDllName.Buffer)
     1088                            &&  WINNT64_VALID_ADDRESS(uMte2.v64.FullDllName.Buffer)
     1089                            )
     1090                        {
     1091                            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v64.BaseDllName.Buffer),
     1092                                               u.wsz, uMte2.v64.BaseDllName.Length);
     1093                            u.wsz[uMte2.v64.BaseDllName.Length / 2] = '\0';
     1094                            if (    RT_SUCCESS(rc)
     1095                                &&  (   !RTUtf16ICmp(u.wsz, g_wszKernelNames[0])
     1096                                  /* || !RTUtf16ICmp(u.wsz, g_wszKernelNames[1]) */
     1097                                    )
     1098                               )
     1099                            {
     1100                                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
     1101                                                   DBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v64.InLoadOrderLinks.Blink),
     1102                                                   &uMte3.v64, RT_SIZEOFMEMB(NTMTE64, InLoadOrderLinks));
     1103                                if (   RT_SUCCESS(rc)
     1104                                    && uMte3.v64.InLoadOrderLinks.Flink == MteAddr.FlatPtr
     1105                                    && WINNT64_VALID_ADDRESS(uMte3.v64.InLoadOrderLinks.Blink) )
     1106                                {
     1107                                    Log(("DigWinNt: MteAddr=%RGv KernelAddr=%RGv SizeOfImage=%x &PsLoadedModuleList=%RGv (32-bit)\n",
     1108                                         MteAddr.FlatPtr, KernelAddr.FlatPtr, uMte2.v64.SizeOfImage, Addr.FlatPtr));
     1109                                    pThis->KernelAddr               = KernelAddr;
     1110                                    pThis->KernelMteAddr            = MteAddr;
     1111                                    pThis->PsLoadedModuleListAddr   = Addr;
     1112                                    pThis->f32Bit                   = false;
     1113                                    return true;
     1114                                }
     1115                            }
     1116                            else if (RT_SUCCESS(rc))
     1117                            {
     1118                                Log2(("DigWinNt: Wrong module: MteAddr=%RGv ImageAddr=%RGv SizeOfImage=%#x '%ls'\n",
     1119                                      MteAddr.FlatPtr, KernelAddr.FlatPtr, uMte2.v64.SizeOfImage, u.wsz));
     1120                                break; /* Not NT kernel */
     1121                            }
     1122                        }
     1123
     1124                        /* next */
     1125                        DBGFR3AddrAdd(&HitAddr, 4);
     1126                        if (HitAddr.FlatPtr < uEnd)
     1127                            rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, uEnd - HitAddr.FlatPtr,
     1128                                               4 /*align*/, &uMte.v64.DllBase, 3 * sizeof(uint32_t), &HitAddr);
    10471129                        else
    10481130                            rc = VERR_DBGF_MEM_NOT_FOUND;
  • trunk/src/VBox/Runtime/common/dbg/dbgmoddbghelp.cpp

    r46108 r46127  
    315315        return TRUE;
    316316    }
    317 
     317    if (pSymInfo->NameLen >= RTDBG_SYMBOL_NAME_LENGTH)
     318    {
     319        Log(("  %#018x LB %#07x  %s  [SKIPPED - TOO LONG (%u > %u)!]\n", pSymInfo->Address, cbSymbol, pSymInfo->Name,
     320             pSymInfo->NameLen, RTDBG_SYMBOL_NAME_LENGTH));
     321        return TRUE;
     322    }
     323
     324    /* ASSUMES the symbol name is ASCII. */
    318325    int rc = RTDbgModSymbolAdd(pArgs->hCnt, pSymInfo->Name, RTDBGSEGIDX_RVA,
    319326                               pSymInfo->Address - pArgs->uModAddr, cbSymbol, 0, NULL);
     
    415422            while (hFake == NULL || hFake == INVALID_HANDLE_VALUE);
    416423
     424            LogFlow(("rtDbgModDbgHelp_TryOpen: \n"));
    417425            if (SymInitialize(hFake, NULL /*SearchPath*/, FALSE /*fInvalidProcess*/))
    418426            {
     
    435443                            pMod->pDbgVt    = &g_rtDbgModVtDbgDbgHelp;
    436444                            hCnt = NIL_RTDBGMOD;
     445                            LogFlow(("rtDbgModDbgHelp_TryOpen: Successfully loaded '%s' at %#llx\n",
     446                                     pMod->pszDbgFile, (uint64_t)uImageBase));
    437447                        }
    438448
     
    440450                    }
    441451                    else
     452                    {
    442453                        rc = RTErrConvertFromWin32(GetLastError());
     454                        LogFlow(("rtDbgModDbgHelp_TryOpen: Error loading the module '%s' at %#llx: %Rrc (%u)\n",
     455                                 pMod->pszDbgFile, (uint64_t)uImageBase, rc, GetLastError()));
     456                    }
    443457                    RTUtf16Free(pwszDbgFile);
    444458                }
     459                else
     460                    LogFlow(("rtDbgModDbgHelp_TryOpen: Unicode version issue: %Rrc\n", rc));
    445461
    446462                BOOL fRc2 = SymCleanup(hFake); Assert(fRc2); NOREF(fRc2);
    447463            }
    448464            else
     465            {
    449466                rc = RTErrConvertFromWin32(GetLastError());
     467                LogFlow(("rtDbgModDbgHelp_TryOpen: SymInitialize failed: %Rrc (%u)\n", rc, GetLastError()));
     468            }
    450469        }
    451470        RTDbgModRelease(hCnt);
  • trunk/src/VBox/Runtime/tools/RTNtDbgHelp.cpp

    r46078 r46127  
    245245        RTPrintf("*** %#018x - %s ***\n", pMod->uModAddr, pMod->szFullName);
    246246
    247         IMAGEHLP_MODULE64 ModInfo;
    248         RT_ZERO(ModInfo);
    249         ModInfo.SizeOfStruct = sizeof(ModInfo);
    250         if (SymGetModuleInfo64(g_hFake, pMod->uModAddr, &ModInfo))
    251         {
    252             RTPrintf("    BaseOfImage     = %#018llx\n", ModInfo.BaseOfImage);
    253             RTPrintf("    ImageSize       = %#010x\n", ModInfo.ImageSize);
    254             RTPrintf("    TimeDateStamp   = %#010x\n", ModInfo.TimeDateStamp);
    255             RTPrintf("    CheckSum        = %#010x\n", ModInfo.CheckSum);
    256             RTPrintf("    NumSyms         = %#010x (%u)\n", ModInfo.NumSyms, ModInfo.NumSyms);
    257             RTPrintf("    SymType         = %s\n", symTypeName(ModInfo.SymType));
    258             RTPrintf("    ModuleName      = %.32s\n", ModInfo.ModuleName);
    259             RTPrintf("    ImageName       = %.256s\n", ModInfo.ImageName);
    260             RTPrintf("    LoadedImageName = %.256s\n", ModInfo.LoadedImageName);
    261             RTPrintf("    LoadedPdbName   = %.256s\n", ModInfo.LoadedPdbName);
    262             RTPrintf("    CVSig           = %#010x\n", ModInfo.CVSig);
     247        static const int8_t s_acbVariations[]  = { 0, -4, -8, -12, -16, -20, -24, -28, -32, 4, 8, 12, 16, 20, 24, 28, 32 };
     248        unsigned            iVariation = 0;
     249        union
     250        {
     251            IMAGEHLP_MODULE64   ModInfo;
     252            uint8_t             abPadding[sizeof(IMAGEHLP_MODULE64) + 64];
     253        } u;
     254
     255        BOOL fRc;
     256        do
     257        {
     258            RT_ZERO(u.ModInfo);
     259            u.ModInfo.SizeOfStruct = sizeof(u.ModInfo) + s_acbVariations[iVariation++];
     260            fRc = SymGetModuleInfo64(g_hFake, pMod->uModAddr, &u.ModInfo);
     261        } while (!fRc && GetLastError() == ERROR_INVALID_PARAMETER && iVariation < RT_ELEMENTS(s_acbVariations));
     262
     263        if (fRc)
     264        {
     265            RTPrintf("    BaseOfImage     = %#018llx\n", u.ModInfo.BaseOfImage);
     266            RTPrintf("    ImageSize       = %#010x\n", u.ModInfo.ImageSize);
     267            RTPrintf("    TimeDateStamp   = %#010x\n", u.ModInfo.TimeDateStamp);
     268            RTPrintf("    CheckSum        = %#010x\n", u.ModInfo.CheckSum);
     269            RTPrintf("    NumSyms         = %#010x (%u)\n", u.ModInfo.NumSyms, u.ModInfo.NumSyms);
     270            RTPrintf("    SymType         = %s\n", symTypeName(u.ModInfo.SymType));
     271            RTPrintf("    ModuleName      = %.32s\n", u.ModInfo.ModuleName);
     272            RTPrintf("    ImageName       = %.256s\n", u.ModInfo.ImageName);
     273            RTPrintf("    LoadedImageName = %.256s\n", u.ModInfo.LoadedImageName);
     274            RTPrintf("    LoadedPdbName   = %.256s\n", u.ModInfo.LoadedPdbName);
     275            RTPrintf("    CVSig           = %#010x\n", u.ModInfo.CVSig);
    263276            /** @todo CVData. */
    264             RTPrintf("    PdbSig          = %#010x\n", ModInfo.PdbSig);
    265             RTPrintf("    PdbSig70        = %RTuuid\n", &ModInfo.PdbSig70);
    266             RTPrintf("    PdbAge          = %#010x\n", ModInfo.PdbAge);
    267             RTPrintf("    PdbUnmatched    = %RTbool\n", ModInfo.PdbUnmatched);
    268             RTPrintf("    DbgUnmatched    = %RTbool\n", ModInfo.DbgUnmatched);
    269             RTPrintf("    LineNumbers     = %RTbool\n", ModInfo.LineNumbers);
    270             RTPrintf("    GlobalSymbols   = %RTbool\n", ModInfo.GlobalSymbols);
    271             RTPrintf("    TypeInfo        = %RTbool\n", ModInfo.TypeInfo);
    272             RTPrintf("    SourceIndexed   = %RTbool\n", ModInfo.SourceIndexed);
    273             RTPrintf("    Publics         = %RTbool\n", ModInfo.Publics);
     277            RTPrintf("    PdbSig          = %#010x\n", u.ModInfo.PdbSig);
     278            RTPrintf("    PdbSig70        = %RTuuid\n", &u.ModInfo.PdbSig70);
     279            RTPrintf("    PdbAge          = %#010x\n", u.ModInfo.PdbAge);
     280            RTPrintf("    PdbUnmatched    = %RTbool\n", u.ModInfo.PdbUnmatched);
     281            RTPrintf("    DbgUnmatched    = %RTbool\n", u.ModInfo.DbgUnmatched);
     282            RTPrintf("    LineNumbers     = %RTbool\n", u.ModInfo.LineNumbers);
     283            RTPrintf("    GlobalSymbols   = %RTbool\n", u.ModInfo.GlobalSymbols);
     284            RTPrintf("    TypeInfo        = %RTbool\n", u.ModInfo.TypeInfo);
     285            RTPrintf("    SourceIndexed   = %RTbool\n", u.ModInfo.SourceIndexed);
     286            RTPrintf("    Publics         = %RTbool\n", u.ModInfo.Publics);
    274287        }
    275288        else
     
    350363
    351364            case 'h':
    352                 RTPrintf("usage: %s [-v|--verbose] [-q|--quiet] [-a <addr>] [-l <file>] [-d] [...]\n"
     365                RTPrintf("usage: %s [-v|--verbose] [-q|--quiet] [--set-debug-info] [-a <addr>] [-l <file>] [-d] [...]\n"
    353366                         "   or: %s [-V|--version]\n"
    354367                         "   or: %s [-h|--help]\n",
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette