include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / arch / parisc / kernel / module.c
1 /*    Kernel dynamically loadable module help for PARISC.
2  *
3  *    The best reference for this stuff is probably the Processor-
4  *    Specific ELF Supplement for PA-RISC:
5  *        http://ftp.parisc-linux.org/docs/arch/elf-pa-hp.pdf
6  *
7  *    Linux/PA-RISC Project (http://www.parisc-linux.org/)
8  *    Copyright (C) 2003 Randolph Chung <tausq at debian . org>
9  *    Copyright (C) 2008 Helge Deller <deller@gmx.de>
10  *
11  *
12  *    This program is free software; you can redistribute it and/or modify
13  *    it under the terms of the GNU General Public License as published by
14  *    the Free Software Foundation; either version 2 of the License, or
15  *    (at your option) any later version.
16  *
17  *    This program is distributed in the hope that it will be useful,
18  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *    GNU General Public License for more details.
21  *
22  *    You should have received a copy of the GNU General Public License
23  *    along with this program; if not, write to the Free Software
24  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25  *
26  *
27  *    Notes:
28  *    - PLT stub handling
29  *      On 32bit (and sometimes 64bit) and with big kernel modules like xfs or
30  *      ipv6 the relocation types R_PARISC_PCREL17F and R_PARISC_PCREL22F may
31  *      fail to reach their PLT stub if we only create one big stub array for
32  *      all sections at the beginning of the core or init section.
33  *      Instead we now insert individual PLT stub entries directly in front of
34  *      of the code sections where the stubs are actually called.
35  *      This reduces the distance between the PCREL location and the stub entry
36  *      so that the relocations can be fulfilled.
37  *      While calculating the final layout of the kernel module in memory, the
38  *      kernel module loader calls arch_mod_section_prepend() to request the
39  *      to be reserved amount of memory in front of each individual section.
40  *
41  *    - SEGREL32 handling
42  *      We are not doing SEGREL32 handling correctly. According to the ABI, we
43  *      should do a value offset, like this:
44  *                      if (in_init(me, (void *)val))
45  *                              val -= (uint32_t)me->module_init;
46  *                      else
47  *                              val -= (uint32_t)me->module_core;
48  *      However, SEGREL32 is used only for PARISC unwind entries, and we want
49  *      those entries to have an absolute address, and not just an offset.
50  *
51  *      The unwind table mechanism has the ability to specify an offset for 
52  *      the unwind table; however, because we split off the init functions into
53  *      a different piece of memory, it is not possible to do this using a 
54  *      single offset. Instead, we use the above hack for now.
55  */
56
57 #include <linux/moduleloader.h>
58 #include <linux/elf.h>
59 #include <linux/vmalloc.h>
60 #include <linux/fs.h>
61 #include <linux/string.h>
62 #include <linux/kernel.h>
63 #include <linux/bug.h>
64 #include <linux/slab.h>
65
66 #include <asm/unwind.h>
67
68 #if 0
69 #define DEBUGP printk
70 #else
71 #define DEBUGP(fmt...)
72 #endif
73
74 #define RELOC_REACHABLE(val, bits) \
75         (( ( !((val) & (1<<((bits)-1))) && ((val)>>(bits)) != 0 )  ||   \
76              ( ((val) & (1<<((bits)-1))) && ((val)>>(bits)) != (((__typeof__(val))(~0))>>((bits)+2)))) ? \
77         0 : 1)
78
79 #define CHECK_RELOC(val, bits) \
80         if (!RELOC_REACHABLE(val, bits)) { \
81                 printk(KERN_ERR "module %s relocation of symbol %s is out of range (0x%lx in %d bits)\n", \
82                 me->name, strtab + sym->st_name, (unsigned long)val, bits); \
83                 return -ENOEXEC;                        \
84         }
85
86 /* Maximum number of GOT entries. We use a long displacement ldd from
87  * the bottom of the table, which has a maximum signed displacement of
88  * 0x3fff; however, since we're only going forward, this becomes
89  * 0x1fff, and thus, since each GOT entry is 8 bytes long we can have
90  * at most 1023 entries.
91  * To overcome this 14bit displacement with some kernel modules, we'll
92  * use instead the unusal 16bit displacement method (see reassemble_16a)
93  * which gives us a maximum positive displacement of 0x7fff, and as such
94  * allows us to allocate up to 4095 GOT entries. */
95 #define MAX_GOTS        4095
96
97 /* three functions to determine where in the module core
98  * or init pieces the location is */
99 static inline int in_init(struct module *me, void *loc)
100 {
101         return (loc >= me->module_init &&
102                 loc <= (me->module_init + me->init_size));
103 }
104
105 static inline int in_core(struct module *me, void *loc)
106 {
107         return (loc >= me->module_core &&
108                 loc <= (me->module_core + me->core_size));
109 }
110
111 static inline int in_local(struct module *me, void *loc)
112 {
113         return in_init(me, loc) || in_core(me, loc);
114 }
115
116 #ifndef CONFIG_64BIT
117 struct got_entry {
118         Elf32_Addr addr;
119 };
120
121 struct stub_entry {
122         Elf32_Word insns[2]; /* each stub entry has two insns */
123 };
124 #else
125 struct got_entry {
126         Elf64_Addr addr;
127 };
128
129 struct stub_entry {
130         Elf64_Word insns[4]; /* each stub entry has four insns */
131 };
132 #endif
133
134 /* Field selection types defined by hppa */
135 #define rnd(x)                  (((x)+0x1000)&~0x1fff)
136 /* fsel: full 32 bits */
137 #define fsel(v,a)               ((v)+(a))
138 /* lsel: select left 21 bits */
139 #define lsel(v,a)               (((v)+(a))>>11)
140 /* rsel: select right 11 bits */
141 #define rsel(v,a)               (((v)+(a))&0x7ff)
142 /* lrsel with rounding of addend to nearest 8k */
143 #define lrsel(v,a)              (((v)+rnd(a))>>11)
144 /* rrsel with rounding of addend to nearest 8k */
145 #define rrsel(v,a)              ((((v)+rnd(a))&0x7ff)+((a)-rnd(a)))
146
147 #define mask(x,sz)              ((x) & ~((1<<(sz))-1))
148
149
150 /* The reassemble_* functions prepare an immediate value for
151    insertion into an opcode. pa-risc uses all sorts of weird bitfields
152    in the instruction to hold the value.  */
153 static inline int sign_unext(int x, int len)
154 {
155         int len_ones;
156
157         len_ones = (1 << len) - 1;
158         return x & len_ones;
159 }
160
161 static inline int low_sign_unext(int x, int len)
162 {
163         int sign, temp;
164
165         sign = (x >> (len-1)) & 1;
166         temp = sign_unext(x, len-1);
167         return (temp << 1) | sign;
168 }
169
170 static inline int reassemble_14(int as14)
171 {
172         return (((as14 & 0x1fff) << 1) |
173                 ((as14 & 0x2000) >> 13));
174 }
175
176 static inline int reassemble_16a(int as16)
177 {
178         int s, t;
179
180         /* Unusual 16-bit encoding, for wide mode only.  */
181         t = (as16 << 1) & 0xffff;
182         s = (as16 & 0x8000);
183         return (t ^ s ^ (s >> 1)) | (s >> 15);
184 }
185
186
187 static inline int reassemble_17(int as17)
188 {
189         return (((as17 & 0x10000) >> 16) |
190                 ((as17 & 0x0f800) << 5) |
191                 ((as17 & 0x00400) >> 8) |
192                 ((as17 & 0x003ff) << 3));
193 }
194
195 static inline int reassemble_21(int as21)
196 {
197         return (((as21 & 0x100000) >> 20) |
198                 ((as21 & 0x0ffe00) >> 8) |
199                 ((as21 & 0x000180) << 7) |
200                 ((as21 & 0x00007c) << 14) |
201                 ((as21 & 0x000003) << 12));
202 }
203
204 static inline int reassemble_22(int as22)
205 {
206         return (((as22 & 0x200000) >> 21) |
207                 ((as22 & 0x1f0000) << 5) |
208                 ((as22 & 0x00f800) << 5) |
209                 ((as22 & 0x000400) >> 8) |
210                 ((as22 & 0x0003ff) << 3));
211 }
212
213 void *module_alloc(unsigned long size)
214 {
215         if (size == 0)
216                 return NULL;
217         return vmalloc(size);
218 }
219
220 #ifndef CONFIG_64BIT
221 static inline unsigned long count_gots(const Elf_Rela *rela, unsigned long n)
222 {
223         return 0;
224 }
225
226 static inline unsigned long count_fdescs(const Elf_Rela *rela, unsigned long n)
227 {
228         return 0;
229 }
230
231 static inline unsigned long count_stubs(const Elf_Rela *rela, unsigned long n)
232 {
233         unsigned long cnt = 0;
234
235         for (; n > 0; n--, rela++)
236         {
237                 switch (ELF32_R_TYPE(rela->r_info)) {
238                         case R_PARISC_PCREL17F:
239                         case R_PARISC_PCREL22F:
240                                 cnt++;
241                 }
242         }
243
244         return cnt;
245 }
246 #else
247 static inline unsigned long count_gots(const Elf_Rela *rela, unsigned long n)
248 {
249         unsigned long cnt = 0;
250
251         for (; n > 0; n--, rela++)
252         {
253                 switch (ELF64_R_TYPE(rela->r_info)) {
254                         case R_PARISC_LTOFF21L:
255                         case R_PARISC_LTOFF14R:
256                         case R_PARISC_PCREL22F:
257                                 cnt++;
258                 }
259         }
260
261         return cnt;
262 }
263
264 static inline unsigned long count_fdescs(const Elf_Rela *rela, unsigned long n)
265 {
266         unsigned long cnt = 0;
267
268         for (; n > 0; n--, rela++)
269         {
270                 switch (ELF64_R_TYPE(rela->r_info)) {
271                         case R_PARISC_FPTR64:
272                                 cnt++;
273                 }
274         }
275
276         return cnt;
277 }
278
279 static inline unsigned long count_stubs(const Elf_Rela *rela, unsigned long n)
280 {
281         unsigned long cnt = 0;
282
283         for (; n > 0; n--, rela++)
284         {
285                 switch (ELF64_R_TYPE(rela->r_info)) {
286                         case R_PARISC_PCREL22F:
287                                 cnt++;
288                 }
289         }
290
291         return cnt;
292 }
293 #endif
294
295
296 /* Free memory returned from module_alloc */
297 void module_free(struct module *mod, void *module_region)
298 {
299         kfree(mod->arch.section);
300         mod->arch.section = NULL;
301
302         vfree(module_region);
303 }
304
305 /* Additional bytes needed in front of individual sections */
306 unsigned int arch_mod_section_prepend(struct module *mod,
307                                       unsigned int section)
308 {
309         /* size needed for all stubs of this section (including
310          * one additional for correct alignment of the stubs) */
311         return (mod->arch.section[section].stub_entries + 1)
312                 * sizeof(struct stub_entry);
313 }
314
315 #define CONST 
316 int module_frob_arch_sections(CONST Elf_Ehdr *hdr,
317                               CONST Elf_Shdr *sechdrs,
318                               CONST char *secstrings,
319                               struct module *me)
320 {
321         unsigned long gots = 0, fdescs = 0, len;
322         unsigned int i;
323
324         len = hdr->e_shnum * sizeof(me->arch.section[0]);
325         me->arch.section = kzalloc(len, GFP_KERNEL);
326         if (!me->arch.section)
327                 return -ENOMEM;
328
329         for (i = 1; i < hdr->e_shnum; i++) {
330                 const Elf_Rela *rels = (void *)sechdrs[i].sh_addr;
331                 unsigned long nrels = sechdrs[i].sh_size / sizeof(*rels);
332                 unsigned int count, s;
333
334                 if (strncmp(secstrings + sechdrs[i].sh_name,
335                             ".PARISC.unwind", 14) == 0)
336                         me->arch.unwind_section = i;
337
338                 if (sechdrs[i].sh_type != SHT_RELA)
339                         continue;
340
341                 /* some of these are not relevant for 32-bit/64-bit
342                  * we leave them here to make the code common. the
343                  * compiler will do its thing and optimize out the
344                  * stuff we don't need
345                  */
346                 gots += count_gots(rels, nrels);
347                 fdescs += count_fdescs(rels, nrels);
348
349                 /* XXX: By sorting the relocs and finding duplicate entries
350                  *  we could reduce the number of necessary stubs and save
351                  *  some memory. */
352                 count = count_stubs(rels, nrels);
353                 if (!count)
354                         continue;
355
356                 /* so we need relocation stubs. reserve necessary memory. */
357                 /* sh_info gives the section for which we need to add stubs. */
358                 s = sechdrs[i].sh_info;
359
360                 /* each code section should only have one relocation section */
361                 WARN_ON(me->arch.section[s].stub_entries);
362
363                 /* store number of stubs we need for this section */
364                 me->arch.section[s].stub_entries += count;
365         }
366
367         /* align things a bit */
368         me->core_size = ALIGN(me->core_size, 16);
369         me->arch.got_offset = me->core_size;
370         me->core_size += gots * sizeof(struct got_entry);
371
372         me->core_size = ALIGN(me->core_size, 16);
373         me->arch.fdesc_offset = me->core_size;
374         me->core_size += fdescs * sizeof(Elf_Fdesc);
375
376         me->arch.got_max = gots;
377         me->arch.fdesc_max = fdescs;
378
379         return 0;
380 }
381
382 #ifdef CONFIG_64BIT
383 static Elf64_Word get_got(struct module *me, unsigned long value, long addend)
384 {
385         unsigned int i;
386         struct got_entry *got;
387
388         value += addend;
389
390         BUG_ON(value == 0);
391
392         got = me->module_core + me->arch.got_offset;
393         for (i = 0; got[i].addr; i++)
394                 if (got[i].addr == value)
395                         goto out;
396
397         BUG_ON(++me->arch.got_count > me->arch.got_max);
398
399         got[i].addr = value;
400  out:
401         DEBUGP("GOT ENTRY %d[%x] val %lx\n", i, i*sizeof(struct got_entry),
402                value);
403         return i * sizeof(struct got_entry);
404 }
405 #endif /* CONFIG_64BIT */
406
407 #ifdef CONFIG_64BIT
408 static Elf_Addr get_fdesc(struct module *me, unsigned long value)
409 {
410         Elf_Fdesc *fdesc = me->module_core + me->arch.fdesc_offset;
411
412         if (!value) {
413                 printk(KERN_ERR "%s: zero OPD requested!\n", me->name);
414                 return 0;
415         }
416
417         /* Look for existing fdesc entry. */
418         while (fdesc->addr) {
419                 if (fdesc->addr == value)
420                         return (Elf_Addr)fdesc;
421                 fdesc++;
422         }
423
424         BUG_ON(++me->arch.fdesc_count > me->arch.fdesc_max);
425
426         /* Create new one */
427         fdesc->addr = value;
428         fdesc->gp = (Elf_Addr)me->module_core + me->arch.got_offset;
429         return (Elf_Addr)fdesc;
430 }
431 #endif /* CONFIG_64BIT */
432
433 enum elf_stub_type {
434         ELF_STUB_GOT,
435         ELF_STUB_MILLI,
436         ELF_STUB_DIRECT,
437 };
438
439 static Elf_Addr get_stub(struct module *me, unsigned long value, long addend,
440         enum elf_stub_type stub_type, Elf_Addr loc0, unsigned int targetsec)
441 {
442         struct stub_entry *stub;
443         int __maybe_unused d;
444
445         /* initialize stub_offset to point in front of the section */
446         if (!me->arch.section[targetsec].stub_offset) {
447                 loc0 -= (me->arch.section[targetsec].stub_entries + 1) *
448                                 sizeof(struct stub_entry);
449                 /* get correct alignment for the stubs */
450                 loc0 = ALIGN(loc0, sizeof(struct stub_entry));
451                 me->arch.section[targetsec].stub_offset = loc0;
452         }
453
454         /* get address of stub entry */
455         stub = (void *) me->arch.section[targetsec].stub_offset;
456         me->arch.section[targetsec].stub_offset += sizeof(struct stub_entry);
457
458         /* do not write outside available stub area */
459         BUG_ON(0 == me->arch.section[targetsec].stub_entries--);
460
461
462 #ifndef CONFIG_64BIT
463 /* for 32-bit the stub looks like this:
464  *      ldil L'XXX,%r1
465  *      be,n R'XXX(%sr4,%r1)
466  */
467         //value = *(unsigned long *)((value + addend) & ~3); /* why? */
468
469         stub->insns[0] = 0x20200000;    /* ldil L'XXX,%r1       */
470         stub->insns[1] = 0xe0202002;    /* be,n R'XXX(%sr4,%r1) */
471
472         stub->insns[0] |= reassemble_21(lrsel(value, addend));
473         stub->insns[1] |= reassemble_17(rrsel(value, addend) / 4);
474
475 #else
476 /* for 64-bit we have three kinds of stubs:
477  * for normal function calls:
478  *      ldd 0(%dp),%dp
479  *      ldd 10(%dp), %r1
480  *      bve (%r1)
481  *      ldd 18(%dp), %dp
482  *
483  * for millicode:
484  *      ldil 0, %r1
485  *      ldo 0(%r1), %r1
486  *      ldd 10(%r1), %r1
487  *      bve,n (%r1)
488  *
489  * for direct branches (jumps between different section of the
490  * same module):
491  *      ldil 0, %r1
492  *      ldo 0(%r1), %r1
493  *      bve,n (%r1)
494  */
495         switch (stub_type) {
496         case ELF_STUB_GOT:
497                 d = get_got(me, value, addend);
498                 if (d <= 15) {
499                         /* Format 5 */
500                         stub->insns[0] = 0x0f6010db; /* ldd 0(%dp),%dp  */
501                         stub->insns[0] |= low_sign_unext(d, 5) << 16;
502                 } else {
503                         /* Format 3 */
504                         stub->insns[0] = 0x537b0000; /* ldd 0(%dp),%dp  */
505                         stub->insns[0] |= reassemble_16a(d);
506                 }
507                 stub->insns[1] = 0x53610020;    /* ldd 10(%dp),%r1      */
508                 stub->insns[2] = 0xe820d000;    /* bve (%r1)            */
509                 stub->insns[3] = 0x537b0030;    /* ldd 18(%dp),%dp      */
510                 break;
511         case ELF_STUB_MILLI:
512                 stub->insns[0] = 0x20200000;    /* ldil 0,%r1           */
513                 stub->insns[1] = 0x34210000;    /* ldo 0(%r1), %r1      */
514                 stub->insns[2] = 0x50210020;    /* ldd 10(%r1),%r1      */
515                 stub->insns[3] = 0xe820d002;    /* bve,n (%r1)          */
516
517                 stub->insns[0] |= reassemble_21(lrsel(value, addend));
518                 stub->insns[1] |= reassemble_14(rrsel(value, addend));
519                 break;
520         case ELF_STUB_DIRECT:
521                 stub->insns[0] = 0x20200000;    /* ldil 0,%r1           */
522                 stub->insns[1] = 0x34210000;    /* ldo 0(%r1), %r1      */
523                 stub->insns[2] = 0xe820d002;    /* bve,n (%r1)          */
524
525                 stub->insns[0] |= reassemble_21(lrsel(value, addend));
526                 stub->insns[1] |= reassemble_14(rrsel(value, addend));
527                 break;
528         }
529
530 #endif
531
532         return (Elf_Addr)stub;
533 }
534
535 int apply_relocate(Elf_Shdr *sechdrs,
536                    const char *strtab,
537                    unsigned int symindex,
538                    unsigned int relsec,
539                    struct module *me)
540 {
541         /* parisc should not need this ... */
542         printk(KERN_ERR "module %s: RELOCATION unsupported\n",
543                me->name);
544         return -ENOEXEC;
545 }
546
547 #ifndef CONFIG_64BIT
548 int apply_relocate_add(Elf_Shdr *sechdrs,
549                        const char *strtab,
550                        unsigned int symindex,
551                        unsigned int relsec,
552                        struct module *me)
553 {
554         int i;
555         Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr;
556         Elf32_Sym *sym;
557         Elf32_Word *loc;
558         Elf32_Addr val;
559         Elf32_Sword addend;
560         Elf32_Addr dot;
561         Elf_Addr loc0;
562         unsigned int targetsec = sechdrs[relsec].sh_info;
563         //unsigned long dp = (unsigned long)$global$;
564         register unsigned long dp asm ("r27");
565
566         DEBUGP("Applying relocate section %u to %u\n", relsec,
567                targetsec);
568         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
569                 /* This is where to make the change */
570                 loc = (void *)sechdrs[targetsec].sh_addr
571                       + rel[i].r_offset;
572                 /* This is the start of the target section */
573                 loc0 = sechdrs[targetsec].sh_addr;
574                 /* This is the symbol it is referring to */
575                 sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
576                         + ELF32_R_SYM(rel[i].r_info);
577                 if (!sym->st_value) {
578                         printk(KERN_WARNING "%s: Unknown symbol %s\n",
579                                me->name, strtab + sym->st_name);
580                         return -ENOENT;
581                 }
582                 //dot = (sechdrs[relsec].sh_addr + rel->r_offset) & ~0x03;
583                 dot =  (Elf32_Addr)loc & ~0x03;
584
585                 val = sym->st_value;
586                 addend = rel[i].r_addend;
587
588 #if 0
589 #define r(t) ELF32_R_TYPE(rel[i].r_info)==t ? #t :
590                 DEBUGP("Symbol %s loc 0x%x val 0x%x addend 0x%x: %s\n",
591                         strtab + sym->st_name,
592                         (uint32_t)loc, val, addend,
593                         r(R_PARISC_PLABEL32)
594                         r(R_PARISC_DIR32)
595                         r(R_PARISC_DIR21L)
596                         r(R_PARISC_DIR14R)
597                         r(R_PARISC_SEGREL32)
598                         r(R_PARISC_DPREL21L)
599                         r(R_PARISC_DPREL14R)
600                         r(R_PARISC_PCREL17F)
601                         r(R_PARISC_PCREL22F)
602                         "UNKNOWN");
603 #undef r
604 #endif
605
606                 switch (ELF32_R_TYPE(rel[i].r_info)) {
607                 case R_PARISC_PLABEL32:
608                         /* 32-bit function address */
609                         /* no function descriptors... */
610                         *loc = fsel(val, addend);
611                         break;
612                 case R_PARISC_DIR32:
613                         /* direct 32-bit ref */
614                         *loc = fsel(val, addend);
615                         break;
616                 case R_PARISC_DIR21L:
617                         /* left 21 bits of effective address */
618                         val = lrsel(val, addend);
619                         *loc = mask(*loc, 21) | reassemble_21(val);
620                         break;
621                 case R_PARISC_DIR14R:
622                         /* right 14 bits of effective address */
623                         val = rrsel(val, addend);
624                         *loc = mask(*loc, 14) | reassemble_14(val);
625                         break;
626                 case R_PARISC_SEGREL32:
627                         /* 32-bit segment relative address */
628                         /* See note about special handling of SEGREL32 at
629                          * the beginning of this file.
630                          */
631                         *loc = fsel(val, addend); 
632                         break;
633                 case R_PARISC_DPREL21L:
634                         /* left 21 bit of relative address */
635                         val = lrsel(val - dp, addend);
636                         *loc = mask(*loc, 21) | reassemble_21(val);
637                         break;
638                 case R_PARISC_DPREL14R:
639                         /* right 14 bit of relative address */
640                         val = rrsel(val - dp, addend);
641                         *loc = mask(*loc, 14) | reassemble_14(val);
642                         break;
643                 case R_PARISC_PCREL17F:
644                         /* 17-bit PC relative address */
645                         /* calculate direct call offset */
646                         val += addend;
647                         val = (val - dot - 8)/4;
648                         if (!RELOC_REACHABLE(val, 17)) {
649                                 /* direct distance too far, create
650                                  * stub entry instead */
651                                 val = get_stub(me, sym->st_value, addend,
652                                         ELF_STUB_DIRECT, loc0, targetsec);
653                                 val = (val - dot - 8)/4;
654                                 CHECK_RELOC(val, 17);
655                         }
656                         *loc = (*loc & ~0x1f1ffd) | reassemble_17(val);
657                         break;
658                 case R_PARISC_PCREL22F:
659                         /* 22-bit PC relative address; only defined for pa20 */
660                         /* calculate direct call offset */
661                         val += addend;
662                         val = (val - dot - 8)/4;
663                         if (!RELOC_REACHABLE(val, 22)) {
664                                 /* direct distance too far, create
665                                  * stub entry instead */
666                                 val = get_stub(me, sym->st_value, addend,
667                                         ELF_STUB_DIRECT, loc0, targetsec);
668                                 val = (val - dot - 8)/4;
669                                 CHECK_RELOC(val, 22);
670                         }
671                         *loc = (*loc & ~0x3ff1ffd) | reassemble_22(val);
672                         break;
673
674                 default:
675                         printk(KERN_ERR "module %s: Unknown relocation: %u\n",
676                                me->name, ELF32_R_TYPE(rel[i].r_info));
677                         return -ENOEXEC;
678                 }
679         }
680
681         return 0;
682 }
683
684 #else
685 int apply_relocate_add(Elf_Shdr *sechdrs,
686                        const char *strtab,
687                        unsigned int symindex,
688                        unsigned int relsec,
689                        struct module *me)
690 {
691         int i;
692         Elf64_Rela *rel = (void *)sechdrs[relsec].sh_addr;
693         Elf64_Sym *sym;
694         Elf64_Word *loc;
695         Elf64_Xword *loc64;
696         Elf64_Addr val;
697         Elf64_Sxword addend;
698         Elf64_Addr dot;
699         Elf_Addr loc0;
700         unsigned int targetsec = sechdrs[relsec].sh_info;
701
702         DEBUGP("Applying relocate section %u to %u\n", relsec,
703                targetsec);
704         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
705                 /* This is where to make the change */
706                 loc = (void *)sechdrs[targetsec].sh_addr
707                       + rel[i].r_offset;
708                 /* This is the start of the target section */
709                 loc0 = sechdrs[targetsec].sh_addr;
710                 /* This is the symbol it is referring to */
711                 sym = (Elf64_Sym *)sechdrs[symindex].sh_addr
712                         + ELF64_R_SYM(rel[i].r_info);
713                 if (!sym->st_value) {
714                         printk(KERN_WARNING "%s: Unknown symbol %s\n",
715                                me->name, strtab + sym->st_name);
716                         return -ENOENT;
717                 }
718                 //dot = (sechdrs[relsec].sh_addr + rel->r_offset) & ~0x03;
719                 dot = (Elf64_Addr)loc & ~0x03;
720                 loc64 = (Elf64_Xword *)loc;
721
722                 val = sym->st_value;
723                 addend = rel[i].r_addend;
724
725 #if 0
726 #define r(t) ELF64_R_TYPE(rel[i].r_info)==t ? #t :
727                 printk("Symbol %s loc %p val 0x%Lx addend 0x%Lx: %s\n",
728                         strtab + sym->st_name,
729                         loc, val, addend,
730                         r(R_PARISC_LTOFF14R)
731                         r(R_PARISC_LTOFF21L)
732                         r(R_PARISC_PCREL22F)
733                         r(R_PARISC_DIR64)
734                         r(R_PARISC_SEGREL32)
735                         r(R_PARISC_FPTR64)
736                         "UNKNOWN");
737 #undef r
738 #endif
739
740                 switch (ELF64_R_TYPE(rel[i].r_info)) {
741                 case R_PARISC_LTOFF21L:
742                         /* LT-relative; left 21 bits */
743                         val = get_got(me, val, addend);
744                         DEBUGP("LTOFF21L Symbol %s loc %p val %lx\n",
745                                strtab + sym->st_name,
746                                loc, val);
747                         val = lrsel(val, 0);
748                         *loc = mask(*loc, 21) | reassemble_21(val);
749                         break;
750                 case R_PARISC_LTOFF14R:
751                         /* L(ltoff(val+addend)) */
752                         /* LT-relative; right 14 bits */
753                         val = get_got(me, val, addend);
754                         val = rrsel(val, 0);
755                         DEBUGP("LTOFF14R Symbol %s loc %p val %lx\n",
756                                strtab + sym->st_name,
757                                loc, val);
758                         *loc = mask(*loc, 14) | reassemble_14(val);
759                         break;
760                 case R_PARISC_PCREL22F:
761                         /* PC-relative; 22 bits */
762                         DEBUGP("PCREL22F Symbol %s loc %p val %lx\n",
763                                strtab + sym->st_name,
764                                loc, val);
765                         val += addend;
766                         /* can we reach it locally? */
767                         if (in_local(me, (void *)val)) {
768                                 /* this is the case where the symbol is local
769                                  * to the module, but in a different section,
770                                  * so stub the jump in case it's more than 22
771                                  * bits away */
772                                 val = (val - dot - 8)/4;
773                                 if (!RELOC_REACHABLE(val, 22)) {
774                                         /* direct distance too far, create
775                                          * stub entry instead */
776                                         val = get_stub(me, sym->st_value,
777                                                 addend, ELF_STUB_DIRECT,
778                                                 loc0, targetsec);
779                                 } else {
780                                         /* Ok, we can reach it directly. */
781                                         val = sym->st_value;
782                                         val += addend;
783                                 }
784                         } else {
785                                 val = sym->st_value;
786                                 if (strncmp(strtab + sym->st_name, "$$", 2)
787                                     == 0)
788                                         val = get_stub(me, val, addend, ELF_STUB_MILLI,
789                                                        loc0, targetsec);
790                                 else
791                                         val = get_stub(me, val, addend, ELF_STUB_GOT,
792                                                        loc0, targetsec);
793                         }
794                         DEBUGP("STUB FOR %s loc %lx, val %lx+%lx at %lx\n", 
795                                strtab + sym->st_name, loc, sym->st_value,
796                                addend, val);
797                         val = (val - dot - 8)/4;
798                         CHECK_RELOC(val, 22);
799                         *loc = (*loc & ~0x3ff1ffd) | reassemble_22(val);
800                         break;
801                 case R_PARISC_DIR64:
802                         /* 64-bit effective address */
803                         *loc64 = val + addend;
804                         break;
805                 case R_PARISC_SEGREL32:
806                         /* 32-bit segment relative address */
807                         /* See note about special handling of SEGREL32 at
808                          * the beginning of this file.
809                          */
810                         *loc = fsel(val, addend); 
811                         break;
812                 case R_PARISC_FPTR64:
813                         /* 64-bit function address */
814                         if(in_local(me, (void *)(val + addend))) {
815                                 *loc64 = get_fdesc(me, val+addend);
816                                 DEBUGP("FDESC for %s at %p points to %lx\n",
817                                        strtab + sym->st_name, *loc64,
818                                        ((Elf_Fdesc *)*loc64)->addr);
819                         } else {
820                                 /* if the symbol is not local to this
821                                  * module then val+addend is a pointer
822                                  * to the function descriptor */
823                                 DEBUGP("Non local FPTR64 Symbol %s loc %p val %lx\n",
824                                        strtab + sym->st_name,
825                                        loc, val);
826                                 *loc64 = val + addend;
827                         }
828                         break;
829
830                 default:
831                         printk(KERN_ERR "module %s: Unknown relocation: %Lu\n",
832                                me->name, ELF64_R_TYPE(rel[i].r_info));
833                         return -ENOEXEC;
834                 }
835         }
836         return 0;
837 }
838 #endif
839
840 static void
841 register_unwind_table(struct module *me,
842                       const Elf_Shdr *sechdrs)
843 {
844         unsigned char *table, *end;
845         unsigned long gp;
846
847         if (!me->arch.unwind_section)
848                 return;
849
850         table = (unsigned char *)sechdrs[me->arch.unwind_section].sh_addr;
851         end = table + sechdrs[me->arch.unwind_section].sh_size;
852         gp = (Elf_Addr)me->module_core + me->arch.got_offset;
853
854         DEBUGP("register_unwind_table(), sect = %d at 0x%p - 0x%p (gp=0x%lx)\n",
855                me->arch.unwind_section, table, end, gp);
856         me->arch.unwind = unwind_table_add(me->name, 0, gp, table, end);
857 }
858
859 static void
860 deregister_unwind_table(struct module *me)
861 {
862         if (me->arch.unwind)
863                 unwind_table_remove(me->arch.unwind);
864 }
865
866 int module_finalize(const Elf_Ehdr *hdr,
867                     const Elf_Shdr *sechdrs,
868                     struct module *me)
869 {
870         int i;
871         unsigned long nsyms;
872         const char *strtab = NULL;
873         Elf_Sym *newptr, *oldptr;
874         Elf_Shdr *symhdr = NULL;
875 #ifdef DEBUG
876         Elf_Fdesc *entry;
877         u32 *addr;
878
879         entry = (Elf_Fdesc *)me->init;
880         printk("FINALIZE, ->init FPTR is %p, GP %lx ADDR %lx\n", entry,
881                entry->gp, entry->addr);
882         addr = (u32 *)entry->addr;
883         printk("INSNS: %x %x %x %x\n",
884                addr[0], addr[1], addr[2], addr[3]);
885         printk("got entries used %ld, gots max %ld\n"
886                "fdescs used %ld, fdescs max %ld\n",
887                me->arch.got_count, me->arch.got_max,
888                me->arch.fdesc_count, me->arch.fdesc_max);
889 #endif
890
891         register_unwind_table(me, sechdrs);
892
893         /* haven't filled in me->symtab yet, so have to find it
894          * ourselves */
895         for (i = 1; i < hdr->e_shnum; i++) {
896                 if(sechdrs[i].sh_type == SHT_SYMTAB
897                    && (sechdrs[i].sh_flags & SHF_ALLOC)) {
898                         int strindex = sechdrs[i].sh_link;
899                         /* FIXME: AWFUL HACK
900                          * The cast is to drop the const from
901                          * the sechdrs pointer */
902                         symhdr = (Elf_Shdr *)&sechdrs[i];
903                         strtab = (char *)sechdrs[strindex].sh_addr;
904                         break;
905                 }
906         }
907
908         DEBUGP("module %s: strtab %p, symhdr %p\n",
909                me->name, strtab, symhdr);
910
911         if(me->arch.got_count > MAX_GOTS) {
912                 printk(KERN_ERR "%s: Global Offset Table overflow (used %ld, allowed %d)\n",
913                                 me->name, me->arch.got_count, MAX_GOTS);
914                 return -EINVAL;
915         }
916
917         kfree(me->arch.section);
918         me->arch.section = NULL;
919
920         /* no symbol table */
921         if(symhdr == NULL)
922                 return 0;
923
924         oldptr = (void *)symhdr->sh_addr;
925         newptr = oldptr + 1;    /* we start counting at 1 */
926         nsyms = symhdr->sh_size / sizeof(Elf_Sym);
927         DEBUGP("OLD num_symtab %lu\n", nsyms);
928
929         for (i = 1; i < nsyms; i++) {
930                 oldptr++;       /* note, count starts at 1 so preincrement */
931                 if(strncmp(strtab + oldptr->st_name,
932                               ".L", 2) == 0)
933                         continue;
934
935                 if(newptr != oldptr)
936                         *newptr++ = *oldptr;
937                 else
938                         newptr++;
939
940         }
941         nsyms = newptr - (Elf_Sym *)symhdr->sh_addr;
942         DEBUGP("NEW num_symtab %lu\n", nsyms);
943         symhdr->sh_size = nsyms * sizeof(Elf_Sym);
944         return module_bug_finalize(hdr, sechdrs, me);
945 }
946
947 void module_arch_cleanup(struct module *mod)
948 {
949         deregister_unwind_table(mod);
950         module_bug_cleanup(mod);
951 }