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