1/*
2 * This file is part of ltrace.
3 * Copyright (C) 2013 Petr Machata, Red Hat Inc.
4 * Copyright (C) 2004,2008,2009 Juan Cespedes
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
19 * 02110-1301 USA
20 */
21
22#include <gelf.h>
23#include <stdbool.h>
24
25#include "proc.h"
26#include "common.h"
27#include "library.h"
28#include "trace.h"
29
30static GElf_Addr
31x86_plt_offset(uint32_t i)
32{
33	/* Skip the first PLT entry, which contains a stub to call the
34	 * resolver.  */
35	return (i + 1) * 16;
36}
37
38GElf_Addr
39arch_plt_sym_val(struct ltelf *lte, size_t ndx, GElf_Rela *rela)
40{
41	uint32_t i = *VECT_ELEMENT(&lte->arch.plt_map, uint32_t, ndx);
42	return x86_plt_offset(i) + lte->plt_addr;
43}
44
45void *
46sym2addr(struct process *proc, struct library_symbol *sym)
47{
48	return sym->enter_addr;
49}
50
51enum plt_status
52arch_elf_add_plt_entry(struct process *proc, struct ltelf *lte,
53		       const char *a_name, GElf_Rela *rela, size_t ndx,
54		       struct library_symbol **ret)
55{
56	bool irelative = false;
57	if (lte->ehdr.e_machine == EM_X86_64) {
58#ifdef R_X86_64_IRELATIVE
59		irelative = GELF_R_TYPE(rela->r_info) == R_X86_64_IRELATIVE;
60#endif
61	} else {
62		assert(lte->ehdr.e_machine == EM_386);
63#ifdef R_386_IRELATIVE
64		irelative = GELF_R_TYPE(rela->r_info) == R_386_IRELATIVE;
65#endif
66	}
67
68	if (irelative)
69		return linux_elf_add_plt_entry_irelative(proc, lte, rela,
70							 ndx, ret);
71
72	return PLT_DEFAULT;
73}
74
75int
76arch_elf_init(struct ltelf *lte, struct library *lib)
77{
78	VECT_INIT(&lte->arch.plt_map, unsigned int);
79
80	/* IRELATIVE slots may make the whole situation a fair deal
81	 * more complex.  On x86{,_64}, the PLT slots are not
82	 * presented in the order of the corresponding relocations,
83	 * but in the order it which these symbols are in the symbol
84	 * table.  That's static symbol table, which may be stripped
85	 * off, not dynsym--that doesn't contain IFUNC symbols at all.
86	 * So we have to decode each PLT entry to figure out what
87	 * entry it corresponds to.  We need to interpret the PLT
88	 * table to figure this out.
89	 *
90	 * On i386, the PLT entry format is as follows:
91	 *
92	 *	8048300:   ff 25 0c a0 04 08       jmp    *0x804a00c
93	 *	8048306:   68 20 00 00 00          push   $0x20
94	 *	804830b:   e9 e0 ff ff ff          jmp    80482f0 <_init+0x30>
95	 *
96	 * For PIE binaries it is the following:
97	 *
98	 *	    410:   ff a3 10 00 00 00       jmp    *0x10(%ebx)
99	 *	    416:   68 00 00 00 00          push   $0x0
100	 *	    41b:   e9 d0 ff ff ff          jmp    3f0 <_init+0x30>
101	 *
102	 * On x86_64, it is:
103	 *
104	 *	 400420:   ff 25 f2 0b 20 00       jmpq   *0x200bf2(%rip)        # 601018 <_GLOBAL_OFFSET_TABLE_+0x18>
105	 *	 400426:   68 00 00 00 00          pushq  $0x0
106	 *	 40042b:   e9 e0 ff ff ff          jmpq   400410 <_init+0x18>
107	 *
108         * On i386, the argument to push is an offset of relocation to
109	 * use.  The first PLT slot has an offset of 0x0, the second
110	 * 0x8, etc.  On x86_64, it's directly the index that we are
111	 * looking for.
112	 */
113
114	/* Here we scan the PLT table and initialize a map of
115	 * relocation->slot number in lte->arch.plt_map.  */
116
117	size_t i;
118	for (i = 0; i < vect_size(&lte->plt_relocs); ++i) {
119
120		GElf_Addr offset = x86_plt_offset(i);
121		uint32_t reloc_arg = 0;
122
123		uint8_t byte;
124		if (elf_read_next_u8(lte->plt_data, &offset, &byte) < 0
125		    || byte != 0xff
126		    || elf_read_next_u8(lte->plt_data, &offset, &byte) < 0
127		    || (byte != 0xa3 && byte != 0x25))
128			goto next;
129
130		/* Skip immediate argument in the instruction.  */
131		offset += 4;
132
133		if (elf_read_next_u8(lte->plt_data, &offset, &byte) < 0
134		    || byte != 0x68
135		    || elf_read_next_u32(lte->plt_data,
136					 &offset, &reloc_arg) < 0) {
137			reloc_arg = 0;
138			goto next;
139		}
140
141		if (lte->ehdr.e_machine == EM_386) {
142			if (reloc_arg % 8 != 0) {
143				reloc_arg = 0;
144				goto next;
145			}
146			reloc_arg /= 8;
147		}
148
149	next:
150		if (VECT_PUSHBACK(&lte->arch.plt_map, &reloc_arg) < 0) {
151			arch_elf_destroy(lte);
152			return -1;
153		}
154	}
155
156	return 0;
157}
158
159void
160arch_elf_destroy(struct ltelf *lte)
161{
162	VECT_DESTROY(&lte->arch.plt_map, uint32_t, NULL, NULL);
163}
164