1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1988 AT&T 24 * All Rights Reserved 25 * 26 * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved. 27 */ 28 29 #define ELF_TARGET_AMD64 30 31 #include <stdio.h> 32 #include <memory.h> 33 #include <debug.h> 34 #include "msg.h" 35 #include "_libld.h" 36 37 /* 38 * The link-editor uses a segment descriptor list to describe the program 39 * headers, and related output segments, it can potentially create. This 40 * list is initially seeded using the templates contained in the sg_desc 41 * array below. Additional segments may be added using a mapfile. 42 * 43 * The entries in sg_desc must be put in the order defined by the 44 * Segment_id enum. 45 * 46 * The entries in sg_desc are initialized using the SG_DESC_INIT macro 47 * for two reasons: 48 * 49 * 1) The first field of the Sg_desc struct is a program header 50 * entry. ELF32_Phdr and ELF64_Phdr have the same fields, 51 * but their order is different. Use of a macro allows us 52 * to handle this transparently. 53 * 2) Most of the fields in the Sg_desc entries are set to 0. 54 * Use of a macro allows us to hide the clutter. 55 * 56 * If a given program header can be referenced via an entrance criteria 57 * (i.e. can serve as a segment), then it must be given a unique sg_name. 58 * Program headers that cannot be a segment (PHDR, INTERP, DYNAMIC, etc) 59 * must have a NULL sg_name --- their program header type identifies them. 60 */ 61 #ifdef _ELF64 62 #define SG_DESC_INIT(id, p_type, p_flags, sg_name, sg_flags) \ 63 { id, { p_type, p_flags, 0, 0, 0, 0, 0, 0}, \ 64 sg_name, 0, 0, NULL, NULL, NULL, sg_flags, NULL, 0, NULL} 65 #else 66 #define SG_DESC_INIT(id, p_type, p_flags, sg_name, sg_flags) \ 67 { id, { p_type, 0, 0, 0, 0, 0, p_flags, 0}, \ 68 sg_name, 0, 0, NULL, NULL, NULL, sg_flags, NULL, 0, NULL} 69 #endif 70 71 /* 72 * Predefined segment descriptors: 73 * 74 * The C language guarantees that a structure containing only fields of 75 * identical type is indistinguishable from a simple array containing 76 * the same number of items of the same type. They will have the same 77 * size, alignment, and internal layout: 78 * 79 * - A pointer to one is equivalent to a pointer to the other, and you 80 * can cast safely between them. 81 * 82 * - You can put both into a union, and access the elements within 83 * either way (by index, or by name). 84 * 85 * We use this fact here to create an "array" of predefined segment 86 * descriptors, assigning each one a mnemonic name that can be used to point 87 * at it from a predefined entrance criteria descriptor (below). These 88 * segments are positioned in the default order that will result in the 89 * output object, unless a mapfile alters things. 90 */ 91 typedef struct { 92 Sg_desc psg_phdr; 93 Sg_desc psg_interp; 94 Sg_desc psg_sunwcap; 95 Sg_desc psg_text; 96 Sg_desc psg_data; 97 Sg_desc psg_bss; 98 #if defined(_ELF64) 99 Sg_desc psg_lrodata; /* (amd64-only) */ 100 Sg_desc psg_ldata; /* (amd64-only) */ 101 #endif 102 Sg_desc psg_dynamic; 103 Sg_desc psg_sunwdtrace; 104 Sg_desc psg_tls; 105 Sg_desc psg_unwind; 106 Sg_desc psg_sunwstack; 107 Sg_desc psg_note; 108 Sg_desc psg_extra; 109 } predef_seg_t; 110 111 static const size_t predef_seg_nelts = 112 (sizeof (predef_seg_t) / sizeof (Sg_desc)); 113 114 static predef_seg_t sg_desc = { 115 /* psg_phdr */ 116 SG_DESC_INIT(SGID_PHDR, PT_PHDR, PF_R + PF_X, NULL, 117 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 118 119 /* psg_interp */ 120 SG_DESC_INIT(SGID_INTERP, PT_INTERP, PF_R, NULL, 121 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 122 123 /* psg_sunwcap */ 124 SG_DESC_INIT(SGID_SUNWCAP, PT_SUNWCAP, PF_R, NULL, 125 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 126 127 /* psg_text */ 128 SG_DESC_INIT(SGID_TEXT, PT_LOAD, PF_R + PF_X, MSG_ORIG(MSG_ENT_TEXT), 129 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 130 131 /* psg_data */ 132 SG_DESC_INIT(SGID_DATA, PT_LOAD, 0, MSG_ORIG(MSG_ENT_DATA), 133 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 134 135 /* psg_bss */ 136 SG_DESC_INIT(SGID_BSS, PT_LOAD, 0, MSG_ORIG(MSG_ENT_BSS), 137 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS | FLG_SG_DISABLED)), 138 139 #if defined(_ELF64) 140 /* psg_lrodata (amd64-only ) */ 141 SG_DESC_INIT(SGID_LRODATA, PT_LOAD, PF_R, MSG_ORIG(MSG_ENT_LRODATA), 142 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 143 144 /* psg_ldata (amd64-only ) */ 145 SG_DESC_INIT(SGID_LDATA, PT_LOAD, 0, MSG_ORIG(MSG_ENT_LDATA), 146 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 147 #endif 148 /* psg_dynamic */ 149 SG_DESC_INIT(SGID_DYN, PT_DYNAMIC, 0, NULL, 150 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 151 152 /* psg_sunwdtrace */ 153 SG_DESC_INIT(SGID_DTRACE, PT_SUNWDTRACE, 0, NULL, 154 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 155 156 /* psg_tls */ 157 SG_DESC_INIT(SGID_TLS, PT_TLS, PF_R, NULL, 158 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 159 160 /* psg_unwind */ 161 SG_DESC_INIT(SGID_UNWIND, PT_SUNW_UNWIND, PF_R, NULL, 162 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), 163 164 /* psg_sunwstack */ 165 SG_DESC_INIT(SGID_SUNWSTACK, PT_SUNWSTACK, 0, NULL, 166 (FLG_SG_P_TYPE | FLG_SG_P_FLAGS | FLG_SG_DISABLED)), 167 168 /* psg_note */ 169 SG_DESC_INIT(SGID_NOTE, PT_NOTE, 0, MSG_ORIG(MSG_ENT_NOTE), 170 FLG_SG_P_TYPE), 171 172 /* 173 * psg_extra 174 * 175 * This segment is referenced by the final entrance criteria descriptor 176 * to catch any segment not otherwise placed. It cannot be disabled 177 * via a mapfile. 178 */ 179 SG_DESC_INIT(SGID_EXTRA, PT_NULL, 0, MSG_ORIG(MSG_ENT_EXTRA), 180 (FLG_SG_P_TYPE | FLG_SG_NODISABLE)) 181 }; 182 #undef SG_DESC_INIT 183 184 /* 185 * The processing of input files by the link-editor involves matching the 186 * input file sections against an ordered list of entrance criteria 187 * descriptors. The following template defines the built in entrance criteria 188 * list. This list can be augmented using a mapfile. Each entrance criteria 189 * is associated with a segment descriptor, providing the means for mapping 190 * input sections to output segments. 191 * 192 * As with the segment descriptors, the EC_DESC_INIT macro is used 193 * to reduce boilerplate clutter. 194 */ 195 #define EC_DESC_INIT(ec_is_name, ec_type, ec_attrmask, ec_attrbits, \ 196 _seg_field, ec_flags) \ 197 { NULL, NULL, ec_is_name, ec_type, ec_attrmask, ec_attrbits, \ 198 &sg_desc.psg_ ## _seg_field, 0, FLG_EC_BUILTIN | ec_flags } 199 200 static const Ent_desc ent_desc[] = { 201 EC_DESC_INIT(NULL, SHT_NOTE, 0, 0, note, 0), 202 203 #if defined(_ELF64) /* (amd64-only) */ 204 EC_DESC_INIT(NULL, 0, SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, 205 SHF_ALLOC + SHF_AMD64_LARGE, lrodata, 0), 206 #endif 207 EC_DESC_INIT(NULL, 0, SHF_ALLOC + SHF_WRITE, SHF_ALLOC, text, 0), 208 209 /* 210 * Explicitly assign the .tdata section to bss. The design of TLS 211 * provides for initialized data being assigned to a .tdata section, 212 * and uninitialized data being assigned to a .tbss section. These 213 * sections should be laid out adjacent to each other, with little or 214 * no gap between them. A PT_TLS program header is created that 215 * defines the address range of the two sections. This header is 216 * passed to libc to instantiate the appropriate thread allocation. 217 * 218 * By default a separate bss segment is disabled, however users can 219 * trigger the creation of a bss segment with a mapfile. By default, 220 * all bss sections are assigned to the data segment, and the section 221 * identifiers of .tdata and .tbss ensure that these two sections are 222 * adjacent to each other. 223 * 224 * However, if a bss segment is enabled, the adjacency of the .tdata 225 * and .tbss sections can only be retained by having an explicit .tdata 226 * entrance criteria. 227 */ 228 EC_DESC_INIT(MSG_ORIG(MSG_SCN_TDATA), 0, SHF_ALLOC + SHF_WRITE, 229 SHF_ALLOC + SHF_WRITE, bss, 0), 230 231 EC_DESC_INIT(NULL, SHT_NOBITS, SHF_ALLOC + SHF_WRITE, 232 SHF_ALLOC + SHF_WRITE, bss, 0), 233 234 #if defined(_ELF64) /* (amd64-only) */ 235 EC_DESC_INIT(NULL, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, 236 SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, data, 0), 237 238 EC_DESC_INIT(NULL, 0, SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, 239 SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, ldata, 0), 240 #endif 241 EC_DESC_INIT(NULL, 0, SHF_ALLOC + SHF_WRITE, SHF_ALLOC + SHF_WRITE, 242 data, 0), 243 244 /* 245 * Final catchall rule sends remaining sections to "extra" 246 * NULL segment, which has been tagged as FLG_SG_NODISABLE, 247 * and which will therefore always accept them. 248 */ 249 EC_DESC_INIT(NULL, 0, 0, 0, extra, FLG_EC_CATCHALL) 250 }; 251 #undef EC_DESC_INIT 252 253 /* 254 * AVL comparison function for Sg_desc items in ofl_segs_avl. 255 * 256 * entry: 257 * n1, n2 - pointers to nodes to be compared 258 * 259 * exit: 260 * Returns -1 if (n1 < n2), 0 if they are equal, and 1 if (n1 > n2) 261 */ 262 static int 263 ofl_segs_avl_cmp(const void *n1, const void *n2) 264 { 265 int rc; 266 267 rc = strcmp(((Sg_desc *)n1)->sg_name, ((Sg_desc *)n2)->sg_name); 268 269 if (rc > 0) 270 return (1); 271 if (rc < 0) 272 return (-1); 273 return (0); 274 } 275 276 /* 277 * AVL comparison function for Ent_desc items in ofl_ents_avl. 278 * 279 * entry: 280 * n1, n2 - pointers to nodes to be compared 281 * 282 * exit: 283 * Returns -1 if (n1 < n2), 0 if they are equal, and 1 if (n1 > n2) 284 */ 285 static int 286 ofl_ents_avl_cmp(const void *n1, const void *n2) 287 { 288 int rc; 289 290 /* 291 * There are entrance criteria nodes with NULL pointer names, 292 * but they are never entered into the AVL tree. Hence, we can 293 * assume that both nodes have names. 294 */ 295 rc = strcmp(((Ent_desc *)n1)->ec_name, ((Ent_desc *)n2)->ec_name); 296 297 if (rc > 0) 298 return (1); 299 if (rc < 0) 300 return (-1); 301 return (0); 302 } 303 304 /* 305 * Lookup a segment descriptor by name. 306 * 307 * entry: 308 * ofl - Output descriptor 309 * name - Name of desired segment 310 * 311 * exit: 312 * On success, returns pointer to descriptor. On failure, returns NULL. 313 */ 314 Sg_desc * 315 ld_seg_lookup(Ofl_desc *ofl, const char *name, avl_index_t *where) 316 { 317 Sg_desc sg; 318 319 sg.sg_name = name; 320 return (avl_find(&ofl->ofl_segs_avl, &sg, where)); 321 } 322 323 324 /* 325 * Look up an entrance criteria record by name 326 * 327 * entry: 328 * mf - Mapfile descriptor 329 * name - Name of entrance criteria to locate 330 * 331 * exit: 332 * On success, a pointer to the entrace criteria record is 333 * returned. On failure, NULL is returned. 334 * 335 * note: 336 * Entrance criteria are not required to have names. Only 337 * named entrance criteria can be looked up via this method. 338 */ 339 Ent_desc * 340 ld_ent_lookup(Ofl_desc *ofl, const char *name, avl_index_t *where) 341 { 342 Ent_desc en; 343 344 en.ec_name = name; 345 return (avl_find(&ofl->ofl_ents_avl, &en, where)); 346 } 347 348 /* 349 * Initialize new entrance and segment descriptors and add them as lists to 350 * the output file descriptor. 351 */ 352 uintptr_t 353 ld_ent_setup(Ofl_desc *ofl, Xword segalign) 354 { 355 Ent_desc *enp; 356 predef_seg_t *psegs; 357 Sg_desc *sgp; 358 size_t idx; 359 360 /* 361 * Initialize the elf library. 362 */ 363 if (elf_version(EV_CURRENT) == EV_NONE) { 364 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ELF_LIBELF), 365 EV_CURRENT); 366 return (S_ERROR); 367 } 368 369 /* 370 * Initialize internal Global Symbol Table AVL tree 371 */ 372 avl_create(&ofl->ofl_symavl, &ld_sym_avl_comp, sizeof (Sym_avlnode), 373 SGSOFFSETOF(Sym_avlnode, sav_node)); 374 375 /* Initialize segment AVL tree */ 376 avl_create(&ofl->ofl_segs_avl, ofl_segs_avl_cmp, 377 sizeof (Sg_desc), SGSOFFSETOF(Sg_desc, sg_avlnode)); 378 379 /* Initialize entrance criteria AVL tree */ 380 avl_create(&ofl->ofl_ents_avl, ofl_ents_avl_cmp, sizeof (Ent_desc), 381 SGSOFFSETOF(Ent_desc, ec_avlnode)); 382 383 384 /* 385 * Allocate and initialize writable copies of both the entrance and 386 * segment descriptors. 387 * 388 * Note that on non-amd64 targets, this allocates a few more 389 * elements than are needed. For now, we are willing to overallocate 390 * a small amount to simplify the code. 391 */ 392 if ((psegs = libld_malloc(sizeof (sg_desc))) == NULL) 393 return (S_ERROR); 394 (void) memcpy(psegs, &sg_desc, sizeof (sg_desc)); 395 sgp = (Sg_desc *) psegs; 396 397 /* 398 * The data segment and stack permissions can differ: 399 * 400 * - Architectural/ABI per-platform differences 401 * - Whether the object is built statically or dynamically 402 * 403 * Those segments so affected have their program header flags 404 * set here at runtime, rather than in the sg_desc templates above. 405 */ 406 psegs->psg_data.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; 407 psegs->psg_bss.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; 408 psegs->psg_dynamic.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; 409 psegs->psg_sunwdtrace.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; 410 #if defined(_ELF64) 411 psegs->psg_ldata.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; 412 psegs->psg_sunwdtrace.sg_phdr.p_flags |= PF_X; 413 #endif 414 psegs->psg_sunwstack.sg_phdr.p_flags = ld_targ.t_m.m_stack_perm; 415 if ((ofl->ofl_flags & FLG_OF_DYNAMIC) == 0) 416 psegs->psg_data.sg_phdr.p_flags |= PF_X; 417 418 /* 419 * Traverse the new entrance descriptor list converting the segment 420 * pointer entries to the absolute address within the new segment 421 * descriptor list. Add each entrance descriptor to the output file 422 * list. 423 */ 424 if ((enp = libld_malloc(sizeof (ent_desc))) == NULL) 425 return (S_ERROR); 426 (void) memcpy(enp, ent_desc, sizeof (ent_desc)); 427 for (idx = 0; idx < (sizeof (ent_desc) / sizeof (ent_desc[0])); idx++, 428 enp++) { 429 430 #if defined(_ELF64) 431 /* Don't use the amd64 entry conditions for non-amd64 targets */ 432 if ((enp->ec_attrmask & SHF_AMD64_LARGE) && 433 (ld_targ.t_m.m_mach != EM_AMD64)) 434 continue; 435 #endif 436 if (aplist_append(&ofl->ofl_ents, enp, 437 AL_CNT_OFL_ENTRANCE) == NULL) 438 return (S_ERROR); 439 440 /* 441 * The segment pointer is currently pointing at a template 442 * segment descriptor in sg_desc. Compute its array index, 443 * and then use that index to compute the address of the 444 * corresponding descriptor in the writable copy. 445 */ 446 enp->ec_segment = 447 &sgp[(enp->ec_segment - (Sg_desc *) &sg_desc)]; 448 } 449 450 /* 451 * Add each segment descriptor to the segment descriptor list. The 452 * ones with non-NULL sg_name are also entered into the AVL tree. 453 * For each loadable segment initialize a default alignment. Note 454 * that ld(1) and ld.so.1 initialize this differently. 455 */ 456 for (idx = 0; idx < predef_seg_nelts; idx++, sgp++) { 457 Phdr *phdr = &(sgp->sg_phdr); 458 459 #if defined(_ELF64) 460 /* Ignore amd64 segment templates for non-amd64 targets */ 461 switch (sgp->sg_id) { 462 case SGID_LRODATA: 463 case SGID_LDATA: 464 if ((ld_targ.t_m.m_mach != EM_AMD64)) 465 continue; 466 } 467 #endif 468 if (phdr->p_type == PT_LOAD) 469 phdr->p_align = segalign; 470 471 if ((aplist_append(&ofl->ofl_segs, sgp, 472 AL_CNT_SEGMENTS)) == NULL) 473 return (S_ERROR); 474 475 #ifdef NDEBUG /* assert() is enabled */ 476 /* 477 * Enforce the segment name rule: Any segment that can 478 * be referenced by an entrance descriptor must have 479 * a name. Any segment that cannot, must have a NULL 480 * name pointer. 481 */ 482 switch (phdr->p_type) { 483 case PT_LOAD: 484 case PT_NOTE: 485 case PT_NULL: 486 assert(sgp->sg_name != NULL); 487 break; 488 default: 489 assert(sgp->sg_name == NULL); 490 break; 491 } 492 #endif 493 494 /* 495 * Add named segment descriptors to the AVL tree to 496 * provide O(logN) lookups. 497 */ 498 if (sgp->sg_name != NULL) 499 avl_add(&ofl->ofl_segs_avl, sgp); 500 } 501 502 return (1); 503 } 504