VirtualBox

Changeset 26160 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Feb 2, 2010 6:23:29 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
57174
Message:

PDM: s/pDevReg/pReg/g

Location:
trunk/src/VBox
Files:
32 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

    r26001 r26160  
    15511551
    15521552/**
    1553  * Construct a device instance for a VM.
    1554  *
    1555  * @returns VBox status.
    1556  * @param   pDevIns     The device instance data.
    1557  *                      If the registration structure is needed,
    1558  *                      pDevIns->pDevReg points to it.
    1559  * @param   iInstance   Instance number. Use this to figure out which
    1560  *                      registers and such to use.
    1561  *                      The device number is also found in pDevIns->iInstance,
    1562  *                      but since it's likely to be freqently used PDM passes
    1563  *                      it as parameter.
    1564  * @param   pCfgHandle  Configuration node handle for the device.
    1565  *                      Use this to obtain the configuration
    1566  *                      of the device instance. It's also found in
    1567  *                      pDevIns->pCfgHandle, but like iInstance it's expected
    1568  *                      to be used a bit in this function.
     1553 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    15691554 */
    15701555static DECLCALLBACK(int) ichac97Construct (PPDMDEVINS pDevIns, int iInstance,

  • trunk/src/VBox/Devices/Audio/audiosniffer.c

    r26001 r26160  
    150150
    151151/**
    152  * Construct a device instance for a VM.
    153  *
    154  * @returns VBox status.
    155  * @param   pDevIns     The device instance data.
    156  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    157  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    158  *                      The device number is also found in pDevIns->iInstance, but since it's
    159  *                      likely to be freqently used PDM passes it as parameter.
    160  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    161  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    162  *                      iInstance it's expected to be used a bit in this function.
     152 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    163153 */
    164154static DECLCALLBACK(int) audioSnifferR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
    … …  
    207197    else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    208198    {
    209         Log(("%s/%d: warning: no driver attached to LUN #0.\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     199        Log(("%s/%d: warning: no driver attached to LUN #0.\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    210200        rc = VINF_SUCCESS;
    211201    }

  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r26157 r26160  
    19771977
    19781978/**
    1979  * Construct a host to PCI Bus device instance for a VM.
    1980  *
    1981  * @returns VBox status.
    1982  * @param   pDevIns     The device instance data.
    1983  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    1984  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    1985  *                      The device number is also found in pDevIns->iInstance, but since it's
    1986  *                      likely to be freqently used PDM passes it as parameter.
    1987  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    1988  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    1989  *                      iInstance it's expected to be used a bit in this function.
     1979 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    19901980 */
    19911981static DECLCALLBACK(int)   pciConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
    … …  
    23772367
    23782368/**
    2379  * Construct a PCI bridge device instance for a VM.
    2380  *
    2381  * @returns VBox status.
    2382  * @param   pDevIns     The device instance data.
    2383  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    2384  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    2385  *                      The device number is also found in pDevIns->iInstance, but since it's
    2386  *                      likely to be freqently used PDM passes it as parameter.
    2387  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    2388  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    2389  *                      iInstance it's expected to be used a bit in this function.
     2369 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    23902370 */
    23912371static DECLCALLBACK(int)   pcibridgeConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/EFI/DevEFI.cpp

    r26157 r26160  
    862862
    863863/**
    864  * Construct a device instance for a VM.
    865  *
    866  * @returns VBox status.
    867  * @param   pDevIns     The device instance data.
    868  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    869  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    870  *                      The device number is also found in pDevIns->iInstance, but since it's
    871  *                      likely to be freqently used PDM passes it as parameter.
    872  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    873  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    874  *                      iInstance it's expected to be used a bit in this function.
     864 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    875865 */
    876866static DECLCALLBACK(int)  efiConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r26157 r26160  
    57595759            else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    57605760            {
    5761                 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     5761                Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    57625762                rc = VINF_SUCCESS;
    57635763            }
    … …  
    58435843
    58445844/**
    5845  * Construct a VGA device instance for a VM.
    5846  *
    5847  * @returns VBox status.
    5848  * @param   pDevIns     The device instance data.
    5849  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    5850  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    5851  *                      The device number is also found in pDevIns->iInstance, but since it's
    5852  *                      likely to be freqently used PDM passes it as parameter.
    5853  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    5854  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    5855  *                      iInstance it's expected to be used a bit in this function.
     5845 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    58565846 */
    58575847static DECLCALLBACK(int)   vgaR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
    … …  
    59565946
    59575947    /* The LBF access handler - error handling is better here than in the map function.  */
    5958     rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, "vgaGCLFBAccessHandler", &pThis->RCPtrLFBHandler);
     5948    rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, "vgaGCLFBAccessHandler", &pThis->RCPtrLFBHandler);
    59595949    if (RT_FAILURE(rc))
    59605950    {
    5961         AssertReleaseMsgFailed(("PDMR3LdrGetSymbolRC(, %s, \"vgaGCLFBAccessHandler\",) -> %Rrc\n", pDevIns->pDevReg->szRCMod, rc));
     5951        AssertReleaseMsgFailed(("PDMR3LdrGetSymbolRC(, %s, \"vgaGCLFBAccessHandler\",) -> %Rrc\n", pDevIns->pReg->szRCMod, rc));
    59625952        return rc;
    59635953    }

  • trunk/src/VBox/Devices/Input/DevPS2.cpp

    r26157 r26160  
    14721472            else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    14731473            {
    1474                 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1474                Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    14751475                rc = VINF_SUCCESS;
    14761476            }
    … …  
    14931493            else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    14941494            {
    1495                 Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1495                Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    14961496                rc = VINF_SUCCESS;
    14971497            }
    … …  
    15811581
    15821582/**
    1583  * Construct a device instance for a VM.
    1584  *
    1585  * @returns VBox status.
    1586  * @param   pDevIns     The device instance data.
    1587  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    1588  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    1589  *                      The device number is also found in pDevIns->iInstance, but since it's
    1590  *                      likely to be freqently used PDM passes it as parameter.
    1591  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    1592  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    1593  *                      iInstance it's expected to be used a bit in this function.
     1583 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    15941584 */
    15951585static DECLCALLBACK(int) kbdConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/Network/DevE1000.cpp

    r26157 r26160  
    50235023
    50245024/**
    5025  * Construct a device instance for a VM.
    5026  *
    5027  * @returns VBox status.
    5028  * @param   pDevIns     The device instance data.
    5029  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    5030  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    5031  *                      The device number is also found in pDevIns->iInstance, but since it's
    5032  *                      likely to be freqently used PDM passes it as parameter.
    5033  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    5034  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    5035  *                      iInstance it's expected to be used a bit in this function.
    5036  * @thread  EMT
     5025 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    50375026 */
    50385027static DECLCALLBACK(int) e1kConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/Network/DevINIP.cpp

    r26001 r26160  
    443443
    444444/**
    445  * Construct an internal networking IP stack device instance.
    446  *
    447  * @returns VBox status.
    448  * @param   pDevIns     The device instance data.
    449  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    450  * @param   iInstance   Instance number. Use this to figure out which registers
    451  * and such to use.
    452  *                      he device number is also found in pDevIns->iInstance, but since it's
    453  *                      likely to be freqently used PDM passes it as parameter.
    454  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    455  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    456  *                      iInstance it's expected to be used a bit in this function.
     445 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    457446 */
    458447static DECLCALLBACK(int) devINIPConstruct(PPDMDEVINS pDevIns, int iInstance,

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r26157 r26160  
    49314931
    49324932/**
    4933  * Construct a device instance for a VM.
    4934  *
    4935  * @returns VBox status.
    4936  * @param   pDevIns     The device instance data.
    4937  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    4938  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    4939  *                      The device number is also found in pDevIns->iInstance, but since it's
    4940  *                      likely to be freqently used PDM passes it as parameter.
    4941  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    4942  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    4943  *                      iInstance it's expected to be used a bit in this function.
     4933 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    49444934 */
    49454935static DECLCALLBACK(int) pcnetConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/Network/DevVirtioNet.cpp

    r26157 r26160  
    16191619
    16201620/**
    1621  * Construct a device instance for a VM.
    1622  *
    1623  * @returns VBox status.
    1624  * @param   pDevIns     The device instance data.
    1625  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    1626  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    1627  *                      The device number is also found in pDevIns->iInstance, but since it's
    1628  *                      likely to be freqently used PDM passes it as parameter.
    1629  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    1630  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    1631  *                      iInstance it's expected to be used a bit in this function.
    1632  * @thread  EMT
     1621 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    16331622 */
    16341623static DECLCALLBACK(int) vnetConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/PC/DevACPI.cpp

    r26157 r26160  
    22262226
    22272227/**
    2228  * Construct a device instance for a VM.
    2229  *
    2230  * @returns VBox status.
    2231  * @param   pDevIns     The device instance data.
    2232  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    2233  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    2234  *                      The device number is also found in pDevIns->iInstance, but since it's
    2235  *                      likely to be freqently used PDM passes it as parameter.
    2236  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    2237  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    2238  *                      iInstance it's expected to be used a bit in this function.
     2228 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    22392229 */
    22402230static DECLCALLBACK(int) acpiConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
    … …  
    24942484   {
    24952485       Log(("acpi: %s/%d: warning: no driver attached to LUN #0!\n",
    2496             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2486            pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    24972487       rc = VINF_SUCCESS;
    24982488   }

  • trunk/src/VBox/Devices/PC/DevDMA.cpp

    r23987 r26160  
    875875
    876876/**
    877  * Construct a device instance for a VM.
    878  *
    879  * @returns VBox status.
    880  * @param   pDevIns     The device instance data.
    881  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    882  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    883  *                      The device number is also found in pDevIns->iInstance, but since it's
    884  *                      likely to be freqently used PDM passes it as parameter.
    885  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    886  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    887  *                      iInstance it's expected to be used a bit in this function.
     877 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    888878 */
    889879static DECLCALLBACK(int) dmaConstruct(PPDMDEVINS pDevIns,

  • trunk/src/VBox/Devices/PC/DevPcArch.c

    r26157 r26160  
    215215
    216216/**
    217  * Construct a device instance for a VM.
    218  *
    219  * @returns VBox status.
    220  * @param   pDevIns     The device instance data.
    221  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    222  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    223  *                      The device number is also found in pDevIns->iInstance, but since it's
    224  *                      likely to be freqently used PDM passes it as parameter.
    225  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    226  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    227  *                      iInstance it's expected to be used a bit in this function.
     217 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    228218 */
    229219static DECLCALLBACK(int)  pcarchConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/PC/DevPcBios.cpp

    r26001 r26160  
    868868
    869869/**
    870  * Construct a device instance for a VM.
    871  *
    872  * @returns VBox status.
    873  * @param   pDevIns     The device instance data.
    874  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    875  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    876  *                      The device number is also found in pDevIns->iInstance, but since it's
    877  *                      likely to be freqently used PDM passes it as parameter.
    878  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    879  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    880  *                      iInstance it's expected to be used a bit in this function.
     870 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    881871 */
    882872static DECLCALLBACK(int)  pcbiosConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/PC/DevPit-i8254.cpp

    r26157 r26160  
    967967
    968968/**
    969  * Construct a device instance for a VM.
    970  *
    971  * @returns VBox status.
    972  * @param   pDevIns     The device instance data.
    973  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    974  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    975  *                      The device number is also found in pDevIns->iInstance, but since it's
    976  *                      likely to be freqently used PDM passes it as parameter.
    977  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    978  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    979  *                      iInstance it's expected to be used a bit in this function.
     969 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    980970 */
    981971static DECLCALLBACK(int)  pitConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/PC/DevRTC.cpp

    r26158 r26160  
    848848
    849849/**
    850  * Construct a device instance for a VM.
    851  *
    852  * @returns VBox status.
    853  * @param   pDevIns     The device instance data.
    854  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    855  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    856  *                      The device number is also found in pDevIns->iInstance, but since it's
    857  *                      likely to be freqently used PDM passes it as parameter.
    858  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    859  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    860  *                      iInstance it's expected to be used a bit in this function.
     850 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    861851 */
    862852static DECLCALLBACK(int)  rtcConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/Parallel/DevParallel.cpp

    r26157 r26160  
    683683
    684684/**
    685  * Construct a device instance for a VM.
    686  *
    687  * @returns VBox status.
    688  * @param   pDevIns     The device instance data.
    689  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    690  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    691  *                      The device number is also found in pDevIns->iInstance, but since it's
    692  *                      likely to be freqently used PDM passes it as parameter.
    693  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    694  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    695  *                      iInstance it's expected to be used a bit in this function.
     685 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    696686 */
    697687static DECLCALLBACK(int) parallelConstruct(PPDMDEVINS pDevIns,

  • trunk/src/VBox/Devices/Serial/DevSerial.cpp

    r26157 r26160  
    766766
    767767/**
    768  * Construct a device instance for a VM.
    769  *
    770  * @returns VBox status.
    771  * @param   pDevIns     The device instance data.
    772  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    773  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    774  *                      The device number is also found in pDevIns->iInstance, but since it's
    775  *                      likely to be freqently used PDM passes it as parameter.
    776  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    777  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    778  *                      iInstance it's expected to be used a bit in this function.
     768 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    779769 */
    780770static DECLCALLBACK(int) serialConstruct(PPDMDEVINS pDevIns,

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r26157 r26160  
    64596459
    64606460/**
    6461  * Construct a device instance for a VM.
    6462  *
    6463  * @returns VBox status.
    6464  * @param   pDevIns     The device instance data.
    6465  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    6466  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    6467  *                      The device number is also found in pDevIns->iInstance, but since it's
    6468  *                      likely to be freqently used PDM passes it as parameter.
    6469  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    6470  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    6471  *                      iInstance it's expected to be used a bit in this function.
     6461 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    64726462 */
    64736463static DECLCALLBACK(int) ahciR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r26157 r26160  
    65046504
    65056505/**
    6506  * Construct a device instance for a VM.
    6507  *
    6508  * @returns VBox status.
    6509  * @param   pDevIns     The device instance data.
    6510  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    6511  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    6512  *                      The device number is also found in pDevIns->iInstance, but since it's
    6513  *                      likely to be freqently used PDM passes it as parameter.
    6514  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    6515  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    6516  *                      iInstance it's expected to be used a bit in this function.
     6506 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    65176507 */
    65186508static DECLCALLBACK(int)   ataR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/Storage/DevBusLogic.cpp

    r26157 r26160  
    25182518
    25192519/**
    2520  * Construct a device instance for a VM.
    2521  *
    2522  * @returns VBox status.
    2523  * @param   pDevIns     The device instance data.
    2524  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    2525  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    2526  *                      The device number is also found in pDevIns->iInstance, but since it's
    2527  *                      likely to be freqently used PDM passes it as parameter.
    2528  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    2529  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    2530  *                      iInstance it's expected to be used a bit in this function.
     2520 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    25312521 */
    25322522static DECLCALLBACK(int) buslogicConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)

  • trunk/src/VBox/Devices/Storage/fdc.c

    r26001 r26160  
    27392739
    27402740/**
    2741  * Construct a device instance for a VM.
    2742  *
    2743  * @returns VBox status.
    2744  * @param   pDevIns     The device instance data.
    2745  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    2746  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    2747  *                      The device number is also found in pDevIns->iInstance, but since it's
    2748  *                      likely to be freqently used PDM passes it as parameter.
    2749  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    2750  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    2751  *                      iInstance it's expected to be used a bit in this function.
     2741 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    27522742 */
    27532743static DECLCALLBACK(int) fdcConstruct (PPDMDEVINS pDevIns,

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r26158 r26160  
    25142514
    25152515/**
    2516  * Construct a device instance for a VM.
    2517  *
    2518  * @returns VBox status.
    2519  * @param   pDevIns     The device instance data.
    2520  *                      If the registration structure is needed, pDevIns->pDevReg points to it.
    2521  * @param   iInstance   Instance number. Use this to figure out which registers and such to use.
    2522  *                      The device number is also found in pDevIns->iInstance, but since it's
    2523  *                      likely to be freqently used PDM passes it as parameter.
    2524  * @param   pCfgHandle  Configuration node handle for the device. Use this to obtain the configuration
    2525  *                      of the device instance. It's also found in pDevIns->pCfgHandle, but like
    2526  *                      iInstance it's expected to be used a bit in this function.
     2516 * @interface_method_impl{PDMDEVREG,pfnConstruct}
    25272517 */
    25282518static DECLCALLBACK(int) vmmdevConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
    … …  
    26972687    else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    26982688    {
    2699         Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2689        Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    27002690        rc = VINF_SUCCESS;
    27012691    }

  • trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp

    r26080 r26160  
    107107    GEN_CHECK_SIZE(PDMDEVINS);
    108108    GEN_CHECK_OFF(PDMDEVINS, Internal);
    109     GEN_CHECK_OFF(PDMDEVINS, pDevReg);
     109    GEN_CHECK_OFF(PDMDEVINS, pReg);
    110110    GEN_CHECK_OFF(PDMDEVINS, pCfgHandle);
    111111    GEN_CHECK_OFF(PDMDEVINS, iInstance);

  • trunk/src/VBox/VMM/PDM.cpp

    r25825 r26160  
    459459    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
    460460    {
    461         if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC)
     461        if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
    462462        {
    463463            pDevIns->pDevHlpRC = pDevHlpRC;
    … …  
    468468            if (pDevIns->Internal.s.pPciDeviceR3)
    469469                pDevIns->Internal.s.pPciDeviceRC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciDeviceR3);
    470             if (pDevIns->pDevReg->pfnRelocate)
     470            if (pDevIns->pReg->pfnRelocate)
    471471            {
    472472                LogFlow(("PDMR3Relocate: Relocating device '%s'/%d\n",
    473                          pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    474                 pDevIns->pDevReg->pfnRelocate(pDevIns, offDelta);
     473                         pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     474                pDevIns->pReg->pfnRelocate(pDevIns, offDelta);
    475475            }
    476476        }
    … …  
    561561    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
    562562    {
    563         pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsR3, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
    564 
    565         if (pDevIns->pDevReg->pfnDestruct)
     563        pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsR3, pDevIns->pReg->szDeviceName, pDevIns->iInstance);
     564
     565        if (pDevIns->pReg->pfnDestruct)
    566566        {
    567567            LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
    568                      pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    569             pDevIns->pDevReg->pfnDestruct(pDevIns);
     568                     pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     569            pDevIns->pReg->pfnDestruct(pDevIns);
    570570        }
    571571
    … …  
    640640    {
    641641        SSMR3PutU32(pSSM, i);
    642         SSMR3PutStrZ(pSSM, pDevIns->pDevReg->szDeviceName);
     642        SSMR3PutStrZ(pSSM, pDevIns->pReg->szDeviceName);
    643643        SSMR3PutU32(pSSM, pDevIns->iInstance);
    644644    }
    … …  
    879879        PPDMDEVINS pDevIns;
    880880        for (pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
    881             if (   !strcmp(szDeviceName, pDevIns->pDevReg->szDeviceName)
     881            if (   !strcmp(szDeviceName, pDevIns->pReg->szDeviceName)
    882882                && pDevIns->iInstance == iInstance)
    883883            {
    884884                AssertLogRelMsgReturn(!(pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_FOUND),
    885                                       ("%s/#%u\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance),
     885                                      ("%s/#%u\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance),
    886886                                      VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
    887887                pDevIns->Internal.s.fIntFlags |= PDMDEVINSINT_FLAGS_FOUND;
    … …  
    902902        if (!(pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_FOUND))
    903903        {
    904             LogRel(("Device '%s'/%d not found in the saved state\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     904            LogRel(("Device '%s'/%d not found in the saved state\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    905905            if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
    906906                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device '%s'/%d not found in the saved state"),
    907                                         pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
     907                                        pDevIns->pReg->szDeviceName, pDevIns->iInstance);
    908908        }
    909909
    … …  
    973973{
    974974    Assert(pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_SUSPENDED);
    975     if (pDevIns->pDevReg->pfnPowerOn)
    976     {
    977         LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    978         int rc = VINF_SUCCESS; pDevIns->pDevReg->pfnPowerOn(pDevIns);
     975    if (pDevIns->pReg->pfnPowerOn)
     976    {
     977        LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     978        int rc = VINF_SUCCESS; pDevIns->pReg->pfnPowerOn(pDevIns);
    979979        if (RT_FAILURE(rc))
    980980        {
    981             LogRel(("PDMR3PowerOn: device '%s'/%d -> %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     981            LogRel(("PDMR3PowerOn: device '%s'/%d -> %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    982982            return rc;
    983983        }
    … …  
    10071007        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3;  pLun && RT_SUCCESS(rc);  pLun = pLun->pNext)
    10081008            for (PPDMDRVINS pDrvIns = pLun->pTop;  pDrvIns && RT_SUCCESS(rc);  pDrvIns = pDrvIns->Internal.s.pDown)
    1009                 rc = pdmR3PowerOnDrv(pDrvIns, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pLun->iLun);
     1009                rc = pdmR3PowerOnDrv(pDrvIns, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun);
    10101010        if (RT_SUCCESS(rc))
    10111011            rc = pdmR3PowerOnDev(pDevIns);
    … …  
    11301130    {
    11311131        pDevIns->Internal.s.fIntFlags |= PDMDEVINSINT_FLAGS_RESET;
    1132         if (pDevIns->pDevReg->pfnReset)
     1132        if (pDevIns->pReg->pfnReset)
    11331133        {
    11341134            if (!pDevIns->Internal.s.pfnAsyncNotify)
    11351135            {
    1136                 LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    1137                 pDevIns->pDevReg->pfnReset(pDevIns);
     1136                LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1137                pDevIns->pReg->pfnReset(pDevIns);
    11381138                if (pDevIns->Internal.s.pfnAsyncNotify)
    1139                     LogFlow(("PDMR3Reset: Async notification started - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1139                    LogFlow(("PDMR3Reset: Async notification started - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    11401140            }
    11411141            else if (pDevIns->Internal.s.pfnAsyncNotify(pDevIns))
    11421142            {
    1143                 LogFlow(("PDMR3Reset: Async notification completed - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1143                LogFlow(("PDMR3Reset: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    11441144                pDevIns->Internal.s.pfnAsyncNotify = NULL;
    11451145            }
    … …  
    12181218                for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
    12191219                    for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1220                         if (!pdmR3ResetDrv(pDrvIns, &cAsync, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
     1220                        if (!pdmR3ResetDrv(pDrvIns, &cAsync, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
    12211221                            break;
    12221222
    … …  
    13561356    {
    13571357        pDevIns->Internal.s.fIntFlags |= PDMDEVINSINT_FLAGS_SUSPENDED;
    1358         if (pDevIns->pDevReg->pfnSuspend)
     1358        if (pDevIns->pReg->pfnSuspend)
    13591359        {
    13601360            if (!pDevIns->Internal.s.pfnAsyncNotify)
    13611361            {
    1362                 LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    1363                 pDevIns->pDevReg->pfnSuspend(pDevIns);
     1362                LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1363                pDevIns->pReg->pfnSuspend(pDevIns);
    13641364                if (pDevIns->Internal.s.pfnAsyncNotify)
    1365                     LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1365                    LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    13661366            }
    13671367            else if (pDevIns->Internal.s.pfnAsyncNotify(pDevIns))
    13681368            {
    1369                 LogFlow(("PDMR3Suspend: Async notification completed - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1369                LogFlow(("PDMR3Suspend: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    13701370                pDevIns->Internal.s.pfnAsyncNotify = NULL;
    13711371            }
    … …  
    14171417            unsigned const cAsyncStart = cAsync;
    14181418
    1419             if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION)
     1419            if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION)
    14201420                pdmR3SuspendDev(pDevIns, &cAsync);
    14211421
    … …  
    14231423                for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
    14241424                    for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1425                         if (!pdmR3SuspendDrv(pDrvIns, &cAsync, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
     1425                        if (!pdmR3SuspendDrv(pDrvIns, &cAsync, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
    14261426                            break;
    14271427
    14281428            if (    cAsync == cAsyncStart
    1429                 && !(pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION))
     1429                && !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION))
    14301430                pdmR3SuspendDev(pDevIns, &cAsync);
    14311431        }
    … …  
    15311531{
    15321532    Assert(pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_SUSPENDED);
    1533     if (pDevIns->pDevReg->pfnResume)
    1534     {
    1535         LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    1536         int rc = VINF_SUCCESS; pDevIns->pDevReg->pfnResume(pDevIns);
     1533    if (pDevIns->pReg->pfnResume)
     1534    {
     1535        LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1536        int rc = VINF_SUCCESS; pDevIns->pReg->pfnResume(pDevIns);
    15371537        if (RT_FAILURE(rc))
    15381538        {
    1539             LogRel(("PDMR3Resume: device '%s'/%d -> %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1539            LogRel(("PDMR3Resume: device '%s'/%d -> %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    15401540            return rc;
    15411541        }
    … …  
    15651565        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3;  pLun && RT_SUCCESS(rc);  pLun    = pLun->pNext)
    15661566            for (PPDMDRVINS pDrvIns = pLun->pTop;  pDrvIns && RT_SUCCESS(rc);  pDrvIns = pDrvIns->Internal.s.pDown)
    1567                 rc = pdmR3ResumeDrv(pDrvIns, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pLun->iLun);
     1567                rc = pdmR3ResumeDrv(pDrvIns, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun);
    15681568        if (RT_SUCCESS(rc))
    15691569            rc = pdmR3ResumeDev(pDevIns);
    … …  
    16881688    {
    16891689        pDevIns->Internal.s.fIntFlags |= PDMDEVINSINT_FLAGS_SUSPENDED;
    1690         if (pDevIns->pDevReg->pfnSuspend)
     1690        if (pDevIns->pReg->pfnSuspend)
    16911691        {
    16921692            if (!pDevIns->Internal.s.pfnAsyncNotify)
    16931693            {
    1694                 LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    1695                 pDevIns->pDevReg->pfnPowerOff(pDevIns);
     1694                LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1695                pDevIns->pReg->pfnPowerOff(pDevIns);
    16961696                if (pDevIns->Internal.s.pfnAsyncNotify)
    1697                     LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1697                    LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    16981698            }
    16991699            else if (pDevIns->Internal.s.pfnAsyncNotify(pDevIns))
    17001700            {
    1701                 LogFlow(("PDMR3PowerOff: Async notification completed - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1701                LogFlow(("PDMR3PowerOff: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    17021702                pDevIns->Internal.s.pfnAsyncNotify = NULL;
    17031703            }
    … …  
    17421742            unsigned const cAsyncStart = cAsync;
    17431743
    1744             if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION)
     1744            if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION)
    17451745                pdmR3PowerOffDev(pDevIns, &cAsync);
    17461746
    … …  
    17481748                for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
    17491749                    for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1750                         if (!pdmR3PowerOffDrv(pDrvIns, &cAsync, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
     1750                        if (!pdmR3PowerOffDrv(pDrvIns, &cAsync, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
    17511751                            break;
    17521752
    17531753            if (    cAsync == cAsyncStart
    1754                 && !(pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION))
     1754                && !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION))
    17551755                pdmR3PowerOffDev(pDevIns, &cAsync);
    17561756        }
    … …  
    18201820    {
    18211821        if (    pDev->cchName == cchDevice
    1822             &&  !memcmp(pDev->pDevReg->szDeviceName, pszDevice, cchDevice))
     1822            &&  !memcmp(pDev->pReg->szDeviceName, pszDevice, cchDevice))
    18231823        {
    18241824            /*

  • trunk/src/VBox/VMM/PDMDevHlp.cpp

    r26159 r26160  
    6868{
    6969    PDMDEV_ASSERT_DEVINS(pDevIns);
    70     LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p p32_tszDesc=%p:{%s}\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
     70    LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p p32_tszDesc=%p:{%s}\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
    7171             Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc, pszDesc));
    7272    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    … …  
    8383    int rc = IOMR3IOPortRegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc);
    8484
    85     LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     85    LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    8686    return rc;
    8787}
    … …  
    9595    PDMDEV_ASSERT_DEVINS(pDevIns);
    9696    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    97     LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
     97    LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
    9898             Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
    9999
    … …  
    102102     */
    103103    int rc = VINF_SUCCESS;
    104     if (    pDevIns->pDevReg->szRCMod[0]
    105         &&  (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC))
     104    if (    pDevIns->pReg->szRCMod[0]
     105        &&  (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC))
    106106    {
    107107        RTRCPTR RCPtrIn = NIL_RTRCPTR;
    108108        if (pszIn)
    109109        {
    110             rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szRCMod, pszIn, &RCPtrIn);
    111             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pDevReg->szRCMod, pszIn));
     110            rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszIn, &RCPtrIn);
     111            AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pReg->szRCMod, pszIn));
    112112        }
    113113        RTRCPTR RCPtrOut = NIL_RTRCPTR;
    114114        if (pszOut && RT_SUCCESS(rc))
    115115        {
    116             rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szRCMod, pszOut, &RCPtrOut);
    117             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pDevReg->szRCMod, pszOut));
     116            rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszOut, &RCPtrOut);
     117            AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pReg->szRCMod, pszOut));
    118118        }
    119119        RTRCPTR RCPtrInStr = NIL_RTRCPTR;
    120120        if (pszInStr && RT_SUCCESS(rc))
    121121        {
    122             rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szRCMod, pszInStr, &RCPtrInStr);
    123             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pDevReg->szRCMod, pszInStr));
     122            rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszInStr, &RCPtrInStr);
     123            AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pReg->szRCMod, pszInStr));
    124124        }
    125125        RTRCPTR RCPtrOutStr = NIL_RTRCPTR;
    126126        if (pszOutStr && RT_SUCCESS(rc))
    127127        {
    128             rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szRCMod, pszOutStr, &RCPtrOutStr);
    129             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pDevReg->szRCMod, pszOutStr));
     128            rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszOutStr, &RCPtrOutStr);
     129            AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pReg->szRCMod, pszOutStr));
    130130        }
    131131
    … …  
    150150    }
    151151
    152     LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     152    LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    153153    return rc;
    154154}
    … …  
    162162    PDMDEV_ASSERT_DEVINS(pDevIns);
    163163    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    164     LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
     164    LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
    165165             Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
    166166
    … …  
    169169     */
    170170    int rc = VINF_SUCCESS;
    171     if (    pDevIns->pDevReg->szR0Mod[0]
    172         &&  (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0))
     171    if (    pDevIns->pReg->szR0Mod[0]
     172        &&  (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
    173173    {
    174174        R0PTRTYPE(PFNIOMIOPORTIN) pfnR0PtrIn = 0;
    175175        if (pszIn)
    176176        {
    177             rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszIn, &pfnR0PtrIn);
    178             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pDevReg->szR0Mod, pszIn));
     177            rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszIn, &pfnR0PtrIn);
     178            AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pReg->szR0Mod, pszIn));
    179179        }
    180180        R0PTRTYPE(PFNIOMIOPORTOUT) pfnR0PtrOut = 0;
    181181        if (pszOut && RT_SUCCESS(rc))
    182182        {
    183             rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszOut, &pfnR0PtrOut);
    184             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pDevReg->szR0Mod, pszOut));
     183            rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszOut, &pfnR0PtrOut);
     184            AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pReg->szR0Mod, pszOut));
    185185        }
    186186        R0PTRTYPE(PFNIOMIOPORTINSTRING) pfnR0PtrInStr = 0;
    187187        if (pszInStr && RT_SUCCESS(rc))
    188188        {
    189             rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszInStr, &pfnR0PtrInStr);
    190             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pDevReg->szR0Mod, pszInStr));
     189            rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszInStr, &pfnR0PtrInStr);
     190            AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pReg->szR0Mod, pszInStr));
    191191        }
    192192        R0PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnR0PtrOutStr = 0;
    193193        if (pszOutStr && RT_SUCCESS(rc))
    194194        {
    195             rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszOutStr, &pfnR0PtrOutStr);
    196             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pDevReg->szR0Mod, pszOutStr));
     195            rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszOutStr, &pfnR0PtrOutStr);
     196            AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pReg->szR0Mod, pszOutStr));
    197197        }
    198198
    … …  
    217217    }
    218218
    219     LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     219    LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    220220    return rc;
    221221}
    … …  
    227227    PDMDEV_ASSERT_DEVINS(pDevIns);
    228228    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    229     LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
     229    LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
    230230             Port, cPorts));
    231231
    232232    int rc = IOMR3IOPortDeregister(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts);
    233233
    234     LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     234    LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    235235    return rc;
    236236}
    … …  
    245245    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    246246    LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p pszDesc=%p:{%s}\n",
    247              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, pszDesc));
     247             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, pszDesc));
    248248
    249249/** @todo IOMR3MMIORegisterR3 mangles the description, move it here. */
    250250    int rc = IOMR3MMIORegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
    251251
    252     LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     252    LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    253253    return rc;
    254254}
    … …  
    263263    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    264264    LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
    265              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
     265             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
    266266
    267267/** @todo pszDesc is unused here, drop it.  */
    … …  
    272272     */
    273273    int rc = VINF_SUCCESS;
    274     if (    pDevIns->pDevReg->szRCMod[0]
    275         &&  (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC))
     274    if (    pDevIns->pReg->szRCMod[0]
     275        &&  (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC))
    276276    {
    277277        RTRCPTR RCPtrWrite = NIL_RTRCPTR;
    278278        if (pszWrite)
    279             rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szRCMod, pszWrite, &RCPtrWrite);
     279            rc = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszWrite, &RCPtrWrite);
    280280
    281281        RTRCPTR RCPtrRead = NIL_RTRCPTR;
    282282        int rc2 = VINF_SUCCESS;
    283283        if (pszRead)
    284             rc2 = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szRCMod, pszRead, &RCPtrRead);
     284            rc2 = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszRead, &RCPtrRead);
    285285
    286286        RTRCPTR RCPtrFill = NIL_RTRCPTR;
    287287        int rc3 = VINF_SUCCESS;
    288288        if (pszFill)
    289             rc3 = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szRCMod, pszFill, &RCPtrFill);
     289            rc3 = PDMR3LdrGetSymbolRCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szRCMod, pszFill, &RCPtrFill);
    290290
    291291        if (RT_SUCCESS(rc) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
    … …  
    293293        else
    294294        {
    295             AssertMsgRC(rc,  ("Failed to resolve %s.%s (pszWrite)\n", pDevIns->pDevReg->szRCMod, pszWrite));
    296             AssertMsgRC(rc2, ("Failed to resolve %s.%s (pszRead)\n",  pDevIns->pDevReg->szRCMod, pszRead));
    297             AssertMsgRC(rc3, ("Failed to resolve %s.%s (pszFill)\n",  pDevIns->pDevReg->szRCMod, pszFill));
     295            AssertMsgRC(rc,  ("Failed to resolve %s.%s (pszWrite)\n", pDevIns->pReg->szRCMod, pszWrite));
     296            AssertMsgRC(rc2, ("Failed to resolve %s.%s (pszRead)\n",  pDevIns->pReg->szRCMod, pszRead));
     297            AssertMsgRC(rc3, ("Failed to resolve %s.%s (pszFill)\n",  pDevIns->pReg->szRCMod, pszFill));
    298298            if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
    299299                rc = rc2;
    … …  
    308308    }
    309309
    310     LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     310    LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    311311    return rc;
    312312}
    … …  
    320320    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    321321    LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
    322              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
     322             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
    323323
    324324/** @todo pszDesc is unused here, remove it.  */
    … …  
    329329     */
    330330    int rc = VINF_SUCCESS;
    331     if (    pDevIns->pDevReg->szR0Mod[0]
    332         &&  (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0))
     331    if (    pDevIns->pReg->szR0Mod[0]
     332        &&  (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
    333333    {
    334334        R0PTRTYPE(PFNIOMMMIOWRITE) pfnR0PtrWrite = 0;
    335335        if (pszWrite)
    336             rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszWrite, &pfnR0PtrWrite);
     336            rc = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszWrite, &pfnR0PtrWrite);
    337337        R0PTRTYPE(PFNIOMMMIOREAD) pfnR0PtrRead = 0;
    338338        int rc2 = VINF_SUCCESS;
    339339        if (pszRead)
    340             rc2 = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszRead, &pfnR0PtrRead);
     340            rc2 = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszRead, &pfnR0PtrRead);
    341341        R0PTRTYPE(PFNIOMMMIOFILL) pfnR0PtrFill = 0;
    342342        int rc3 = VINF_SUCCESS;
    343343        if (pszFill)
    344             rc3 = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszFill, &pfnR0PtrFill);
     344            rc3 = PDMR3LdrGetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pReg->szR0Mod, pszFill, &pfnR0PtrFill);
    345345        if (RT_SUCCESS(rc) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
    346346            rc = IOMR3MMIORegisterR0(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, pfnR0PtrWrite, pfnR0PtrRead, pfnR0PtrFill);
    347347        else
    348348        {
    349             AssertMsgRC(rc,  ("Failed to resolve %s.%s (pszWrite)\n", pDevIns->pDevReg->szR0Mod, pszWrite));
    350             AssertMsgRC(rc2, ("Failed to resolve %s.%s (pszRead)\n",  pDevIns->pDevReg->szR0Mod, pszRead));
    351             AssertMsgRC(rc3, ("Failed to resolve %s.%s (pszFill)\n",  pDevIns->pDevReg->szR0Mod, pszFill));
     349            AssertMsgRC(rc,  ("Failed to resolve %s.%s (pszWrite)\n", pDevIns->pReg->szR0Mod, pszWrite));
     350            AssertMsgRC(rc2, ("Failed to resolve %s.%s (pszRead)\n",  pDevIns->pReg->szR0Mod, pszRead));
     351            AssertMsgRC(rc3, ("Failed to resolve %s.%s (pszFill)\n",  pDevIns->pReg->szR0Mod, pszFill));
    352352            if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
    353353                rc = rc2;
    … …  
    362362    }
    363363
    364     LogFlow(("pdmR3DevHlp_MMIORegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     364    LogFlow(("pdmR3DevHlp_MMIORegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    365365    return rc;
    366366}
    … …  
    373373    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    374374    LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x\n",
    375              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange));
     375             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange));
    376376
    377377    int rc = IOMR3MMIODeregister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange);
    378378
    379     LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     379    LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    380380    return rc;
    381381}
    … …  
    390390    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    391391    LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: iRegion=%#x cb=%#RGp fFlags=%RX32 ppv=%p pszDescp=%p:{%s}\n",
    392              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, cb, fFlags, ppv, pszDesc, pszDesc));
     392             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, cb, fFlags, ppv, pszDesc, pszDesc));
    393393
    394394/** @todo PGMR3PhysMMIO2Register mangles the description, move it here and
    … …  
    396396    int rc = PGMR3PhysMMIO2Register(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, cb, fFlags, ppv, pszDesc);
    397397
    398     LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     398    LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    399399    return rc;
    400400}
    … …  
    409409    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    410410    LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: iRegion=%#x\n",
    411              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion));
     411             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion));
    412412
    413413    AssertReturn(iRegion == UINT32_MAX, VERR_INVALID_PARAMETER);
    … …  
    415415    int rc = PGMR3PhysMMIO2Deregister(pDevIns->Internal.s.pVMR3, pDevIns, iRegion);
    416416
    417     LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     417    LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    418418    return rc;
    419419}
    … …  
    428428    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    429429    LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: iRegion=%#x GCPhys=%#RGp\n",
    430              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, GCPhys));
     430             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, GCPhys));
    431431
    432432    int rc = PGMR3PhysMMIO2Map(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, GCPhys);
    433433
    434     LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     434    LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    435435    return rc;
    436436}
    … …  
    445445    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    446446    LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: iRegion=%#x GCPhys=%#RGp\n",
    447              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, GCPhys));
     447             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, GCPhys));
    448448
    449449    int rc = PGMR3PhysMMIO2Unmap(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, GCPhys);
    450450
    451     LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     451    LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    452452    return rc;
    453453}
    … …  
    464464    VM_ASSERT_EMT(pVM);
    465465    LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pRCPtr=%p\n",
    466              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
     466             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
    467467
    468468    if (pDevIns->iInstance > 0)
    … …  
    475475    int rc = MMR3HyperMapMMIO2(pVM, pDevIns, iRegion, off, cb, pszDesc, pRCPtr);
    476476
    477     LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc *pRCPtr=%RRv\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc, *pRCPtr));
     477    LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc *pRCPtr=%RRv\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc, *pRCPtr));
    478478    return rc;
    479479}
    … …  
    490490    VM_ASSERT_EMT(pVM);
    491491    LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pR0Ptr=%p\n",
    492              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pR0Ptr));
     492             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pR0Ptr));
    493493
    494494    if (pDevIns->iInstance > 0)
    … …  
    501501    int rc = PGMR3PhysMMIO2MapKernel(pVM, pDevIns, iRegion, off, cb, pszDesc, pR0Ptr);
    502502
    503     LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: returns %Rrc *pR0Ptr=%RHv\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc, *pR0Ptr));
     503    LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: returns %Rrc *pR0Ptr=%RHv\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc, *pR0Ptr));
    504504    return rc;
    505505}
    … …  
    512512    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    513513    LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvBinary=%p fFlags=%#RX32 pszDesc=%p:{%s}\n",
    514              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, fFlags, pszDesc, pszDesc));
     514             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, fFlags, pszDesc, pszDesc));
    515515
    516516/** @todo can we mangle pszDesc? */
    517517    int rc = PGMR3PhysRomRegister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvBinary, fFlags, pszDesc);
    518518
    519     LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     519    LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    520520    return rc;
    521521}
    … …  
    527527    PDMDEV_ASSERT_DEVINS(pDevIns);
    528528    LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x enmProt=%d\n",
    529              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
     529             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
    530530
    531531    int rc = PGMR3PhysRomProtect(pDevIns->Internal.s.pVMR3, GCPhysStart, cbRange, enmProt);
    532532
    533     LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     533    LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    534534    return rc;
    535535}
    … …  
    546546    LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: uVersion=#x cbGuess=%#x pszBefore=%p:{%s}\n"
    547547             "    pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
    548              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
     548             pDevIns->pReg->szDeviceName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
    549549             pfnLivePrep, pfnLiveExec, pfnLiveVote,
    550550             pfnSavePrep, pfnSaveExec, pfnSaveDone,
    551551             pfnLoadPrep, pfnLoadExec, pfnLoadDone));
    552552
    553     int rc = SSMR3RegisterDevice(pDevIns->Internal.s.pVMR3, pDevIns, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
     553    int rc = SSMR3RegisterDevice(pDevIns->Internal.s.pVMR3, pDevIns, pDevIns->pReg->szDeviceName, pDevIns->iInstance,
    554554                                 uVersion, cbGuess, pszBefore,
    555555                                 pfnLivePrep, pfnLiveExec, pfnLiveVote,
    … …  
    557557                                 pfnLoadPrep, pfnLoadExec, pfnLoadDone);
    558558
    559     LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     559    LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    560560    return rc;
    561561}
    … …  
    569569    VM_ASSERT_EMT(pVM);
    570570    LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
    571              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
     571             pDevIns->pReg->szDeviceName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
    572572
    573573    if (pDevIns->iInstance > 0) /** @todo use a string cache here later. */
    … …  
    580580    int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
    581581
    582     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     582    LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    583583    return rc;
    584584}
    … …  
    590590    PDMDEV_ASSERT_DEVINS(pDevIns);
    591591    LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: pTime=%p\n",
    592              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pTime));
     592             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pTime));
    593593
    594594    pTime = TMR3UtcNow(pDevIns->Internal.s.pVMR3, pTime);
    595595
    596     LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
     596    LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
    597597    return pTime;
    598598}
    … …  
    605605    PVM pVM = pDevIns->Internal.s.pVMR3;
    606606    LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
    607              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
     607             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
    608608
    609609#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
    … …  
    622622        rc = PGMR3PhysReadExternal(pVM, GCPhys, pvBuf, cbRead);
    623623
    624     Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     624    Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    625625    return rc;
    626626}
    … …  
    633633    PVM pVM = pDevIns->Internal.s.pVMR3;
    634634    LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
    635              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
     635             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
    636636
    637637#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
    … …  
    648648        rc = PGMPhysWrite(pVM, GCPhys, pvBuf, cbWrite);
    649649    else
    650         rc = PGMR3PhysWriteExternal(pVM, GCPhys, pvBuf, cbWrite, pDevIns->pDevReg->szDeviceName);
    651 
    652     Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     650        rc = PGMR3PhysWriteExternal(pVM, GCPhys, pvBuf, cbWrite, pDevIns->pReg->szDeviceName);
     651
     652    Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    653653    return rc;
    654654}
    … …  
    661661    PVM pVM = pDevIns->Internal.s.pVMR3;
    662662    LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
    663              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
     663             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
    664664    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
    665665
    … …  
    675675    int rc = PGMR3PhysGCPhys2CCPtrExternal(pVM, GCPhys, ppv, pLock);
    676676
    677     Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     677    Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    678678    return rc;
    679679}
    … …  
    686686    PVM pVM = pDevIns->Internal.s.pVMR3;
    687687    LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
    688              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
     688             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
    689689    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
    690690
    … …  
    700700    int rc = PGMR3PhysGCPhys2CCPtrReadOnlyExternal(pVM, GCPhys, ppv, pLock);
    701701
    702     Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     702    Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    703703    return rc;
    704704}
    … …  
    711711    PVM pVM = pDevIns->Internal.s.pVMR3;
    712712    LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
    713              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pLock));
     713             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLock));
    714714
    715715    PGMPhysReleasePageMappingLock(pVM, pLock);
    716716
    717     Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     717    Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    718718}
    719719
    … …  
    726726    VM_ASSERT_EMT(pVM);
    727727    LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
    728              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
     728             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
    729729
    730730    PVMCPU pVCpu = VMMGetCpu(pVM);
    … …  
    737737    int rc = PGMPhysSimpleReadGCPtr(pVCpu, pvDst, GCVirtSrc, cb);
    738738
    739     LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     739    LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    740740
    741741    return rc;
    … …  
    750750    VM_ASSERT_EMT(pVM);
    751751    LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
    752              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
     752             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
    753753
    754754    PVMCPU pVCpu = VMMGetCpu(pVM);
    … …  
    761761    int rc = PGMPhysSimpleWriteGCPtr(pVCpu, GCVirtDst, pvSrc, cb);
    762762
    763     LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     763    LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    764764
    765765    return rc;
    … …  
    774774    VM_ASSERT_EMT(pVM);
    775775    LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
    776              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPtr, pGCPhys));
     776             pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPtr, pGCPhys));
    777777
    778778    PVMCPU pVCpu = VMMGetCpu(pVM);
    … …  
    785785    int rc = PGMPhysGCPtr2GCPhys(pVCpu, GCPtr, pGCPhys);
    786786
    787     LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc *pGCPhys=%RGp\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc, *pGCPhys));
     787    LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc *pGCPhys=%RGp\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc, *pGCPhys));
    788788
    789789    return rc;
    … …  
    795795{
    796796    PDMDEV_ASSERT_DEVINS(pDevIns);
    797     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cb));
     797    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, cb));
    798798
    799799    void *pv = MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
    800800
    801     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pv));
     801    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pv));
    802802    return pv;
    803803}
    … …  
    808808{
    809809    PDMDEV_ASSERT_DEVINS(pDevIns);
    810     LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cb));
     810    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, cb));
    811811
    812812    void *pv = MMR3HeapAllocZ(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
    813813
    814     LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pv));
     814    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pv));
    815815    return pv;
    816816}
    … …  
    821821{
    822822    PDMDEV_ASSERT_DEVINS(pDevIns);
    823     LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pv));
     823    LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pv));
    824824
    825825    MMR3HeapFree(pv);
    826826
    827     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     827    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    828828}
    829829
    … …  
    836836    VMSTATE enmVMState = VMR3GetState(pDevIns->Internal.s.pVMR3);
    837837
    838     LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
     838    LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
    839839             enmVMState, VMR3GetStateName(enmVMState)));
    840840    return enmVMState;
    … …  
    849849    bool fRc = VMR3TeleportedAndNotFullyResumedYet(pDevIns->Internal.s.pVMR3);
    850850
    851     LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
     851    LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
    852852             fRc));
    853853    return fRc;
    … …  
    905905    va_copy(va2, args);
    906906    LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
    907              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
     907             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
    908908    va_end(va2);
    909909#endif
    … …  
    915915        rc = VINF_SUCCESS;
    916916
    917     LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     917    LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    918918    return rc;
    919919}
    … …  
    925925    PDMDEV_ASSERT_DEVINS(pDevIns);
    926926    LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
    927              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
     927             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
    928928
    929929    PVM pVM = pDevIns->Internal.s.pVMR3;
    … …  
    931931    int rc = DBGFR3InfoRegisterDevice(pVM, pszName, pszDesc, pfnHandler, pDevIns);
    932932
    933     LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     933    LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    934934    return rc;
    935935}
    … …  
    989989    VM_ASSERT_EMT(pVM);
    990990    LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs}\n",
    991              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pPciDev, pPciDev->config));
     991             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPciDev, pPciDev->config));
    992992
    993993    /*
    … …  
    997997    {
    998998        Assert(pPciDev);
    999         LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (pPciDev)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     999        LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (pPciDev)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    10001000        return VERR_INVALID_PARAMETER;
    10011001    }
    … …  
    10031003    {
    10041004        Assert(pPciDev->config[0] || pPciDev->config[1]);
    1005         LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (vendor)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1005        LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (vendor)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    10061006        return VERR_INVALID_PARAMETER;
    10071007    }
    … …  
    10301030        rc = CFGMR3QueryU8Def(pDevIns->Internal.s.pCfgHandle, "PCIBusNo", &u8Bus, 0);
    10311031        AssertLogRelMsgRCReturn(rc, ("Configuration error: PCIBusNo query failed with rc=%Rrc (%s/%d)\n",
    1032                                      rc, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance), rc);
     1032                                     rc, pDevIns->pReg->szDeviceName, pDevIns->iInstance), rc);
    10331033        AssertLogRelMsgReturn(u8Bus < RT_ELEMENTS(pVM->pdm.s.aPciBuses),
    10341034                              ("Configuration error: PCIBusNo=%d, max is %d. (%s/%d)\n", u8Bus,
    1035                                RT_ELEMENTS(pVM->pdm.s.aPciBuses), pDevIns->pDevReg->szDeviceName, pDevIns->iInstance),
     1035                               RT_ELEMENTS(pVM->pdm.s.aPciBuses), pDevIns->pReg->szDeviceName, pDevIns->iInstance),
    10361036                              VERR_PDM_NO_PCI_BUS);
    10371037        pBus = pDevIns->Internal.s.pPciBusR3 = &pVM->pdm.s.aPciBuses[u8Bus];
    … …  
    10391039    if (pBus->pDevInsR3)
    10401040    {
    1041         if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC)
     1041        if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
    10421042            pDevIns->Internal.s.pPciBusR0 = MMHyperR3ToR0(pVM, pDevIns->Internal.s.pPciBusR3);
    10431043        else
    10441044            pDevIns->Internal.s.pPciBusR0 = NIL_RTR0PTR;
    10451045
    1046         if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC)
     1046        if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
    10471047            pDevIns->Internal.s.pPciBusRC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciBusR3);
    10481048        else
    … …  
    10601060            {
    10611061                AssertMsgFailed(("Configuration error: PCIDeviceNo=%d, max is 31. (%s/%d)\n",
    1062                                  u8Device, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1062                                 u8Device, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    10631063                return VERR_INTERNAL_ERROR;
    10641064            }
    … …  
    10691069            {
    10701070                AssertMsgFailed(("Configuration error: PCIDeviceNo, but PCIFunctionNo query failed with rc=%Rrc (%s/%d)\n",
    1071                                  rc, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1071                                 rc, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    10721072                return rc;
    10731073            }
    … …  
    10751075            {
    10761076                AssertMsgFailed(("Configuration error: PCIFunctionNo=%d, max is 7. (%s/%d)\n",
    1077                                  u8Function, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1077                                 u8Function, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    10781078                return VERR_INTERNAL_ERROR;
    10791079            }
    … …  
    10831083        {
    10841084            AssertMsgFailed(("Configuration error: PCIDeviceNo query failed with rc=%Rrc (%s/%d)\n",
    1085                              rc, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1085                             rc, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    10861086            return rc;
    10871087        }
    … …  
    10911091         */
    10921092        pdmLock(pVM);
    1093         rc = pBus->pfnRegisterR3(pBus->pDevInsR3, pPciDev, pDevIns->pDevReg->szDeviceName, iDev);
     1093        rc = pBus->pfnRegisterR3(pBus->pDevInsR3, pPciDev, pDevIns->pReg->szDeviceName, iDev);
    10941094        pdmUnlock(pVM);
    10951095        if (RT_SUCCESS(rc))
    … …  
    10981098
    10991099            pDevIns->Internal.s.pPciDeviceR3 = pPciDev;
    1100             if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0)
     1100            if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
    11011101                pDevIns->Internal.s.pPciDeviceR0 = MMHyperR3ToR0(pVM, pPciDev);
    11021102            else
    11031103                pDevIns->Internal.s.pPciDeviceR0 = NIL_RTR0PTR;
    11041104
    1105             if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC)
     1105            if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
    11061106                pDevIns->Internal.s.pPciDeviceRC = MMHyperR3ToRC(pVM, pPciDev);
    11071107            else
    … …  
    11091109
    11101110            Log(("PDM: Registered device '%s'/%d as PCI device %d on bus %d\n",
    1111                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pPciDev->devfn, pDevIns->Internal.s.pPciBusR3->iBus));
     1111                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPciDev->devfn, pDevIns->Internal.s.pPciBusR3->iBus));
    11121112        }
    11131113    }
    … …  
    11181118    }
    11191119
    1120     LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1120    LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    11211121    return rc;
    11221122}
    … …  
    11301130    VM_ASSERT_EMT(pVM);
    11311131    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: iRegion=%d cbRegion=%#x enmType=%d pfnCallback=%p\n",
    1132              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, cbRegion, enmType, pfnCallback));
     1132             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, cbRegion, enmType, pfnCallback));
    11331133
    11341134    /*
    … …  
    11381138    {
    11391139        Assert(iRegion >= 0 && iRegion < PCI_NUM_REGIONS);
    1140         LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1140        LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    11411141        return VERR_INVALID_PARAMETER;
    11421142    }
    … …  
    11481148             */
    11491149            AssertMsgReturn(cbRegion <= _32K,
    1150                             ("caller='%s'/%d: %#x\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cbRegion),
     1150                            ("caller='%s'/%d: %#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, cbRegion),
    11511151                            VERR_INVALID_PARAMETER);
    11521152            break;
    … …  
    11591159             */
    11601160            AssertMsgReturn(cbRegion <= 512 * _1M,
    1161                             ("caller='%s'/%d: %#x\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cbRegion),
     1161                            ("caller='%s'/%d: %#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, cbRegion),
    11621162                            VERR_INVALID_PARAMETER);
    11631163            break;
    11641164        default:
    11651165            AssertMsgFailed(("enmType=%#x is unknown\n", enmType));
    1166             LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1166            LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    11671167            return VERR_INVALID_PARAMETER;
    11681168    }
    … …  
    11701170    {
    11711171        Assert(pfnCallback);
    1172         LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (callback)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1172        LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (callback)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    11731173        return VERR_INVALID_PARAMETER;
    11741174    }
    … …  
    11891189        {
    11901190            Log(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: aligning cbRegion %#x -> %#x\n",
    1191                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cbRegion, RT_ALIGN_32(cbRegion, PAGE_SIZE)));
     1191                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, cbRegion, RT_ALIGN_32(cbRegion, PAGE_SIZE)));
    11921192            cbRegion = RT_ALIGN_32(cbRegion, PAGE_SIZE);
    11931193        }
    … …  
    12141214    }
    12151215
    1216     LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1216    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    12171217    return rc;
    12181218}
    … …  
    12271227    VM_ASSERT_EMT(pVM);
    12281228    LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: pPciDev=%p pfnRead=%p ppfnReadOld=%p pfnWrite=%p ppfnWriteOld=%p\n",
    1229              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld));
     1229             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld));
    12301230
    12311231    /*
    … …  
    12521252    pdmUnlock(pVM);
    12531253
    1254     LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: returns void\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1254    LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    12551255}
    12561256
    … …  
    12601260{
    12611261    PDMDEV_ASSERT_DEVINS(pDevIns);
    1262     LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iIrq, iLevel));
     1262    LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, iIrq, iLevel));
    12631263
    12641264    /*
    … …  
    12831283        AssertReleaseMsgFailed(("No PCI device registered!\n"));
    12841284
    1285     LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1285    LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    12861286}
    12871287
    … …  
    12981298{
    12991299    PDMDEV_ASSERT_DEVINS(pDevIns);
    1300     LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iIrq, iLevel));
     1300    LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, iIrq, iLevel));
    13011301
    13021302    /*
    … …  
    13081308    PDMIsaSetIrq(pVM, iIrq, iLevel);    /* (The API takes the lock.) */
    13091309
    1310     LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1310    LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    13111311}
    13121312
    … …  
    13261326    VM_ASSERT_EMT(pVM);
    13271327    LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
    1328              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
     1328             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
    13291329
    13301330    /*
    … …  
    13681368            pLunPrev->pNext = pLun;
    13691369        Log(("pdmR3DevHlp_DriverAttach: Registered LUN#%d '%s' with device '%s'/%d.\n",
    1370              iLun, pszDesc, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1370             iLun, pszDesc, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    13711371    }
    13721372    else if (pLun->pTop)
    13731373    {
    13741374        AssertMsgFailed(("Already attached! The device should keep track of such things!\n"));
    1375         LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_PDM_DRIVER_ALREADY_ATTACHED));
     1375        LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_PDM_DRIVER_ALREADY_ATTACHED));
    13761376        return VERR_PDM_DRIVER_ALREADY_ATTACHED;
    13771377    }
    … …  
    13901390
    13911391
    1392     LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1392    LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    13931393    return rc;
    13941394}
    … …  
    14011401    PDMDEV_ASSERT_DEVINS(pDevIns);
    14021402    LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fGCEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
    1403              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, pszName, ppQueue));
     1403             pDevIns->pReg->szDeviceName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, pszName, ppQueue));
    14041404
    14051405    PVM pVM = pDevIns->Internal.s.pVMR3;
    … …  
    14141414    int rc = PDMR3QueueCreateDevice(pVM, pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, ppQueue);
    14151415
    1416     LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc, *ppQueue));
     1416    LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc, *ppQueue));
    14171417    return rc;
    14181418}
    … …  
    14251425    PDMDEV_ASSERT_DEVINS(pDevIns);
    14261426    LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
    1427              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
     1427             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
    14281428
    14291429    PVM pVM = pDevIns->Internal.s.pVMR3;
    … …  
    14311431    int rc = pdmR3CritSectInitDevice(pVM, pDevIns, pCritSect, RT_SRC_POS, pszNameFmt, va);
    14321432
    1433     LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1433    LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    14341434    return rc;
    14351435}
    … …  
    14431443    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    14441444    LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
    1445              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
     1445             pDevIns->pReg->szDeviceName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
    14461446
    14471447    int rc = pdmR3ThreadCreateDevice(pDevIns->Internal.s.pVMR3, pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
    14481448
    1449     LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
     1449    LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
    14501450            rc, *ppThread));
    14511451    return rc;
    … …  
    14581458    PDMDEV_ASSERT_DEVINS(pDevIns);
    14591459    VM_ASSERT_EMT0(pDevIns->Internal.s.pVMR3);
    1460     LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pfnAsyncNotify));
     1460    LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pfnAsyncNotify));
    14611461
    14621462    int rc = VINF_SUCCESS;
    … …  
    14771477        pDevIns->Internal.s.pfnAsyncNotify = pfnAsyncNotify;
    14781478
    1479     LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1479    LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    14801480    return rc;
    14811481}
    … …  
    14971497        || enmVMState == VMSTATE_POWERING_OFF_LS)
    14981498    {
    1499         LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     1499        LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    15001500        VMR3AsyncPdmNotificationWakeupU(pVM->pUVM);
    15011501    }
    15021502    else
    1503         LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, enmVMState));
     1503        LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, enmVMState));
    15041504}
    15051505
    … …  
    15111511    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    15121512    LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
    1513              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
     1513             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
    15141514             pRtcReg->pfnWrite, ppRtcHlp));
    15151515
    … …  
    15221522                         PDM_RTCREG_VERSION));
    15231523        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (version)\n",
    1524                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1524                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    15251525        return VERR_INVALID_PARAMETER;
    15261526    }
    … …  
    15311531        Assert(pRtcReg->pfnRead);
    15321532        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
    1533                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1533                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    15341534        return VERR_INVALID_PARAMETER;
    15351535    }
    … …  
    15391539        Assert(ppRtcHlp);
    15401540        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (ppRtcHlp)\n",
    1541                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1541                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    15421542        return VERR_INVALID_PARAMETER;
    15431543    }
    … …  
    15511551        AssertMsgFailed(("Only one RTC device is supported!\n"));
    15521552        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
    1553                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1553                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    15541554        return VERR_INVALID_PARAMETER;
    15551555    }
    … …  
    15691569        *ppRtcHlp = &g_pdmR3DevRtcHlp;
    15701570        Log(("PDM: Registered RTC device '%s'/%d pDevIns=%p\n",
    1571              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns));
     1571             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
    15721572    }
    15731573    else
    … …  
    15751575
    15761576    LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
    1577              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1577             pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    15781578    return rc;
    15791579}
    … …  
    15871587    VM_ASSERT_EMT(pVM);
    15881588    LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
    1589              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
     1589             pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
    15901590    int rc = VINF_SUCCESS;
    15911591    if (pVM->pdm.s.pDmac)
    … …  
    15971597    }
    15981598    LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
    1599              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1599             pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    16001600    return rc;
    16011601}
    … …  
    16091609    VM_ASSERT_EMT(pVM);
    16101610    LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
    1611              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
     1611             pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
    16121612    int rc = VINF_SUCCESS;
    16131613    if (pVM->pdm.s.pDmac)
    … …  
    16231623    }
    16241624    LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
    1625              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1625             pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    16261626    return rc;
    16271627}
    … …  
    16351635    VM_ASSERT_EMT(pVM);
    16361636    LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
    1637              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
     1637             pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
    16381638    int rc = VINF_SUCCESS;
    16391639    if (pVM->pdm.s.pDmac)
    … …  
    16491649    }
    16501650    LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
    1651              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1651             pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    16521652    return rc;
    16531653}
    … …  
    16611661    VM_ASSERT_EMT(pVM);
    16621662    LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
    1663              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, uChannel, uLevel));
     1663             pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel, uLevel));
    16641664    int rc = VINF_SUCCESS;
    16651665    if (pVM->pdm.s.pDmac)
    … …  
    16711671    }
    16721672    LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
    1673              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1673             pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    16741674    return rc;
    16751675}
    … …  
    16821682    VM_ASSERT_EMT(pVM);
    16831683    LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
    1684              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, uChannel));
     1684             pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel));
    16851685    uint8_t u8Mode;
    16861686    if (pVM->pdm.s.pDmac)
    … …  
    16921692    }
    16931693    LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
    1694              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, u8Mode));
     1694             pDevIns->pReg->szDeviceName, pDevIns->iInstance, u8Mode));
    16951695    return u8Mode;
    16961696}
    … …  
    17031703    VM_ASSERT_EMT(pVM);
    17041704    LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d: VM_FF_PDM_DMA %d -> 1\n",
    1705              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_PDM_DMA)));
     1705             pDevIns->pReg->szDeviceName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_PDM_DMA)));
    17061706
    17071707    AssertMsg(pVM->pdm.s.pDmac, ("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
    … …  
    17201720
    17211721    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
    1722              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iReg, u8Value));
     1722             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iReg, u8Value));
    17231723    int rc;
    17241724    if (pVM->pdm.s.pRtc)
    … …  
    17281728
    17291729    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
    1730              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1730             pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    17311731    return rc;
    17321732}
    … …  
    17411741
    17421742    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
    1743              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iReg, pu8Value));
     1743             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iReg, pu8Value));
    17441744    int rc;
    17451745    if (pVM->pdm.s.pRtc)
    … …  
    17491749
    17501750    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
    1751              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1751             pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    17521752    return rc;
    17531753}
    … …  
    17621762
    17631763    char szMsg[100];
    1764     RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
     1764    RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance);
    17651765    RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
    17661766    AssertBreakpoint();
    … …  
    17771777
    17781778    char szMsg[100];
    1779     RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
     1779    RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance);
    17801780    RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
    17811781    AssertBreakpoint();
    … …  
    17911791    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    17921792    LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
    1793              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
     1793             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
    17941794
    17951795    int rc;
    17961796    if (   strncmp(pszSymPrefix, "dev", 3) == 0
    1797         && RTStrIStr(pszSymPrefix + 3, pDevIns->pDevReg->szDeviceName) != NULL)
    1798     {
    1799         if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC)
     1797        && RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szDeviceName) != NULL)
     1798    {
     1799        if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
    18001800            rc = PDMR3LdrGetInterfaceSymbols(pDevIns->Internal.s.pVMR3, pvInterface, cbInterface,
    1801                                              pDevIns->pDevReg->szDeviceName, pszSymPrefix, pszSymList,
     1801                                             pDevIns->pReg->szDeviceName, pszSymPrefix, pszSymList,
    18021802                                             false /*fRing0OrRC*/);
    18031803        else
    … …  
    18101810    {
    18111811        AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'dev' and contain the driver name!\n",
    1812                          pszSymPrefix, pDevIns->pDevReg->szDeviceName));
     1812                         pszSymPrefix, pDevIns->pReg->szDeviceName));
    18131813        rc = VERR_INVALID_NAME;
    18141814    }
    18151815
    1816     LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName,
     1816    LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName,
    18171817             pDevIns->iInstance, rc));
    18181818    return rc;
    … …  
    18271827    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    18281828    LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
    1829              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
     1829             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
    18301830
    18311831    int rc;
    18321832    if (   strncmp(pszSymPrefix, "dev", 3) == 0
    1833         && RTStrIStr(pszSymPrefix + 3, pDevIns->pDevReg->szDeviceName) != NULL)
    1834     {
    1835         if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0)
     1833        && RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szDeviceName) != NULL)
     1834    {
     1835        if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
    18361836            rc = PDMR3LdrGetInterfaceSymbols(pDevIns->Internal.s.pVMR3, pvInterface, cbInterface,
    1837                                              pDevIns->pDevReg->szDeviceName, pszSymPrefix, pszSymList,
     1837                                             pDevIns->pReg->szDeviceName, pszSymPrefix, pszSymList,
    18381838                                             true /*fRing0OrRC*/);
    18391839        else
    … …  
    18461846    {
    18471847        AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'dev' and contain the driver name!\n",
    1848                          pszSymPrefix, pDevIns->pDevReg->szDeviceName));
     1848                         pszSymPrefix, pDevIns->pReg->szDeviceName));
    18491849        rc = VERR_INVALID_NAME;
    18501850    }
    18511851
    1852     LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName,
     1852    LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName,
    18531853             pDevIns->iInstance, rc));
    18541854    return rc;
    … …  
    18601860{
    18611861    PDMDEV_ASSERT_DEVINS(pDevIns);
    1862     LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns->Internal.s.pVMR3));
     1862    LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns->Internal.s.pVMR3));
    18631863    return pDevIns->Internal.s.pVMR3;
    18641864}
    … …  
    18701870    PDMDEV_ASSERT_DEVINS(pDevIns);
    18711871    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    1872     LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMMGetCpuId(pDevIns->Internal.s.pVMR3)));
     1872    LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VMMGetCpuId(pDevIns->Internal.s.pVMR3)));
    18731873    return VMMGetCpu(pDevIns->Internal.s.pVMR3);
    18741874}
    … …  
    18831883    LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, .pfnSetIrqR3=%p, "
    18841884             ".pfnSaveExecR3=%p, .pfnLoadExecR3=%p, .pfnFakePCIBIOSR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppPciHlpR3=%p\n",
    1885              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
     1885             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
    18861886             pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnSetIrqR3, pPciBusReg->pfnSaveExecR3, pPciBusReg->pfnLoadExecR3,
    18871887             pPciBusReg->pfnFakePCIBIOSR3, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqR0, pPciBusReg->pszSetIrqR0, ppPciHlpR3));
    … …  
    18931893    {
    18941894        AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREG_VERSION));
    1895         LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1895        LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    18961896        return VERR_INVALID_PARAMETER;
    18971897    }
    … …  
    19091909        Assert(pPciBusReg->pfnLoadExecR3);
    19101910        Assert(pPciBusReg->pfnFakePCIBIOSR3);
    1911         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1911        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19121912        return VERR_INVALID_PARAMETER;
    19131913    }
    … …  
    19161916    {
    19171917        Assert(VALID_PTR(pPciBusReg->pszSetIrqRC));
    1918         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1918        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19191919        return VERR_INVALID_PARAMETER;
    19201920    }
    … …  
    19231923    {
    19241924        Assert(VALID_PTR(pPciBusReg->pszSetIrqR0));
    1925         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1925        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19261926        return VERR_INVALID_PARAMETER;
    19271927    }
    … …  
    19291929    {
    19301930        Assert(ppPciHlpR3);
    1931         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (ppPciHlpR3)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1931        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (ppPciHlpR3)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19321932        return VERR_INVALID_PARAMETER;
    19331933    }
    … …  
    19431943    {
    19441944        AssertMsgFailed(("Too many PCI buses. Max=%u\n", RT_ELEMENTS(pVM->pdm.s.aPciBuses)));
    1945         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (pci bus)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1945        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (pci bus)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19461946        return VERR_INVALID_PARAMETER;
    19471947    }
    … …  
    19531953    if (pPciBusReg->pszSetIrqRC)
    19541954    {
    1955         int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pPciBusReg->pszSetIrqRC, &pPciBus->pfnSetIrqRC);
    1956         AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pPciBusReg->pszSetIrqRC, rc));
     1955        int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pPciBusReg->pszSetIrqRC, &pPciBus->pfnSetIrqRC);
     1956        AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPciBusReg->pszSetIrqRC, rc));
    19571957        if (RT_FAILURE(rc))
    19581958        {
    1959             LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1959            LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    19601960            return rc;
    19611961        }
    … …  
    19731973    if (pPciBusReg->pszSetIrqR0)
    19741974    {
    1975         int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pPciBusReg->pszSetIrqR0, &pPciBus->pfnSetIrqR0);
    1976         AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pPciBusReg->pszSetIrqR0, rc));
     1975        int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pPciBusReg->pszSetIrqR0, &pPciBus->pfnSetIrqR0);
     1976        AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPciBusReg->pszSetIrqR0, rc));
    19771977        if (RT_FAILURE(rc))
    19781978        {
    1979             LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     1979            LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    19801980            return rc;
    19811981        }
    … …  
    20012001    pPciBus->pfnFakePCIBIOSR3        = pPciBusReg->pfnFakePCIBIOSR3;
    20022002
    2003     Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2003    Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
    20042004
    20052005    /* set the helper pointer and return. */
    20062006    *ppPciHlpR3 = &g_pdmR3DevPciHlp;
    2007     LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2007    LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
    20082008    return VINF_SUCCESS;
    20092009}
    … …  
    20162016    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    20172017    LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlpR3=%p\n",
    2018              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
     2018             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
    20192019             pPicReg->pszSetIrqRC, pPicReg->pszSetIrqRC, pPicReg->pszGetInterruptRC, pPicReg->pszGetInterruptRC,
    20202020             pPicReg->pszSetIrqR0, pPicReg->pszSetIrqR0, pPicReg->pszGetInterruptR0, pPicReg->pszGetInterruptR0,
    … …  
    20272027    {
    20282028        AssertMsgFailed(("u32Version=%#x expected %#x\n", pPicReg->u32Version, PDM_PICREG_VERSION));
    2029         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2029        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20302030        return VERR_INVALID_PARAMETER;
    20312031    }
    … …  
    20352035        Assert(pPicReg->pfnSetIrqR3);
    20362036        Assert(pPicReg->pfnGetInterruptR3);
    2037         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2037        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20382038        return VERR_INVALID_PARAMETER;
    20392039    }
    … …  
    20462046        Assert(VALID_PTR(pPicReg->pszSetIrqRC));
    20472047        Assert(VALID_PTR(pPicReg->pszGetInterruptRC));
    2048         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2048        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20492049        return VERR_INVALID_PARAMETER;
    20502050    }
    20512051    if (    pPicReg->pszSetIrqRC
    2052         &&  !(pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC))
    2053     {
    2054         Assert(pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC);
    2055         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC flag)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2052        &&  !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC))
     2053    {
     2054        Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC);
     2055        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC flag)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20562056        return VERR_INVALID_PARAMETER;
    20572057    }
    20582058    if (    pPicReg->pszSetIrqR0
    2059         &&  !(pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0))
    2060     {
    2061         Assert(pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0);
    2062         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R0 flag)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2059        &&  !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0))
     2060    {
     2061        Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0);
     2062        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R0 flag)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20632063        return VERR_INVALID_PARAMETER;
    20642064    }
    … …  
    20662066    {
    20672067        Assert(ppPicHlpR3);
    2068         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (ppPicHlpR3)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2068        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (ppPicHlpR3)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20692069        return VERR_INVALID_PARAMETER;
    20702070    }
    … …  
    20772077    {
    20782078        AssertMsgFailed(("Only one pic device is supported!\n"));
    2079         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2079        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20802080        return VERR_INVALID_PARAMETER;
    20812081    }
    … …  
    20862086    if (pPicReg->pszSetIrqRC)
    20872087    {
    2088         int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pPicReg->pszSetIrqRC, &pVM->pdm.s.Pic.pfnSetIrqRC);
    2089         AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pPicReg->pszSetIrqRC, rc));
     2088        int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pPicReg->pszSetIrqRC, &pVM->pdm.s.Pic.pfnSetIrqRC);
     2089        AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPicReg->pszSetIrqRC, rc));
    20902090        if (RT_SUCCESS(rc))
    20912091        {
    2092             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pPicReg->pszGetInterruptRC, &pVM->pdm.s.Pic.pfnGetInterruptRC);
    2093             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pPicReg->pszGetInterruptRC, rc));
     2092            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pPicReg->pszGetInterruptRC, &pVM->pdm.s.Pic.pfnGetInterruptRC);
     2093            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pPicReg->pszGetInterruptRC, rc));
    20942094        }
    20952095        if (RT_FAILURE(rc))
    20962096        {
    2097             LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2097            LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    20982098            return rc;
    20992099        }
    … …  
    21122112    if (pPicReg->pszSetIrqR0)
    21132113    {
    2114         int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pPicReg->pszSetIrqR0, &pVM->pdm.s.Pic.pfnSetIrqR0);
    2115         AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pPicReg->pszSetIrqR0, rc));
     2114        int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pPicReg->pszSetIrqR0, &pVM->pdm.s.Pic.pfnSetIrqR0);
     2115        AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPicReg->pszSetIrqR0, rc));
    21162116        if (RT_SUCCESS(rc))
    21172117        {
    2118             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pPicReg->pszGetInterruptR0, &pVM->pdm.s.Pic.pfnGetInterruptR0);
    2119             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pPicReg->pszGetInterruptR0, rc));
     2118            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pPicReg->pszGetInterruptR0, &pVM->pdm.s.Pic.pfnGetInterruptR0);
     2119            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pPicReg->pszGetInterruptR0, rc));
    21202120        }
    21212121        if (RT_FAILURE(rc))
    21222122        {
    2123             LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2123            LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    21242124            return rc;
    21252125        }
    … …  
    21402140    pVM->pdm.s.Pic.pfnSetIrqR3 = pPicReg->pfnSetIrqR3;
    21412141    pVM->pdm.s.Pic.pfnGetInterruptR3 = pPicReg->pfnGetInterruptR3;
    2142     Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2142    Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
    21432143
    21442144    /* set the helper pointer and return. */
    21452145    *ppPicHlpR3 = &g_pdmR3DevPicHlp;
    2146     LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2146    LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
    21472147    return VINF_SUCCESS;
    21482148}
    … …  
    21572157             ".pfnSetTPRR3=%p, .pfnGetTPRR3=%p, .pfnWriteMSR3=%p, .pfnReadMSR3=%p, .pfnBusDeliverR3=%p, .pfnLocalInterruptR3=%p, pszGetInterruptRC=%p:{%s}, pszSetBaseRC=%p:{%s}, pszGetBaseRC=%p:{%s}, "
    21582158             ".pszSetTPRRC=%p:{%s}, .pszGetTPRRC=%p:{%s}, .pszWriteMSRRC=%p:{%s}, .pszReadMSRRC=%p:{%s}, .pszBusDeliverRC=%p:{%s}, .pszLocalInterruptRC=%p:{%s}} ppApicHlpR3=%p\n",
    2159              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pApicReg, pApicReg->u32Version, pApicReg->pfnGetInterruptR3, pApicReg->pfnSetBaseR3,
     2159             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pApicReg, pApicReg->u32Version, pApicReg->pfnGetInterruptR3, pApicReg->pfnSetBaseR3,
    21602160             pApicReg->pfnGetBaseR3, pApicReg->pfnSetTPRR3, pApicReg->pfnGetTPRR3, pApicReg->pfnWriteMSRR3, pApicReg->pfnReadMSRR3, pApicReg->pfnBusDeliverR3, pApicReg->pfnLocalInterruptR3, pApicReg->pszGetInterruptRC,
    21612161             pApicReg->pszGetInterruptRC, pApicReg->pszSetBaseRC, pApicReg->pszSetBaseRC, pApicReg->pszGetBaseRC, pApicReg->pszGetBaseRC,
    … …  
    21692169    {
    21702170        AssertMsgFailed(("u32Version=%#x expected %#x\n", pApicReg->u32Version, PDM_APICREG_VERSION));
    2171         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2171        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    21722172        return VERR_INVALID_PARAMETER;
    21732173    }
    … …  
    21932193        Assert(pApicReg->pfnBusDeliverR3);
    21942194        Assert(pApicReg->pfnLocalInterruptR3);
    2195         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2195        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    21962196        return VERR_INVALID_PARAMETER;
    21972197    }
    … …  
    22282228        Assert(VALID_PTR(pApicReg->pszBusDeliverRC));
    22292229        Assert(VALID_PTR(pApicReg->pszLocalInterruptRC));
    2230         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2230        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    22312231        return VERR_INVALID_PARAMETER;
    22322232    }
    … …  
    22632263        Assert(VALID_PTR(pApicReg->pszBusDeliverR0));
    22642264        Assert(VALID_PTR(pApicReg->pszLocalInterruptR0));
    2265         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R0 callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2265        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R0 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    22662266        return VERR_INVALID_PARAMETER;
    22672267    }
    … …  
    22692269    {
    22702270        Assert(ppApicHlpR3);
    2271         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2271        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    22722272        return VERR_INVALID_PARAMETER;
    22732273    }
    … …  
    22812281    {
    22822282        AssertMsgFailed(("Only one apic device is supported!\n"));
    2283         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2283        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    22842284        return VERR_INVALID_PARAMETER;
    22852285    }
    … …  
    22902290    if (pApicReg->pszGetInterruptRC)
    22912291    {
    2292         int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszGetInterruptRC, &pVM->pdm.s.Apic.pfnGetInterruptRC);
    2293         AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszGetInterruptRC, rc));
     2292        int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszGetInterruptRC, &pVM->pdm.s.Apic.pfnGetInterruptRC);
     2293        AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszGetInterruptRC, rc));
    22942294        if (RT_SUCCESS(rc))
    22952295        {
    2296             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszHasPendingIrqRC, &pVM->pdm.s.Apic.pfnHasPendingIrqRC);
    2297             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszHasPendingIrqRC, rc));
     2296            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszHasPendingIrqRC, &pVM->pdm.s.Apic.pfnHasPendingIrqRC);
     2297            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszHasPendingIrqRC, rc));
    22982298        }
    22992299        if (RT_SUCCESS(rc))
    23002300        {
    2301             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszSetBaseRC, &pVM->pdm.s.Apic.pfnSetBaseRC);
    2302             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszSetBaseRC, rc));
     2301            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszSetBaseRC, &pVM->pdm.s.Apic.pfnSetBaseRC);
     2302            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszSetBaseRC, rc));
    23032303        }
    23042304        if (RT_SUCCESS(rc))
    23052305        {
    2306             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszGetBaseRC, &pVM->pdm.s.Apic.pfnGetBaseRC);
    2307             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszGetBaseRC, rc));
     2306            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszGetBaseRC, &pVM->pdm.s.Apic.pfnGetBaseRC);
     2307            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszGetBaseRC, rc));
    23082308        }
    23092309        if (RT_SUCCESS(rc))
    23102310        {
    2311             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszSetTPRRC, &pVM->pdm.s.Apic.pfnSetTPRRC);
    2312             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszSetTPRRC, rc));
     2311            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszSetTPRRC, &pVM->pdm.s.Apic.pfnSetTPRRC);
     2312            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszSetTPRRC, rc));
    23132313        }
    23142314        if (RT_SUCCESS(rc))
    23152315        {
    2316             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszGetTPRRC, &pVM->pdm.s.Apic.pfnGetTPRRC);
    2317             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszGetTPRRC, rc));
     2316            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszGetTPRRC, &pVM->pdm.s.Apic.pfnGetTPRRC);
     2317            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszGetTPRRC, rc));
    23182318        }
    23192319        if (RT_SUCCESS(rc))
    23202320        {
    2321             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszWriteMSRRC, &pVM->pdm.s.Apic.pfnWriteMSRRC);
    2322             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszWriteMSRRC, rc));
     2321            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszWriteMSRRC, &pVM->pdm.s.Apic.pfnWriteMSRRC);
     2322            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszWriteMSRRC, rc));
    23232323        }
    23242324        if (RT_SUCCESS(rc))
    23252325        {
    2326             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszReadMSRRC, &pVM->pdm.s.Apic.pfnReadMSRRC);
    2327             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszReadMSRRC, rc));
     2326            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszReadMSRRC, &pVM->pdm.s.Apic.pfnReadMSRRC);
     2327            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszReadMSRRC, rc));
    23282328        }
    23292329        if (RT_SUCCESS(rc))
    23302330        {
    2331             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszBusDeliverRC, &pVM->pdm.s.Apic.pfnBusDeliverRC);
    2332             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszBusDeliverRC, rc));
     2331            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszBusDeliverRC, &pVM->pdm.s.Apic.pfnBusDeliverRC);
     2332            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszBusDeliverRC, rc));
    23332333        }
    23342334        if (RT_SUCCESS(rc))
    23352335        {
    2336             rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pApicReg->pszLocalInterruptRC, &pVM->pdm.s.Apic.pfnLocalInterruptRC);
    2337             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pApicReg->pszLocalInterruptRC, rc));
     2336            rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pApicReg->pszLocalInterruptRC, &pVM->pdm.s.Apic.pfnLocalInterruptRC);
     2337            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pApicReg->pszLocalInterruptRC, rc));
    23382338        }
    23392339        if (RT_FAILURE(rc))
    23402340        {
    2341             LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2341            LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    23422342            return rc;
    23432343        }
    … …  
    23642364    if (pApicReg->pszGetInterruptR0)
    23652365    {
    2366         int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszGetInterruptR0, &pVM->pdm.s.Apic.pfnGetInterruptR0);
    2367         AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszGetInterruptR0, rc));
     2366        int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszGetInterruptR0, &pVM->pdm.s.Apic.pfnGetInterruptR0);
     2367        AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszGetInterruptR0, rc));
    23682368        if (RT_SUCCESS(rc))
    23692369        {
    2370             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszHasPendingIrqR0, &pVM->pdm.s.Apic.pfnHasPendingIrqR0);
    2371             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszHasPendingIrqR0, rc));
     2370            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszHasPendingIrqR0, &pVM->pdm.s.Apic.pfnHasPendingIrqR0);
     2371            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszHasPendingIrqR0, rc));
    23722372        }
    23732373        if (RT_SUCCESS(rc))
    23742374        {
    2375             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszSetBaseR0, &pVM->pdm.s.Apic.pfnSetBaseR0);
    2376             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszSetBaseR0, rc));
     2375            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszSetBaseR0, &pVM->pdm.s.Apic.pfnSetBaseR0);
     2376            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszSetBaseR0, rc));
    23772377        }
    23782378        if (RT_SUCCESS(rc))
    23792379        {
    2380             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszGetBaseR0, &pVM->pdm.s.Apic.pfnGetBaseR0);
    2381             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszGetBaseR0, rc));
     2380            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszGetBaseR0, &pVM->pdm.s.Apic.pfnGetBaseR0);
     2381            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszGetBaseR0, rc));
    23822382        }
    23832383        if (RT_SUCCESS(rc))
    23842384        {
    2385             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszSetTPRR0, &pVM->pdm.s.Apic.pfnSetTPRR0);
    2386             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszSetTPRR0, rc));
     2385            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszSetTPRR0, &pVM->pdm.s.Apic.pfnSetTPRR0);
     2386            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszSetTPRR0, rc));
    23872387        }
    23882388        if (RT_SUCCESS(rc))
    23892389        {
    2390             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszGetTPRR0, &pVM->pdm.s.Apic.pfnGetTPRR0);
    2391             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszGetTPRR0, rc));
     2390            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszGetTPRR0, &pVM->pdm.s.Apic.pfnGetTPRR0);
     2391            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszGetTPRR0, rc));
    23922392        }
    23932393        if (RT_SUCCESS(rc))
    23942394        {
    2395             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszWriteMSRR0, &pVM->pdm.s.Apic.pfnWriteMSRR0);
    2396             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszWriteMSRR0, rc));
     2395            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszWriteMSRR0, &pVM->pdm.s.Apic.pfnWriteMSRR0);
     2396            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszWriteMSRR0, rc));
    23972397        }
    23982398        if (RT_SUCCESS(rc))
    23992399        {
    2400             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszReadMSRR0, &pVM->pdm.s.Apic.pfnReadMSRR0);
    2401             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszReadMSRR0, rc));
     2400            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszReadMSRR0, &pVM->pdm.s.Apic.pfnReadMSRR0);
     2401            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszReadMSRR0, rc));
    24022402        }
    24032403        if (RT_SUCCESS(rc))
    24042404        {
    2405             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszBusDeliverR0, &pVM->pdm.s.Apic.pfnBusDeliverR0);
    2406             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszBusDeliverR0, rc));
     2405            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszBusDeliverR0, &pVM->pdm.s.Apic.pfnBusDeliverR0);
     2406            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszBusDeliverR0, rc));
    24072407        }
    24082408        if (RT_SUCCESS(rc))
    24092409        {
    2410             rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pApicReg->pszLocalInterruptR0, &pVM->pdm.s.Apic.pfnLocalInterruptR0);
    2411             AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pApicReg->pszLocalInterruptR0, rc));
     2410            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pApicReg->pszLocalInterruptR0, &pVM->pdm.s.Apic.pfnLocalInterruptR0);
     2411            AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pApicReg->pszLocalInterruptR0, rc));
    24122412        }
    24132413        if (RT_FAILURE(rc))
    24142414        {
    2415             LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2415            LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    24162416            return rc;
    24172417        }
    … …  
    24482448    pVM->pdm.s.Apic.pfnBusDeliverR3     = pApicReg->pfnBusDeliverR3;
    24492449    pVM->pdm.s.Apic.pfnLocalInterruptR3 = pApicReg->pfnLocalInterruptR3;
    2450     Log(("PDM: Registered APIC device '%s'/%d pDevIns=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2450    Log(("PDM: Registered APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
    24512451
    24522452    /* set the helper pointer and return. */
    24532453    *ppApicHlpR3 = &g_pdmR3DevApicHlp;
    2454     LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2454    LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
    24552455    return VINF_SUCCESS;
    24562456}
    … …  
    24632463    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    24642464    LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppIoApicHlpR3=%p\n",
    2465              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
     2465             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
    24662466             pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqR0, pIoApicReg->pszSetIrqR0, ppIoApicHlpR3));
    24672467
    … …  
    24722472    {
    24732473        AssertMsgFailed(("u32Version=%#x expected %#x\n", pIoApicReg->u32Version, PDM_IOAPICREG_VERSION));
    2474         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2474        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    24752475        return VERR_INVALID_PARAMETER;
    24762476    }
    … …  
    24782478    {
    24792479        Assert(pIoApicReg->pfnSetIrqR3);
    2480         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2480        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    24812481        return VERR_INVALID_PARAMETER;
    24822482    }
    … …  
    24852485    {
    24862486        Assert(VALID_PTR(pIoApicReg->pszSetIrqRC));
    2487         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2487        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    24882488        return VERR_INVALID_PARAMETER;
    24892489    }
    … …  
    24922492    {
    24932493        Assert(VALID_PTR(pIoApicReg->pszSetIrqR0));
    2494         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2494        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    24952495        return VERR_INVALID_PARAMETER;
    24962496    }
    … …  
    24982498    {
    24992499        Assert(ppIoApicHlpR3);
    2500         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (ppApicHlp)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2500        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (ppApicHlp)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    25012501        return VERR_INVALID_PARAMETER;
    25022502    }
    … …  
    25102510    {
    25112511        AssertMsgFailed(("Configuration error / Init order error! No APIC!\n"));
    2512         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no APIC)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2512        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no APIC)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    25132513        return VERR_INVALID_PARAMETER;
    25142514    }
    … …  
    25172517    {
    25182518        AssertMsgFailed(("Configuration error! APIC doesn't do GC, I/O APIC does!\n"));
    2519         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no GC APIC)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2519        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no GC APIC)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    25202520        return VERR_INVALID_PARAMETER;
    25212521    }
    … …  
    25272527    {
    25282528        AssertMsgFailed(("Only one ioapic device is supported!\n"));
    2529         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (only one)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2529        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (only one)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    25302530        return VERR_INVALID_PARAMETER;
    25312531    }
    … …  
    25362536    if (pIoApicReg->pszSetIrqRC)
    25372537    {
    2538         int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pDevReg->szRCMod, pIoApicReg->pszSetIrqRC, &pVM->pdm.s.IoApic.pfnSetIrqRC);
    2539         AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szRCMod, pIoApicReg->pszSetIrqRC, rc));
     2538        int rc = PDMR3LdrGetSymbolRCLazy(pVM, pDevIns->pReg->szRCMod, pIoApicReg->pszSetIrqRC, &pVM->pdm.s.IoApic.pfnSetIrqRC);
     2539        AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szRCMod, pIoApicReg->pszSetIrqRC, rc));
    25402540        if (RT_FAILURE(rc))
    25412541        {
    2542             LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2542            LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    25432543            return rc;
    25442544        }
    … …  
    25562556    if (pIoApicReg->pszSetIrqR0)
    25572557    {
    2558         int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pDevReg->szR0Mod, pIoApicReg->pszSetIrqR0, &pVM->pdm.s.IoApic.pfnSetIrqR0);
    2559         AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pDevReg->szR0Mod, pIoApicReg->pszSetIrqR0, rc));
     2558        int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pDevIns->pReg->szR0Mod, pIoApicReg->pszSetIrqR0, &pVM->pdm.s.IoApic.pfnSetIrqR0);
     2559        AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->szR0Mod, pIoApicReg->pszSetIrqR0, rc));
    25602560        if (RT_FAILURE(rc))
    25612561        {
    2562             LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2562            LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    25632563            return rc;
    25642564        }
    … …  
    25772577    pVM->pdm.s.IoApic.pDevInsR3   = pDevIns;
    25782578    pVM->pdm.s.IoApic.pfnSetIrqR3 = pIoApicReg->pfnSetIrqR3;
    2579     Log(("PDM: Registered I/O APIC device '%s'/%d pDevIns=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2579    Log(("PDM: Registered I/O APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
    25802580
    25812581    /* set the helper pointer and return. */
    25822582    *ppIoApicHlpR3 = &g_pdmR3DevIoApicHlp;
    2583     LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2583    LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
    25842584    return VINF_SUCCESS;
    25852585}
    … …  
    25992599    {
    26002600        AssertMsgFailed(("u32Version=%#x expected %#x\n", pHpetReg->u32Version, PDM_HPETREG_VERSION));
    2601         LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2601        LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26022602        return VERR_INVALID_PARAMETER;
    26032603    }
    … …  
    26062606    {
    26072607        Assert(ppHpetHlpR3);
    2608         LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2608        LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26092609        return VERR_INVALID_PARAMETER;
    26102610    }
    … …  
    26122612    /* set the helper pointer and return. */
    26132613    *ppHpetHlpR3 = &g_pdmR3DevHpetHlp;
    2614     LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2614    LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
    26152615    return VINF_SUCCESS;
    26162616}
    … …  
    26232623    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    26242624    LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: pDmacReg=%p:{.u32Version=%#x, .pfnRun=%p, .pfnRegister=%p, .pfnReadMemory=%p, .pfnWriteMemory=%p, .pfnSetDREQ=%p, .pfnGetChannelMode=%p} ppDmacHlp=%p\n",
    2625              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
     2625             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
    26262626             pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
    26272627
    … …  
    26342634                         PDM_DMACREG_VERSION));
    26352635        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (version)\n",
    2636                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2636                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26372637        return VERR_INVALID_PARAMETER;
    26382638    }
    … …  
    26512651        Assert(pDmacReg->pfnGetChannelMode);
    26522652        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
    2653                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2653                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26542654        return VERR_INVALID_PARAMETER;
    26552655    }
    … …  
    26592659        Assert(ppDmacHlp);
    26602660        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (ppDmacHlp)\n",
    2661                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2661                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26622662        return VERR_INVALID_PARAMETER;
    26632663    }
    … …  
    26712671        AssertMsgFailed(("Only one DMA device is supported!\n"));
    26722672        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
    2673                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2673                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26742674        return VERR_INVALID_PARAMETER;
    26752675    }
    … …  
    26892689        *ppDmacHlp = &g_pdmR3DevDmacHlp;
    26902690        Log(("PDM: Registered DMAC device '%s'/%d pDevIns=%p\n",
    2691              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2691             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
    26922692    }
    26932693    else
    … …  
    26952695
    26962696    LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
    2697              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2697             pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    26982698    return rc;
    26992699}
    … …  
    27332733    VM_ASSERT_EMT(pVM);
    27342734    LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: VM_FF_RESET %d -> 1\n",
    2735              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_RESET)));
     2735             pDevIns->pReg->szDeviceName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_RESET)));
    27362736
    27372737    /*
    … …  
    27532753    }
    27542754
    2755     LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2755    LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    27562756    return rc;
    27572757}
    … …  
    27662766    VM_ASSERT_EMT(pVM);
    27672767    LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
    2768              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2768             pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    27692769
    27702770    if (pVM->cCpus > 1)
    … …  
    27782778        rc = VMR3Suspend(pVM);
    27792779
    2780     LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2780    LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    27812781    return rc;
    27822782}
    … …  
    27912791    VM_ASSERT_EMT(pVM);
    27922792    LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
    2793              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2793             pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    27942794
    27952795    if (pVM->cCpus > 1)
    … …  
    28072807        rc = VMR3PowerOff(pVM);
    28082808
    2809     LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     2809    LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    28102810    return rc;
    28112811}
    … …  
    28202820    bool fRc = PGMPhysIsA20Enabled(VMMGetCpu(pDevIns->Internal.s.pVMR3));
    28212821
    2822     LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, fRc));
     2822    LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, fRc));
    28232823    return fRc;
    28242824}
    … …  
    28302830    PDMDEV_ASSERT_DEVINS(pDevIns);
    28312831    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    2832     LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, fEnable));
     2832    LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, fEnable));
    28332833    PGMR3PhysSetA20(VMMGetCpu(pDevIns->Internal.s.pVMR3), fEnable);
    28342834}
    … …  
    28432843
    28442844    LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
    2845              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
     2845             pDevIns->pReg->szDeviceName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
    28462846    AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
    28472847
    … …  
    28492849
    28502850    LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - *pEax=%#x *pEbx=%#x *pEcx=%#x *pEdx=%#x\n",
    2851              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, *pEax, *pEbx, *pEcx, *pEdx));
     2851             pDevIns->pReg->szDeviceName, pDevIns->iInstance, *pEax, *pEbx, *pEcx, *pEdx));
    28522852}
    28532853
    … …  
    29622962{
    29632963    PDMDEV_ASSERT_DEVINS(pDevIns);
    2964     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2964    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    29652965    return NULL;
    29662966}
    … …  
    29712971{
    29722972    PDMDEV_ASSERT_DEVINS(pDevIns);
    2973     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2973    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    29742974    return NULL;
    29752975}
    … …  
    29802980{
    29812981    PDMDEV_ASSERT_DEVINS(pDevIns);
    2982     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2982    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    29832983    return VERR_ACCESS_DENIED;
    29842984}
    … …  
    29892989{
    29902990    PDMDEV_ASSERT_DEVINS(pDevIns);
    2991     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2991    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    29922992    return VERR_ACCESS_DENIED;
    29932993}
    … …  
    29982998{
    29992999    PDMDEV_ASSERT_DEVINS(pDevIns);
    3000     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     3000    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    30013001    return VERR_ACCESS_DENIED;
    30023002}
    … …  
    30073007{
    30083008    PDMDEV_ASSERT_DEVINS(pDevIns);
    3009     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     3009    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    30103010    return VERR_ACCESS_DENIED;
    30113011}
    … …  
    30163016{
    30173017    PDMDEV_ASSERT_DEVINS(pDevIns);
    3018     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     3018    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    30193019    return VERR_ACCESS_DENIED;
    30203020}
    … …  
    30253025{
    30263026    PDMDEV_ASSERT_DEVINS(pDevIns);
    3027     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     3027    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    30283028    return false;
    30293029}
    … …  
    30343034{
    30353035    PDMDEV_ASSERT_DEVINS(pDevIns);
    3036     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     3036    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    30373037    NOREF(fEnable);
    30383038}
    … …  
    30443044{
    30453045    PDMDEV_ASSERT_DEVINS(pDevIns);
    3046     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     3046    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    30473047}
    30483048

  • trunk/src/VBox/VMM/PDMDevMiscHlp.cpp

    r26152 r26160  
    5252    {
    5353        LogFlow(("pdmR3PicHlp_SetInterruptFF: caller='%s'/%d: Setting local interrupt on LAPIC\n",
    54                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     54                 pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    5555        /* Raise the LAPIC's LINT0 line instead of signaling the CPU directly. */
    5656        pVM->pdm.s.Apic.pfnLocalInterruptR3(pVM->pdm.s.Apic.pDevInsR3, 0, 1);
    … …  
    6161
    6262    LogFlow(("pdmR3PicHlp_SetInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT_PIC %d -> 1\n",
    63              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC)));
     63             pDevIns->pReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC)));
    6464
    6565    VMCPU_FF_SET(pVCpu, VMCPU_FF_INTERRUPT_PIC);
    … …  
    8080        /* Raise the LAPIC's LINT0 line instead of signaling the CPU directly. */
    8181        LogFlow(("pdmR3PicHlp_ClearInterruptFF: caller='%s'/%d: Clearing local interrupt on LAPIC\n",
    82                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     82                 pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    8383        /* Lower the LAPIC's LINT0 line instead of signaling the CPU directly. */
    8484        pVM->pdm.s.Apic.pfnLocalInterruptR3(pVM->pdm.s.Apic.pDevInsR3, 0, 0);
    … …  
    8787
    8888    LogFlow(("pdmR3PicHlp_ClearInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT_PIC %d -> 0\n",
    89              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC)));
     89             pDevIns->pReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC)));
    9090
    9191    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_PIC);
    … …  
    120120    AssertRelease(pRCHelpers);
    121121    LogFlow(("pdmR3PicHlp_GetRCHelpers: caller='%s'/%d: returns %RRv\n",
    122              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     122             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
    123123    return pRCHelpers;
    124124}
    … …  
    135135    AssertRelease(pR0Helpers);
    136136    LogFlow(("pdmR3PicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    137              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     137             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
    138138    return pR0Helpers;
    139139}
    … …  
    174174
    175175    LogFlow(("pdmR3ApicHlp_SetInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT(%d) %d -> 1\n",
    176              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, idCpu, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC)));
     176             pDevIns->pReg->szDeviceName, pDevIns->iInstance, idCpu, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC)));
    177177
    178178    switch (enmType)
    … …  
    209209
    210210    LogFlow(("pdmR3ApicHlp_ClearInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT(%d) %d -> 0\n",
    211              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, idCpu, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC)));
     211             pDevIns->pReg->szDeviceName, pDevIns->iInstance, idCpu, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC)));
    212212
    213213    /* Note: NMI/SMI can't be cleared. */
    … …  
    233233    PDMDEV_ASSERT_DEVINS(pDevIns);
    234234    LogFlow(("pdmR3ApicHlp_ChangeFeature: caller='%s'/%d: version=%d\n",
    235              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, (int)enmVersion));
     235             pDevIns->pReg->szDeviceName, pDevIns->iInstance, (int)enmVersion));
    236236    switch (enmVersion)
    237237    {
    … …  
    288288    AssertRelease(pRCHelpers);
    289289    LogFlow(("pdmR3ApicHlp_GetRCHelpers: caller='%s'/%d: returns %RRv\n",
    290              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     290             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
    291291    return pRCHelpers;
    292292}
    … …  
    303303    AssertRelease(pR0Helpers);
    304304    LogFlow(("pdmR3ApicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    305              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     305             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
    306306    return pR0Helpers;
    307307}
    … …  
    312312{
    313313    PDMDEV_ASSERT_DEVINS(pDevIns);
    314     LogFlow(("pdmR3ApicHlp_Lock: caller='%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     314    LogFlow(("pdmR3ApicHlp_Lock: caller='%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    315315    return &pDevIns->Internal.s.pVMR3->pdm.s.CritSect;
    316316}
    … …  
    323323    PVM pVM = pDevIns->Internal.s.pVMR3;
    324324    RTRCPTR RCPtr = MMHyperCCToRC(pVM, &pVM->pdm.s.CritSect);
    325     LogFlow(("pdmR3ApicHlp_GetR0CritSect: caller='%s'/%d: return %RRv\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, RCPtr));
     325    LogFlow(("pdmR3ApicHlp_GetR0CritSect: caller='%s'/%d: return %RRv\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, RCPtr));
    326326    return RCPtr;
    327327}
    … …  
    334334    PVM pVM = pDevIns->Internal.s.pVMR3;
    335335    RTR0PTR R0Ptr = MMHyperCCToR0(pVM, &pVM->pdm.s.CritSect);
    336     LogFlow(("pdmR3ApicHlp_GetR0CritSect: caller='%s'/%d: return %RHv\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, R0Ptr));
     336    LogFlow(("pdmR3ApicHlp_GetR0CritSect: caller='%s'/%d: return %RHv\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, R0Ptr));
    337337    return R0Ptr;
    338338}
    … …  
    376376    PVM pVM = pDevIns->Internal.s.pVMR3;
    377377    LogFlow(("pdmR3IoApicHlp_ApicBusDeliver: caller='%s'/%d: u8Dest=%RX8 u8DestMode=%RX8 u8DeliveryMode=%RX8 iVector=%RX8 u8Polarity=%RX8 u8TriggerMode=%RX8\n",
    378              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode));
     378             pDevIns->pReg->szDeviceName, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode));
    379379    if (pVM->pdm.s.Apic.pfnBusDeliverR3)
    380380        return pVM->pdm.s.Apic.pfnBusDeliverR3(pVM->pdm.s.Apic.pDevInsR3, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode);
    … …  
    387387{
    388388    PDMDEV_ASSERT_DEVINS(pDevIns);
    389     LogFlow(("pdmR3IoApicHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     389    LogFlow(("pdmR3IoApicHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    390390    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
    391391}
    … …  
    396396{
    397397    PDMDEV_ASSERT_DEVINS(pDevIns);
    398     LogFlow(("pdmR3IoApicHlp_Unlock: caller='%s'/%d:\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     398    LogFlow(("pdmR3IoApicHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    399399    pdmUnlock(pDevIns->Internal.s.pVMR3);
    400400}
    … …  
    411411    AssertRelease(pRCHelpers);
    412412    LogFlow(("pdmR3IoApicHlp_GetRCHelpers: caller='%s'/%d: returns %RRv\n",
    413              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     413             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
    414414    return pRCHelpers;
    415415}
    … …  
    426426    AssertRelease(pR0Helpers);
    427427    LogFlow(("pdmR3IoApicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    428              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     428             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
    429429    return pR0Helpers;
    430430}
    … …  
    487487{
    488488    PDMDEV_ASSERT_DEVINS(pDevIns);
    489     LogFlow(("pdmR3PciHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     489    LogFlow(("pdmR3PciHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    490490    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
    491491}
    … …  
    496496{
    497497    PDMDEV_ASSERT_DEVINS(pDevIns);
    498     LogFlow(("pdmR3PciHlp_Unlock: caller='%s'/%d:\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     498    LogFlow(("pdmR3PciHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    499499    pdmUnlock(pDevIns->Internal.s.pVMR3);
    500500}
    … …  
    511511    AssertRelease(pRCHelpers);
    512512    LogFlow(("pdmR3IoApicHlp_GetGCHelpers: caller='%s'/%d: returns %RRv\n",
    513              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     513             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
    514514    return pRCHelpers;
    515515}
    … …  
    526526    AssertRelease(pR0Helpers);
    527527    LogFlow(("pdmR3IoApicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    528              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     528             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
    529529    return pR0Helpers;
    530530}
    … …  
    560560{
    561561    PDMDEV_ASSERT_DEVINS(pDevIns);
    562     LogFlow(("pdmR3HpetHlp_SetLegacyMode: caller='%s'/%d: fActivate=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, fActivate));
     562    LogFlow(("pdmR3HpetHlp_SetLegacyMode: caller='%s'/%d: fActivate=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, fActivate));
    563563    return 0;
    564564}
    … …  
    569569{
    570570    PDMDEV_ASSERT_DEVINS(pDevIns);
    571     LogFlow(("pdmR3HpetHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     571    LogFlow(("pdmR3HpetHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    572572    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
    573573}
    … …  
    578578{
    579579    PDMDEV_ASSERT_DEVINS(pDevIns);
    580     LogFlow(("pdmR3HpetHlp_Unlock: caller='%s'/%d:\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     580    LogFlow(("pdmR3HpetHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
    581581    pdmUnlock(pDevIns->Internal.s.pVMR3);
    582582}
    … …  
    593593    AssertRelease(pRCHelpers);
    594594    LogFlow(("pdmR3HpetHlp_GetGCHelpers: caller='%s'/%d: returns %RRv\n",
    595              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     595             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
    596596    return pRCHelpers;
    597597}
    … …  
    608608    AssertRelease(pR0Helpers);
    609609    LogFlow(("pdmR3HpetHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    610              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     610             pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
    611611    return pR0Helpers;
    612612}

  • trunk/src/VBox/VMM/PDMDevice.cpp

    r25893 r26160  
    7575*   Internal Functions                                                         *
    7676*******************************************************************************/
    77 static DECLCALLBACK(int)    pdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pDevReg);
     77static DECLCALLBACK(int)    pdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pReg);
    7878static DECLCALLBACK(void *) pdmR3DevReg_MMHeapAlloc(PPDMDEVREGCB pCallbacks, size_t cb);
    7979static int                  pdmR3DevLoadModules(PVM pVM);
    … …  
    188188    {
    189189        /* Get the device name. */
    190         char szName[sizeof(paDevs[0].pDev->pDevReg->szDeviceName)];
     190        char szName[sizeof(paDevs[0].pDev->pReg->szDeviceName)];
    191191        rc = CFGMR3GetName(pCur, szName, sizeof(szName));
    192192        AssertMsgRCReturn(rc, ("Configuration error: device name is too long (or something)! rc=%Rrc\n", rc), rc);
    … …  
    201201        if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    202202        {
    203             uint32_t u32 = pDev->pDevReg->fClass;
     203            uint32_t u32 = pDev->pReg->fClass;
    204204            for (u32Order = 1; !(u32 & u32Order); u32Order <<= 1)
    205205                /* nop */;
    … …  
    230230
    231231        /* check the number of instances */
    232         if (i - iStart > pDev->pDevReg->cMaxInstances)
     232        if (i - iStart > pDev->pReg->cMaxInstances)
    233233            AssertLogRelMsgFailedReturn(("Configuration error: Too many instances of %s was configured: %u, max %u\n",
    234                                          szName, i - iStart, pDev->pDevReg->cMaxInstances),
     234                                         szName, i - iStart, pDev->pReg->cMaxInstances),
    235235                                        VERR_PDM_TOO_MANY_DEVICE_INSTANCES);
    236236    } /* devices */
    … …  
    292292         * Allocate the device instance.
    293293         */
    294         AssertReturn(paDevs[i].pDev->cInstances < paDevs[i].pDev->pDevReg->cMaxInstances, VERR_PDM_TOO_MANY_DEVICE_INSTANCES);
    295         size_t cb = RT_OFFSETOF(PDMDEVINS, achInstanceData[paDevs[i].pDev->pDevReg->cbInstance]);
     294        AssertReturn(paDevs[i].pDev->cInstances < paDevs[i].pDev->pReg->cMaxInstances, VERR_PDM_TOO_MANY_DEVICE_INSTANCES);
     295        size_t cb = RT_OFFSETOF(PDMDEVINS, achInstanceData[paDevs[i].pDev->pReg->cbInstance]);
    296296        cb = RT_ALIGN_Z(cb, 16);
    297297        PPDMDEVINS pDevIns;
    298         if (paDevs[i].pDev->pDevReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0))
     298        if (paDevs[i].pDev->pReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0))
    299299            rc = MMR3HyperAllocOnceNoRel(pVM, cb, 0, MM_TAG_PDM_DEVICE, (void **)&pDevIns);
    300300        else
    … …  
    303303        {
    304304            AssertMsgFailed(("Failed to allocate %d bytes of instance data for device '%s'. rc=%Rrc\n",
    305                              cb, paDevs[i].pDev->pDevReg->szDeviceName, rc));
     305                             cb, paDevs[i].pDev->pReg->szDeviceName, rc));
    306306            return rc;
    307307        }
    … …  
    329329        pDevIns->pDevHlpRC                      = pDevHlpRC;
    330330        pDevIns->pDevHlpR0                      = pDevHlpR0;
    331         pDevIns->pDevReg                        = paDevs[i].pDev->pDevReg;
     331        pDevIns->pReg                           = paDevs[i].pDev->pReg;
    332332        pDevIns->pCfgHandle                     = pConfigNode;
    333333        pDevIns->iInstance                      = paDevs[i].iInstance;
    334334        pDevIns->pvInstanceDataR3               = &pDevIns->achInstanceData[0];
    335         pDevIns->pvInstanceDataRC               = pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_RC
     335        pDevIns->pvInstanceDataRC               = pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC
    336336                                                ? MMHyperR3ToRC(pVM, pDevIns->pvInstanceDataR3) : NIL_RTRCPTR;
    337         pDevIns->pvInstanceDataR0               = pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0
     337        pDevIns->pvInstanceDataR0               = pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0
    338338                                                ? MMHyperR3ToR0(pVM, pDevIns->pvInstanceDataR3) : NIL_RTR0PTR;
    339339
    … …  
    367367         */
    368368        paDevs[i].pDev->cInstances++;
    369         Log(("PDM: Constructing device '%s' instance %d...\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    370         rc = pDevIns->pDevReg->pfnConstruct(pDevIns, pDevIns->iInstance, pDevIns->pCfgHandle);
     369        Log(("PDM: Constructing device '%s' instance %d...\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     370        rc = pDevIns->pReg->pfnConstruct(pDevIns, pDevIns->iInstance, pDevIns->pCfgHandle);
    371371        if (RT_FAILURE(rc))
    372372        {
    373             LogRel(("PDM: Failed to construct '%s'/%d! %Rra\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     373            LogRel(("PDM: Failed to construct '%s'/%d! %Rra\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    374374            paDevs[i].pDev->cInstances--;
    375375            /* because we're damn lazy right now, we'll say that the destructor will be called even if the constructor fails. */
    … …  
    405405    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
    406406    {
    407         if (pDevIns->pDevReg->pfnInitComplete)
    408         {
    409             rc = pDevIns->pDevReg->pfnInitComplete(pDevIns);
     407        if (pDevIns->pReg->pfnInitComplete)
     408        {
     409            rc = pDevIns->pReg->pfnInitComplete(pDevIns);
    410410            if (RT_FAILURE(rc))
    411411            {
    412412                AssertMsgFailed(("InitComplete on device '%s'/%d failed with rc=%Rrc\n",
    413                                  pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
     413                                 pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
    414414                return rc;
    415415            }
    … …  
    438438    for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
    439439        if (    pDev->cchName == cchName
    440             &&  !strcmp(pDev->pDevReg->szDeviceName, pszName))
     440            &&  !strcmp(pDev->pReg->szDeviceName, pszName))
    441441            return pDev;
    442442    return NULL;
    … …  
    602602
    603603/**
    604  * Registers a device with the current VM instance.
    605  *
    606  * @returns VBox status code.
    607  * @param   pCallbacks      Pointer to the callback table.
    608  * @param   pDevReg         Pointer to the device registration record.
    609  *                          This data must be permanent and readonly.
    610  */
    611 static DECLCALLBACK(int) pdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pDevReg)
     604 * @interface_method_impl{PDMDEVREGCB,pfnRegister}
     605 */
     606static DECLCALLBACK(int) pdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pReg)
    612607{
    613608    /*
    614609     * Validate the registration structure.
    615610     */
    616     Assert(pDevReg);
    617     if (pDevReg->u32Version != PDM_DEVREG_VERSION)
    618     {
    619         AssertMsgFailed(("Unknown struct version %#x!\n", pDevReg->u32Version));
     611    Assert(pReg);
     612    if (pReg->u32Version != PDM_DEVREG_VERSION)
     613    {
     614        AssertMsgFailed(("Unknown struct version %#x!\n", pReg->u32Version));
    620615        return VERR_PDM_UNKNOWN_DEVREG_VERSION;
    621616    }
    622     if (    !pDevReg->szDeviceName[0]
    623         ||  strlen(pDevReg->szDeviceName) >= sizeof(pDevReg->szDeviceName))
    624     {
    625         AssertMsgFailed(("Invalid name '%s'\n", pDevReg->szDeviceName));
     617    if (    !pReg->szDeviceName[0]
     618        ||  strlen(pReg->szDeviceName) >= sizeof(pReg->szDeviceName))
     619    {
     620        AssertMsgFailed(("Invalid name '%s'\n", pReg->szDeviceName));
    626621        return VERR_PDM_INVALID_DEVICE_REGISTRATION;
    627622    }
    628     if (    (pDevReg->fFlags & PDM_DEVREG_FLAGS_RC)
    629         &&  (   !pDevReg->szRCMod[0]
    630              || strlen(pDevReg->szRCMod) >= sizeof(pDevReg->szRCMod)))
    631     {
    632         AssertMsgFailed(("Invalid GC module name '%s' - (Device %s)\n", pDevReg->szRCMod, pDevReg->szDeviceName));
     623    if (    (pReg->fFlags & PDM_DEVREG_FLAGS_RC)
     624        &&  (   !pReg->szRCMod[0]
     625             || strlen(pReg->szRCMod) >= sizeof(pReg->szRCMod)))
     626    {
     627        AssertMsgFailed(("Invalid GC module name '%s' - (Device %s)\n", pReg->szRCMod, pReg->szDeviceName));
    633628        return VERR_PDM_INVALID_DEVICE_REGISTRATION;
    634629    }
    635     if (    (pDevReg->fFlags & PDM_DEVREG_FLAGS_R0)
    636         &&  (   !pDevReg->szR0Mod[0]
    637              || strlen(pDevReg->szR0Mod) >= sizeof(pDevReg->szR0Mod)))
    638     {
    639         AssertMsgFailed(("Invalid R0 module name '%s' - (Device %s)\n", pDevReg->szR0Mod, pDevReg->szDeviceName));
     630    if (    (pReg->fFlags & PDM_DEVREG_FLAGS_R0)
     631        &&  (   !pReg->szR0Mod[0]
     632             || strlen(pReg->szR0Mod) >= sizeof(pReg->szR0Mod)))
     633    {
     634        AssertMsgFailed(("Invalid R0 module name '%s' - (Device %s)\n", pReg->szR0Mod, pReg->szDeviceName));
    640635        return VERR_PDM_INVALID_DEVICE_REGISTRATION;
    641636    }
    642     if ((pDevReg->fFlags & PDM_DEVREG_FLAGS_HOST_BITS_MASK) != PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT)
    643     {
    644         AssertMsgFailed(("Invalid host bits flags! fFlags=%#x (Device %s)\n", pDevReg->fFlags, pDevReg->szDeviceName));
     637    if ((pReg->fFlags & PDM_DEVREG_FLAGS_HOST_BITS_MASK) != PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT)
     638    {
     639        AssertMsgFailed(("Invalid host bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szDeviceName));
    645640        return VERR_PDM_INVALID_DEVICE_HOST_BITS;
    646641    }
    647     if (!(pDevReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK))
    648     {
    649         AssertMsgFailed(("Invalid guest bits flags! fFlags=%#x (Device %s)\n", pDevReg->fFlags, pDevReg->szDeviceName));
     642    if (!(pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK))
     643    {
     644        AssertMsgFailed(("Invalid guest bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szDeviceName));
    650645        return VERR_PDM_INVALID_DEVICE_REGISTRATION;
    651646    }
    652     if (!pDevReg->fClass)
    653     {
    654         AssertMsgFailed(("No class! (Device %s)\n", pDevReg->szDeviceName));
     647    if (!pReg->fClass)
     648    {
     649        AssertMsgFailed(("No class! (Device %s)\n", pReg->szDeviceName));
    655650        return VERR_PDM_INVALID_DEVICE_REGISTRATION;
    656651    }
    657     if (pDevReg->cMaxInstances <= 0)
    658     {
    659         AssertMsgFailed(("Max instances %u! (Device %s)\n", pDevReg->cMaxInstances, pDevReg->szDeviceName));
     652    if (pReg->cMaxInstances <= 0)
     653    {
     654        AssertMsgFailed(("Max instances %u! (Device %s)\n", pReg->cMaxInstances, pReg->szDeviceName));
    660655        return VERR_PDM_INVALID_DEVICE_REGISTRATION;
    661656    }
    662     if (pDevReg->cbInstance > (RTUINT)(pDevReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0)  ? 96 * _1K : _1M))
    663     {
    664         AssertMsgFailed(("Instance size %d bytes! (Device %s)\n", pDevReg->cbInstance, pDevReg->szDeviceName));
     657    if (pReg->cbInstance > (RTUINT)(pReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0)  ? 96 * _1K : _1M))
     658    {
     659        AssertMsgFailed(("Instance size %d bytes! (Device %s)\n", pReg->cbInstance, pReg->szDeviceName));
    665660        return VERR_PDM_INVALID_DEVICE_REGISTRATION;
    666661    }
    667     if (!pDevReg->pfnConstruct)
    668     {
    669         AssertMsgFailed(("No constructore! (Device %s)\n", pDevReg->szDeviceName));
     662    if (!pReg->pfnConstruct)
     663    {
     664        AssertMsgFailed(("No constructore! (Device %s)\n", pReg->szDeviceName));
    670665        return VERR_PDM_INVALID_DEVICE_REGISTRATION;
    671666    }
    672667    /* Check matching guest bits last without any asserting. Enables trial and error registration. */
    673     if (!(pDevReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT))
    674     {
    675         Log(("PDM: Rejected device '%s' because it didn't match the guest bits.\n", pDevReg->szDeviceName));
     668    if (!(pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT))
     669    {
     670        Log(("PDM: Rejected device '%s' because it didn't match the guest bits.\n", pReg->szDeviceName));
    676671        return VERR_PDM_INVALID_DEVICE_GUEST_BITS;
    677672    }
    678     AssertLogRelMsg(pDevReg->u32VersionEnd == PDM_DEVREG_VERSION,
     673    AssertLogRelMsg(pReg->u32VersionEnd == PDM_DEVREG_VERSION,
    679674                    ("u32VersionEnd=%#x, expected %#x. (szDeviceName=%s)\n",
    680                      pDevReg->u32VersionEnd, PDM_DEVREG_VERSION, pDevReg->szDeviceName));
     675                     pReg->u32VersionEnd, PDM_DEVREG_VERSION, pReg->szDeviceName));
    681676
    682677    /*
    … …  
    688683    for (; pDev; pDevPrev = pDev, pDev = pDev->pNext)
    689684    {
    690         if (!strcmp(pDev->pDevReg->szDeviceName, pDevReg->szDeviceName))
    691         {
    692             AssertMsgFailed(("Device '%s' already exists\n", pDevReg->szDeviceName));
     685        if (!strcmp(pDev->pReg->szDeviceName, pReg->szDeviceName))
     686        {
     687            AssertMsgFailed(("Device '%s' already exists\n", pReg->szDeviceName));
    693688            return VERR_PDM_DEVICE_NAME_CLASH;
    694689        }
    … …  
    704699        pDev->cInstances = 0;
    705700        pDev->pInstances = NULL;
    706         pDev->pDevReg = pDevReg;
    707         pDev->cchName = (uint32_t)strlen(pDevReg->szDeviceName);
     701        pDev->pReg = pReg;
     702        pDev->cchName = (uint32_t)strlen(pReg->szDeviceName);
    708703
    709704        if (pDevPrev)
    … …  
    711706        else
    712707            pRegCB->pVM->pdm.s.pDevs = pDev;
    713         Log(("PDM: Registered device '%s'\n", pDevReg->szDeviceName));
     708        Log(("PDM: Registered device '%s'\n", pReg->szDeviceName));
    714709        return VINF_SUCCESS;
    715710    }
    … …  
    719714
    720715/**
    721  * Allocate memory which is associated with current VM instance
    722  * and automatically freed on it's destruction.
    723  *
    724  * @returns Pointer to allocated memory. The memory is *NOT* zero-ed.
    725  * @param   pCallbacks      Pointer to the callback table.
    726  * @param   cb              Number of bytes to allocate.
     716 * @interface_method_impl{PDMDEVREGCB,pfnMMHeapAlloc}
    727717 */
    728718static DECLCALLBACK(void *) pdmR3DevReg_MMHeapAlloc(PPDMDEVREGCB pCallbacks, size_t cb)
    … …  
    757747    {
    758748        if (    pDev->cchName == cchDevice
    759             &&  !memcmp(pDev->pDevReg->szDeviceName, pszDevice, cchDevice))
     749            &&  !memcmp(pDev->pReg->szDeviceName, pszDevice, cchDevice))
    760750        {
    761751            /*
    … …  
    818808         */
    819809        PPDMDEVINS pDevIns = pLun->pDevIns;
    820         if (pDevIns->pDevReg->pfnAttach)
     810        if (pDevIns->pReg->pfnAttach)
    821811        {
    822812            if (!pLun->pTop)
    823813            {
    824                 rc = pDevIns->pDevReg->pfnAttach(pDevIns, iLun, fFlags);
     814                rc = pDevIns->pReg->pfnAttach(pDevIns, iLun, fFlags);
    825815            }
    826816            else
    … …  
    904894            /* No, ask the device to attach to the new stuff. */
    905895            PPDMDEVINS pDevIns = pLun->pDevIns;
    906             if (pDevIns->pDevReg->pfnAttach)
     896            if (pDevIns->pReg->pfnAttach)
    907897            {
    908                 rc = pDevIns->pDevReg->pfnAttach(pDevIns, iLun, fFlags);
     898                rc = pDevIns->pReg->pfnAttach(pDevIns, iLun, fFlags);
    909899                if (RT_SUCCESS(rc) && ppBase)
    910900                    *ppBase = pLun->pTop ? &pLun->pTop->IBase : NULL;

  • trunk/src/VBox/VMM/PDMDriver.cpp

    r26151 r26160  
    502502                                 pNew, pDrv->pDrvReg->szDriverName, pNew->iInstance,
    503503                                 pLun->iLun,
    504                                  pLun->pDevIns ? pLun->pDevIns->pDevReg->szDeviceName : pLun->pUsbIns->pUsbReg->szDeviceName,
     504                                 pLun->pDevIns ? pLun->pDevIns->pReg->szDeviceName : pLun->pUsbIns->pUsbReg->szDeviceName,
    505505                                 pLun->pDevIns ? pLun->pDevIns->iInstance             : pLun->pUsbIns->iInstance,
    506506                                 pDrvAbove, pDrvAbove ? pDrvAbove->pDrvReg->szDriverName : "", pDrvAbove ? pDrvAbove->iInstance : -1));
    … …  
    571571    if (pDrvIns->Internal.s.pUp
    572572        ? !pDrvIns->Internal.s.pUp->pDrvReg->pfnDetach
    573         : !pDrvIns->Internal.s.pLun->pDevIns->pDevReg->pfnDetach)
     573        : !pDrvIns->Internal.s.pLun->pDevIns->pReg->pfnDetach)
    574574    {
    575575        AssertMsgFailed(("Cannot detach driver instance because the driver/device above doesn't support it!\n"));
    … …  
    638638            Assert(pLun->pTop == pCur);
    639639            pLun->pTop = NULL;
    640             if (!(fFlags & PDM_TACH_FLAGS_NO_CALLBACKS) && pLun->pDevIns->pDevReg->pfnDetach)
    641                 pLun->pDevIns->pDevReg->pfnDetach(pLun->pDevIns, pLun->iLun, fFlags);
     640            if (!(fFlags & PDM_TACH_FLAGS_NO_CALLBACKS) && pLun->pDevIns->pReg->pfnDetach)
     641                pLun->pDevIns->pReg->pfnDetach(pLun->pDevIns, pLun->iLun, fFlags);
    642642        }
    643643

  • trunk/src/VBox/VMM/PDMInternal.h

    r26112 r26160  
    375375    RTUINT                          cchName;
    376376    /** Registration structure. */
    377     R3PTRTYPE(const struct PDMDEVREG *) pDevReg;
     377    R3PTRTYPE(const struct PDMDEVREG *) pReg;
    378378    /** Number of instances. */
    379379    uint32_t                        cInstances;

  • trunk/src/VBox/VMM/PGMSavedState.cpp

    r26150 r26160  
    627627        pMmio2->idSavedState = id;
    628628        SSMR3PutU8(pSSM, id);
    629         SSMR3PutStrZ(pSSM, pMmio2->pDevInsR3->pDevReg->szDeviceName);
     629        SSMR3PutStrZ(pSSM, pMmio2->pDevInsR3->pReg->szDeviceName);
    630630        SSMR3PutU32(pSSM, pMmio2->pDevInsR3->iInstance);
    631631        SSMR3PutU8(pSSM, pMmio2->iRegion);
    … …  
    698698                &&  pMmio2->iRegion == iRegion
    699699                &&  pMmio2->pDevInsR3->iInstance == uInstance
    700                 &&  !strcmp(pMmio2->pDevInsR3->pDevReg->szDeviceName, szDevName))
     700                &&  !strcmp(pMmio2->pDevInsR3->pReg->szDeviceName, szDevName))
    701701            {
    702702                pMmio2->idSavedState = id;

  • trunk/src/VBox/VMM/testcase/tstVMStructRC.cpp

    r26107 r26160  
    375375    GEN_CHECK_OFF(PDMDEVINS, pDevHlpR3);
    376376    GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR3);
    377     GEN_CHECK_OFF(PDMDEVINS, pDevReg);
     377    GEN_CHECK_OFF(PDMDEVINS, pReg);
    378378    GEN_CHECK_OFF(PDMDEVINS, pCfgHandle);
    379379    GEN_CHECK_OFF(PDMDEVINS, IBase);
Note: See TracChangeset for help on using the changeset viewer.

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