$OpenBSD: patch-cpu_segment_ctrl_pro_cc,v 1.2 2001/03/30 18:53:25 todd Exp $
--- cpu/segment_ctrl_pro.cc.orig	Sat Mar 25 21:39:09 2000
+++ cpu/segment_ctrl_pro.cc	Fri Mar 30 11:29:40 2001
@@ -70,7 +70,7 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
       Bit32u dword1, dword2;
 
       if ((new_value & 0xfffc) == 0) { /* null selector */
-        bx_panic("load_seg_reg: SS: new_value == 0\n");
+        bio->printd("[CPU%u] load_seg_reg: SS: new_value == 0\n", BX_SIM_ID);
         exception(BX_GP_EXCEPTION, 0, 0);
         return;
         }
@@ -83,8 +83,8 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
 
       if (ti == 0) { /* GDT */
         if ((index*8 + 7) > BX_CPU_THIS_PTR gdtr.limit) {
-          bx_panic("load_seg_reg: GDT: %s: index(%04x) > limit(%06x)\n",
-            BX_CPU_THIS_PTR strseg(seg), (unsigned) index, (unsigned) BX_CPU_THIS_PTR gdtr.limit);
+          bio->printd("[CPU%u] load_seg_reg: GDT: %s: index(%04x) > limit(%06x)\n",
+            BX_SIM_ID, BX_CPU_THIS_PTR strseg(seg), (unsigned) index, (unsigned) BX_CPU_THIS_PTR gdtr.limit);
           exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
           return;
           }
@@ -95,12 +95,12 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
         }
       else { /* LDT */
         if (BX_CPU_THIS_PTR ldtr.cache.valid==0) { /* ??? */
-          bx_printf("load_seg_reg: LDT invalid\n");
+          bio->printd("[CPU%u] load_seg_reg: LDT invalid\n", BX_SIM_ID);
           exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
           return;
           }
         if ((index*8 + 7) > BX_CPU_THIS_PTR ldtr.cache.u.ldt.limit) {
-          bx_printf("load_seg_reg ss: LDT: index > limit\n");
+          bio->printd("[CPU%u] load_seg_reg ss: LDT: index > limit\n", BX_SIM_ID);
           exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
           return;
           }
@@ -112,7 +112,7 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
 
       /* selector's RPL must = CPL, else #GP(selector) */
       if (rpl != CPL) {
-        bx_printf("load_seg_reg(): rpl != CPL\n");
+        bio->printd("[CPU%u] load_seg_reg(): rpl != CPL\n", BX_SIM_ID);
         exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
         return;
         }
@@ -120,7 +120,7 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
       parse_descriptor(dword1, dword2, &descriptor);
 
       if (descriptor.valid==0) {
-        bx_printf("load_seg_reg(): valid bit cleared\n");
+        bio->printd("[CPU%u] load_seg_reg(): valid bit cleared\n", BX_SIM_ID);
         exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
         return;
         }
@@ -129,19 +129,19 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
       if ( (descriptor.segment==0) ||
            descriptor.u.segment.executable ||
            descriptor.u.segment.r_w==0 ) {
-        bx_printf("load_seg_reg(): not writable data segment\n");
+        bio->printd("[CPU%u] load_seg_reg(): not writable data segment\n", BX_SIM_ID);
         exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
         }
 
       /* DPL in the AR byte must equal CPL else #GP(selector) */
       if (descriptor.dpl != CPL) {
-        bx_printf("load_seg_reg(): dpl != CPL\n");
+        bio->printd("[CPU%u] load_seg_reg(): dpl != CPL\n", BX_SIM_ID);
         exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
         }
 
       /* segment must be marked PRESENT else #SS(selector) */
       if (descriptor.p == 0) {
-        bx_printf("load_seg_reg(): not present\n");
+        bio->printd("[CPU%u] load_seg_reg(): not present\n", BX_SIM_ID);
         exception(BX_SS_EXCEPTION, new_value & 0xfffc, 0);
         }
 
@@ -197,8 +197,8 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
 
       if (ti == 0) { /* GDT */
         if ((index*8 + 7) > BX_CPU_THIS_PTR gdtr.limit) {
-          bx_printf("load_seg_reg: GDT: %s: index(%04x) > limit(%06x)\n",
-            BX_CPU_THIS_PTR strseg(seg), (unsigned) index, (unsigned) BX_CPU_THIS_PTR gdtr.limit);
+          bio->printd("[CPU%u] load_seg_reg: GDT: %s: index(%04x) > limit(%06x)\n",
+            BX_SIM_ID, BX_CPU_THIS_PTR strseg(seg), (unsigned) index, (unsigned) BX_CPU_THIS_PTR gdtr.limit);
           exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
           return;
           }
@@ -209,12 +209,12 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
         }
       else { /* LDT */
         if (BX_CPU_THIS_PTR ldtr.cache.valid==0) {
-          bx_printf("load_seg_reg: LDT invalid\n");
+          bio->printd("[CPU%u] load_seg_reg: LDT invalid\n", BX_SIM_ID);
           exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
           return;
           }
         if ((index*8 + 7) > BX_CPU_THIS_PTR ldtr.cache.u.ldt.limit) {
-          bx_printf("load_seg_reg ds,es: LDT: index > limit\n");
+          bio->printd("[CPU%u] load_seg_reg ds,es: LDT: index > limit\n", BX_SIM_ID);
           exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
           return;
           }
@@ -227,7 +227,7 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
       parse_descriptor(dword1, dword2, &descriptor);
 
       if (descriptor.valid==0) {
-        bx_printf("load_seg_reg(): valid bit cleared\n");
+        bio->printd("[CPU%u] load_seg_reg(): valid bit cleared\n", BX_SIM_ID);
         exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
         return;
         }
@@ -236,7 +236,7 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
       if ( descriptor.segment==0 ||
            (descriptor.u.segment.executable==1 &&
             descriptor.u.segment.r_w==0) ) {
-        bx_printf("load_seg_reg(): not data or readable code\n");
+        bio->printd("[CPU%u] load_seg_reg(): not data or readable code\n", BX_SIM_ID);
         exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
         return;
         }
@@ -246,7 +246,7 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
       if ( descriptor.u.segment.executable==0 ||
            descriptor.u.segment.c_ed==0 ) {
         if ((rpl > descriptor.dpl) || (CPL > descriptor.dpl)) {
-          bx_printf("load_seg_reg: RPL & CPL must be <= DPL\n");
+          bio->printd("[CPU%u] load_seg_reg: RPL & CPL must be <= DPL\n", BX_SIM_ID);
           exception(BX_GP_EXCEPTION, new_value & 0xfffc, 0);
           return;
           }
@@ -254,7 +254,7 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
 
       /* segment must be marked PRESENT else #NP(selector) */
       if (descriptor.p == 0) {
-        bx_printf("load_seg_reg: segment not present\n");
+        bio->printd("[CPU%u] load_seg_reg: segment not present\n", BX_SIM_ID);
         exception(BX_NP_EXCEPTION, new_value & 0xfffc, 0);
         return;
         }
@@ -281,7 +281,7 @@ BX_CPU_C::load_seg_reg(bx_segment_reg_t 
       return;
       }
     else {
-      bx_panic("load_seg_reg(): invalid segment register passed!\n");
+      bio->panic("[CPU%u] load_seg_reg(): invalid segment register passed!\n", BX_SIM_ID);
       return;
       }
     }
@@ -447,7 +447,7 @@ BX_CPU_C::parse_descriptor(Bit32u dword1
         temp->valid = 1;
         break;
 #endif
-      default: bx_panic("parse_descriptor(): case %d unfinished\n",
+      default: bio->panic("parse_descriptor(): case %d unfinished\n",
                  (unsigned) temp->type);
         temp->valid    = 0;
       }
@@ -465,13 +465,13 @@ BX_CPU_C::load_ldtr(bx_selector_t *selec
     }
 
   if (!descriptor)
-    bx_panic("load_ldtr(): descriptor == NULL!\n");
+    bio->panic("load_ldtr(): descriptor == NULL!\n");
 
   BX_CPU_THIS_PTR ldtr.cache = *descriptor; /* whole structure copy */
   BX_CPU_THIS_PTR ldtr.selector = *selector;
 
   if (BX_CPU_THIS_PTR ldtr.cache.u.ldt.limit < 7) {
-    bx_panic("load_ldtr(): ldtr.limit < 7\n");
+    bio->panic("load_ldtr(): ldtr.limit < 7\n");
     }
 
   BX_CPU_THIS_PTR ldtr.cache.valid = 1;
@@ -500,10 +500,10 @@ BX_CPU_C::load_ss(bx_selector_t *selecto
   BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.rpl = cpl;
 
   if ( (BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].selector.value & 0xfffc) == 0 )
-    bx_panic("load_ss(): null selector passed\n");
+    bio->panic("load_ss(): null selector passed\n");
 
   if ( !BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS].cache.valid ) {
-    bx_panic("load_ss(): invalid selector/descriptor passed.\n");
+    bio->panic("load_ss(): invalid selector/descriptor passed.\n");
     }
 }
 
@@ -516,12 +516,12 @@ BX_CPU_C::fetch_raw_descriptor(bx_select
 {
   if (selector->ti == 0) { /* GDT */
     if ((selector->index*8 + 7) > BX_CPU_THIS_PTR gdtr.limit) {
-bx_printf("-----------------------------------\n");
-bx_printf("selector->index*8 + 7 = %u\n", (unsigned) selector->index*8 + 7);
-bx_printf("gdtr.limit = %u\n", (unsigned) BX_CPU_THIS_PTR gdtr.limit);
-      bx_printf("fetch_raw_descriptor: GDT: index > limit\n");
+bio->printd("-----------------------------------\n");
+bio->printd("selector->index*8 + 7 = %u\n", (unsigned) selector->index*8 + 7);
+bio->printd("gdtr.limit = %u\n", (unsigned) BX_CPU_THIS_PTR gdtr.limit);
+      bio->printd("fetch_raw_descriptor: GDT: index > limit\n");
 debug(BX_CPU_THIS_PTR prev_eip);
-bx_printf("-----------------------------------\n");
+bio->printd("-----------------------------------\n");
       exception(exception_no, selector->value & 0xfffc, 0);
       return;
       }
@@ -532,10 +532,10 @@ bx_printf("-----------------------------
     }
   else { /* LDT */
     if (BX_CPU_THIS_PTR ldtr.cache.valid==0) {
-      bx_panic("fetch_raw_descriptor: LDTR.valid=0\n");
+      bio->panic("fetch_raw_descriptor: LDTR.valid=0\n");
       }
     if ((selector->index*8 + 7) > BX_CPU_THIS_PTR ldtr.cache.u.ldt.limit) {
-      bx_panic("fetch_raw_descriptor: LDT: index > limit\n");
+      bio->printd("fetch_raw_descriptor: LDT: index > limit\n");
       exception(exception_no, selector->value & 0xfffc, 0);
       return;
       }
