1/*
2 * DWARF2 debugging format
3 *
4 *  Copyright (C) 2006-2007  Peter Johnson
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
19 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 * POSSIBILITY OF SUCH DAMAGE.
26 */
27#include <util.h>
28
29#include <libyasm.h>
30
31#include "dwarf2-dbgfmt.h"
32
33struct dwarf2_head {
34    yasm_bytecode *start_prevbc;
35    yasm_bytecode *end_prevbc;
36    /*@null@*/ yasm_section *debug_ptr;
37    int with_address;
38    int with_segment;
39};
40
41/* Bytecode callback function prototypes */
42static void dwarf2_head_bc_destroy(void *contents);
43static void dwarf2_head_bc_print(const void *contents, FILE *f,
44                                 int indent_level);
45static int dwarf2_head_bc_calc_len
46    (yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data);
47static int dwarf2_head_bc_tobytes
48    (yasm_bytecode *bc, unsigned char **bufp, unsigned char *bufstart, void *d,
49     yasm_output_value_func output_value,
50     /*@null@*/ yasm_output_reloc_func output_reloc);
51
52/* Bytecode callback structures */
53static const yasm_bytecode_callback dwarf2_head_bc_callback = {
54    dwarf2_head_bc_destroy,
55    dwarf2_head_bc_print,
56    yasm_bc_finalize_common,
57    NULL,
58    dwarf2_head_bc_calc_len,
59    yasm_bc_expand_common,
60    dwarf2_head_bc_tobytes,
61    0
62};
63
64/* Section data callback function prototypes */
65static void dwarf2_section_data_destroy(void *data);
66static void dwarf2_section_data_print(void *data, FILE *f, int indent_level);
67
68/* Section data callback */
69const yasm_assoc_data_callback yasm_dwarf2__section_data_cb = {
70    dwarf2_section_data_destroy,
71    dwarf2_section_data_print
72};
73
74yasm_dbgfmt_module yasm_dwarf2_LTX_dbgfmt;
75
76
77static /*@null@*/ /*@only@*/ yasm_dbgfmt *
78dwarf2_dbgfmt_create(yasm_object *object)
79{
80    yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 =
81        yasm_xmalloc(sizeof(yasm_dbgfmt_dwarf2));
82    size_t i;
83
84    dbgfmt_dwarf2->dbgfmt.module = &yasm_dwarf2_LTX_dbgfmt;
85
86    dbgfmt_dwarf2->dirs_allocated = 32;
87    dbgfmt_dwarf2->dirs_size = 0;
88    dbgfmt_dwarf2->dirs =
89        yasm_xmalloc(sizeof(char *)*dbgfmt_dwarf2->dirs_allocated);
90
91    dbgfmt_dwarf2->filenames_allocated = 32;
92    dbgfmt_dwarf2->filenames_size = 0;
93    dbgfmt_dwarf2->filenames =
94        yasm_xmalloc(sizeof(dwarf2_filename)*dbgfmt_dwarf2->filenames_allocated);
95    for (i=0; i<dbgfmt_dwarf2->filenames_allocated; i++) {
96        dbgfmt_dwarf2->filenames[i].pathname = NULL;
97        dbgfmt_dwarf2->filenames[i].filename = NULL;
98        dbgfmt_dwarf2->filenames[i].dir = 0;
99    }
100
101    dbgfmt_dwarf2->format = DWARF2_FORMAT_32BIT;    /* TODO: flexible? */
102
103    dbgfmt_dwarf2->sizeof_address = yasm_arch_get_address_size(object->arch)/8;
104    switch (dbgfmt_dwarf2->format) {
105        case DWARF2_FORMAT_32BIT:
106            dbgfmt_dwarf2->sizeof_offset = 4;
107            break;
108        case DWARF2_FORMAT_64BIT:
109            dbgfmt_dwarf2->sizeof_offset = 8;
110            break;
111    }
112    dbgfmt_dwarf2->min_insn_len = yasm_arch_min_insn_len(object->arch);
113
114    return (yasm_dbgfmt *)dbgfmt_dwarf2;
115}
116
117static void
118dwarf2_dbgfmt_destroy(/*@only@*/ yasm_dbgfmt *dbgfmt)
119{
120    yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = (yasm_dbgfmt_dwarf2 *)dbgfmt;
121    size_t i;
122    for (i=0; i<dbgfmt_dwarf2->dirs_size; i++)
123        if (dbgfmt_dwarf2->dirs[i])
124            yasm_xfree(dbgfmt_dwarf2->dirs[i]);
125    yasm_xfree(dbgfmt_dwarf2->dirs);
126    for (i=0; i<dbgfmt_dwarf2->filenames_size; i++) {
127        if (dbgfmt_dwarf2->filenames[i].pathname)
128            yasm_xfree(dbgfmt_dwarf2->filenames[i].pathname);
129        if (dbgfmt_dwarf2->filenames[i].filename)
130            yasm_xfree(dbgfmt_dwarf2->filenames[i].filename);
131    }
132    yasm_xfree(dbgfmt_dwarf2->filenames);
133    yasm_xfree(dbgfmt);
134}
135
136/* Add a bytecode to a section, updating offset on insertion;
137 * no optimization necessary.
138 */
139yasm_bytecode *
140yasm_dwarf2__append_bc(yasm_section *sect, yasm_bytecode *bc)
141{
142    yasm_bytecode *precbc = yasm_section_bcs_last(sect);
143    bc->offset = yasm_bc_next_offset(precbc);
144    yasm_section_bcs_append(sect, bc);
145    return precbc;
146}
147
148static void
149dwarf2_dbgfmt_generate(yasm_object *object, yasm_linemap *linemap,
150                       yasm_errwarns *errwarns)
151{
152    yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = (yasm_dbgfmt_dwarf2 *)object->dbgfmt;
153    size_t num_line_sections;
154    /*@null@*/ yasm_section *debug_info, *debug_line, *main_code;
155
156    /* If we don't have any .file directives, generate line information
157     * based on the asm source.
158     */
159    debug_line = yasm_dwarf2__generate_line(object, linemap, errwarns,
160                                            dbgfmt_dwarf2->filenames_size == 0,
161                                            &main_code, &num_line_sections);
162
163    /* If we don't have a .debug_info (or it's empty), generate the minimal
164     * set of .debug_info, .debug_aranges, and .debug_abbrev so that the
165     * .debug_line we're generating is actually useful.
166     */
167    debug_info = yasm_object_find_general(object, ".debug_info");
168    if (num_line_sections > 0 &&
169        (!debug_info || yasm_section_bcs_first(debug_info)
170                        == yasm_section_bcs_last(debug_info))) {
171        debug_info = yasm_dwarf2__generate_info(object, debug_line, main_code);
172        yasm_dwarf2__generate_aranges(object, debug_info);
173        /*yasm_dwarf2__generate_pubnames(object, debug_info);*/
174    }
175}
176
177yasm_symrec *
178yasm_dwarf2__bc_sym(yasm_symtab *symtab, yasm_bytecode *bc)
179{
180    /*@dependent@*/ yasm_symrec *sym;
181    if (bc->symrecs && bc->symrecs[0])
182        sym = bc->symrecs[0];
183    else
184        sym = yasm_symtab_define_label(symtab, ".bcsym", bc, 0, 0);
185    return sym;
186}
187
188dwarf2_head *
189yasm_dwarf2__add_head
190    (yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2, yasm_section *sect,
191     /*@null@*/ yasm_section *debug_ptr, int with_address, int with_segment)
192{
193    dwarf2_head *head;
194    yasm_bytecode *bc;
195
196    head = yasm_xmalloc(sizeof(dwarf2_head));
197    head->start_prevbc = yasm_section_bcs_last(sect);
198
199    bc = yasm_bc_create_common(&dwarf2_head_bc_callback, head, 0);
200    bc->len = dbgfmt_dwarf2->sizeof_offset + 2;
201    if (dbgfmt_dwarf2->format == DWARF2_FORMAT_64BIT)
202        bc->len += 4;
203
204    if (debug_ptr) {
205        head->debug_ptr = debug_ptr;
206        bc->len += dbgfmt_dwarf2->sizeof_offset;
207    } else
208        head->debug_ptr = NULL;
209
210    head->with_address = with_address;
211    head->with_segment = with_segment;
212    if (with_address)
213        bc->len++;
214    if (with_segment)
215        bc->len++;
216
217    head->end_prevbc = bc;
218    yasm_dwarf2__append_bc(sect, bc);
219    return head;
220}
221
222void
223yasm_dwarf2__set_head_end(dwarf2_head *head, yasm_bytecode *end_prevbc)
224{
225    head->end_prevbc = end_prevbc;
226}
227
228static void
229dwarf2_head_bc_destroy(void *contents)
230{
231    yasm_xfree(contents);
232}
233
234static void
235dwarf2_head_bc_print(const void *contents, FILE *f, int indent_level)
236{
237    /* TODO */
238}
239
240static int
241dwarf2_head_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
242                        void *add_span_data)
243{
244    yasm_internal_error(N_("tried to calc_len a dwarf2 head bytecode"));
245    /*@notreached@*/
246    return 0;
247}
248
249static int
250dwarf2_head_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp,
251                       unsigned char *bufstart, void *d,
252                       yasm_output_value_func output_value,
253                       yasm_output_reloc_func output_reloc)
254{
255    yasm_object *object = yasm_section_get_object(bc->section);
256    yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = (yasm_dbgfmt_dwarf2 *)object->dbgfmt;
257    dwarf2_head *head = (dwarf2_head *)bc->contents;
258    unsigned char *buf = *bufp;
259    yasm_intnum *intn, *cval;
260
261    if (dbgfmt_dwarf2->format == DWARF2_FORMAT_64BIT) {
262        YASM_WRITE_8(buf, 0xff);
263        YASM_WRITE_8(buf, 0xff);
264        YASM_WRITE_8(buf, 0xff);
265        YASM_WRITE_8(buf, 0xff);
266    }
267
268    /* Total length of aranges info (following this field) */
269    cval = yasm_intnum_create_uint(dbgfmt_dwarf2->sizeof_offset);
270    intn = yasm_calc_bc_dist(head->start_prevbc, head->end_prevbc);
271    yasm_intnum_calc(intn, YASM_EXPR_SUB, cval);
272    yasm_arch_intnum_tobytes(object->arch, intn, buf,
273                             dbgfmt_dwarf2->sizeof_offset,
274                             dbgfmt_dwarf2->sizeof_offset*8, 0, bc, 0);
275    buf += dbgfmt_dwarf2->sizeof_offset;
276    yasm_intnum_destroy(intn);
277
278    /* DWARF version */
279    yasm_intnum_set_uint(cval, 2);
280    yasm_arch_intnum_tobytes(object->arch, cval, buf, 2, 16, 0, bc, 0);
281    buf += 2;
282
283    /* Pointer to another debug section */
284    if (head->debug_ptr) {
285        yasm_value value;
286        yasm_value_init_sym(&value,
287            yasm_dwarf2__bc_sym(object->symtab,
288                                yasm_section_bcs_first(head->debug_ptr)),
289            dbgfmt_dwarf2->sizeof_offset*8);
290        output_value(&value, buf, dbgfmt_dwarf2->sizeof_offset,
291                     (unsigned long)(buf-bufstart), bc, 0, d);
292        buf += dbgfmt_dwarf2->sizeof_offset;
293    }
294
295    /* Size of the offset portion of the address */
296    if (head->with_address)
297        YASM_WRITE_8(buf, dbgfmt_dwarf2->sizeof_address);
298
299    /* Size of a segment descriptor.  0 = flat address space */
300    if (head->with_segment)
301        YASM_WRITE_8(buf, 0);
302
303    *bufp = buf;
304
305    yasm_intnum_destroy(cval);
306    return 0;
307}
308
309static void
310dwarf2_section_data_destroy(void *data)
311{
312    dwarf2_section_data *dsd = data;
313    dwarf2_loc *n1, *n2;
314
315    /* Delete locations */
316    n1 = STAILQ_FIRST(&dsd->locs);
317    while (n1) {
318        n2 = STAILQ_NEXT(n1, link);
319        yasm_xfree(n1);
320        n1 = n2;
321    }
322
323    yasm_xfree(data);
324}
325
326static void
327dwarf2_section_data_print(void *data, FILE *f, int indent_level)
328{
329    /* TODO */
330}
331
332static const yasm_directive dwarf2_directives[] = {
333    { ".loc",   "gas",  yasm_dwarf2__dir_loc,   YASM_DIR_ARG_REQUIRED },
334    { ".file",  "gas",  yasm_dwarf2__dir_file,  YASM_DIR_ARG_REQUIRED },
335    { "loc",    "nasm", yasm_dwarf2__dir_loc,   YASM_DIR_ARG_REQUIRED },
336    { "file",   "nasm", yasm_dwarf2__dir_file,  YASM_DIR_ARG_REQUIRED },
337    { NULL, NULL, NULL, 0 }
338};
339
340/* Define dbgfmt structure -- see dbgfmt.h for details */
341yasm_dbgfmt_module yasm_dwarf2_LTX_dbgfmt = {
342    "DWARF2 debugging format",
343    "dwarf2",
344    dwarf2_directives,
345    dwarf2_dbgfmt_create,
346    dwarf2_dbgfmt_destroy,
347    dwarf2_dbgfmt_generate
348};
349