sparc: Remove unnecessary semicolons
[linux-2.6.git] / arch / sparc / kernel / module.c
index 598682f..99ba5ba 100644 (file)
@@ -1,4 +1,4 @@
-/* Kernel module help for sparc32.
+/* Kernel module help for sparc64.
  *
  * Copyright (C) 2001 Rusty Russell.
  * Copyright (C) 2002 David S. Miller.
@@ -9,8 +9,47 @@
 #include <linux/elf.h>
 #include <linux/vmalloc.h>
 #include <linux/fs.h>
+#include <linux/gfp.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
+#include <linux/mm.h>
+
+#include <asm/processor.h>
+#include <asm/spitfire.h>
+
+#ifdef CONFIG_SPARC64
+
+#include <linux/jump_label.h>
+
+static void *module_map(unsigned long size)
+{
+       if (PAGE_ALIGN(size) > MODULES_LEN)
+               return NULL;
+       return __vmalloc_node_range(size, 1, MODULES_VADDR, MODULES_END,
+                               GFP_KERNEL, PAGE_KERNEL, -1,
+                               __builtin_return_address(0));
+}
+
+static char *dot2underscore(char *name)
+{
+       return name;
+}
+#else
+static void *module_map(unsigned long size)
+{
+       return vmalloc(size);
+}
+
+/* Replace references to .func with _Func */
+static char *dot2underscore(char *name)
+{
+       if (name[0] == '.') {
+               name[0] = '_';
+                name[1] = toupper(name[1]);
+       }
+       return name;
+}
+#endif /* CONFIG_SPARC64 */
 
 void *module_alloc(unsigned long size)
 {
@@ -20,7 +59,7 @@ void *module_alloc(unsigned long size)
        if (size == 0)
                return NULL;
 
-       ret = vmalloc(size);
+       ret = module_map(size);
        if (!ret)
                ret = ERR_PTR(-ENOMEM);
        else
@@ -33,20 +72,16 @@ void *module_alloc(unsigned long size)
 void module_free(struct module *mod, void *module_region)
 {
        vfree(module_region);
-       /* FIXME: If module_region == mod->init_region, trim exception
-           table entries. */
 }
 
-/* Make generic code ignore STT_REGISTER dummy undefined symbols,
- * and replace references to .func with _Func
- */
+/* Make generic code ignore STT_REGISTER dummy undefined symbols.  */
 int module_frob_arch_sections(Elf_Ehdr *hdr,
                              Elf_Shdr *sechdrs,
                              char *secstrings,
                              struct module *mod)
 {
        unsigned int symidx;
-       Elf32_Sym *sym;
+       Elf_Sym *sym;
        char *strtab;
        int i;
 
@@ -56,26 +91,23 @@ int module_frob_arch_sections(Elf_Ehdr *hdr,
                        return -ENOEXEC;
                }
        }
-       sym = (Elf32_Sym *)sechdrs[symidx].sh_addr;
+       sym = (Elf_Sym *)sechdrs[symidx].sh_addr;
        strtab = (char *)sechdrs[sechdrs[symidx].sh_link].sh_addr;
 
        for (i = 1; i < sechdrs[symidx].sh_size / sizeof(Elf_Sym); i++) {
                if (sym[i].st_shndx == SHN_UNDEF) {
-                       if (ELF32_ST_TYPE(sym[i].st_info) == STT_REGISTER)
+                       if (ELF_ST_TYPE(sym[i].st_info) == STT_REGISTER) {
                                sym[i].st_shndx = SHN_ABS;
-                       else {
+                       } else {
                                char *name = strtab + sym[i].st_name;
-                               if (name[0] == '.') {
-                                       name[0] = '_';
-                                       name[1] = toupper(name[1]);
-                               }
+                               dot2underscore(name);
                        }
                }
        }
        return 0;
 }
 
-int apply_relocate(Elf32_Shdr *sechdrs,
+int apply_relocate(Elf_Shdr *sechdrs,
                   const char *strtab,
                   unsigned int symindex,
                   unsigned int relsec,
@@ -86,32 +118,68 @@ int apply_relocate(Elf32_Shdr *sechdrs,
        return -ENOEXEC;
 }
 
-int apply_relocate_add(Elf32_Shdr *sechdrs,
+int apply_relocate_add(Elf_Shdr *sechdrs,
                       const char *strtab,
                       unsigned int symindex,
                       unsigned int relsec,
                       struct module *me)
 {
        unsigned int i;
-       Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr;
-       Elf32_Sym *sym;
+       Elf_Rela *rel = (void *)sechdrs[relsec].sh_addr;
+       Elf_Sym *sym;
        u8 *location;
        u32 *loc32;
 
        for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
-               Elf32_Addr v;
+               Elf_Addr v;
 
                /* This is where to make the change */
                location = (u8 *)sechdrs[sechdrs[relsec].sh_info].sh_addr
                        + rel[i].r_offset;
                loc32 = (u32 *) location;
+
+#ifdef CONFIG_SPARC64
+               BUG_ON(((u64)location >> (u64)32) != (u64)0);
+#endif /* CONFIG_SPARC64 */
+
                /* This is the symbol it is referring to.  Note that all
                   undefined symbols have been resolved.  */
-               sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
-                       + ELF32_R_SYM(rel[i].r_info);
+               sym = (Elf_Sym *)sechdrs[symindex].sh_addr
+                       + ELF_R_SYM(rel[i].r_info);
                v = sym->st_value + rel[i].r_addend;
 
-               switch (ELF32_R_TYPE(rel[i].r_info)) {
+               switch (ELF_R_TYPE(rel[i].r_info) & 0xff) {
+#ifdef CONFIG_SPARC64
+               case R_SPARC_64:
+                       location[0] = v >> 56;
+                       location[1] = v >> 48;
+                       location[2] = v >> 40;
+                       location[3] = v >> 32;
+                       location[4] = v >> 24;
+                       location[5] = v >> 16;
+                       location[6] = v >>  8;
+                       location[7] = v >>  0;
+                       break;
+
+               case R_SPARC_DISP32:
+                       v -= (Elf_Addr) location;
+                       *loc32 = v;
+                       break;
+
+               case R_SPARC_WDISP19:
+                       v -= (Elf_Addr) location;
+                       *loc32 = (*loc32 & ~0x7ffff) |
+                               ((v >> 2) & 0x7ffff);
+                       break;
+
+               case R_SPARC_OLO10:
+                       *loc32 = (*loc32 & ~0x1fff) |
+                               (((v & 0x3ff) +
+                                 (ELF_R_TYPE(rel[i].r_info) >> 8))
+                                & 0x1fff);
+                       break;
+#endif /* CONFIG_SPARC64 */
+
                case R_SPARC_32:
                case R_SPARC_UA32:
                        location[0] = v >> 24;
@@ -121,13 +189,13 @@ int apply_relocate_add(Elf32_Shdr *sechdrs,
                        break;
 
                case R_SPARC_WDISP30:
-                       v -= (Elf32_Addr) location;
+                       v -= (Elf_Addr) location;
                        *loc32 = (*loc32 & ~0x3fffffff) |
                                ((v >> 2) & 0x3fffffff);
                        break;
 
                case R_SPARC_WDISP22:
-                       v -= (Elf32_Addr) location;
+                       v -= (Elf_Addr) location;
                        *loc32 = (*loc32 & ~0x3fffff) |
                                ((v >> 2) & 0x3fffff);
                        break;
@@ -144,19 +212,41 @@ int apply_relocate_add(Elf32_Shdr *sechdrs,
                default:
                        printk(KERN_ERR "module %s: Unknown relocation: %x\n",
                               me->name,
-                              (int) (ELF32_R_TYPE(rel[i].r_info) & 0xff));
+                              (int) (ELF_R_TYPE(rel[i].r_info) & 0xff));
                        return -ENOEXEC;
-               };
+               }
        }
        return 0;
 }
 
+#ifdef CONFIG_SPARC64
 int module_finalize(const Elf_Ehdr *hdr,
                    const Elf_Shdr *sechdrs,
                    struct module *me)
 {
+       /* make jump label nops */
+       jump_label_apply_nops(me);
+
+       /* Cheetah's I-cache is fully coherent.  */
+       if (tlb_type == spitfire) {
+               unsigned long va;
+
+               flushw_all();
+               for (va =  0; va < (PAGE_SIZE << 1); va += 32)
+                       spitfire_put_icache_tag(va, 0x0);
+               __asm__ __volatile__("flush %g6");
+       }
+
        return 0;
 }
+#else
+int module_finalize(const Elf_Ehdr *hdr,
+                    const Elf_Shdr *sechdrs,
+                    struct module *me)
+{
+        return 0;
+}
+#endif /* CONFIG_SPARC64 */
 
 void module_arch_cleanup(struct module *mod)
 {