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