]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - arch/alpha/kernel/module.c
1 /* Kernel module help for Alpha.
2 Copyright (C) 2002 Richard Henderson.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 #include <linux/moduleloader.h>
19 #include <linux/elf.h>
20 #include <linux/vmalloc.h>
22 #include <linux/string.h>
23 #include <linux/kernel.h>
24 #include <linux/slab.h>
29 #define DEBUGP(fmt...)
32 /* Allocate the GOT at the end of the core sections. */
35 struct got_entry
*next
;
36 Elf64_Sxword r_addend
;
41 process_reloc_for_got(Elf64_Rela
*rela
,
42 struct got_entry
*chains
, Elf64_Xword
*poffset
)
44 unsigned long r_sym
= ELF64_R_SYM (rela
->r_info
);
45 unsigned long r_type
= ELF64_R_TYPE (rela
->r_info
);
46 Elf64_Sxword r_addend
= rela
->r_addend
;
49 if (r_type
!= R_ALPHA_LITERAL
)
52 for (g
= chains
+ r_sym
; g
; g
= g
->next
)
53 if (g
->r_addend
== r_addend
) {
54 if (g
->got_offset
== 0) {
55 g
->got_offset
= *poffset
;
61 g
= kmalloc (sizeof (*g
), GFP_KERNEL
);
62 g
->next
= chains
[r_sym
].next
;
63 g
->r_addend
= r_addend
;
64 g
->got_offset
= *poffset
;
66 chains
[r_sym
].next
= g
;
69 /* Trick: most of the ELF64_R_TYPE field is unused. There are
70 42 valid relocation types, and a 32-bit field. Co-opt the
71 bits above 256 to store the got offset for this reloc. */
72 rela
->r_info
|= g
->got_offset
<< 8;
76 module_frob_arch_sections(Elf64_Ehdr
*hdr
, Elf64_Shdr
*sechdrs
,
77 char *secstrings
, struct module
*me
)
79 struct got_entry
*chains
;
81 Elf64_Shdr
*esechdrs
, *symtab
, *s
, *got
;
82 unsigned long nsyms
, nrela
, i
;
84 esechdrs
= sechdrs
+ hdr
->e_shnum
;
87 /* Find out how large the symbol table is. Allocate one got_entry
88 head per symbol. Normally this will be enough, but not always.
89 We'll chain different offsets for the symbol down each head. */
90 for (s
= sechdrs
; s
< esechdrs
; ++s
)
91 if (s
->sh_type
== SHT_SYMTAB
)
93 else if (!strcmp(".got", secstrings
+ s
->sh_name
)) {
95 me
->arch
.gotsecindex
= s
- sechdrs
;
99 printk(KERN_ERR
"module %s: no symbol table\n", me
->name
);
103 printk(KERN_ERR
"module %s: no got section\n", me
->name
);
107 nsyms
= symtab
->sh_size
/ sizeof(Elf64_Sym
);
108 chains
= kcalloc(nsyms
, sizeof(struct got_entry
), GFP_KERNEL
);
111 "module %s: no memory for symbol chain buffer\n",
117 got
->sh_addralign
= 8;
118 got
->sh_type
= SHT_NOBITS
;
120 /* Examine all LITERAL relocations to find out what GOT entries
121 are required. This sizes the GOT section as well. */
122 for (s
= sechdrs
; s
< esechdrs
; ++s
)
123 if (s
->sh_type
== SHT_RELA
) {
124 nrela
= s
->sh_size
/ sizeof(Elf64_Rela
);
125 rela
= (void *)hdr
+ s
->sh_offset
;
126 for (i
= 0; i
< nrela
; ++i
)
127 process_reloc_for_got(rela
+i
, chains
,
131 /* Free the memory we allocated. */
132 for (i
= 0; i
< nsyms
; ++i
) {
133 struct got_entry
*g
, *n
;
134 for (g
= chains
[i
].next
; g
; g
= n
) {
145 apply_relocate_add(Elf64_Shdr
*sechdrs
, const char *strtab
,
146 unsigned int symindex
, unsigned int relsec
,
149 Elf64_Rela
*rela
= (void *)sechdrs
[relsec
].sh_addr
;
150 unsigned long i
, n
= sechdrs
[relsec
].sh_size
/ sizeof(*rela
);
151 Elf64_Sym
*symtab
, *sym
;
152 void *base
, *location
;
153 unsigned long got
, gp
;
155 DEBUGP("Applying relocate section %u to %u\n", relsec
,
156 sechdrs
[relsec
].sh_info
);
158 base
= (void *)sechdrs
[sechdrs
[relsec
].sh_info
].sh_addr
;
159 symtab
= (Elf64_Sym
*)sechdrs
[symindex
].sh_addr
;
161 /* The small sections were sorted to the end of the segment.
162 The following should definitely cover them. */
163 gp
= (u64
)me
->core_layout
.base
+ me
->core_layout
.size
- 0x8000;
164 got
= sechdrs
[me
->arch
.gotsecindex
].sh_addr
;
166 for (i
= 0; i
< n
; i
++) {
167 unsigned long r_sym
= ELF64_R_SYM (rela
[i
].r_info
);
168 unsigned long r_type
= ELF64_R_TYPE (rela
[i
].r_info
);
169 unsigned long r_got_offset
= r_type
>> 8;
170 unsigned long value
, hi
, lo
;
173 /* This is where to make the change. */
174 location
= base
+ rela
[i
].r_offset
;
176 /* This is the symbol it is referring to. Note that all
177 unresolved symbols have been resolved. */
178 sym
= symtab
+ r_sym
;
179 value
= sym
->st_value
+ rela
[i
].r_addend
;
184 case R_ALPHA_REFQUAD
:
185 /* BUG() can produce misaligned relocations. */
186 ((u32
*)location
)[0] = value
;
187 ((u32
*)location
)[1] = value
>> 32;
189 case R_ALPHA_GPREL32
:
191 if ((int)value
!= value
)
193 *(u32
*)location
= value
;
195 case R_ALPHA_LITERAL
:
196 hi
= got
+ r_got_offset
;
200 *(u16
*)location
= lo
;
206 value
= gp
- (u64
)location
;
208 hi
= (int)(value
- lo
);
209 if (hi
+ lo
!= value
)
211 *(u16
*)location
= hi
>> 16;
212 *(u16
*)(location
+ rela
[i
].r_addend
) = lo
;
215 /* BRSGP is only allowed to bind to local symbols.
216 If the section is undef, this means that the
217 value was resolved from somewhere else. */
218 if (sym
->st_shndx
== SHN_UNDEF
)
220 if ((sym
->st_other
& STO_ALPHA_STD_GPLOAD
) ==
221 STO_ALPHA_STD_GPLOAD
)
222 /* Omit the prologue. */
226 value
-= (u64
)location
+ 4;
229 value
= (long)value
>> 2;
230 if (value
+ (1<<21) >= 1<<22)
233 value
|= *(u32
*)location
& ~0x1fffff;
234 *(u32
*)location
= value
;
239 value
-= (u64
)location
;
240 if ((int)value
!= value
)
242 *(u32
*)location
= value
;
245 value
-= (u64
)location
;
246 *(u64
*)location
= value
;
248 case R_ALPHA_GPRELHIGH
:
249 value
= (long)(value
- gp
+ 0x8000) >> 16;
250 if ((short) value
!= value
)
252 *(u16
*)location
= value
;
254 case R_ALPHA_GPRELLOW
:
256 *(u16
*)location
= value
;
258 case R_ALPHA_GPREL16
:
260 if ((short) value
!= value
)
262 *(u16
*)location
= value
;
265 printk(KERN_ERR
"module %s: Unknown relocation: %lu\n",
269 if (ELF64_ST_TYPE (sym
->st_info
) == STT_SECTION
)
271 "module %s: Relocation (type %lu) overflow vs section %d\n",
272 me
->name
, r_type
, sym
->st_shndx
);
275 "module %s: Relocation (type %lu) overflow vs %s\n",
276 me
->name
, r_type
, strtab
+ sym
->st_name
);