obj-$(CONFIG_X86_32)   += common.o bugs.o cmpxchg.o
 obj-$(CONFIG_X86_64)   += common_64.o bugs_64.o
 
+obj-$(CONFIG_CPU_SUP_INTEL_32)         += intel.o
+obj-$(CONFIG_CPU_SUP_INTEL_64)         += intel_64.o
 obj-$(CONFIG_CPU_SUP_AMD_32)           += amd.o
 obj-$(CONFIG_CPU_SUP_AMD_64)           += amd_64.o
 obj-$(CONFIG_CPU_SUP_CYRIX_32)         += cyrix.o
 obj-$(CONFIG_CPU_SUP_CENTAUR_32)       += centaur.o
 obj-$(CONFIG_CPU_SUP_CENTAUR_64)       += centaur_64.o
 obj-$(CONFIG_CPU_SUP_TRANSMETA_32)     += transmeta.o
-obj-$(CONFIG_CPU_SUP_INTEL_32)         += intel.o
-obj-$(CONFIG_CPU_SUP_INTEL_64)         += intel_64.o
 obj-$(CONFIG_CPU_SUP_UMC_32)           += umc.o
 
 obj-$(CONFIG_X86_MCE)  += mcheck/
 
        .c_early_init   = early_init_amd,
        .c_init         = init_amd,
        .c_size_cache   = amd_size_cache,
+       .c_x86_vendor   = X86_VENDOR_AMD,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_AMD, &amd_cpu_dev);
+cpu_dev_register(amd_cpu_dev);
 
        .c_ident        = { "AuthenticAMD" },
        .c_early_init   = early_init_amd,
        .c_init         = init_amd,
+       .c_x86_vendor   = X86_VENDOR_AMD,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_AMD, &amd_cpu_dev);
-
+cpu_dev_register(amd_cpu_dev);
 
        .c_early_init   = early_init_centaur,
        .c_init         = init_centaur,
        .c_size_cache   = centaur_size_cache,
+       .c_x86_vendor   = X86_VENDOR_CENTAUR,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_CENTAUR, ¢aur_cpu_dev);
+cpu_dev_register(centaur_cpu_dev);
 
        .c_ident        = { "CentaurHauls" },
        .c_early_init   = early_init_centaur,
        .c_init         = init_centaur,
+       .c_x86_vendor   = X86_VENDOR_CENTAUR,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_CENTAUR, ¢aur_cpu_dev);
+cpu_dev_register(centaur_cpu_dev);
 
 
 static int cachesize_override __cpuinitdata = -1;
 static int disable_x86_serial_nr __cpuinitdata = 1;
 
-struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
+static struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
 
 static void __cpuinit default_init(struct cpuinfo_x86 *c)
 {
 static struct cpu_dev __cpuinitdata default_cpu = {
        .c_init = default_init,
        .c_vendor = "Unknown",
+       .c_x86_vendor = X86_VENDOR_UNKNOWN,
 };
-static struct cpu_dev *this_cpu __cpuinitdata = &default_cpu;
+static struct cpu_dev *this_cpu __cpuinitdata;
 
 static int __init cachesize_setup(char *str)
 {
        static int printed;
 
        for (i = 0; i < X86_VENDOR_NUM; i++) {
-               if (cpu_devs[i]) {
-                       if (!strcmp(v, cpu_devs[i]->c_ident[0]) ||
-                           (cpu_devs[i]->c_ident[1] &&
-                            !strcmp(v, cpu_devs[i]->c_ident[1]))) {
-                               c->x86_vendor = i;
-                               this_cpu = cpu_devs[i];
-                               return;
-                       }
+               if (!cpu_devs[i])
+                       break;
+
+               if (!strcmp(v, cpu_devs[i]->c_ident[0]) ||
+                   (cpu_devs[i]->c_ident[1] &&
+                    !strcmp(v, cpu_devs[i]->c_ident[1]))) {
+                       this_cpu = cpu_devs[i];
+                       c->x86_vendor = this_cpu->c_x86_vendor;
+                       return;
                }
        }
+
        if (!printed) {
                printed++;
                printk(KERN_ERR "CPU: Vendor unknown, using generic init.\n");
                printk(KERN_ERR "CPU: Your system may be unstable.\n");
        }
+
        c->x86_vendor = X86_VENDOR_UNKNOWN;
        this_cpu = &default_cpu;
 }
        return flag_is_changeable_p(X86_EFLAGS_ID);
 }
 
-static void __init early_cpu_support_print(void)
-{
-       int i,j;
-       struct cpu_dev *cpu_devx;
-
-       printk("KERNEL supported cpus:\n");
-       for (i = 0; i < X86_VENDOR_NUM; i++) {
-               cpu_devx = cpu_devs[i];
-               if (!cpu_devx)
-                       continue;
-               for (j = 0; j < 2; j++) {
-                       if (!cpu_devx->c_ident[j])
-                               continue;
-                       printk("  %s %s\n", cpu_devx->c_vendor,
-                               cpu_devx->c_ident[j]);
-               }
-       }
-}
-
 void __cpuinit cpu_detect(struct cpuinfo_x86 *c)
 {
        /* Get vendor name */
 
        get_cpu_cap(c);
 
-       if (c->x86_vendor != X86_VENDOR_UNKNOWN &&
-           cpu_devs[c->x86_vendor]->c_early_init)
-               cpu_devs[c->x86_vendor]->c_early_init(c);
+       if (this_cpu->c_early_init)
+               this_cpu->c_early_init(c);
 
        validate_pat_support(c);
 }
 
 void __init early_cpu_init(void)
 {
-       struct cpu_vendor_dev *cvdev;
+       struct cpu_dev **cdev;
+       int count = 0;
+
+       printk("KERNEL supported cpus:\n");
+       for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) {
+               struct cpu_dev *cpudev = *cdev;
+               unsigned int j;
 
-       for (cvdev = __x86cpuvendor_start; cvdev < __x86cpuvendor_end; cvdev++)
-               cpu_devs[cvdev->vendor] = cvdev->cpu_dev;
+               if (count >= X86_VENDOR_NUM)
+                       break;
+               cpu_devs[count] = cpudev;
+               count++;
+
+               for (j = 0; j < 2; j++) {
+                       if (!cpudev->c_ident[j])
+                               continue;
+                       printk("  %s %s\n", cpudev->c_vendor,
+                               cpudev->c_ident[j]);
+               }
+       }
 
-       early_cpu_support_print();
        early_identify_cpu(&boot_cpu_data);
 }
 
 
        load_gdt(&gdt_descr);
 }
 
-struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
+static struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
 
 static void __cpuinit default_init(struct cpuinfo_x86 *c)
 {
 static struct cpu_dev __cpuinitdata default_cpu = {
        .c_init = default_init,
        .c_vendor = "Unknown",
+       .c_x86_vendor = X86_VENDOR_UNKNOWN,
 };
-static struct cpu_dev *this_cpu __cpuinitdata = &default_cpu;
+static struct cpu_dev *this_cpu __cpuinitdata;
 
 int __cpuinit get_model_name(struct cpuinfo_x86 *c)
 {
        static int printed;
 
        for (i = 0; i < X86_VENDOR_NUM; i++) {
-               if (cpu_devs[i]) {
-                       if (!strcmp(v, cpu_devs[i]->c_ident[0]) ||
-                           (cpu_devs[i]->c_ident[1] &&
-                            !strcmp(v, cpu_devs[i]->c_ident[1]))) {
-                               c->x86_vendor = i;
-                               this_cpu = cpu_devs[i];
-                               return;
-                       }
+               if (!cpu_devs[i])
+                       break;
+
+               if (!strcmp(v, cpu_devs[i]->c_ident[0]) ||
+                   (cpu_devs[i]->c_ident[1] &&
+                    !strcmp(v, cpu_devs[i]->c_ident[1]))) {
+                       this_cpu = cpu_devs[i];
+                       c->x86_vendor = this_cpu->c_x86_vendor;
+                       return;
                }
        }
+
        if (!printed) {
                printed++;
                printk(KERN_ERR "CPU: Vendor unknown, using generic init.\n");
                printk(KERN_ERR "CPU: Your system may be unstable.\n");
        }
+
        c->x86_vendor = X86_VENDOR_UNKNOWN;
        this_cpu = &default_cpu;
 }
 
-static void __init early_cpu_support_print(void)
-{
-       int i,j;
-       struct cpu_dev *cpu_devx;
-
-       printk("KERNEL supported cpus:\n");
-       for (i = 0; i < X86_VENDOR_NUM; i++) {
-               cpu_devx = cpu_devs[i];
-               if (!cpu_devx)
-                       continue;
-               for (j = 0; j < 2; j++) {
-                       if (!cpu_devx->c_ident[j])
-                               continue;
-                       printk("  %s %s\n", cpu_devx->c_vendor,
-                               cpu_devx->c_ident[j]);
-               }
-       }
-}
-
 void __cpuinit cpu_detect(struct cpuinfo_x86 *c)
 {
        /* Get vendor name */
 
        get_cpu_cap(c);
 
-       if (c->x86_vendor != X86_VENDOR_UNKNOWN &&
-           cpu_devs[c->x86_vendor]->c_early_init)
-               cpu_devs[c->x86_vendor]->c_early_init(c);
+       if (this_cpu->c_early_init)
+               this_cpu->c_early_init(c);
 
        validate_pat_support(c);
 }
 
 void __init early_cpu_init(void)
 {
-       struct cpu_vendor_dev *cvdev;
+       struct cpu_dev **cdev;
+       int count = 0;
+
+       printk("KERNEL supported cpus:\n");
+       for (cdev = __x86_cpu_dev_start; cdev < __x86_cpu_dev_end; cdev++) {
+               struct cpu_dev *cpudev = *cdev;
+               unsigned int j;
 
-       for (cvdev = __x86cpuvendor_start; cvdev < __x86cpuvendor_end; cvdev++)
-               cpu_devs[cvdev->vendor] = cvdev->cpu_dev;
+               if (count >= X86_VENDOR_NUM)
+                       break;
+               cpu_devs[count] = cpudev;
+               count++;
+
+               for (j = 0; j < 2; j++) {
+                       if (!cpudev->c_ident[j])
+                               continue;
+                       printk("  %s %s\n", cpudev->c_vendor,
+                               cpudev->c_ident[j]);
+               }
+       }
 
-       early_cpu_support_print();
        early_identify_cpu(&boot_cpu_data);
 }
 
 
        void            (*c_init)(struct cpuinfo_x86 * c);
        void            (*c_identify)(struct cpuinfo_x86 * c);
        unsigned int    (*c_size_cache)(struct cpuinfo_x86 * c, unsigned int size);
+       int     c_x86_vendor;
 };
 
-extern struct cpu_dev * cpu_devs [X86_VENDOR_NUM];
+#define cpu_dev_register(cpu_devX) \
+       static struct cpu_dev *__cpu_dev_##cpu_devX __used \
+       __attribute__((__section__(".x86_cpu_dev.init"))) = \
+       &cpu_devX;
 
-struct cpu_vendor_dev {
-       int vendor;
-       struct cpu_dev *cpu_dev;
-};
-
-#define cpu_vendor_dev_register(cpu_vendor_id, cpu_dev) \
-       static struct cpu_vendor_dev __cpu_vendor_dev_##cpu_vendor_id __used \
-       __attribute__((__section__(".x86cpuvendor.init"))) = \
-       { cpu_vendor_id, cpu_dev }
-
-extern struct cpu_vendor_dev __x86cpuvendor_start[], __x86cpuvendor_end[];
+extern struct cpu_dev *__x86_cpu_dev_start[], *__x86_cpu_dev_end[];
 
 extern int get_model_name(struct cpuinfo_x86 *c);
 extern void display_cacheinfo(struct cpuinfo_x86 *c);
 
        .c_early_init   = early_init_cyrix,
        .c_init         = init_cyrix,
        .c_identify     = cyrix_identify,
+       .c_x86_vendor   = X86_VENDOR_CYRIX,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_CYRIX, &cyrix_cpu_dev);
+cpu_dev_register(cyrix_cpu_dev);
 
 static struct cpu_dev nsc_cpu_dev __cpuinitdata = {
        .c_vendor       = "NSC",
        .c_ident        = { "Geode by NSC" },
        .c_init         = init_nsc,
+       .c_x86_vendor   = X86_VENDOR_NSC,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_NSC, &nsc_cpu_dev);
+cpu_dev_register(nsc_cpu_dev);
 
        .c_early_init   = early_init_intel,
        .c_init         = init_intel,
        .c_size_cache   = intel_size_cache,
+       .c_x86_vendor   = X86_VENDOR_INTEL,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_INTEL, &intel_cpu_dev);
+cpu_dev_register(intel_cpu_dev);
 
 /* arch_initcall(intel_cpu_init); */
 
 
        .c_ident        = { "GenuineIntel" },
        .c_early_init   = early_init_intel,
        .c_init         = init_intel,
+       .c_x86_vendor   = X86_VENDOR_INTEL,
 };
-cpu_vendor_dev_register(X86_VENDOR_INTEL, &intel_cpu_dev);
 
+cpu_dev_register(intel_cpu_dev);
 
        .c_ident        = { "GenuineTMx86", "TransmetaCPU" },
        .c_init         = init_transmeta,
        .c_identify     = transmeta_identify,
+       .c_x86_vendor   = X86_VENDOR_TRANSMETA,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_TRANSMETA, &transmeta_cpu_dev);
+cpu_dev_register(transmeta_cpu_dev);
 
                  }
                },
        },
+       .c_x86_vendor   = X86_VENDOR_UMC,
 };
 
-cpu_vendor_dev_register(X86_VENDOR_UMC, &umc_cpu_dev);
+cpu_dev_register(umc_cpu_dev);
 
 
        *(.con_initcall.init)
        __con_initcall_end = .;
   }
-  .x86cpuvendor.init : AT(ADDR(.x86cpuvendor.init) - LOAD_OFFSET) {
-       __x86cpuvendor_start = .;
-       *(.x86cpuvendor.init)
-       __x86cpuvendor_end = .;
+  .x86_cpu_dev.init : AT(ADDR(.x86_cpu_dev.init) - LOAD_OFFSET) {
+       __x86_cpu_dev_start = .;
+       *(.x86_cpu_dev.init)
+       __x86_cpu_dev_end = .;
   }
   SECURITY_INIT
   . = ALIGN(4);
 
        *(.con_initcall.init)
   }
   __con_initcall_end = .;
-  . = ALIGN(16);
-  __x86cpuvendor_start = .;
-  .x86cpuvendor.init : AT(ADDR(.x86cpuvendor.init) - LOAD_OFFSET) {
-       *(.x86cpuvendor.init)
+  __x86_cpu_dev_start = .;
+  .x86_cpu_dev.init : AT(ADDR(.x86_cpu_dev.init) - LOAD_OFFSET) {
+       *(.x86_cpu_dev.init)
   }
-  __x86cpuvendor_end = .;
   SECURITY_INIT
+  __x86_cpu_dev_end = .;
 
   . = ALIGN(8);
   .parainstructions : AT(ADDR(.parainstructions) - LOAD_OFFSET) {