Linux Perf
genelf_debug.c
Go to the documentation of this file.
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
86 {
87  be->data = NULL;
88  be->cur_pos = 0;
89  be->max_sz = 0;
90 }
91 
92 static inline size_t
94 {
95  return be->cur_pos;
96 }
97 
98 static inline void *
100 {
101  return be->data;
102 }
103 
105  // Not counting this field
107  // version number (2 currently)
109  // relative offset from next field to
110  // program statement
114  // line_base - see DWARF 2 specs
116  // line_range - see DWARF 2 specs
118  // number of opcode + 1
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  */
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 */
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 
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 */
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 
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 
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) -
422 
423  emit_lineno_info(be, ent, nr_entry, code_addr);
424 
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
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
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  }
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 }
void * data
Definition: genelf_debug.c:44
static void emit_uword(struct buffer_ext *be, uword data)
Definition: genelf_debug.c:181
uint64_t addr
Definition: jitdump.h:92
static size_t buffer_ext_size(struct buffer_ext *be)
Definition: genelf_debug.c:93
#define BUFFER_EXT_DFL_SIZE
Definition: genelf_debug.c:32
#define DW_LNS_num_opcode
Definition: genelf_debug.c:144
static struct compilation_unit_header default_comp_unit_header
Definition: genelf_debug.c:174
size_t size
Definition: evsel.c:60
static void add_debug_abbrev(struct buffer_ext *be)
Definition: genelf_debug.c:433
static void add_compilation_unit(struct buffer_ext *be, size_t offset_debug_line)
Definition: genelf_debug.c:446
static ubyte get_special_opcode(struct debug_entry *ent, unsigned int last_line, unsigned long last_vma)
Definition: genelf_debug.c:295
int lineno
Definition: jitdump.h:93
const char * filename
Definition: hists_common.c:26
static void emit_signed_LEB128(struct buffer_ext *be, long data)
Definition: genelf_debug.c:203
static void emit_lne_set_address(struct buffer_ext *be, void *address)
Definition: genelf_debug.c:289
static void * buffer_ext_addr(struct buffer_ext *be)
Definition: genelf_debug.c:99
uint16_t uhalf
Definition: genelf_debug.c:35
static void emit_unsigned_LEB128(struct buffer_ext *be, unsigned long data)
Definition: genelf_debug.c:191
static void emit_opcode(struct buffer_ext *be, ubyte opcode)
Definition: genelf_debug.c:233
size_t max_sz
Definition: genelf_debug.c:43
struct debug_line_header __packed
Definition: jitdump.h:91
static ubyte standard_opcode_length[]
Definition: genelf_debug.c:158
#define elf_getshdr
Definition: genelf.h:44
#define Elf_Shdr
Definition: genelf.h:46
int8_t sbyte
Definition: genelf_debug.c:39
if(!yyg->yy_init)
static void emit_extended_opcode(struct buffer_ext *be, ubyte opcode, void *data, size_t data_len)
Definition: genelf_debug.c:222
static void emit_lne_define_filename(struct buffer_ext *be, const char *filename)
Definition: genelf_debug.c:272
static void emit_advance_pc(struct buffer_ext *be, unsigned long delta_pc)
Definition: genelf_debug.c:252
static int buffer_ext_add(struct buffer_ext *be, void *addr, size_t sz)
Definition: genelf_debug.c:57
int jit_add_debug_info(Elf *e, uint64_t code_addr, void *debug, int nr_debug_entries)
Definition: genelf_debug.c:486
size_t cur_pos
Definition: genelf_debug.c:42
static struct debug_line_header const default_debug_line_header
Definition: genelf_debug.c:147
x86 movsq based memcpy() in arch/x86/lib/memcpy_64.S") MEMCPY_FN(memcpy_erms
static void add_debug_line(struct buffer_ext *be, struct debug_entry *ent, size_t nr_entry, unsigned long code_addr)
Definition: genelf_debug.c:399
uint8_t ubyte
Definition: genelf_debug.c:38
static void buffer_ext_init(struct buffer_ext *be)
Definition: genelf_debug.c:85
int32_t sword
Definition: genelf_debug.c:36
static void emit_advance_lineno(struct buffer_ext *be, long delta_lineno)
Definition: genelf_debug.c:257
static void buffer_ext_dump(struct buffer_ext *be, const char *msg)
Definition: genelf_debug.c:48
static int jit_process_debug_info(uint64_t code_addr, void *debug, int nr_debug_entries, struct buffer_ext *dl, struct buffer_ext *da, struct buffer_ext *di)
Definition: genelf_debug.c:464
uint32_t uword
Definition: genelf_debug.c:34
static void emit_opcode_signed(struct buffer_ext *be, ubyte opcode, long data)
Definition: genelf_debug.c:238
int16_t shalf
Definition: genelf_debug.c:37
static void emit_lne_end_of_sequence(struct buffer_ext *be)
Definition: genelf_debug.c:262
static void emit_opcode_unsigned(struct buffer_ext *be, ubyte opcode, unsigned long data)
Definition: genelf_debug.c:245
static void emit_lineno_info(struct buffer_ext *be, struct debug_entry *ent, size_t nr_entry, unsigned long code_addr)
Definition: genelf_debug.c:329
static void emit_set_file(struct buffer_ext *be, unsigned long idx)
Definition: genelf_debug.c:267
static void emit_string(struct buffer_ext *be, const char *s)
Definition: genelf_debug.c:186
static struct debug_entry * debug_entry_next(struct debug_entry *ent)
Definition: jitdump.h:125
ubyte minimum_instruction_length
Definition: genelf_debug.c:112