Commit | Line | Data |
---|---|---|
4f1d9bd8 NC |
1 | /* SPARC-specific values for a.out files |
2 | ||
e4e42b45 | 3 | Copyright 2001, 2009, 2010 Free Software Foundation, Inc. |
4f1d9bd8 NC |
4 | |
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
e4e42b45 | 7 | the Free Software Foundation; either version 3 of the License, or |
4f1d9bd8 NC |
8 | (at your option) any later version. |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the Free Software | |
e4e42b45 NC |
17 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
18 | MA 02110-1301, USA. */ | |
252b5132 RH |
19 | |
20 | /* Some systems, e.g., AIX, may have defined this in header files already | |
21 | included. */ | |
4f1d9bd8 | 22 | #undef TARGET_PAGE_SIZE |
252b5132 RH |
23 | #define TARGET_PAGE_SIZE 0x2000 /* 8K. aka NBPG in <sys/param.h> */ |
24 | /* Note that some SPARCs have 4K pages, some 8K, some others. */ | |
25 | ||
26 | #define SEG_SIZE_SPARC TARGET_PAGE_SIZE | |
27 | #define SEG_SIZE_SUN3 0x20000 /* Resolution of r/w protection hw */ | |
28 | ||
29 | #define TEXT_START_ADDR TARGET_PAGE_SIZE /* Location 0 is not accessible */ | |
30 | #define N_HEADER_IN_TEXT(x) 1 | |
31 | ||
32 | /* Non-default definitions of the accessor macros... */ | |
33 | ||
34 | /* Segment size varies on Sun-3 versus Sun-4. */ | |
35 | ||
36 | #define N_SEGSIZE(x) (N_MACHTYPE(x) == M_SPARC? SEG_SIZE_SPARC: \ | |
37 | N_MACHTYPE(x) == M_68020? SEG_SIZE_SUN3: \ | |
38 | /* Guess? */ TARGET_PAGE_SIZE) | |
39 | ||
40 | /* Virtual Address of text segment from the a.out file. For OMAGIC, | |
41 | (almost always "unlinked .o's" these days), should be zero. | |
42 | Sun added a kludge so that shared libraries linked ZMAGIC get | |
43 | an address of zero if a_entry (!!!) is lower than the otherwise | |
44 | expected text address. These kludges have gotta go! | |
45 | For linked files, should reflect reality if we know it. */ | |
46 | ||
4a056f14 AM |
47 | #define N_SHARED_LIB(x) ((x).a_entry < TEXT_START_ADDR \ |
48 | && (x).a_text >= EXEC_BYTES_SIZE) | |
49 | ||
252b5132 RH |
50 | /* This differs from the version in aout64.h (which we override by defining |
51 | it here) only for NMAGIC (we return TEXT_START_ADDR+EXEC_BYTES_SIZE; | |
52 | they return 0). */ | |
53 | ||
54 | #define N_TXTADDR(x) \ | |
55 | (N_MAGIC(x)==OMAGIC? 0 \ | |
56 | : (N_MAGIC(x) == ZMAGIC && (x).a_entry < TEXT_START_ADDR)? 0 \ | |
57 | : TEXT_START_ADDR+EXEC_BYTES_SIZE) | |
58 | ||
59 | /* When a file is linked against a shared library on SunOS 4, the | |
60 | dynamic bit in the exec header is set, and the first symbol in the | |
61 | symbol table is __DYNAMIC. Its value is the address of the | |
62 | following structure. */ | |
63 | ||
64 | struct external_sun4_dynamic | |
65 | { | |
66 | /* The version number of the structure. SunOS 4.1.x creates files | |
67 | with version number 3, which is what this structure is based on. | |
68 | According to gdb, version 2 is similar. I believe that version 2 | |
69 | used a different type of procedure linkage table, and there may | |
70 | have been other differences. */ | |
71 | bfd_byte ld_version[4]; | |
72 | /* The virtual address of a 28 byte structure used in debugging. | |
73 | The contents are filled in at run time by ld.so. */ | |
74 | bfd_byte ldd[4]; | |
75 | /* The virtual address of another structure with information about | |
76 | how to relocate the executable at run time. */ | |
77 | bfd_byte ld[4]; | |
78 | }; | |
79 | ||
80 | /* The size of the debugging structure pointed to by the debugger | |
81 | field of __DYNAMIC. */ | |
82 | #define EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE (24) | |
83 | ||
84 | /* The structure pointed to by the linker field of __DYNAMIC. As far | |
85 | as I can tell, most of the addresses in this structure are offsets | |
86 | within the file, but some are actually virtual addresses. */ | |
87 | ||
88 | struct internal_sun4_dynamic_link | |
89 | { | |
90 | /* Linked list of loaded objects. This is filled in at runtime by | |
91 | ld.so and probably by dlopen. */ | |
92 | unsigned long ld_loaded; | |
93 | ||
94 | /* The address of the list of names of shared objects which must be | |
95 | included at runtime. Each entry in the list is 16 bytes: the 4 | |
96 | byte address of the string naming the object (e.g., for -lc this | |
97 | is "c"); 4 bytes of flags--the high bit is whether to search for | |
98 | the object using the library path; the 2 byte major version | |
99 | number; the 2 byte minor version number; the 4 byte address of | |
100 | the next entry in the list (zero if this is the last entry). The | |
101 | version numbers seem to only be non-zero when doing library | |
102 | searching. */ | |
103 | unsigned long ld_need; | |
104 | ||
105 | /* The address of the path to search for the shared objects which | |
106 | must be included. This points to a string in PATH format which | |
107 | is generated from the -L arguments to the linker. According to | |
108 | the man page, ld.so implicitly adds ${LD_LIBRARY_PATH} to the | |
109 | beginning of this string and /lib:/usr/lib:/usr/local/lib to the | |
110 | end. The string is terminated by a null byte. This field is | |
111 | zero if there is no additional path. */ | |
112 | unsigned long ld_rules; | |
113 | ||
114 | /* The address of the global offset table. This appears to be a | |
115 | virtual address, not a file offset. The first entry in the | |
116 | global offset table seems to be the virtual address of the | |
117 | sun4_dynamic structure (the same value as the __DYNAMIC symbol). | |
118 | The global offset table is used for PIC code to hold the | |
119 | addresses of variables. A dynamically linked file which does not | |
120 | itself contain PIC code has a four byte global offset table. */ | |
121 | unsigned long ld_got; | |
122 | ||
123 | /* The address of the procedure linkage table. This appears to be a | |
124 | virtual address, not a file offset. | |
125 | ||
126 | On a SPARC, the table is composed of 12 byte entries, each of | |
127 | which consists of three instructions. The first entry is | |
128 | sethi %hi(0),%g1 | |
129 | jmp %g1 | |
130 | nop | |
131 | These instructions are changed by ld.so into a jump directly into | |
132 | ld.so itself. Each subsequent entry is | |
133 | save %sp, -96, %sp | |
134 | call <address of first entry in procedure linkage table> | |
135 | <reloc_number | 0x01000000> | |
136 | The reloc_number is the number of the reloc to use to resolve | |
137 | this entry. The reloc will be a JMP_SLOT reloc against some | |
138 | symbol that is not defined in this object file but should be | |
139 | defined in a shared object (if it is not, ld.so will report a | |
140 | runtime error and exit). The constant 0x010000000 turns the | |
141 | reloc number into a sethi of %g0, which does nothing since %g0 is | |
142 | hardwired to zero. | |
143 | ||
144 | When one of these entries is executed, it winds up calling into | |
145 | ld.so. ld.so looks at the reloc number, available via the return | |
146 | address, to determine which entry this is. It then looks at the | |
147 | reloc and patches up the entry in the table into a sethi and jmp | |
148 | to the real address followed by a nop. This means that the reloc | |
149 | lookup only has to happen once, and it also means that the | |
150 | relocation only needs to be done if the function is actually | |
151 | called. The relocation is expensive because ld.so must look up | |
152 | the symbol by name. | |
153 | ||
154 | The size of the procedure linkage table is given by the ld_plt_sz | |
155 | field. */ | |
156 | unsigned long ld_plt; | |
157 | ||
158 | /* The address of the relocs. These are in the same format as | |
159 | ordinary relocs. Symbol index numbers refer to the symbols | |
160 | pointed to by ld_stab. I think the only way to determine the | |
161 | number of relocs is to assume that all the bytes from ld_rel to | |
162 | ld_hash contain reloc entries. */ | |
163 | unsigned long ld_rel; | |
164 | ||
165 | /* The address of a hash table of symbols. The hash table has | |
166 | roughly the same number of entries as there are dynamic symbols; | |
167 | I think the only way to get the exact size is to assume that | |
168 | every byte from ld_hash to ld_stab is devoted to the hash table. | |
169 | ||
170 | Each entry in the hash table is eight bytes. The first four | |
171 | bytes are a symbol index into the dynamic symbols. The second | |
172 | four bytes are the index of the next hash table entry in the | |
173 | bucket. The ld_buckets field gives the number of buckets, say B. | |
174 | The first B entries in the hash table each start a bucket which | |
175 | is chained through the second four bytes of each entry. A value | |
176 | of zero ends the chain. | |
177 | ||
178 | The hash function is simply | |
179 | h = 0; | |
180 | while (*string != '\0') | |
181 | h = (h << 1) + *string++; | |
182 | h &= 0x7fffffff; | |
183 | ||
184 | To look up a symbol, compute the hash value of the name. Take | |
185 | the modulos of hash value and the number of buckets. Start at | |
186 | that entry in the hash table. See if the symbol (from the first | |
187 | four bytes of the hash table entry) has the name you are looking | |
188 | for. If not, use the chain field (the second four bytes of the | |
189 | hash table entry) to move on to the next entry in this bucket. | |
190 | If the chain field is zero you have reached the end of the | |
191 | bucket, and the symbol is not in the hash table. */ | |
192 | unsigned long ld_hash; | |
193 | ||
194 | /* The address of the symbol table. This is a list of | |
195 | external_nlist structures. The string indices are relative to | |
196 | the ld_symbols field. I think the only way to determine the | |
197 | number of symbols is to assume that all the bytes between ld_stab | |
198 | and ld_symbols are external_nlist structures. */ | |
199 | unsigned long ld_stab; | |
200 | ||
201 | /* I don't know what this is for. It seems to always be zero. */ | |
202 | unsigned long ld_stab_hash; | |
203 | ||
204 | /* The number of buckets in the hash table. */ | |
205 | unsigned long ld_buckets; | |
206 | ||
207 | /* The address of the symbol string table. The first string in this | |
208 | string table need not be the empty string. */ | |
209 | unsigned long ld_symbols; | |
210 | ||
211 | /* The size in bytes of the symbol string table. */ | |
212 | unsigned long ld_symb_size; | |
213 | ||
214 | /* The size in bytes of the text segment. */ | |
215 | unsigned long ld_text; | |
216 | ||
217 | /* The size in bytes of the procedure linkage table. */ | |
218 | unsigned long ld_plt_sz; | |
219 | }; | |
220 | ||
221 | /* The external form of the structure. */ | |
222 | ||
223 | struct external_sun4_dynamic_link | |
224 | { | |
225 | bfd_byte ld_loaded[4]; | |
226 | bfd_byte ld_need[4]; | |
227 | bfd_byte ld_rules[4]; | |
228 | bfd_byte ld_got[4]; | |
229 | bfd_byte ld_plt[4]; | |
230 | bfd_byte ld_rel[4]; | |
231 | bfd_byte ld_hash[4]; | |
232 | bfd_byte ld_stab[4]; | |
233 | bfd_byte ld_stab_hash[4]; | |
234 | bfd_byte ld_buckets[4]; | |
235 | bfd_byte ld_symbols[4]; | |
236 | bfd_byte ld_symb_size[4]; | |
237 | bfd_byte ld_text[4]; | |
238 | bfd_byte ld_plt_sz[4]; | |
239 | }; |