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