vbox的更動 11264 路徑 trunk/src/VBox/Devices/PC

時間撮記:

2008-8-8 下午03:52:17 (16 年 以前)

作者:

vboxsync

訊息:

DevPIC: pData -> pThis.

檔案:

• trunk/src/VBox/Devices/PC/DevPIC.cpp (修改) (39 筆差異)

trunk/src/VBox/Devices/PC/DevPIC.cpp

@@ -153 +153 @@
 static inline void DumpPICState(PicState *s, const char *szFn)
 {
-    PDEVPIC pData = PDMINS_2_DATA(s->CTX_SUFF(pDevIns), PDEVPIC);
+    PDEVPIC pThis = PDMINS_2_DATA(s->CTX_SUFF(pDevIns), PDEVPIC);
 
     Log2(("%s: pic%d: elcr=%x last_irr=%x irr=%x imr=%x isr=%x irq_base=%x\n",
-        szFn, (&pData->aPics[0] == s) ? 0 : 1,
+        szFn, (&pThis->aPics[0] == s) ? 0 : 1,
           s->elcr, s->last_irr, s->irr, s->imr, s->isr, s->irq_base));
 }
 #else
-# define DumpPICState(pData, szFn) do { } while (0)
+# define DumpPICState(pThis, szFn) do { } while (0)
 #endif
 
@@ -240 +240 @@
 /* raise irq to CPU if necessary. must be called every time the active
    irq may change */
-static int pic_update_irq(PDEVPIC pData)
-{
-    PicState *pics = &pData->aPics[0];
+static int pic_update_irq(PDEVPIC pThis)
+{
+    PicState *pics = &pThis->aPics[0];
     int irq2, irq;
 
@@ -271 +271 @@
             Log(("pic: cpu_interrupt\n"));
 #endif
-            pData->CTX_SUFF(pPicHlp)->pfnSetInterruptFF(pData->CTX_SUFF(pDevIns));
+            pThis->CTX_SUFF(pPicHlp)->pfnSetInterruptFF(pThis->CTX_SUFF(pDevIns));
         }
         else
         {
-            STAM_COUNTER_INC(&pData->StatClearedActiveIRQ2);
+            STAM_COUNTER_INC(&pThis->StatClearedActiveIRQ2);
             Log(("pic_update_irq: irq 2 is active, but no interrupt is pending on the slave pic!!\n"));
             /* Clear it here, so lower priority interrupts can still be dispatched. */
 
             /* if this was the only pending irq, then we must clear the interrupt ff flag */
-            pData->CTX_SUFF(pPicHlp)->pfnClearInterruptFF(pData->CTX_SUFF(pDevIns));
+            pThis->CTX_SUFF(pPicHlp)->pfnClearInterruptFF(pThis->CTX_SUFF(pDevIns));
 
             /** @note Is this correct? */
@@ -286 +286 @@
 
             /* Call ourselves again just in case other interrupts are pending */
-            return pic_update_irq(pData);
+            return pic_update_irq(pThis);
         }
     }
@@ -294 +294 @@
 
         /* we must clear the interrupt ff flag */
-        pData->CTX_SUFF(pPicHlp)->pfnClearInterruptFF(pData->CTX_SUFF(pDevIns));
+        pThis->CTX_SUFF(pPicHlp)->pfnClearInterruptFF(pThis->CTX_SUFF(pDevIns));
     }
     return VINF_SUCCESS;
@@ -300 +300 @@
 
 /** @note if an interrupt line state changes from unmasked to masked, then it must be deactivated when currently pending! */
-static void pic_update_imr(PDEVPIC pData, PicState *s, uint8_t val)
+static void pic_update_imr(PDEVPIC pThis, PicState *s, uint8_t val)
 {
     int       irq, intno;
@@ -306 +306 @@
 
     /* Query the current pending irq, if any. */
-    pActivePIC = &pData->aPics[0];
+    pActivePIC = &pThis->aPics[0];
     intno = irq = pic_get_irq(pActivePIC);
     if (irq == 2)
     {
-        pActivePIC = &pData->aPics[1];
+        pActivePIC = &pThis->aPics[1];
         irq = pic_get_irq(pActivePIC);
         intno = irq + 8;
@@ -323 +323 @@
     {
         Log(("pic_update_imr: pic0: elcr=%x last_irr=%x irr=%x imr=%x isr=%x irq_base=%x\n",
-            pData->aPics[0].elcr, pData->aPics[0].last_irr, pData->aPics[0].irr, pData->aPics[0].imr, pData->aPics[0].isr, pData->aPics[0].irq_base));
+            pThis->aPics[0].elcr, pThis->aPics[0].last_irr, pThis->aPics[0].irr, pThis->aPics[0].imr, pThis->aPics[0].isr, pThis->aPics[0].irq_base));
         Log(("pic_update_imr: pic1: elcr=%x last_irr=%x irr=%x imr=%x isr=%x irq_base=%x\n",
-            pData->aPics[1].elcr, pData->aPics[1].last_irr, pData->aPics[1].irr, pData->aPics[1].imr, pData->aPics[1].isr, pData->aPics[1].irq_base));
+            pThis->aPics[1].elcr, pThis->aPics[1].last_irr, pThis->aPics[1].irr, pThis->aPics[1].imr, pThis->aPics[1].isr, pThis->aPics[1].irq_base));
 
         /* Clear pending IRQ 2 on master controller in case of slave interrupt. */
@@ -331 +331 @@
         if (intno > 7)
         {
-            pData->aPics[0].irr &= ~(1 << 2);
-            STAM_COUNTER_INC(&pData->StatClearedActiveSlaveIRQ);
+            pThis->aPics[0].irr &= ~(1 << 2);
+            STAM_COUNTER_INC(&pThis->StatClearedActiveSlaveIRQ);
         }
         else
-            STAM_COUNTER_INC(&pData->StatClearedActiveMasterIRQ);
+            STAM_COUNTER_INC(&pThis->StatClearedActiveMasterIRQ);
 
         Log(("pic_update_imr: clear pending interrupt %d\n", intno));
-        pData->CTX_SUFF(pPicHlp)->pfnClearInterruptFF(pData->CTX_SUFF(pDevIns));
+        pThis->CTX_SUFF(pPicHlp)->pfnClearInterruptFF(pThis->CTX_SUFF(pDevIns));
     }
 }
@@ -352 +352 @@
 PDMBOTHCBDECL(void) picSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
-    PDEVPIC     pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
-    Assert(pData->CTX_SUFF(pDevIns) == pDevIns);
-    Assert(pData->aPics[0].CTX_SUFF(pDevIns) == pDevIns);
-    Assert(pData->aPics[1].CTX_SUFF(pDevIns) == pDevIns);
+    PDEVPIC     pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    Assert(pThis->CTX_SUFF(pDevIns) == pDevIns);
+    Assert(pThis->aPics[0].CTX_SUFF(pDevIns) == pDevIns);
+    Assert(pThis->aPics[1].CTX_SUFF(pDevIns) == pDevIns);
     AssertMsg(iIrq < 16, ("iIrq=%d\n", iIrq));
 
     Log(("picSetIrq %d %d\n", iIrq, iLevel));
-    DumpPICState(&pData->aPics[0], "picSetIrq");
-    DumpPICState(&pData->aPics[1], "picSetIrq");
-    STAM_COUNTER_INC(&pData->CTXSUFF(StatSetIrq));
-    pic_set_irq1(&pData->aPics[iIrq >> 3], iIrq & 7, iLevel & PDM_IRQ_LEVEL_HIGH);
-    pic_update_irq(pData);
+    DumpPICState(&pThis->aPics[0], "picSetIrq");
+    DumpPICState(&pThis->aPics[1], "picSetIrq");
+    STAM_COUNTER_INC(&pThis->CTXSUFF(StatSetIrq));
+    pic_set_irq1(&pThis->aPics[iIrq >> 3], iIrq & 7, iLevel & PDM_IRQ_LEVEL_HIGH);
+    pic_update_irq(pThis);
     if ((iLevel & PDM_IRQ_LEVEL_FLIP_FLOP) == PDM_IRQ_LEVEL_FLIP_FLOP)
     {
-        pic_set_irq1(&pData->aPics[iIrq >> 3], iIrq & 7, 0);
-        pic_update_irq(pData);
+        pic_set_irq1(&pThis->aPics[iIrq >> 3], iIrq & 7, 0);
+        pic_update_irq(pThis);
     }
 }
@@ -398 +398 @@
 PDMBOTHCBDECL(int) picGetInterrupt(PPDMDEVINS pDevIns)
 {
-    PDEVPIC     pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    PDEVPIC     pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
     int         irq;
     int         irq2;
@@ -404 +404 @@
 
     /* read the irq from the PIC */
-    DumpPICState(&pData->aPics[0], "picGetInterrupt");
-    DumpPICState(&pData->aPics[1], "picGetInterrupt");
-
-    irq = pic_get_irq(&pData->aPics[0]);
+    DumpPICState(&pThis->aPics[0], "picGetInterrupt");
+    DumpPICState(&pThis->aPics[1], "picGetInterrupt");
+
+    irq = pic_get_irq(&pThis->aPics[0]);
     if (irq >= 0)
     {
-        pic_intack(&pData->aPics[0], irq);
+        pic_intack(&pThis->aPics[0], irq);
         if (irq == 2)
         {
-            irq2 = pic_get_irq(&pData->aPics[1]);
+            irq2 = pic_get_irq(&pThis->aPics[1]);
             if (irq2 >= 0) {
-                pic_intack(&pData->aPics[1], irq2);
+                pic_intack(&pThis->aPics[1], irq2);
             }
             else
@@ -423 +423 @@
                 irq2 = 7;
             }
-            intno = pData->aPics[1].irq_base + irq2;
-            Log2(("picGetInterrupt1: %x base=%x irq=%x\n", intno, pData->aPics[1].irq_base, irq2));
+            intno = pThis->aPics[1].irq_base + irq2;
+            Log2(("picGetInterrupt1: %x base=%x irq=%x\n", intno, pThis->aPics[1].irq_base, irq2));
             irq = irq2 + 8;
         }
         else {
-            intno = pData->aPics[0].irq_base + irq;
-            Log2(("picGetInterrupt0: %x base=%x irq=%x\n", intno, pData->aPics[0].irq_base, irq));
+            intno = pThis->aPics[0].irq_base + irq;
+            Log2(("picGetInterrupt0: %x base=%x irq=%x\n", intno, pThis->aPics[0].irq_base, irq));
         }
     }
@@ -437 +437 @@
         AssertMsgFailed(("picGetInterrupt: spurious IRQ on master controller\n"));
         irq = 7;
-        intno = pData->aPics[0].irq_base + irq;
-    }
-    pic_update_irq(pData);
-
-    Log(("picGetInterrupt: 0x%02x pending 0:%d 1:%d\n", intno, pic_get_irq(&pData->aPics[0]), pic_get_irq(&pData->aPics[1])));
+        intno = pThis->aPics[0].irq_base + irq;
+    }
+    pic_update_irq(pThis);
+
+    Log(("picGetInterrupt: 0x%02x pending 0:%d 1:%d\n", intno, pic_get_irq(&pThis->aPics[0]), pic_get_irq(&pThis->aPics[1])));
 
     return intno;
@@ -467 +467 @@
 {
     PicState *s = (PicState*)opaque;
-    PDEVPIC     pData = PDMINS_2_DATA(s->CTX_SUFF(pDevIns), PDEVPIC);
+    PDEVPIC     pThis = PDMINS_2_DATA(s->CTX_SUFF(pDevIns), PDEVPIC);
     int         rc = VINF_SUCCESS;
     int priority, cmd, irq;
@@ -478 +478 @@
             pic_reset(s);
             /* deassert a pending interrupt */
-            pData->CTX_SUFF(pPicHlp)->pfnClearInterruptFF(pData->CTX_SUFF(pDevIns));
+            pThis->CTX_SUFF(pPicHlp)->pfnClearInterruptFF(pThis->CTX_SUFF(pDevIns));
 
             s->init_state = 1;
@@ -510 +510 @@
                     if (cmd == 5)
                         s->priority_add = (irq + 1) & 7;
-                    rc = pic_update_irq(pData);
+                    rc = pic_update_irq(pThis);
                     Assert(rc == VINF_SUCCESS);
                     DumpPICState(s, "eoi");
@@ -521 +521 @@
                 Log(("pic_write: EOI2 for irq %d\n", irq));
                 s->isr &= ~(1 << irq);
-                rc = pic_update_irq(pData);
+                rc = pic_update_irq(pThis);
                 Assert(rc == VINF_SUCCESS);
                 DumpPICState(s, "eoi2");
@@ -530 +530 @@
                 s->priority_add = (val + 1) & 7;
                 Log(("pic_write: lowest priority %d (highest %d)\n", val & 7, s->priority_add));
-                rc = pic_update_irq(pData);
+                rc = pic_update_irq(pThis);
                 Assert(rc == VINF_SUCCESS);
                 break;
@@ -540 +540 @@
                 s->isr &= ~(1 << irq);
                 s->priority_add = (irq + 1) & 7;
-                rc = pic_update_irq(pData);
+                rc = pic_update_irq(pThis);
                 Assert(rc == VINF_SUCCESS);
                 DumpPICState(s, "eoi3");
@@ -555 +555 @@
         {
             /* normal mode */
-            pic_update_imr(pData, s, val);
-
-            rc = pic_update_irq(pData);
+            pic_update_imr(pThis, s, val);
+
+            rc = pic_update_irq(pThis);
             Assert(rc == VINF_SUCCESS);
             break;
@@ -587 +587 @@
 static uint32_t pic_poll_read (PicState *s, uint32_t addr1)
 {
-    PDEVPIC     pData = PDMINS_2_DATA(s->CTX_SUFF(pDevIns), PDEVPIC);
-    PicState   *pics = &pData->aPics[0];
+    PDEVPIC     pThis = PDMINS_2_DATA(s->CTX_SUFF(pDevIns), PDEVPIC);
+    PicState   *pics = &pThis->aPics[0];
     int ret;
 
@@ -602 +602 @@
         s->isr &= ~(1 << ret);
         if (addr1 >> 7 || ret != 2)
-            pic_update_irq(pData);
+            pic_update_irq(pThis);
     } else {
         ret = 0x07;
-        pic_update_irq(pData);
+        pic_update_irq(pThis);
     }
 
@@ -706 +706 @@
 PDMBOTHCBDECL(int) picIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
 {
-    PDEVPIC     pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    PDEVPIC     pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
     uint32_t    iPic  = (uint32_t)(uintptr_t)pvUser;
 
@@ -713 +713 @@
     {
         int rc;
-        PIC_LOCK(pData, VINF_IOM_HC_IOPORT_READ);
-        *pu32 = pic_ioport_read(&pData->aPics[iPic], Port, &rc);
-        PIC_UNLOCK(pData);
+        PIC_LOCK(pThis, VINF_IOM_HC_IOPORT_READ);
+        *pu32 = pic_ioport_read(&pThis->aPics[iPic], Port, &rc);
+        PIC_UNLOCK(pThis);
         return rc;
     }
@@ -734 +734 @@
 PDMBOTHCBDECL(int) picIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
 {
-    PDEVPIC     pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    PDEVPIC     pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
     uint32_t    iPic  = (uint32_t)(uintptr_t)pvUser;
 
@@ -742 +742 @@
     {
         int rc;
-        PIC_LOCK(pData, VINF_IOM_HC_IOPORT_WRITE);
-        rc = pic_ioport_write(&pData->aPics[iPic], Port, u32);
-        PIC_UNLOCK(pData);
+        PIC_LOCK(pThis, VINF_IOM_HC_IOPORT_WRITE);
+        rc = pic_ioport_write(&pThis->aPics[iPic], Port, u32);
+        PIC_UNLOCK(pThis);
         return rc;
     }
@@ -811 +811 @@
 static DECLCALLBACK(void) picInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    PDEVPIC pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    PDEVPIC pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
 
     /*
@@ -819 +819 @@
     {
         pHlp->pfnPrintf(pHlp, "PIC%d:\n", i);
-        pHlp->pfnPrintf(pHlp, "  last_irr                  = %02x\n", pData->aPics[i].last_irr);
-        pHlp->pfnPrintf(pHlp, "  irr                       = %02x\n", pData->aPics[i].irr);
-        pHlp->pfnPrintf(pHlp, "  imr                       = %02x\n", pData->aPics[i].imr);
-        pHlp->pfnPrintf(pHlp, "  isr                       = %02x\n", pData->aPics[i].isr);
-        pHlp->pfnPrintf(pHlp, "  priority_add              = %02x\n", pData->aPics[i].priority_add);
-        pHlp->pfnPrintf(pHlp, "  irq_base                  = %02x\n", pData->aPics[i].irq_base);
-        pHlp->pfnPrintf(pHlp, "  read_reg_select           = %02x\n", pData->aPics[i].read_reg_select);
-        pHlp->pfnPrintf(pHlp, "  poll                      = %02x\n", pData->aPics[i].poll);
-        pHlp->pfnPrintf(pHlp, "  special_mask              = %02x\n", pData->aPics[i].special_mask);
-        pHlp->pfnPrintf(pHlp, "  init_state                = %02x\n", pData->aPics[i].init_state);
-        pHlp->pfnPrintf(pHlp, "  auto_eoi                  = %02x\n", pData->aPics[i].auto_eoi);
-        pHlp->pfnPrintf(pHlp, "  rotate_on_auto_eoi        = %02x\n", pData->aPics[i].rotate_on_auto_eoi);
-        pHlp->pfnPrintf(pHlp, "  special_fully_nested_mode = %02x\n", pData->aPics[i].special_fully_nested_mode);
-        pHlp->pfnPrintf(pHlp, "  init4                     = %02x\n", pData->aPics[i].init4);
-        pHlp->pfnPrintf(pHlp, "  elcr                      = %02x\n", pData->aPics[i].elcr);
-        pHlp->pfnPrintf(pHlp, "  elcr_mask                 = %02x\n", pData->aPics[i].elcr_mask);
+        pHlp->pfnPrintf(pHlp, "  last_irr                  = %02x\n", pThis->aPics[i].last_irr);
+        pHlp->pfnPrintf(pHlp, "  irr                       = %02x\n", pThis->aPics[i].irr);
+        pHlp->pfnPrintf(pHlp, "  imr                       = %02x\n", pThis->aPics[i].imr);
+        pHlp->pfnPrintf(pHlp, "  isr                       = %02x\n", pThis->aPics[i].isr);
+        pHlp->pfnPrintf(pHlp, "  priority_add              = %02x\n", pThis->aPics[i].priority_add);
+        pHlp->pfnPrintf(pHlp, "  irq_base                  = %02x\n", pThis->aPics[i].irq_base);
+        pHlp->pfnPrintf(pHlp, "  read_reg_select           = %02x\n", pThis->aPics[i].read_reg_select);
+        pHlp->pfnPrintf(pHlp, "  poll                      = %02x\n", pThis->aPics[i].poll);
+        pHlp->pfnPrintf(pHlp, "  special_mask              = %02x\n", pThis->aPics[i].special_mask);
+        pHlp->pfnPrintf(pHlp, "  init_state                = %02x\n", pThis->aPics[i].init_state);
+        pHlp->pfnPrintf(pHlp, "  auto_eoi                  = %02x\n", pThis->aPics[i].auto_eoi);
+        pHlp->pfnPrintf(pHlp, "  rotate_on_auto_eoi        = %02x\n", pThis->aPics[i].rotate_on_auto_eoi);
+        pHlp->pfnPrintf(pHlp, "  special_fully_nested_mode = %02x\n", pThis->aPics[i].special_fully_nested_mode);
+        pHlp->pfnPrintf(pHlp, "  init4                     = %02x\n", pThis->aPics[i].init4);
+        pHlp->pfnPrintf(pHlp, "  elcr                      = %02x\n", pThis->aPics[i].elcr);
+        pHlp->pfnPrintf(pHlp, "  elcr_mask                 = %02x\n", pThis->aPics[i].elcr_mask);
     }
 }
@@ -848 +848 @@
 static DECLCALLBACK(int) picSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
 {
-    PDEVPIC     pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
-    pic_save(pSSMHandle, &pData->aPics[0]);
-    pic_save(pSSMHandle, &pData->aPics[1]);
+    PDEVPIC     pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    pic_save(pSSMHandle, &pThis->aPics[0]);
+    pic_save(pSSMHandle, &pThis->aPics[1]);
     return VINF_SUCCESS;
 }
@@ -865 +865 @@
 static DECLCALLBACK(int) picLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
 {
-    PDEVPIC     pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
-    int rc = pic_load(pSSMHandle, &pData->aPics[0], u32Version);
+    PDEVPIC     pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    int rc = pic_load(pSSMHandle, &pThis->aPics[0], u32Version);
     if (RT_SUCCESS(rc))
-        rc = pic_load(pSSMHandle, &pData->aPics[1], u32Version);
+        rc = pic_load(pSSMHandle, &pThis->aPics[1], u32Version);
     return rc;
 }
@@ -883 +883 @@
 static DECLCALLBACK(void)  picReset(PPDMDEVINS pDevIns)
 {
-    PDEVPIC     pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    PDEVPIC     pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
     unsigned    i;
     LogFlow(("picReset:\n"));
-    pData->pPicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR);
-
-    for (i = 0; i < RT_ELEMENTS(pData->aPics); i++)
-        pic_reset(&pData->aPics[i]);
-
-    PIC_UNLOCK(pData);
+    pThis->pPicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR);
+
+    for (i = 0; i < RT_ELEMENTS(pThis->aPics); i++)
+        pic_reset(&pThis->aPics[i]);
+
+    PIC_UNLOCK(pThis);
 }
 
@@ -900 +900 @@
 static DECLCALLBACK(void) picRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
-    PDEVPIC         pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    PDEVPIC         pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
     unsigned        i;
 
-    pData->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->pPicHlpRC = pData->pPicHlpR3->pfnGetRCHelpers(pDevIns);
-    for (i = 0; i < RT_ELEMENTS(pData->aPics); i++)
-        pData->aPics[i].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->pPicHlpRC = pThis->pPicHlpR3->pfnGetRCHelpers(pDevIns);
+    for (i = 0; i < RT_ELEMENTS(pThis->aPics); i++)
+        pThis->aPics[i].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
 }
 
@@ -915 +915 @@
 static DECLCALLBACK(int)  picConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
 {
-    PDEVPIC         pData = PDMINS_2_DATA(pDevIns, PDEVPIC);
+    PDEVPIC         pThis = PDMINS_2_DATA(pDevIns, PDEVPIC);
     PDMPICREG       PicReg;
     int             rc;
@@ -943 +943 @@
      * Init the data.
      */
-    Assert(RT_ELEMENTS(pData->aPics) == 2);
-    pData->pDevInsR3 = pDevIns;
-    pData->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-    pData->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->aPics[0].elcr_mask = 0xf8;
-    pData->aPics[1].elcr_mask = 0xde;
-    pData->aPics[0].pDevInsR3 = pDevIns;
-    pData->aPics[1].pDevInsR3 = pDevIns;
-    pData->aPics[0].pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-    pData->aPics[1].pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
-    pData->aPics[0].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
-    pData->aPics[1].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    Assert(RT_ELEMENTS(pThis->aPics) == 2);
+    pThis->pDevInsR3 = pDevIns;
+    pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+    pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->aPics[0].elcr_mask = 0xf8;
+    pThis->aPics[1].elcr_mask = 0xde;
+    pThis->aPics[0].pDevInsR3 = pDevIns;
+    pThis->aPics[1].pDevInsR3 = pDevIns;
+    pThis->aPics[0].pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+    pThis->aPics[1].pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
+    pThis->aPics[0].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
+    pThis->aPics[1].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
 
     /*
@@ -986 +986 @@
 
     Assert(pDevIns->pDevHlp->pfnPICRegister);
-    rc = pDevIns->pDevHlp->pfnPICRegister(pDevIns, &PicReg, &pData->pPicHlpR3);
+    rc = pDevIns->pDevHlp->pfnPICRegister(pDevIns, &PicReg, &pThis->pPicHlpR3);
     AssertLogRelMsgRCReturn(rc, ("PICRegister -> %Vrc\n", rc), rc);
     if (fGCEnabled)
-        pData->pPicHlpRC = pData->pPicHlpR3->pfnGetRCHelpers(pDevIns);
+        pThis->pPicHlpRC = pThis->pPicHlpR3->pfnGetRCHelpers(pDevIns);
     if (fR0Enabled)
-        pData->pPicHlpR0 = pData->pPicHlpR3->pfnGetR0Helpers(pDevIns);
+        pThis->pPicHlpR0 = pThis->pPicHlpR3->pfnGetR0Helpers(pDevIns);
 
 
@@ -1022 +1022 @@
     }
 
-    rc = PDMDevHlpIOPortRegister(pDevIns, 0x4d0, 1, &pData->aPics[0],
+    rc = PDMDevHlpIOPortRegister(pDevIns, 0x4d0, 1, &pThis->aPics[0],
                                  picIOPortElcrWrite, picIOPortElcrRead, NULL, NULL, "i8259 PIC #0 - elcr");
     if (RT_FAILURE(rc))
         return rc;
-    rc = PDMDevHlpIOPortRegister(pDevIns, 0x4d1, 1, &pData->aPics[1],
+    rc = PDMDevHlpIOPortRegister(pDevIns, 0x4d1, 1, &pThis->aPics[1],
                                  picIOPortElcrWrite, picIOPortElcrRead, NULL, NULL, "i8259 PIC #1 - elcr");
     if (RT_FAILURE(rc))
@@ -1055 +1055 @@
     }
 
-    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */, sizeof(*pData),
+    rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */, sizeof(*pThis),
                               NULL, picSaveExec, NULL,
                               NULL, picLoadExec, NULL);
@@ -1078 +1078 @@
      * Statistics.
      */
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatSetIrqGC, STAMTYPE_COUNTER, "/PDM/PIC/SetIrqGC", STAMUNIT_OCCURENCES, "Number of PIC SetIrq calls in GC.");
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatSetIrqHC, STAMTYPE_COUNTER, "/PDM/PIC/SetIrqHC", STAMUNIT_OCCURENCES, "Number of PIC SetIrq calls in HC.");
-
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatClearedActiveIRQ2,       STAMTYPE_COUNTER, "/PDM/PIC/Masked/ActiveIRQ2",   STAMUNIT_OCCURENCES, "Number of cleared irq 2.");
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatClearedActiveMasterIRQ,  STAMTYPE_COUNTER, "/PDM/PIC/Masked/ActiveMaster", STAMUNIT_OCCURENCES, "Number of cleared master irqs.");
-    PDMDevHlpSTAMRegister(pDevIns, &pData->StatClearedActiveSlaveIRQ,   STAMTYPE_COUNTER, "/PDM/PIC/Masked/ActiveSlave",  STAMUNIT_OCCURENCES, "Number of cleared slave irqs.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatSetIrqGC, STAMTYPE_COUNTER, "/PDM/PIC/SetIrqGC", STAMUNIT_OCCURENCES, "Number of PIC SetIrq calls in GC.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatSetIrqHC, STAMTYPE_COUNTER, "/PDM/PIC/SetIrqHC", STAMUNIT_OCCURENCES, "Number of PIC SetIrq calls in HC.");
+
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatClearedActiveIRQ2,       STAMTYPE_COUNTER, "/PDM/PIC/Masked/ActiveIRQ2",   STAMUNIT_OCCURENCES, "Number of cleared irq 2.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatClearedActiveMasterIRQ,  STAMTYPE_COUNTER, "/PDM/PIC/Masked/ActiveMaster", STAMUNIT_OCCURENCES, "Number of cleared master irqs.");
+    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatClearedActiveSlaveIRQ,   STAMTYPE_COUNTER, "/PDM/PIC/Masked/ActiveSlave",  STAMUNIT_OCCURENCES, "Number of cleared slave irqs.");
 #endif