Changeset 10105

Timestamp:

Jul 18, 2008, 8:55:27 PM (13 years ago)

Author:

rme

Message:

Changes for x8632.

File:

• trunk/source/lisp-kernel/x86-gc.c (modified) (47 diffs)

trunk/source/lisp-kernel/x86-gc.c

@@ -43 +43 @@
   case fulltag_even_fixnum:
   case fulltag_odd_fixnum:
+#ifdef X8632
+  case fulltag_imm:
+#endif
+#ifdef X8664
   case fulltag_imm_0:
   case fulltag_imm_1:
+#endif
     return;
 
+#ifdef X8664
   case fulltag_nil:
     if (n != lisp_nil) {
@@ -52 +58 @@
     }
     return;
-
-
+#endif
+
+#ifdef X8632
+  case fulltag_nodeheader:
+  case fulltag_immheader:
+#endif
+#ifdef X8664
   case fulltag_nodeheader_0: 
   case fulltag_nodeheader_1: 
@@ -59 +70 @@
   case fulltag_immheader_1: 
   case fulltag_immheader_2: 
+#endif
     Bug(NULL, "Header not expected : 0x%lx", n);
     return;
 
+#ifdef X8632
+  case fulltag_tra:
+#endif
+#ifdef X8664
   case fulltag_tra_0:
   case fulltag_tra_1:
+#endif
     a = heap_area_containing((BytePtr)ptr_from_lispobj(n));
     if (a == NULL) {
@@ -76 +93 @@
        check the function it (should) identify.
     */
+#ifdef X8632
+    {
+      LispObj fun = 0;
+
+      if (*(unsigned char *)n == RECOVER_FN_OPCODE)
+        fun = *(LispObj *)(n + 1);
+      if (fun == 0 ||
+         (header_subtag(header_of(fun)) != subtag_function) ||
+         (heap_area_containing((BytePtr)ptr_from_lispobj(fun)) != a)) {
+        Bug(NULL, "TRA at 0x%x has bad function address 0x%x\n", n, fun);
+      }
+      n = fun;
+    }
+#endif
+#ifdef X8664
     {
       int disp = 0;
@@ -91 +123 @@
       }
     }
+#endif
     /* Otherwise, fall through and check the header on the function
        that the tra references */
@@ -96 +129 @@
   case fulltag_misc:
   case fulltag_cons:
+#ifdef X8664
   case fulltag_symbol:
   case fulltag_function:
+#endif
     a = heap_area_containing((BytePtr)ptr_from_lispobj(n));
     
@@ -163 +198 @@
       elements = header_element_count(node) | 1;
       if (header_subtag(node) == subtag_function) {
+#ifdef X8632
+        int skip = *(unsigned short *)current;
+#else
         int skip = *(int *)current;
+#endif
         current += skip;
         elements -= skip;
@@ -250 +289 @@
   }
 
+#ifdef X8632
+  if (tag_n == fulltag_tra) {
+    if (*(unsigned char *)n == RECOVER_FN_OPCODE) {
+      n = *(LispObj *)(n + 1);
+      tag_n = fulltag_misc;
+    } else
+      return;
+  }
+#endif
+#ifdef X8664
   if (tag_of(n) == tag_tra) {
     if ((*((unsigned short *)n) == RECOVER_FN_FROM_RIP_WORD0) &&
@@ -261 +310 @@
     }
   }
+#endif
 
 
@@ -292 +342 @@
     tag_n = fulltag_of(header);
 
-
+#ifdef X8664
     if ((nodeheader_tag_p(tag_n)) ||
         (tag_n == ivector_class_64_bit)) {
@@ -308 +358 @@
       }
     }
+#endif
+#ifdef X8632
+    if ((tag_n == fulltag_nodeheader) ||
+        (subtag <= max_32_bit_ivector_subtag)) {
+      total_size_in_bytes = 4 + (element_count<<2);
+    } else if (subtag <= max_8_bit_ivector_subtag) {
+      total_size_in_bytes = 4 + element_count;
+    } else if (subtag <= max_16_bit_ivector_subtag) {
+      total_size_in_bytes = 4 + (element_count<<1);
+    } else if (subtag == subtag_double_float_vector) {
+      total_size_in_bytes = 8 + (element_count<<3);
+    } else {
+      total_size_in_bytes = 4 + ((element_count+7)>>3);
+    }
+#endif
+
 
     suffix_dnodes = ((total_size_in_bytes+(dnode_size-1))>>dnode_shift) -1;
@@ -344 +410 @@
 
       if (subtag == subtag_function) {
+#ifdef X8632
+        prefix_nodes = (natural) ((unsigned short) deref(base,1));
+#else
         prefix_nodes = (natural) ((int) deref(base,1));
+#endif
         if (prefix_nodes > element_count) {
           Bug(NULL, "Function 0x%lx trashed",n);
@@ -397 +467 @@
 #ifdef X8664
 #define RMARK_PREV_ROOT fulltag_imm_1 /* fulltag of 'undefined' value */
-#define RMARK_PREV_CAR fulltag_nil /* fulltag_nil + node_size. Coincidence ? I think not. */
+#define RMARK_PREV_CAR fulltag_nil /* fulltag_cons + node_size. Coincidence ? I think not. */
 #else
-#endif
-
+#define RMARK_PREV_ROOT fulltag_imm /* fulltag of 'undefined' value */
+#define RMARK_PREV_CAR fulltag_odd_fixnum 
+#endif
 
 
@@ -419 +490 @@
   }
 
+#ifdef X8632
+  if (tag_n == fulltag_tra) {
+    if (*(unsigned char *)n == RECOVER_FN_OPCODE) {
+      n = *(LispObj *)(n + 1);
+      tag_n = fulltag_misc;
+    } else {
+      return;
+    }
+  }
+#endif
+#ifdef X8664
   if (tag_of(n) == tag_tra) {
     if ((*((unsigned short *)n) == RECOVER_FN_FROM_RIP_WORD0) &&
@@ -429 +511 @@
     }
   }
+#endif
 
   dnode = gc_area_dnode(n);
@@ -456 +539 @@
       tag_n = fulltag_of(header);
 
+#ifdef X8664
       if ((nodeheader_tag_p(tag_n)) ||
           (tag_n == ivector_class_64_bit)) {
@@ -471 +555 @@
         }
       }
+#else
+      if ((tag_n == fulltag_nodeheader) ||
+          (subtag <= max_32_bit_ivector_subtag)) {
+        total_size_in_bytes = 4 + (element_count<<2);
+      } else if (subtag <= max_8_bit_ivector_subtag) {
+        total_size_in_bytes = 4 + element_count;
+      } else if (subtag <= max_16_bit_ivector_subtag) {
+        total_size_in_bytes = 4 + (element_count<<1);
+      } else if (subtag == subtag_double_float_vector) {
+        total_size_in_bytes = 8 + (element_count<<3);
+      } else {
+        total_size_in_bytes = 4 + ((element_count+7)>>3);
+      }
+#endif
+
       suffix_dnodes = ((total_size_in_bytes+(dnode_size-1))>>dnode_shift)-1;
 
@@ -513 +612 @@
 
       if (subtag == subtag_function) {
-        if ((int)base[1] >= nmark) {
+#ifdef X8664
+        int code_words = (int)base[1];
+#else
+        int code_words = (unsigned short)base[1];
+#endif
+        if (code_words >= nmark) {
           Bug(NULL,"Bad function at 0x%lx",n);
         }
-        nmark -= (int)base[1];
+        nmark -= code_words;
       }
 
@@ -531 +635 @@
     }
   } else {
-
     /* This is all a bit more complicated than the PPC version:
 
@@ -618 +721 @@
     case tag_misc:
     case fulltag_misc:
+#ifdef X8664
     case tag_symbol:
     case fulltag_symbol:
     case tag_function:
     case fulltag_function:
+#endif
       goto ClimbVector;
 
@@ -633 +738 @@
       goto ClimbCar;
 
-      /* default: abort() */
+    default: abort();
     }
 
@@ -642 +747 @@
   MarkCons:
     next = deref(this,1);
+#ifdef X8632
+    this += (RMARK_PREV_CAR-fulltag_cons);
+#else
     this += node_size;
+#endif
     tag_n = fulltag_of(next);
     if (!is_node_fulltag(tag_n)) goto MarkCdr;
@@ -660 +769 @@
   MarkCdr:
     next = deref(this, 0);
+#ifdef X8632
+    this -= (RMARK_PREV_CAR-fulltag_cons);
+#else
     this -= node_size;
+#endif
     tag_n = fulltag_of(next);
     if (!is_node_fulltag(tag_n)) goto Climb;
@@ -677 +790 @@
 
   MarkVector:
+#ifdef X8664
     if ((tag_n == fulltag_tra_0) ||
         (tag_n == fulltag_tra_1)) {
@@ -717 +831 @@
       }
     }
+#else
+    if (tag_n == fulltag_tra) {
+      LispObj fn = *(LispObj *)(n + 1);
+
+      base = (LispObj *)untag(fn);
+      header = *(natural *)base;
+      subtag = header_subtag(header);
+      boundary = base + (unsigned short)base[1];
+      /*
+       * On x8632, the upper 24 bits of the boundary word are zero.
+       * Functions on x8632 can be no more than 2^16 words (or 2^24
+       * bytes) long (including the self-reference table but excluding
+       * any constants).  Therefore, we can do the same basic thing
+       * that the x8664 port does: namely, we keep the byte
+       * displacement from the address of the object (tagged tra or
+       * fulltag_misc) that references the function to the address of
+       * the boundary marker in those 24 bits, recovering it when
+       * we've finished marking the function vector.
+       */
+      *((int *)boundary) &= 0xff;
+      *((int *)boundary) |= ((this-(LispObj)boundary) << 8);
+      this = (LispObj)(base)+fulltag_misc;
+      dnode = gc_area_dnode(this);
+      set_bit(markbits,dnode);
+    } else {
+      base = (LispObj *) ptr_from_lispobj(untag(this));
+      header = *((natural *) base);
+      subtag = header_subtag(header);
+      if (subtag == subtag_function) {
+        boundary = base + (unsigned short)base[1];
+        *((int *)boundary) &= 0xff;
+        *((int *)boundary) |= ((this-((LispObj)boundary)) << 8);
+      }
+    }
+    element_count = header_element_count(header);
+    tag_n = fulltag_of(header);
+
+    if ((tag_n == fulltag_nodeheader) ||
+        (subtag <= max_32_bit_ivector_subtag)) {
+      total_size_in_bytes = 4 + (element_count<<2);
+    } else if (subtag <= max_8_bit_ivector_subtag) {
+      total_size_in_bytes = 4 + element_count;
+    } else if (subtag <= max_16_bit_ivector_subtag) {
+      total_size_in_bytes = 4 + (element_count<<1);
+    } else if (subtag == subtag_double_float_vector) {
+      total_size_in_bytes = 8 + (element_count<<3);
+    } else {
+      total_size_in_bytes = 4 + ((element_count+7)>>3);
+    }
+#endif
+
     suffix_dnodes = ((total_size_in_bytes+(dnode_size-1))>>dnode_shift)-1;
     
@@ -759 +924 @@
     this -= node_size;
     next = indirect_node(this);
+#ifdef X8664
     if ((tag_of(this) == tag_function) &&
         (header_subtag(next) == function_boundary_marker)) goto MarkFunctionDone;
+#else
+    if ((tag_of(this) == tag_misc) &&
+        (header_subtag(next) == function_boundary_marker)) goto MarkFunctionDone;
+#endif
+
     tag_n = fulltag_of(next);
     if (nodeheader_tag_p(tag_n)) goto MarkVectorDone;
@@ -786 +957 @@
   MarkFunctionDone:
     boundary = (LispObj *)(node_aligned(this));
+#ifdef X8664
     this = ((LispObj)boundary) + (((int *)boundary)[1]);
     (((int *)boundary)[1]) = 0;
+#else
+    this = ((LispObj)boundary) + ((*((int *)boundary)) >> 8);
+    ((int *)boundary)[0] &= 0xff;
     goto Climb;
+#endif
   }
 }
@@ -801 +977 @@
 
 
-
+#ifdef X8664
   switch (fulltag_of(header)) {
   case ivector_class_64_bit:
@@ -820 +996 @@
   }
   return ptr_from_lispobj(start+(~15 & (nbytes + 8 + 15)));
-
+#else
+  if (subtag <= max_32_bit_ivector_subtag) {
+    nbytes = element_count << 2;
+  } else if (subtag <= max_8_bit_ivector_subtag) {
+    nbytes = element_count;
+  } else if (subtag <= max_16_bit_ivector_subtag) {
+    nbytes = element_count << 1;
+  } else if (subtag == subtag_double_float_vector) {
+    nbytes = 4 + (element_count << 3);
+  } else {
+    nbytes = (element_count+7) >> 3;
+  }
+  return ptr_from_lispobj(start+(~7 & (nbytes + 4 + 7)));
+#endif
 }
 
@@ -840 +1029 @@
     } else {
       if (header_subtag(x1) == subtag_function) {
+#ifdef X8632
+        int skip = (unsigned short)deref(start,1);
+#else
         int skip = (int) deref(start,1);
+#endif
         start += ((1+skip)&~1);
         x1 = *start;
@@ -1015 +1208 @@
       base = start + element_count + 1;
       if (subtag == subtag_function) {
+#ifdef X8632
+        element_count -= (unsigned short)start[1];
+#else
         element_count -= (int)start[1];
+#endif
       }
       while(element_count--) {
@@ -1076 +1273 @@
 
 /* Mark the lisp objects in an exception frame */
+#ifdef X8664
 void
 mark_xp(ExceptionInformation *xp)
@@ -1114 +1312 @@
   }
 }
-
-
-      
-
-
-
-
+#else
+void
+mark_xp(ExceptionInformation *xp, natural node_regs_mask)
+{
+  natural *regs = (natural *) xpGPRvector(xp), dnode;
+  LispObj eip;
+  int i;
+
+  if (node_regs_mask & (1<<0)) mark_root(regs[REG_EAX]);
+  if (node_regs_mask & (1<<1)) mark_root(regs[REG_EBX]);
+  if (node_regs_mask & (1<<2)) mark_root(regs[REG_ECX]);
+  if (node_regs_mask & (1<<3)) mark_root(regs[REG_EDX]);
+  if (node_regs_mask & (1<<4)) mark_root(regs[REG_ESP]);
+  if (node_regs_mask & (1<<5)) mark_root(regs[REG_EBP]);
+  if (node_regs_mask & (1<<6)) mark_root(regs[REG_ESI]);
+  if (node_regs_mask & (1<<7)) mark_root(regs[REG_EDI]);
+
+  /* If the EIP isn't pointing into a marked function, we're probably
+     in trouble.  We can -maybe- recover from that if it's tagged as a
+     TRA. */
+  eip = regs[Ieip];
+  dnode = gc_area_dnode(eip);
+  if ((dnode < GCndnodes_in_area) &&
+      (! ref_bit(GCmarkbits,dnode))) {
+    if (fulltag_of(eip) == fulltag_tra) {
+      mark_root(eip);
+    } else if ((fulltag_of(eip) == fulltag_misc) &&
+               (header_subtag(header_of(eip)) == subtag_function) &&
+               (*(unsigned char *)eip == RECOVER_FN_OPCODE) &&
+               (*(LispObj *)(eip + 1)) == eip) {
+      mark_root(eip);
+    } else {
+      Bug(NULL, "Can't find function for eip 0x%4x", eip);
+    }
+  }
+}
+#endif
 
 /* A "pagelet" contains 32 doublewords.  The relocation table contains
@@ -1218 +1446 @@
 }
 #else
-
+#ifdef X8664
 /* Quicker, dirtier */
 LispObj
@@ -1244 +1472 @@
   return new;
 }
+#endif
+#ifdef X8632
+LispObj
+dnode_forwarding_address(natural dnode, int tag_n)
+{
+  natural pagelet, nbits;
+  unsigned short near_bits;
+  LispObj new;
+
+  if (GCDebug) {
+    if (! ref_bit(GCdynamic_markbits, dnode)) {
+      Bug(NULL, "unmarked object being forwarded!\n");
+    }
+  }
+
+  pagelet = dnode >> 5;
+  nbits = dnode & 0x1f;
+  /* On little-endian x86, we have to flip the low bit of dnode>>4 to
+     get the near_bits from the appropriate half-word. */
+  near_bits = ((unsigned short *)GCdynamic_markbits)[(dnode>>4)^1];
+
+  if (nbits < 16) {
+    new = GCrelocptr[pagelet] + tag_n;;
+    /* Increment "new" by the count of 1 bits which precede the dnode */
+    if (near_bits == 0xffff) {
+      return (new + (nbits << 3));
+    } else {
+      near_bits &= (0xffff0000 >> nbits);
+      if (nbits > 7) {
+        new += one_bits(near_bits & 0xff);
+      }
+      return (new + (one_bits(near_bits >> 8))); 
+    }
+  } else {
+    new = GCrelocptr[pagelet+1] + tag_n;
+    nbits = 32-nbits;
+
+    if (near_bits == 0xffff) {
+      return (new - (nbits << 3));
+    } else {
+      near_bits &= (1<<nbits)-1;
+      if (nbits > 7) {
+        new -= one_bits(near_bits >> 8);
+      }
+      return (new - one_bits(near_bits & 0xff));
+    }
+  }
+}
+#endif
 #endif
 
@@ -1316 +1593 @@
       } else {
         if (header_subtag(node) == subtag_function) {
+#ifdef X8632
+          int skip = (unsigned short)(p[1]);
+#else
           int skip = (int)(p[1]);
+#endif
           p += skip;
           nwords -= skip;
@@ -1380 +1661 @@
 }
 
-
+#ifdef X8664
 void
 forward_xp(ExceptionInformation *xp)
@@ -1399 +1680 @@
   update_locref(&(regs[Iip]));
 }
+#else
+void
+forward_xp(ExceptionInformation *xp, natural node_regs_mask)
+{
+  natural *regs = (natural *) xpGPRvector(xp);
+
+  if (node_regs_mask & (1<<0)) update_noderef(&regs[REG_EAX]);
+  if (node_regs_mask & (1<<1)) update_noderef(&regs[REG_EBX]);
+  if (node_regs_mask & (1<<2)) update_noderef(&regs[REG_ECX]);
+  if (node_regs_mask & (1<<3)) update_noderef(&regs[REG_EDX]);
+  if (node_regs_mask & (1<<4)) update_noderef(&regs[REG_ESP]);
+  if (node_regs_mask & (1<<5)) update_noderef(&regs[REG_EBP]);
+  if (node_regs_mask & (1<<6)) update_noderef(&regs[REG_ESI]);
+  if (node_regs_mask & (1<<7)) update_noderef(&regs[REG_EDI]);
+
+  update_locref(&(regs[Iip]));
+}
+#endif
 
 
@@ -1409 +1708 @@
   xp = tcr->gc_context;
   if (xp) {
+#ifdef X8664
     forward_xp(xp);
+#else
+    forward_xp(xp, tcr->node_regs_mask);
+
+    update_noderef(&tcr->save0);
+    update_noderef(&tcr->save1);
+    update_noderef(&tcr->save2);
+    update_noderef(&tcr->save3);
+#endif
   }
   for (xframes = tcr->xframe; xframes; xframes = xframes->prev) {
+#ifdef X8664
     forward_xp(xframes->curr);
-  }
-}
-
-
-
+#else
+    forward_xp(xframes->curr, xframes->node_regs_mask);
+#endif
+  }
+}
+
+
+#ifdef X8632
+void
+update_self_references(LispObj *node)
+{
+  LispObj fn = fulltag_misc + (LispObj)node;
+  unsigned char *p = (unsigned char *)node;
+  natural i, offset;
+
+  i = ((unsigned short *)node)[2];
+  offset = node[--i];
+  while (offset) {
+    *(LispObj *)(p + offset) = fn;
+    offset = node[--i];
+  }    
+}
+#endif
 
 /*
@@ -1480 +1807 @@
           dnode += node_dnodes;
           if (header_subtag(node) == subtag_function) {
+#ifdef X8632
+            int skip = *((unsigned short *)src);
+            LispObj *f = dest;
+#else
             int skip = *((int *)src);
+#endif
             *dest++ = node;
             elements -= skip;
@@ -1486 +1818 @@
               *dest++ = *src++;
             }
+#ifdef X8632
+            update_self_references(f);
+#endif
             while(elements--) {
               *dest++ = node_forwarding_address(*src++);
@@ -1541 +1876 @@
           tag = header_subtag(node);
 
-
+#ifdef X8664
           switch(fulltag_of(tag)) {
           case ivector_class_64_bit:
@@ -1558 +1893 @@
             }
           }
+#endif
+#ifdef X8632
+          if (tag <= max_32_bit_ivector_subtag) {
+            imm_dnodes = (((elements+1)+1)>>1);
+          } else if (tag <= max_8_bit_ivector_subtag) {
+            imm_dnodes = (((elements+4)+7)>>3);
+          } else if (tag <= max_16_bit_ivector_subtag) {
+            imm_dnodes = (((elements+2)+3)>>2);
+          } else if (tag == subtag_bit_vector) {
+            imm_dnodes = (((elements+32)+63)>>6);
+          } else {
+            imm_dnodes = elements+1;
+          }
+#endif
+
           dnode += imm_dnodes;
           while (--imm_dnodes) {
@@ -1572 +1922 @@
         }
       }
-  
-    }
-
+    }
   }
   return ptr_to_lispobj(dest);
@@ -1607 +1955 @@
         subtag = header_subtag(header);
 
+#ifdef X8664
         switch(fulltag_of(header)) {
         case ivector_class_64_bit:
@@ -1624 +1973 @@
           }
         }
+#endif
+#ifdef X8632
+          if (subtag <= max_32_bit_ivector_subtag) {
+            bytes = 4 + (elements<<2);
+          } else if (subtag <= max_8_bit_ivector_subtag) {
+            bytes = 4 + elements;
+          } else if (subtag <= max_16_bit_ivector_subtag) {
+            bytes = 4 + (elements<<1);
+          } else if (subtag == subtag_double_float_vector) {
+            bytes = 8 + (elements<<3);
+          } else {
+            bytes = 4 + ((elements+7)>>3);
+          }
+#endif
+
         bytes = (bytes+dnode_size-1) & ~(dnode_size-1);
         total += bytes;
@@ -1785 +2149 @@
         } else {
           if (header_subtag(header) == subtag_function) {
+#ifdef X8632
+            int skip = (unsigned short)(start[1]);
+#else
             int skip = (int)(start[1]);
+#endif
             start += skip;
             nwords -= skip;