1 /* obj-evax.c - EVAX (openVMS/Alpha) object file format. 2 Copyright 1996, 1997, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. 3 Contributed by Klaus K�mpf (kkaempf@progis.de) of 4 proGIS Software, Aachen, Germany. 5 Extensively enhanced by Douglas Rupp of AdaCore. 6 7 This file is part of GAS, the GNU Assembler 8 9 GAS is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 GAS is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GAS; see the file COPYING. If not, write to 21 the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 #define OBJ_HEADER "obj-evax.h" 25 26 #include "bfd.h" 27 #include "vms.h" 28 #include "as.h" 29 #include "subsegs.h" 30 #include "struc-symbol.h" 31 #include "safe-ctype.h" 32 33 static void s_evax_weak (int); 34 static unsigned int crc32 (unsigned char *, int); 35 static char *encode_32 (unsigned int); 36 static char *encode_16 (unsigned int); 37 static int decode_16 (const char *); 38 39 const pseudo_typeS obj_pseudo_table[] = 40 { 41 { "weak", s_evax_weak, 0}, 42 {0, 0, 0}, 43 }; /* obj_pseudo_table */ 44 45 void obj_read_begin_hook () {} 46 47 /* Handle the weak specific pseudo-op. */ 48 49 static void 50 s_evax_weak (int ignore ATTRIBUTE_UNUSED) 51 { 52 char *name; 53 int c; 54 symbolS *symbolP; 55 char *stop = NULL; 56 char stopc; 57 58 if (flag_mri) 59 stop = mri_comment_field (&stopc); 60 61 do 62 { 63 name = input_line_pointer; 64 c = get_symbol_end (); 65 symbolP = symbol_find_or_make (name); 66 *input_line_pointer = c; 67 SKIP_WHITESPACE (); 68 S_SET_WEAK (symbolP); 69 if (c == ',') 70 { 71 input_line_pointer++; 72 SKIP_WHITESPACE (); 73 if (*input_line_pointer == '\n') 74 c = '\n'; 75 } 76 } 77 while (c == ','); 78 79 if (flag_mri) 80 mri_comment_end (stop, stopc); 81 82 demand_empty_rest_of_line (); 83 } 84 85 void 86 evax_symbol_new_hook (symbolS *sym) 87 { 88 struct evax_private_udata_struct *udata; 89 90 udata = (struct evax_private_udata_struct *) 91 xmalloc (sizeof (struct evax_private_udata_struct)); 92 93 udata->bsym = symbol_get_bfdsym (sym); 94 udata->enbsym = NULL; 95 udata->origname = xstrdup (S_GET_NAME (sym)); 96 udata->lkindex = 0; 97 symbol_get_bfdsym(sym)->udata.p = (PTR) udata; 98 } 99 100 void 101 evax_frob_symbol (symbolS *sym, int *punt) 102 { 103 const char *symname = S_GET_NAME (sym); 104 int symlen = strlen (symname); 105 asymbol *symbol = symbol_get_bfdsym (sym); 106 107 if (symlen > 4 108 && strcmp (symname + symlen - 4, "..en") == 0 109 && S_GET_SEGMENT (sym) == undefined_section) 110 { 111 symbol_clear_used_in_reloc (sym); 112 *punt = 1; 113 } 114 115 else if ((symbol->flags & BSF_GLOBAL) && (symbol->flags & BSF_FUNCTION)) 116 { 117 struct evax_private_udata_struct *udata 118 = (struct evax_private_udata_struct *)symbol->udata.p; 119 120 /* Fix up equates of function definitions. */ 121 while (udata->enbsym == NULL) 122 { 123 /* ??? Equates have been resolved at this point so their 124 expression is O_constant; but they previously were 125 O_symbol and we hope the equated symbol is still there. */ 126 sym = symbol_get_value_expression (sym)->X_add_symbol; 127 if (sym == NULL) 128 abort (); 129 symbol = symbol_get_bfdsym (sym); 130 udata->enbsym 131 = ((struct evax_private_udata_struct *)symbol->udata.p)->enbsym; 132 } 133 } 134 } 135 136 void 137 evax_frob_file_before_adjust (void) 138 { 139 struct alpha_linkage_fixups *l; 140 segT current_section = now_seg; 141 int current_subsec = now_subseg; 142 segment_info_type *seginfo; 143 int linkage_index = 1; 144 145 subseg_set (alpha_link_section, 0); 146 seginfo = seg_info (alpha_link_section); 147 148 /* Handle .linkage fixups. */ 149 for (l = alpha_linkage_fixup_root; l != NULL; l = l->next) 150 { 151 if (S_GET_SEGMENT (l->fixp->fx_addsy) == alpha_link_section) 152 { 153 symbolS * entry_sym; 154 fixS *fixpentry, *fixppdesc, *fixtail; 155 156 fixtail = seginfo->fix_tail; 157 158 /* Replace the linkage with the local symbols */ 159 entry_sym = symbol_find 160 (((struct evax_private_udata_struct *)symbol_get_bfdsym (l->fixp->fx_addsy)->udata.p)->enbsym->name); 161 if (!entry_sym) 162 abort (); 163 fixpentry = fix_new (l->fixp->fx_frag, l->fixp->fx_where, 8, 164 entry_sym, l->fixp->fx_offset, 0, 165 BFD_RELOC_64); 166 fixppdesc = fix_new (l->fixp->fx_frag, l->fixp->fx_where+8, 8, 167 l->fixp->fx_addsy, l->fixp->fx_offset, 0, 168 BFD_RELOC_64); 169 l->fixp->fx_size = 0; 170 l->fixp->fx_done = 1; 171 172 /* If not already at the tail, splice the new fixups into 173 the chain right after the one we are nulling out */ 174 if (fixtail != l->fixp) 175 { 176 fixppdesc->fx_next = l->fixp->fx_next; 177 l->fixp->fx_next = fixpentry; 178 fixtail->fx_next = 0; 179 seginfo->fix_tail = fixtail; 180 } 181 } 182 else 183 { 184 ((struct evax_private_udata_struct *) 185 symbol_get_bfdsym (l->label)->udata.p)->lkindex = linkage_index; 186 187 l->fixp->fx_addnumber = linkage_index; 188 189 linkage_index += 2; 190 } 191 } 192 193 subseg_set (current_section, current_subsec); 194 } 195 196 void 197 evax_frob_file_before_fix (void) 198 { 199 /* Now that the fixups are done earlier, we need to transfer the values 200 into the BFD symbols before calling fix_segment (ideally should not 201 be done also later). */ 202 if (symbol_rootP) 203 { 204 symbolS *symp; 205 206 /* Set the value into the BFD symbol. Up til now the value 207 has only been kept in the gas symbolS struct. */ 208 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 209 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 210 } 211 } 212 213 /* The length is computed from the maximum allowable length of 64 less the 214 4 character ..xx extension that must be preserved (removed before 215 krunching and appended back on afterwards). The $<nnn>.. prefix is 216 also removed and prepened back on, but doesn't enter into the length 217 computation because symbols with that prefix are always resolved 218 by the assembler and will never appear in the symbol table. At least 219 I hope that's true, TBD. */ 220 #define MAX_LABEL_LENGTH 60 221 222 static char *shorten_identifier (char *); 223 static int is_truncated_identifier (char *); 224 225 char * 226 evax_shorten_name (char *id) 227 { 228 int prefix_dotdot = 0; 229 char prefix [64]; 230 int len = strlen (id); 231 int suffix_dotdot = len; 232 char suffix [64]; 233 char *base_id; 234 235 /* This test may be too conservative. */ 236 if (len <= MAX_LABEL_LENGTH) 237 return id; 238 239 suffix [0] = 0; 240 prefix [0] = 0; 241 242 /* Check for ..xx suffix and save it. */ 243 if (strncmp (&id[len-4], "..", 2) == 0) 244 { 245 suffix_dotdot = len - 4; 246 strncpy (suffix, &id[len-4], 4); 247 suffix [4] = 0; 248 } 249 250 /* Check for $<nnn>.. prefix and save it. */ 251 if ((id[0] == '$') && ISDIGIT (id[1])) 252 { 253 int i; 254 255 for (i=2; i < len; i++) 256 { 257 if (!ISDIGIT (id[i])) 258 { 259 if (id[i] == '.' && id [i+1] == '.') 260 { 261 prefix_dotdot = i+2; 262 strncpy (prefix, id, prefix_dotdot); 263 prefix [prefix_dotdot] = 0; 264 } 265 break; 266 } 267 } 268 } 269 270 /* We only need worry about krunching the base symbol. */ 271 base_id = xmalloc (suffix_dotdot - prefix_dotdot + 1); 272 strncpy (base_id, &id[prefix_dotdot], suffix_dotdot - prefix_dotdot); 273 base_id [suffix_dotdot - prefix_dotdot] = 0; 274 275 if (strlen (base_id) > MAX_LABEL_LENGTH) 276 { 277 char new_id [4096]; 278 char *return_id; 279 280 strcpy (new_id, base_id); 281 282 /* Shorten it. */ 283 strcpy (new_id, shorten_identifier (new_id)); 284 285 /* Prepend back the prefix if there was one. */ 286 if (prefix_dotdot) 287 { 288 memmove (&new_id [prefix_dotdot], new_id, strlen (new_id) + 1); 289 strncpy (new_id, prefix, prefix_dotdot); 290 } 291 292 /* Append back the suffix if there was one. */ 293 if (strlen (suffix)) 294 strcat (new_id, suffix); 295 296 /* Save it on the heap and return. */ 297 return_id = xmalloc (strlen (new_id) + 1); 298 strcpy (return_id, new_id); 299 300 return return_id; 301 } 302 else 303 return id; 304 } 305 306 /* The code below implements a mechanism for truncating long 307 identifiers to an arbitrary length (set by MAX_LABEL_LENGTH). 308 309 It attempts to make each truncated identifier unique by replacing 310 part of the identifier with an encoded 32-bit CRC and an associated 311 checksum (the checksum is used as a way to determine that the name 312 was truncated). 313 314 Note that both a portion of the start and of the end of the 315 identifier may be kept. The macro ID_SUFFIX_LENGTH will return the 316 number of characters in the suffix of the identifier that should be 317 kept. 318 319 The portion of the identifier that is going to be removed is 320 checksummed. The checksum is then encoded as a 5-character string, 321 the characters of which are then summed. This sum is then encoded 322 as a 3-character string. Finally, the original length of the 323 identifier is encoded as a 3-character string. 324 325 These three strings are then concatenated together (along with an _h 326 which further designates that the name was truncated): 327 328 "original_identifier"_haaaaabbbccc 329 330 aaaaa = 32-bit CRC 331 bbb = length of original identifier 332 ccc = sum of 32-bit CRC characters 333 334 The resulting identifier will be MAX_LABEL_LENGTH characters long. 335 336 */ 337 338 339 /* Table used to convert an integer into a string. */ 340 341 static const char codings[] = { 342 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 343 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 344 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 345 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 346 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_'}; 347 348 /* The number of codings in the above table. */ 349 static const int number_of_codings = sizeof (codings) / sizeof (char); 350 351 /* Table used by decode_16 () to convert an encoded string back into 352 an integer. */ 353 static char decodings[256]; 354 355 /* Table used by the crc32 function to calcuate the checksum. */ 356 static unsigned int crc32_table[256] = {0, 0}; 357 358 /* Given a string in BUF, calculate a 32-bit CRC for it. 359 360 This is used as a reasonably unique hash for the given string. */ 361 362 static unsigned int 363 crc32 (unsigned char *buf, int len) 364 { 365 unsigned int crc = 0xffffffff; 366 367 if (! crc32_table[1]) 368 { 369 /* Initialize the CRC table and the decoding table. */ 370 int i, j; 371 unsigned int c; 372 373 for (i = 0; i < 256; i++) 374 { 375 for (c = i << 24, j = 8; j > 0; --j) 376 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); 377 crc32_table[i] = c; 378 decodings[i] = 0; 379 } 380 for (i = 0; i < number_of_codings; i++) 381 decodings[codings[i] & 255] = i; 382 } 383 384 while (len--) 385 { 386 crc = (crc << 8) ^ crc32_table[(crc >> 24) ^ *buf]; 387 buf++; 388 } 389 return crc; 390 } 391 392 /* Encode the lower 32 bits of VALUE as a 5-character string. */ 393 394 static char * 395 encode_32 (unsigned int value) 396 { 397 static char res[6]; 398 int x; 399 400 res[5] = 0; 401 for(x = 0; x < 5; x++) 402 { 403 res[x] = codings[value % number_of_codings]; 404 value = value / number_of_codings; 405 } 406 return res; 407 } 408 409 /* Encode the lower 16 bits of VALUE as a 3-character string. */ 410 411 static char * 412 encode_16 (unsigned int value) 413 { 414 static char res[4]; 415 int x; 416 417 res[3] = 0; 418 for(x = 0; x < 3; x++) 419 { 420 res[x] = codings[value % number_of_codings]; 421 value = value / number_of_codings; 422 } 423 return res; 424 } 425 426 /* Convert the encoded string obtained from encode_16 () back into a 427 16-bit integer. */ 428 429 static int 430 decode_16 (const char *string) 431 { 432 return decodings[(int) string[2]] * number_of_codings * number_of_codings 433 + decodings[(int) string[1]] * number_of_codings 434 + decodings[(int) string[0]]; 435 } 436 437 /* ID_SUFFIX_LENGTH is used to determine how many characters in the 438 suffix of the identifier are to be preserved, if any. */ 439 440 #ifndef ID_SUFFIX_LENGTH 441 #define ID_SUFFIX_LENGTH(ID) (0) 442 #endif 443 444 /* Return a reasonably-unique version of NAME that is less than or 445 equal to MAX_LABEL_LENGTH characters long. The string returned from 446 this function may be a copy of NAME; the function will never 447 actually modify the contents of NAME. */ 448 449 static char newname[MAX_LABEL_LENGTH + 1]; 450 451 static char * 452 shorten_identifier (char *name) 453 { 454 int crc, len, sum, x, final_len; 455 char *crc_chars; 456 int suffix_length = ID_SUFFIX_LENGTH (name); 457 458 if ((len = strlen (name)) <= MAX_LABEL_LENGTH) 459 return name; 460 461 final_len = MAX_LABEL_LENGTH - 2 - 5 - 3 - 3 - suffix_length; 462 crc = crc32 ((unsigned char *)name + final_len, 463 len - final_len - suffix_length); 464 crc_chars = encode_32 (crc); 465 sum = 0; 466 for (x = 0; x < 5; x++) 467 sum += crc_chars [x]; 468 strncpy (newname, name, final_len); 469 newname [MAX_LABEL_LENGTH] = 0; 470 /* Now append the suffix of the original identifier, if any. */ 471 if (suffix_length) 472 strncpy (newname + MAX_LABEL_LENGTH - suffix_length, 473 name + len - suffix_length, 474 suffix_length); 475 strncpy (newname + final_len, "_h", 2); 476 strncpy (newname + final_len + 2 , crc_chars, 5); 477 strncpy (newname + final_len + 2 + 5, encode_16 (len), 3); 478 strncpy (newname + final_len + 2 + 5 + 3, encode_16 (sum), 3); 479 if (!is_truncated_identifier (newname)) 480 abort (); 481 return newname; 482 } 483 484 /* Determine whether or not ID is a truncated identifier, and return a 485 non-zero value if it is. */ 486 487 static int 488 is_truncated_identifier (char *id) 489 { 490 char *ptr; 491 int len = strlen (id); 492 /* If it's not exactly MAX_LABEL_LENGTH characters long, it can't be 493 a truncated identifier. */ 494 if (len != MAX_LABEL_LENGTH) 495 return 0; 496 497 /* Start scanning backwards for a _h. */ 498 len = len - 3 - 3 - 5 - 2; 499 ptr = id + len; 500 while (ptr >= id) 501 { 502 if (ptr[0] == '_' && ptr[1] == 'h') 503 { 504 /* Now see if the sum encoded in the identifer matches. */ 505 int x, sum; 506 sum = 0; 507 for (x = 0; x < 5; x++) 508 sum += ptr[x + 2]; 509 /* If it matches, this is probably a truncated identifier. */ 510 if (sum == decode_16 (ptr + 5 + 2 + 3)) 511 return 1; 512 } 513 ptr--; 514 } 515 return 0; 516 } 517 518 /* end of obj-evax.c */ 519