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 17 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 18 19/* Some systems, e.g., AIX, may have defined this in header files already 20 included. */ 21#undef TARGET_PAGE_SIZE 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 60struct 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 84struct 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 219struct 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}; 236