Changeset 73097 in vbox for trunk/src/VBox/Runtime

Timestamp:

Jul 12, 2018 9:06:33 PM (7 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

123672

Message:

*: Made RT_UOFFSETOF, RT_OFFSETOF, RT_UOFFSETOF_ADD and RT_OFFSETOF_ADD work like builtin_offsetof() and require compile time resolvable requests, adding RT_UOFFSETOF_DYN for the dynamic questions that can only be answered at runtime.

Location:

trunk/src/VBox/Runtime

Files:

• common/alloc/memtracker.cpp (modified) (1 diff)
• common/asn1/asn1-basics.cpp (modified) (2 diffs)
• common/checksum/ipv4.cpp (modified) (3 diffs)
• common/checksum/manifest2.cpp (modified) (3 diffs)
• common/crypto/digest-core.cpp (modified) (2 diffs)
• common/crypto/pkix-signature-core.cpp (modified) (2 diffs)
• common/crypto/store-inmem.cpp (modified) (1 diff)
• common/dbg/dbgas.cpp (modified) (1 diff)
• common/dbg/dbgcfg.cpp (modified) (1 diff)
• common/dbg/dbgmod.cpp (modified) (1 diff)
• common/dbg/dbgmodcodeview.cpp (modified) (2 diffs)
• common/dvm/dvmvfs.cpp (modified) (3 diffs)
• common/fs/RTFsCmdLs.cpp (modified) (4 diffs)
• common/fs/ext2vfs.cpp (modified) (1 diff)
• common/fs/fatvfs.cpp (modified) (9 diffs)
• common/fs/isomaker.cpp (modified) (5 diffs)
• common/fs/isomakerimport.cpp (modified) (8 diffs)
• common/fs/isovfs.cpp (modified) (12 diffs)
• common/fs/ntfsvfs.cpp (modified) (9 diffs)
• common/fuzz/fuzz-observer.cpp (modified) (1 diff)
• common/fuzz/fuzz.cpp (modified) (4 diffs)
• common/ldr/ldrEx.cpp (modified) (1 diff)
• common/ldr/ldrPE.cpp (modified) (8 diffs)
• common/ldr/ldrVfsFile.cpp (modified) (1 diff)
• common/log/log.cpp (modified) (5 diffs)
• common/log/tracebuf.cpp (modified) (1 diff)
• common/log/tracelogreader.cpp (modified) (2 diffs)
• common/log/tracelogwriter.cpp (modified) (1 diff)
• common/path/RTPathGlob.cpp (modified) (6 diffs)
• common/path/RTPathSplit.cpp (modified) (1 diff)
• common/path/RTPathSplitA.cpp (modified) (1 diff)
• common/string/strcache.cpp (modified) (3 diffs)
• common/vfs/vfsbase.cpp (modified) (3 diffs)
• common/vfs/vfsfss2dir.cpp (modified) (2 diffs)
• common/vfs/vfsmemory.cpp (modified) (2 diffs)
• common/vfs/vfsmount.cpp (modified) (2 diffs)
• common/vfs/vfsprogress.cpp (modified) (1 diff)
• common/vfs/vfsreadahead.cpp (modified) (2 diffs)
• common/vfs/vfsstddir.cpp (modified) (4 diffs)
• common/vfs/vfsstdfile.cpp (modified) (1 diff)
• common/zip/pkzipvfs.cpp (modified) (1 diff)
• common/zip/tarvfs.cpp (modified) (1 diff)
• common/zip/tarvfswriter.cpp (modified) (1 diff)
• common/zip/xarvfs.cpp (modified) (2 diffs)
• generic/mempool-generic.cpp (modified) (1 diff)
• r0drv/linux/memobj-r0drv-linux.c (modified) (3 diffs)
• r0drv/linux/timer-r0drv-linux.c (modified) (2 diffs)
• r0drv/nt/dbgkrnlinfo-r0drv-nt.cpp (modified) (1 diff)
• r0drv/nt/initterm-r0drv-nt.cpp (modified) (1 diff)
• r0drv/nt/memobj-r0drv-nt.cpp (modified) (1 diff)
• r0drv/nt/nt3fakes-r0drv-nt.cpp (modified) (1 diff)
• r0drv/nt/ntBldSymDb.cpp (modified) (2 diffs)
• r0drv/nt/thread-r0drv-nt.cpp (modified) (1 diff)
• r0drv/nt/timer-r0drv-nt.cpp (modified) (1 diff)
• r0drv/os2/memobj-r0drv-os2.cpp (modified) (9 diffs)
• r0drv/solaris/timer-r0drv-solaris.c (modified) (1 diff)
• r3/linux/krnlmod-linux.cpp (modified) (1 diff)
• r3/nt/direnum-r3-nt.cpp (modified) (4 diffs)
• r3/posix/dir-posix.cpp (modified) (5 diffs)
• r3/posix/localipc-posix.cpp (modified) (1 diff)
• r3/solaris/coredumper-solaris.cpp (modified) (2 diffs)
• r3/solaris/krnlmod-solaris.cpp (modified) (1 diff)
• r3/win/RTSystemShutdown-win.cpp (modified) (1 diff)
• r3/win/direnum-win.cpp (modified) (4 diffs)
• r3/win/fileaio-win.cpp (modified) (1 diff)
• r3/win/krnlmod-win.cpp (modified) (2 diffs)
• r3/win/localipc-win.cpp (modified) (1 diff)
• r3/win/process-win.cpp (modified) (4 diffs)
• testcase/tstRTAvl.cpp (modified) (1 diff)
• testcase/tstRTTraceLog.cpp (modified) (1 diff)
• tools/RTLdrCheckImports.cpp (modified) (1 diff)
• tools/RTNtDbgHelp.cpp (modified) (1 diff)
• tools/RTSignTool.cpp (modified) (1 diff)

trunk/src/VBox/Runtime/common/alloc/memtracker.cpp

@@ -402 +402 @@
     if (RT_UNLIKELY(!pTag))
     {
-        pTag = (PRTMEMTRACKERTAG)RTMemAllocZVar(RT_OFFSETOF(RTMEMTRACKERTAG, szTag[cchTag + 1]));
+        pTag = (PRTMEMTRACKERTAG)RTMemAllocZVar(RT_UOFFSETOF_DYN(RTMEMTRACKERTAG, szTag[cchTag + 1]));
         if (pTag)
         {

trunk/src/VBox/Runtime/common/asn1/asn1-basics.cpp

@@ -198 +198 @@
 
     /* Make the allocation. */
-    uint32_t            cbAlloc = RT_OFFSETOF(RTASN1MEMCONTENT, au64Content) + (uint32_t)cb;
+    uint32_t            cbAlloc = RT_UOFFSETOF(RTASN1MEMCONTENT, au64Content) + (uint32_t)cb;
     PRTASN1MEMCONTENT   pHdr;
     int rc = pAllocator->pfnAlloc(pAllocator, &Allocation, (void **)&pHdr, cbAlloc);
@@ -234 +234 @@
          * Case 1 - Initial allocation.
          */
-        uint32_t cbNeeded  = RT_OFFSETOF(RTASN1MEMCONTENT, au64Content) + (uint32_t)cb;
+        uint32_t cbNeeded  = RT_UOFFSETOF(RTASN1MEMCONTENT, au64Content) + (uint32_t)cb;
         if (!(pAsn1Core->fFlags & RTASN1CORE_F_ALLOCATED_CONTENT))
             return RTAsn1ContentAllocZ(pAsn1Core, cb, pAllocator);

trunk/src/VBox/Runtime/common/checksum/ipv4.cpp

@@ -663 +663 @@
      * Validate all the header fields we're able to...
      */
-    if (cbDhcp < RT_OFFSETOF(RTNETBOOTP, bp_op) + sizeof(pDhcp->bp_op))
+    if (cbDhcp < RT_UOFFSETOF(RTNETBOOTP, bp_op) + sizeof(pDhcp->bp_op))
         return true;
     if (RT_UNLIKELY(    pDhcp->bp_op != RTNETBOOTP_OP_REQUEST
@@ -669 +669 @@
         return false;
 
-    if (cbDhcp < RT_OFFSETOF(RTNETBOOTP, bp_htype) + sizeof(pDhcp->bp_htype))
+    if (cbDhcp < RT_UOFFSETOF(RTNETBOOTP, bp_htype) + sizeof(pDhcp->bp_htype))
         return true;
     if (RT_UNLIKELY(pDhcp->bp_htype != RTNET_ARP_ETHER))
         return false;
 
-    if (cbDhcp < RT_OFFSETOF(RTNETBOOTP, bp_hlen) + sizeof(pDhcp->bp_hlen))
+    if (cbDhcp < RT_UOFFSETOF(RTNETBOOTP, bp_hlen) + sizeof(pDhcp->bp_hlen))
         return true;
     if (RT_UNLIKELY(pDhcp->bp_hlen != sizeof(RTMAC)))
         return false;
 
-    if (cbDhcp < RT_OFFSETOF(RTNETBOOTP, bp_flags) + sizeof(pDhcp->bp_flags))
+    if (cbDhcp < RT_UOFFSETOF(RTNETBOOTP, bp_flags) + sizeof(pDhcp->bp_flags))
         return true;
     if (RT_UNLIKELY(RT_BE2H_U16(pDhcp->bp_flags) & ~(RTNET_DHCP_FLAGS_NO_BROADCAST)))
@@ -688 +688 @@
      * (because that seems to be indicating that it's BOOTP and not DHCP).
      */
-    cbLeft = (ssize_t)cbDhcp - RT_OFFSETOF(RTNETBOOTP, bp_vend.Dhcp.dhcp_cookie) + sizeof(pDhcp->bp_vend.Dhcp.dhcp_cookie);
+    cbLeft = (ssize_t)cbDhcp - RT_UOFFSETOF(RTNETBOOTP, bp_vend.Dhcp.dhcp_cookie) + sizeof(pDhcp->bp_vend.Dhcp.dhcp_cookie);
     if (cbLeft < 0)
         return true;

trunk/src/VBox/Runtime/common/checksum/manifest2.cpp

@@ -704 +704 @@
     {
         size_t const cbName = strlen(pszAttr) + 1;
-        pAttr = (PRTMANIFESTATTR)RTMemAllocVar(RT_UOFFSETOF(RTMANIFESTATTR, szName[cbName]));
+        pAttr = (PRTMANIFESTATTR)RTMemAllocVar(RT_UOFFSETOF_DYN(RTMANIFESTATTR, szName[cbName]));
         if (!pAttr)
         {
@@ -1070 +1070 @@
     if (rc == VERR_NOT_FOUND)
     {
-        pEntry = (PRTMANIFESTENTRY)RTMemAlloc(RT_UOFFSETOF(RTMANIFESTENTRY, szName[cchEntry + 1]));
+        pEntry = (PRTMANIFESTENTRY)RTMemAlloc(RT_UOFFSETOF_DYN(RTMANIFESTENTRY, szName[cchEntry + 1]));
         if (!pEntry)
             return VERR_NO_MEMORY;
@@ -1196 +1196 @@
     if (rc == VERR_NOT_FOUND)
     {
-        pEntry = (PRTMANIFESTENTRY)RTMemAlloc(RT_UOFFSETOF(RTMANIFESTENTRY, szName[cchEntry + 1]));
+        pEntry = (PRTMANIFESTENTRY)RTMemAlloc(RT_UOFFSETOF_DYN(RTMANIFESTENTRY, szName[cchEntry + 1]));
         if (pEntry)
         {

trunk/src/VBox/Runtime/common/crypto/digest-core.cpp

@@ -97 +97 @@
     AssertReturn(pDesc->pfnNew || offHash, VERR_INVALID_PARAMETER);
     AssertReturn(!pDesc->pfnNew || (pDesc->pfnFree && pDesc->pfnInit && pDesc->pfnClone), VERR_INVALID_PARAMETER);
-    PRTCRDIGESTINT pThis = (PRTCRDIGESTINT)RTMemAllocZ(RT_OFFSETOF(RTCRDIGESTINT, abState[offHash + pDesc->cbHash]));
+    PRTCRDIGESTINT pThis = (PRTCRDIGESTINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTCRDIGESTINT, abState[offHash + pDesc->cbHash]));
     if (pThis)
     {
@@ -140 +140 @@
     int rc = VINF_SUCCESS;
     uint32_t const offHash = hSrc->offHash;
-    PRTCRDIGESTINT pThis = (PRTCRDIGESTINT)RTMemAllocZ(RT_OFFSETOF(RTCRDIGESTINT, abState[offHash + hSrc->pDesc->cbHash]));
+    PRTCRDIGESTINT pThis = (PRTCRDIGESTINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTCRDIGESTINT, abState[offHash + hSrc->pDesc->cbHash]));
     if (pThis)
     {

trunk/src/VBox/Runtime/common/crypto/pkix-signature-core.cpp

@@ -107 +107 @@
      */
     int rc = VINF_SUCCESS;
-    PRTCRPKIXSIGNATUREINT pThis = (PRTCRPKIXSIGNATUREINT)RTMemAllocZ(RT_OFFSETOF(RTCRPKIXSIGNATUREINT, abState[pDesc->cbState]));
+    PRTCRPKIXSIGNATUREINT pThis = (PRTCRPKIXSIGNATUREINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTCRPKIXSIGNATUREINT,
+                                                                                      abState[pDesc->cbState]));
     if (pThis)
     {
@@ -160 +161 @@
             pThis->pDesc->pfnDelete(pThis->pDesc, pThis->abState, pThis->fSigning);
 
-        size_t cbToWipe = RT_OFFSETOF(RTCRPKIXSIGNATUREINT, abState[pThis->pDesc->cbState]);
+        size_t cbToWipe = RT_UOFFSETOF_DYN(RTCRPKIXSIGNATUREINT, abState[pThis->pDesc->cbState]);
         RTMemWipeThoroughly(pThis, cbToWipe, 6);
 

trunk/src/VBox/Runtime/common/crypto/store-inmem.cpp

@@ -120 +120 @@
 {
     int                 rc;
-    PRTCRSTOREINMEMCERT pEntry    = (PRTCRSTOREINMEMCERT)RTMemAllocZ(RT_UOFFSETOF(RTCRSTOREINMEMCERT, abEncoded[cbSrc]));
+    PRTCRSTOREINMEMCERT pEntry    = (PRTCRSTOREINMEMCERT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTCRSTOREINMEMCERT, abEncoded[cbSrc]));
     if (pEntry)
     {

trunk/src/VBox/Runtime/common/dbg/dbgas.cpp

@@ -198 +198 @@
      */
     size_t cchName = strlen(pszName);
-    PRTDBGASINT pDbgAs = (PRTDBGASINT)RTMemAllocVar(RT_OFFSETOF(RTDBGASINT, szName[cchName + 1]));
+    PRTDBGASINT pDbgAs = (PRTDBGASINT)RTMemAllocVar(RT_UOFFSETOF_DYN(RTDBGASINT, szName[cchName + 1]));
     if (!pDbgAs)
         return VERR_NO_MEMORY;

trunk/src/VBox/Runtime/common/dbg/dbgcfg.cpp

@@ -1955 +1955 @@
              * We're adding a new one.
              */
-            PRTDBGCFGSTR pNew = (PRTDBGCFGSTR)RTMemAlloc(RT_OFFSETOF(RTDBGCFGSTR, sz[cchPath + 1]));
+            PRTDBGCFGSTR pNew = (PRTDBGCFGSTR)RTMemAlloc(RT_UOFFSETOF_DYN(RTDBGCFGSTR, sz[cchPath + 1]));
             if (!pNew)
                 return VERR_NO_MEMORY;

trunk/src/VBox/Runtime/common/dbg/dbgmod.cpp

@@ -1442 +1442 @@
                     PRTDBGMODDEFERRED pDeferred;
                     rc = rtDbgModDeferredCreate(pDbgMod, rtDbgModFromMachOImageDeferredCallback, cbImage, hDbgCfg,
-                                                RT_OFFSETOF(RTDBGMODDEFERRED, u.MachO.aSegs[cSegs]),
+                                                RT_UOFFSETOF_DYN(RTDBGMODDEFERRED, u.MachO.aSegs[cSegs]),
                                                 &pDeferred);
                     if (RT_SUCCESS(rc))

trunk/src/VBox/Runtime/common/dbg/dbgmodcodeview.cpp

@@ -1227 +1227 @@
                                  cbSubSect, RT_UOFFSETOF(RTCVSRCFILE, aoffSrcLines), i, offSrcFile));
         PCRTCVSRCFILE   pSrcFile    = (PCRTCVSRCFILE)((uint8_t const *)pvSubSect + offSrcFile);
-        size_t         cbSrcFileHdr = RT_UOFFSETOF(RTCVSRCFILE, aoffSrcLines[pSrcFile->cSegs])
+        size_t         cbSrcFileHdr = RT_UOFFSETOF_DYN(RTCVSRCFILE, aoffSrcLines[pSrcFile->cSegs])
                                     + sizeof(RTCVSRCRANGE) * pSrcFile->cSegs
                                     + sizeof(uint8_t);
@@ -1251 +1251 @@
                                      cbSubSect, RT_UOFFSETOF(RTCVSRCLINE, aoffLines), iSeg, offSrcLine));
             PCRTCVSRCLINE   pSrcLine    = (PCRTCVSRCLINE)((uint8_t const *)pvSubSect + offSrcLine);
-            size_t          cbSrcLine   = RT_UOFFSETOF(RTCVSRCLINE, aoffLines[pSrcLine->cPairs])
+            size_t          cbSrcLine   = RT_UOFFSETOF_DYN(RTCVSRCLINE, aoffLines[pSrcLine->cPairs])
                                         + pSrcLine->cPairs * sizeof(uint16_t);
             RTDBGMODCV_CHECK_RET_BF(cbSubSect >= offSrcLine + cbSrcLine,

trunk/src/VBox/Runtime/common/dvm/dvmvfs.cpp

@@ -472 +472 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtDvmVfsFile_SetMode,
         rtDvmVfsFile_SetTimes,
@@ -921 +921 @@
 
         size_t cchVolName = strlen(pszVolName);
-        size_t cbNeeded   = RT_OFFSETOF(RTDIRENTRYEX,  szName[cchVolName + 1]);
+        size_t cbNeeded   = RT_UOFFSETOF_DYN(RTDIRENTRYEX,  szName[cchVolName + 1]);
         if (cbNeeded <= *pcbDirEntry)
         {
@@ -982 +982 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSDIROPS, Obj) - RT_OFFSETOF(RTVFSDIROPS, ObjSet),
+        RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
         rtDvmVfsDir_SetMode,
         rtDvmVfsDir_SetTimes,

trunk/src/VBox/Runtime/common/fs/RTFsCmdLs.cpp

@@ -782 +782 @@
     {
         default: AssertFailed(); RT_FALL_THRU();
-        case RTCMDLSTIME_MTIME: offTime = RT_OFFSETOF(RTCMDLSENTRY, Info.ModificationTime); break;
-        case RTCMDLSTIME_BTIME: offTime = RT_OFFSETOF(RTCMDLSENTRY, Info.BirthTime); break;
-        case RTCMDLSTIME_CTIME: offTime = RT_OFFSETOF(RTCMDLSENTRY, Info.ChangeTime); break;
-        case RTCMDLSTIME_ATIME: offTime = RT_OFFSETOF(RTCMDLSENTRY, Info.AccessTime); break;
+        case RTCMDLSTIME_MTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.ModificationTime); break;
+        case RTCMDLSTIME_BTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.BirthTime); break;
+        case RTCMDLSTIME_CTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.ChangeTime); break;
+        case RTCMDLSTIME_ATIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.AccessTime); break;
     }
 
@@ -1027 +1027 @@
             && *pszName)
         {
-            PRTCMDLSCOLLECTION pCollection = (PRTCMDLSCOLLECTION)RTMemAllocZ(RT_OFFSETOF(RTCMDLSCOLLECTION, szName[1]));
+            PRTCMDLSCOLLECTION pCollection = (PRTCMDLSCOLLECTION)RTMemAllocZ(RT_UOFFSETOF(RTCMDLSCOLLECTION, szName[1]));
             if (!pCollection)
             {
@@ -1040 +1040 @@
     /* Add new collection. */
     size_t cbName = strlen(pszName) + 1;
-    PRTCMDLSCOLLECTION pCollection = (PRTCMDLSCOLLECTION)RTMemAllocZ(RT_OFFSETOF(RTCMDLSCOLLECTION, szName[cbName]));
+    PRTCMDLSCOLLECTION pCollection = (PRTCMDLSCOLLECTION)RTMemAllocZ(RT_UOFFSETOF_DYN(RTCMDLSCOLLECTION, szName[cbName]));
     if (pCollection)
     {
@@ -1083 +1083 @@
     size_t const cbGroup  = pszGroup  ? strlen(pszGroup)  + 1 : 0;
     size_t const cbTarget = pszTarget ? strlen(pszTarget) + 1 : 0;
-    size_t const cbEntry  = RT_OFFSETOF(RTCMDLSENTRY, szName[cchEntry + 1 + cbOwner + cbGroup + cbTarget]);
+    size_t const cbEntry  = RT_UOFFSETOF_DYN(RTCMDLSENTRY, szName[cchEntry + 1 + cbOwner + cbGroup + cbTarget]);
     PRTCMDLSENTRY pEntry = (PRTCMDLSENTRY)RTMemAlloc(cbEntry);
     if (pEntry)

trunk/src/VBox/Runtime/common/fs/ext2vfs.cpp

@@ -99 +99 @@
     if (!pBlkGrpDesc)
     {
-        size_t cbBlkDesc = RT_OFFSETOF(RTFILESYSTEMEXTBLKGRP, abBlockBitmap[cbBlockBitmap]);
+        size_t cbBlkDesc = RT_UOFFSETOF_DYN(RTFILESYSTEMEXTBLKGRP, abBlockBitmap[cbBlockBitmap]);
         pBlkGrpDesc = (PRTFILESYSTEMEXTBLKGRP)RTMemAllocZ(cbBlkDesc);
         if (!pBlkGrpDesc)

trunk/src/VBox/Runtime/common/fs/fatvfs.cpp

@@ -824 +824 @@
      */
     PRTFSFATCLUSTERMAPCACHE pFatCache;
-    pThis->pFatCache = pFatCache = (PRTFSFATCLUSTERMAPCACHE)RTMemAllocZ(RT_OFFSETOF(RTFSFATCLUSTERMAPCACHE, aEntries[cEntries]));
+    pFatCache = (PRTFSFATCLUSTERMAPCACHE)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFSFATCLUSTERMAPCACHE, aEntries[cEntries]));
+    pThis->pFatCache = pFatCache;
     if (!pFatCache)
         return RTErrInfoSet(pErrInfo, VERR_NO_MEMORY, "Failed to allocate FAT cache");
@@ -2571 +2572 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtFsFatFile_SetMode,
         rtFsFatFile_SetTimes,
@@ -4412 +4413 @@
     if (pThis->offDir < 2)
     {
-        size_t cbNeeded = RT_OFFSETOF(RTDIRENTRYEX, szName[pThis->offDir + 2]);
+        size_t cbNeeded = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[pThis->offDir + 2]);
         if (cbNeeded < *pcbDirEntry)
             *pcbDirEntry = cbNeeded;
@@ -4554 +4555 @@
                 if (!fLongName)
                     cchName = rtFsFatDir_CalcUtf8LengthForDirEntry(pShared, &paEntries[iEntry].Entry);
-                size_t cbNeeded = RT_OFFSETOF(RTDIRENTRYEX, szName[cchName + 1]);
+                size_t cbNeeded = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cchName + 1]);
                 if (cbNeeded <= *pcbDirEntry)
                     *pcbDirEntry = cbNeeded;
@@ -4626 +4627 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSDIROPS, Obj) - RT_OFFSETOF(RTVFSDIROPS, ObjSet),
+        RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
         rtFsFatDir_SetMode,
         rtFsFatDir_SetTimes,
@@ -5031 +5032 @@
     Assert(offFirstZero >= RT_UOFFSETOF(FATBOOTSECTOR, Bpb));
     uint32_t const cbZeroPad    = RT_MIN(offJump - offFirstZero,
-                                         sizeof(pBootSector->Bpb.Bpb20) - (offFirstZero - RT_OFFSETOF(FATBOOTSECTOR, Bpb)));
+                                         sizeof(pBootSector->Bpb.Bpb20) - (offFirstZero - RT_UOFFSETOF(FATBOOTSECTOR, Bpb)));
 
     if (!ASMMemIsAllU8((uint8_t const *)pBootSector + offFirstZero, cbZeroPad, 0))
@@ -5387 +5388 @@
              && pBootSector->abJmp[2] <= 0x7f)
         offJmp = RT_MIN(127, RT_MAKE_U16(pBootSector->abJmp[1], pBootSector->abJmp[2]));
-    uint8_t const cbMaxBpb = offJmp - RT_OFFSETOF(FATBOOTSECTOR, Bpb);
+    uint8_t const cbMaxBpb = offJmp - RT_UOFFSETOF(FATBOOTSECTOR, Bpb);
 
     /*
@@ -5444 +5445 @@
     if (   (   sizeof(FAT32EBPB) <= cbMaxBpb
             && pBootSector->Bpb.Fat32Ebpb.bExtSignature == FATEBPB_SIGNATURE)
-        || (   RT_OFFSETOF(FAT32EBPB, achLabel) <= cbMaxBpb
+        || (   RT_UOFFSETOF(FAT32EBPB, achLabel) <= cbMaxBpb
             && pBootSector->Bpb.Fat32Ebpb.bExtSignature == FATEBPB_SIGNATURE_OLD) )
     {
@@ -5460 +5461 @@
         if (   (   sizeof(FATEBPB) <= cbMaxBpb
                 && pBootSector->Bpb.Ebpb.bExtSignature == FATEBPB_SIGNATURE)
-            || (   RT_OFFSETOF(FATEBPB, achLabel) <= cbMaxBpb
+            || (   RT_UOFFSETOF(FATEBPB, achLabel) <= cbMaxBpb
                 && pBootSector->Bpb.Ebpb.bExtSignature == FATEBPB_SIGNATURE_OLD) )
         {

trunk/src/VBox/Runtime/common/fs/isomaker.cpp

@@ -99 +99 @@
  *        is the case in rtFsIsoMakerNormalizeNameForNamespace. */
 #define RTFSISOMAKER_CALC_PATHREC_SIZE(a_cbNameInDirRec) \
-    ( RT_UOFFSETOF(ISO9660PATHREC, achDirId[(a_cbNameInDirRec) + ((a_cbNameInDirRec) & 1)]) )
+    ( RT_UOFFSETOF_DYN(ISO9660PATHREC, achDirId[(a_cbNameInDirRec) + ((a_cbNameInDirRec) & 1)]) )
 
 
@@ -660 +660 @@
 } g_aRTFsIsoNamespaces[] =
 {
-    {   RTFSISOMAKER_NAMESPACE_ISO_9660, RT_OFFSETOF(RTFSISOMAKERINT, PrimaryIso), RT_OFFSETOF(RTFSISOMAKEROBJ, pPrimaryName), "iso-9660" },
-    {   RTFSISOMAKER_NAMESPACE_JOLIET,   RT_OFFSETOF(RTFSISOMAKERINT, Joliet),     RT_OFFSETOF(RTFSISOMAKEROBJ, pJolietName),  "joliet" },
-    {   RTFSISOMAKER_NAMESPACE_UDF,      RT_OFFSETOF(RTFSISOMAKERINT, Udf),        RT_OFFSETOF(RTFSISOMAKEROBJ, pUdfName),     "udf" },
-    {   RTFSISOMAKER_NAMESPACE_HFS,      RT_OFFSETOF(RTFSISOMAKERINT, Hfs),        RT_OFFSETOF(RTFSISOMAKEROBJ, pHfsName),     "hfs" },
+    {   RTFSISOMAKER_NAMESPACE_ISO_9660, RT_UOFFSETOF(RTFSISOMAKERINT, PrimaryIso), RT_UOFFSETOF(RTFSISOMAKEROBJ, pPrimaryName), "iso-9660" },
+    {   RTFSISOMAKER_NAMESPACE_JOLIET,   RT_UOFFSETOF(RTFSISOMAKERINT, Joliet),     RT_UOFFSETOF(RTFSISOMAKEROBJ, pJolietName),  "joliet" },
+    {   RTFSISOMAKER_NAMESPACE_UDF,      RT_UOFFSETOF(RTFSISOMAKERINT, Udf),        RT_UOFFSETOF(RTFSISOMAKEROBJ, pUdfName),     "udf" },
+    {   RTFSISOMAKER_NAMESPACE_HFS,      RT_UOFFSETOF(RTFSISOMAKERINT, Hfs),        RT_UOFFSETOF(RTFSISOMAKEROBJ, pHfsName),     "hfs" },
 };
 
@@ -3611 +3611 @@
      * Do the adding.
      */
-    PRTFSISOMAKERSYMLINK pSymlink = (PRTFSISOMAKERSYMLINK)RTMemAllocZ(RT_UOFFSETOF(RTFSISOMAKERSYMLINK, szTarget[cchTarget + 1]));
+    PRTFSISOMAKERSYMLINK pSymlink = (PRTFSISOMAKERSYMLINK)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFSISOMAKERSYMLINK, szTarget[cchTarget + 1]));
     AssertReturn(pSymlink, VERR_NO_MEMORY);
     int rc = rtFsIsoMakerInitCommonObj(pThis, &pSymlink->Core, RTFSISOMAKEROBJTYPE_SYMLINK, pObjInfo);
@@ -5882 +5882 @@
                 size_t         cchThis = RT_MIN(cchSrc, ISO9660RRIPNM_MAX_NAME_LEN);
                 PISO9660RRIPNM pNM     = (PISO9660RRIPNM)pbSys;
-                Assert(cbSys >= RT_UOFFSETOF(ISO9660RRIPNM, achName[cchThis]));
+                Assert(cbSys >= RT_UOFFSETOF_DYN(ISO9660RRIPNM, achName[cchThis]));
                 pNM->Hdr.bSig1      = ISO9660RRIPNM_SIG1;
                 pNM->Hdr.bSig2      = ISO9660RRIPNM_SIG2;
@@ -7379 +7379 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         NULL /*SetMode*/,
         NULL /*SetTimes*/,

trunk/src/VBox/Runtime/common/fs/isomakerimport.cpp

@@ -732 +732 @@
                     || pUnion->SP.bCheck1   != ISO9660SUSPSP_CHECK1
                     || pUnion->SP.bCheck2   != ISO9660SUSPSP_CHECK2
-                    || pUnion->SP.cbSkip > UINT8_MAX - RT_OFFSETOF(ISO9660DIRREC, achFileId[1]))
+                    || pUnion->SP.cbSkip > UINT8_MAX - RT_UOFFSETOF(ISO9660DIRREC, achFileId[1]))
                     LogRel(("rtFsIsoImport/Rock: Malformed 'SP' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x), bCheck1=%#x (vs %#x), bCheck2=%#x (vs %#x), cbSkip=%#x (vs max %#x)\n",
                             pUnion->Hdr.cbEntry, ISO9660SUSPSP_LEN, pUnion->Hdr.bVersion, ISO9660SUSPSP_VER,
                             pUnion->SP.bCheck1, ISO9660SUSPSP_CHECK1, pUnion->SP.bCheck2, ISO9660SUSPSP_CHECK2,
-                            pUnion->SP.cbSkip, UINT8_MAX - RT_OFFSETOF(ISO9660DIRREC, achFileId[1]) ));
+                            pUnion->SP.cbSkip, UINT8_MAX - RT_UOFFSETOF(ISO9660DIRREC, achFileId[1]) ));
                 else if (!fIsFirstDirRec)
                     LogRel(("rtFsIsoImport/Rock: Ignorining 'SP' entry in non-root directory record\n"));
@@ -750 +750 @@
 
             case MAKE_SIG(ISO9660SUSPER_SIG1, ISO9660SUSPER_SIG2): /* ER */
-                if (   pUnion->Hdr.cbEntry >   RT_OFFSETOF(ISO9660SUSPER, achPayload) + (uint32_t)pUnion->ER.cchIdentifier
+                if (   pUnion->Hdr.cbEntry >   RT_UOFFSETOF(ISO9660SUSPER, achPayload) + (uint32_t)pUnion->ER.cchIdentifier
                                              + (uint32_t)pUnion->ER.cchDescription   + (uint32_t)pUnion->ER.cchSource
                     || pUnion->Hdr.bVersion != ISO9660SUSPER_VER)
@@ -914 +914 @@
             case MAKE_SIG(ISO9660RRIPSL_SIG1, ISO9660RRIPSL_SIG2): /* SL */
                 if (   pUnion->SL.Hdr.bVersion != ISO9660RRIPSL_VER
-                    || pUnion->SL.Hdr.cbEntry < RT_OFFSETOF(ISO9660RRIPSL, abComponents[2])
+                    || pUnion->SL.Hdr.cbEntry < RT_UOFFSETOF(ISO9660RRIPSL, abComponents[2])
                     || (pUnion->SL.fFlags & ~ISO9660RRIP_SL_F_CONTINUE)
                     || (pUnion->SL.abComponents[0] & ISO9660RRIP_SL_C_RESERVED_MASK) )
                     LogRel(("rtFsIsoImport/Rock: Malformed 'SL' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x comp[0].fFlags=%#x\n",
-                            pUnion->SL.Hdr.cbEntry, RT_OFFSETOF(ISO9660RRIPSL, abComponents[2]),
+                            pUnion->SL.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPSL, abComponents[2]),
                             pUnion->SL.Hdr.bVersion, ISO9660RRIPSL_VER, pUnion->SL.fFlags, pUnion->SL.abComponents[0]));
                 else if (pThis->fSeenLastSL)
@@ -928 +928 @@
                     size_t         offDst    = strlen(pThis->szRockSymlinkTargetBuf);
                     uint8_t const *pbSrc     = &pUnion->SL.abComponents[0];
-                    uint8_t        cbSrcLeft = pUnion->SL.Hdr.cbEntry - RT_OFFSETOF(ISO9660RRIPSL, abComponents);
+                    uint8_t        cbSrcLeft = pUnion->SL.Hdr.cbEntry - RT_UOFFSETOF(ISO9660RRIPSL, abComponents);
                     while (cbSrcLeft >= 2)
                     {
@@ -1019 +1019 @@
             case MAKE_SIG(ISO9660RRIPNM_SIG1, ISO9660RRIPNM_SIG2): /* NM */
                 if (   pUnion->NM.Hdr.bVersion != ISO9660RRIPNM_VER
-                    || pUnion->NM.Hdr.cbEntry < RT_OFFSETOF(ISO9660RRIPNM, achName)
+                    || pUnion->NM.Hdr.cbEntry < RT_UOFFSETOF(ISO9660RRIPNM, achName)
                     || (pUnion->NM.fFlags & ISO9660RRIP_NM_F_RESERVED_MASK) )
                     LogRel(("rtFsIsoImport/Rock: Malformed 'NM' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x %.*Rhxs\n",
-                            pUnion->NM.Hdr.cbEntry, RT_OFFSETOF(ISO9660RRIPNM, achName),
+                            pUnion->NM.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPNM, achName),
                             pUnion->NM.Hdr.bVersion, ISO9660RRIPNM_VER, pUnion->NM.fFlags,
-                            pUnion->NM.Hdr.cbEntry - RT_MIN(pUnion->NM.Hdr.cbEntry, RT_OFFSETOF(ISO9660RRIPNM, achName)),
+                            pUnion->NM.Hdr.cbEntry - RT_MIN(pUnion->NM.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPNM, achName)),
                             &pUnion->NM.achName[0] ));
                 else if (pThis->fSeenLastNM)
@@ -1032 +1032 @@
                     pThis->fSeenLastNM = !(pUnion->NM.fFlags & ISO9660RRIP_NM_F_CONTINUE);
 
-                    uint8_t const cchName = pUnion->NM.Hdr.cbEntry - (uint8_t)RT_OFFSETOF(ISO9660RRIPNM, achName);
+                    uint8_t const cchName = pUnion->NM.Hdr.cbEntry - (uint8_t)RT_UOFFSETOF(ISO9660RRIPNM, achName);
                     if (pUnion->NM.fFlags & (ISO9660RRIP_NM_F_CURRENT | ISO9660RRIP_NM_F_PARENT))
                     {
@@ -1163 +1163 @@
                                ISO9660_GET_ENDIAN(&pDirRec->offExtent), pThis->cBlocksInPrimaryVolumeSpace);
 
-    if (pDirRec->cbDirRec < RT_OFFSETOF(ISO9660DIRREC, achFileId) + pDirRec->bFileIdLength)
+    if (pDirRec->cbDirRec < RT_UOFFSETOF(ISO9660DIRREC, achFileId) + pDirRec->bFileIdLength)
         return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_DIR_REC_LENGTH,
                                "Dir record size is too small: %#x (min %#x)",
-                               pDirRec->cbDirRec, RT_OFFSETOF(ISO9660DIRREC, achFileId) + pDirRec->bFileIdLength);
+                               pDirRec->cbDirRec, RT_UOFFSETOF(ISO9660DIRREC, achFileId) + pDirRec->bFileIdLength);
     if (pDirRec->cbDirRec > cbMax)
         return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_DIR_REC_LENGTH,
@@ -1830 +1830 @@
                                ISO9660_GET_ENDIAN(&pDirRec->offExtent), pThis->cBlocksInPrimaryVolumeSpace);
 
-    if (pDirRec->cbDirRec < RT_OFFSETOF(ISO9660DIRREC, achFileId))
+    if (pDirRec->cbDirRec < RT_UOFFSETOF(ISO9660DIRREC, achFileId))
         return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_ROOT_DIR_REC_LENGTH,
                                "Root dir record size is too small: %#x (min %#x)",
-                               pDirRec->cbDirRec, RT_OFFSETOF(ISO9660DIRREC, achFileId));
+                               pDirRec->cbDirRec, RT_UOFFSETOF(ISO9660DIRREC, achFileId));
 
     if (!(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY))

trunk/src/VBox/Runtime/common/fs/isovfs.cpp

@@ -1229 +1229 @@
      * Basic sanity checking of what we use.
      */
-    if (     RT_OFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs + pFileEntry->cbAllocDescs
+    if (     RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs + pFileEntry->cbAllocDescs
            > pVol->Udf.VolInfo.cbBlock
         || (pFileEntry->cbExtAttribs & 3) != 0
@@ -1275 +1275 @@
                                                 idxDefaultPart,
                                                   ((uint64_t)pFileEntry->Tag.offTag << pVol->Udf.VolInfo.cShiftBlock)
-                                                + RT_OFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs,
+                                                + RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs,
                                                 pVol);
         if (RT_SUCCESS(rc))
@@ -1381 +1381 @@
      * Basic sanity checking of what we use.
      */
-    if (     RT_OFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs + pFileEntry->cbAllocDescs
+    if (     RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs + pFileEntry->cbAllocDescs
            > pVol->Udf.VolInfo.cbBlock
         || (pFileEntry->cbExtAttribs & 3) != 0
@@ -1431 +1431 @@
                                                 idxDefaultPart,
                                                   ((uint64_t)pFileEntry->Tag.offTag << pVol->Udf.VolInfo.cShiftBlock)
-                                                + RT_OFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs,
+                                                + RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs,
                                                 pVol);
         if (RT_SUCCESS(rc))
@@ -2153 +2153 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         NULL /*SetMode*/,
         NULL /*SetTimes*/,
@@ -3430 +3430 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSDIROPS, Obj) - RT_OFFSETOF(RTVFSDIROPS, ObjSet),
+        RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
         NULL /*SetMode*/,
         NULL /*SetTimes*/,
@@ -3549 +3549 @@
                   wszName));
 
-            uint32_t offSysUse = RT_OFFSETOF(ISO9660DIRREC, achFileId[pDirRec->bFileIdLength]) + !(pDirRec->bFileIdLength & 1);
+            uint32_t offSysUse = RT_UOFFSETOF_DYN(ISO9660DIRREC, achFileId[pDirRec->bFileIdLength])
+                               + !(pDirRec->bFileIdLength & 1);
             if (offSysUse < pDirRec->cbDirRec)
             {
@@ -3631 +3632 @@
     {
         uint32_t offDesc = 0;
-        while (offDesc + RT_OFFSETOF(UDFFILEIDDESC, abImplementationUse) < pThis->cbDir)
+        while (offDesc + RT_UOFFSETOF(UDFFILEIDDESC, abImplementationUse) < pThis->cbDir)
         {
             PCUDFFILEIDDESC pFid  = (PCUDFFILEIDDESC)&pThis->pbDir[offDesc];
@@ -5368 +5369 @@
         Log2(("ISO9660:  RootDir.RecTime.bFileIdLength:      %RX8\n", pVolDesc->RootDir.DirRec.bFileIdLength));
         Log2(("ISO9660:  RootDir.RecTime.achFileId:          '%.*s'\n", pVolDesc->RootDir.DirRec.bFileIdLength, pVolDesc->RootDir.DirRec.achFileId));
-        uint32_t offSysUse = RT_OFFSETOF(ISO9660DIRREC, achFileId[pVolDesc->RootDir.DirRec.bFileIdLength])
+        uint32_t offSysUse = RT_UOFFSETOF_DYN(ISO9660DIRREC, achFileId[pVolDesc->RootDir.DirRec.bFileIdLength])
                            + !(pVolDesc->RootDir.DirRec.bFileIdLength & 1);
         if (offSysUse < pVolDesc->RootDir.DirRec.cbDirRec)
@@ -5392 +5393 @@
                                    PISO9660DIRREC pDstRootDir, PRTERRINFO pErrInfo)
 {
-    if (pRootDir->cbDirRec < RT_OFFSETOF(ISO9660DIRREC, achFileId))
+    if (pRootDir->cbDirRec < RT_UOFFSETOF(ISO9660DIRREC, achFileId))
         return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Root dir record size is too small: %#x (min %#x)",
-                                   pRootDir->cbDirRec, RT_OFFSETOF(ISO9660DIRREC, achFileId));
+                                   pRootDir->cbDirRec, RT_UOFFSETOF(ISO9660DIRREC, achFileId));
 
     if (!(pRootDir->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY))
@@ -5494 +5495 @@
      * ... and the root directory record.
      */
-    *poffRootDirRec = offVolDesc + RT_OFFSETOF(ISO9660PRIMARYVOLDESC, RootDir.DirRec);
+    *poffRootDirRec = offVolDesc + RT_UOFFSETOF(ISO9660PRIMARYVOLDESC, RootDir.DirRec);
     return rtFsIsoVolHandleRootDir(pThis, &pVolDesc->RootDir.DirRec, pRootDir, pErrInfo);
 }
@@ -5571 +5572 @@
     if (RT_SUCCESS(rc))
     {
-        *poffRootDirRec = offVolDesc + RT_OFFSETOF(ISO9660SUPVOLDESC, RootDir.DirRec);
+        *poffRootDirRec = offVolDesc + RT_UOFFSETOF(ISO9660SUPVOLDESC, RootDir.DirRec);
         *pbUcs2Level    = pVolDesc->abEscapeSequences[2] == ISO9660_JOLIET_ESC_SEQ_2_LEVEL_1 ? 1
                         : pVolDesc->abEscapeSequences[2] == ISO9660_JOLIET_ESC_SEQ_2_LEVEL_2 ? 2 : 3;

trunk/src/VBox/Runtime/common/fs/ntfsvfs.cpp

@@ -764 +764 @@
                                     Log2(("NTFS:     cwcFilename        %#x\n", pInfo->cwcFilename));
                                     Log2(("NTFS:     fFilenameType      %#x\n", pInfo->fFilenameType));
-                                    if (RT_UOFFSETOF(NTFSATFILENAME, wszFilename[pInfo->cwcFilename]) <= cbValue)
+                                    if (RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pInfo->cwcFilename]) <= cbValue)
                                         Log2(("NTFS:     wszFilename       '%.*ls'\n", pInfo->cwcFilename, pInfo->wszFilename ));
                                     else
@@ -770 +770 @@
                                 }
                                 else
-                                    Log2(("NTFS:     Error! cbValue=%#x is smaller than expected (%#x) for NTFSATFILENAME!\n",
-                                          cbValue, RT_OFFSETOF(NTFSATFILENAME, wszFilename) ));
+                                    Log2(("NTFS:     Error! cbValue=%#x is smaller than expected (%#zx) for NTFSATFILENAME!\n",
+                                          cbValue, RT_UOFFSETOF(NTFSATFILENAME, wszFilename) ));
                                 break;
                             }
@@ -2138 +2138 @@
         if (   pFilename
             && pFilename->cwcFilename >= 4
-            && RT_UOFFSETOF(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) <= cbFilename)
+            && RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) <= cbFilename)
         {
             PCRTUTF16 pwcExt = &pFilename->wszFilename[pFilename->cwcFilename - 4];
@@ -2618 +2618 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtFsNtfsFile_SetMode,
         rtFsNtfsFile_SetTimes,
@@ -2820 +2820 @@
             Log2(("NTFS:             cwcFilename        %#x\n", pFilename->cwcFilename));
             Log2(("NTFS:             fFilenameType      %#x\n", pFilename->fFilenameType));
-            if (RT_UOFFSETOF(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) <= RT_LE2H_U16(pEntryHdr->cbKey))
+            if (RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) <= RT_LE2H_U16(pEntryHdr->cbKey))
                 Log2(("NTFS:             wszFilename       '%.*ls'\n", pFilename->cwcFilename, pFilename->wszFilename ));
             else
@@ -2980 +2980 @@
         {
             PCNTFSATFILENAME pFilename = (PCNTFSATFILENAME)(pEntryHdr + 1);
-            if (RT_UOFFSETOF(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) > cbKey)
+            if (RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) > cbKey)
                 return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT,
                                                "%s: Entry #%u filename is out of bounds: cwcFilename=%#x -> %#x key, max %#x",
                                                pszWhat, iEntry, pFilename->cwcFilename,
-                                               RT_UOFFSETOF(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]), cbKey);
+                                               RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]), cbKey);
         }
 
@@ -4163 +4163 @@
         {
 
-            *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName[pThis->paEnumStack[0].iNext + 2]);
+            *pcbDirEntry = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[pThis->paEnumStack[0].iNext + 2]);
             if (*pcbDirEntry > cbDirEntry)
                 return VERR_BUFFER_OVERFLOW;
@@ -4255 +4255 @@
                                 rc, pFilename->cwcFilename * sizeof(RTUTF16), pFilename->wszFilename));
                     }
-                    *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName[cchFilename + 1]);
+                    *pcbDirEntry = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cchFilename + 1]);
                     if (*pcbDirEntry > cbDirEntry)
                     {
@@ -4403 +4403 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSDIROPS, Obj) - RT_OFFSETOF(RTVFSDIROPS, ObjSet),
+        RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
         rtFsNtfsDir_SetMode,
         rtFsNtfsDir_SetTimes,

trunk/src/VBox/Runtime/common/fuzz/fuzz-observer.cpp

@@ -439 +439 @@
 {
     int rc = VINF_SUCCESS;
-    PRTFUZZOBSEXECCTX pExecCtx = (PRTFUZZOBSEXECCTX)RTMemAllocZ(RT_OFFSETOF(RTFUZZOBSEXECCTX, apszArgs[pThis->cArgs + 1]));
+    PRTFUZZOBSEXECCTX pExecCtx = (PRTFUZZOBSEXECCTX)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFUZZOBSEXECCTX, apszArgs[pThis->cArgs + 1]));
     if (RT_LIKELY(pExecCtx))
     {

trunk/src/VBox/Runtime/common/fuzz/fuzz.cpp

@@ -333 +333 @@
 static PRTFUZZINPUTINT rtFuzzCtxInputClone(PRTFUZZCTXINT pThis, const void *pvBuf, size_t cbBuf)
 {
-    PRTFUZZINPUTINT pInpClone = (PRTFUZZINPUTINT)RTMemAllocZ(RT_OFFSETOF(RTFUZZINPUTINT, abInput[cbBuf]));
+    PRTFUZZINPUTINT pInpClone = (PRTFUZZINPUTINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFUZZINPUTINT, abInput[cbBuf]));
     if (RT_LIKELY(pInpClone))
     {
@@ -355 +355 @@
 static PRTFUZZINPUTINT rtFuzzCtxInputCreate(PRTFUZZCTXINT pThis, size_t cbInput)
 {
-    PRTFUZZINPUTINT pInput = (PRTFUZZINPUTINT)RTMemAllocZ(RT_OFFSETOF(RTFUZZINPUTINT, abInput[cbInput]));
+    PRTFUZZINPUTINT pInput = (PRTFUZZINPUTINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFUZZINPUTINT, abInput[cbInput]));
     if (RT_LIKELY(pInput))
     {
@@ -846 +846 @@
     if (!pInput)
     {
-        pInput = (PRTFUZZINPUTINT)RTMemAllocZ(RT_OFFSETOF(RTFUZZINPUTINT, abInput[cbInput]));
+        pInput = (PRTFUZZINPUTINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFUZZINPUTINT, abInput[cbInput]));
         if (RT_LIKELY(pInput))
         {
@@ -897 +897 @@
     if (RT_SUCCESS(rc))
     {
-        PRTFUZZINPUTINT pInput = (PRTFUZZINPUTINT)RTMemAllocZ(RT_OFFSETOF(RTFUZZINPUTINT, abInput[cbFile]));
+        PRTFUZZINPUTINT pInput = (PRTFUZZINPUTINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFUZZINPUTINT, abInput[cbFile]));
         if (RT_LIKELY(pInput))
         {

trunk/src/VBox/Runtime/common/ldr/ldrEx.cpp

@@ -95 +95 @@
     if (uSign.au16[0] == IMAGE_DOS_SIGNATURE)
     {
-        rc = pReader->pfnRead(pReader, &offHdr, sizeof(offHdr), RT_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
+        rc = pReader->pfnRead(pReader, &offHdr, sizeof(offHdr), RT_UOFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
         if (RT_FAILURE(rc))
             return rc;

trunk/src/VBox/Runtime/common/ldr/ldrPE.cpp

@@ -1134 +1134 @@
                  * Enough buffer?
                  */
-                uint32_t cbNeeded = RT_OFFSETOF(RTLDRIMPORTINFO, szModule[iImpOrdinal != UINT32_MAX ? offDot + 1 : off + 1]);
+                uint32_t cbNeeded = RT_UOFFSETOF_DYN(RTLDRIMPORTINFO, szModule[iImpOrdinal != UINT32_MAX ? offDot + 1 : off + 1]);
                 if (cbNeeded > cbInfo)
                     return VERR_BUFFER_OVERFLOW;
@@ -1519 +1519 @@
                             {
                                 rc = RTUtf16ToUtf8Ex((PCRTUTF16)&pMisc->Data[0],
-                                                     (pMisc->Length - RT_OFFSETOF(IMAGE_DEBUG_MISC, Data)) / sizeof(RTUTF16),
+                                                     (pMisc->Length - RT_UOFFSETOF(IMAGE_DEBUG_MISC, Data)) / sizeof(RTUTF16),
                                                      &pszPath, RTPATH_MAX, NULL);
                                 if (RT_SUCCESS(rc))
@@ -2141 +2141 @@
     pPlaces->offCksum       = (uint32_t)pModPe->offNtHdrs
                             + (pModPe->f64Bit
-                               ? RT_OFFSETOF(IMAGE_NT_HEADERS64, OptionalHeader.CheckSum)
-                               : RT_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader.CheckSum));
+                               ? RT_UOFFSETOF(IMAGE_NT_HEADERS64, OptionalHeader.CheckSum)
+                               : RT_UOFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader.CheckSum));
     pPlaces->cbCksum        = RT_SIZEOFMEMB(IMAGE_NT_HEADERS32, OptionalHeader.CheckSum);
     pPlaces->offSecDir      = (uint32_t)pModPe->offNtHdrs
                             + (pModPe->f64Bit
-                               ? RT_OFFSETOF(IMAGE_NT_HEADERS64, OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY])
-                               : RT_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]));
+                               ? RT_UOFFSETOF(IMAGE_NT_HEADERS64, OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY])
+                               : RT_UOFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]));
     pPlaces->cbSecDir       = sizeof(IMAGE_DATA_DIRECTORY);
     pPlaces->offEndSpecial  = pPlaces->offSecDir + pPlaces->cbSecDir;
@@ -2460 +2460 @@
     RTAsn1CursorInitPrimary(&PrimaryCursor,
                             &pEntry->bCertificate[0],
-                            pEntry->dwLength - RT_OFFSETOF(WIN_CERTIFICATE, bCertificate),
+                            pEntry->dwLength - RT_UOFFSETOF(WIN_CERTIFICATE, bCertificate),
                             pErrInfo,
                             &g_RTAsn1DefaultAllocator,
@@ -2985 +2985 @@
 
     /* from LoaderFlags and out the difference is 4 * 32-bits. */
-    Assert(RT_OFFSETOF(IMAGE_OPTIONAL_HEADER32, LoaderFlags) + 16 == RT_OFFSETOF(IMAGE_OPTIONAL_HEADER64, LoaderFlags));
-    Assert(     RT_OFFSETOF(IMAGE_OPTIONAL_HEADER32, DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]) + 16
-           ==   RT_OFFSETOF(IMAGE_OPTIONAL_HEADER64, DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]));
+    Assert(RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER32, LoaderFlags) + 16 == RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER64, LoaderFlags));
+    Assert(     RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER32, DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]) + 16
+           ==   RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER64, DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]));
     uint32_t volatile       *pu32Dst     = (uint32_t *)&pOptHdr64->DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] - 1;
     const uint32_t volatile *pu32Src     = (uint32_t *)&pOptHdr32->DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] - 1;
@@ -3005 +3005 @@
      * other since this is all declared volatile, but taking now chances, we'll use a temp variable.
      */
-    Assert(RT_OFFSETOF(IMAGE_OPTIONAL_HEADER32, SizeOfStackReserve) == RT_OFFSETOF(IMAGE_OPTIONAL_HEADER64, SizeOfStackReserve));
-    Assert(RT_OFFSETOF(IMAGE_OPTIONAL_HEADER32, BaseOfData) == RT_OFFSETOF(IMAGE_OPTIONAL_HEADER64, ImageBase));
-    Assert(RT_OFFSETOF(IMAGE_OPTIONAL_HEADER32, SectionAlignment) == RT_OFFSETOF(IMAGE_OPTIONAL_HEADER64, SectionAlignment));
+    Assert(RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER32, SizeOfStackReserve) == RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER64, SizeOfStackReserve));
+    Assert(RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER32, BaseOfData)         == RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER64, ImageBase));
+    Assert(RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER32, SectionAlignment)   == RT_UOFFSETOF(IMAGE_OPTIONAL_HEADER64, SectionAlignment));
     uint32_t u32ImageBase = pOptHdr32->ImageBase;
     pOptHdr64->ImageBase = u32ImageBase;
@@ -3066 +3066 @@
     pLoadCfg64->DeCommitFreeBlockThreshold      = u32DeCommitFreeBlockThreshold;
     /* the rest is equal. */
-    Assert(     RT_OFFSETOF(IMAGE_LOAD_CONFIG_DIRECTORY32, DeCommitFreeBlockThreshold)
-           ==   RT_OFFSETOF(IMAGE_LOAD_CONFIG_DIRECTORY64, DeCommitFreeBlockThreshold));
+    Assert(     RT_UOFFSETOF(IMAGE_LOAD_CONFIG_DIRECTORY32, DeCommitFreeBlockThreshold)
+           ==   RT_UOFFSETOF(IMAGE_LOAD_CONFIG_DIRECTORY64, DeCommitFreeBlockThreshold));
 }
 
@@ -3898 +3898 @@
                     pModPe->offPkcs7SignedData = Dir.VirtualAddress
                                                + (uint32_t)((uintptr_t)&pCur->bCertificate[0] - (uintptr_t)pFirst);
-                    pModPe->cbPkcs7SignedData  = pCur->dwLength - RT_OFFSETOF(WIN_CERTIFICATE, bCertificate);
+                    pModPe->cbPkcs7SignedData  = pCur->dwLength - RT_UOFFSETOF(WIN_CERTIFICATE, bCertificate);
                 }
 

trunk/src/VBox/Runtime/common/ldr/ldrVfsFile.cpp

@@ -189 +189 @@
     size_t cbFilename = strlen(pszFilename) + 1;
     int rc = VERR_NO_MEMORY;
-    PRTLDRREADERVFSFILE pFileReader = (PRTLDRREADERVFSFILE)RTMemAlloc(RT_OFFSETOF(RTLDRREADERVFSFILE, szFilename[cbFilename]));
+    PRTLDRREADERVFSFILE pFileReader = (PRTLDRREADERVFSFILE)RTMemAlloc(RT_UOFFSETOF_DYN(RTLDRREADERVFSFILE, szFilename[cbFilename]));
     if (pFileReader)
     {

trunk/src/VBox/Runtime/common/log/log.cpp

@@ -213 +213 @@
 # ifdef IN_RING3
 /** The size of the RTLOGGERINTERNAL structure in ring-0.  */
-#  define RTLOGGERINTERNAL_R0_SIZE       RT_OFFSETOF(RTLOGGERINTERNAL, pfnPhase)
+#  define RTLOGGERINTERNAL_R0_SIZE       RT_UOFFSETOF(RTLOGGERINTERNAL, pfnPhase)
 AssertCompileMemberAlignment(RTLOGGERINTERNAL, hFile, sizeof(void *));
 AssertCompileMemberAlignment(RTLOGGERINTERNAL, cbHistoryFileMax, sizeof(uint64_t));
@@ -809 +809 @@
      * Allocate a logger instance.
      */
-    offInternal = RT_OFFSETOF(RTLOGGER, afGroups[cGroups]);
+    offInternal = RT_UOFFSETOF_DYN(RTLOGGER, afGroups[cGroups]);
     offInternal = RT_ALIGN_Z(offInternal, sizeof(uint64_t));
     cbLogger = offInternal + sizeof(RTLOGGERINTERNAL);
@@ -1194 +1194 @@
      * Check if there's enough space for the groups.
      */
-    if (cbLoggerRC < (size_t)RT_OFFSETOF(RTLOGGERRC, afGroups[pLogger->cGroups]))
-    {
-        AssertMsgFailed(("%d req=%d cGroups=%d\n", cbLoggerRC, RT_OFFSETOF(RTLOGGERRC, afGroups[pLogger->cGroups]), pLogger->cGroups));
+    if (cbLoggerRC < (size_t)RT_UOFFSETOF_DYN(RTLOGGERRC, afGroups[pLogger->cGroups]))
+    {
+        AssertMsgFailed(("%zu req=%zu cGroups=%d\n", cbLoggerRC, RT_UOFFSETOF_DYN(RTLOGGERRC, afGroups[pLogger->cGroups]), pLogger->cGroups));
         return VERR_BUFFER_OVERFLOW;
     }
@@ -1349 +1349 @@
 RTDECL(size_t) RTLogCalcSizeForR0(uint32_t cGroups, uint32_t fFlags)
 {
-    size_t cb = RT_OFFSETOF(RTLOGGER, afGroups[cGroups]);
+    size_t cb = RT_UOFFSETOF_DYN(RTLOGGER, afGroups[cGroups]);
     cb = RT_ALIGN_Z(cb, sizeof(uint64_t));
     cb += sizeof(RTLOGGERINTERNAL);
@@ -1394 +1394 @@
     {
         AssertMsgFailed(("cMaxGroups=%zd cGroups=%zd (min size %d)\n", pDstInt->cMaxGroups,
-                         pSrcLogger->cGroups, RT_OFFSETOF(RTLOGGER, afGroups[pSrcLogger->cGroups]) + RTLOGGERINTERNAL_R0_SIZE));
+                         pSrcLogger->cGroups, RT_UOFFSETOF_DYN(RTLOGGER, afGroups[pSrcLogger->cGroups]) + RTLOGGERINTERNAL_R0_SIZE));
         rc = VERR_INVALID_PARAMETER;
         cGroups = pDstInt->cMaxGroups;

trunk/src/VBox/Runtime/common/log/tracebuf.cpp

@@ -265 +265 @@
     pszBuf  = &pEntry->szMsg[0]; \
     *pszBuf = '\0'; \
-    cchBuf  = pThis->cbEntry - RT_OFFSETOF(RTTRACEBUFENTRY, szMsg) - 1; \
+    cchBuf  = pThis->cbEntry - RT_UOFFSETOF(RTTRACEBUFENTRY, szMsg) - 1; \
     rc      = VINF_SUCCESS
 

trunk/src/VBox/Runtime/common/log/tracelogreader.cpp

@@ -820 +820 @@
         {
             /* Allocate new internal event descriptor state. */
-            size_t cbEvtDesc = RT_OFFSETOF(RTTRACELOGRDREVTDESC, aEvtItemDesc[pEvtDesc->cEvtItems]);
+            size_t cbEvtDesc = RT_UOFFSETOF_DYN(RTTRACELOGRDREVTDESC, aEvtItemDesc[pEvtDesc->cEvtItems]);
             PRTTRACELOGRDREVTDESC pEvtDescInt = (PRTTRACELOGRDREVTDESC)RTMemAllocZ(cbEvtDesc);
             if (RT_LIKELY(pEvtDesc))
@@ -999 +999 @@
                 && pEvtStrm->cRawEvtDataSz == pEvtDesc->cRawDataNonStatic))
         {
-            size_t cbEvt = RT_OFFSETOF(RTTRACELOGRDREVTINT, abEvtData[pEvtStrm->cbEvtData]);
+            size_t cbEvt = RT_UOFFSETOF_DYN(RTTRACELOGRDREVTINT, abEvtData[pEvtStrm->cbEvtData]);
             cbEvt += pEvtDesc->cRawDataNonStatic * sizeof(size_t);
             PRTTRACELOGRDREVTINT pEvt = (PRTTRACELOGRDREVTINT)RTMemAllocZ(cbEvt);

trunk/src/VBox/Runtime/common/log/tracelogwriter.cpp

@@ -137 +137 @@
 static size_t rtTraceLogWrtEvtDescGetSz(PCRTTRACELOGEVTDESC pEvtDesc)
 {
-    size_t cbAlloc = RT_OFFSETOF(RTTRACELOGWREVTDESC, aEvtItemDesc[pEvtDesc->cEvtItems]);
+    size_t cbAlloc = RT_UOFFSETOF_DYN(RTTRACELOGWREVTDESC, aEvtItemDesc[pEvtDesc->cEvtItems]);
 
     cbAlloc += strlen(pEvtDesc->pszId) + 1;

trunk/src/VBox/Runtime/common/path/RTPathGlob.cpp

@@ -1475 +1475 @@
     if (pGlob->cResults < RTPATHGLOB_MAX_RESULTS)
     {
-        PRTPATHGLOBENTRY pEntry = (PRTPATHGLOBENTRY)RTMemAlloc(RT_OFFSETOF(RTPATHGLOBENTRY, szPath[cchPath + 1]));
+        PRTPATHGLOBENTRY pEntry = (PRTPATHGLOBENTRY)RTMemAlloc(RT_UOFFSETOF_DYN(RTPATHGLOBENTRY, szPath[cchPath + 1]));
         if (pEntry)
         {
@@ -1515 +1515 @@
     if (pGlob->cResults < RTPATHGLOB_MAX_RESULTS)
     {
-        PRTPATHGLOBENTRY pEntry = (PRTPATHGLOBENTRY)RTMemAlloc(RT_OFFSETOF(RTPATHGLOBENTRY, szPath[cchPath + cchName + 1]));
+        PRTPATHGLOBENTRY pEntry = (PRTPATHGLOBENTRY)RTMemAlloc(RT_UOFFSETOF_DYN(RTPATHGLOBENTRY, szPath[cchPath + cchName + 1]));
         if (pEntry)
         {
@@ -1559 +1559 @@
     if (pGlob->cResults < RTPATHGLOB_MAX_RESULTS)
     {
-        PRTPATHGLOBENTRY pEntry = (PRTPATHGLOBENTRY)RTMemAlloc(RT_OFFSETOF(RTPATHGLOBENTRY, szPath[cchPath + cchName + 1]));
+        PRTPATHGLOBENTRY pEntry = (PRTPATHGLOBENTRY)RTMemAlloc(RT_UOFFSETOF_DYN(RTPATHGLOBENTRY, szPath[cchPath + cchName + 1]));
         if (pEntry)
         {
@@ -2083 +2083 @@
      * Parse the path.
      */
-    size_t        cbParsed = RT_OFFSETOF(RTPATHPARSED, aComps[1]); /** @todo 16 after testing */
+    size_t        cbParsed = RT_UOFFSETOF(RTPATHPARSED, aComps[1]); /** @todo 16 after testing */
     PRTPATHPARSED pParsed = (PRTPATHPARSED)RTMemTmpAlloc(cbParsed);
     AssertReturn(pParsed, VERR_NO_MEMORY);
@@ -2089 +2089 @@
     if (rc == VERR_BUFFER_OVERFLOW)
     {
-        cbParsed = RT_OFFSETOF(RTPATHPARSED, aComps[pParsed->cComps + 1]);
+        cbParsed = RT_UOFFSETOF_DYN(RTPATHPARSED, aComps[pParsed->cComps + 1]);
         RTMemTmpFree(pParsed);
         pParsed = (PRTPATHPARSED)RTMemTmpAlloc(cbParsed);
@@ -2112 +2112 @@
              * Allocate and initialize the glob state data structure.
              */
-            size_t      cbGlob = RT_OFFSETOF(RTPATHGLOB, aComps[pParsed->cComps + 1]);
+            size_t      cbGlob = RT_UOFFSETOF_DYN(RTPATHGLOB, aComps[pParsed->cComps + 1]);
             PRTPATHGLOB pGlob  = (PRTPATHGLOB)RTMemTmpAllocZ(cbGlob);
             if (pGlob)

trunk/src/VBox/Runtime/common/path/RTPathSplit.cpp

@@ -73 +73 @@
     uint16_t const  cchPath   = pParsedVolatile->cchPath;
     uint16_t const  offSuffix = pParsedVolatile->offSuffix;
-    uint32_t        cbNeeded  = RT_OFFSETOF(RTPATHSPLIT, apszComps[cComps])
+    uint32_t        cbNeeded  = RT_UOFFSETOF_DYN(RTPATHSPLIT, apszComps[cComps])
                               + cchPath
                               + RTPATH_PROP_FIRST_NEEDS_NO_SLASH(fProps) /* zero terminator for root spec. */

trunk/src/VBox/Runtime/common/path/RTPathSplitA.cpp

@@ -49 +49 @@
      */
     size_t cbSplit = strlen(pszPath);
-    cbSplit += RT_OFFSETOF(RTPATHSPLIT, apszComps[cbSplit / 8]) + cbSplit / 8 + 8;
+    cbSplit += RT_UOFFSETOF_DYN(RTPATHSPLIT, apszComps[cbSplit / 8]) + cbSplit / 8 + 8;
     cbSplit = RT_ALIGN(cbSplit, 64);
     PRTPATHSPLIT pSplit = (PRTPATHSPLIT)RTMemAllocTag(cbSplit, pszTag);

trunk/src/VBox/Runtime/common/string/strcache.cpp

@@ -668 +668 @@
      * here to encourage the heap to give us optimal alignment.
      */
-    size_t              cbEntry   = RT_UOFFSETOF(RTSTRCACHEBIGENTRY, Core.szString[cchString + 1]);
+    size_t              cbEntry   = RT_UOFFSETOF_DYN(RTSTRCACHEBIGENTRY, Core.szString[cchString + 1]);
     PRTSTRCACHEBIGENTRY pBigEntry = (PRTSTRCACHEBIGENTRY)RTMemAlloc(RT_ALIGN_Z(cbEntry, RTSTRCACHE_HEAP_ENTRY_SIZE_ALIGN));
     if (!pBigEntry)
@@ -780 +780 @@
     *pcCollisions = 0;
 
-    uint16_t cchStringFirst = RT_UOFFSETOF(RTSTRCACHEENTRY, szString[cchString + 1]) < RTSTRCACHE_HEAP_THRESHOLD
+    uint16_t cchStringFirst = RT_UOFFSETOF_DYN(RTSTRCACHEENTRY, szString[cchString + 1]) < RTSTRCACHE_HEAP_THRESHOLD
                             ? (uint16_t)cchString : RTSTRCACHEENTRY_BIG_LEN;
     uint32_t iHash          = uHashLen % pThis->cHashTab;
@@ -1134 +1134 @@
         PRTSTRCACHEBIGENTRY pBigStr = RT_FROM_MEMBER(pStr, RTSTRCACHEBIGENTRY, Core);
         RTListNodeRemove(&pBigStr->ListEntry);
-        pThis->cbBigEntries -= RT_ALIGN_32(RT_UOFFSETOF(RTSTRCACHEBIGENTRY, Core.szString[cchString + 1]),
+        pThis->cbBigEntries -= RT_ALIGN_32(RT_UOFFSETOF_DYN(RTSTRCACHEBIGENTRY, Core.szString[cchString + 1]),
                                            RTSTRCACHE_HEAP_ENTRY_SIZE_ALIGN);
 

trunk/src/VBox/Runtime/common/vfs/vfsbase.cpp

@@ -91 +91 @@
     do { \
         RTVFSOBJ_ASSERT_OPS(&(pDirOps)->Obj, a_enmType); \
-        RTVFSOBJSET_ASSERT_OPS(&(pDirOps)->ObjSet, RT_OFFSETOF(RTVFSDIROPS, Obj) - RT_OFFSETOF(RTVFSDIROPS, ObjSet)); \
+        RTVFSOBJSET_ASSERT_OPS(&(pDirOps)->ObjSet, RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj)); \
         Assert((pDirOps)->uVersion == RTVFSDIROPS_VERSION); \
         Assert(!(pDirOps)->fReserved); \
@@ -126 +126 @@
     do { \
         RTVFSOBJ_ASSERT_OPS(&(pSymlinkOps)->Obj, a_enmType); \
-        RTVFSOBJSET_ASSERT_OPS(&(pSymlinkOps)->ObjSet, RT_OFFSETOF(RTVFSSYMLINKOPS, Obj) - RT_OFFSETOF(RTVFSSYMLINKOPS, ObjSet)); \
+        RTVFSOBJSET_ASSERT_OPS(&(pSymlinkOps)->ObjSet, RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj)); \
         Assert((pSymlinkOps)->uVersion == RTVFSSYMLINKOPS_VERSION); \
         Assert(!(pSymlinkOps)->fReserved); \
@@ -3170 +3170 @@
         cbDirEntry = *pcbDirEntry;
         AssertMsgReturn(cbDirEntry >= RT_UOFFSETOF(RTDIRENTRYEX, szName[2]),
-                        ("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])),
+                        ("Invalid *pcbDirEntry=%d (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRYEX, szName[2])),
                         VERR_INVALID_PARAMETER);
     }

trunk/src/VBox/Runtime/common/vfs/vfsfss2dir.cpp

@@ -222 +222 @@
         size_t const            cbRelativePath = strlen(pszPath);
         PRTVFSFSSWRITE2DIRENTRY pEntry;
-        pEntry = (PRTVFSFSSWRITE2DIRENTRY)RTMemAllocVar(RT_UOFFSETOF(RTVFSFSSWRITE2DIRENTRY, szName[cbRelativePath]));
+        pEntry = (PRTVFSFSSWRITE2DIRENTRY)RTMemAllocVar(RT_UOFFSETOF_DYN(RTVFSFSSWRITE2DIRENTRY, szName[cbRelativePath]));
         if (pEntry)
         {
@@ -369 +369 @@
                 PRTVFSFSSWRITE2DIR      pThis;
                 RTVFSFSSTREAM           hVfsFss;
-                rc = RTVfsNewFsStream(&g_rtVfsFssToDirOps, RT_UOFFSETOF(RTVFSFSSWRITE2DIR, szBaseDir[cbBaseDir]),
+                rc = RTVfsNewFsStream(&g_rtVfsFssToDirOps, RT_UOFFSETOF_DYN(RTVFSFSSWRITE2DIR, szBaseDir[cbBaseDir]),
                                       NIL_RTVFS, NIL_RTVFSLOCK, false /*fReadOnly*/, &hVfsFss, (void **)&pThis);
                 if (RT_SUCCESS(rc))

trunk/src/VBox/Runtime/common/vfs/vfsmemory.cpp

@@ -421 +421 @@
      * Allocate, initialize and insert the new extent.
      */
-    PRTVFSMEMEXTENT pNew = (PRTVFSMEMEXTENT)RTMemAllocZ(RT_OFFSETOF(RTVFSMEMEXTENT, abData[cbExtent]));
+    PRTVFSMEMEXTENT pNew = (PRTVFSMEMEXTENT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTVFSMEMEXTENT, abData[cbExtent]));
     if (pNew)
     {
@@ -731 +731 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtVfsMemFile_SetMode,
         rtVfsMemFile_SetTimes,

trunk/src/VBox/Runtime/common/vfs/vfsmount.cpp

@@ -238 +238 @@
         Assert(offFirstZero >= RT_UOFFSETOF(FATBOOTSECTOR, Bpb));
         uint32_t const cbZeroPad    = RT_MIN(offJump - offFirstZero,
-                                             sizeof(pBootSector->Bpb.Bpb20) - (offFirstZero - RT_OFFSETOF(FATBOOTSECTOR, Bpb)));
+                                             sizeof(pBootSector->Bpb.Bpb20) - (offFirstZero - RT_UOFFSETOF(FATBOOTSECTOR, Bpb)));
 
         if (!ASMMemIsAllU8((uint8_t const *)pBootSector + offFirstZero, cbZeroPad, 0))
@@ -266 +266 @@
                  && pBootSector->abJmp[2] <= 0x7f)
             offJmp = RT_MIN(127, RT_MAKE_U16(pBootSector->abJmp[1], pBootSector->abJmp[2]));
-        uint8_t const cbMaxBpb = offJmp - RT_OFFSETOF(FATBOOTSECTOR, Bpb);
+        uint8_t const cbMaxBpb = offJmp - RT_UOFFSETOF(FATBOOTSECTOR, Bpb);
         if (cbMaxBpb < sizeof(FATBPB20))
         {

trunk/src/VBox/Runtime/common/vfs/vfsprogress.cpp

@@ -456 +456 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtVfsProgressFile_SetMode,
         rtVfsProgressFile_SetTimes,

trunk/src/VBox/Runtime/common/vfs/vfsreadahead.cpp

@@ -579 +579 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtVfsReadAhead_SetMode,
         rtVfsReadAhead_SetTimes,
@@ -733 +733 @@
         RTVFSIOSTREAM   hVfsIosReadAhead  = NIL_RTVFSIOSTREAM;
         PRTVFSREADAHEAD pThis;
-        size_t          cbThis = RT_OFFSETOF(RTVFSREADAHEAD, aBufDescs[cBuffers]);
+        size_t          cbThis = RT_UOFFSETOF_DYN(RTVFSREADAHEAD, aBufDescs[cBuffers]);
         if (hVfsFileSrc != NIL_RTVFSFILE)
             rc = RTVfsNewFile(&g_VfsReadAheadFileOps, cbThis, RTFILE_O_READ, NIL_RTVFS, NIL_RTVFSLOCK,

trunk/src/VBox/Runtime/common/vfs/vfsstddir.cpp

@@ -171 +171 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSSYMLINKOPS, Obj) - RT_OFFSETOF(RTVFSSYMLINKOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj),
         rtVfsStdSym_SetMode,
         rtVfsStdSym_SetTimes,
@@ -363 +363 @@
                         PRTVFSSTDSYMLINK pNewSymlink;
                         size_t           cchSymlink = strlen(pszEntry);
-                        rc = RTVfsNewSymlink(&g_rtVfsStdSymOps, RT_UOFFSETOF(RTVFSSTDSYMLINK, szSymlink[cchSymlink + 1]),
+                        rc = RTVfsNewSymlink(&g_rtVfsStdSymOps, RT_UOFFSETOF_DYN(RTVFSSTDSYMLINK, szSymlink[cchSymlink + 1]),
                                              NIL_RTVFS, NIL_RTVFSLOCK, &hVfsSymlink, (void **)&pNewSymlink);
                         if (RT_SUCCESS(rc))
@@ -540 +540 @@
                 PRTVFSSTDSYMLINK pNewSymlink;
                 size_t           cchSymlink = strlen(pszSymlink);
-                rc = RTVfsNewSymlink(&g_rtVfsStdSymOps, RT_UOFFSETOF(RTVFSSTDSYMLINK, szSymlink[cchSymlink + 1]),
+                rc = RTVfsNewSymlink(&g_rtVfsStdSymOps, RT_UOFFSETOF_DYN(RTVFSSTDSYMLINK, szSymlink[cchSymlink + 1]),
                                      NIL_RTVFS, NIL_RTVFSLOCK, phVfsSymlink, (void **)&pNewSymlink);
                 if (RT_SUCCESS(rc))
@@ -673 +673 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSDIROPS, Obj) - RT_OFFSETOF(RTVFSDIROPS, ObjSet),
+        RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
         rtVfsStdDir_SetMode,
         rtVfsStdDir_SetTimes,

trunk/src/VBox/Runtime/common/vfs/vfsstdfile.cpp

@@ -450 +450 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtVfsStdFile_SetMode,
         rtVfsStdFile_SetTimes,

trunk/src/VBox/Runtime/common/zip/pkzipvfs.cpp

@@ -717 +717 @@
                 {
                     /* sanity check */
-                    if (off + RT_OFFSETOF(RTZIPPKZIPENDOFCENTRDIRREC, u8Comment) + eocd.cbComment == cbFile)
+                    if (off + RT_UOFFSETOF(RTZIPPKZIPENDOFCENTRDIRREC, u8Comment) + eocd.cbComment == cbFile)
                     {
                         pThis->offFirstCdh = eocd.offCentrDir;

trunk/src/VBox/Runtime/common/zip/tarvfs.cpp

@@ -1191 +1191 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSSYMLINKOPS, Obj) - RT_OFFSETOF(RTVFSSYMLINKOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj),
         rtZipTarFssSym_SetMode,
         rtZipTarFssSym_SetTimes,

trunk/src/VBox/Runtime/common/zip/tarvfswriter.cpp

@@ -819 +819 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtZipTarWriterPush_SetMode,
         rtZipTarWriterPush_SetTimes,

trunk/src/VBox/Runtime/common/zip/xarvfs.cpp

@@ -1163 +1163 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSFILEOPS, Stream.Obj) - RT_OFFSETOF(RTVFSFILEOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
         rtZipXarFssFile_SetMode,
         rtZipXarFssFile_SetTimes,
@@ -1433 +1433 @@
     { /* ObjSet */
         RTVFSOBJSETOPS_VERSION,
-        RT_OFFSETOF(RTVFSSYMLINKOPS, Obj) - RT_OFFSETOF(RTVFSSYMLINKOPS, ObjSet),
+        RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj),
         rtZipXarFssSym_SetMode,
         rtZipXarFssSym_SetTimes,

trunk/src/VBox/Runtime/generic/mempool-generic.cpp

@@ -135 +135 @@
 
     size_t          cchName  = strlen(pszName);
-    PRTMEMPOOLINT   pMemPool = (PRTMEMPOOLINT)RTMemAlloc(RT_OFFSETOF(RTMEMPOOLINT, szName[cchName + 1]));
+    PRTMEMPOOLINT   pMemPool = (PRTMEMPOOLINT)RTMemAlloc(RT_UOFFSETOF_DYN(RTMEMPOOLINT, szName[cchName + 1]));
     if (!pMemPool)
         return VERR_NO_MEMORY;

trunk/src/VBox/Runtime/r0drv/linux/memobj-r0drv-linux.c

@@ -296 +296 @@
      * the page pointer array.
      */
-    PRTR0MEMOBJLNX  pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJLNX, apPages[cPages]), enmType, NULL, cb);
+    PRTR0MEMOBJLNX  pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJLNX, apPages[cPages]), enmType, NULL, cb);
     if (!pMemLnx)
         return VERR_NO_MEMORY;
@@ -1056 +1056 @@
      * Allocate the memory object and a temporary buffer for the VMAs.
      */
-    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJLNX, apPages[cPages]), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
+    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJLNX, apPages[cPages]), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
     if (!pMemLnx)
     {
@@ -1221 +1221 @@
      * Allocate the memory object.
      */
-    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJLNX, apPages[cPages]), RTR0MEMOBJTYPE_LOCK, pv, cb);
+    pMemLnx = (PRTR0MEMOBJLNX)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJLNX, apPages[cPages]), RTR0MEMOBJTYPE_LOCK, pv, cb);
     if (!pMemLnx)
     {

trunk/src/VBox/Runtime/r0drv/linux/timer-r0drv-linux.c

@@ -462 +462 @@
      * Finally, free the resources.
      */
-    RTMemFreeEx(pTimer, RT_OFFSETOF(RTTIMER, aSubTimers[pTimer->cCpus]));
+    RTMemFreeEx(pTimer, RT_UOFFSETOF_DYN(RTTIMER, aSubTimers[pTimer->cCpus]));
     if (hSpinlock != NIL_RTSPINLOCK)
         RTSpinlockDestroy(hSpinlock);
@@ -1551 +1551 @@
 #endif
 
-    rc = RTMemAllocEx(RT_OFFSETOF(RTTIMER, aSubTimers[cCpus]), 0,
+    rc = RTMemAllocEx(RT_UOFFSETOF_DYN(RTTIMER, aSubTimers[cCpus]), 0,
                       RTMEMALLOCEX_FLAGS_ZEROED | RTMEMALLOCEX_FLAGS_ANY_CTX_FREE, (void **)&pTimer);
     if (RT_FAILURE(rc))

trunk/src/VBox/Runtime/r0drv/nt/dbgkrnlinfo-r0drv-nt.cpp

@@ -357 +357 @@
      */
     uint32_t                cModules = pModInfo ? 110 /*32KB*/ : 27 /*8KB*/;
-    ULONG                   cbInfo   = RT_OFFSETOF(RTL_PROCESS_MODULES, Modules[cModules]);
+    ULONG                   cbInfo   = RT_UOFFSETOF_DYN(RTL_PROCESS_MODULES, Modules[cModules]);
     PRTL_PROCESS_MODULES    pInfo    = (PRTL_PROCESS_MODULES)RTMemAllocZ(cbInfo);
     if (!pInfo)
     {
         cModules = cModules / 4;
-        cbInfo   = RT_OFFSETOF(RTL_PROCESS_MODULES, Modules[cModules]);
+        cbInfo   = RT_UOFFSETOF_DYN(RTL_PROCESS_MODULES, Modules[cModules]);
         pInfo    = (PRTL_PROCESS_MODULES)RTMemAllocZ(cbInfo);
         if (!pInfo)

trunk/src/VBox/Runtime/r0drv/nt/initterm-r0drv-nt.cpp

@@ -385 +385 @@
     {
 #if defined(RT_ARCH_X86)
-        PKPCR    pPcr   = (PKPCR)__readfsdword(RT_OFFSETOF(KPCR,SelfPcr));
+        PKPCR    pPcr   = (PKPCR)__readfsdword(RT_UOFFSETOF(KPCR,SelfPcr));
         pbPrcb = (uint8_t *)pPcr->Prcb;
 #elif defined(RT_ARCH_AMD64)
-        PKPCR    pPcr   = (PKPCR)__readgsqword(RT_OFFSETOF(KPCR,Self));
+        PKPCR    pPcr   = (PKPCR)__readgsqword(RT_UOFFSETOF(KPCR,Self));
         pbPrcb = (uint8_t *)pPcr->CurrentPrcb;
 #else

trunk/src/VBox/Runtime/r0drv/nt/memobj-r0drv-nt.cpp

@@ -551 +551 @@
     if (cMdls >= UINT32_MAX)
         return VERR_OUT_OF_RANGE;
-    PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJNT, apMdls[cMdls]),
+    PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJNT, apMdls[cMdls]),
                                                         RTR0MEMOBJTYPE_LOCK, pv, cb);
     if (!pMemNt)

trunk/src/VBox/Runtime/r0drv/nt/nt3fakes-r0drv-nt.cpp

@@ -469 +469 @@
         {
             uZero     = *(uint32_t const *)pbCode;
-            offNewHdr = *(uint32_t const *)&pbCode[RT_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew)];
+            offNewHdr = *(uint32_t const *)&pbCode[RT_UOFFSETOF(IMAGE_DOS_HEADER, e_lfanew)];
         }
         __except(EXCEPTION_EXECUTE_HANDLER)

trunk/src/VBox/Runtime/r0drv/nt/ntBldSymDb.cpp

@@ -350 +350 @@
     if (s_cbNeeded == 0)
     {
-        s_cbNeeded = RT_OFFSETOF(MYSET, aStructs[RT_ELEMENTS(g_aStructs)]);
+        s_cbNeeded = RT_UOFFSETOF(MYSET, aStructs[RT_ELEMENTS(g_aStructs)]);
         for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
             s_cbNeeded += sizeof(MYMEMBER) * g_aStructs[i].cMembers;
@@ -522 +522 @@
     MyDbgPrintf(" %s: cChildren=%u (%#x)\n", pszStructNm, cChildren);
     TI_FINDCHILDREN_PARAMS *pChildren;
-    pChildren = (TI_FINDCHILDREN_PARAMS *)alloca(RT_OFFSETOF(TI_FINDCHILDREN_PARAMS, ChildId[cChildren]));
+    pChildren = (TI_FINDCHILDREN_PARAMS *)alloca(RT_UOFFSETOF_DYN(TI_FINDCHILDREN_PARAMS, ChildId[cChildren]));
     pChildren->Start = 0;
     pChildren->Count = cChildren;

trunk/src/VBox/Runtime/r0drv/nt/thread-r0drv-nt.cpp

@@ -137 +137 @@
 
 #ifdef RT_ARCH_X86
-    PKPCR       pPcr   = (PKPCR)__readfsdword(RT_OFFSETOF(KPCR,SelfPcr));
+    PKPCR       pPcr   = (PKPCR)__readfsdword(RT_UOFFSETOF(KPCR,SelfPcr));
     uint8_t    *pbPrcb = (uint8_t *)pPcr->Prcb;
 
 #elif defined(RT_ARCH_AMD64)
     /* HACK ALERT! The offset is from windbg/vista64. */
-    PKPCR       pPcr   = (PKPCR)__readgsqword(RT_OFFSETOF(KPCR,Self));
+    PKPCR       pPcr   = (PKPCR)__readgsqword(RT_UOFFSETOF(KPCR,Self));
     uint8_t    *pbPrcb = (uint8_t *)pPcr->CurrentPrcb;
 

trunk/src/VBox/Runtime/r0drv/nt/timer-r0drv-nt.cpp

@@ -493 +493 @@
     }
 
-    PRTTIMER pTimer = (PRTTIMER)RTMemAllocZ(RT_OFFSETOF(RTTIMER, aSubTimers[cSubTimers]));
+    PRTTIMER pTimer = (PRTTIMER)RTMemAllocZ(RT_UOFFSETOF_DYN(RTTIMER, aSubTimers[cSubTimers]));
     if (!pTimer)
         return VERR_NO_MEMORY;

trunk/src/VBox/Runtime/r0drv/os2/memobj-r0drv-os2.cpp

@@ -119 +119 @@
     /* create the object. */
     const ULONG cPages = cb >> PAGE_SHIFT;
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_PAGE, NULL, cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJOS2, aPages[cPages]),
+                                                           RTR0MEMOBJTYPE_PAGE, NULL, cb);
     if (!pMemOs2)
         return VERR_NO_MEMORY;
@@ -148 +149 @@
     /* create the object. */
     const ULONG cPages = cb >> PAGE_SHIFT;
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_LOW, NULL, cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJOS2, aPages[cPages]),
+                                                           RTR0MEMOBJTYPE_LOW, NULL, cb);
     if (!pMemOs2)
         return VERR_NO_MEMORY;
@@ -177 +179 @@
 
     /* create the object. */
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_CONT, NULL, cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_CONT, NULL, cb);
     if (!pMemOs2)
         return VERR_NO_MEMORY;
@@ -205 +207 @@
 
     /* create the object. */
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_PHYS, NULL, cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_PHYS, NULL, cb);
     if (!pMemOs2)
         return VERR_NO_MEMORY;
@@ -237 +239 @@
 
     /* create the object. */
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_PHYS, NULL, cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_PHYS, NULL, cb);
     if (!pMemOs2)
         return VERR_NO_MEMORY;
@@ -257 +259 @@
     /* create the object. */
     const ULONG cPages = cb >> PAGE_SHIFT;
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJOS2, aPages[cPages]),
+                                                           RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
     if (!pMemOs2)
         return VERR_NO_MEMORY;
@@ -283 +286 @@
     /* create the object. */
     const ULONG cPages = cb >> PAGE_SHIFT;
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_LOCK, pv, cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJOS2, aPages[cPages]),
+                                                           RTR0MEMOBJTYPE_LOCK, pv, cb);
     if (!pMemOs2)
         return VERR_NO_MEMORY;
@@ -386 +390 @@
      * (reference counting).
      */
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_MAPPING, pvR0, pMemToMapOs2->Core.cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_MAPPING,
+                                                           pvR0, pMemToMapOs2->Core.cb);
     if (pMemOs2)
     {
@@ -474 +479 @@
      * Create a mapping object for it.
      */
-    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_MAPPING, pvR3, pMemToMapOs2->Core.cb);
+    PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_UOFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_MAPPING,
+                                                           pvR3, pMemToMapOs2->Core.cb);
     if (pMemOs2)
     {

trunk/src/VBox/Runtime/r0drv/solaris/timer-r0drv-solaris.c

@@ -377 +377 @@
      */
     PRTTIMER pTimer = (PRTTIMER)RTMemAllocZ(  (fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL
-                                            ? RT_OFFSETOF(RTTIMER, u.Omni.aPerCpu[RTMpGetCount()])
+                                            ? RT_UOFFSETOF_DYN(RTTIMER, u.Omni.aPerCpu[RTMpGetCount()])
                                             : sizeof(RTTIMER));
     if (!pTimer)

trunk/src/VBox/Runtime/r3/linux/krnlmod-linux.cpp

@@ -103 +103 @@
     int rc = VINF_SUCCESS;
     size_t cchName = strlen(pszName) + 1;
-    PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(RT_OFFSETOF(RTKRNLMODINFOINT, achName[cchName]));
+    PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTKRNLMODINFOINT, achName[cchName]));
     if (RT_LIKELY(pThis))
     {

trunk/src/VBox/Runtime/r3/nt/direnum-r3-nt.cpp

@@ -643 +643 @@
         cbDirEntry = *pcbDirEntry;
         AssertMsgReturn(cbDirEntry >= RT_UOFFSETOF(RTDIRENTRY, szName[2]),
-                        ("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRY, szName[2])),
+                        ("Invalid *pcbDirEntry=%zu (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRY, szName[2])),
                         VERR_INVALID_PARAMETER);
     }
@@ -669 +669 @@
     const char  *pszName    = pDir->pszName;
     const size_t cchName    = pDir->cchName;
-    const size_t cbRequired = RT_OFFSETOF(RTDIRENTRY, szName[1]) + cchName;
+    const size_t cbRequired = RT_UOFFSETOF(RTDIRENTRY, szName[1]) + cchName;
     if (pcbDirEntry)
         *pcbDirEntry = cbRequired;
@@ -748 +748 @@
         cbDirEntry = *pcbDirEntry;
         AssertMsgReturn(cbDirEntry >= RT_UOFFSETOF(RTDIRENTRYEX, szName[2]),
-                        ("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])),
+                        ("Invalid *pcbDirEntry=%zu (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRYEX, szName[2])),
                         VERR_INVALID_PARAMETER);
     }
@@ -774 +774 @@
     const char  *pszName    = pDir->pszName;
     const size_t cchName    = pDir->cchName;
-    const size_t cbRequired = RT_OFFSETOF(RTDIRENTRYEX, szName[1]) + cchName;
+    const size_t cbRequired = RT_UOFFSETOF(RTDIRENTRYEX, szName[1]) + cchName;
     if (pcbDirEntry)
         *pcbDirEntry = cbRequired;

trunk/src/VBox/Runtime/r3/posix/dir-posix.cpp

@@ -217 +217 @@
         cbNameMax = _XOPEN_NAME_MAX;
 # endif
-    size_t cbDir = RT_OFFSETOF(RTDIRINTERNAL, Data.d_name[cbNameMax + 1]);
+    size_t cbDir = RT_UOFFSETOF_DYN(RTDIRINTERNAL, Data.d_name[cbNameMax + 1]);
     if (cbDir < sizeof(RTDIRINTERNAL))  /* Ditto. */
         cbDir = sizeof(RTDIRINTERNAL);
@@ -482 +482 @@
         cbDirEntry = *pcbDirEntry;
         AssertMsgReturn(cbDirEntry >= RT_UOFFSETOF(RTDIRENTRY, szName[2]),
-                        ("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])),
+                        ("Invalid *pcbDirEntry=%d (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRYEX, szName[2])),
                         VERR_INVALID_PARAMETER);
     }
@@ -497 +497 @@
         const char  *pszName    = pDir->pszName;
         const size_t cchName    = pDir->cchName;
-        const size_t cbRequired = RT_OFFSETOF(RTDIRENTRY, szName[1]) + cchName;
+        const size_t cbRequired = RT_UOFFSETOF(RTDIRENTRY, szName[1]) + cchName;
         if (pcbDirEntry)
             *pcbDirEntry = cbRequired;
@@ -585 +585 @@
         AssertMsgReturn(VALID_PTR(pcbDirEntry), ("%p\n", pcbDirEntry), VERR_INVALID_POINTER);
         cbDirEntry = *pcbDirEntry;
-        AssertMsgReturn(cbDirEntry >= (unsigned)RT_OFFSETOF(RTDIRENTRYEX, szName[2]),
-                        ("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])),
+        AssertMsgReturn(cbDirEntry >= RT_UOFFSETOF(RTDIRENTRYEX, szName[2]),
+                        ("Invalid *pcbDirEntry=%zu (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRYEX, szName[2])),
                         VERR_INVALID_PARAMETER);
     }
@@ -601 +601 @@
         const char  *pszName    = pDir->pszName;
         const size_t cchName    = pDir->cchName;
-        const size_t cbRequired = RT_OFFSETOF(RTDIRENTRYEX, szName[1]) + cchName;
+        const size_t cbRequired = RT_UOFFSETOF(RTDIRENTRYEX, szName[1]) + cchName;
         if (pcbDirEntry)
             *pcbDirEntry = cbRequired;

trunk/src/VBox/Runtime/r3/posix/localipc-posix.cpp

@@ -177 +177 @@
             *pcbAddr = sizeof(*pAddr);
 #else
-            *pcbAddr = RT_OFFSETOF(struct sockaddr_un, sun_path) + (uint8_t)cbFull;
+            *pcbAddr = RT_UOFFSETOF(struct sockaddr_un, sun_path) + (uint8_t)cbFull;
 #endif
 #ifdef HAVE_SUN_LEN_MEMBER

trunk/src/VBox/Runtime/r3/solaris/coredumper-solaris.cpp

@@ -983 +983 @@
      * layout in the future. See @bugref{8479}.
      */
-    size_t const offZoneId = RT_OFFSETOF(psinfo_t, pr_zoneid);
+    size_t const offZoneId = RT_UOFFSETOF(psinfo_t, pr_zoneid);
     if (pSolProc->cbProcInfo < offZoneId)
     {
@@ -1035 +1035 @@
     PRTSOLCOREPROCESS pSolProc = &pSolCore->SolProc;
 
-    size_t offLwp         = RT_OFFSETOF(psinfo_t, pr_lwp);
+    size_t offLwp         = RT_UOFFSETOF(psinfo_t, pr_lwp);
     /* last member we care about in lwpsinfo_t is pr_bindpset which is also present on ancient Solaris version we use for
        building the additions. Should be safe enough as we don't need/access members upto or beyond that point anyway. */
-    size_t offLastOnProc  = RT_OFFSETOF(lwpsinfo_t, pr_bindpset);
+    size_t offLastOnProc  = RT_UOFFSETOF(lwpsinfo_t, pr_bindpset);
     if (pSolProc->cbProcInfo >= offLwp + offLastOnProc)
     {

trunk/src/VBox/Runtime/r3/solaris/krnlmod-solaris.cpp

@@ -91 +91 @@
     int rc = VINF_SUCCESS;
     size_t cchName = strlen(&pModInfo->mi_name[0]) + 1;
-    PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(RT_OFFSETOF(RTKRNLMODINFOINT, achName[cchName]));
+    PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTKRNLMODINFOINT, achName[cchName]));
     if (RT_LIKELY(pThis))
     {

trunk/src/VBox/Runtime/r3/win/RTSystemShutdown-win.cpp

@@ -76 +76 @@
                                        FALSE /*DisableAllPrivileges*/,
                                        &u.TokenPriv,
-                                       RT_OFFSETOF(TOKEN_PRIVILEGES, Privileges[1]),
+                                       RT_UOFFSETOF(TOKEN_PRIVILEGES, Privileges[1]),
                                        NULL,
                                        NULL) )

trunk/src/VBox/Runtime/r3/win/direnum-win.cpp

@@ -161 +161 @@
         if (cbDirEntry < RT_UOFFSETOF(RTDIRENTRY, szName[2]))
         {
-            AssertMsgFailed(("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRY, szName[2])));
+            AssertMsgFailed(("Invalid *pcbDirEntry=%zu (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRY, szName[2])));
             return VERR_INVALID_PARAMETER;
         }
@@ -203 +203 @@
     const char  *pszName    = pDir->pszName;
     const size_t cchName    = pDir->cchName;
-    const size_t cbRequired = RT_OFFSETOF(RTDIRENTRY, szName[1]) + cchName;
+    const size_t cbRequired = RT_UOFFSETOF(RTDIRENTRY, szName[1]) + cchName;
     if (pcbDirEntry)
         *pcbDirEntry = cbRequired;
@@ -255 +255 @@
         if (cbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName[2]))
         {
-            AssertMsgFailed(("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])));
+            AssertMsgFailed(("Invalid *pcbDirEntry=%zu (min %zu)\n", *pcbDirEntry, RT_UOFFSETOF(RTDIRENTRYEX, szName[2])));
             return VERR_INVALID_PARAMETER;
         }
@@ -297 +297 @@
     const char  *pszName    = pDir->pszName;
     const size_t cchName    = pDir->cchName;
-    const size_t cbRequired = RT_OFFSETOF(RTDIRENTRYEX, szName[1]) + cchName;
+    const size_t cbRequired = RT_UOFFSETOF(RTDIRENTRYEX, szName[1]) + cchName;
     if (pcbDirEntry)
         *pcbDirEntry = cbRequired;

trunk/src/VBox/Runtime/r3/win/fileaio-win.cpp

@@ -122 +122 @@
 #define AIO_CONTEXT_WAKEUP_EVENT 1
 /** Converts a pointer to an OVERLAPPED structure to a internal request. */
-#define OVERLAPPED_2_RTFILEAIOREQINTERNAL(pOverlapped) ( (PRTFILEAIOREQINTERNAL)((uintptr_t)(pOverlapped) - RT_OFFSETOF(RTFILEAIOREQINTERNAL, Overlapped)) )
+#define OVERLAPPED_2_RTFILEAIOREQINTERNAL(pOverlapped) ( (PRTFILEAIOREQINTERNAL)((uintptr_t)(pOverlapped) - RT_UOFFSETOF(RTFILEAIOREQINTERNAL, Overlapped)) )
 
 RTR3DECL(int) RTFileAioGetLimits(PRTFILEAIOLIMITS pAioLimits)

trunk/src/VBox/Runtime/r3/win/krnlmod-win.cpp

@@ -95 +95 @@
     if (NT_SUCCESS(rcNt) || rcNt == STATUS_INFO_LENGTH_MISMATCH)
     {
-        ULONG cbKrnlMods = RT_OFFSETOF(RTL_PROCESS_MODULES, Modules[KrnlModsSize.NumberOfModules]);
+        ULONG cbKrnlMods = RT_UOFFSETOF_DYN(RTL_PROCESS_MODULES, Modules[KrnlModsSize.NumberOfModules]);
         PRTL_PROCESS_MODULES pKrnlMods = (PRTL_PROCESS_MODULES)RTMemAllocZ(cbKrnlMods);
         if (RT_LIKELY(pKrnlMods))
@@ -127 +127 @@
     RT_NOREF2(pModInfo, phKrnlModInfo);
     size_t cchFilePath = strlen((const char *)&pModInfo->FullPathName[0]) + 1;
-    PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(RT_OFFSETOF(RTKRNLMODINFOINT, achFilePath[cchFilePath]));
+    PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(RT_UOFFSETOF_DYN(RTKRNLMODINFOINT, achFilePath[cchFilePath]));
     if (RT_LIKELY(pThis))
     {

trunk/src/VBox/Runtime/r3/win/localipc-win.cpp

@@ -401 +401 @@
          * Allocate and initialize the instance data.
          */
-        size_t cbThis = RT_OFFSETOF(RTLOCALIPCSERVERINT, wszName[cwcFullName + 1]);
+        size_t cbThis = RT_UOFFSETOF_DYN(RTLOCALIPCSERVERINT, wszName[cwcFullName + 1]);
         PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)RTMemAllocVar(cbThis);
         AssertReturn(pThis, VERR_NO_MEMORY);

trunk/src/VBox/Runtime/r3/win/process-win.cpp

@@ -831 +831 @@
             uOld = uNew;
             SetLastError(NO_ERROR);
-            DWORD cbActual = RT_OFFSETOF(TOKEN_PRIVILEGES, Privileges[1]);
+            DWORD cbActual = RT_UOFFSETOF(TOKEN_PRIVILEGES, Privileges[1]);
             AdjustTokenPrivileges(hToken, FALSE /*fDisableAllPrivileges*/, &uNew.TokPriv, cbActual, &uOld.TokPriv, &cbActual);
             if (GetLastError() != NO_ERROR)
@@ -1124 +1124 @@
     } AceBuf;
     RT_ZERO(AceBuf);
-    uint32_t const cbAllowedAce = RT_OFFSETOF(ACCESS_ALLOWED_ACE, SidStart) + cbSid;
+    uint32_t const cbAllowedAce = RT_UOFFSETOF(ACCESS_ALLOWED_ACE, SidStart) + cbSid;
     AssertReturn(cbAllowedAce <= sizeof(AceBuf), false);
 
@@ -1848 +1848 @@
                     SIZE_T cbCopied = 0;
                     if (!ReadProcessMemory(hDstProcess,
-                                           (char *)BasicInfo.PebBaseAddress + RT_OFFSETOF(PEB_COMMON, ProcessParameters),
+                                           (char *)BasicInfo.PebBaseAddress + RT_UOFFSETOF(PEB_COMMON, ProcessParameters),
                                            ppvDstProcParamCache, sizeof(*ppvDstProcParamCache), &cbCopied))
                     {
@@ -2006 +2006 @@
                 PVOID pvDstProcParamCache = NULL;
                 rtProcWinDupStdHandleIntoChild(pStartupInfo->hStdInput, pProcInfo->hProcess,
-                                               RT_OFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardInput), &pvDstProcParamCache);
+                                               RT_UOFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardInput), &pvDstProcParamCache);
                 rtProcWinDupStdHandleIntoChild(pStartupInfo->hStdOutput, pProcInfo->hProcess,
-                                               RT_OFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardOutput), &pvDstProcParamCache);
+                                               RT_UOFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardOutput), &pvDstProcParamCache);
                 rtProcWinDupStdHandleIntoChild(pStartupInfo->hStdError,  pProcInfo->hProcess,
-                                               RT_OFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardError), &pvDstProcParamCache);
+                                               RT_UOFFSETOF(RTL_USER_PROCESS_PARAMETERS, StandardError), &pvDstProcParamCache);
 
                 if (ResumeThread(pProcInfo->hThread) != ~(DWORD)0)

trunk/src/VBox/Runtime/testcase/tstRTAvl.cpp

@@ -74 +74 @@
 {
     uint32_t cbBitmap = (MaxKey + sizeof(uint32_t) * sizeof(uint8_t) - 1) / sizeof(uint8_t);
-    PTRACKER pTracker = (PTRACKER)RTMemAllocZ(RT_OFFSETOF(TRACKER, abBitmap[cbBitmap]));
+    PTRACKER pTracker = (PTRACKER)RTMemAllocZ(RT_UOFFSETOF_DYN(TRACKER, abBitmap[cbBitmap]));
     if (pTracker)
     {

trunk/src/VBox/Runtime/testcase/tstRTTraceLog.cpp

@@ -111 +111 @@
 static int tstRTTraceLogBufAlloc(size_t cbBuf, PTSTRTTRACELOGBUF *ppBuf)
 {
-    PTSTRTTRACELOGBUF pBuf = (PTSTRTTRACELOGBUF)RTMemAllocZ(RT_OFFSETOF(TSTRTTRACELOGBUF, abBuf[cbBuf]));
+    PTSTRTTRACELOGBUF pBuf = (PTSTRTTRACELOGBUF)RTMemAllocZ(RT_UOFFSETOF_DYN(TSTRTTRACELOGBUF, abBuf[cbBuf]));
     if (RT_LIKELY(pBuf))
     {

trunk/src/VBox/Runtime/tools/RTLdrCheckImports.cpp

@@ -422 +422 @@
     if (RT_SUCCESS(rc))
     {
-        RTCHECKIMPORTSTATE *pState = (RTCHECKIMPORTSTATE *)RTMemAllocZ(RT_UOFFSETOF(RTCHECKIMPORTSTATE, aImports[cImports + 1]));
+        RTCHECKIMPORTSTATE *pState = (RTCHECKIMPORTSTATE *)RTMemAllocZ(RT_UOFFSETOF_DYN(RTCHECKIMPORTSTATE, aImports[cImports + 1]));
         if (pState)
         {

trunk/src/VBox/Runtime/tools/RTNtDbgHelp.cpp

@@ -182 +182 @@
 
     size_t cbFullName = strlen(pszFile) + 1;
-    PRTNTDBGHELPMOD pMod = (PRTNTDBGHELPMOD)RTMemAlloc(RT_OFFSETOF(RTNTDBGHELPMOD, szFullName[cbFullName + 1]));
+    PRTNTDBGHELPMOD pMod = (PRTNTDBGHELPMOD)RTMemAlloc(RT_UOFFSETOF_DYN(RTNTDBGHELPMOD, szFullName[cbFullName + 1]));
     memcpy(pMod->szFullName, pszFile, cbFullName);
     pMod->pszName  = RTPathFilename(pMod->szFullName);

trunk/src/VBox/Runtime/tools/RTSignTool.cpp

@@ -778 +778 @@
                              * Sector align the signature portion.
                              */
-                            uint32_t const  cbWinCert = RT_OFFSETOF(WIN_CERTIFICATE, bCertificate);
+                            uint32_t const  cbWinCert = RT_UOFFSETOF(WIN_CERTIFICATE, bCertificate);
                             uint64_t        offCur    = 0;
                             rc = RTFileGetSize(hFile, &offCur);