Hand merged

Makefile

@@ -159,7 +159,7 @@ STRIP		= $(CROSS_COMPILE)strip
 OBJCOPY		= $(CROSS_COMPILE)objcopy
 OBJDUMP		= $(CROSS_COMPILE)objdump
 AWK		= awk
-GENKSYMS	= /sbin/genksyms
+GENKSYMS	= scripts/genksyms/genksyms
 DEPMOD		= /sbin/depmod
 KALLSYMS	= scripts/kallsyms
 PERL		= perl
@@ -377,7 +377,7 @@ cmd_kallsyms = $(NM) -n $< | scripts/kallsyms > $@
 	$(call cmd,kallsyms)
 
 .tmp_vmlinux1: $(vmlinux-objs) arch/$(ARCH)/vmlinux.lds.s FORCE
-	$(call if_changed_rule,vmlinux__)
+	+$(call if_changed_rule,vmlinux__)
 
 .tmp_vmlinux2: $(vmlinux-objs) .tmp_kallsyms1.o arch/$(ARCH)/vmlinux.lds.s FORCE
 	$(call if_changed_rule,vmlinux__)
@@ -457,14 +457,14 @@ include/asm:
 # 	Split autoconf.h into include/linux/config/*
 
 include/config/MARKER: scripts/split-include include/linux/autoconf.h
-	@echo '  SPLIT  include/linux/autoconf.h -> include/config/*'
+	@echo '  SPLIT   include/linux/autoconf.h -> include/config/*'
 	@scripts/split-include include/linux/autoconf.h include/config
 	@touch $@
 
 # 	if .config is newer than include/linux/autoconf.h, someone tinkered
 # 	with it and forgot to run make oldconfig
 
-include/linux/autoconf.h: .config
+include/linux/autoconf.h: .config scripts
 	$(Q)$(MAKE) $(build)=scripts/kconfig scripts/kconfig/conf
 	./scripts/kconfig/conf -s arch/$(ARCH)/Kconfig
 
@@ -506,7 +506,7 @@ all: modules
 #	Build modules
 
 .PHONY: modules
-modules: $(SUBDIRS) $(if $(CONFIG_MODVERSIONS),vmlinux)
+modules: $(SUBDIRS) $(if $(KBUILD_BUILTIN),vmlinux)
 	@echo '  Building modules, stage 2.';
 	$(Q)$(MAKE) -rR -f scripts/Makefile.modpost
 
@@ -571,6 +571,7 @@ define generate-asm-offsets.h
 	 echo "#endif" )
 endef
 
+
 else # ifdef include_config
 
 ifeq ($(filter-out $(noconfig_targets),$(MAKECMDGOALS)),)
@@ -744,7 +745,7 @@ spec:
 	. scripts/mkspec >kernel.spec
 
 #	Build a tar ball, generate an rpm from it and pack the result
-#	There arw two bits of magic here
+#	There are two bits of magic here
 #	1) The use of /. to avoid tar packing just the symlink
 #	2) Removing the .dep files as they have source paths in them that
 #	   will become invalid

drivers/char/Makefile

@@ -83,7 +83,7 @@ obj-$(CONFIG_HANGCHECK_TIMER) += hangcheck-timer.o
 clean-files := consolemap_deftbl.c defkeymap.c qtronixmap.c
 
 $(obj)/consolemap_deftbl.c: $(src)/$(FONTMAPFILE)
-	$(call do_cmd,CONMK  $@,$(objtree)/scripts/conmakehash $< > $@)
+	$(call do_cmd,CONMK   $@,$(objtree)/scripts/conmakehash $< > $@)
 
 $(obj)/defkeymap.o:  $(obj)/defkeymap.c
 

include/linux/module.h

@@ -150,13 +150,7 @@ void *__symbol_get(const char *symbol);
 void *__symbol_get_gpl(const char *symbol);
 #define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x)))
 
-#ifdef __GENKSYMS__
-
-/* genksyms doesn't handle GPL-only symbols yet */
-#define EXPORT_SYMBOL_GPL EXPORT_SYMBOL
-	
-#else
-
+#ifndef __GENKSYMS__
 #ifdef CONFIG_MODVERSIONS
 /* Mark the CRC weak since genksyms apparently decides not to
  * generate a checksums for some symbols */
@@ -188,7 +182,7 @@ void *__symbol_get_gpl(const char *symbol);
 #endif
 
 /* We don't mangle the actual symbol anymore, so no need for
- * special casing EXPORT_SYMBOL_NOVERS */
+ * special casing EXPORT_SYMBOL_NOVERS.  FIXME: Deprecated */
 #define EXPORT_SYMBOL_NOVERS(sym) EXPORT_SYMBOL(sym)
 
 struct module_ref

scripts/Makefile

@@ -5,7 +5,7 @@
 # fix-dep: 	 Used to generate dependency information during build process
 # split-include: Divide all config symbols up in a number of files in
 #                include/config/...
-# docproc: 	 Preprocess .tmpl file in order to generate .sgml documentation
+# docproc: 	 Preprocess .tmpl file in order to generate .sgml docs
 # conmakehash:	 Create arrays for initializing the kernel console tables
 
 host-progs    := fixdep split-include conmakehash docproc kallsyms modpost \
@@ -14,20 +14,20 @@ build-targets := $(host-progs) empty.o
 
 modpost-objs  := modpost.o file2alias.o
 
-clean-files := elfconfig.h
+subdir-$(CONFIG_MODVERSIONS)	+= genksyms
 
 # Let clean descend into subdirs
-subdir-	:= lxdialog kconfig
+subdir-	+= lxdialog kconfig
 
 # fixdep is needed to compile other host programs
-$(addprefix $(obj)/,$(filter-out fixdep,$(build-targets))): $(obj)/fixdep
+$(addprefix $(obj)/,$(filter-out fixdep,$(build-targets)) $(subdir-y)): $(obj)/fixdep
 
 # dependencies on generated files need to be listed explicitly
 
 $(obj)/modpost.o $(obj)/file2alias.o: $(obj)/elfconfig.h
 
 quiet_cmd_elfconfig = MKELF   $@
-      cmd_elfconfig = $(obj)/mk_elfconfig < $< > $@
+      cmd_elfconfig = $(obj)/mk_elfconfig $(ARCH) < $< > $@
 
 $(obj)/elfconfig.h: $(obj)/empty.o $(obj)/mk_elfconfig FORCE
 	$(call if_changed,elfconfig)

scripts/Makefile.build

@@ -90,8 +90,7 @@ define rule_vcc_o_c
 		mv $(@D)/.tmp_$(@F) $@;					      \
 	else								      \
 		$(CPP) -D__GENKSYMS__ $(c_flags) $<			      \
-		| $(GENKSYMS) -k $(VERSION).$(PATCHLEVEL).$(SUBLEVEL)	      \
-		| sed -n 's/\#define __ver_\([^ 	]*\)[ 	]*\([^ 	]*\)/__crc_\1 = 0x\2 ;/gp' \
+		| $(GENKSYMS)						      \
 		> $(@D)/.tmp_$(@F:.o=.ver);				      \
 									      \
 		$(LD) $(LDFLAGS) -r -o $@ $(@D)/.tmp_$(@F) 		      \

scripts/Makefile.clean

@@ -35,7 +35,7 @@ subdir-ymn	:= $(addprefix $(obj)/,$(subdir-ymn))
 
 # ==========================================================================
 
-__clean-files := $(wildcard $(EXTRA_TARGETS) $(host-progs) $(clean-files))
+__clean-files := $(wildcard $(EXTRA_TARGETS) $(host-progs) $(clean-files) $(targets))
 
 quiet_cmd_clean = CLEAN   $(obj)
       cmd_clean = rm -f $(__clean-files); $(clean-rule)

scripts/genksyms/Makefile

+
+host-progs	:= genksyms
+build-targets	:= $(host-progs)
+
+genksyms-objs	:= genksyms.o parse.o lex.o
+
+HOSTCFLAGS_parse.o := -Wno-uninitialized
+
+# dependencies on generated files need to be listed explicitly
+
+$(obj)/lex.o: $(obj)/parse.h $(obj)/keywords.c
+
+
+ifdef GENERATE_PARSER
+
+# gperf
+
+quiet_cmd_keywords.c = GPERF   $@
+      cmd_keywords.c = gperf -L ANSI-C -a -C -E -g -H is_reserved_hash	\
+		       -k 1,3,$$ -N is_reserved_word -p -t $< > $@
+
+$(obj)/keywords.c: $(obj)/keywords.gperf FORCE
+	$(call if_changed,keywords.c)
+
+# flex
+
+quiet_cmd_lex.c = FLEX    $@
+      cmd_lex.c = flex -o$@ -d $(filter-out FORCE,$^)
+
+$(obj)/lex.c: $(obj)/lex.l $(obj)/parse.h FORCE
+	$(call if_changed,lex.c)
+
+# bison
+
+quiet_cmd_parse.c = BISON   $@
+      cmd_parse.c = bison -o$@ -dtv $(filter-out FORCE,$^)
+
+$(obj)/parse.c: $(obj)/parse.y FORCE
+	$(call if_changed,parse.c)
+
+$(obj)/parse.h: $(obj)/parse.c ;
+
+clean-files	+= parse.output
+
+endif
+
+targets += $(obj)/keywords.c $(obj)/lex.c $(obj)/parse.c $(obj)/parse.h

scripts/genksyms/genksyms.h

+/* Generate kernel symbol version hashes.
+   Copyright 1996, 1997 Linux International.
+
+   New implementation contributed by Richard Henderson <rth@tamu.edu>
+   Based on original work by Bjorn Ekwall <bj0rn@blox.se>
+
+   This file is part of the Linux modutils.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#ifndef MODUTILS_GENKSYMS_H
+#define MODUTILS_GENKSYMS_H 1
+
+#include <stdio.h>
+#include <assert.h>
+
+
+enum symbol_type
+{
+  SYM_NORMAL, SYM_TYPEDEF, SYM_ENUM, SYM_STRUCT, SYM_UNION
+};
+
+struct string_list
+{
+  struct string_list *next;
+  enum symbol_type tag;
+  char *string;
+};
+
+struct symbol
+{
+  struct symbol *hash_next;
+  const char *name;
+  enum symbol_type type;
+  struct string_list *defn;
+  struct symbol *expansion_trail;
+  int is_extern;
+};
+
+typedef struct string_list **yystype;
+#define YYSTYPE yystype
+
+extern FILE *outfile, *debugfile;
+
+extern int cur_line;
+extern char *cur_filename, *output_directory;
+
+extern int flag_debug, flag_dump_defs, flag_warnings;
+extern int checksum_version, kernel_version;
+
+extern int want_brace_phrase, want_exp_phrase, discard_phrase_contents;
+extern struct string_list *current_list, *next_list;
+
+
+struct symbol *find_symbol(const char *name, enum symbol_type ns);
+struct symbol *add_symbol(const char *name, enum symbol_type type,
+			   struct string_list *defn, int is_extern);
+void export_symbol(const char *);
+
+struct string_list *reset_list(void);
+void free_list(struct string_list *s, struct string_list *e);
+void free_node(struct string_list *list);
+struct string_list *copy_node(struct string_list *);
+struct string_list *copy_list(struct string_list *s, struct string_list *e);
+int equal_list(struct string_list *a, struct string_list *b);
+void print_list(FILE *, struct string_list *list);
+
+int yylex(void);
+int yyparse(void);
+
+void error_with_pos(const char *, ...);
+
+#define version(a,b,c)  ((a << 16) | (b << 8) | (c))
+
+/*----------------------------------------------------------------------*/
+
+#define MODUTILS_VERSION "<in-kernel>"
+
+#define xmalloc(size) ({ void *__ptr = malloc(size); assert(__ptr || size == 0); __ptr; })
+#define xstrdup(str)  ({ char *__str = strdup(str); assert(__str); __str; })
+
+
+#endif /* genksyms.h */

scripts/genksyms/keywords.c_shipped

+/* ANSI-C code produced by gperf version 2.7.2 */
+/* Command-line: gperf -L ANSI-C -a -C -E -g -H is_reserved_hash -k '1,3,$' -N is_reserved_word -p -t scripts/genksyms/keywords.gperf  */
+struct resword { const char *name; int token; };
+/* maximum key range = 109, duplicates = 0 */
+
+#ifdef __GNUC__
+__inline
+#else
+#ifdef __cplusplus
+inline
+#endif
+#endif
+static unsigned int
+is_reserved_hash (register const char *str, register unsigned int len)
+{
+  static const unsigned char asso_values[] =
+    {
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113,   5,
+      113, 113, 113, 113, 113, 113,   0, 113, 113, 113,
+        0, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113,   0, 113,   0, 113,  20,
+       25,   0,  35,  30, 113,  20, 113, 113,  40,  30,
+       30,   0,   0, 113,   0,  51,   0,  15,   5, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+      113, 113, 113, 113, 113, 113
+    };
+  return len + asso_values[(unsigned char)str[2]] + asso_values[(unsigned char)str[0]] + asso_values[(unsigned char)str[len - 1]];
+}
+
+#ifdef __GNUC__
+__inline
+#endif
+const struct resword *
+is_reserved_word (register const char *str, register unsigned int len)
+{
+  enum
+    {
+      TOTAL_KEYWORDS = 41,
+      MIN_WORD_LENGTH = 3,
+      MAX_WORD_LENGTH = 17,
+      MIN_HASH_VALUE = 4,
+      MAX_HASH_VALUE = 112
+    };
+
+  static const struct resword wordlist[] =
+    {
+      {""}, {""}, {""}, {""},
+      {"auto", AUTO_KEYW},
+      {""}, {""},
+      {"__asm__", ASM_KEYW},
+      {""},
+      {"_restrict", RESTRICT_KEYW},
+      {"__typeof__", TYPEOF_KEYW},
+      {"__attribute", ATTRIBUTE_KEYW},
+      {"__restrict__", RESTRICT_KEYW},
+      {"__attribute__", ATTRIBUTE_KEYW},
+      {""},
+      {"__volatile", VOLATILE_KEYW},
+      {""},
+      {"__volatile__", VOLATILE_KEYW},
+      {"EXPORT_SYMBOL", EXPORT_SYMBOL_KEYW},
+      {""}, {""}, {""},
+      {"EXPORT_SYMBOL_GPL", EXPORT_SYMBOL_KEYW},
+      {"int", INT_KEYW},
+      {"char", CHAR_KEYW},
+      {""}, {""},
+      {"__const", CONST_KEYW},
+      {"__inline", INLINE_KEYW},
+      {"__const__", CONST_KEYW},
+      {"__inline__", INLINE_KEYW},
+      {""}, {""}, {""}, {""},
+      {"__asm", ASM_KEYW},
+      {"extern", EXTERN_KEYW},
+      {""},
+      {"register", REGISTER_KEYW},
+      {""},
+      {"float", FLOAT_KEYW},
+      {"typeof", TYPEOF_KEYW},
+      {"typedef", TYPEDEF_KEYW},
+      {""}, {""},
+      {"_Bool", BOOL_KEYW},
+      {"double", DOUBLE_KEYW},
+      {""}, {""},
+      {"enum", ENUM_KEYW},
+      {""}, {""}, {""},
+      {"volatile", VOLATILE_KEYW},
+      {"void", VOID_KEYW},
+      {"const", CONST_KEYW},
+      {"short", SHORT_KEYW},
+      {"struct", STRUCT_KEYW},
+      {""},
+      {"restrict", RESTRICT_KEYW},
+      {""},
+      {"__signed__", SIGNED_KEYW},
+      {""},
+      {"asm", ASM_KEYW},
+      {""}, {""},
+      {"inline", INLINE_KEYW},
+      {""}, {""}, {""},
+      {"union", UNION_KEYW},
+      {""}, {""}, {""}, {""}, {""}, {""},
+      {"static", STATIC_KEYW},
+      {""}, {""}, {""}, {""}, {""}, {""},
+      {"__signed", SIGNED_KEYW},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""},
+      {"unsigned", UNSIGNED_KEYW},
+      {""}, {""}, {""}, {""},
+      {"long", LONG_KEYW},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {"signed", SIGNED_KEYW}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = is_reserved_hash (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register const char *s = wordlist[key].name;
+
+          if (*str == *s && !strcmp (str + 1, s + 1))
+            return &wordlist[key];
+        }
+    }
+  return 0;
+}

scripts/genksyms/keywords.gperf

+%{
+%}
+struct resword { const char *name; int token; }
+%%
+EXPORT_SYMBOL, EXPORT_SYMBOL_KEYW
+EXPORT_SYMBOL_GPL, EXPORT_SYMBOL_KEYW
+__asm, ASM_KEYW
+__asm__, ASM_KEYW
+__attribute, ATTRIBUTE_KEYW
+__attribute__, ATTRIBUTE_KEYW
+__const, CONST_KEYW
+__const__, CONST_KEYW
+__inline, INLINE_KEYW
+__inline__, INLINE_KEYW
+__signed, SIGNED_KEYW
+__signed__, SIGNED_KEYW
+__volatile, VOLATILE_KEYW
+__volatile__, VOLATILE_KEYW
+# According to rth, c99 defines _Bool, __restrict, __restrict__, restrict.  KAO
+_Bool, BOOL_KEYW
+_restrict, RESTRICT_KEYW
+__restrict__, RESTRICT_KEYW
+restrict, RESTRICT_KEYW
+asm, ASM_KEYW
+# attribute commented out in modutils 2.4.2.  People are using 'attribute' as a
+# field name which breaks the genksyms parser.  It is not a gcc keyword anyway.
+# KAO.
+#   attribute, ATTRIBUTE_KEYW
+auto, AUTO_KEYW
+char, CHAR_KEYW
+const, CONST_KEYW
+double, DOUBLE_KEYW
+enum, ENUM_KEYW
+extern, EXTERN_KEYW
+float, FLOAT_KEYW
+inline, INLINE_KEYW
+int, INT_KEYW
+long, LONG_KEYW
+register, REGISTER_KEYW
+short, SHORT_KEYW
+signed, SIGNED_KEYW
+static, STATIC_KEYW
+struct, STRUCT_KEYW
+typedef, TYPEDEF_KEYW
+union, UNION_KEYW
+unsigned, UNSIGNED_KEYW
+void, VOID_KEYW
+volatile, VOLATILE_KEYW
+typeof, TYPEOF_KEYW
+__typeof__, TYPEOF_KEYW

scripts/genksyms/lex.l

+/* Lexical analysis for genksyms.
+   Copyright 1996, 1997 Linux International.
+
+   New implementation contributed by Richard Henderson <rth@tamu.edu>
+   Based on original work by Bjorn Ekwall <bj0rn@blox.se>
+
+   Taken from Linux modutils 2.4.22.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+%{
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "genksyms.h"
+#include "parse.h"
+
+/* We've got a two-level lexer here.  We let flex do basic tokenization
+   and then we categorize those basic tokens in the second stage.  */
+#define YY_DECL		static int yylex1(void)
+
+%}
+
+IDENT			[A-Za-z_][A-Za-z0-9_]*
+
+O_INT			0[0-7]*
+D_INT			[1-9][0-9]*
+X_INT			0[Xx][0-9A-Fa-f]+
+I_SUF			[Uu]|[Ll]|[Uu][Ll]|[Ll][Uu]
+INT			({O_INT}|{D_INT}|{X_INT}){I_SUF}?
+
+FRAC			([0-9]*\.[0-9]+)|([0-9]+\.)
+EXP			[Ee][+-]?[0-9]+
+F_SUF			[FfLl]
+REAL			({FRAC}{EXP}?{F_SUF}?)|([0-9]+{EXP}{F_SUF}?)
+
+STRING			L?\"([^\\\"]*\\.)*[^\\\"]*\"
+CHAR			L?\'([^\\\']*\\.)*[^\\\']*\'
+
+MC_TOKEN		([~%^&*+=|<>/-]=)|(&&)|("||")|(->)|(<<)|(>>)
+
+/* Version 2 checksumming does proper tokenization; version 1 wasn't
+   quite so pedantic.  */
+%s V2_TOKENS
+
+/* We don't do multiple input files.  */
+%option noyywrap
+
+%%
+
+
+ /* Keep track of our location in the original source files.  */
+^#[ \t]+{INT}[ \t]+\"[^\"\n]+\".*\n	return FILENAME;
+^#.*\n					cur_line++;
+\n					cur_line++;
+
+ /* Ignore all other whitespace.  */
+[ \t\f\v\r]+				;
+
+
+{STRING}				return STRING;
+{CHAR}					return CHAR;
+{IDENT}					return IDENT;
+
+ /* The Pedant requires that the other C multi-character tokens be
+    recognized as tokens.  We don't actually use them since we don't
+    parse expressions, but we do want whitespace to be arranged
+    around them properly.  */
+<V2_TOKENS>{MC_TOKEN}			return OTHER;
+<V2_TOKENS>{INT}			return INT;
+<V2_TOKENS>{REAL}			return REAL;
+
+"..."					return DOTS;
+
+ /* All other tokens are single characters.  */
+.					return yytext[0];
+
+
+%%
+
+/* Bring in the keyword recognizer.  */
+
+#include "keywords.c"
+
+
+/* Macros to append to our phrase collection list.  */
+
+#define _APP(T,L)	do {						   \
+			  cur_node = next_node;				   \
+			  next_node = xmalloc(sizeof(*next_node));	   \
+			  next_node->next = cur_node;			   \
+			  cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
+			  cur_node->tag = SYM_NORMAL;			   \
+			} while (0)
+
+#define APP		_APP(yytext, yyleng)
+
+
+/* The second stage lexer.  Here we incorporate knowledge of the state
+   of the parser to tailor the tokens that are returned.  */
+
+int
+yylex(void)
+{
+  static enum {
+    ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_BRACKET, ST_BRACE,
+    ST_EXPRESSION, ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4,
+    ST_TABLE_5, ST_TABLE_6
+  } lexstate = ST_NOTSTARTED;
+
+  static int suppress_type_lookup, dont_want_brace_phrase;
+  static struct string_list *next_node;
+
+  int token, count = 0;
+  struct string_list *cur_node;
+
+  if (lexstate == ST_NOTSTARTED)
+    {
+      BEGIN(V2_TOKENS);
+      next_node = xmalloc(sizeof(*next_node));
+      next_node->next = NULL;
+      lexstate = ST_NORMAL;
+    }
+
+repeat:
+  token = yylex1();
+
+  if (token == 0)
+    return 0;
+  else if (token == FILENAME)
+    {
+      char *file, *e;
+
+      /* Save the filename and line number for later error messages.  */
+
+      if (cur_filename)
+	free(cur_filename);
+
+      file = strchr(yytext, '\"')+1;
+      e = strchr(file, '\"');
+      *e = '\0';
+      cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
+      cur_line = atoi(yytext+2);
+
+      goto repeat;
+    }
+
+  switch (lexstate)
+    {
+    case ST_NORMAL:
+      switch (token)
+	{
+	case IDENT:
+	  APP;
+	  {
+	    const struct resword *r = is_reserved_word(yytext, yyleng);
+	    if (r)
+	      {
+		switch (token = r->token)
+		  {
+		  case ATTRIBUTE_KEYW:
+		    lexstate = ST_ATTRIBUTE;
+		    count = 0;
+		    goto repeat;
+		  case ASM_KEYW:
+		    lexstate = ST_ASM;
+		    count = 0;
+		    goto repeat;
+
+		  case STRUCT_KEYW:
+		  case UNION_KEYW:
+		    dont_want_brace_phrase = 3;
+		  case ENUM_KEYW:
+		    suppress_type_lookup = 2;
+		    goto fini;
+
+		  case EXPORT_SYMBOL_KEYW:
+		      goto fini;
+		  }
+	      }
+	    if (!suppress_type_lookup)
+	      {
+		struct symbol *sym = find_symbol(yytext, SYM_TYPEDEF);
+		if (sym && sym->type == SYM_TYPEDEF)
+		  token = TYPE;
+	      }
+	  }
+	  break;
+
+	case '[':
+	  APP;
+	  lexstate = ST_BRACKET;
+	  count = 1;
+	  goto repeat;
+
+	case '{':
+	  APP;
+	  if (dont_want_brace_phrase)
+	    break;
+	  lexstate = ST_BRACE;
+	  count = 1;
+	  goto repeat;
+
+	case '=': case ':':
+	  APP;
+	  lexstate = ST_EXPRESSION;
+	  break;
+
+	case DOTS:
+	default:
+	  APP;
+	  break;
+	}
+      break;
+
+    case ST_ATTRIBUTE:
+      APP;
+      switch (token)
+	{
+	case '(':
+	  ++count;
+	  goto repeat;
+	case ')':
+	  if (--count == 0)
+	    {
+	      lexstate = ST_NORMAL;
+	      token = ATTRIBUTE_PHRASE;
+	      break;
+	    }
+	  goto repeat;
+	default:
+	  goto repeat;
+	}
+      break;
+
+    case ST_ASM:
+      APP;
+      switch (token)
+	{
+	case '(':
+	  ++count;
+	  goto repeat;
+	case ')':
+	  if (--count == 0)
+	    {
+	      lexstate = ST_NORMAL;
+	      token = ASM_PHRASE;
+	      break;
+	    }
+	  goto repeat;
+	default:
+	  goto repeat;
+	}
+      break;
+
+    case ST_BRACKET:
+      APP;
+      switch (token)
+	{
+	case '[':
+	  ++count;
+	  goto repeat;
+	case ']':
+	  if (--count == 0)
+	    {
+	      lexstate = ST_NORMAL;
+	      token = BRACKET_PHRASE;
+	      break;
+	    }
+	  goto repeat;
+	default:
+	  goto repeat;
+	}
+      break;
+
+    case ST_BRACE:
+      APP;
+      switch (token)
+	{
+	case '{':
+	  ++count;
+	  goto repeat;
+	case '}':
+	  if (--count == 0)
+	    {
+	      lexstate = ST_NORMAL;
+	      token = BRACE_PHRASE;
+	      break;
+	    }
+	  goto repeat;
+	default:
+	  goto repeat;
+	}
+      break;
+
+    case ST_EXPRESSION:
+      switch (token)
+	{
+	case '(': case '[': case '{':
+	  ++count;
+	  APP;
+	  goto repeat;
+	case ')': case ']': case '}':
+	  --count;
+	  APP;
+	  goto repeat;
+	case ',': case ';':
+	  if (count == 0)
+	    {
+	      /* Put back the token we just read so's we can find it again
+		 after registering the expression.  */
+	      unput(token);
+
+	      lexstate = ST_NORMAL;
+	      token = EXPRESSION_PHRASE;
+	      break;
+	    }
+	  APP;
+	  goto repeat;
+	default:
+	  APP;
+	  goto repeat;
+	}
+      break;
+
+    case ST_TABLE_1:
+      goto repeat;
+
+    case ST_TABLE_2:
+      if (token == IDENT && yyleng == 1 && yytext[0] == 'X')
+	{
+	  token = EXPORT_SYMBOL_KEYW;
+	  lexstate = ST_TABLE_5;
+	  APP;
+	  break;
+	}
+      lexstate = ST_TABLE_6;
+      /* FALLTHRU */
+
+    case ST_TABLE_6:
+      switch (token)
+	{
+	case '{': case '[': case '(':
+	  ++count;
+	  break;
+	case '}': case ']': case ')':
+	  --count;
+	  break;
+	case ',':
+	  if (count == 0)
+	    lexstate = ST_TABLE_2;
+	  break;
+	};
+      goto repeat;
+
+    case ST_TABLE_3:
+      goto repeat;
+
+    case ST_TABLE_4:
+      if (token == ';')
+	lexstate = ST_NORMAL;
+      goto repeat;
+
+    case ST_TABLE_5:
+      switch (token)
+	{
+	case ',':
+	  token = ';';
+	  lexstate = ST_TABLE_2;
+	  APP;
+	  break;
+	default:
+	  APP;
+	  break;
+	}
+      break;
+
+    default:
+      abort();
+    }
+fini:
+
+  if (suppress_type_lookup > 0)
+    --suppress_type_lookup;
+  if (dont_want_brace_phrase > 0)
+    --dont_want_brace_phrase;
+
+  yylval = &next_node->next;
+
+  return token;
+}

scripts/genksyms/parse.h_shipped

+#ifndef YYSTYPE
+#define YYSTYPE int
+#endif
+#define	ASM_KEYW	257
+#define	ATTRIBUTE_KEYW	258
+#define	AUTO_KEYW	259
+#define	BOOL_KEYW	260
+#define	CHAR_KEYW	261
+#define	CONST_KEYW	262
+#define	DOUBLE_KEYW	263
+#define	ENUM_KEYW	264
+#define	EXTERN_KEYW	265
+#define	FLOAT_KEYW	266
+#define	INLINE_KEYW	267
+#define	INT_KEYW	268
+#define	LONG_KEYW	269
+#define	REGISTER_KEYW	270
+#define	RESTRICT_KEYW	271
+#define	SHORT_KEYW	272
+#define	SIGNED_KEYW	273
+#define	STATIC_KEYW	274
+#define	STRUCT_KEYW	275
+#define	TYPEDEF_KEYW	276
+#define	UNION_KEYW	277
+#define	UNSIGNED_KEYW	278
+#define	VOID_KEYW	279
+#define	VOLATILE_KEYW	280
+#define	TYPEOF_KEYW	281
+#define	EXPORT_SYMBOL_KEYW	282
+#define	ASM_PHRASE	283
+#define	ATTRIBUTE_PHRASE	284
+#define	BRACE_PHRASE	285
+#define	BRACKET_PHRASE	286
+#define	EXPRESSION_PHRASE	287
+#define	CHAR	288
+#define	DOTS	289
+#define	IDENT	290
+#define	INT	291
+#define	REAL	292
+#define	STRING	293
+#define	TYPE	294
+#define	OTHER	295
+#define	FILENAME	296
+
+
+extern YYSTYPE yylval;

scripts/mk_elfconfig.c

@@ -9,6 +9,9 @@ main(int argc, char **argv)
 	unsigned char ei[EI_NIDENT];	
 	union { short s; char c[2]; } endian_test;
 
+	if (argc != 2) {
+		fprintf(stderr, "Error: no arch\n");
+	}
 	if (fread(ei, 1, EI_NIDENT, stdin) != EI_NIDENT) {
 		fprintf(stderr, "Error: input truncated\n");
 		return 1;
@@ -52,6 +55,11 @@ main(int argc, char **argv)
 	else
 		abort();
 
+	if (strcmp(argv[1], "v850") == 0)
+		printf("#define MODULE_SYMBOL_PREFIX \"_\"\n");
+	else 
+		printf("#define MODULE_SYMBOL_PREFIX \"\"\n");
+
 	return 0;
 }
 

scripts/modpost.c

@@ -265,6 +265,9 @@ parse_elf_finish(struct elf_info *info)
 	munmap(info->hdr, info->size);
 }
 
+#define CRC_PFX     MODULE_SYMBOL_PREFIX "__crc_"
+#define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_"
+
 void
 handle_modversions(struct module *mod, struct elf_info *info,
 		   Elf_Sym *sym, const char *symname)
@@ -279,9 +282,10 @@ handle_modversions(struct module *mod, struct elf_info *info,
 		break;
 	case SHN_ABS:
 		/* CRC'd symbol */
-		if (memcmp(symname, "__crc_", 6) == 0) {
+		if (memcmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
 			crc = (unsigned int) sym->st_value;
-			add_exported_symbol(symname+6, mod, &crc);
+			add_exported_symbol(symname + strlen(CRC_PFX),
+					    mod, &crc);
 			modversions = 1;
 		}
 		break;
@@ -290,15 +294,20 @@ handle_modversions(struct module *mod, struct elf_info *info,
 		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL)
 			break;
 		
-		s = alloc_symbol(symname);
-		/* add to list */
-		s->next = mod->unres;
-		mod->unres = s;
+		if (memcmp(symname, MODULE_SYMBOL_PREFIX,
+			   strlen(MODULE_SYMBOL_PREFIX)) == 0) {
+			s = alloc_symbol(symname + 
+					 strlen(MODULE_SYMBOL_PREFIX));
+			/* add to list */
+			s->next = mod->unres;
+			mod->unres = s;
+		}
 		break;
 	default:
 		/* All exported symbols */
-		if (memcmp(symname, "__ksymtab_", 10) == 0) {
-			add_exported_symbol(symname+10, mod, NULL);
+		if (memcmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
+			add_exported_symbol(symname + strlen(KSYMTAB_PFX),
+					    mod, NULL);
 		}
 		break;
 	}