GNU Linux-libre 4.19.211-gnu1
[releases.git] / tools / perf / util / genelf_debug.c
1 /*
2  * genelf_debug.c
3  * Copyright (C) 2015, Google, Inc
4  *
5  * Contributed by:
6  *      Stephane Eranian <eranian@google.com>
7  *
8  * Released under the GPL v2.
9  *
10  * based on GPLv2 source code from Oprofile
11  * @remark Copyright 2007 OProfile authors
12  * @author Philippe Elie
13  */
14 #include <linux/compiler.h>
15 #include <sys/types.h>
16 #include <stdio.h>
17 #include <getopt.h>
18 #include <stddef.h>
19 #include <libelf.h>
20 #include <string.h>
21 #include <stdlib.h>
22 #include <inttypes.h>
23 #include <limits.h>
24 #include <fcntl.h>
25 #include <err.h>
26 #include <dwarf.h>
27
28 #include "perf.h"
29 #include "genelf.h"
30 #include "../util/jitdump.h"
31
32 #define BUFFER_EXT_DFL_SIZE     (4 * 1024)
33
34 typedef uint32_t uword;
35 typedef uint16_t uhalf;
36 typedef int32_t  sword;
37 typedef int16_t  shalf;
38 typedef uint8_t  ubyte;
39 typedef int8_t   sbyte;
40
41 struct buffer_ext {
42         size_t cur_pos;
43         size_t max_sz;
44         void *data;
45 };
46
47 static void
48 buffer_ext_dump(struct buffer_ext *be, const char *msg)
49 {
50         size_t i;
51         warnx("DUMP for %s", msg);
52         for (i = 0 ; i < be->cur_pos; i++)
53                 warnx("%4zu 0x%02x", i, (((char *)be->data)[i]) & 0xff);
54 }
55
56 static inline int
57 buffer_ext_add(struct buffer_ext *be, void *addr, size_t sz)
58 {
59         void *tmp;
60         size_t be_sz = be->max_sz;
61
62 retry:
63         if ((be->cur_pos + sz) < be_sz) {
64                 memcpy(be->data + be->cur_pos, addr, sz);
65                 be->cur_pos += sz;
66                 return 0;
67         }
68
69         if (!be_sz)
70                 be_sz = BUFFER_EXT_DFL_SIZE;
71         else
72                 be_sz <<= 1;
73
74         tmp = realloc(be->data, be_sz);
75         if (!tmp)
76                 return -1;
77
78         be->data   = tmp;
79         be->max_sz = be_sz;
80
81         goto retry;
82 }
83
84 static void
85 buffer_ext_init(struct buffer_ext *be)
86 {
87         be->data = NULL;
88         be->cur_pos = 0;
89         be->max_sz = 0;
90 }
91
92 static inline size_t
93 buffer_ext_size(struct buffer_ext *be)
94 {
95         return be->cur_pos;
96 }
97
98 static inline void *
99 buffer_ext_addr(struct buffer_ext *be)
100 {
101         return be->data;
102 }
103
104 struct debug_line_header {
105         // Not counting this field
106         uword total_length;
107         // version number (2 currently)
108         uhalf version;
109         // relative offset from next field to
110         // program statement
111         uword prolog_length;
112         ubyte minimum_instruction_length;
113         ubyte default_is_stmt;
114         // line_base - see DWARF 2 specs
115         sbyte line_base;
116         // line_range - see DWARF 2 specs
117         ubyte line_range;
118         // number of opcode + 1
119         ubyte opcode_base;
120         /* follow the array of opcode args nr: ubytes [nr_opcode_base] */
121         /* follow the search directories index, zero terminated string
122          * terminated by an empty string.
123          */
124         /* follow an array of { filename, LEB128, LEB128, LEB128 }, first is
125          * the directory index entry, 0 means current directory, then mtime
126          * and filesize, last entry is followed by en empty string.
127          */
128         /* follow the first program statement */
129 } __packed;
130
131 /* DWARF 2 spec talk only about one possible compilation unit header while
132  * binutils can handle two flavours of dwarf 2, 32 and 64 bits, this is not
133  * related to the used arch, an ELF 32 can hold more than 4 Go of debug
134  * information. For now we handle only DWARF 2 32 bits comp unit. It'll only
135  * become a problem if we generate more than 4GB of debug information.
136  */
137 struct compilation_unit_header {
138         uword total_length;
139         uhalf version;
140         uword debug_abbrev_offset;
141         ubyte pointer_size;
142 } __packed;
143
144 #define DW_LNS_num_opcode (DW_LNS_set_isa + 1)
145
146 /* field filled at run time are marked with -1 */
147 static struct debug_line_header const default_debug_line_header = {
148         .total_length = -1,
149         .version = 2,
150         .prolog_length = -1,
151         .minimum_instruction_length = 1,        /* could be better when min instruction size != 1 */
152         .default_is_stmt = 1,   /* we don't take care about basic block */
153         .line_base = -5,        /* sensible value for line base ... */
154         .line_range = -14,     /* ... and line range are guessed statically */
155         .opcode_base = DW_LNS_num_opcode
156 };
157
158 static ubyte standard_opcode_length[] =
159 {
160         0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1
161 };
162 #if 0
163 {
164         [DW_LNS_advance_pc]   = 1,
165         [DW_LNS_advance_line] = 1,
166         [DW_LNS_set_file] =  1,
167         [DW_LNS_set_column] = 1,
168         [DW_LNS_fixed_advance_pc] = 1,
169         [DW_LNS_set_isa] = 1,
170 };
171 #endif
172
173 /* field filled at run time are marked with -1 */
174 static struct compilation_unit_header default_comp_unit_header = {
175         .total_length = -1,
176         .version = 2,
177         .debug_abbrev_offset = 0,     /* we reuse the same abbrev entries for all comp unit */
178         .pointer_size = sizeof(void *)
179 };
180
181 static void emit_uword(struct buffer_ext *be, uword data)
182 {
183         buffer_ext_add(be, &data, sizeof(uword));
184 }
185
186 static void emit_string(struct buffer_ext *be, const char *s)
187 {
188         buffer_ext_add(be, (void *)s, strlen(s) + 1);
189 }
190
191 static void emit_unsigned_LEB128(struct buffer_ext *be,
192                                  unsigned long data)
193 {
194         do {
195                 ubyte cur = data & 0x7F;
196                 data >>= 7;
197                 if (data)
198                         cur |= 0x80;
199                 buffer_ext_add(be, &cur, 1);
200         } while (data);
201 }
202
203 static void emit_signed_LEB128(struct buffer_ext *be, long data)
204 {
205         int more = 1;
206         int negative = data < 0;
207         int size = sizeof(long) * CHAR_BIT;
208         while (more) {
209                 ubyte cur = data & 0x7F;
210                 data >>= 7;
211                 if (negative)
212                         data |= - (1 << (size - 7));
213                 if ((data == 0 && !(cur & 0x40)) ||
214                     (data == -1l && (cur & 0x40)))
215                         more = 0;
216                 else
217                         cur |= 0x80;
218                 buffer_ext_add(be, &cur, 1);
219         }
220 }
221
222 static void emit_extended_opcode(struct buffer_ext *be, ubyte opcode,
223                                  void *data, size_t data_len)
224 {
225         buffer_ext_add(be, (char *)"", 1);
226
227         emit_unsigned_LEB128(be, data_len + 1);
228
229         buffer_ext_add(be, &opcode, 1);
230         buffer_ext_add(be, data, data_len);
231 }
232
233 static void emit_opcode(struct buffer_ext *be, ubyte opcode)
234 {
235         buffer_ext_add(be, &opcode, 1);
236 }
237
238 static void emit_opcode_signed(struct buffer_ext  *be,
239                                ubyte opcode, long data)
240 {
241         buffer_ext_add(be, &opcode, 1);
242         emit_signed_LEB128(be, data);
243 }
244
245 static void emit_opcode_unsigned(struct buffer_ext *be, ubyte opcode,
246                                  unsigned long data)
247 {
248         buffer_ext_add(be, &opcode, 1);
249         emit_unsigned_LEB128(be, data);
250 }
251
252 static void emit_advance_pc(struct buffer_ext *be, unsigned long delta_pc)
253 {
254         emit_opcode_unsigned(be, DW_LNS_advance_pc, delta_pc);
255 }
256
257 static void emit_advance_lineno(struct buffer_ext  *be, long delta_lineno)
258 {
259         emit_opcode_signed(be, DW_LNS_advance_line, delta_lineno);
260 }
261
262 static void emit_lne_end_of_sequence(struct buffer_ext *be)
263 {
264         emit_extended_opcode(be, DW_LNE_end_sequence, NULL, 0);
265 }
266
267 static void emit_set_file(struct buffer_ext *be, unsigned long idx)
268 {
269         emit_opcode_unsigned(be, DW_LNS_set_file, idx);
270 }
271
272 static void emit_lne_define_filename(struct buffer_ext *be,
273                                      const char *filename)
274 {
275         buffer_ext_add(be, (void *)"", 1);
276
277         /* LNE field, strlen(filename) + zero termination, 3 bytes for: the dir entry, timestamp, filesize */
278         emit_unsigned_LEB128(be, strlen(filename) + 5);
279         emit_opcode(be, DW_LNE_define_file);
280         emit_string(be, filename);
281         /* directory index 0=do not know */
282         emit_unsigned_LEB128(be, 0);
283         /* last modification date on file 0=do not know */
284         emit_unsigned_LEB128(be, 0);
285         /* filesize 0=do not know */
286         emit_unsigned_LEB128(be, 0);
287 }
288
289 static void emit_lne_set_address(struct buffer_ext *be,
290                                  void *address)
291 {
292         emit_extended_opcode(be, DW_LNE_set_address, &address, sizeof(unsigned long));
293 }
294
295 static ubyte get_special_opcode(struct debug_entry *ent,
296                                 unsigned int last_line,
297                                 unsigned long last_vma)
298 {
299         unsigned int temp;
300         unsigned long delta_addr;
301
302         /*
303          * delta from line_base
304          */
305         temp = (ent->lineno - last_line) - default_debug_line_header.line_base;
306
307         if (temp >= default_debug_line_header.line_range)
308                 return 0;
309
310         /*
311          * delta of addresses
312          */
313         delta_addr = (ent->addr - last_vma) / default_debug_line_header.minimum_instruction_length;
314
315         /* This is not sufficient to ensure opcode will be in [0-256] but
316          * sufficient to ensure when summing with the delta lineno we will
317          * not overflow the unsigned long opcode */
318
319         if (delta_addr <= 256 / default_debug_line_header.line_range) {
320                 unsigned long opcode = temp +
321                         (delta_addr * default_debug_line_header.line_range) +
322                         default_debug_line_header.opcode_base;
323
324                 return opcode <= 255 ? opcode : 0;
325         }
326         return 0;
327 }
328
329 static void emit_lineno_info(struct buffer_ext *be,
330                              struct debug_entry *ent, size_t nr_entry,
331                              unsigned long code_addr)
332 {
333         size_t i;
334
335         /*
336          * Machine state at start of a statement program
337          * address = 0
338          * file    = 1
339          * line    = 1
340          * column  = 0
341          * is_stmt = default_is_stmt as given in the debug_line_header
342          * basic block = 0
343          * end sequence = 0
344          */
345
346         /* start state of the state machine we take care of */
347         unsigned long last_vma = code_addr;
348         char const  *cur_filename = NULL;
349         unsigned long cur_file_idx = 0;
350         int last_line = 1;
351
352         emit_lne_set_address(be, (void *)code_addr);
353
354         for (i = 0; i < nr_entry; i++, ent = debug_entry_next(ent)) {
355                 int need_copy = 0;
356                 ubyte special_opcode;
357
358                 /*
359                  * check if filename changed, if so add it
360                  */
361                 if (!cur_filename || strcmp(cur_filename, ent->name)) {
362                         emit_lne_define_filename(be, ent->name);
363                         cur_filename = ent->name;
364                         emit_set_file(be, ++cur_file_idx);
365                         need_copy = 1;
366                 }
367
368                 special_opcode = get_special_opcode(ent, last_line, last_vma);
369                 if (special_opcode != 0) {
370                         last_line = ent->lineno;
371                         last_vma  = ent->addr;
372                         emit_opcode(be, special_opcode);
373                 } else {
374                         /*
375                          * lines differ, emit line delta
376                          */
377                         if (last_line != ent->lineno) {
378                                 emit_advance_lineno(be, ent->lineno - last_line);
379                                 last_line = ent->lineno;
380                                 need_copy = 1;
381                         }
382                         /*
383                          * addresses differ, emit address delta
384                          */
385                         if (last_vma != ent->addr) {
386                                 emit_advance_pc(be, ent->addr - last_vma);
387                                 last_vma = ent->addr;
388                                 need_copy = 1;
389                         }
390                         /*
391                          * add new row to matrix
392                          */
393                         if (need_copy)
394                                 emit_opcode(be, DW_LNS_copy);
395                 }
396         }
397 }
398
399 static void add_debug_line(struct buffer_ext *be,
400         struct debug_entry *ent, size_t nr_entry,
401         unsigned long code_addr)
402 {
403         struct debug_line_header * dbg_header;
404         size_t old_size;
405
406         old_size = buffer_ext_size(be);
407
408         buffer_ext_add(be, (void *)&default_debug_line_header,
409                  sizeof(default_debug_line_header));
410
411         buffer_ext_add(be, &standard_opcode_length,  sizeof(standard_opcode_length));
412
413         // empty directory entry
414         buffer_ext_add(be, (void *)"", 1);
415
416         // empty filename directory
417         buffer_ext_add(be, (void *)"", 1);
418
419         dbg_header = buffer_ext_addr(be) + old_size;
420         dbg_header->prolog_length = (buffer_ext_size(be) - old_size) -
421                 offsetof(struct debug_line_header, minimum_instruction_length);
422
423         emit_lineno_info(be, ent, nr_entry, code_addr);
424
425         emit_lne_end_of_sequence(be);
426
427         dbg_header = buffer_ext_addr(be) + old_size;
428         dbg_header->total_length = (buffer_ext_size(be) - old_size) -
429                 offsetof(struct debug_line_header, version);
430 }
431
432 static void
433 add_debug_abbrev(struct buffer_ext *be)
434 {
435         emit_unsigned_LEB128(be, 1);
436         emit_unsigned_LEB128(be, DW_TAG_compile_unit);
437         emit_unsigned_LEB128(be, DW_CHILDREN_yes);
438         emit_unsigned_LEB128(be, DW_AT_stmt_list);
439         emit_unsigned_LEB128(be, DW_FORM_data4);
440         emit_unsigned_LEB128(be, 0);
441         emit_unsigned_LEB128(be, 0);
442         emit_unsigned_LEB128(be, 0);
443 }
444
445 static void
446 add_compilation_unit(struct buffer_ext *be,
447                      size_t offset_debug_line)
448 {
449         struct compilation_unit_header *comp_unit_header;
450         size_t old_size = buffer_ext_size(be);
451
452         buffer_ext_add(be, &default_comp_unit_header,
453                        sizeof(default_comp_unit_header));
454
455         emit_unsigned_LEB128(be, 1);
456         emit_uword(be, offset_debug_line);
457
458         comp_unit_header = buffer_ext_addr(be) + old_size;
459         comp_unit_header->total_length = (buffer_ext_size(be) - old_size) -
460                 offsetof(struct compilation_unit_header, version);
461 }
462
463 static int
464 jit_process_debug_info(uint64_t code_addr,
465                        void *debug, int nr_debug_entries,
466                        struct buffer_ext *dl,
467                        struct buffer_ext *da,
468                        struct buffer_ext *di)
469 {
470         struct debug_entry *ent = debug;
471         int i;
472
473         for (i = 0; i < nr_debug_entries; i++) {
474                 ent->addr = ent->addr - code_addr;
475                 ent = debug_entry_next(ent);
476         }
477         add_compilation_unit(di, buffer_ext_size(dl));
478         add_debug_line(dl, debug, nr_debug_entries, 0);
479         add_debug_abbrev(da);
480         if (0) buffer_ext_dump(da, "abbrev");
481
482         return 0;
483 }
484
485 int
486 jit_add_debug_info(Elf *e, uint64_t code_addr, void *debug, int nr_debug_entries)
487 {
488         Elf_Data *d;
489         Elf_Scn *scn;
490         Elf_Shdr *shdr;
491         struct buffer_ext dl, di, da;
492         int ret;
493
494         buffer_ext_init(&dl);
495         buffer_ext_init(&di);
496         buffer_ext_init(&da);
497
498         ret = jit_process_debug_info(code_addr, debug, nr_debug_entries, &dl, &da, &di);
499         if (ret)
500                 return -1;
501         /*
502          * setup .debug_line section
503          */
504         scn = elf_newscn(e);
505         if (!scn) {
506                 warnx("cannot create section");
507                 return -1;
508         }
509
510         d = elf_newdata(scn);
511         if (!d) {
512                 warnx("cannot get new data");
513                 return -1;
514         }
515
516         d->d_align = 1;
517         d->d_off = 0LL;
518         d->d_buf = buffer_ext_addr(&dl);
519         d->d_type = ELF_T_BYTE;
520         d->d_size = buffer_ext_size(&dl);
521         d->d_version = EV_CURRENT;
522
523         shdr = elf_getshdr(scn);
524         if (!shdr) {
525                 warnx("cannot get section header");
526                 return -1;
527         }
528
529         shdr->sh_name = 52; /* .debug_line */
530         shdr->sh_type = SHT_PROGBITS;
531         shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
532         shdr->sh_flags = 0;
533         shdr->sh_entsize = 0;
534
535         /*
536          * setup .debug_info section
537          */
538         scn = elf_newscn(e);
539         if (!scn) {
540                 warnx("cannot create section");
541                 return -1;
542         }
543
544         d = elf_newdata(scn);
545         if (!d) {
546                 warnx("cannot get new data");
547                 return -1;
548         }
549
550         d->d_align = 1;
551         d->d_off = 0LL;
552         d->d_buf = buffer_ext_addr(&di);
553         d->d_type = ELF_T_BYTE;
554         d->d_size = buffer_ext_size(&di);
555         d->d_version = EV_CURRENT;
556
557         shdr = elf_getshdr(scn);
558         if (!shdr) {
559                 warnx("cannot get section header");
560                 return -1;
561         }
562
563         shdr->sh_name = 64; /* .debug_info */
564         shdr->sh_type = SHT_PROGBITS;
565         shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
566         shdr->sh_flags = 0;
567         shdr->sh_entsize = 0;
568
569         /*
570          * setup .debug_abbrev section
571          */
572         scn = elf_newscn(e);
573         if (!scn) {
574                 warnx("cannot create section");
575                 return -1;
576         }
577
578         d = elf_newdata(scn);
579         if (!d) {
580                 warnx("cannot get new data");
581                 return -1;
582         }
583
584         d->d_align = 1;
585         d->d_off = 0LL;
586         d->d_buf = buffer_ext_addr(&da);
587         d->d_type = ELF_T_BYTE;
588         d->d_size = buffer_ext_size(&da);
589         d->d_version = EV_CURRENT;
590
591         shdr = elf_getshdr(scn);
592         if (!shdr) {
593                 warnx("cannot get section header");
594                 return -1;
595         }
596
597         shdr->sh_name = 76; /* .debug_info */
598         shdr->sh_type = SHT_PROGBITS;
599         shdr->sh_addr = 0; /* must be zero or == sh_offset -> dynamic object */
600         shdr->sh_flags = 0;
601         shdr->sh_entsize = 0;
602
603         /*
604          * now we update the ELF image with all the sections
605          */
606         if (elf_update(e, ELF_C_WRITE) < 0) {
607                 warnx("elf_update debug failed");
608                 return -1;
609         }
610         return 0;
611 }