Merge branch 'for-5.12/uclogic' into for-linus
[linux-2.6-microblaze.git] / tools / objtool / orc_gen.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2017 Josh Poimboeuf <jpoimboe@redhat.com>
4  */
5
6 #include <stdlib.h>
7 #include <string.h>
8
9 #include <linux/objtool.h>
10 #include <asm/orc_types.h>
11
12 #include "check.h"
13 #include "warn.h"
14
15 int create_orc(struct objtool_file *file)
16 {
17         struct instruction *insn;
18
19         for_each_insn(file, insn) {
20                 struct orc_entry *orc = &insn->orc;
21                 struct cfi_reg *cfa = &insn->cfi.cfa;
22                 struct cfi_reg *bp = &insn->cfi.regs[CFI_BP];
23
24                 if (!insn->sec->text)
25                         continue;
26
27                 orc->end = insn->cfi.end;
28
29                 if (cfa->base == CFI_UNDEFINED) {
30                         orc->sp_reg = ORC_REG_UNDEFINED;
31                         continue;
32                 }
33
34                 switch (cfa->base) {
35                 case CFI_SP:
36                         orc->sp_reg = ORC_REG_SP;
37                         break;
38                 case CFI_SP_INDIRECT:
39                         orc->sp_reg = ORC_REG_SP_INDIRECT;
40                         break;
41                 case CFI_BP:
42                         orc->sp_reg = ORC_REG_BP;
43                         break;
44                 case CFI_BP_INDIRECT:
45                         orc->sp_reg = ORC_REG_BP_INDIRECT;
46                         break;
47                 case CFI_R10:
48                         orc->sp_reg = ORC_REG_R10;
49                         break;
50                 case CFI_R13:
51                         orc->sp_reg = ORC_REG_R13;
52                         break;
53                 case CFI_DI:
54                         orc->sp_reg = ORC_REG_DI;
55                         break;
56                 case CFI_DX:
57                         orc->sp_reg = ORC_REG_DX;
58                         break;
59                 default:
60                         WARN_FUNC("unknown CFA base reg %d",
61                                   insn->sec, insn->offset, cfa->base);
62                         return -1;
63                 }
64
65                 switch(bp->base) {
66                 case CFI_UNDEFINED:
67                         orc->bp_reg = ORC_REG_UNDEFINED;
68                         break;
69                 case CFI_CFA:
70                         orc->bp_reg = ORC_REG_PREV_SP;
71                         break;
72                 case CFI_BP:
73                         orc->bp_reg = ORC_REG_BP;
74                         break;
75                 default:
76                         WARN_FUNC("unknown BP base reg %d",
77                                   insn->sec, insn->offset, bp->base);
78                         return -1;
79                 }
80
81                 orc->sp_offset = cfa->offset;
82                 orc->bp_offset = bp->offset;
83                 orc->type = insn->cfi.type;
84         }
85
86         return 0;
87 }
88
89 static int create_orc_entry(struct elf *elf, struct section *u_sec, struct section *ip_relocsec,
90                                 unsigned int idx, struct section *insn_sec,
91                                 unsigned long insn_off, struct orc_entry *o)
92 {
93         struct orc_entry *orc;
94         struct reloc *reloc;
95
96         /* populate ORC data */
97         orc = (struct orc_entry *)u_sec->data->d_buf + idx;
98         memcpy(orc, o, sizeof(*orc));
99
100         /* populate reloc for ip */
101         reloc = malloc(sizeof(*reloc));
102         if (!reloc) {
103                 perror("malloc");
104                 return -1;
105         }
106         memset(reloc, 0, sizeof(*reloc));
107
108         insn_to_reloc_sym_addend(insn_sec, insn_off, reloc);
109         if (!reloc->sym) {
110                 WARN("missing symbol for insn at offset 0x%lx",
111                      insn_off);
112                 return -1;
113         }
114
115         reloc->type = R_X86_64_PC32;
116         reloc->offset = idx * sizeof(int);
117         reloc->sec = ip_relocsec;
118
119         elf_add_reloc(elf, reloc);
120
121         return 0;
122 }
123
124 int create_orc_sections(struct objtool_file *file)
125 {
126         struct instruction *insn, *prev_insn;
127         struct section *sec, *u_sec, *ip_relocsec;
128         unsigned int idx;
129
130         struct orc_entry empty = {
131                 .sp_reg = ORC_REG_UNDEFINED,
132                 .bp_reg  = ORC_REG_UNDEFINED,
133                 .type    = UNWIND_HINT_TYPE_CALL,
134         };
135
136         sec = find_section_by_name(file->elf, ".orc_unwind");
137         if (sec) {
138                 WARN("file already has .orc_unwind section, skipping");
139                 return -1;
140         }
141
142         /* count the number of needed orcs */
143         idx = 0;
144         for_each_sec(file, sec) {
145                 if (!sec->text)
146                         continue;
147
148                 prev_insn = NULL;
149                 sec_for_each_insn(file, sec, insn) {
150                         if (!prev_insn ||
151                             memcmp(&insn->orc, &prev_insn->orc,
152                                    sizeof(struct orc_entry))) {
153                                 idx++;
154                         }
155                         prev_insn = insn;
156                 }
157
158                 /* section terminator */
159                 if (prev_insn)
160                         idx++;
161         }
162         if (!idx)
163                 return -1;
164
165
166         /* create .orc_unwind_ip and .rela.orc_unwind_ip sections */
167         sec = elf_create_section(file->elf, ".orc_unwind_ip", 0, sizeof(int), idx);
168         if (!sec)
169                 return -1;
170
171         ip_relocsec = elf_create_reloc_section(file->elf, sec, SHT_RELA);
172         if (!ip_relocsec)
173                 return -1;
174
175         /* create .orc_unwind section */
176         u_sec = elf_create_section(file->elf, ".orc_unwind", 0,
177                                    sizeof(struct orc_entry), idx);
178
179         /* populate sections */
180         idx = 0;
181         for_each_sec(file, sec) {
182                 if (!sec->text)
183                         continue;
184
185                 prev_insn = NULL;
186                 sec_for_each_insn(file, sec, insn) {
187                         if (!prev_insn || memcmp(&insn->orc, &prev_insn->orc,
188                                                  sizeof(struct orc_entry))) {
189
190                                 if (create_orc_entry(file->elf, u_sec, ip_relocsec, idx,
191                                                      insn->sec, insn->offset,
192                                                      &insn->orc))
193                                         return -1;
194
195                                 idx++;
196                         }
197                         prev_insn = insn;
198                 }
199
200                 /* section terminator */
201                 if (prev_insn) {
202                         if (create_orc_entry(file->elf, u_sec, ip_relocsec, idx,
203                                              prev_insn->sec,
204                                              prev_insn->offset + prev_insn->len,
205                                              &empty))
206                                 return -1;
207
208                         idx++;
209                 }
210         }
211
212         if (elf_rebuild_reloc_section(file->elf, ip_relocsec))
213                 return -1;
214
215         return 0;
216 }