VirtualBox

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


Ignore:
Timestamp:
Oct 22, 2011 12:28:46 AM (13 years ago)
Author:
vboxsync
Message:

IPRT: -Wunused-parameter.

Location:
trunk/src/VBox/Runtime
Files:
60 edited

Legend:

Unmodified
Added
Removed

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

    r38553 r39083  
    129129static DECLCALLBACK(void) rtDbgModTermCallback(RTTERMREASON enmReason, int32_t iStatus, void *pvUser)
    130130{
     131    NOREF(iStatus); NOREF(pvUser);
    131132    if (enmReason == RTTERMREASON_UNLOAD)
    132133    {
    … …  
    258259static DECLCALLBACK(int) rtDbgModInitOnce(void *pvUser1, void *pvUser2)
    259260{
     261    NOREF(pvUser1); NOREF(pvUser2);
     262
    260263    /*
    261264     * Create the semaphore and string cache.
    … …  
    362365
    363366
    364 RTDECL(int)         RTDbgModCreateDeferred(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, RTUINTPTR cb, uint32_t fFlags)
    365 {
     367RTDECL(int) RTDbgModCreateDeferred(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName,
     368                                   RTUINTPTR cb, uint32_t fFlags)
     369{
     370    NOREF(phDbgMod); NOREF(pszFilename); NOREF(pszName); NOREF(cb); NOREF(fFlags);
    366371    return VERR_NOT_IMPLEMENTED;
    367372}
    … …  
    501506
    502507
    503 RTDECL(int) RTDbgModCreateFromMap(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, RTUINTPTR uSubtrahend, uint32_t fFlags)
     508RTDECL(int) RTDbgModCreateFromMap(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName,
     509                                  RTUINTPTR uSubtrahend, uint32_t fFlags)
    504510{
    505511    /*
    … …  
    512518    AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
    513519    AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER);
     520    AssertReturn(uSubtrahend == 0, VERR_NOT_IMPLEMENTED); /** @todo implement uSubtrahend. */
    514521
    515522    int rc = rtDbgModLazyInit();

  • trunk/src/VBox/Runtime/common/dbg/dbgmodcontainer.cpp

    r28800 r39083  
    400400    pSymbol->cb                 = cb;
    401401    pSymbol->fFlags             = fFlags;
    402     pSymbol->NameCore.pszString = RTStrCacheEnter(g_hDbgModStrCache, pszSymbol);
     402    pSymbol->NameCore.pszString = RTStrCacheEnterN(g_hDbgModStrCache, pszSymbol, cchSymbol);
    403403    int rc;
    404404    if (pSymbol->NameCore.pszString)
    … …  
    604604    pSym->NameCore.pszString = NULL;
    605605    RTMemFree(pSym);
     606    NOREF(pvUser);
    606607    return 0;
    607608}
    … …  
    638639static DECLCALLBACK(int) rtDbgModContainer_TryOpen(PRTDBGMODINT pMod)
    639640{
     641    NOREF(pMod);
    640642    return VERR_INTERNAL_ERROR_5;
    641643}

  • trunk/src/VBox/Runtime/common/dbg/dbgmoddwarf.cpp

    r39070 r39083  
    827827    Log(("Segment %.*s: LinkAddress=%#llx RVA=%#llx cb=%#llx\n",
    828828         pSeg->cchName, pSeg->pchName, (uint64_t)pSeg->LinkAddress, (uint64_t)pSeg->RVA, pSeg->cb));
     829    NOREF(hLdrMod);
    829830    RTLDRADDR cb = RT_MAX(pSeg->cb, pSeg->cbMapped);
    830831#if 1
    … …  
    922923static int rtDbgModDwarfStringToUtf8(PRTDBGMODDWARF pThis, char **ppsz)
    923924{
     925    /** @todo DWARF & UTF-8. */
     926    NOREF(pThis);
    924927    RTStrPurgeEncoding(*ppsz);
    925928    return VINF_SUCCESS;
    … …  
    17311734                        ? pLnState->papszFileNames[pLnState->Regs.iFile]
    17321735                        : "<bad file name index>";
     1736    NOREF(offOpCode);
     1737
    17331738    RTDBGSEGIDX iSeg;
    17341739    RTUINTPTR   offSeg;
    … …  
    24372442{
    24382443    AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDR), VERR_INTERNAL_ERROR_3);
     2444    NOREF(pDie);
    24392445
    24402446    uint64_t uAddr;
    … …  
    24652471{
    24662472    AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(bool), VERR_INTERNAL_ERROR_3);
     2473    NOREF(pDie);
    24672474
    24682475    bool *pfMember = (bool *)pbMember;
    … …  
    24962503    AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDRRANGE), VERR_INTERNAL_ERROR_3);
    24972504    AssertReturn(pDesc->uAttr == DW_AT_low_pc || pDesc->uAttr == DW_AT_high_pc, VERR_INTERNAL_ERROR_3);
     2505    NOREF(pDie);
    24982506
    24992507    uint64_t uAddr;
    … …  
    25452553    AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFADDRRANGE), VERR_INTERNAL_ERROR_3);
    25462554    AssertReturn(pDesc->uAttr == DW_AT_low_pc || pDesc->uAttr == DW_AT_high_pc, VERR_INTERNAL_ERROR_3);
     2555    NOREF(pDie);
    25472556
    25482557    /* Decode it. */
    … …  
    26582667{
    26592668    AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(RTDWARFREF), VERR_INTERNAL_ERROR_3);
     2669    NOREF(pDie);
    26602670
    26612671    uint64_t off;
    … …  
    26992709{
    27002710    AssertReturn(ATTR_GET_SIZE(pDesc) == sizeof(const char *), VERR_INTERNAL_ERROR_3);
     2711    NOREF(pDie);
    27012712
    27022713    switch (uForm)
    … …  
    27222733                                                   uint32_t uForm, PRTDWARFCURSOR pCursor)
    27232734{
     2735    NOREF(pDie);
    27242736    uint64_t u64Val;
    27252737    switch (uForm)
    … …  
    28882900                                      PCRTDWARFABBREV pAbbrev, PRTDWARFDIE pParent)
    28892901{
     2902    NOREF(pThis);
    28902903    Assert(pDieDesc->cbDie >= sizeof(RTDWARFDIE));
    28912904    PRTDWARFDIE pDie = (PRTDWARFDIE)RTMemAllocZ(pDieDesc->cbDie);
    … …  
    32823295{
    32833296    PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
     3297    Assert(!pszFile[cchFile]); NOREF(cchFile);
    32843298    return RTDbgModLineAdd(pThis->hCnt, pszFile, uLineNo, iSeg, off, piOrdinal);
    32853299}
    … …  
    33273341{
    33283342    PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
     3343    Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
    33293344    return RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, iSeg, off, cb, fFlags, piOrdinal);
    33303345}
    … …  
    33523367{
    33533368    PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pMod->pvDbgPriv;
     3369    Assert(!pszName[cchName]); NOREF(cchName);
    33543370    return RTDbgModSegmentAdd(pThis->hCnt, uRva, cb, pszName, fFlags, piSeg);
    33553371}
    … …  
    33973413                                                   const char *pszExtFile, void *pvUser)
    33983414{
     3415    NOREF(hLdrMod); NOREF(iDbgInfo); NOREF(iMajorVer); NOREF(iMinorVer); NOREF(LinkAddress);
     3416
    33993417    /*
    34003418     * Skip stuff we can't handle.

  • trunk/src/VBox/Runtime/common/dbg/dbgmodldr.cpp

    r38581 r39083  
    6464static DECLCALLBACK(int) rtDbgModLdr_UnmapPart(PRTDBGMODINT pMod, size_t cb, void const **ppvMap)
    6565{
     66    NOREF(pMod); NOREF(cb);
    6667    RTMemFree((void *)*ppvMap);
    6768    *ppvMap = NULL;

  • trunk/src/VBox/Runtime/common/dbg/dbgmodnm.cpp

    r38515 r39083  
    8686{
    8787    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
     88    Assert(!pszFile[cchFile]); NOREF(cchFile);
    8889    return RTDbgModLineAdd(pThis->hCnt, pszFile, uLineNo, iSeg, off, piOrdinal);
    8990}
    … …  
    100101
    101102/** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByName} */
    102 static DECLCALLBACK(int) rtDbgModNm_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol, PRTDBGSYMBOL pSymInfo)
    103 {
    104     PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
     103static DECLCALLBACK(int) rtDbgModNm_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
     104                                                 PRTDBGSYMBOL pSymInfo)
     105{
     106    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
     107    Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
    105108    return RTDbgModSymbolByName(pThis->hCnt, pszSymbol, pSymInfo);
    106109}
    … …  
    129132{
    130133    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
     134    Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
    131135    return RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, iSeg, off, cb, fFlags, piOrdinal);
    132136}
    … …  
    150154
    151155/** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentAdd} */
    152 static DECLCALLBACK(int) rtDbgModNm_SegmentAdd(PRTDBGMODINT pMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName, size_t cchName,
    153                                                uint32_t fFlags, PRTDBGSEGIDX piSeg)
    154 {
    155     PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
     156static DECLCALLBACK(int) rtDbgModNm_SegmentAdd(PRTDBGMODINT pMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName,
     157                                               size_t cchName, uint32_t fFlags, PRTDBGSEGIDX piSeg)
     158{
     159    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
     160    Assert(!pszName[cchName]); NOREF(cchName);
    156161    return RTDbgModSegmentAdd(pThis->hCnt, uRva, cb, pszName, fFlags, piSeg);
    157162}

  • trunk/src/VBox/Runtime/common/dvm/dvmbsdlabel.cpp

    r37423 r39083  
    328328DECLCALLBACK(int) rtDvmFmtBsdLblInitialize(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt)
    329329{
     330    NOREF(pDisk); NOREF(phVolMgrFmt);
    330331    return VERR_NOT_IMPLEMENTED;
    331332}
    … …  
    449450DECLCALLBACK(int) rtDvmFmtBsdLblVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName)
    450451{
     452    NOREF(hVolFmt); NOREF(ppszVolName);
     453    return VERR_NOT_SUPPORTED;
     454}
     455
     456DECLCALLBACK(RTDVMVOLTYPE) rtDvmFmtBsdLblVolumeGetType(RTDVMVOLUMEFMT hVolFmt)
     457{
    451458    NOREF(hVolFmt);
    452     return VERR_NOT_SUPPORTED;
    453 }
    454 
    455 DECLCALLBACK(RTDVMVOLTYPE) rtDvmFmtBsdLblVolumeGetType(RTDVMVOLUMEFMT hVolFmt)
    456 {
    457459    return RTDVMVOLTYPE_UNKNOWN;
    458460}

  • trunk/src/VBox/Runtime/common/dvm/dvmgpt.cpp

    r37024 r39083  
    325325static DECLCALLBACK(int) rtDvmFmtGptInitialize(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt)
    326326{
     327    NOREF(pDisk); NOREF(phVolMgrFmt);
    327328    return VERR_NOT_IMPLEMENTED;
    328329}

  • trunk/src/VBox/Runtime/common/dvm/dvmmbr.cpp

    r37024 r39083  
    323323static DECLCALLBACK(int) rtDvmFmtMbrVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName)
    324324{
    325     NOREF(hVolFmt);
     325    NOREF(hVolFmt); NOREF(ppszVolName);
    326326    return VERR_NOT_SUPPORTED;
    327327}

  • trunk/src/VBox/Runtime/common/ldr/ldrELFRelocatable.cpp.h

    r39032 r39083  
    264264                                          const void *pvRelocs, Elf_Size cbRelocs)
    265265{
     266#if ELF_MODE != 32
     267    NOREF(pu8SecBaseR);
     268#endif
     269
    266270    /*
    267271     * Iterate the relocations.
    … …  
    423427static DECLCALLBACK(int) RTLDRELF_NAME(Done)(PRTLDRMODINTERNAL pMod)
    424428{
    425     //PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
     429    NOREF(pMod); /*PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;*/
    426430    /** @todo  Have to think more about this .... */
    427431    return -1;
    … …  
    434438{
    435439    PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
     440    NOREF(pvBits);
    436441
    437442    /*
    … …  
    550555
    551556/** @copydoc RTLDROPS::Relocate */
    552 static DECLCALLBACK(int) RTLDRELF_NAME(Relocate)(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR NewBaseAddress, RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
     557static DECLCALLBACK(int) RTLDRELF_NAME(Relocate)(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR NewBaseAddress,
     558                                                 RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
    553559{
    554560    PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
     561    NOREF(OldBaseAddress);
    555562
    556563    /*
    … …  
    692699    NOREF(pvBits);
    693700
    694     return VERR_NOT_IMPLEMENTED; NOREF(pModElf);
     701    return VERR_NOT_IMPLEMENTED; NOREF(pModElf); NOREF(pfnCallback); NOREF(pvUser);
    695702}
    696703
    … …  
    701708    PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
    702709
    703     return VERR_NOT_IMPLEMENTED; NOREF(pModElf);
     710    return VERR_NOT_IMPLEMENTED; NOREF(pModElf); NOREF(pfnCallback); NOREF(pvUser);
    704711}
    705712
    … …  
    711718    PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
    712719
    713     return VERR_NOT_IMPLEMENTED; NOREF(pModElf);
     720    return VERR_NOT_IMPLEMENTED; NOREF(pModElf); NOREF(LinkAddress); NOREF(piSeg); NOREF(poffSeg);
    714721}
    715722
    … …  
    720727    PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
    721728
    722     return VERR_NOT_IMPLEMENTED; NOREF(pModElf);
     729    return VERR_NOT_IMPLEMENTED; NOREF(pModElf); NOREF(LinkAddress); NOREF(pRva);
    723730}
    724731
    … …  
    730737    PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
    731738
    732     return VERR_NOT_IMPLEMENTED; NOREF(pModElf);
     739    return VERR_NOT_IMPLEMENTED; NOREF(pModElf); NOREF(iSeg); NOREF(offSeg); NOREF(pRva);
    733740}
    734741
    … …  
    740747    PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
    741748
    742     return VERR_NOT_IMPLEMENTED; NOREF(pModElf);
     749    return VERR_NOT_IMPLEMENTED; NOREF(pModElf); NOREF(Rva); NOREF(piSeg); NOREF(poffSeg);
    743750}
    744751
    … …  
    783790 * @param   cbRawImage  The size of the raw image.
    784791 */
    785 static int RTLDRELF_NAME(ValidateElfHeader)(const Elf_Ehdr *pEhdr, const char *pszLogName, uint64_t cbRawImage, PRTLDRARCH penmArch)
     792static int RTLDRELF_NAME(ValidateElfHeader)(const Elf_Ehdr *pEhdr, const char *pszLogName, uint64_t cbRawImage,
     793                                            PRTLDRARCH penmArch)
    786794{
    787795    Log3(("RTLdrELF:     e_ident: %.*Rhxs\n"
    … …  
    808816       )
    809817    {
    810         Log(("RTLdrELF: %s: Invalid ELF magic (%.*Rhxs)\n", pszLogName, sizeof(pEhdr->e_ident), pEhdr->e_ident));
     818        Log(("RTLdrELF: %s: Invalid ELF magic (%.*Rhxs)\n", pszLogName, sizeof(pEhdr->e_ident), pEhdr->e_ident)); NOREF(pszLogName);
    811819        return VERR_BAD_EXE_FORMAT;
    812820    }
    … …  
    982990    {
    983991        Log(("RTLdrELF: %s: Shdr #%d: sh_link (%d) is beyond the end of the section table (%d)!\n",
    984              pszLogName, iShdr, pShdr->sh_link, pModElf->Ehdr.e_shnum));
     992             pszLogName, iShdr, pShdr->sh_link, pModElf->Ehdr.e_shnum)); NOREF(pszLogName);
    985993        return VERR_BAD_EXE_FORMAT;
    986994    }
    … …  
    10591067    const char *pszLogName = pReader->pfnLogName(pReader);
    10601068    RTFOFF      cbRawImage = pReader->pfnSize(pReader);
     1069    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
    10611070
    10621071    /*

  • trunk/src/VBox/Runtime/common/ldr/ldrFile.cpp

    r37596 r39083  
    176176    }
    177177
     178    NOREF(pvBits);
    178179    return VINF_SUCCESS;
    179180}

  • trunk/src/VBox/Runtime/common/ldr/ldrNative.cpp

    r38581 r39083  
    4444
    4545/** @copydoc RTLDROPS::pfnEnumSymbols */
    46 static DECLCALLBACK(int) rtldrNativeEnumSymbols(PRTLDRMODINTERNAL pMod, unsigned fFlags, const void *pvBits, RTUINTPTR BaseAddress,
    47                                                 PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
    48 {
     46static DECLCALLBACK(int) rtldrNativeEnumSymbols(PRTLDRMODINTERNAL pMod, unsigned fFlags, const void *pvBits,
     47                                                RTUINTPTR BaseAddress, PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
     48{
     49    NOREF(pMod); NOREF(fFlags); NOREF(pvBits); NOREF(BaseAddress); NOREF(pfnCallback); NOREF(pvUser);
    4950    return VERR_NOT_SUPPORTED;
    5051}
    … …  
    5455static DECLCALLBACK(int) rtldrNativeDone(PRTLDRMODINTERNAL pMod)
    5556{
     57    NOREF(pMod);
    5658    return VINF_SUCCESS;
    5759}

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

    r38581 r39083  
    672672{
    673673    PRTLDRMODPE pModPe = (PRTLDRMODPE)pMod;
     674    NOREF(fFlags); /* ignored ... */
    674675
    675676    /*
    … …  
    772773                                             PFNRTLDRENUMDBG pfnCallback, void *pvUser)
    773774{
     775    NOREF(pMod); NOREF(pvBits); NOREF(pfnCallback); NOREF(pvUser);
    774776    return VINF_NOT_SUPPORTED;
    775777}
    … …  
    779781static DECLCALLBACK(int) rtldrPE_EnumSegments(PRTLDRMODINTERNAL pMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser)
    780782{
     783    NOREF(pMod); NOREF(pfnCallback); NOREF(pvUser);
    781784    return VINF_NOT_SUPPORTED;
    782785}
    … …  
    787790                                                        uint32_t *piSeg, PRTLDRADDR poffSeg)
    788791{
     792    NOREF(pMod); NOREF(LinkAddress); NOREF(piSeg); NOREF(poffSeg);
    789793    return VERR_NOT_IMPLEMENTED;
    790794}
    … …  
    794798static DECLCALLBACK(int) rtldrPE_LinkAddressToRva(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva)
    795799{
     800    NOREF(pMod); NOREF(LinkAddress); NOREF(pRva);
    796801    return VERR_NOT_IMPLEMENTED;
    797802}
    … …  
    802807                                                PRTLDRADDR pRva)
    803808{
     809    NOREF(pMod); NOREF(iSeg); NOREF(offSeg); NOREF(pRva);
    804810    return VERR_NOT_IMPLEMENTED;
    805811}
    … …  
    810816                                                uint32_t *piSeg, PRTLDRADDR poffSeg)
    811817{
     818    NOREF(pMod); NOREF(Rva); NOREF(piSeg); NOREF(poffSeg);
    812819    return VERR_NOT_IMPLEMENTED;
    813820}
    … …  
    15571564int rtldrPEOpen(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, RTFOFF offNtHdrs, PRTLDRMOD phLdrMod)
    15581565{
     1566    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
     1567
    15591568    /*
    15601569     * Read and validate the file header.

  • trunk/src/VBox/Runtime/common/ldr/ldrkStuff.cpp

    r38581 r39083  
    232232static int      rtkldrRdr_Create(  PPKRDR ppRdr, const char *pszFilename)
    233233{
     234    NOREF(ppRdr); NOREF(pszFilename);
    234235    AssertReleaseFailed();
    235236    return -1;
    … …  
    300301static KIPTR rtkldrRdr_NativeFH(PKRDR pRdr)
    301302{
     303    NOREF(pRdr);
    302304    AssertFailed();
    303305    return -1;
    … …  
    308310static KSIZE rtkldrRdr_PageSize(PKRDR pRdr)
    309311{
     312    NOREF(pRdr);
    310313    return PAGE_SIZE;
    311314}
    … …  
    316319{
    317320    //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
     321    NOREF(pRdr); NOREF(ppvBase); NOREF(cSegments); NOREF(paSegments); NOREF(fFixed);
    318322    AssertFailed();
    319323    return -1;
    … …  
    325329{
    326330    //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
     331    NOREF(pRdr); NOREF(pvBase); NOREF(cSegments); NOREF(paSegments);
    327332    AssertFailed();
    328333    return -1;
    … …  
    334339{
    335340    //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
     341    NOREF(pRdr); NOREF(pvBase); NOREF(cSegments); NOREF(paSegments); NOREF(fUnprotectOrProtect);
    336342    AssertFailed();
    337343    return -1;
    … …  
    343349{
    344350    //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
     351    NOREF(pRdr); NOREF(pvBase); NOREF(cSegments); NOREF(paSegments);
    345352    AssertFailed();
    346353    return -1;
    … …  
    350357static void     rtkldrRdr_Done(    PKRDR pRdr)
    351358{
     359    NOREF(pRdr);
    352360    //PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
    353361}
    … …  
    409417{
    410418    PRTLDRMODKLDRARGS pArgs = (PRTLDRMODKLDRARGS)pvUser;
     419    NOREF(pMod); NOREF(pszVersion); NOREF(fKind);
    411420
    412421    /* If not zero terminated we'll have to use a temporary buffer. */
    … …  
    468477{
    469478    PRTLDRMODKLDRARGS pArgs = (PRTLDRMODKLDRARGS)pvUser;
     479    NOREF(pMod); NOREF(pszVersion); NOREF(pfKind);
    470480
    471481    /* If not zero terminated we'll have to use a temporary buffer. */
    … …  
    587597{
    588598    PRTLDRMODKLDRARGS pArgs = (PRTLDRMODKLDRARGS)pvUser;
     599    NOREF(pMod);
    589600
    590601    RTLDRDBGINFOTYPE enmMyType;

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

    r39070 r39083  
    308308            return rc;
    309309    }
     310#else
     311    NOREF(pLogger);
    310312#endif
    311313    return VINF_SUCCESS;
    … …  
    322324    if (pLogger->pInt->hSpinMtx != NIL_RTSEMSPINMUTEX)
    323325        RTSemSpinMutexRelease(pLogger->pInt->hSpinMtx);
     326#else
     327    NOREF(pLogger);
    324328#endif
    325329    return;

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

    r29271 r39083  
    102102static DECLCALLBACK(size_t) rtLogComOutput(void *pv, const char *pachChars, size_t cbChars)
    103103{
     104    NOREF(pv);
    104105    if (cbChars)
    105106        RTLogWriteCom(pachChars, cbChars);

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

    r33540 r39083  
    5757#endif
    5858    va_end(args);
     59    NOREF(pvCallerRet);
    5960}
    6061RT_EXPORT_SYMBOL(RTLogLogger);

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

    r33496 r39083  
    9494    AssertMsgFailed(("Invalid logger format type '%%%c%.10s'!\n", ch, *ppszFormat)); NOREF(ch);
    9595
     96    NOREF(pvArg); NOREF(pfnOutput); NOREF(pvArgOutput); NOREF(pArgs); NOREF(cchWidth);
     97    NOREF(cchPrecision); NOREF(fFlags); NOREF(chArgSize);
    9698    return 0;
    9799}

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

    r37409 r39083  
    256256        pszBuf += cchPos; \
    257257        cchBuf -= cchPos; \
     258        NOREF(pszFunction); \
    258259    } while (0)
    259260

  • trunk/src/VBox/Runtime/common/misc/lockvalidator.cpp

    r39071 r39083  
    13921392                                             bool fAutodidacticism, PCRTLOCKVALSRCPOS pSrcPos)
    13931393{
     1394    NOREF(pSrcPos);
    13941395    if (!RTCritSectIsInitialized(&g_LockValClassTeachCS))
    13951396        rtLockValidatorLazyInit();

  • trunk/src/VBox/Runtime/common/misc/s3.cpp

    r38734 r39083  
    281281}
    282282
    283 static size_t rtS3WriteNothingCallback(void *pvBuf, size_t cSize, size_t cBSize, void *pvUser)
    284 {
    285     return cSize*cBSize;
     283static size_t rtS3WriteNothingCallback(void *pvBuf, size_t cbItem, size_t cItems, void *pvUser)
     284{
     285    NOREF(pvBuf); NOREF(pvUser);
     286    return cbItem * cItems;
    286287}
    287288

  • trunk/src/VBox/Runtime/common/misc/thread.cpp

    r38636 r39083  
    13261326    if (RT_SUCCESS(rc)) /* hide any warnings */
    13271327        return VINF_SUCCESS;
     1328    NOREF(pvUser);
    13281329    return rc;
    13291330}

  • trunk/src/VBox/Runtime/common/path/rtPathVolumeSpecLen.cpp

    r28800 r39083  
    6363    /// @todo (dmik) well, it's better to consider there's no volume name
    6464    //  at all on *nix systems
     65    NOREF(pszPath);
    6566    return 0;
    6667//    return pszPath && pszPath[0] == '/';

  • trunk/src/VBox/Runtime/common/string/RTStrConvertHexBytes.cpp

    r28800 r39083  
    4242
    4343    AssertFailed();
    44     return VERR_NOT_IMPLEMENTED;
     44    return VERR_NOT_IMPLEMENTED; NOREF(pv); NOREF(cb); NOREF(fFlags);
    4545}
    4646

  • trunk/src/VBox/Runtime/common/string/strformatnum.cpp

    r35585 r39083  
    156156                                signed int cchWidth, signed int cchPrecision, uint32_t fFlags)
    157157{
     158    NOREF(cchWidth); NOREF(cchPrecision);
    158159    if (uiBase != 16)
    159160        fFlags |= RTSTR_F_SPECIAL;
    … …  
    174175                                 signed int cchPrecision, uint32_t fFlags)
    175176{
     177    NOREF(cchWidth); NOREF(cchPrecision); NOREF(fFlags);
    176178    char szTmp[160];
    177179

  • trunk/src/VBox/Runtime/common/string/strformattype.cpp

    r36555 r39083  
    425425    char        ch;
    426426    void       *pvValue = va_arg(*pArgs, void *);
     427    NOREF(chArgSize);
    427428
    428429    /*

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

    r37596 r39083  
    15021502RTDECL(int) RTVfsUtilDummyPollOne(uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr, uint32_t *pfRetEvents)
    15031503{
     1504    NOREF(fEvents);
    15041505    int rc;
    15051506    if (fIntr)

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

    r39032 r39083  
    548548                                              uint32_t *pfRetEvents)
    549549{
     550    NOREF(pvThis);
    550551    int rc;
    551552    if (fEvents != RTPOLL_EVT_ERROR)

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

    r39032 r39083  
    253253                                              uint32_t *pfRetEvents)
    254254{
     255    NOREF(pvThis);
    255256    int rc;
    256257    if (fEvents != RTPOLL_EVT_ERROR)
    … …  
    347348    return RTFileSetOwner(pThis->hFile, uid, gid);
    348349#else
     350    NOREF(pvThis); NOREF(uid); NOREF(gid);
    349351    return VERR_NOT_IMPLEMENTED;
    350352#endif

  • trunk/src/VBox/Runtime/common/zip/gzipvfs.cpp

    r39050 r39083  
    358358    int              rc;
    359359
     360    AssertReturn(off == -1, VERR_INVALID_PARAMETER);
    360361    if (!pThis->fDecompress)
    361362        return VERR_ACCESS_DENIED;
    … …  
    398399    //int              rc;
    399400
     401    AssertReturn(off == -1, VERR_INVALID_PARAMETER);
    400402    NOREF(fBlocking);
    401403    if (pThis->fDecompress)
    … …  
    403405
    404406    /** @todo implement compression. */
     407    NOREF(pSgBuf); NOREF(pcbWritten);
    405408    return VERR_NOT_IMPLEMENTED;
    406409}

  • trunk/src/VBox/Runtime/common/zip/tar.cpp

    r39070 r39083  
    995995            break;
    996996        }
    997         default: AssertFailedReturn(VERR_INVALID_PARAMETER); break;
    998     }
     997        default: AssertFailedReturn(VERR_INVALID_PARAMETER);
     998    }
     999
     1000    if (poffActual)
     1001        *poffActual = pFileInt->offCurrent;
    9991002
    10001003    return VINF_SUCCESS;

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

    r34928 r39083  
    10591059    PRTZIPTARIOSTREAM pThis = (PRTZIPTARIOSTREAM)pvThis;
    10601060    int               rc;
     1061    AssertReturn(off == -1, VERR_INVALID_PARAMETER);
    10611062
    10621063    if (pSgBuf->cSegs == 1)

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

    r39050 r39083  
    316316static DECLCALLBACK(int) rtZipStoreCompDestroy(PRTZIPCOMP pZip)
    317317{
     318    NOREF(pZip);
    318319    return VINF_SUCCESS;
    319320}
    … …  
    328329static DECLCALLBACK(int) rtZipStoreCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel)
    329330{
     331    NOREF(enmLevel);
    330332    pZip->pfnCompress = rtZipStoreCompress;
    331333    pZip->pfnFinish   = rtZipStoreCompFinish;
    … …  
    394396static DECLCALLBACK(int) rtZipStoreDecompDestroy(PRTZIPDECOMP pZip)
    395397{
     398    NOREF(pZip);
    396399    return VINF_SUCCESS;
    397400}
    … …  
    10421045static DECLCALLBACK(int) rtZipLZFCompDestroy(PRTZIPCOMP pZip)
    10431046{
     1047    NOREF(pZip);
    10441048    return VINF_SUCCESS;
    10451049}
    … …  
    10541058static DECLCALLBACK(int) rtZipLZFCompInit(PRTZIPCOMP pZip, RTZIPLEVEL enmLevel)
    10551059{
     1060    NOREF(enmLevel);
    10561061    pZip->pfnCompress = rtZipLZFCompress;
    10571062    pZip->pfnFinish   = rtZipLZFCompFinish;
    … …  
    13041309static DECLCALLBACK(int) rtZipLZFDecompDestroy(PRTZIPDECOMP pZip)
    13051310{
     1311    NOREF(pZip);
    13061312    return VINF_SUCCESS;
    13071313}
    … …  
    14931499static DECLCALLBACK(int) rtZipStubDecompress(PRTZIPDECOMP pZip, void *pvBuf, size_t cbBuf, size_t *pcbWritten)
    14941500{
     1501    NOREF(pZip); NOREF(pvBuf); NOREF(cbBuf); NOREF(pcbWritten);
    14951502    return VERR_NOT_SUPPORTED;
    14961503}
    … …  
    15021509static DECLCALLBACK(int) rtZipStubDecompDestroy(PRTZIPDECOMP pZip)
    15031510{
     1511    NOREF(pZip);
    15041512    return VINF_SUCCESS;
    15051513}

  • trunk/src/VBox/Runtime/generic/RTProcIsRunningByName-generic.cpp

    r28800 r39083  
    3838     * No other info here, so return false;
    3939     */
     40    NOREF(pszName);
    4041    return false;
    4142}

  • trunk/src/VBox/Runtime/generic/semrw-generic.cpp

    r36190 r39083  
    903903     * Ask the lock validator.
    904904     */
     905    NOREF(fWannaHear);
    905906    return RTLockValidatorRecSharedIsOwner(&pThis->ValidatorRead, NIL_RTTHREAD);
    906907#else

  • trunk/src/VBox/Runtime/generic/timer-generic.cpp

    r33540 r39083  
    231231    if (!rtTimerIsValid(pTimer))
    232232        return VERR_INVALID_HANDLE;
     233    NOREF(u64NanoInterval);
    233234    return VERR_NOT_SUPPORTED;
    234235}
    … …  
    236237
    237238
    238 static DECLCALLBACK(int) rtTimerThread(RTTHREAD Thread, void *pvUser)
     239static DECLCALLBACK(int) rtTimerThread(RTTHREAD hThreadSelf, void *pvUser)
    239240{
    240241    PRTTIMER pTimer = (PRTTIMER)pvUser;
     242    NOREF(hThreadSelf);
    241243
    242244    /*
    … …  
    323325RTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
    324326{
     327    NOREF(u32Request); NOREF(pu32Granted);
    325328    return VERR_NOT_SUPPORTED;
    326329}
    … …  
    330333RTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
    331334{
     335    NOREF(u32Granted);
    332336    return VERR_NOT_SUPPORTED;
    333337}

  • trunk/src/VBox/Runtime/generic/timerlr-generic.cpp

    r34507 r39083  
    237237
    238238
    239 static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThread, void *pvUser)
     239static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThreadSelf, void *pvUser)
    240240{
    241241    PRTTIMERLRINT pThis = (PRTTIMERLRINT)pvUser;
     242    NOREF(hThreadSelf);
    242243
    243244    /*

  • trunk/src/VBox/Runtime/r3/alloc-ef.cpp

    r33540 r39083  
    9696    vfprintf(stderr, pszFormat, args);
    9797    va_end(args);
     98#else
     99    NOREF(pszOp); NOREF(pszFormat);
    98100#endif
    99101}
    … …  
    200202            (unsigned long)(pBlock->cbAligned - pBlock->cbUnaligned),
    201203            pBlock->pvCaller);
     204    NOREF(pvUser);
    202205    return 0;
    203206}
    … …  
    377380RTDECL(void) rtR3MemFree(const char *pszOp, RTMEMTYPE enmType, void *pv, void *pvCaller, RT_SRC_POS_DECL)
    378381{
     382    NOREF(enmType); RT_SRC_POS_NOREF();
     383
    379384    /*
    380385     * Simple case.

  • trunk/src/VBox/Runtime/r3/alloc.cpp

    r36597 r39083  
    111111    void *pv = RTMemTrackerHdrAlloc(malloc(cb + sizeof(RTMEMTRACKERHDR)), cb, pszTag, RTMEMTRACKERMETHOD_ALLOC);
    112112# else
    113     void *pv = malloc(cb);
     113    void *pv = malloc(cb); NOREF(pszTag);
    114114# endif
    115115    AssertMsg(pv, ("malloc(%#zx) failed!!!\n", cb));
    … …  
    135135    void *pv = RTMemTrackerHdrAlloc(calloc(1, cb + sizeof(RTMEMTRACKERHDR)), cb, pszTag, RTMEMTRACKERMETHOD_ALLOCZ);
    136136#else
    137     void *pv = calloc(1, cb);
     137    void *pv = calloc(1, cb); NOREF(pszTag);
    138138#endif
    139139    AssertMsg(pv, ("calloc(1,%#zx) failed!!!\n", cb));
    … …  
    192192    void *pv         = RTMemTrackerHdrReallocDone(pvNew, cbNew, pvOld, pszTag);
    193193# else
    194     void *pv = realloc(pvOld, cbNew);
     194    void *pv = realloc(pvOld, cbNew); NOREF(pszTag);
    195195# endif
    196196    AssertMsg(pv || !cbNew, ("realloc(%p, %#zx) failed!!!\n", pvOld, cbNew));

  • trunk/src/VBox/Runtime/r3/darwin/mp-darwin.cpp

    r36232 r39083  
    161161{
    162162    /** @todo figure out how to get the current cpu speed on darwin. Have to check what powermanagement does. */
     163    NOREF(idCpu);
    163164    return 0;
    164165}

  • trunk/src/VBox/Runtime/r3/darwin/sched-darwin.cpp

    r36555 r39083  
    237237    if (offBest)
    238238    {
    239         const PROCPRIORITY *pProcessPriority = &g_aDefaultPriority;
    240239        for (unsigned i = 0; i < RT_ELEMENTS(g_aPriorities); i++)
    241240        {

  • trunk/src/VBox/Runtime/r3/fs.cpp

    r34015 r39083  
    103103RTFMODE rtFsModeFromUnix(RTFMODE fMode, const char *pszName, size_t cbName)
    104104{
     105    NOREF(cbName);
     106
    105107    fMode &= RTFS_UNIX_MASK;
    106108

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

    r36167 r39083  
    196196int rtDirNativeOpen(PRTDIR pDir, char *pszPathBuf)
    197197{
     198    NOREF(pszPathBuf); /* only used on windows */
     199
    198200    /*
    199201     * Convert to a native path and try opendir.

  • trunk/src/VBox/Runtime/r3/posix/fileaio-posix.cpp

    r37596 r39083  
    579579    if (hAioCtx == NIL_RTFILEAIOCTX)
    580580        return RTFILEAIO_UNLIMITED_REQS;
    581     else
    582         return pCtxInt->cMaxRequests;
     581    return pCtxInt->cMaxRequests;
    583582}
    584583
    585584RTDECL(int) RTFileAioCtxAssociateWithFile(RTFILEAIOCTX hAioCtx, RTFILE hFile)
    586585{
     586    NOREF(hAioCtx); NOREF(hFile);
    587587    return VINF_SUCCESS;
    588588}

  • trunk/src/VBox/Runtime/r3/posix/fileio-posix.cpp

    r39030 r39083  
    686686RTR3DECL(int) RTFileIoCtl(RTFILE hFile, unsigned long ulRequest, void *pvData, unsigned cbData, int *piRet)
    687687{
     688    NOREF(cbData);
    688689    int rc = ioctl(RTFileToNative(hFile), ulRequest, pvData);
    689690    if (piRet)

  • trunk/src/VBox/Runtime/r3/posix/fileio2-posix.cpp

    r37596 r39083  
    135135                             PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
    136136{
     137    NOREF(pChangeTime); NOREF(pBirthTime);
     138
    137139    /*
    138140     * We can only set AccessTime and ModificationTime, so if neither

  • trunk/src/VBox/Runtime/r3/posix/process-creation-posix.cpp

    r39032 r39083  
    8585 * @returns IPRT status code
    8686 */
    87 static int rtCheckCredentials(const char *pszUser, const char *pszPasswd, gid_t *gid, uid_t *uid)
     87static int rtCheckCredentials(const char *pszUser, const char *pszPasswd, gid_t *pGid, uid_t *pUid)
    8888{
    8989#if defined(RT_OS_LINUX)
    … …  
    111111        return VERR_PERMISSION_DENIED;
    112112
    113     *gid = pw->pw_gid;
    114     *uid = pw->pw_uid;
     113    *pGid = pw->pw_gid;
     114    *pUid = pw->pw_uid;
    115115    return VINF_SUCCESS;
    116116
    … …  
    135135        return VERR_PERMISSION_DENIED;
    136136
    137     *gid = ppw->pw_gid;
    138     *uid = ppw->pw_uid;
     137    *pGid = ppw->pw_gid;
     138    *pUid = ppw->pw_uid;
    139139    return VINF_SUCCESS;
    140140
    141141#else
     142    NOREF(pszUser); NOREF(pszPasswd); NOREF(pGid); NOREF(pUid);
    142143    return VERR_PERMISSION_DENIED;
    143144#endif

  • trunk/src/VBox/Runtime/r3/posix/rtmempage-exec-mmap-heap-posix.cpp

    r33279 r39083  
    175175
    176176/**
    177  * Deletes the heap an all the memory it tracks.
     177 * Deletes the heap and all the memory it tracks.
    178178 *
    179179 * @returns IPRT status code.
    … …  
    182182int RTHeapPageDelete(PRTHEAPPAGE pHeap)
    183183{
     184    NOREF(pHeap);
    184185    return VERR_NOT_IMPLEMENTED;
    185186}
    … …  
    312313{
    313314    int rc;
     315    NOREF(pszTag);
    314316
    315317    /*
    … …  
    564566static DECLCALLBACK(int) rtMemPagePosixInitOnce(void *pvUser1, void *pvUser2)
    565567{
     568    NOREF(pvUser1); NOREF(pvUser2);
    566569    int rc = RTHeapPageInit(&g_MemPagePosixHeap, false /*fExec*/);
    567570    if (RT_SUCCESS(rc))

  • trunk/src/VBox/Runtime/r3/posix/semeventmulti-posix.cpp

    r33540 r39083  
    429429#endif
    430430        RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT_MULTI, true);
     431        /** @todo interruptible wait is not implementable... */ NOREF(fFlags);
    431432        rc = pthread_cond_wait(&pThis->Cond, &pThis->Mutex);
    432433        RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT_MULTI);

  • trunk/src/VBox/Runtime/r3/tcp.cpp

    r39070 r39083  
    963963static int rtTcpClose(RTSOCKET Sock, const char *pszMsg, bool fTryGracefulShutdown)
    964964{
    965     int rc;
     965    NOREF(pszMsg); /** @todo drop this parameter? */
    966966
    967967    /* ignore nil handles. */
    … …  
    972972     * Try to gracefully shut it down.
    973973     */
     974    int rc;
    974975    if (fTryGracefulShutdown)
    975976    {

  • trunk/src/VBox/Runtime/r3/udp.cpp

    r37197 r39083  
    670670static int rtUdpClose(RTSOCKET Sock, const char *pszMsg)
    671671{
     672    NOREF(pszMsg); /** @todo drop this parameter? */
     673
    672674    /* ignore nil handles. */
    673675    if (Sock == NIL_RTSOCKET)

  • trunk/src/VBox/Runtime/r3/xml.cpp

    r37493 r39083  
    16601660{
    16611661    /// @todo to be written
     1662    NOREF(aCtxt);
    16621663
    16631664    return -1;
    … …  
    17851786{
    17861787    /// @todo to be written
     1788    NOREF(aCtxt);
    17871789
    17881790    return -1;

  • trunk/src/VBox/Runtime/testcase/tstLdrDisasmTest.cpp

    r28800 r39083  
    8282DECLCALLBACK(int) DisasmTest1ReadCode(RTUINTPTR SrcAddr, uint8_t *pbDst, uint32_t cb, void *pvUser)
    8383{
     84    NOREF(pvUser);
    8485    while (cb > 0)
    8586    {

  • trunk/src/VBox/Runtime/testcase/tstLdrObj.cpp

    r38325 r39083  
    8282extern "C" DECLEXPORT(char *) SomeExportFunction2(void *pvBuf)
    8383{
     84    NOREF(pvBuf);
    8485    return (char *)memcpy(achBss, szStr1, sizeof(szStr1));
    8586}
    … …  
    8889extern "C" DECLEXPORT(char *) SomeExportFunction3(void *pvBuf)
    8990{
     91    NOREF(pvBuf);
    9092    return (char *)memcpy(achBss, szStr2, strlen(szStr2));
    9193}

  • trunk/src/VBox/Runtime/testcase/tstLdrObjR0.cpp

    r28800 r39083  
    7171extern "C" DECLEXPORT(uint32_t) SomeExportFunction1(void *pvBuf)
    7272{
     73    NOREF(pvBuf);
    7374    return achBss[0] + achBss[16384];
    7475}
    … …  
    7778extern "C" DECLEXPORT(char *) SomeExportFunction2(void *pvBuf)
    7879{
     80    NOREF(pvBuf);
    7981    return (char *)memcpy(achBss, szStr1, sizeof(szStr1));
    8082}
    … …  
    8385extern "C" DECLEXPORT(char *) SomeExportFunction3(void *pvBuf)
    8486{
     87    NOREF(pvBuf);
    8588    return (char *)memcpy(achBss, szStr2, strlen(szStr2));
    8689}

  • trunk/src/VBox/Runtime/testcase/tstR0ThreadPreemption.cpp

    r29250 r39083  
    5050                                                   uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr)
    5151{
     52    NOREF(pSession);
    5253    if (u64Arg)
    5354        return VERR_INVALID_PARAMETER;

  • trunk/src/VBox/Runtime/testcase/tstRTAssertCompile.cpp

    r37809 r39083  
    3535{
    3636    /* Only positive tests here. */
     37    NOREF(argc); NOREF(argv);
    3738
    3839    AssertCompile(true);

  • trunk/src/VBox/Runtime/testcase/tstRTBitOperations.cpp

    r28800 r39083  
    131131    RTTestBanner(hTest);
    132132
    133     int rcRet = 0;
    134133    int i;
    135134    int j;

  • trunk/src/VBox/Runtime/testcase/tstRTR0MemUserKernel.cpp

    r28800 r39083  
    5050                                                  uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr)
    5151{
     52    NOREF(pSession);
    5253    if (!VALID_PTR(pReqHdr))
    5354        return VERR_INVALID_PARAMETER;

  • trunk/src/VBox/Runtime/testcase/tstRTR0SemMutex.cpp

    r28800 r39083  
    5757                                             uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr)
    5858{
     59    NOREF(pSession);
    5960    if (!VALID_PTR(pReqHdr))
    6061        return VERR_INVALID_PARAMETER;

  • trunk/src/VBox/Runtime/testcase/tstRTR0Timer.cpp

    r33540 r39083  
    120120    RTCPUID             idCpu    = RTMpCpuId();
    121121    uint32_t            iCpu     = RTMpCpuIdToSetIndex(idCpu);
     122    NOREF(pTimer);
    122123
    123124    RTR0TESTR0_CHECK_MSG(iCpu < RTCPUSET_MAX_CPUS, ("iCpu=%d idCpu=%u\n", iCpu, idCpu));
    … …  
    148149    PTSTRTR0TIMERS1 pState = (PTSTRTR0TIMERS1)pvUser;
    149150    uint32_t        iShot  = ASMAtomicIncU32(&pState->cShots);
     151    NOREF(pTimer);
    150152
    151153    if (iShot <= RT_ELEMENTS(pState->aShotNsTSes))
    … …  
    278280    PTSTRTR0TIMERS1 pState = (PTSTRTR0TIMERS1)pvUser;
    279281    uint32_t        iShot  = ASMAtomicIncU32(&pState->cShots);
     282    NOREF(pTimer);
    280283
    281284    if (iShot <= RT_ELEMENTS(pState->aShotNsTSes))
    … …  
    288291
    289292
     293#ifdef SOME_UNUSED_FUNCTION
    290294/**
    291295 * Checks that the interval between two timer shots are within the specified
    … …  
    306310    return 0;
    307311}
     312#endif
    308313
    309314
    … …  
    357362{
    358363    RTR0TESTR0_SRV_REQ_PROLOG_RET(pReqHdr);
     364    NOREF(pSession);
    359365
    360366    /*
Note: See TracChangeset for help on using the changeset viewer.

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