11618Srie /* 21618Srie * CDDL HEADER START 31618Srie * 41618Srie * The contents of this file are subject to the terms of the 51618Srie * Common Development and Distribution License (the "License"). 61618Srie * You may not use this file except in compliance with the License. 71618Srie * 81618Srie * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 91618Srie * or http://www.opensolaris.org/os/licensing. 101618Srie * See the License for the specific language governing permissions 111618Srie * and limitations under the License. 121618Srie * 131618Srie * When distributing Covered Code, include this CDDL HEADER in each 141618Srie * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 151618Srie * If applicable, add the following below this CDDL HEADER, with the 161618Srie * fields enclosed by brackets "[]" replaced with your own identifying 171618Srie * information: Portions Copyright [yyyy] [name of copyright owner] 181618Srie * 191618Srie * CDDL HEADER END 201618Srie */ 211618Srie 221618Srie /* 231618Srie * Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. 241618Srie * Copyright (c) 1988 AT&T 251618Srie * All Rights Reserved 261618Srie * 27*3862Srie * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 281618Srie * Use is subject to license terms. 291618Srie */ 301618Srie #pragma ident "%Z%%M% %I% %E% SMI" 311618Srie 321618Srie #include <string.h> 331618Srie #include <stdio.h> 341618Srie #include <sys/elf_386.h> 351618Srie #include <debug.h> 361618Srie #include <reloc.h> 371618Srie #include "msg.h" 381618Srie #include "_libld.h" 391618Srie 401618Srie Word 411618Srie ld_init_rel(Rel_desc *reld, void *reloc) 421618Srie { 431618Srie Rel * rel = (Rel *)reloc; 441618Srie 451618Srie /* LINTED */ 461618Srie reld->rel_rtype = (Word)ELF_R_TYPE(rel->r_info); 471618Srie reld->rel_roffset = rel->r_offset; 481618Srie reld->rel_raddend = 0; 491618Srie reld->rel_typedata = 0; 501618Srie 511618Srie return ((Word)ELF_R_SYM(rel->r_info)); 521618Srie } 531618Srie 541618Srie void 551618Srie ld_mach_eflags(Ehdr *ehdr, Ofl_desc *ofl) 561618Srie { 571618Srie ofl->ofl_dehdr->e_flags |= ehdr->e_flags; 581618Srie } 591618Srie 601618Srie void 611618Srie ld_mach_make_dynamic(Ofl_desc *ofl, size_t *cnt) 621618Srie { 631618Srie if (!(ofl->ofl_flags & FLG_OF_RELOBJ)) { 641618Srie /* 651618Srie * Create this entry if we are going to create a PLT table. 661618Srie */ 671618Srie if (ofl->ofl_pltcnt) 681618Srie (*cnt)++; /* DT_PLTGOT */ 691618Srie } 701618Srie } 711618Srie 721618Srie void 732145Srie ld_mach_update_odynamic(Ofl_desc *ofl, Dyn **dyn) 741618Srie { 751618Srie if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) && ofl->ofl_pltcnt) { 761618Srie (*dyn)->d_tag = DT_PLTGOT; 771618Srie if (ofl->ofl_osgot) 781618Srie (*dyn)->d_un.d_ptr = ofl->ofl_osgot->os_shdr->sh_addr; 791618Srie else 801618Srie (*dyn)->d_un.d_ptr = 0; 811618Srie (*dyn)++; 821618Srie } 831618Srie } 841618Srie 851618Srie Xword 861618Srie ld_calc_plt_addr(Sym_desc *sdp, Ofl_desc *ofl) 871618Srie { 881618Srie Xword value; 891618Srie 901618Srie value = (Xword)(ofl->ofl_osplt->os_shdr->sh_addr) + 911618Srie M_PLT_RESERVSZ + ((sdp->sd_aux->sa_PLTndx - 1) * M_PLT_ENTSIZE); 921618Srie return (value); 931618Srie } 941618Srie 951618Srie /* 961618Srie * Build a single plt entry - code is: 971618Srie * if (building a.out) 981618Srie * JMP *got_off 991618Srie * else 1001618Srie * JMP *got_off@GOT(%ebx) 1011618Srie * PUSHL &rel_off 1021618Srie * JMP -n(%pc) # -n is pcrel offset to first plt entry 1031618Srie * 1041618Srie * The got_off@GOT entry gets filled with the address of the PUSHL, 1051618Srie * so the first pass through the plt jumps back here, jumping 1061618Srie * in turn to the first plt entry, which jumps to the dynamic 1071618Srie * linker. The dynamic linker then patches the GOT, rerouting 1081618Srie * future plt calls to the proper destination. 1091618Srie */ 1101618Srie static void 1111618Srie plt_entry(Ofl_desc * ofl, Word rel_off, Sym_desc * sdp) 1121618Srie { 1131618Srie uchar_t *pltent, *gotent; 1141618Srie Sword plt_off; 1151618Srie Word got_off; 1161618Srie 1171618Srie got_off = sdp->sd_aux->sa_PLTGOTndx * M_GOT_ENTSIZE; 1181618Srie plt_off = M_PLT_RESERVSZ + ((sdp->sd_aux->sa_PLTndx - 1) * 1191618Srie M_PLT_ENTSIZE); 1201618Srie pltent = (uchar_t *)(ofl->ofl_osplt->os_outdata->d_buf) + plt_off; 1211618Srie gotent = (uchar_t *)(ofl->ofl_osgot->os_outdata->d_buf) + got_off; 1221618Srie 1231618Srie /* 1241618Srie * Fill in the got entry with the address of the next instruction. 1251618Srie */ 1261618Srie /* LINTED */ 1271618Srie *(Word *)gotent = ofl->ofl_osplt->os_shdr->sh_addr + plt_off + 1281618Srie M_PLT_INSSIZE; 1291618Srie 1301618Srie if (!(ofl->ofl_flags & FLG_OF_SHAROBJ)) { 1311618Srie pltent[0] = M_SPECIAL_INST; 1321618Srie pltent[1] = M_JMP_DISP_IND; 1331618Srie pltent += 2; 1341618Srie /* LINTED */ 1351618Srie *(Word *)pltent = (Word)(ofl->ofl_osgot->os_shdr->sh_addr + 1361618Srie got_off); 1371618Srie } else { 1381618Srie pltent[0] = M_SPECIAL_INST; 1391618Srie pltent[1] = M_JMP_REG_DISP_IND; 1401618Srie pltent += 2; 1411618Srie /* LINTED */ 1421618Srie *(Word *)pltent = (Word)got_off; 1431618Srie } 1441618Srie pltent += 4; 1451618Srie 1461618Srie pltent[0] = M_INST_PUSHL; 1471618Srie pltent++; 1481618Srie /* LINTED */ 1491618Srie *(Word *)pltent = (Word)rel_off; 1501618Srie pltent += 4; 1511618Srie 1521618Srie plt_off = -(plt_off + 16); /* JMP, PUSHL, JMP take 16 bytes */ 1531618Srie pltent[0] = M_INST_JMP; 1541618Srie pltent++; 1551618Srie /* LINTED */ 1561618Srie *(Word *)pltent = (Word)plt_off; 1571618Srie } 1581618Srie 1591618Srie uintptr_t 1601618Srie ld_perform_outreloc(Rel_desc * orsp, Ofl_desc * ofl) 1611618Srie { 1621618Srie Os_desc * relosp, * osp = 0; 1631618Srie Word ndx, roffset, value; 1641618Srie Rel rea; 1651618Srie char *relbits; 1661618Srie Sym_desc * sdp, * psym = (Sym_desc *)0; 1671618Srie int sectmoved = 0; 1681618Srie 1691618Srie sdp = orsp->rel_sym; 1701618Srie 1711618Srie /* 1721618Srie * If the section this relocation is against has been discarded 1731618Srie * (-zignore), then also discard (skip) the relocation itself. 1741618Srie */ 1751618Srie if (orsp->rel_isdesc && ((orsp->rel_flags & 1761618Srie (FLG_REL_GOT | FLG_REL_BSS | FLG_REL_PLT | FLG_REL_NOINFO)) == 0) && 1771618Srie (orsp->rel_isdesc->is_flags & FLG_IS_DISCARD)) { 1781618Srie DBG_CALL(Dbg_reloc_discard(ofl->ofl_lml, M_MACH, orsp)); 1791618Srie return (1); 1801618Srie } 1811618Srie 1821618Srie /* 1831618Srie * If this is a relocation against a move table, or expanded move 1841618Srie * table, adjust the relocation entries. 1851618Srie */ 1861618Srie if (orsp->rel_move) 1871618Srie ld_adj_movereloc(ofl, orsp); 1881618Srie 1891618Srie /* 1901618Srie * If this is a relocation against a section using a partial initialized 1911618Srie * symbol, adjust the embedded symbol info. 1921618Srie * 1931618Srie * The second argument of the am_I_partial() is the value stored at the 1941618Srie * target address relocation is going to be applied. 1951618Srie */ 1961618Srie if (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) { 1971618Srie if (ofl->ofl_parsym.head && 1981618Srie (sdp->sd_isc->is_flags & FLG_IS_RELUPD) && 1991618Srie /* LINTED */ 2001618Srie (psym = ld_am_I_partial(orsp, *(Xword *) 2011618Srie ((uchar_t *)(orsp->rel_isdesc->is_indata->d_buf) + 2021618Srie orsp->rel_roffset)))) { 2031618Srie DBG_CALL(Dbg_move_outsctadj(ofl->ofl_lml, psym)); 2041618Srie sectmoved = 1; 2051618Srie } 2061618Srie } 2071618Srie 2081618Srie value = sdp->sd_sym->st_value; 2091618Srie 2101618Srie if (orsp->rel_flags & FLG_REL_GOT) { 2111618Srie osp = ofl->ofl_osgot; 2121618Srie roffset = (Word)ld_calc_got_offset(orsp, ofl); 2131618Srie 2141618Srie } else if (orsp->rel_flags & FLG_REL_PLT) { 2151618Srie /* 2161618Srie * Note that relocations for PLT's actually 2171618Srie * cause a relocation againt the GOT. 2181618Srie */ 2191618Srie osp = ofl->ofl_osplt; 2201618Srie roffset = (Word) (ofl->ofl_osgot->os_shdr->sh_addr) + 2211618Srie sdp->sd_aux->sa_PLTGOTndx * M_GOT_ENTSIZE; 2221618Srie 2231618Srie plt_entry(ofl, osp->os_relosdesc->os_szoutrels, sdp); 2241618Srie 2251618Srie } else if (orsp->rel_flags & FLG_REL_BSS) { 2261618Srie /* 2271618Srie * This must be a R_386_COPY. For these set the roffset to 2281618Srie * point to the new symbols location. 2291618Srie */ 2301618Srie osp = ofl->ofl_isbss->is_osdesc; 2311618Srie roffset = (Word)value; 2321618Srie } else { 2331618Srie osp = orsp->rel_osdesc; 2341618Srie 2351618Srie /* 2361618Srie * Calculate virtual offset of reference point; equals offset 2371618Srie * into section + vaddr of section for loadable sections, or 2381618Srie * offset plus section displacement for nonloadable sections. 2391618Srie */ 2401618Srie roffset = orsp->rel_roffset + 2411618Srie (Off)_elf_getxoff(orsp->rel_isdesc->is_indata); 2421618Srie if (!(ofl->ofl_flags & FLG_OF_RELOBJ)) 2431618Srie roffset += orsp->rel_isdesc->is_osdesc-> 2441618Srie os_shdr->sh_addr; 2451618Srie } 2461618Srie 2471618Srie if ((osp == 0) || ((relosp = osp->os_relosdesc) == 0)) 2481618Srie relosp = ofl->ofl_osrel; 2491618Srie 2501618Srie /* 2511618Srie * Assign the symbols index for the output relocation. If the 2521618Srie * relocation refers to a SECTION symbol then it's index is based upon 2531618Srie * the output sections symbols index. Otherwise the index can be 2541618Srie * derived from the symbols index itself. 2551618Srie */ 2561618Srie if (orsp->rel_rtype == R_386_RELATIVE) 2571618Srie ndx = STN_UNDEF; 2581618Srie else if ((orsp->rel_flags & FLG_REL_SCNNDX) || 2591618Srie (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION)) { 2601618Srie if (sectmoved == 0) { 2611618Srie /* 2621618Srie * Check for a null input section. This can 2631618Srie * occur if this relocation references a symbol 2641618Srie * generated by sym_add_sym(). 2651618Srie */ 2661618Srie if ((sdp->sd_isc != 0) && 2671618Srie (sdp->sd_isc->is_osdesc != 0)) 2681618Srie ndx = sdp->sd_isc->is_osdesc->os_scnsymndx; 2691618Srie else 2701618Srie ndx = sdp->sd_shndx; 2711618Srie } else 2721618Srie ndx = ofl->ofl_sunwdata1ndx; 2731618Srie } else 2741618Srie ndx = sdp->sd_symndx; 2751618Srie 2761618Srie relbits = (char *)relosp->os_outdata->d_buf; 2771618Srie 2781618Srie rea.r_info = ELF_R_INFO(ndx, orsp->rel_rtype); 2791618Srie rea.r_offset = roffset; 2801618Srie DBG_CALL(Dbg_reloc_out(ofl, ELF_DBG_LD, SHT_REL, &rea, relosp->os_name, 2811618Srie orsp->rel_sname)); 2821618Srie 2831618Srie /* 2841618Srie * Assert we haven't walked off the end of our relocation table. 2851618Srie */ 2861618Srie assert(relosp->os_szoutrels <= relosp->os_shdr->sh_size); 2871618Srie 2881618Srie (void) memcpy((relbits + relosp->os_szoutrels), 2891618Srie (char *)&rea, sizeof (Rel)); 2901618Srie relosp->os_szoutrels += sizeof (Rel); 2911618Srie 2921618Srie /* 2931618Srie * Determine if this relocation is against a non-writable, allocatable 2941618Srie * section. If so we may need to provide a text relocation diagnostic. 2951618Srie * Note that relocations against the .plt (R_386_JMP_SLOT) actually 2961618Srie * result in modifications to the .got. 2971618Srie */ 2981618Srie if (orsp->rel_rtype == R_386_JMP_SLOT) 2991618Srie osp = ofl->ofl_osgot; 3001618Srie 3011618Srie ld_reloc_remain_entry(orsp, osp, ofl); 3021618Srie return (1); 3031618Srie } 3041618Srie 3051618Srie /* 3061618Srie * i386 Instructions for TLS processing 3071618Srie */ 3081618Srie static uchar_t tlsinstr_gd_ie[] = { 3091618Srie /* 3101618Srie * 0x00 movl %gs:0x0, %eax 3111618Srie */ 3121618Srie 0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, 3131618Srie /* 3141618Srie * 0x06 addl x(%eax), %eax 3151618Srie * 0x0c ... 3161618Srie */ 3171618Srie 0x03, 0x80, 0x00, 0x00, 0x00, 0x00 3181618Srie }; 3191618Srie 3201618Srie static uchar_t tlsinstr_gd_le[] = { 3211618Srie /* 3221618Srie * 0x00 movl %gs:0x0, %eax 3231618Srie */ 3241618Srie 0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, 3251618Srie /* 3261618Srie * 0x06 addl $0x0, %eax 3271618Srie */ 3281618Srie 0x05, 0x00, 0x00, 0x00, 0x00, 3291618Srie /* 3301618Srie * 0x0b nop 3311618Srie * 0x0c 3321618Srie */ 3331618Srie 0x90 3341618Srie }; 3351618Srie 3361618Srie static uchar_t tlsinstr_gd_ie_movgs[] = { 3371618Srie /* 3381618Srie * movl %gs:0x0,%eax 3391618Srie */ 3401618Srie 0x65, 0xa1, 0x00, 0x00, 0x00, 00 3411618Srie }; 3421618Srie 3431618Srie #define TLS_GD_IE_MOV 0x8b /* movl opcode */ 3441618Srie #define TLS_GD_IE_POP 0x58 /* popl + reg */ 3451618Srie 3461618Srie #define TLS_GD_LE_MOVL 0xb8 /* movl + reg */ 3471618Srie 3481618Srie #define TLS_NOP 0x90 /* NOP instruction */ 3491618Srie 3501618Srie #define MODRM_MSK_MOD 0xc0 3511618Srie #define MODRM_MSK_RO 0x38 3521618Srie #define MODRM_MSK_RM 0x07 3531618Srie 3541618Srie #define SIB_MSK_SS 0xc0 3551618Srie #define SIB_MSK_IND 0x38 3561618Srie #define SIB_MSK_BS 0x07 3571618Srie 3581618Srie static Fixupret 3591618Srie tls_fixups(Ofl_desc *ofl, Rel_desc *arsp) 3601618Srie { 3611618Srie Sym_desc *sdp = arsp->rel_sym; 3621618Srie Word rtype = arsp->rel_rtype; 3631618Srie uchar_t *offset, r1, r2; 3641618Srie 3651618Srie offset = (uchar_t *)((uintptr_t)arsp->rel_roffset + 3661618Srie (uintptr_t)_elf_getxoff(arsp->rel_isdesc->is_indata) + 3671618Srie (uintptr_t)arsp->rel_osdesc->os_outdata->d_buf); 3681618Srie 3691618Srie if (sdp->sd_ref == REF_DYN_NEED) { 3701618Srie /* 3711618Srie * IE reference model 3721618Srie */ 3731618Srie switch (rtype) { 3741618Srie case R_386_TLS_GD: 3751618Srie /* 3761618Srie * Transition: 3771618Srie * 0x0 leal x@tlsgd(,r1,1), %eax 3781618Srie * 0x7 call ___tls_get_addr 3791618Srie * 0xc 3801618Srie * To: 3811618Srie * 0x0 movl %gs:0, %eax 3821618Srie * 0x6 addl x@gotntpoff(r1), %eax 3831618Srie */ 3841618Srie DBG_CALL(Dbg_reloc_transition(ofl->ofl_lml, M_MACH, 3853304Srie R_386_TLS_GOTIE, arsp)); 3861618Srie arsp->rel_rtype = R_386_TLS_GOTIE; 3871618Srie arsp->rel_roffset += 5; 3881618Srie 3891618Srie /* 3903304Srie * Adjust 'offset' to beginning of instruction 3911618Srie * sequence. 3921618Srie */ 3931618Srie offset -= 3; 3941618Srie r1 = (offset[2] & SIB_MSK_IND) >> 3; 3951618Srie (void) memcpy(offset, tlsinstr_gd_ie, 3961618Srie sizeof (tlsinstr_gd_ie)); 3971618Srie 3981618Srie /* 3991618Srie * set register %r1 into the addl 4001618Srie * instruction. 4011618Srie */ 4021618Srie offset[0x7] |= r1; 4031618Srie return (FIX_RELOC); 4041618Srie 4051618Srie case R_386_TLS_GD_PLT: 4061618Srie /* 4071618Srie * Fixup done via the TLS_GD relocation 4081618Srie */ 4091618Srie DBG_CALL(Dbg_reloc_transition(ofl->ofl_lml, M_MACH, 4103304Srie R_386_NONE, arsp)); 4111618Srie return (FIX_DONE); 4121618Srie } 4131618Srie } 4141618Srie 4151618Srie /* 4161618Srie * LE reference model 4171618Srie */ 4181618Srie switch (rtype) { 4191618Srie case R_386_TLS_GD: 4201618Srie /* 4211618Srie * Transition: 4221618Srie * 0x0 leal x@tlsgd(,r1,1), %eax 4231618Srie * 0x7 call ___tls_get_addr 4241618Srie * 0xc 4251618Srie * To: 4261618Srie * 0x0 movl %gs:0, %eax 4271618Srie * 0x6 addl $x@ntpoff, %eax 4281618Srie * 0xb nop 4291618Srie * 0xc 4301618Srie */ 4311618Srie DBG_CALL(Dbg_reloc_transition(ofl->ofl_lml, M_MACH, 4323304Srie R_386_TLS_LE, arsp)); 4331618Srie 4341618Srie arsp->rel_rtype = R_386_TLS_LE; 4351618Srie arsp->rel_roffset += 4; 4361618Srie 4371618Srie /* 4383304Srie * Adjust 'offset' to beginning of instruction 4391618Srie * sequence. 4401618Srie */ 4411618Srie offset -= 3; 4421618Srie (void) memcpy(offset, tlsinstr_gd_le, 4431618Srie sizeof (tlsinstr_gd_le)); 4441618Srie return (FIX_RELOC); 4451618Srie 4461618Srie case R_386_TLS_GD_PLT: 4471618Srie case R_386_PLT32: 4481618Srie /* 4491618Srie * Fixup done via the TLS_GD relocation 4501618Srie */ 4511618Srie DBG_CALL(Dbg_reloc_transition(ofl->ofl_lml, M_MACH, 4523304Srie R_386_NONE, arsp)); 4531618Srie return (FIX_DONE); 4541618Srie 4551618Srie case R_386_TLS_LDM_PLT: 4561618Srie DBG_CALL(Dbg_reloc_transition(ofl->ofl_lml, M_MACH, 4573304Srie R_386_NONE, arsp)); 4581618Srie 4591618Srie /* 4601618Srie * Transition: 4611618Srie * call __tls_get_addr() 4621618Srie * to: 4631618Srie * nop 4641618Srie * nop 4651618Srie * nop 4661618Srie * nop 4671618Srie * nop 4681618Srie */ 4691618Srie *(offset - 1) = TLS_NOP; 4701618Srie *(offset) = TLS_NOP; 4711618Srie *(offset + 1) = TLS_NOP; 4721618Srie *(offset + 2) = TLS_NOP; 4731618Srie *(offset + 3) = TLS_NOP; 4741618Srie return (FIX_DONE); 4751618Srie 4761618Srie case R_386_TLS_LDM: 4771618Srie DBG_CALL(Dbg_reloc_transition(ofl->ofl_lml, M_MACH, 4783304Srie R_386_NONE, arsp)); 4791618Srie 4801618Srie /* 4811618Srie * Transition: 4821618Srie * 4831618Srie * 0x00 leal x1@tlsldm(%ebx), %eax 4841618Srie * 0x06 call ___tls_get_addr 4851618Srie * 4861618Srie * to: 4871618Srie * 4881618Srie * 0x00 movl %gs:0, %eax 4891618Srie */ 4901618Srie (void) memcpy(offset - 2, tlsinstr_gd_ie_movgs, 4911618Srie sizeof (tlsinstr_gd_ie_movgs)); 4921618Srie return (FIX_DONE); 4931618Srie 4941618Srie case R_386_TLS_LDO_32: 4951618Srie /* 4961618Srie * Instructions: 4971618Srie * 4981618Srie * 0x10 leal x1@dtpoff(%eax), %edx R_386_TLS_LDO_32 4991618Srie * to 5001618Srie * 0x10 leal x1@ntpoff(%eax), %edx R_386_TLS_LE 5011618Srie * 5021618Srie */ 5031618Srie offset -= 2; 5041618Srie 5051618Srie DBG_CALL(Dbg_reloc_transition(ofl->ofl_lml, M_MACH, 5063304Srie R_386_TLS_LE, arsp)); 5071618Srie arsp->rel_rtype = R_386_TLS_LE; 5081618Srie return (FIX_RELOC); 5091618Srie 5101618Srie case R_386_TLS_GOTIE: 5111618Srie /* 5121618Srie * These transitions are a little different than the 5131618Srie * others, in that we could have multiple instructions 5141618Srie * pointed to by a single relocation. Depending upon the 5151618Srie * instruction, we perform a different code transition. 5161618Srie * 5171618Srie * Here's the known transitions: 5181618Srie * 5191618Srie * 1) movl foo@gotntpoff(%reg1), %reg2 5201618Srie * 0x8b, 0x80 | (reg2 << 3) | reg1, foo@gotntpoff 5211618Srie * 5221618Srie * 2) addl foo@gotntpoff(%reg1), %reg2 5231618Srie * 0x03, 0x80 | (reg2 << 3) | reg1, foo@gotntpoff 5241618Srie * 5251618Srie * Transitions IE -> LE 5261618Srie * 5271618Srie * 1) movl $foo@ntpoff, %reg2 5281618Srie * 0xc7, 0xc0 | reg2, foo@ntpoff 5291618Srie * 5301618Srie * 2) addl $foo@ntpoff, %reg2 5311618Srie * 0x81, 0xc0 | reg2, foo@ntpoff 5321618Srie * 5331618Srie * Note: reg1 != 4 (%esp) 5341618Srie */ 5351618Srie DBG_CALL(Dbg_reloc_transition(ofl->ofl_lml, M_MACH, 5363304Srie R_386_TLS_LE, arsp)); 5371618Srie arsp->rel_rtype = R_386_TLS_LE; 5381618Srie 5391618Srie offset -= 2; 5401618Srie r2 = (offset[1] & MODRM_MSK_RO) >> 3; 5411618Srie if (offset[0] == 0x8b) { 5421618Srie /* case 1 above */ 5431618Srie offset[0] = 0xc7; /* movl */ 5441618Srie offset[1] = 0xc0 | r2; 5451618Srie return (FIX_RELOC); 5461618Srie } 5471618Srie 5481618Srie if (offset[0] == 0x03) { 5491618Srie /* case 2 above */ 5501618Srie assert(offset[0] == 0x03); 5511618Srie offset[0] = 0x81; /* addl */ 5521618Srie offset[1] = 0xc0 | r2; 5531618Srie return (FIX_RELOC); 5541618Srie } 5551618Srie 5561618Srie /* 5571618Srie * Unexpected instruction sequence - fatal error. 5581618Srie */ 5591618Srie eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_REL_BADTLSINS), 5601976Sab196087 conv_reloc_386_type(arsp->rel_rtype, 0), 5611618Srie arsp->rel_isdesc->is_file->ifl_name, 5621618Srie demangle(arsp->rel_sname), arsp->rel_isdesc->is_name, 5631618Srie EC_OFF(arsp->rel_roffset)); 5641618Srie return (FIX_ERROR); 5651618Srie 5661618Srie case R_386_TLS_IE: 5671618Srie /* 5681618Srie * These transitions are a little different than the 5691618Srie * others, in that we could have multiple instructions 5701618Srie * pointed to by a single relocation. Depending upon the 5711618Srie * instruction, we perform a different code transition. 5721618Srie * 5731618Srie * Here's the known transitions: 5741618Srie * 1) movl foo@indntpoff, %eax 5751618Srie * 0xa1, foo@indntpoff 5761618Srie * 5771618Srie * 2) movl foo@indntpoff, %eax 5781618Srie * 0x8b, 0x05 | (reg << 3), foo@gotntpoff 5791618Srie * 5801618Srie * 3) addl foo@indntpoff, %eax 5811618Srie * 0x03, 0x05 | (reg << 3), foo@gotntpoff 5821618Srie * 5831618Srie * Transitions IE -> LE 5841618Srie * 5851618Srie * 1) movl $foo@ntpoff, %eax 5861618Srie * 0xb8, foo@ntpoff 5871618Srie * 5881618Srie * 2) movl $foo@ntpoff, %reg 5891618Srie * 0xc7, 0xc0 | reg, foo@ntpoff 5901618Srie * 5911618Srie * 3) addl $foo@ntpoff, %reg 5921618Srie * 0x81, 0xc0 | reg, foo@ntpoff 5931618Srie */ 5941618Srie arsp->rel_rtype = R_386_TLS_LE; 5951618Srie offset--; 5961618Srie if (offset[0] == 0xa1) { 5971618Srie /* case 1 above */ 5981618Srie offset[0] = 0xb8; /* movl */ 5991618Srie return (FIX_RELOC); 6001618Srie } 6011618Srie 6021618Srie offset--; 6031618Srie if (offset[0] == 0x8b) { 6041618Srie /* case 2 above */ 6051618Srie r2 = (offset[1] & MODRM_MSK_RO) >> 3; 6061618Srie offset[0] = 0xc7; /* movl */ 6071618Srie offset[1] = 0xc0 | r2; 6081618Srie return (FIX_RELOC); 6091618Srie } 6101618Srie if (offset[0] == 0x03) { 6111618Srie /* case 3 above */ 6121618Srie r2 = (offset[1] & MODRM_MSK_RO) >> 3; 6131618Srie offset[0] = 0x81; /* addl */ 6141618Srie offset[1] = 0xc0 | r2; 6151618Srie return (FIX_RELOC); 6161618Srie } 6171618Srie /* 6181618Srie * Unexpected instruction sequence - fatal error. 6191618Srie */ 6201618Srie eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_REL_BADTLSINS), 6211976Sab196087 conv_reloc_386_type(arsp->rel_rtype, 0), 6221618Srie arsp->rel_isdesc->is_file->ifl_name, 6231618Srie demangle(arsp->rel_sname), arsp->rel_isdesc->is_name, 6241618Srie EC_OFF(arsp->rel_roffset)); 6251618Srie return (FIX_ERROR); 6261618Srie } 6271618Srie return (FIX_RELOC); 6281618Srie } 6291618Srie 6301618Srie uintptr_t 6311618Srie ld_do_activerelocs(Ofl_desc *ofl) 6321618Srie { 6331618Srie Rel_desc *arsp; 6341618Srie Rel_cache *rcp; 6351618Srie Listnode *lnp; 6361618Srie uintptr_t return_code = 1; 6371618Srie Word flags = ofl->ofl_flags; 6381618Srie Word dtflags1 = ofl->ofl_dtflags_1; 6391618Srie 6402647Srie if (ofl->ofl_actrels.head) 6412647Srie DBG_CALL(Dbg_reloc_doact_title(ofl->ofl_lml)); 6422647Srie 6431618Srie /* 6441618Srie * Process active relocations. 6451618Srie */ 6461618Srie for (LIST_TRAVERSE(&ofl->ofl_actrels, lnp, rcp)) { 6471618Srie /* LINTED */ 6481618Srie for (arsp = (Rel_desc *)(rcp + 1); 6491618Srie arsp < rcp->rc_free; arsp++) { 6501618Srie uchar_t *addr; 6511618Srie Xword value; 6521618Srie Sym_desc *sdp; 6531618Srie const char *ifl_name; 6541618Srie Xword refaddr; 6551618Srie int moved = 0; 6561618Srie Gotref gref; 6571618Srie 6581618Srie /* 6591618Srie * If the section this relocation is against has been 6601618Srie * discarded (-zignore), then discard (skip) the 6611618Srie * relocation itself. 6621618Srie */ 6631618Srie if ((arsp->rel_isdesc->is_flags & FLG_IS_DISCARD) && 6641618Srie ((arsp->rel_flags & 6651618Srie (FLG_REL_GOT | FLG_REL_BSS | 6661618Srie FLG_REL_PLT | FLG_REL_NOINFO)) == 0)) { 6671618Srie DBG_CALL(Dbg_reloc_discard(ofl->ofl_lml, 6681618Srie M_MACH, arsp)); 6691618Srie continue; 6701618Srie } 6711618Srie 6721618Srie /* 6731618Srie * We deteremine what the 'got reference' 6741618Srie * model (if required) is at this point. This 6751618Srie * needs to be done before tls_fixup() since 6761618Srie * it may 'transition' our instructions. 6771618Srie * 6781618Srie * The got table entries have already been assigned, 6791618Srie * and we bind to those initial entries. 6801618Srie */ 6811618Srie if (arsp->rel_flags & FLG_REL_DTLS) 6821618Srie gref = GOT_REF_TLSGD; 6831618Srie else if (arsp->rel_flags & FLG_REL_MTLS) 6841618Srie gref = GOT_REF_TLSLD; 6851618Srie else if (arsp->rel_flags & FLG_REL_STLS) 6861618Srie gref = GOT_REF_TLSIE; 6871618Srie else 6881618Srie gref = GOT_REF_GENERIC; 6891618Srie 6901618Srie /* 6911618Srie * Perform any required TLS fixups. 6921618Srie */ 6931618Srie if (arsp->rel_flags & FLG_REL_TLSFIX) { 6941618Srie Fixupret ret; 6951618Srie 6961618Srie if ((ret = tls_fixups(ofl, arsp)) == FIX_ERROR) 6971618Srie return (S_ERROR); 6981618Srie if (ret == FIX_DONE) 6991618Srie continue; 7001618Srie } 7011618Srie 7021618Srie /* 7031618Srie * If this is a relocation against a move table, or 7041618Srie * expanded move table, adjust the relocation entries. 7051618Srie */ 7061618Srie if (arsp->rel_move) 7071618Srie ld_adj_movereloc(ofl, arsp); 7081618Srie 7091618Srie sdp = arsp->rel_sym; 7101618Srie refaddr = arsp->rel_roffset + 7111618Srie (Off)_elf_getxoff(arsp->rel_isdesc->is_indata); 7121618Srie 7131618Srie if (arsp->rel_flags & FLG_REL_CLVAL) 7141618Srie value = 0; 7151618Srie else if (ELF_ST_TYPE(sdp->sd_sym->st_info) == 7161618Srie STT_SECTION) { 7171618Srie Sym_desc *sym; 7181618Srie 7191618Srie /* 7201618Srie * The value for a symbol pointing to a SECTION 7211618Srie * is based off of that sections position. 7221618Srie * 7231618Srie * The second argument of the ld_am_I_partial() 7241618Srie * is the value stored at the target address 7251618Srie * relocation is going to be applied. 7261618Srie */ 7271618Srie if ((sdp->sd_isc->is_flags & FLG_IS_RELUPD) && 7281618Srie /* LINTED */ 7291618Srie (sym = ld_am_I_partial(arsp, *(Xword *) 7301618Srie ((uchar_t *) 7311618Srie arsp->rel_isdesc->is_indata->d_buf + 7321618Srie arsp->rel_roffset)))) { 7331618Srie /* 7341618Srie * If the symbol is moved, 7351618Srie * adjust the value 7361618Srie */ 7371618Srie value = sym->sd_sym->st_value; 7381618Srie moved = 1; 7391618Srie } else { 7401618Srie value = _elf_getxoff( 7411618Srie sdp->sd_isc->is_indata); 7421618Srie if (sdp->sd_isc->is_shdr->sh_flags & 7431618Srie SHF_ALLOC) 7441618Srie value += sdp->sd_isc-> 7451618Srie is_osdesc->os_shdr->sh_addr; 7461618Srie } 7471618Srie if (sdp->sd_isc->is_shdr->sh_flags & SHF_TLS) 7481618Srie value -= ofl->ofl_tlsphdr->p_vaddr; 7492850Srie 7502850Srie } else if (IS_SIZE(arsp->rel_rtype)) { 7512850Srie /* 7522850Srie * Size relocations require the symbols size. 7532850Srie */ 7542850Srie value = sdp->sd_sym->st_size; 7551618Srie } else { 7561618Srie /* 7572647Srie * Else the value is the symbols value. 7581618Srie */ 7591618Srie value = sdp->sd_sym->st_value; 7601618Srie } 7611618Srie 7621618Srie /* 7631618Srie * Relocation against the GLOBAL_OFFSET_TABLE. 7641618Srie */ 7651618Srie if (arsp->rel_flags & FLG_REL_GOT) 7661618Srie arsp->rel_osdesc = ofl->ofl_osgot; 7671618Srie 7681618Srie /* 7691618Srie * If loadable and not producing a relocatable object 7701618Srie * add the sections virtual address to the reference 7711618Srie * address. 7721618Srie */ 7731618Srie if ((arsp->rel_flags & FLG_REL_LOAD) && 7741618Srie ((flags & FLG_OF_RELOBJ) == 0)) 7751618Srie refaddr += arsp->rel_isdesc->is_osdesc-> 7761618Srie os_shdr->sh_addr; 7771618Srie 7781618Srie /* 7791618Srie * If this entry has a PLT assigned to it, it's 7801618Srie * value is actually the address of the PLT (and 7811618Srie * not the address of the function). 7821618Srie */ 7831618Srie if (IS_PLT(arsp->rel_rtype)) { 7841618Srie if (sdp->sd_aux && sdp->sd_aux->sa_PLTndx) 7851618Srie value = ld_calc_plt_addr(sdp, ofl); 7861618Srie } 7871618Srie 7881618Srie /* 7891618Srie * Determine whether the value needs further adjustment. 7901618Srie * Filter through the attributes of the relocation to 7911618Srie * determine what adjustment is required. Note, many 7921618Srie * of the following cases are only applicable when a 7931618Srie * .got is present. As a .got is not generated when a 7941618Srie * relocatable object is being built, any adjustments 7951618Srie * that require a .got need to be skipped. 7961618Srie */ 7971618Srie if ((arsp->rel_flags & FLG_REL_GOT) && 7981618Srie ((flags & FLG_OF_RELOBJ) == 0)) { 7991618Srie Xword R1addr; 8001618Srie uintptr_t R2addr; 8011618Srie Word gotndx; 8021618Srie Gotndx *gnp; 8031618Srie 8041618Srie /* 8051618Srie * Perform relocation against GOT table. Since 8061618Srie * this doesn't fit exactly into a relocation 8071618Srie * we place the appropriate byte in the GOT 8081618Srie * directly 8091618Srie * 8101618Srie * Calculate offset into GOT at which to apply 8111618Srie * the relocation. 8121618Srie */ 8131618Srie gnp = ld_find_gotndx(&(sdp->sd_GOTndxs), gref, 8141618Srie ofl, 0); 8151618Srie assert(gnp); 8161618Srie 8171618Srie if (arsp->rel_rtype == R_386_TLS_DTPOFF32) 8181618Srie gotndx = gnp->gn_gotndx + 1; 8191618Srie else 8201618Srie gotndx = gnp->gn_gotndx; 8211618Srie 8221618Srie R1addr = (Xword)(gotndx * M_GOT_ENTSIZE); 8231618Srie 8241618Srie /* 8251618Srie * Add the GOTs data's offset. 8261618Srie */ 8271618Srie R2addr = R1addr + (uintptr_t) 8281618Srie arsp->rel_osdesc->os_outdata->d_buf; 8291618Srie 8301618Srie DBG_CALL(Dbg_reloc_doact(ofl->ofl_lml, 8311618Srie ELF_DBG_LD, M_MACH, SHT_REL, 8321618Srie arsp->rel_rtype, R1addr, value, 8331618Srie arsp->rel_sname, arsp->rel_osdesc)); 8341618Srie 8351618Srie /* 8361618Srie * And do it. 8371618Srie */ 8381618Srie *(Xword *)R2addr = value; 8391618Srie continue; 8401618Srie 8411618Srie } else if (IS_GOT_BASED(arsp->rel_rtype) && 8421618Srie ((flags & FLG_OF_RELOBJ) == 0)) { 8431618Srie value -= ofl->ofl_osgot->os_shdr->sh_addr; 8441618Srie 8451618Srie } else if (IS_GOT_PC(arsp->rel_rtype) && 8461618Srie ((flags & FLG_OF_RELOBJ) == 0)) { 8471618Srie value = 8481618Srie (Xword)(ofl->ofl_osgot->os_shdr->sh_addr) - 8491618Srie refaddr; 8501618Srie 8511618Srie } else if ((IS_PC_RELATIVE(arsp->rel_rtype)) && 8521618Srie (((flags & FLG_OF_RELOBJ) == 0) || 8531618Srie (arsp->rel_osdesc == sdp->sd_isc->is_osdesc))) { 8541618Srie value -= refaddr; 8551618Srie 8561618Srie } else if (IS_TLS_INS(arsp->rel_rtype) && 8571618Srie IS_GOT_RELATIVE(arsp->rel_rtype) && 8581618Srie ((flags & FLG_OF_RELOBJ) == 0)) { 8591618Srie Gotndx *gnp; 8601618Srie 8611618Srie gnp = ld_find_gotndx(&(sdp->sd_GOTndxs), gref, 8621618Srie ofl, 0); 8631618Srie assert(gnp); 8641618Srie value = (Xword)gnp->gn_gotndx * M_GOT_ENTSIZE; 8651618Srie if (arsp->rel_rtype == R_386_TLS_IE) { 8661618Srie value += 8671618Srie ofl->ofl_osgot->os_shdr->sh_addr; 8681618Srie } 8691618Srie 8701618Srie } else if (IS_GOT_RELATIVE(arsp->rel_rtype) && 8711618Srie ((flags & FLG_OF_RELOBJ) == 0)) { 8721618Srie Gotndx *gnp; 8731618Srie 8741618Srie gnp = ld_find_gotndx(&(sdp->sd_GOTndxs), 8751618Srie GOT_REF_GENERIC, ofl, 0); 8761618Srie assert(gnp); 8771618Srie value = (Xword)gnp->gn_gotndx * M_GOT_ENTSIZE; 8781618Srie 8791618Srie } else if ((arsp->rel_flags & FLG_REL_STLS) && 8801618Srie ((flags & FLG_OF_RELOBJ) == 0)) { 8811618Srie Xword tlsstatsize; 8821618Srie 8831618Srie /* 8841618Srie * This is the LE TLS reference model. Static 8851618Srie * offset is hard-coded. 8861618Srie */ 8871618Srie tlsstatsize = 8881618Srie S_ROUND(ofl->ofl_tlsphdr->p_memsz, 8891618Srie M_TLSSTATALIGN); 8901618Srie value = tlsstatsize - value; 8911618Srie 8921618Srie /* 8931618Srie * Since this code is fixed up, it assumes a 8941618Srie * negative offset that can be added to the 8951618Srie * thread pointer. 8961618Srie */ 8971618Srie if ((arsp->rel_rtype == R_386_TLS_LDO_32) || 8981618Srie (arsp->rel_rtype == R_386_TLS_LE)) 8991618Srie value = -value; 9001618Srie } 9011618Srie 9021618Srie if (arsp->rel_isdesc->is_file) 9031618Srie ifl_name = arsp->rel_isdesc->is_file->ifl_name; 9041618Srie else 9051618Srie ifl_name = MSG_INTL(MSG_STR_NULL); 9061618Srie 9071618Srie /* 9081618Srie * Make sure we have data to relocate. Compiler and 9091618Srie * assembler developers have been known to generate 9101618Srie * relocations against invalid sections (normally .bss), 9111618Srie * so for their benefit give them sufficient information 9121618Srie * to help analyze the problem. End users should never 9131618Srie * see this. 9141618Srie */ 9151618Srie if (arsp->rel_isdesc->is_indata->d_buf == 0) { 9161618Srie eprintf(ofl->ofl_lml, ERR_FATAL, 9171618Srie MSG_INTL(MSG_REL_EMPTYSEC), 9181976Sab196087 conv_reloc_386_type(arsp->rel_rtype, 0), 9191618Srie ifl_name, demangle(arsp->rel_sname), 9201618Srie arsp->rel_isdesc->is_name); 9211618Srie return (S_ERROR); 9221618Srie } 9231618Srie 9241618Srie /* 9251618Srie * Get the address of the data item we need to modify. 9261618Srie */ 9271618Srie addr = (uchar_t *)((uintptr_t)arsp->rel_roffset + 9281618Srie (uintptr_t)_elf_getxoff(arsp->rel_isdesc-> 9291618Srie is_indata)); 9301618Srie 9311618Srie DBG_CALL(Dbg_reloc_doact(ofl->ofl_lml, ELF_DBG_LD, 9321618Srie M_MACH, SHT_REL, arsp->rel_rtype, EC_NATPTR(addr), 9331618Srie value, arsp->rel_sname, arsp->rel_osdesc)); 9341618Srie addr += (uintptr_t)arsp->rel_osdesc->os_outdata->d_buf; 9351618Srie 9361618Srie if ((((uintptr_t)addr - (uintptr_t)ofl->ofl_nehdr) > 9371618Srie ofl->ofl_size) || (arsp->rel_roffset > 9381618Srie arsp->rel_osdesc->os_shdr->sh_size)) { 9391618Srie int class; 9401618Srie 9411618Srie if (((uintptr_t)addr - 9421618Srie (uintptr_t)ofl->ofl_nehdr) > ofl->ofl_size) 9431618Srie class = ERR_FATAL; 9441618Srie else 9451618Srie class = ERR_WARNING; 9461618Srie 9471618Srie eprintf(ofl->ofl_lml, class, 9481618Srie MSG_INTL(MSG_REL_INVALOFFSET), 9491976Sab196087 conv_reloc_386_type(arsp->rel_rtype, 0), 9501618Srie ifl_name, arsp->rel_isdesc->is_name, 9511618Srie demangle(arsp->rel_sname), 9521618Srie EC_ADDR((uintptr_t)addr - 9531618Srie (uintptr_t)ofl->ofl_nehdr)); 9541618Srie 9551618Srie if (class == ERR_FATAL) { 9561618Srie return_code = S_ERROR; 9571618Srie continue; 9581618Srie } 9591618Srie } 9601618Srie 9611618Srie /* 9621618Srie * The relocation is additive. Ignore the previous 9631618Srie * symbol value if this local partial symbol is 9641618Srie * expanded. 9651618Srie */ 9661618Srie if (moved) 9671618Srie value -= *addr; 9681618Srie 9691618Srie /* 9701618Srie * If '-z noreloc' is specified - skip the do_reloc 9711618Srie * stage. 9721618Srie */ 9731618Srie if ((flags & FLG_OF_RELOBJ) || 9741618Srie !(dtflags1 & DF_1_NORELOC)) { 9751618Srie if (do_reloc((uchar_t)arsp->rel_rtype, addr, 9761618Srie &value, arsp->rel_sname, ifl_name, 9771618Srie ofl->ofl_lml) == 0) 9781618Srie return_code = S_ERROR; 9791618Srie } 9801618Srie } 9811618Srie } 9821618Srie return (return_code); 9831618Srie } 9841618Srie 9851618Srie /* 9861618Srie * Add an output relocation record. 9871618Srie */ 9881618Srie uintptr_t 9891618Srie ld_add_outrel(Word flags, Rel_desc *rsp, Ofl_desc *ofl) 9901618Srie { 9911618Srie Rel_desc *orsp; 9921618Srie Rel_cache *rcp; 9931618Srie Sym_desc *sdp = rsp->rel_sym; 9941618Srie 9951618Srie /* 9961618Srie * Static executables *do not* want any relocations against them. 9971618Srie * Since our engine still creates relocations against a WEAK UNDEFINED 9981618Srie * symbol in a static executable, it's best to disable them here 9991618Srie * instead of through out the relocation code. 10001618Srie */ 10011618Srie if ((ofl->ofl_flags & (FLG_OF_STATIC | FLG_OF_EXEC)) == 10021618Srie (FLG_OF_STATIC | FLG_OF_EXEC)) 10031618Srie return (1); 10041618Srie 10051618Srie /* 10061618Srie * If no relocation cache structures are available allocate 10071618Srie * a new one and link it into the cache list. 10081618Srie */ 10091618Srie if ((ofl->ofl_outrels.tail == 0) || 10101618Srie ((rcp = (Rel_cache *)ofl->ofl_outrels.tail->data) == 0) || 10111618Srie ((orsp = rcp->rc_free) == rcp->rc_end)) { 10121618Srie static size_t nextsize = 0; 10131618Srie size_t size; 10141618Srie 10151618Srie /* 10161618Srie * Output relocation numbers can vary considerably between 10171618Srie * building executables or shared objects (pic vs. non-pic), 10181618Srie * etc. But, they typically aren't very large, so for these 10191618Srie * objects use a standard bucket size. For building relocatable 10201618Srie * objects, typically there will be an output relocation for 10211618Srie * every input relocation. 10221618Srie */ 10231618Srie if (nextsize == 0) { 10241618Srie if (ofl->ofl_flags & FLG_OF_RELOBJ) { 10251618Srie if ((size = ofl->ofl_relocincnt) == 0) 10261618Srie size = REL_LOIDESCNO; 10271618Srie if (size > REL_HOIDESCNO) 10281618Srie nextsize = REL_HOIDESCNO; 10291618Srie else 10301618Srie nextsize = REL_LOIDESCNO; 10311618Srie } else 10321618Srie nextsize = size = REL_HOIDESCNO; 10331618Srie } else 10341618Srie size = nextsize; 10351618Srie 10361618Srie size = size * sizeof (Rel_desc); 10371618Srie 10381618Srie if (((rcp = libld_malloc(sizeof (Rel_cache) + size)) == 0) || 10391618Srie (list_appendc(&ofl->ofl_outrels, rcp) == 0)) 10401618Srie return (S_ERROR); 10411618Srie 10421618Srie /* LINTED */ 10431618Srie rcp->rc_free = orsp = (Rel_desc *)(rcp + 1); 10441618Srie /* LINTED */ 10451618Srie rcp->rc_end = (Rel_desc *)((char *)rcp->rc_free + size); 10461618Srie } 10471618Srie 10481618Srie /* 10491618Srie * If we are adding a output relocation against a section 10501618Srie * symbol (non-RELATIVE) then mark that section. These sections 10511618Srie * will be added to the .dynsym symbol table. 10521618Srie */ 10531618Srie if (sdp && (rsp->rel_rtype != M_R_RELATIVE) && 10541618Srie ((flags & FLG_REL_SCNNDX) || 10551618Srie (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION))) { 10561618Srie 10571618Srie /* 10581618Srie * If this is a COMMON symbol - no output section 10591618Srie * exists yet - (it's created as part of sym_validate()). 10601618Srie * So - we mark here that when it's created it should 10611618Srie * be tagged with the FLG_OS_OUTREL flag. 10621618Srie */ 10631618Srie if ((sdp->sd_flags & FLG_SY_SPECSEC) && 10641682Srie (sdp->sd_sym->st_shndx == SHN_COMMON)) { 10651618Srie if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_TLS) 10661618Srie ofl->ofl_flags1 |= FLG_OF1_BSSOREL; 10671618Srie else 10681618Srie ofl->ofl_flags1 |= FLG_OF1_TLSOREL; 10691618Srie } else { 10701618Srie Os_desc *osp = sdp->sd_isc->is_osdesc; 10711618Srie 10722347Srie if (osp && ((osp->os_flags & FLG_OS_OUTREL) == 0)) { 10731618Srie ofl->ofl_dynshdrcnt++; 10741618Srie osp->os_flags |= FLG_OS_OUTREL; 10751618Srie } 10761618Srie } 10771618Srie } 10781618Srie 10791618Srie *orsp = *rsp; 10801618Srie orsp->rel_flags |= flags; 10811618Srie 10821618Srie rcp->rc_free++; 10831618Srie ofl->ofl_outrelscnt++; 10841618Srie 10851618Srie if (flags & FLG_REL_GOT) 10861618Srie ofl->ofl_relocgotsz += (Xword)sizeof (Rel); 10871618Srie else if (flags & FLG_REL_PLT) 10881618Srie ofl->ofl_relocpltsz += (Xword)sizeof (Rel); 10891618Srie else if (flags & FLG_REL_BSS) 10901618Srie ofl->ofl_relocbsssz += (Xword)sizeof (Rel); 10911618Srie else if (flags & FLG_REL_NOINFO) 10921618Srie ofl->ofl_relocrelsz += (Xword)sizeof (Rel); 10931618Srie else 10941618Srie orsp->rel_osdesc->os_szoutrels += (Xword)sizeof (Rel); 10951618Srie 10961618Srie if (orsp->rel_rtype == M_R_RELATIVE) 10971618Srie ofl->ofl_relocrelcnt++; 10981618Srie 10991618Srie /* 11001618Srie * We don't perform sorting on PLT relocations because 11011618Srie * they have already been assigned a PLT index and if we 11021618Srie * were to sort them we would have to re-assign the plt indexes. 11031618Srie */ 11041618Srie if (!(flags & FLG_REL_PLT)) 11051618Srie ofl->ofl_reloccnt++; 11061618Srie 11071618Srie /* 11081618Srie * Insure a GLOBAL_OFFSET_TABLE is generated if required. 11091618Srie */ 11101618Srie if (IS_GOT_REQUIRED(orsp->rel_rtype)) 11111618Srie ofl->ofl_flags |= FLG_OF_BLDGOT; 11121618Srie 11131618Srie /* 11141618Srie * Identify and possibly warn of a displacement relocation. 11151618Srie */ 11161618Srie if (orsp->rel_flags & FLG_REL_DISP) { 11171618Srie ofl->ofl_dtflags_1 |= DF_1_DISPRELPND; 11181618Srie 11191618Srie if (ofl->ofl_flags & FLG_OF_VERBOSE) 11201618Srie ld_disp_errmsg(MSG_INTL(MSG_REL_DISPREL4), orsp, ofl); 11211618Srie } 11221618Srie DBG_CALL(Dbg_reloc_ors_entry(ofl->ofl_lml, ELF_DBG_LD, SHT_REL, 11231618Srie M_MACH, orsp)); 11241618Srie return (1); 11251618Srie } 11261618Srie 11271618Srie /* 11281618Srie * Stub routine since register symbols are not supported on i386. 11291618Srie */ 11301618Srie /* ARGSUSED */ 11311618Srie uintptr_t 11321618Srie ld_reloc_register(Rel_desc * rsp, Is_desc * isp, Ofl_desc * ofl) 11331618Srie { 11341618Srie eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_REL_NOREG)); 11351618Srie return (S_ERROR); 11361618Srie } 11371618Srie 11381618Srie /* 11391618Srie * process relocation for a LOCAL symbol 11401618Srie */ 11411618Srie uintptr_t 11421618Srie ld_reloc_local(Rel_desc * rsp, Ofl_desc * ofl) 11431618Srie { 11441618Srie Word flags = ofl->ofl_flags; 11451618Srie Sym_desc *sdp = rsp->rel_sym; 11461682Srie Word shndx = sdp->sd_sym->st_shndx; 11471618Srie 11481618Srie /* 11491618Srie * if ((shared object) and (not pc relative relocation) and 11501618Srie * (not against ABS symbol)) 11511618Srie * then 11521618Srie * build R_386_RELATIVE 11531618Srie * fi 11541618Srie */ 11551618Srie if ((flags & FLG_OF_SHAROBJ) && (rsp->rel_flags & FLG_REL_LOAD) && 11562850Srie !(IS_PC_RELATIVE(rsp->rel_rtype)) && !(IS_SIZE(rsp->rel_rtype)) && 11571618Srie !(IS_GOT_BASED(rsp->rel_rtype)) && 11581618Srie !(rsp->rel_isdesc != NULL && 11591618Srie (rsp->rel_isdesc->is_shdr->sh_type == SHT_SUNW_dof)) && 11601618Srie (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) || 11611618Srie (shndx != SHN_ABS) || (sdp->sd_aux && sdp->sd_aux->sa_symspec))) { 11621618Srie Word ortype = rsp->rel_rtype; 11631618Srie 11641618Srie rsp->rel_rtype = R_386_RELATIVE; 11651618Srie if (ld_add_outrel(NULL, rsp, ofl) == S_ERROR) 11661618Srie return (S_ERROR); 11671618Srie rsp->rel_rtype = ortype; 11681618Srie } 11691618Srie 11701618Srie /* 11711618Srie * If the relocation is against a 'non-allocatable' section 11721618Srie * and we can not resolve it now - then give a warning 11731618Srie * message. 11741618Srie * 11751618Srie * We can not resolve the symbol if either: 11761618Srie * a) it's undefined 11771618Srie * b) it's defined in a shared library and a 11781618Srie * COPY relocation hasn't moved it to the executable 11791618Srie * 11801618Srie * Note: because we process all of the relocations against the 11811618Srie * text segment before any others - we know whether 11821618Srie * or not a copy relocation will be generated before 11831618Srie * we get here (see reloc_init()->reloc_segments()). 11841618Srie */ 11851618Srie if (!(rsp->rel_flags & FLG_REL_LOAD) && 11861618Srie ((shndx == SHN_UNDEF) || 11871618Srie ((sdp->sd_ref == REF_DYN_NEED) && 11881618Srie ((sdp->sd_flags & FLG_SY_MVTOCOMM) == 0)))) { 11891618Srie /* 11901618Srie * If the relocation is against a SHT_SUNW_ANNOTATE 11911618Srie * section - then silently ignore that the relocation 11921618Srie * can not be resolved. 11931618Srie */ 11941618Srie if (rsp->rel_osdesc && 11951618Srie (rsp->rel_osdesc->os_shdr->sh_type == SHT_SUNW_ANNOTATE)) 11961618Srie return (0); 11971618Srie eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_REL_EXTERNSYM), 11981976Sab196087 conv_reloc_386_type(rsp->rel_rtype, 0), 11991618Srie rsp->rel_isdesc->is_file->ifl_name, 12001618Srie demangle(rsp->rel_sname), rsp->rel_osdesc->os_name); 12011618Srie return (1); 12021618Srie } 12031618Srie 12041618Srie /* 12051618Srie * Perform relocation. 12061618Srie */ 12071618Srie return (ld_add_actrel(NULL, rsp, ofl)); 12081618Srie } 12091618Srie 12101618Srie uintptr_t 12111618Srie /* ARGSUSED */ 12121618Srie ld_reloc_GOTOP(Boolean local, Rel_desc * rsp, Ofl_desc * ofl) 12131618Srie { 12141618Srie /* 12151618Srie * Stub routine for common code compatibility, we shouldn't 12161618Srie * actually get here on x86. 12171618Srie */ 12181618Srie assert(0); 12191618Srie return (S_ERROR); 12201618Srie } 12211618Srie 12221618Srie uintptr_t 12231618Srie ld_reloc_TLS(Boolean local, Rel_desc * rsp, Ofl_desc * ofl) 12241618Srie { 12251618Srie Word rtype = rsp->rel_rtype; 12261618Srie Sym_desc *sdp = rsp->rel_sym; 12271618Srie Word flags = ofl->ofl_flags; 12281618Srie Gotndx *gnp; 12291618Srie 12301618Srie /* 12312145Srie * If we're building an executable - use either the IE or LE access 12322145Srie * model. If we're building a shared object process any IE model. 12331618Srie */ 12342145Srie if ((flags & FLG_OF_EXEC) || (IS_TLS_IE(rtype))) { 12351618Srie /* 12362145Srie * Set the DF_STATIC_TLS flag. 12371618Srie */ 12381618Srie ofl->ofl_dtflags |= DF_STATIC_TLS; 12391618Srie 12402145Srie if (!local || ((flags & FLG_OF_EXEC) == 0)) { 12411618Srie /* 12422145Srie * Assign a GOT entry for static TLS references. 12431618Srie */ 12442145Srie if ((gnp = ld_find_gotndx(&(sdp->sd_GOTndxs), 12452145Srie GOT_REF_TLSIE, ofl, 0)) == 0) { 12462145Srie 12472145Srie if (ld_assign_got_TLS(local, rsp, ofl, sdp, 12482145Srie gnp, GOT_REF_TLSIE, FLG_REL_STLS, 12492145Srie rtype, R_386_TLS_TPOFF, 0) == S_ERROR) 12502145Srie return (S_ERROR); 12511618Srie } 12521618Srie 12532145Srie /* 12542145Srie * IE access model. 12552145Srie */ 12562145Srie if (IS_TLS_IE(rtype)) { 12572145Srie if (ld_add_actrel(FLG_REL_STLS, 12582145Srie rsp, ofl) == S_ERROR) 12592145Srie return (S_ERROR); 12602145Srie 12612145Srie /* 12622145Srie * A non-pic shared object needs to adjust the 12632145Srie * active relocation (indntpoff). 12642145Srie */ 12652145Srie if (((flags & FLG_OF_EXEC) == 0) && 12662145Srie (rtype == R_386_TLS_IE)) { 12672145Srie rsp->rel_rtype = R_386_RELATIVE; 12682145Srie return (ld_add_outrel(NULL, rsp, ofl)); 12692145Srie } 12702145Srie return (1); 12712145Srie } 12721618Srie 12731618Srie /* 12742145Srie * Fixups are required for other executable models. 12751618Srie */ 12761618Srie return (ld_add_actrel((FLG_REL_TLSFIX | FLG_REL_STLS), 12771618Srie rsp, ofl)); 12781618Srie } 12792145Srie 12801618Srie /* 12812145Srie * LE access model. 12821618Srie */ 12831618Srie if (IS_TLS_LE(rtype) || (rtype == R_386_TLS_LDO_32)) 12841618Srie return (ld_add_actrel(FLG_REL_STLS, rsp, ofl)); 12851618Srie 12861618Srie return (ld_add_actrel((FLG_REL_TLSFIX | FLG_REL_STLS), 12871618Srie rsp, ofl)); 12881618Srie } 12891618Srie 12901618Srie /* 12912145Srie * Building a shared object. 12922145Srie * 12932145Srie * Assign a GOT entry for a dynamic TLS reference. 12941618Srie */ 12952145Srie if (IS_TLS_LD(rtype) && ((gnp = ld_find_gotndx(&(sdp->sd_GOTndxs), 12962145Srie GOT_REF_TLSLD, ofl, 0)) == 0)) { 12972145Srie 12982145Srie if (ld_assign_got_TLS(local, rsp, ofl, sdp, gnp, GOT_REF_TLSLD, 12992145Srie FLG_REL_MTLS, rtype, R_386_TLS_DTPMOD32, 0) == S_ERROR) 13002145Srie return (S_ERROR); 13012145Srie 13022145Srie } else if (IS_TLS_GD(rtype) && 13032145Srie ((gnp = ld_find_gotndx(&(sdp->sd_GOTndxs), GOT_REF_TLSGD, 13042145Srie ofl, 0)) == 0)) { 13052145Srie 13062145Srie if (ld_assign_got_TLS(local, rsp, ofl, sdp, gnp, GOT_REF_TLSGD, 13072145Srie FLG_REL_DTLS, rtype, R_386_TLS_DTPMOD32, 13082145Srie R_386_TLS_DTPOFF32) == S_ERROR) 13092145Srie return (S_ERROR); 13101618Srie } 13111618Srie 13121618Srie /* 13131618Srie * For GD/LD TLS reference - TLS_{GD,LD}_CALL, this will eventually 13142145Srie * cause a call to __tls_get_addr(). Convert this relocation to that 13152145Srie * symbol now, and prepare for the PLT magic. 13161618Srie */ 13171618Srie if ((rtype == R_386_TLS_GD_PLT) || (rtype == R_386_TLS_LDM_PLT)) { 1318*3862Srie Sym_desc *tlsgetsym; 13191618Srie 13201618Srie if ((tlsgetsym = ld_sym_add_u(MSG_ORIG(MSG_SYM_TLSGETADDR_UU), 1321*3862Srie ofl, MSG_STR_TLSREL)) == (Sym_desc *)S_ERROR) 13221618Srie return (S_ERROR); 13232145Srie 13241618Srie rsp->rel_sym = tlsgetsym; 13251618Srie rsp->rel_sname = tlsgetsym->sd_name; 13261618Srie rsp->rel_rtype = R_386_PLT32; 13272145Srie 13281618Srie if (ld_reloc_plt(rsp, ofl) == S_ERROR) 13291618Srie return (S_ERROR); 13302145Srie 13311618Srie rsp->rel_sym = sdp; 13321618Srie rsp->rel_sname = sdp->sd_name; 13331618Srie rsp->rel_rtype = rtype; 13341618Srie return (1); 13351618Srie } 13361618Srie 13371618Srie if (IS_TLS_LD(rtype)) 13381618Srie return (ld_add_actrel(FLG_REL_MTLS, rsp, ofl)); 13391618Srie 13401618Srie return (ld_add_actrel(FLG_REL_DTLS, rsp, ofl)); 13411618Srie } 13421618Srie 13431618Srie /* ARGSUSED3 */ 13441618Srie Gotndx * 13451618Srie ld_find_gotndx(List * lst, Gotref gref, Ofl_desc * ofl, Rel_desc * rdesc) 13461618Srie { 13471618Srie Listnode * lnp; 13481618Srie Gotndx * gnp; 13491618Srie 13501618Srie if ((gref == GOT_REF_TLSLD) && ofl->ofl_tlsldgotndx) 13511618Srie return (ofl->ofl_tlsldgotndx); 13521618Srie 13531618Srie for (LIST_TRAVERSE(lst, lnp, gnp)) { 13541618Srie if (gnp->gn_gotref == gref) 13551618Srie return (gnp); 13561618Srie } 13571618Srie return ((Gotndx *)0); 13581618Srie } 13591618Srie 13601618Srie Xword 13611618Srie ld_calc_got_offset(Rel_desc * rdesc, Ofl_desc * ofl) 13621618Srie { 13631618Srie Os_desc *osp = ofl->ofl_osgot; 13641618Srie Sym_desc *sdp = rdesc->rel_sym; 13651618Srie Xword gotndx; 13661618Srie Gotref gref; 13671618Srie Gotndx *gnp; 13681618Srie 13691618Srie if (rdesc->rel_flags & FLG_REL_DTLS) 13701618Srie gref = GOT_REF_TLSGD; 13711618Srie else if (rdesc->rel_flags & FLG_REL_MTLS) 13721618Srie gref = GOT_REF_TLSLD; 13731618Srie else if (rdesc->rel_flags & FLG_REL_STLS) 13741618Srie gref = GOT_REF_TLSIE; 13751618Srie else 13761618Srie gref = GOT_REF_GENERIC; 13771618Srie 13781618Srie gnp = ld_find_gotndx(&(sdp->sd_GOTndxs), gref, ofl, 0); 13791618Srie assert(gnp); 13801618Srie 13811618Srie gotndx = (Xword)gnp->gn_gotndx; 13821618Srie 13831618Srie if ((rdesc->rel_flags & FLG_REL_DTLS) && 13841618Srie (rdesc->rel_rtype == R_386_TLS_DTPOFF32)) 13851618Srie gotndx++; 13861618Srie 13871618Srie return ((Xword)(osp->os_shdr->sh_addr + (gotndx * M_GOT_ENTSIZE))); 13881618Srie } 13891618Srie 13901618Srie 13911618Srie /* ARGSUSED4 */ 13921618Srie uintptr_t 13932145Srie ld_assign_got_ndx(List * lst, Gotndx * pgnp, Gotref gref, Ofl_desc * ofl, 13941618Srie Rel_desc * rsp, Sym_desc * sdp) 13951618Srie { 13961618Srie Gotndx *gnp; 13971618Srie uint_t gotents; 13981618Srie 13991618Srie if (pgnp) 14001618Srie return (1); 14011618Srie 14021618Srie if ((gref == GOT_REF_TLSGD) || (gref == GOT_REF_TLSLD)) 14031618Srie gotents = 2; 14041618Srie else 14051618Srie gotents = 1; 14061618Srie 14071618Srie if ((gnp = libld_calloc(sizeof (Gotndx), 1)) == 0) 14081618Srie return (S_ERROR); 14091618Srie gnp->gn_gotndx = ofl->ofl_gotcnt; 14101618Srie gnp->gn_gotref = gref; 14111618Srie 14121618Srie ofl->ofl_gotcnt += gotents; 14131618Srie 14141618Srie if (gref == GOT_REF_TLSLD) { 14151618Srie ofl->ofl_tlsldgotndx = gnp; 14161618Srie return (1); 14171618Srie } 14181618Srie 14191618Srie if (list_appendc(lst, (void *)gnp) == 0) 14201618Srie return (S_ERROR); 14211618Srie 14221618Srie return (1); 14231618Srie } 14241618Srie 14251618Srie void 14261618Srie ld_assign_plt_ndx(Sym_desc * sdp, Ofl_desc *ofl) 14271618Srie { 14281618Srie sdp->sd_aux->sa_PLTndx = 1 + ofl->ofl_pltcnt++; 14291618Srie sdp->sd_aux->sa_PLTGOTndx = ofl->ofl_gotcnt++; 14301618Srie ofl->ofl_flags |= FLG_OF_BLDGOT; 14311618Srie } 14321618Srie 14331618Srie /* 14341618Srie * Initializes .got[0] with the _DYNAMIC symbol value. 14351618Srie */ 14361618Srie uintptr_t 14372145Srie ld_fillin_gotplt(Ofl_desc *ofl) 14381618Srie { 14392145Srie Word flags = ofl->ofl_flags; 14402145Srie 14411618Srie if (ofl->ofl_osgot) { 14422145Srie Sym_desc *sdp; 14431618Srie 14441618Srie if ((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_DYNAMIC_U), 14451618Srie SYM_NOHASH, 0, ofl)) != NULL) { 14462145Srie uchar_t *genptr; 14472145Srie 14482145Srie genptr = ((uchar_t *)ofl->ofl_osgot->os_outdata->d_buf + 14491618Srie (M_GOT_XDYNAMIC * M_GOT_ENTSIZE)); 14501618Srie /* LINTED */ 14511618Srie *(Word *)genptr = (Word)sdp->sd_sym->st_value; 14521618Srie } 14531618Srie } 14541618Srie 14551618Srie /* 14561618Srie * Fill in the reserved slot in the procedure linkage table the first 14571618Srie * entry is: 14581618Srie * if (building a.out) { 14591618Srie * PUSHL got[1] # the address of the link map entry 14601618Srie * JMP * got[2] # the address of rtbinder 14611618Srie * } else { 14621618Srie * PUSHL got[1]@GOT(%ebx) # the address of the link map entry 14631618Srie * JMP * got[2]@GOT(%ebx) # the address of rtbinder 14641618Srie * } 14651618Srie */ 14662145Srie if ((flags & FLG_OF_DYNAMIC) && ofl->ofl_osplt) { 14671618Srie uchar_t *pltent; 14681618Srie 14691618Srie pltent = (uchar_t *)ofl->ofl_osplt->os_outdata->d_buf; 14702145Srie if (!(flags & FLG_OF_SHAROBJ)) { 14711618Srie pltent[0] = M_SPECIAL_INST; 14721618Srie pltent[1] = M_PUSHL_DISP; 14731618Srie pltent += 2; 14741618Srie /* LINTED */ 14751618Srie *(Word *)pltent = (Word)(ofl->ofl_osgot->os_shdr-> 14761618Srie sh_addr + M_GOT_XLINKMAP * M_GOT_ENTSIZE); 14771618Srie pltent += 4; 14781618Srie pltent[0] = M_SPECIAL_INST; 14791618Srie pltent[1] = M_JMP_DISP_IND; 14801618Srie pltent += 2; 14811618Srie /* LINTED */ 14821618Srie *(Word *)pltent = (Word)(ofl->ofl_osgot->os_shdr-> 14831618Srie sh_addr + M_GOT_XRTLD * M_GOT_ENTSIZE); 14841618Srie } else { 14851618Srie pltent[0] = M_SPECIAL_INST; 14861618Srie pltent[1] = M_PUSHL_REG_DISP; 14871618Srie pltent += 2; 14881618Srie /* LINTED */ 14891618Srie *(Word *)pltent = (Word)(M_GOT_XLINKMAP * 14901618Srie M_GOT_ENTSIZE); 14911618Srie pltent += 4; 14921618Srie pltent[0] = M_SPECIAL_INST; 14931618Srie pltent[1] = M_JMP_REG_DISP_IND; 14941618Srie pltent += 2; 14951618Srie /* LINTED */ 14961618Srie *(Word *)pltent = (Word)(M_GOT_XRTLD * 14971618Srie M_GOT_ENTSIZE); 14981618Srie } 14991618Srie } 15001618Srie return (1); 15011618Srie } 1502