[PATCH] kallsyms: change compression algorithm

This patch changes the way the compression algorithm works.  The base
algorithm is similiar to the previous but we force the compressed token
size to 2.

Having a fixed size compressed token allows for a lot of optimizations, and
that in turn allows this code to run over *all* the symbols faster than it
did before over just a subset.

Having it work over all the symbols will make it behave better when symbols
change positions between passes, and the "inconsistent kallsyms" messages
should become less frequent.

In my tests the compression ratio was degraded by about 0.5%, but the
results will depend greatly on the number of symbols to compress.

Signed-off-by: Paulo Marques <pmarques@grupopie.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 95 insertions, 329 deletions

diff --git a/scripts/kallsyms.c b/scripts/kallsyms.c
index 9be41a9f5aff..1f53d4fc4c1d 100644
--- a/scripts/kallsyms.c
+++ b/scripts/kallsyms.c
@@ -24,75 +24,37 @@
  *
  */
 
+#define _GNU_SOURCE
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 
-/* maximum token length used. It doesn't pay to increase it a lot, because
- * very long substrings probably don't repeat themselves too often. */
-#define MAX_TOK_SIZE            11
 #define KSYM_NAME_LEN           127
 
-/* we use only a subset of the complete symbol table to gather the token count,
- * to speed up compression, at the expense of a little compression ratio */
-#define WORKING_SET             1024
-
-/* first find the best token only on the list of tokens that would profit more
- * than GOOD_BAD_THRESHOLD. Only if this list is empty go to the "bad" list.
- * Increasing this value will put less tokens on the "good" list, so the search
- * is faster. However, if the good list runs out of tokens, we must painfully
- * search the bad list. */
-#define GOOD_BAD_THRESHOLD      10
-
-/* token hash parameters */
-#define HASH_BITS               18
-#define HASH_TABLE_SIZE         (1 << HASH_BITS)
-#define HASH_MASK               (HASH_TABLE_SIZE - 1)
-#define HASH_BASE_OFFSET        2166136261U
-#define HASH_FOLD(a)            ((a)&(HASH_MASK))
-
-/* flags to mark symbols */
-#define SYM_FLAG_VALID          1
-#define SYM_FLAG_SAMPLED        2
 
 struct sym_entry {
         unsigned long long addr;
-        char type;
-        unsigned char flags;
-        unsigned char len;
+        unsigned int len;
         unsigned char *sym;
 };
 
 
 static struct sym_entry *table;
-static int size, cnt;
+static unsigned int table_size, table_cnt;
 static unsigned long long _stext, _etext, _sinittext, _einittext, _sextratext, _eextratext;
 static int all_symbols = 0;
 static char symbol_prefix_char = '\0';
 
-struct token {
-        unsigned char data[MAX_TOK_SIZE];
-        unsigned char len;
-        /* profit: the number of bytes that could be saved by inserting this
-         * token into the table */
-        int profit;
-        struct token *next;     /* next token on the hash list */
-        struct token *right;    /* next token on the good/bad list */
-        struct token *left;    /* previous token on the good/bad list */
-        struct token *smaller; /* token that is less one letter than this one */
-        };
-
-struct token bad_head, good_head;
-struct token *hash_table[HASH_TABLE_SIZE];
+int token_profit[0x10000];
 
 /* the table that holds the result of the compression */
-unsigned char best_table[256][MAX_TOK_SIZE+1];
+unsigned char best_table[256][2];
 unsigned char best_table_len[256];
 
 
-static void
-usage(void)
+static void usage(void)
 {
         fprintf(stderr, "Usage: kallsyms [--all-symbols] [--symbol-prefix=<prefix char>] < in.map > out.S\n");
         exit(1);
@@ -102,21 +64,19 @@ usage(void)
  * This ignores the intensely annoying "mapping symbols" found
  * in ARM ELF files: $a, $t and $d.
  */
-static inline int
-is_arm_mapping_symbol(const char *str)
+static inline int is_arm_mapping_symbol(const char *str)
 {
         return str[0] == '$' && strchr("atd", str[1])
                && (str[2] == '\0' || str[2] == '.');
 }
 
-static int
-read_symbol(FILE *in, struct sym_entry *s)
+static int read_symbol(FILE *in, struct sym_entry *s)
 {
         char str[500];
-        char *sym;
+        char *sym, stype;
         int rc;
 
-        rc = fscanf(in, "%llx %c %499s\n", &s->addr, &s->type, str);
+        rc = fscanf(in, "%llx %c %499s\n", &s->addr, &stype, str);
         if (rc != 3) {
                 if (rc != EOF) {
                         /* skip line */
@@ -143,7 +103,7 @@ read_symbol(FILE *in, struct sym_entry *s)
                 _sextratext = s->addr;
         else if (strcmp(sym, "_eextratext") == 0)
                 _eextratext = s->addr;
-        else if (toupper(s->type) == 'A')
+        else if (toupper(stype) == 'A')
         {
                 /* Keep these useful absolute symbols */
                 if (strcmp(sym, "__kernel_syscall_via_break") &&
@@ -153,22 +113,21 @@ read_symbol(FILE *in, struct sym_entry *s)
                         return -1;
 
         }
-        else if (toupper(s->type) == 'U' ||
+        else if (toupper(stype) == 'U' ||
                  is_arm_mapping_symbol(sym))
                 return -1;
 
         /* include the type field in the symbol name, so that it gets
          * compressed together */
         s->len = strlen(str) + 1;
-        s->sym = (char *) malloc(s->len + 1);
-        strcpy(s->sym + 1, str);
-        s->sym[0] = s->type;
+        s->sym = malloc(s->len + 1);
+        strcpy((char *)s->sym + 1, str);
+        s->sym[0] = stype;
 
         return 0;
 }
 
-static int
-symbol_valid(struct sym_entry *s)
+static int symbol_valid(struct sym_entry *s)
 {
         /* Symbols which vary between passes.  Passes 1 and 2 must have
          * identical symbol lists.  The kallsyms_* symbols below are only added
@@ -214,30 +173,29 @@ symbol_valid(struct sym_entry *s)
         }
 
         /* Exclude symbols which vary between passes. */
-        if (strstr(s->sym + offset, "_compiled."))
+        if (strstr((char *)s->sym + offset, "_compiled."))
                 return 0;
 
         for (i = 0; special_symbols[i]; i++)
-                if( strcmp(s->sym + offset, special_symbols[i]) == 0 )
+                if( strcmp((char *)s->sym + offset, special_symbols[i]) == 0 )
                         return 0;
 
         return 1;
 }
 
-static void
-read_map(FILE *in)
+static void read_map(FILE *in)
 {
         while (!feof(in)) {
-                if (cnt >= size) {
+                if (table_cnt >= table_size) {