xnu-7195.101.1.tar.gz

[apple/xnu.git] / libkern / kxld / WKdmDecompress.c

diff --git a/libkern/kxld/WKdmDecompress.c b/libkern/kxld/WKdmDecompress.c
index 8eaf78bd89421667b76f461a3b6ad6f9b3dff9f3..9af3ab95ae45a34be35e3f55a0d36d39bdf1dc90 100644 (file)
--- a/libkern/kxld/WKdmDecompress.c
+++ b/libkern/kxld/WKdmDecompress.c
@@ -5,7 +5,7 @@
  *          THE UNPACKING ROUTINES should GO HERE
  */
 
  *          THE UNPACKING ROUTINES should GO HERE
  */
 

-const char hashLookupTable [] = HASH_LOOKUP_TABLE_CONTENTS;
+const char hashLookupTable[] = HASH_LOOKUP_TABLE_CONTENTS;

 
 #if 0
 #define GET_NEXT_TAG tags[tagsIndex++]
 
 #if 0
 #define GET_NEXT_TAG tags[tagsIndex++]


@@ -21,31 +21,30 @@ const char hashLookupTable [] = HASH_LOOKUP_TABLE_CONTENTS;
  */
 static WK_word*
 WK_unpack_2bits(WK_word *input_buf,
  */
 static WK_word*
 WK_unpack_2bits(WK_word *input_buf,

-                WK_word *input_end,
-                WK_word *output_buf) {
-
-  register WK_word *input_next = input_buf;
-  register WK_word *output_next = output_buf;
-  register WK_word packing_mask = TWO_BITS_PACKING_MASK;
-
-  /* loop to repeatedly grab one input word and unpack it into
-   * 4 output words.  This loop could be unrolled a little---it's
-   * designed to be easy to do that.
-   */   
-  while (input_next < input_end) {
-    register WK_word temp = input_next[0];
-    DEBUG_PRINT_2("Unpacked tags word: %.8x\n", temp);
-    output_next[0] = temp & packing_mask;
-    output_next[1] = (temp >> 2) & packing_mask;
-    output_next[2] = (temp >> 4) & packing_mask;
-    output_next[3] = (temp >> 6) & packing_mask;
-    
-    output_next += 4;
-    input_next++;
-  }
-
-  return output_next;
-
+    WK_word *input_end,
+    WK_word *output_buf)
+{
+       WK_word *input_next = input_buf;
+       WK_word *output_next = output_buf;
+       WK_word packing_mask = TWO_BITS_PACKING_MASK;
+
+       /* loop to repeatedly grab one input word and unpack it into
+        * 4 output words.  This loop could be unrolled a little---it's
+        * designed to be easy to do that.
+        */
+       while (input_next < input_end) {
+               WK_word temp = input_next[0];
+               DEBUG_PRINT_2("Unpacked tags word: %.8x\n", temp);
+               output_next[0] = temp & packing_mask;
+               output_next[1] = (temp >> 2) & packing_mask;
+               output_next[2] = (temp >> 4) & packing_mask;
+               output_next[3] = (temp >> 6) & packing_mask;
+
+               output_next += 4;
+               input_next++;
+       }
+
+       return output_next;

 }
 
 /* unpack four bits consumes any number of words (between input_buf
 }
 
 /* unpack four bits consumes any number of words (between input_buf


@@ -56,30 +55,29 @@ WK_unpack_2bits(WK_word *input_buf,
  */
 static WK_word*
 WK_unpack_4bits(WK_word *input_buf,
  */
 static WK_word*
 WK_unpack_4bits(WK_word *input_buf,

-                WK_word *input_end,
-                WK_word *output_buf) {
-
-  register WK_word *input_next = input_buf;
-  register WK_word *output_next = output_buf;
-  register WK_word packing_mask = FOUR_BITS_PACKING_MASK;
-  
-  
-  /* loop to repeatedly grab one input word and unpack it into
-   * 4 output words.  This loop should probably be unrolled
-   * a little---it's designed to be easy to do that.
-   */   
-  while (input_next < input_end) {
-    register WK_word temp = input_next[0];
-    DEBUG_PRINT_2("Unpacked dictionary indices word: %.8x\n", temp);
-    output_next[0] = temp & packing_mask;
-    output_next[1] = (temp >> 4) & packing_mask;
-    
-    output_next += 2;
-    input_next++;
-  }
-  
-  return output_next;
-
+    WK_word *input_end,
+    WK_word *output_buf)
+{
+       WK_word *input_next = input_buf;
+       WK_word *output_next = output_buf;
+       WK_word packing_mask = FOUR_BITS_PACKING_MASK;
+
+
+       /* loop to repeatedly grab one input word and unpack it into
+        * 4 output words.  This loop should probably be unrolled
+        * a little---it's designed to be easy to do that.
+        */
+       while (input_next < input_end) {
+               WK_word temp = input_next[0];
+               DEBUG_PRINT_2("Unpacked dictionary indices word: %.8x\n", temp);
+               output_next[0] = temp & packing_mask;
+               output_next[1] = (temp >> 4) & packing_mask;
+
+               output_next += 2;
+               input_next++;
+       }
+
+       return output_next;

 }
 
 /* unpack_3_tenbits unpacks three 10-bit items from (the low 30 bits of)
 }
 
 /* unpack_3_tenbits unpacks three 10-bit items from (the low 30 bits of)


@@ -87,197 +85,190 @@ WK_unpack_4bits(WK_word *input_buf,
  */
 static WK_word*
 WK_unpack_3_tenbits(WK_word *input_buf,
  */
 static WK_word*
 WK_unpack_3_tenbits(WK_word *input_buf,

-                    WK_word *input_end,
-                    WK_word *output_buf) {
-
-  register WK_word *input_next = input_buf;
-  register WK_word *output_next = output_buf;
-  register WK_word packing_mask = LOW_BITS_MASK;
-  
-  /* loop to fetch words of input, splitting each into three
-   * words of output with 10 meaningful low bits.  This loop
-   * probably ought to be unrolled and maybe coiled
-   */
-  while (input_next < input_end) {
-    register WK_word temp = input_next[0];
-    
-    output_next[0] = temp & packing_mask;
-    output_next[1] = (temp >> 10) & packing_mask;
-    output_next[2] = temp >> 20;
-    
-    input_next++;
-    output_next += 3;
-  }
-  
-  return output_next;
-
+    WK_word *input_end,
+    WK_word *output_buf)
+{
+       WK_word *input_next = input_buf;
+       WK_word *output_next = output_buf;
+       WK_word packing_mask = LOW_BITS_MASK;
+
+       /* loop to fetch words of input, splitting each into three
+        * words of output with 10 meaningful low bits.  This loop
+        * probably ought to be unrolled and maybe coiled
+        */
+       while (input_next < input_end) {
+               WK_word temp = input_next[0];
+
+               output_next[0] = temp & packing_mask;
+               output_next[1] = (temp >> 10) & packing_mask;
+               output_next[2] = temp >> 20;
+
+               input_next++;
+               output_next += 3;
+       }
+
+       return output_next;

 }
 
 /*********************************************************************
 }
 
 /*********************************************************************

- * WKdm_decompress --- THE DECOMPRESSOR                                 
+ * WKdm_decompress --- THE DECOMPRESSOR

  * Expects WORD pointers to the source and destination buffers
  * Expects WORD pointers to the source and destination buffers

- * and a page size in words.  The page size had better be 1024 unless     
- * somebody finds the places that are dependent on the page size and 
+ * and a page size in words.  The page size had better be 1024 unless
+ * somebody finds the places that are dependent on the page size and

  * fixes them
  */
 
 void
  * fixes them
  */
 
 void

-WKdm_decompress (WK_word* src_buf,
-                WK_word* dest_buf,
-                __unused unsigned int words)
+WKdm_decompress(WK_word* src_buf,
+    WK_word* dest_buf,
+    __unused unsigned int words)

 {
 {

+       DictionaryElement dictionary[DICTIONARY_SIZE];

 
 

-  DictionaryElement dictionary[DICTIONARY_SIZE];
+       /* arrays that hold output data in intermediate form during modeling */
+       /* and whose contents are packed into the actual output after modeling */

 
 

-  /* arrays that hold output data in intermediate form during modeling */
-  /* and whose contents are packed into the actual output after modeling */
+       /* sizes of these arrays should be increased if you want to compress
+        * pages larger than 4KB
+        */
+       WK_word tempTagsArray[300];  /* tags for everything          */
+       WK_word tempQPosArray[300];  /* queue positions for matches  */
+       WK_word tempLowBitsArray[1200]; /* low bits for partial matches */

 
 

-  /* sizes of these arrays should be increased if you want to compress
-   * pages larger than 4KB
-   */
-  WK_word tempTagsArray[300];        /* tags for everything          */
-  WK_word tempQPosArray[300];        /* queue positions for matches  */
-  WK_word tempLowBitsArray[1200];    /* low bits for partial matches */
-
-  PRELOAD_DICTIONARY;
+       PRELOAD_DICTIONARY;

 
 #ifdef WK_DEBUG
 
 #ifdef WK_DEBUG

-  printf("\nIn DECOMPRESSOR\n");
-  printf("tempTagsArray is at %p\n", tempTagsArray);
-  printf("tempQPosArray is at %p\n", tempQPosArray);
-  printf("tempLowBitsArray is at %p\n", tempLowBitsArray);
-
-  printf(" first four words of source buffer are:\n");
-  printf("   %u\n   %u\n   %u\n   %u\n",
-         src_buf[0], src_buf[1], src_buf[2], src_buf[3]);
-  
-  { int i;
-    WK_word *arr =(src_buf + TAGS_AREA_OFFSET + (PAGE_SIZE_IN_WORDS / 16));
-
-    printf("  first 20 full patterns are: \n");
-    for (i = 0; i < 20; i++) {
-      printf(" %d", arr[i]);
-    }
-    printf("\n");
-  }
+       printf("\nIn DECOMPRESSOR\n");
+       printf("tempTagsArray is at %p\n", tempTagsArray);
+       printf("tempQPosArray is at %p\n", tempQPosArray);
+       printf("tempLowBitsArray is at %p\n", tempLowBitsArray);
+
+       printf(" first four words of source buffer are:\n");
+       printf("   %u\n   %u\n   %u\n   %u\n",
+           src_buf[0], src_buf[1], src_buf[2], src_buf[3]);
+
+       { int i;
+         WK_word *arr = (src_buf + TAGS_AREA_OFFSET + (PAGE_SIZE_IN_WORDS / 16));
+
+         printf("  first 20 full patterns are: \n");
+         for (i = 0; i < 20; i++) {
+                 printf(" %d", arr[i]);
+         }
+         printf("\n");}

 #endif
 
 #endif
 

-  WK_unpack_2bits(TAGS_AREA_START(src_buf),
-                  TAGS_AREA_END(src_buf),
-                  tempTagsArray);
+       WK_unpack_2bits(TAGS_AREA_START(src_buf),
+           TAGS_AREA_END(src_buf),
+           tempTagsArray);

 
 #ifdef WK_DEBUG
 
 #ifdef WK_DEBUG

-  { int i;
-    char* arr = (char *) tempTagsArray;
-
-    printf("  first 200 tags are: \n");
-    for (i = 0; i < 200; i++) {
-      printf(" %d", arr[i]);
-    }
-    printf("\n");
-  }
+       { int i;
+         char* arr = (char *) tempTagsArray;
+
+         printf("  first 200 tags are: \n");
+         for (i = 0; i < 200; i++) {
+                 printf(" %d", arr[i]);
+         }
+         printf("\n");}

 #endif
 
 #endif
 

-  WK_unpack_4bits(QPOS_AREA_START(src_buf),
-                  QPOS_AREA_END(src_buf),
-                  tempQPosArray);
+       WK_unpack_4bits(QPOS_AREA_START(src_buf),
+           QPOS_AREA_END(src_buf),
+           tempQPosArray);

 
 #ifdef WK_DEBUG
 
 #ifdef WK_DEBUG

-  { int i;
-    char* arr = (char *) tempQPosArray;
-
-    printf("  first 200 queue positions are: \n");
-    for (i = 0; i < 200; i++) {
-      printf(" %d", arr[i]);
-    }
-    printf("\n");
-  }
+       { int i;
+         char* arr = (char *) tempQPosArray;
+
+         printf("  first 200 queue positions are: \n");
+         for (i = 0; i < 200; i++) {
+                 printf(" %d", arr[i]);
+         }
+         printf("\n");}

 #endif
 
 #endif
 

-  WK_unpack_3_tenbits(LOW_BITS_AREA_START(src_buf),
-                      LOW_BITS_AREA_END(src_buf),
-                      tempLowBitsArray);
+       WK_unpack_3_tenbits(LOW_BITS_AREA_START(src_buf),
+           LOW_BITS_AREA_END(src_buf),
+           tempLowBitsArray);

 
 #ifdef WK_DEBUG
 
 #ifdef WK_DEBUG

-  printf("AFTER UNPACKING, about to enter main block \n");
+       printf("AFTER UNPACKING, about to enter main block \n");

 #endif
 
 #endif
 

-  {
-    register char *next_tag = (char *) tempTagsArray;
-    char *tags_area_end =
-       ((char *) tempTagsArray) + PAGE_SIZE_IN_WORDS;
-    char *next_q_pos = (char *) tempQPosArray;
-    WK_word *next_low_bits = tempLowBitsArray;
-    WK_word *next_full_word = FULL_WORD_AREA_START(src_buf);
+       {
+               char *next_tag = (char *) tempTagsArray;
+               char *tags_area_end =
+                   ((char *) tempTagsArray) + PAGE_SIZE_IN_WORDS;
+               char *next_q_pos = (char *) tempQPosArray;
+               WK_word *next_low_bits = tempLowBitsArray;
+               WK_word *next_full_word = FULL_WORD_AREA_START(src_buf);
+
+               WK_word *next_output = dest_buf;
+
+#ifdef WK_DEBUG
+               printf("next_output is %u\n", next_output);
+
+               printf("next_tag is %u \n", next_tag);
+               printf("tags_area_end is %u\n", tags_area_end);
+               printf("next_q_pos is %u\n", next_q_pos);
+               printf("next_low_bits is %u\n", next_low_bits);
+               printf("next_full_word is %u\n", next_full_word);
+#endif

 
 

-    WK_word *next_output = dest_buf;
+               /* this loop should probably be unrolled. Maybe we should unpack
+                * as 4 bit values, giving two consecutive tags, and switch on
+                * that 16 ways to decompress 2 words at a whack
+                */
+               while (next_tag < tags_area_end) {
+                       char tag = next_tag[0];
+
+                       switch (tag) {
+                       case ZERO_TAG: {
+                               *next_output = 0;
+                               break;
+                       }
+                       case EXACT_TAG: {
+                               WK_word *dict_location = dictionary + *(next_q_pos++);
+                               /* no need to replace dict. entry if matched exactly */
+                               *next_output = *dict_location;
+                               break;
+                       }
+                       case PARTIAL_TAG: {
+                               WK_word *dict_location = dictionary + *(next_q_pos++);
+                               {
+                                       WK_word temp = *dict_location;
+
+                                       /* strip out low bits */
+                                       temp = ((temp >> NUM_LOW_BITS) << NUM_LOW_BITS);
+
+                                       /* add in stored low bits from temp array */
+                                       temp = temp | *(next_low_bits++);
+
+                                       *dict_location = temp; /* replace old value in dict. */
+                                       *next_output = temp; /* and echo it to output */
+                               }
+                               break;
+                       }
+                       case MISS_TAG: {
+                               WK_word missed_word = *(next_full_word++);
+                               WK_word *dict_location =
+                                   (WK_word *)
+                                   ((void *) (((char *) dictionary) + HASH_TO_DICT_BYTE_OFFSET(missed_word)));
+                               *dict_location = missed_word;
+                               *next_output = missed_word;
+                               break;
+                       }
+                       }
+                       next_tag++;
+                       next_output++;
+               }

 
 #ifdef WK_DEBUG
 
 #ifdef WK_DEBUG

-    printf("next_output is %u\n", next_output);
-
-    printf("next_tag is %u \n", next_tag);
-    printf("tags_area_end is %u\n", tags_area_end);
-    printf("next_q_pos is %u\n", next_q_pos);
-    printf("next_low_bits is %u\n", next_low_bits);
-    printf("next_full_word is %u\n", next_full_word);
-#endif 
-
-    /* this loop should probably be unrolled. Maybe we should unpack
-     * as 4 bit values, giving two consecutive tags, and switch on
-     * that 16 ways to decompress 2 words at a whack
-     */
-    while (next_tag < tags_area_end) {
-
-       char tag = next_tag[0];
-
-       switch(tag) {
-
-         case ZERO_TAG: {
-            *next_output = 0;
-            break;
-         }
-         case EXACT_TAG: {
-            WK_word *dict_location = dictionary + *(next_q_pos++);
-            /* no need to replace dict. entry if matched exactly */
-            *next_output = *dict_location;
-            break;
-         }
-         case PARTIAL_TAG: {
-            WK_word *dict_location = dictionary + *(next_q_pos++);
-            {
-               WK_word temp = *dict_location;
-
-               /* strip out low bits */
-               temp = ((temp >> NUM_LOW_BITS) << NUM_LOW_BITS);
-
-               /* add in stored low bits from temp array */
-               temp = temp | *(next_low_bits++);
-
-               *dict_location = temp;      /* replace old value in dict. */
-               *next_output = temp;    /* and echo it to output */
-            }
-            break;
-         }
-         case MISS_TAG: {
-            WK_word missed_word = *(next_full_word++);
-            WK_word *dict_location = 
-              (WK_word *)
-              ((void *) (((char *) dictionary) + HASH_TO_DICT_BYTE_OFFSET(missed_word)));
-            *dict_location = missed_word;
-            *next_output = missed_word;
-            break;
-         }
-       }
-       next_tag++;
-       next_output++;
-    }
-
-#ifdef WK_DEBUG        
-    printf("AFTER DECOMPRESSING\n");
-    printf("next_output is %p\n", next_output);
-    printf("next_tag is %p\n", next_tag);
-    printf("next_full_word is %p\n", next_full_word);
-    printf("next_q_pos is %p\n", next_q_pos);
+               printf("AFTER DECOMPRESSING\n");
+               printf("next_output is %p\n", next_output);
+               printf("next_tag is %p\n", next_tag);
+               printf("next_full_word is %p\n", next_full_word);
+               printf("next_q_pos is %p\n", next_q_pos);

 #endif
 #endif

-  }
+       }

 }
 }