relocate-rela.c
3.42 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
/*
* Copyright 2013 Freescale Semiconductor, Inc.
*
* SPDX-License-Identifier: GPL-2.0+ BSD-2-Clause
*
* 64-bit and little-endian target only until we need to support a different
* arch that needs this.
*/
#include <elf.h>
#include <errno.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "compiler.h"
#ifndef R_AARCH64_RELATIVE
#define R_AARCH64_RELATIVE 1027
#endif
static const bool debug_en;
static void debug(const char *fmt, ...)
{
va_list args;
if (debug_en) {
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
}
}
static bool supported_rela(Elf64_Rela *rela)
{
uint64_t mask = 0xffffffffULL; /* would be different on 32-bit */
uint32_t type = rela->r_info & mask;
switch (type) {
#ifdef R_AARCH64_RELATIVE
case R_AARCH64_RELATIVE:
return true;
#endif
default:
fprintf(stderr, "warning: unsupported relocation type %"
PRIu32 " at %" PRIx64 "\n",
type, rela->r_offset);
return false;
}
}
static bool read_num(const char *str, uint64_t *num)
{
char *endptr;
*num = strtoull(str, &endptr, 16);
return str[0] && !endptr[0];
}
int main(int argc, char **argv)
{
FILE *f;
int i, num;
uint64_t rela_start, rela_end, text_base;
if (argc != 5) {
fprintf(stderr, "Statically apply ELF rela relocations\n");
fprintf(stderr, "Usage: %s <bin file> <text base> " \
"<rela start> <rela end>\n", argv[0]);
fprintf(stderr, "All numbers in hex.\n");
return 1;
}
f = fopen(argv[1], "r+b");
if (!f) {
fprintf(stderr, "%s: Cannot open %s: %s\n",
argv[0], argv[1], strerror(errno));
return 2;
}
if (!read_num(argv[2], &text_base) ||
!read_num(argv[3], &rela_start) ||
!read_num(argv[4], &rela_end)) {
fprintf(stderr, "%s: bad number\n", argv[0]);
return 3;
}
if (rela_start > rela_end || rela_start < text_base ||
(rela_end - rela_start) % sizeof(Elf64_Rela)) {
fprintf(stderr, "%s: bad rela bounds\n", argv[0]);
return 3;
}
rela_start -= text_base;
rela_end -= text_base;
num = (rela_end - rela_start) / sizeof(Elf64_Rela);
for (i = 0; i < num; i++) {
Elf64_Rela rela, swrela;
uint64_t pos = rela_start + sizeof(Elf64_Rela) * i;
uint64_t addr;
if (fseek(f, pos, SEEK_SET) < 0) {
fprintf(stderr, "%s: %s: seek to %" PRIx64
" failed: %s\n",
argv[0], argv[1], pos, strerror(errno));
}
if (fread(&rela, sizeof(rela), 1, f) != 1) {
fprintf(stderr, "%s: %s: read rela failed at %"
PRIx64 "\n",
argv[0], argv[1], pos);
return 4;
}
swrela.r_offset = cpu_to_le64(rela.r_offset);
swrela.r_info = cpu_to_le64(rela.r_info);
swrela.r_addend = cpu_to_le64(rela.r_addend);
if (!supported_rela(&swrela))
continue;
debug("Rela %" PRIx64 " %" PRIu64 " %" PRIx64 "\n",
swrela.r_offset, swrela.r_info, swrela.r_addend);
if (swrela.r_offset < text_base) {
fprintf(stderr, "%s: %s: bad rela at %" PRIx64 "\n",
argv[0], argv[1], pos);
return 4;
}
addr = swrela.r_offset - text_base;
if (fseek(f, addr, SEEK_SET) < 0) {
fprintf(stderr, "%s: %s: seek to %"
PRIx64 " failed: %s\n",
argv[0], argv[1], addr, strerror(errno));
}
if (fwrite(&rela.r_addend, sizeof(rela.r_addend), 1, f) != 1) {
fprintf(stderr, "%s: %s: write failed at %" PRIx64 "\n",
argv[0], argv[1], addr);
return 4;
}
}
if (fclose(f) < 0) {
fprintf(stderr, "%s: %s: close failed: %s\n",
argv[0], argv[1], strerror(errno));
return 4;
}
return 0;
}