2 * TCC - Tiny C Compiler
4 * Copyright (c) 2001-2004 Fabrice Bellard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 /* stab debug support */
31 { VT_INT
, 4, DW_ATE_signed
, "int:t1=r1;-2147483648;2147483647;" },
32 { VT_BYTE
, 1, DW_ATE_signed_char
, "char:t2=r2;0;127;" },
34 { VT_LONG
| VT_INT
, 4, DW_ATE_signed
, "long int:t3=r3;-2147483648;2147483647;" },
36 { VT_LLONG
| VT_LONG
, 8, DW_ATE_signed
, "long int:t3=r3;-9223372036854775808;9223372036854775807;" },
38 { VT_INT
| VT_UNSIGNED
, 4, DW_ATE_unsigned
, "unsigned int:t4=r4;0;037777777777;" },
40 { VT_LONG
| VT_INT
| VT_UNSIGNED
, 4, DW_ATE_unsigned
, "long unsigned int:t5=r5;0;037777777777;" },
42 /* use octal instead of -1 so size_t works (-gstabs+ in gcc) */
43 { VT_LLONG
| VT_LONG
| VT_UNSIGNED
, 8, DW_ATE_unsigned
, "long unsigned int:t5=r5;0;01777777777777777777777;" },
45 { VT_QLONG
, 16, DW_ATE_signed
, "__int128:t6=r6;0;-1;" },
46 { VT_QLONG
| VT_UNSIGNED
, 16, DW_ATE_unsigned
, "__int128 unsigned:t7=r7;0;-1;" },
47 { VT_LLONG
, 8, DW_ATE_signed
, "long long int:t8=r8;-9223372036854775808;9223372036854775807;" },
48 { VT_LLONG
| VT_UNSIGNED
, 8, DW_ATE_unsigned
, "long long unsigned int:t9=r9;0;01777777777777777777777;" },
49 { VT_SHORT
, 2, DW_ATE_signed
, "short int:t10=r10;-32768;32767;" },
50 { VT_SHORT
| VT_UNSIGNED
, 2, DW_ATE_unsigned
, "short unsigned int:t11=r11;0;65535;" },
51 { VT_BYTE
| VT_DEFSIGN
, 1, DW_ATE_signed_char
, "signed char:t12=r12;-128;127;" },
52 { VT_BYTE
| VT_DEFSIGN
| VT_UNSIGNED
, 1, DW_ATE_unsigned_char
, "unsigned char:t13=r13;0;255;" },
53 { VT_FLOAT
, 4, DW_ATE_float
, "float:t14=r1;4;0;" },
54 { VT_DOUBLE
, 8, DW_ATE_float
, "double:t15=r1;8;0;" },
55 #ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
56 { VT_DOUBLE
| VT_LONG
, 8, DW_ATE_float
, "long double:t16=r1;8;0;" },
58 { VT_LDOUBLE
, 16, DW_ATE_float
, "long double:t16=r1;16;0;" },
60 { -1, -1, -1, "_Float32:t17=r1;4;0;" },
61 { -1, -1, -1, "_Float64:t18=r1;8;0;" },
62 { -1, -1, -1, "_Float128:t19=r1;16;0;" },
63 { -1, -1, -1, "_Float32x:t20=r1;8;0;" },
64 { -1, -1, -1, "_Float64x:t21=r1;16;0;" },
65 { -1, -1, -1, "_Decimal32:t22=r1;4;0;" },
66 { -1, -1, -1, "_Decimal64:t23=r1;8;0;" },
67 { -1, -1, -1, "_Decimal128:t24=r1;16;0;" },
68 /* if default char is unsigned */
69 { VT_BYTE
| VT_UNSIGNED
, 1, DW_ATE_unsigned_char
, "unsigned char:t25=r25;0;255;" },
71 { VT_BOOL
, 1, DW_ATE_boolean
, "bool:t26=r26;0;255;" },
73 { VT_VOID
, 1, DW_ATE_unsigned_char
, "void:t27=27" },
75 /* bitfields use these */
76 { VT_LONG
| VT_INT
, 8, DW_ATE_signed
, "long int:t27=r27;-9223372036854775808;9223372036854775807;" },
77 { VT_LONG
| VT_INT
| VT_UNSIGNED
, 8, DW_ATE_unsigned
, "long unsigned int:t28=r28;0;01777777777777777777777;" },
78 { VT_VOID
, 1, DW_ATE_unsigned_char
, "void:t29=29" },
82 #define N_DEFAULT_DEBUG (sizeof (default_debug) / sizeof (default_debug[0]))
86 #define DWARF_LINE_BASE -5
87 #define DWARF_LINE_RANGE 14
88 #define DWARF_OPCODE_BASE 13
90 #if defined TCC_TARGET_ARM64
91 #define DWARF_MIN_INSTR_LEN 4
92 #elif defined TCC_TARGET_ARM
93 #define DWARF_MIN_INSTR_LEN 2
95 #define DWARF_MIN_INSTR_LEN 1
98 #define DWARF_ABBREV_COMPILE_UNIT 1
99 #define DWARF_ABBREV_BASE_TYPE 2
100 #define DWARF_ABBREV_VARIABLE_EXTERNAL 3
101 #define DWARF_ABBREV_VARIABLE_STATIC 4
102 #define DWARF_ABBREV_VARIABLE_LOCAL 5
103 #define DWARF_ABBREV_FORMAL_PARAMETER 6
104 #define DWARF_ABBREV_POINTER 7
105 #define DWARF_ABBREV_ARRAY_TYPE 8
106 #define DWARF_ABBREV_SUBRANGE_TYPE 9
107 #define DWARF_ABBREV_TYPEDEF 10
108 #define DWARF_ABBREV_ENUMERATOR_SIGNED 11
109 #define DWARF_ABBREV_ENUMERATOR_UNSIGNED 12
110 #define DWARF_ABBREV_ENUMERATION_TYPE 13
111 #define DWARF_ABBREV_MEMBER 14
112 #define DWARF_ABBREV_MEMBER_BF 15
113 #define DWARF_ABBREV_STRUCTURE_TYPE 16
114 #define DWARF_ABBREV_STRUCTURE_EMPTY_TYPE 17
115 #define DWARF_ABBREV_UNION_TYPE 18
116 #define DWARF_ABBREV_UNION_EMPTY_TYPE 19
117 #define DWARF_ABBREV_SUBPROGRAM_EXTERNAL 20
118 #define DWARF_ABBREV_SUBPROGRAM_STATIC 21
119 #define DWARF_ABBREV_LEXICAL_BLOCK 22
120 #define DWARF_ABBREV_LEXICAL_EMPTY_BLOCK 23
121 #define DWARF_ABBREV_SUBROUTINE_TYPE 24
122 #define DWARF_ABBREV_SUBROUTINE_EMPTY_TYPE 25
123 #define DWARF_ABBREV_FORMAL_PARAMETER2 26
125 /* all entries should have been generated with dwarf_uleb128 except
126 has_children. All values are currently below 128 so this currently
128 static const unsigned char dwarf_abbrev_init
[] = {
129 DWARF_ABBREV_COMPILE_UNIT
, DW_TAG_compile_unit
, 1,
130 DW_AT_producer
, DW_FORM_strp
,
131 DW_AT_language
, DW_FORM_data1
,
132 DW_AT_name
, DW_FORM_line_strp
,
133 DW_AT_comp_dir
, DW_FORM_line_strp
,
134 DW_AT_low_pc
, DW_FORM_addr
,
136 DW_AT_high_pc
, DW_FORM_data4
,
138 DW_AT_high_pc
, DW_FORM_data8
,
140 DW_AT_stmt_list
, DW_FORM_sec_offset
,
142 DWARF_ABBREV_BASE_TYPE
, DW_TAG_base_type
, 0,
143 DW_AT_byte_size
, DW_FORM_udata
,
144 DW_AT_encoding
, DW_FORM_data1
,
145 DW_AT_name
, DW_FORM_strp
,
147 DWARF_ABBREV_VARIABLE_EXTERNAL
, DW_TAG_variable
, 0,
148 DW_AT_name
, DW_FORM_strp
,
149 DW_AT_decl_file
, DW_FORM_udata
,
150 DW_AT_decl_line
, DW_FORM_udata
,
151 DW_AT_type
, DW_FORM_ref4
,
152 DW_AT_external
, DW_FORM_flag
,
153 DW_AT_location
, DW_FORM_exprloc
,
155 DWARF_ABBREV_VARIABLE_STATIC
, DW_TAG_variable
, 0,
156 DW_AT_name
, DW_FORM_strp
,
157 DW_AT_decl_file
, DW_FORM_udata
,
158 DW_AT_decl_line
, DW_FORM_udata
,
159 DW_AT_type
, DW_FORM_ref4
,
160 DW_AT_location
, DW_FORM_exprloc
,
162 DWARF_ABBREV_VARIABLE_LOCAL
, DW_TAG_variable
, 0,
163 DW_AT_name
, DW_FORM_strp
,
164 DW_AT_type
, DW_FORM_ref4
,
165 DW_AT_location
, DW_FORM_exprloc
,
167 DWARF_ABBREV_FORMAL_PARAMETER
, DW_TAG_formal_parameter
, 0,
168 DW_AT_name
, DW_FORM_strp
,
169 DW_AT_type
, DW_FORM_ref4
,
170 DW_AT_location
, DW_FORM_exprloc
,
172 DWARF_ABBREV_POINTER
, DW_TAG_pointer_type
, 0,
173 DW_AT_byte_size
, DW_FORM_data1
,
174 DW_AT_type
, DW_FORM_ref4
,
176 DWARF_ABBREV_ARRAY_TYPE
, DW_TAG_array_type
, 1,
177 DW_AT_type
, DW_FORM_ref4
,
178 DW_AT_sibling
, DW_FORM_ref4
,
180 DWARF_ABBREV_SUBRANGE_TYPE
, DW_TAG_subrange_type
, 0,
181 DW_AT_type
, DW_FORM_ref4
,
182 DW_AT_upper_bound
, DW_FORM_udata
,
184 DWARF_ABBREV_TYPEDEF
, DW_TAG_typedef
, 0,
185 DW_AT_name
, DW_FORM_strp
,
186 DW_AT_decl_file
, DW_FORM_udata
,
187 DW_AT_decl_line
, DW_FORM_udata
,
188 DW_AT_type
, DW_FORM_ref4
,
190 DWARF_ABBREV_ENUMERATOR_SIGNED
, DW_TAG_enumerator
, 0,
191 DW_AT_name
, DW_FORM_strp
,
192 DW_AT_const_value
, DW_FORM_sdata
,
194 DWARF_ABBREV_ENUMERATOR_UNSIGNED
, DW_TAG_enumerator
, 0,
195 DW_AT_name
, DW_FORM_strp
,
196 DW_AT_const_value
, DW_FORM_udata
,
198 DWARF_ABBREV_ENUMERATION_TYPE
, DW_TAG_enumeration_type
, 1,
199 DW_AT_name
, DW_FORM_strp
,
200 DW_AT_encoding
, DW_FORM_data1
,
201 DW_AT_byte_size
, DW_FORM_data1
,
202 DW_AT_type
, DW_FORM_ref4
,
203 DW_AT_decl_file
, DW_FORM_udata
,
204 DW_AT_decl_line
, DW_FORM_udata
,
205 DW_AT_sibling
, DW_FORM_ref4
,
207 DWARF_ABBREV_MEMBER
, DW_TAG_member
, 0,
208 DW_AT_name
, DW_FORM_strp
,
209 DW_AT_decl_file
, DW_FORM_udata
,
210 DW_AT_decl_line
, DW_FORM_udata
,
211 DW_AT_type
, DW_FORM_ref4
,
212 DW_AT_data_member_location
, DW_FORM_udata
,
214 DWARF_ABBREV_MEMBER_BF
, DW_TAG_member
, 0,
215 DW_AT_name
, DW_FORM_strp
,
216 DW_AT_decl_file
, DW_FORM_udata
,
217 DW_AT_decl_line
, DW_FORM_udata
,
218 DW_AT_type
, DW_FORM_ref4
,
219 DW_AT_bit_size
, DW_FORM_udata
,
220 DW_AT_data_bit_offset
, DW_FORM_udata
,
222 DWARF_ABBREV_STRUCTURE_TYPE
, DW_TAG_structure_type
, 1,
223 DW_AT_name
, DW_FORM_strp
,
224 DW_AT_byte_size
, DW_FORM_udata
,
225 DW_AT_decl_file
, DW_FORM_udata
,
226 DW_AT_decl_line
, DW_FORM_udata
,
227 DW_AT_sibling
, DW_FORM_ref4
,
229 DWARF_ABBREV_STRUCTURE_EMPTY_TYPE
, DW_TAG_structure_type
, 0,
230 DW_AT_name
, DW_FORM_strp
,
231 DW_AT_byte_size
, DW_FORM_udata
,
232 DW_AT_decl_file
, DW_FORM_udata
,
233 DW_AT_decl_line
, DW_FORM_udata
,
235 DWARF_ABBREV_UNION_TYPE
, DW_TAG_union_type
, 1,
236 DW_AT_name
, DW_FORM_strp
,
237 DW_AT_byte_size
, DW_FORM_udata
,
238 DW_AT_decl_file
, DW_FORM_udata
,
239 DW_AT_decl_line
, DW_FORM_udata
,
240 DW_AT_sibling
, DW_FORM_ref4
,
242 DWARF_ABBREV_UNION_EMPTY_TYPE
, DW_TAG_union_type
, 0,
243 DW_AT_name
, DW_FORM_strp
,
244 DW_AT_byte_size
, DW_FORM_udata
,
245 DW_AT_decl_file
, DW_FORM_udata
,
246 DW_AT_decl_line
, DW_FORM_udata
,
248 DWARF_ABBREV_SUBPROGRAM_EXTERNAL
, DW_TAG_subprogram
, 1,
249 DW_AT_external
, DW_FORM_flag
,
250 DW_AT_name
, DW_FORM_strp
,
251 DW_AT_decl_file
, DW_FORM_udata
,
252 DW_AT_decl_line
, DW_FORM_udata
,
253 DW_AT_type
, DW_FORM_ref4
,
254 DW_AT_low_pc
, DW_FORM_addr
,
256 DW_AT_high_pc
, DW_FORM_data4
,
258 DW_AT_high_pc
, DW_FORM_data8
,
260 DW_AT_sibling
, DW_FORM_ref4
,
261 DW_AT_frame_base
, DW_FORM_exprloc
,
263 DWARF_ABBREV_SUBPROGRAM_STATIC
, DW_TAG_subprogram
, 1,
264 DW_AT_name
, DW_FORM_strp
,
265 DW_AT_decl_file
, DW_FORM_udata
,
266 DW_AT_decl_line
, DW_FORM_udata
,
267 DW_AT_type
, DW_FORM_ref4
,
268 DW_AT_low_pc
, DW_FORM_addr
,
270 DW_AT_high_pc
, DW_FORM_data4
,
272 DW_AT_high_pc
, DW_FORM_data8
,
274 DW_AT_sibling
, DW_FORM_ref4
,
275 DW_AT_frame_base
, DW_FORM_exprloc
,
277 DWARF_ABBREV_LEXICAL_BLOCK
, DW_TAG_lexical_block
, 1,
278 DW_AT_low_pc
, DW_FORM_addr
,
280 DW_AT_high_pc
, DW_FORM_data4
,
282 DW_AT_high_pc
, DW_FORM_data8
,
285 DWARF_ABBREV_LEXICAL_EMPTY_BLOCK
, DW_TAG_lexical_block
, 0,
286 DW_AT_low_pc
, DW_FORM_addr
,
288 DW_AT_high_pc
, DW_FORM_data4
,
290 DW_AT_high_pc
, DW_FORM_data8
,
293 DWARF_ABBREV_SUBROUTINE_TYPE
, DW_TAG_subroutine_type
, 1,
294 DW_AT_type
, DW_FORM_ref4
,
295 DW_AT_sibling
, DW_FORM_ref4
,
297 DWARF_ABBREV_SUBROUTINE_EMPTY_TYPE
, DW_TAG_subroutine_type
, 0,
298 DW_AT_type
, DW_FORM_ref4
,
300 DWARF_ABBREV_FORMAL_PARAMETER2
, DW_TAG_formal_parameter
, 0,
301 DW_AT_type
, DW_FORM_ref4
,
306 static const unsigned char dwarf_line_opcodes
[] = {
307 0 ,1 ,1 ,1 ,1 ,0 ,0 ,0 ,1 ,0 ,0 ,1
310 /* ------------------------------------------------------------------------- */
315 int last_line_num
, new_file
;
325 struct _debug_anon_hash
{
332 int n_debug_anon_hash
;
348 struct _debug_info
*child
, *next
, *last
, *parent
;
349 } *debug_info
, *debug_info_root
;
364 struct dwarf_filename_struct
{
370 unsigned char *line_data
;
381 int base_type_used
[N_DEFAULT_DEBUG
];
386 unsigned long offset
;
387 unsigned long last_file_name
;
388 unsigned long last_func_name
;
395 #define last_line_num s1->dState->last_line_num
396 #define new_file s1->dState->new_file
397 #define section_sym s1->dState->section_sym
398 #define debug_next_type s1->dState->debug_next_type
399 #define debug_hash s1->dState->debug_hash
400 #define debug_anon_hash s1->dState->debug_anon_hash
401 #define n_debug_hash s1->dState->n_debug_hash
402 #define n_debug_anon_hash s1->dState->n_debug_anon_hash
403 #define debug_info s1->dState->debug_info
404 #define debug_info_root s1->dState->debug_info_root
405 #define dwarf_sym s1->dState->dwarf_sym
406 #define dwarf_line s1->dState->dwarf_line
407 #define dwarf_info s1->dState->dwarf_info
408 #define tcov_data s1->dState->tcov_data
410 /* ------------------------------------------------------------------------- */
411 static void put_stabs(TCCState
*s1
, const char *str
, int type
, int other
,
412 int desc
, unsigned long value
);
414 ST_FUNC
void tcc_debug_new(TCCState
*s1
)
418 s1
->dState
= tcc_mallocz(sizeof *s1
->dState
);
420 #ifdef CONFIG_TCC_BACKTRACE
421 /* include stab info with standalone backtrace support */
422 if (s1
->do_debug
&& s1
->output_type
== TCC_OUTPUT_MEMORY
)
423 s1
->do_backtrace
= 1;
424 if (s1
->do_backtrace
)
425 shf
= SHF_ALLOC
| SHF_WRITE
; // SHF_WRITE needed for musl/SELINUX
429 s1
->dwlo
= s1
->nb_sections
;
431 new_section(s1
, ".debug_info", SHT_PROGBITS
, shf
);
432 dwarf_abbrev_section
=
433 new_section(s1
, ".debug_abbrev", SHT_PROGBITS
, shf
);
435 new_section(s1
, ".debug_line", SHT_PROGBITS
, shf
);
436 dwarf_aranges_section
=
437 new_section(s1
, ".debug_aranges", SHT_PROGBITS
, shf
);
438 shf
|= SHF_MERGE
| SHF_STRINGS
;
440 new_section(s1
, ".debug_str", SHT_PROGBITS
, shf
);
441 dwarf_str_section
->sh_entsize
= 1;
442 dwarf_info_section
->sh_addralign
=
443 dwarf_abbrev_section
->sh_addralign
=
444 dwarf_line_section
->sh_addralign
=
445 dwarf_aranges_section
->sh_addralign
=
446 dwarf_str_section
->sh_addralign
= 1;
447 if (s1
->dwarf
>= 5) {
448 dwarf_line_str_section
=
449 new_section(s1
, ".debug_line_str", SHT_PROGBITS
, shf
);
450 dwarf_line_str_section
->sh_entsize
= 1;
451 dwarf_line_str_section
->sh_addralign
= 1;
453 s1
->dwhi
= s1
->nb_sections
;
457 stab_section
= new_section(s1
, ".stab", SHT_PROGBITS
, shf
);
458 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
459 stab_section
->sh_addralign
= sizeof ((Stab_Sym
*)0)->n_value
;
460 stab_section
->link
= new_section(s1
, ".stabstr", SHT_STRTAB
, shf
);
461 /* put first entry */
462 put_stabs(s1
, "", 0, 0, 0, 0);
466 /* put stab debug information */
467 static void put_stabs(TCCState
*s1
, const char *str
, int type
, int other
, int desc
,
474 && (offset
= stab_section
->data_offset
)
475 && (sym
= (Stab_Sym
*)(stab_section
->data
+ offset
) - 1)
476 && sym
->n_type
== type
477 && sym
->n_value
== value
) {
478 /* just update line_number in previous entry */
483 sym
= section_ptr_add(stab_section
, sizeof(Stab_Sym
));
485 sym
->n_strx
= put_elf_str(stab_section
->link
, str
);
490 sym
->n_other
= other
;
492 sym
->n_value
= value
;
495 static void put_stabs_r(TCCState
*s1
, const char *str
, int type
, int other
, int desc
,
496 unsigned long value
, Section
*sec
, int sym_index
)
498 put_elf_reloc(symtab_section
, stab_section
,
499 stab_section
->data_offset
+ 8,
500 sizeof ((Stab_Sym
*)0)->n_value
== PTR_SIZE
? R_DATA_PTR
: R_DATA_32
,
502 put_stabs(s1
, str
, type
, other
, desc
, value
);
505 static void put_stabn(TCCState
*s1
, int type
, int other
, int desc
, int value
)
507 put_stabs(s1
, NULL
, type
, other
, desc
, value
);
510 /* ------------------------------------------------------------------------- */
511 #define dwarf_data1(s,data) \
512 { unsigned char *p = section_ptr_add((s), 1); *p = (data); }
513 #define dwarf_data2(s,data) \
514 write16le(section_ptr_add((s), 2), (data))
515 #define dwarf_data4(s,data) \
516 write32le(section_ptr_add((s), 4), (data))
517 #define dwarf_data8(s,data) \
518 write64le(section_ptr_add((s), 8), (data))
520 static int dwarf_get_section_sym(Section
*s
)
522 TCCState
*s1
= s
->s1
;
523 return put_elf_sym(symtab_section
, 0, 0,
524 ELFW(ST_INFO
)(STB_LOCAL
, STT_SECTION
), 0,
528 static void dwarf_reloc(Section
*s
, int sym
, int rel
)
530 TCCState
*s1
= s
->s1
;
531 put_elf_reloca(symtab_section
, s
, s
->data_offset
, rel
, sym
, 0);
534 static void dwarf_string(Section
*s
, Section
*dw
, int sym
, const char *str
)
536 TCCState
*s1
= s
->s1
;
540 len
= strlen(str
) + 1;
541 offset
= dw
->data_offset
;
542 ptr
= section_ptr_add(dw
, len
);
543 memmove(ptr
, str
, len
);
544 put_elf_reloca(symtab_section
, s
, s
->data_offset
, R_DATA_32DW
, sym
,
545 PTR_SIZE
== 4 ? 0 : offset
);
546 dwarf_data4(s
, PTR_SIZE
== 4 ? offset
: 0);
549 static void dwarf_strp(Section
*s
, const char *str
)
551 TCCState
*s1
= s
->s1
;
552 dwarf_string(s
, dwarf_str_section
, dwarf_sym
.str
, str
);
555 static void dwarf_line_strp(Section
*s
, const char *str
)
557 TCCState
*s1
= s
->s1
;
558 dwarf_string(s
, dwarf_line_str_section
, dwarf_sym
.line_str
, str
);
561 static void dwarf_line_op(TCCState
*s1
, unsigned char op
)
563 if (dwarf_line
.line_size
>= dwarf_line
.line_max_size
) {
564 dwarf_line
.line_max_size
+= 1024;
565 dwarf_line
.line_data
=
566 (unsigned char *)tcc_realloc(dwarf_line
.line_data
,
567 dwarf_line
.line_max_size
);
569 dwarf_line
.line_data
[dwarf_line
.line_size
++] = op
;
572 static void dwarf_file(TCCState
*s1
)
576 int index_offset
= s1
->dwarf
< 5;
578 if (!strcmp(file
->filename
, "<command line>")) {
579 dwarf_line
.cur_file
= 1;
582 filename
= strrchr(file
->filename
, '/');
583 if (filename
== NULL
) {
584 for (i
= 1; i
< dwarf_line
.filename_size
; i
++)
585 if (dwarf_line
.filename_table
[i
].dir_entry
== 0 &&
586 strcmp(dwarf_line
.filename_table
[i
].name
,
587 file
->filename
) == 0) {
588 dwarf_line
.cur_file
= i
+ index_offset
;
592 filename
= file
->filename
;
595 char *undo
= filename
;
596 char *dir
= file
->filename
;
599 for (i
= 0; i
< dwarf_line
.dir_size
; i
++)
600 if (strcmp(dwarf_line
.dir_table
[i
], dir
) == 0) {
601 for (j
= 1; j
< dwarf_line
.filename_size
; j
++)
602 if (dwarf_line
.filename_table
[j
].dir_entry
- index_offset
604 strcmp(dwarf_line
.filename_table
[j
].name
,
607 dwarf_line
.cur_file
= j
+ index_offset
;
612 if (i
== dwarf_line
.dir_size
) {
613 dwarf_line
.dir_size
++;
614 dwarf_line
.dir_table
=
615 (char **) tcc_realloc(dwarf_line
.dir_table
,
616 dwarf_line
.dir_size
*
618 dwarf_line
.dir_table
[i
] = tcc_strdup(dir
);
622 dwarf_line
.filename_table
=
623 (struct dwarf_filename_struct
*)
624 tcc_realloc(dwarf_line
.filename_table
,
625 (dwarf_line
.filename_size
+ 1) *
626 sizeof (struct dwarf_filename_struct
));
627 dwarf_line
.filename_table
[dwarf_line
.filename_size
].dir_entry
=
629 dwarf_line
.filename_table
[dwarf_line
.filename_size
].name
=
630 tcc_strdup(filename
);
631 dwarf_line
.cur_file
= dwarf_line
.filename_size
++ + index_offset
;
636 static int dwarf_uleb128_size (unsigned long long value
)
643 } while (value
!= 0);
648 static int dwarf_sleb128_size (long long value
)
651 long long end
= value
>> 63;
652 unsigned char last
= end
& 0x40;
659 } while (value
!= end
|| (byte
& 0x40) != last
);
663 static void dwarf_uleb128 (Section
*s
, unsigned long long value
)
666 unsigned char byte
= value
& 0x7f;
669 dwarf_data1(s
, byte
| (value
? 0x80 : 0));
670 } while (value
!= 0);
673 static void dwarf_sleb128 (Section
*s
, long long value
)
676 long long end
= value
>> 63;
677 unsigned char last
= end
& 0x40;
680 unsigned char byte
= value
& 0x7f;
683 more
= value
!= end
|| (byte
& 0x40) != last
;
684 dwarf_data1(s
, byte
| (0x80 * more
));
688 static void dwarf_uleb128_op (TCCState
*s1
, unsigned long long value
)
691 unsigned char byte
= value
& 0x7f;
694 dwarf_line_op(s1
, byte
| (value
? 0x80 : 0));
695 } while (value
!= 0);
698 static void dwarf_sleb128_op (TCCState
*s1
, long long value
)
701 long long end
= value
>> 63;
702 unsigned char last
= end
& 0x40;
705 unsigned char byte
= value
& 0x7f;
708 more
= value
!= end
|| (byte
& 0x40) != last
;
709 dwarf_line_op(s1
, byte
| (0x80 * more
));
713 /* start of translation unit info */
714 ST_FUNC
void tcc_debug_start(TCCState
*s1
)
720 /* we might currently #include the <command-line> */
721 filename
= file
->prev
? file
->prev
->filename
: file
->filename
;
723 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
724 symbols can be safely used */
725 put_elf_sym(symtab_section
, 0, 0,
726 ELFW(ST_INFO
)(STB_LOCAL
, STT_FILE
), 0,
731 new_file
= last_line_num
= 0;
732 debug_next_type
= N_DEFAULT_DEBUG
;
734 debug_anon_hash
= NULL
;
736 n_debug_anon_hash
= 0;
738 getcwd(buf
, sizeof(buf
));
740 normalize_slashes(buf
);
749 start_abbrev
= dwarf_abbrev_section
->data_offset
;
750 ptr
= section_ptr_add(dwarf_abbrev_section
, sizeof(dwarf_abbrev_init
));
751 memcpy(ptr
, dwarf_abbrev_init
, sizeof(dwarf_abbrev_init
));
757 if (ptr
[1] == DW_FORM_line_strp
)
758 ptr
[1] = DW_FORM_strp
;
760 /* These are compatable for DW_TAG_compile_unit
762 if (ptr
[1] == DW_FORM_sec_offset
)
763 ptr
[1] = DW_FORM_data4
;
764 /* This code uses only size < 0x80 so these are
766 if (ptr
[1] == DW_FORM_exprloc
)
767 ptr
[1] = DW_FORM_block1
;
775 dwarf_sym
.info
= dwarf_get_section_sym(dwarf_info_section
);
776 dwarf_sym
.abbrev
= dwarf_get_section_sym(dwarf_abbrev_section
);
777 dwarf_sym
.line
= dwarf_get_section_sym(dwarf_line_section
);
778 dwarf_sym
.str
= dwarf_get_section_sym(dwarf_str_section
);
779 if (tcc_state
->dwarf
>= 5)
780 dwarf_sym
.line_str
= dwarf_get_section_sym(dwarf_line_str_section
);
782 dwarf_line_str_section
= dwarf_str_section
;
783 dwarf_sym
.line_str
= dwarf_sym
.str
;
785 section_sym
= dwarf_get_section_sym(text_section
);
788 dwarf_info
.start
= dwarf_info_section
->data_offset
;
789 dwarf_data4(dwarf_info_section
, 0); // size
790 dwarf_data2(dwarf_info_section
, s1
->dwarf
); // version
791 if (s1
->dwarf
>= 5) {
792 dwarf_data1(dwarf_info_section
, DW_UT_compile
); // unit type
793 dwarf_data1(dwarf_info_section
, PTR_SIZE
);
794 dwarf_reloc(dwarf_info_section
, dwarf_sym
.abbrev
, R_DATA_32DW
);
795 dwarf_data4(dwarf_info_section
, start_abbrev
);
798 dwarf_reloc(dwarf_info_section
, dwarf_sym
.abbrev
, R_DATA_32DW
);
799 dwarf_data4(dwarf_info_section
, start_abbrev
);
800 dwarf_data1(dwarf_info_section
, PTR_SIZE
);
803 dwarf_data1(dwarf_info_section
, DWARF_ABBREV_COMPILE_UNIT
);
804 dwarf_strp(dwarf_info_section
, "tcc " TCC_VERSION
);
805 dwarf_data1(dwarf_info_section
, s1
->cversion
== 201112 ? DW_LANG_C11
: DW_LANG_C99
);
806 dwarf_line_strp(dwarf_info_section
, filename
);
807 dwarf_line_strp(dwarf_info_section
, buf
);
808 dwarf_reloc(dwarf_info_section
, section_sym
, R_DATA_PTR
);
810 dwarf_data4(dwarf_info_section
, ind
); // low pc
811 dwarf_data4(dwarf_info_section
, 0); // high pc
813 dwarf_data8(dwarf_info_section
, ind
); // low pc
814 dwarf_data8(dwarf_info_section
, 0); // high pc
816 dwarf_reloc(dwarf_info_section
, dwarf_sym
.line
, R_DATA_32DW
);
817 dwarf_data4(dwarf_info_section
, dwarf_line_section
->data_offset
); // stmt_list
820 dwarf_line
.start
= dwarf_line_section
->data_offset
;
821 dwarf_data4(dwarf_line_section
, 0); // length
822 dwarf_data2(dwarf_line_section
, s1
->dwarf
); // version
823 if (s1
->dwarf
>= 5) {
824 dwarf_data1(dwarf_line_section
, PTR_SIZE
); // address size
825 dwarf_data1(dwarf_line_section
, 0); // segment selector
827 dwarf_data4(dwarf_line_section
, 0); // prologue Length
828 dwarf_data1(dwarf_line_section
, DWARF_MIN_INSTR_LEN
);
830 dwarf_data1(dwarf_line_section
, 1); // maximum ops per instruction
831 dwarf_data1(dwarf_line_section
, 1); // Initial value of 'is_stmt'
832 dwarf_data1(dwarf_line_section
, DWARF_LINE_BASE
);
833 dwarf_data1(dwarf_line_section
, DWARF_LINE_RANGE
);
834 dwarf_data1(dwarf_line_section
, DWARF_OPCODE_BASE
);
835 ptr
= section_ptr_add(dwarf_line_section
, sizeof(dwarf_line_opcodes
));
836 memcpy(ptr
, dwarf_line_opcodes
, sizeof(dwarf_line_opcodes
));
837 undo
= strrchr(filename
, '/');
840 dwarf_line
.dir_size
= 1 + (undo
!= NULL
);
841 dwarf_line
.dir_table
= (char **) tcc_malloc(sizeof (char *) *
842 dwarf_line
.dir_size
);
843 dwarf_line
.dir_table
[0] = tcc_strdup(buf
);
845 dwarf_line
.dir_table
[1] = tcc_strdup(filename
);
846 dwarf_line
.filename_size
= 2;
847 dwarf_line
.filename_table
=
848 (struct dwarf_filename_struct
*)
849 tcc_malloc(2*sizeof (struct dwarf_filename_struct
));
850 dwarf_line
.filename_table
[0].dir_entry
= 0;
852 dwarf_line
.filename_table
[0].name
= tcc_strdup(undo
+ 1);
853 dwarf_line
.filename_table
[1].dir_entry
= 1;
854 dwarf_line
.filename_table
[1].name
= tcc_strdup(undo
+ 1);
858 dwarf_line
.filename_table
[0].name
= tcc_strdup(filename
);
859 dwarf_line
.filename_table
[1].dir_entry
= 0;
860 dwarf_line
.filename_table
[1].name
= tcc_strdup(filename
);
862 dwarf_line
.line_size
= dwarf_line
.line_max_size
= 0;
863 dwarf_line
.line_data
= NULL
;
864 dwarf_line
.cur_file
= 1;
865 dwarf_line
.last_file
= 0;
866 dwarf_line
.last_pc
= 0;
867 dwarf_line
.last_line
= 1;
868 dwarf_line_op(s1
, 0); // extended
869 dwarf_uleb128_op(s1
, 1 + PTR_SIZE
); // extended size
870 dwarf_line_op(s1
, DW_LNE_set_address
);
871 for (i
= 0; i
< PTR_SIZE
; i
++)
872 dwarf_line_op(s1
, 0);
873 memset(&dwarf_info
.base_type_used
, 0, sizeof(dwarf_info
.base_type_used
));
877 /* file info: full path + filename */
878 pstrcat(buf
, sizeof(buf
), "/");
879 section_sym
= put_elf_sym(symtab_section
, 0, 0,
880 ELFW(ST_INFO
)(STB_LOCAL
, STT_SECTION
), 0,
881 text_section
->sh_num
, NULL
);
882 put_stabs_r(s1
, buf
, N_SO
, 0, 0,
883 text_section
->data_offset
, text_section
, section_sym
);
884 put_stabs_r(s1
, filename
, N_SO
, 0, 0,
885 text_section
->data_offset
, text_section
, section_sym
);
886 for (i
= 0; i
< N_DEFAULT_DEBUG
; i
++)
887 put_stabs(s1
, default_debug
[i
].name
, N_LSYM
, 0, 0, 0);
889 /* we're currently 'including' the <command line> */
894 /* put end of translation unit info */
895 ST_FUNC
void tcc_debug_end(TCCState
*s1
)
897 if (!s1
->do_debug
|| debug_next_type
== 0)
901 tcc_debug_funcend(s1
, 0); /* free stuff in case of errors */
907 int text_size
= text_section
->data_offset
;
910 for (i
= 0; i
< n_debug_anon_hash
; i
++) {
911 Sym
*t
= debug_anon_hash
[i
].type
;
912 int pos
= dwarf_info_section
->data_offset
;
914 dwarf_data1(dwarf_info_section
,
915 IS_UNION (t
->type
.t
) ? DWARF_ABBREV_UNION_EMPTY_TYPE
916 : DWARF_ABBREV_STRUCTURE_EMPTY_TYPE
);
917 dwarf_strp(dwarf_info_section
,
918 (t
->v
& ~SYM_STRUCT
) >= SYM_FIRST_ANOM
919 ? "" : get_tok_str(t
->v
, NULL
));
920 dwarf_uleb128(dwarf_info_section
, 0);
921 dwarf_uleb128(dwarf_info_section
, dwarf_line
.cur_file
);
922 dwarf_uleb128(dwarf_info_section
, file
->line_num
);
923 for (j
= 0; j
< debug_anon_hash
[i
].n_debug_type
; j
++)
924 write32le(dwarf_info_section
->data
+
925 debug_anon_hash
[i
].debug_type
[j
],
926 pos
- dwarf_info
.start
);
927 tcc_free (debug_anon_hash
[i
].debug_type
);
929 tcc_free (debug_anon_hash
);
930 dwarf_data1(dwarf_info_section
, 0);
931 ptr
= dwarf_info_section
->data
+ dwarf_info
.start
;
932 write32le(ptr
, dwarf_info_section
->data_offset
- dwarf_info
.start
- 4);
933 write32le(ptr
+ 25 + (s1
->dwarf
>= 5) + PTR_SIZE
, text_size
);
936 start_aranges
= dwarf_aranges_section
->data_offset
;
937 dwarf_data4(dwarf_aranges_section
, 0); // size
938 dwarf_data2(dwarf_aranges_section
, 2); // version
939 dwarf_reloc(dwarf_aranges_section
, dwarf_sym
.info
, R_DATA_32DW
);
940 dwarf_data4(dwarf_aranges_section
, 0); // dwarf_info
942 dwarf_data1(dwarf_aranges_section
, 4); // address size
944 dwarf_data1(dwarf_aranges_section
, 8); // address size
946 dwarf_data1(dwarf_aranges_section
, 0); // segment selector size
947 dwarf_data4(dwarf_aranges_section
, 0); // padding
948 dwarf_reloc(dwarf_aranges_section
, section_sym
, R_DATA_PTR
);
950 dwarf_data4(dwarf_aranges_section
, 0); // Begin
951 dwarf_data4(dwarf_aranges_section
, text_size
); // End
952 dwarf_data4(dwarf_aranges_section
, 0); // End list
953 dwarf_data4(dwarf_aranges_section
, 0); // End list
955 dwarf_data8(dwarf_aranges_section
, 0); // Begin
956 dwarf_data8(dwarf_aranges_section
, text_size
); // End
957 dwarf_data8(dwarf_aranges_section
, 0); // End list
958 dwarf_data8(dwarf_aranges_section
, 0); // End list
960 ptr
= dwarf_aranges_section
->data
+ start_aranges
;
961 write32le(ptr
, dwarf_aranges_section
->data_offset
- start_aranges
- 4);
964 if (s1
->dwarf
>= 5) {
965 dwarf_data1(dwarf_line_section
, 1); /* col */
966 dwarf_uleb128(dwarf_line_section
, DW_LNCT_path
);
967 dwarf_uleb128(dwarf_line_section
, DW_FORM_line_strp
);
968 dwarf_uleb128(dwarf_line_section
, dwarf_line
.dir_size
);
969 for (i
= 0; i
< dwarf_line
.dir_size
; i
++)
970 dwarf_line_strp(dwarf_line_section
, dwarf_line
.dir_table
[i
]);
971 dwarf_data1(dwarf_line_section
, 2); /* col */
972 dwarf_uleb128(dwarf_line_section
, DW_LNCT_path
);
973 dwarf_uleb128(dwarf_line_section
, DW_FORM_line_strp
);
974 dwarf_uleb128(dwarf_line_section
, DW_LNCT_directory_index
);
975 dwarf_uleb128(dwarf_line_section
, DW_FORM_udata
);
976 dwarf_uleb128(dwarf_line_section
, dwarf_line
.filename_size
);
977 for (i
= 0; i
< dwarf_line
.filename_size
; i
++) {
978 dwarf_line_strp(dwarf_line_section
,
979 dwarf_line
.filename_table
[i
].name
);
980 dwarf_uleb128(dwarf_line_section
,
981 dwarf_line
.filename_table
[i
].dir_entry
);
987 for (i
= 0; i
< dwarf_line
.dir_size
; i
++) {
988 len
= strlen(dwarf_line
.dir_table
[i
]) + 1;
989 ptr
= section_ptr_add(dwarf_line_section
, len
);
990 memmove(ptr
, dwarf_line
.dir_table
[i
], len
);
992 dwarf_data1(dwarf_line_section
, 0); /* end dir */
993 for (i
= 0; i
< dwarf_line
.filename_size
; i
++) {
994 len
= strlen(dwarf_line
.filename_table
[i
].name
) + 1;
995 ptr
= section_ptr_add(dwarf_line_section
, len
);
996 memmove(ptr
, dwarf_line
.filename_table
[i
].name
, len
);
997 dwarf_uleb128(dwarf_line_section
,
998 dwarf_line
.filename_table
[i
].dir_entry
);
999 dwarf_uleb128(dwarf_line_section
, 0); /* time */
1000 dwarf_uleb128(dwarf_line_section
, 0); /* size */
1002 dwarf_data1(dwarf_line_section
, 0); /* end file */
1004 for (i
= 0; i
< dwarf_line
.dir_size
; i
++)
1005 tcc_free(dwarf_line
.dir_table
[i
]);
1006 tcc_free(dwarf_line
.dir_table
);
1007 for (i
= 0; i
< dwarf_line
.filename_size
; i
++)
1008 tcc_free(dwarf_line
.filename_table
[i
].name
);
1009 tcc_free(dwarf_line
.filename_table
);
1011 dwarf_line_op(s1
, 0); // extended
1012 dwarf_uleb128_op(s1
, 1); // extended size
1013 dwarf_line_op(s1
, DW_LNE_end_sequence
);
1014 i
= (s1
->dwarf
>= 5) * 2;
1015 write32le(&dwarf_line_section
->data
[dwarf_line
.start
+ 6 + i
],
1016 dwarf_line_section
->data_offset
- dwarf_line
.start
- (10 + i
));
1017 section_ptr_add(dwarf_line_section
, 3);
1018 dwarf_reloc(dwarf_line_section
, section_sym
, R_DATA_PTR
);
1019 ptr
= section_ptr_add(dwarf_line_section
, dwarf_line
.line_size
- 3);
1020 memmove(ptr
- 3, dwarf_line
.line_data
, dwarf_line
.line_size
);
1021 tcc_free(dwarf_line
.line_data
);
1022 write32le(dwarf_line_section
->data
+ dwarf_line
.start
,
1023 dwarf_line_section
->data_offset
- dwarf_line
.start
- 4);
1027 put_stabs_r(s1
, NULL
, N_SO
, 0, 0,
1028 text_section
->data_offset
, text_section
, section_sym
);
1030 tcc_free(debug_hash
);
1031 debug_next_type
= 0;
1034 static BufferedFile
* put_new_file(TCCState
*s1
)
1036 BufferedFile
*f
= file
;
1037 /* use upper file if from inline ":asm:" */
1038 if (f
->filename
[0] == ':')
1040 if (f
&& new_file
) {
1041 new_file
= last_line_num
= 0;
1045 put_stabs_r(s1
, f
->filename
, N_SOL
, 0, 0, ind
, text_section
, section_sym
);
1050 /* put alternative filename */
1051 ST_FUNC
void tcc_debug_newfile(TCCState
*s1
)
1060 /* begin of #include */
1061 ST_FUNC
void tcc_debug_bincl(TCCState
*s1
)
1068 put_stabs(s1
, file
->filename
, N_BINCL
, 0, 0, 0);
1072 /* end of #include */
1073 ST_FUNC
void tcc_debug_eincl(TCCState
*s1
)
1080 put_stabn(s1
, N_EINCL
, 0, 0, 0);
1084 /* generate line number info */
1085 ST_FUNC
void tcc_debug_line(TCCState
*s1
)
1091 if (cur_text_section
!= text_section
|| nocode_wanted
)
1093 f
= put_new_file(s1
);
1096 if (last_line_num
== f
->line_num
)
1098 last_line_num
= f
->line_num
;
1101 int len_pc
= (ind
- dwarf_line
.last_pc
) / DWARF_MIN_INSTR_LEN
;
1102 int len_line
= f
->line_num
- dwarf_line
.last_line
;
1103 int n
= len_pc
* DWARF_LINE_RANGE
+ len_line
+ DWARF_OPCODE_BASE
- DWARF_LINE_BASE
;
1105 if (dwarf_line
.cur_file
!= dwarf_line
.last_file
) {
1106 dwarf_line
.last_file
= dwarf_line
.cur_file
;
1107 dwarf_line_op(s1
, DW_LNS_set_file
);
1108 dwarf_uleb128_op(s1
, dwarf_line
.cur_file
);
1111 len_line
>= DWARF_LINE_BASE
&& len_line
<= (DWARF_OPCODE_BASE
+ DWARF_LINE_BASE
) &&
1112 n
>= DWARF_OPCODE_BASE
&& n
<= 255)
1113 dwarf_line_op(s1
, n
);
1116 n
= len_pc
* DWARF_LINE_RANGE
+ 0 + DWARF_OPCODE_BASE
- DWARF_LINE_BASE
;
1117 if (n
>= DWARF_OPCODE_BASE
&& n
<= 255)
1118 dwarf_line_op(s1
, n
);
1120 dwarf_line_op(s1
, DW_LNS_advance_pc
);
1121 dwarf_uleb128_op(s1
, len_pc
);
1125 n
= 0 * DWARF_LINE_RANGE
+ len_line
+ DWARF_OPCODE_BASE
- DWARF_LINE_BASE
;
1126 if (len_line
>= DWARF_LINE_BASE
&& len_line
<= (DWARF_OPCODE_BASE
+ DWARF_LINE_BASE
) &&
1127 n
>= DWARF_OPCODE_BASE
&& n
<= 255)
1128 dwarf_line_op(s1
, n
);
1130 dwarf_line_op(s1
, DW_LNS_advance_line
);
1131 dwarf_sleb128_op(s1
, len_line
);
1135 dwarf_line
.last_pc
= ind
;
1136 dwarf_line
.last_line
= f
->line_num
;
1140 if (func_ind
!= -1) {
1141 put_stabn(s1
, N_SLINE
, 0, f
->line_num
, ind
- func_ind
);
1143 /* from tcc_assemble */
1144 put_stabs_r(s1
, NULL
, N_SLINE
, 0, f
->line_num
, ind
, text_section
, section_sym
);
1149 static void tcc_debug_stabs (TCCState
*s1
, const char *str
, int type
, unsigned long value
,
1150 Section
*sec
, int sym_index
, int info
)
1152 struct debug_sym
*s
;
1156 (struct debug_sym
*)tcc_realloc (debug_info
->sym
,
1157 sizeof(struct debug_sym
) *
1158 (debug_info
->n_sym
+ 1));
1159 s
= debug_info
->sym
+ debug_info
->n_sym
++;
1162 s
->str
= tcc_strdup(str
);
1164 s
->sym_index
= sym_index
;
1166 s
->file
= dwarf_line
.cur_file
;
1167 s
->line
= file
->line_num
;
1170 put_stabs_r (s1
, str
, type
, 0, 0, value
, sec
, sym_index
);
1172 put_stabs (s1
, str
, type
, 0, 0, value
);
1175 ST_FUNC
void tcc_debug_stabn(TCCState
*s1
, int type
, int value
)
1179 if (type
== N_LBRAC
) {
1180 struct _debug_info
*info
=
1181 (struct _debug_info
*) tcc_mallocz(sizeof (*info
));
1183 info
->start
= value
;
1184 info
->parent
= debug_info
;
1186 if (debug_info
->child
) {
1187 if (debug_info
->child
->last
)
1188 debug_info
->child
->last
->next
= info
;
1190 debug_info
->child
->next
= info
;
1191 debug_info
->child
->last
= info
;
1194 debug_info
->child
= info
;
1197 debug_info_root
= info
;
1201 debug_info
->end
= value
;
1202 debug_info
= debug_info
->parent
;
1206 static int tcc_debug_find(TCCState
*s1
, Sym
*t
, int dwarf
)
1210 if (!debug_info
&& dwarf
&&
1211 (t
->type
.t
& VT_BTYPE
) == VT_STRUCT
&& t
->c
== -1) {
1212 for (i
= 0; i
< n_debug_anon_hash
; i
++)
1213 if (t
== debug_anon_hash
[i
].type
)
1215 debug_anon_hash
= (struct _debug_anon_hash
*)
1216 tcc_realloc (debug_anon_hash
,
1217 (n_debug_anon_hash
+ 1) * sizeof(*debug_anon_hash
));
1218 debug_anon_hash
[n_debug_anon_hash
].n_debug_type
= 0;
1219 debug_anon_hash
[n_debug_anon_hash
].debug_type
= NULL
;
1220 debug_anon_hash
[n_debug_anon_hash
++].type
= t
;
1223 for (i
= 0; i
< n_debug_hash
; i
++)
1224 if (t
== debug_hash
[i
].type
)
1225 return debug_hash
[i
].debug_type
;
1229 static int tcc_get_dwarf_info(TCCState
*s1
, Sym
*s
);
1231 static void tcc_debug_check_anon(TCCState
*s1
, Sym
*t
, int debug_type
)
1235 if (!debug_info
&& (t
->type
.t
& VT_BTYPE
) == VT_STRUCT
&& t
->type
.ref
->c
== -1)
1236 for (i
= 0; i
< n_debug_anon_hash
; i
++)
1237 if (t
->type
.ref
== debug_anon_hash
[i
].type
) {
1238 debug_anon_hash
[i
].debug_type
=
1239 tcc_realloc(debug_anon_hash
[i
].debug_type
,
1240 (debug_anon_hash
[i
].n_debug_type
+ 1) * sizeof(int));
1241 debug_anon_hash
[i
].debug_type
[debug_anon_hash
[i
].n_debug_type
++] =
1246 ST_FUNC
void tcc_debug_fix_anon(TCCState
*s1
, CType
*t
)
1248 int i
, j
, debug_type
;
1250 if (!(s1
->do_debug
& 2) || !s1
->dwarf
|| debug_info
)
1253 if ((t
->t
& VT_BTYPE
) == VT_STRUCT
&& t
->ref
->c
!= -1)
1254 for (i
= 0; i
< n_debug_anon_hash
; i
++)
1255 if (t
->ref
== debug_anon_hash
[i
].type
) {
1256 Sym sym
= {0}; sym
.type
= *t
;
1258 /* Trick to not hash this struct */
1259 debug_info
= (struct _debug_info
*) t
;
1260 debug_type
= tcc_get_dwarf_info(s1
, &sym
);
1262 for (j
= 0; j
< debug_anon_hash
[i
].n_debug_type
; j
++)
1263 write32le(dwarf_info_section
->data
+
1264 debug_anon_hash
[i
].debug_type
[j
],
1265 debug_type
- dwarf_info
.start
);
1266 tcc_free(debug_anon_hash
[i
].debug_type
);
1267 n_debug_anon_hash
--;
1268 for (; i
< n_debug_anon_hash
; i
++)
1269 debug_anon_hash
[i
] = debug_anon_hash
[i
+ 1];
1273 static int tcc_debug_add(TCCState
*s1
, Sym
*t
, int dwarf
)
1275 int offset
= dwarf
? dwarf_info_section
->data_offset
: ++debug_next_type
;
1276 debug_hash
= (struct _debug_hash
*)
1277 tcc_realloc (debug_hash
,
1278 (n_debug_hash
+ 1) * sizeof(*debug_hash
));
1279 debug_hash
[n_debug_hash
].debug_type
= offset
;
1280 debug_hash
[n_debug_hash
++].type
= t
;
1284 static void tcc_debug_remove(TCCState
*s1
, Sym
*t
)
1288 for (i
= 0; i
< n_debug_hash
; i
++)
1289 if (t
== debug_hash
[i
].type
) {
1291 for (; i
< n_debug_hash
; i
++)
1292 debug_hash
[i
] = debug_hash
[i
+1];
1296 #define STRUCT_NODEBUG(s) \
1298 ((s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM && \
1299 ((s->type.t & VT_BTYPE) == VT_BYTE || \
1300 (s->type.t & VT_BTYPE) == VT_BOOL || \
1301 (s->type.t & VT_BTYPE) == VT_SHORT || \
1302 (s->type.t & VT_BTYPE) == VT_INT || \
1303 (s->type.t & VT_BTYPE) == VT_LLONG)))
1305 static void tcc_get_debug_info(TCCState
*s1
, Sym
*s
, CString
*result
)
1309 int debug_type
= -1;
1314 type
= t
->type
.t
& ~(VT_STORAGE
| VT_CONSTANT
| VT_VOLATILE
| VT_VLA
);
1315 if ((type
& VT_BTYPE
) != VT_BYTE
)
1316 type
&= ~VT_DEFSIGN
;
1317 if (type
== VT_PTR
|| type
== (VT_PTR
| VT_ARRAY
))
1318 n
++, t
= t
->type
.ref
;
1322 if ((type
& VT_BTYPE
) == VT_STRUCT
) {
1326 debug_type
= tcc_debug_find(s1
, t
, 0);
1327 if (debug_type
== -1) {
1328 debug_type
= tcc_debug_add(s1
, t
, 0);
1330 cstr_printf (&str
, "%s:T%d=%c%d",
1331 (t
->v
& ~SYM_STRUCT
) >= SYM_FIRST_ANOM
1332 ? "" : get_tok_str(t
->v
, NULL
),
1334 IS_UNION (t
->type
.t
) ? 'u' : 's',
1337 int pos
, size
, align
;
1340 if (STRUCT_NODEBUG(t
))
1342 cstr_printf (&str
, "%s:",
1343 get_tok_str(t
->v
, NULL
));
1344 tcc_get_debug_info (s1
, t
, &str
);
1345 if (t
->type
.t
& VT_BITFIELD
) {
1346 pos
= t
->c
* 8 + BIT_POS(t
->type
.t
);
1347 size
= BIT_SIZE(t
->type
.t
);
1351 size
= type_size(&t
->type
, &align
) * 8;
1353 cstr_printf (&str
, ",%d,%d;", pos
, size
);
1355 cstr_printf (&str
, ";");
1356 tcc_debug_stabs(s1
, str
.data
, N_LSYM
, 0, NULL
, 0, 0);
1359 tcc_debug_remove(s1
, e
);
1362 else if (IS_ENUM(type
)) {
1363 Sym
*e
= t
= t
->type
.ref
;
1365 debug_type
= tcc_debug_find(s1
, t
, 0);
1366 if (debug_type
== -1) {
1367 debug_type
= tcc_debug_add(s1
, t
, 0);
1369 cstr_printf (&str
, "%s:T%d=e",
1370 (t
->v
& ~SYM_STRUCT
) >= SYM_FIRST_ANOM
1371 ? "" : get_tok_str(t
->v
, NULL
),
1375 cstr_printf (&str
, "%s:",
1376 (t
->v
& ~SYM_FIELD
) >= SYM_FIRST_ANOM
1377 ? "" : get_tok_str(t
->v
, NULL
));
1378 cstr_printf (&str
, e
->type
.t
& VT_UNSIGNED
? "%u," : "%d,",
1381 cstr_printf (&str
, ";");
1382 tcc_debug_stabs(s1
, str
.data
, N_LSYM
, 0, NULL
, 0, 0);
1385 tcc_debug_remove(s1
, e
);
1388 else if ((type
& VT_BTYPE
) != VT_FUNC
) {
1389 type
&= ~VT_STRUCT_MASK
;
1390 for (debug_type
= 1; debug_type
<= N_DEFAULT_DEBUG
; debug_type
++)
1391 if (default_debug
[debug_type
- 1].type
== type
)
1393 if (debug_type
> N_DEFAULT_DEBUG
)
1397 cstr_printf (result
, "%d=", ++debug_next_type
);
1400 type
= t
->type
.t
& ~(VT_STORAGE
| VT_CONSTANT
| VT_VOLATILE
| VT_VLA
);
1401 if ((type
& VT_BTYPE
) != VT_BYTE
)
1402 type
&= ~VT_DEFSIGN
;
1404 cstr_printf (result
, "%d=*", ++debug_next_type
);
1405 else if (type
== (VT_PTR
| VT_ARRAY
))
1406 cstr_printf (result
, "%d=ar1;0;%d;",
1407 ++debug_next_type
, t
->type
.ref
->c
- 1);
1408 else if (type
== VT_FUNC
) {
1409 cstr_printf (result
, "%d=f", ++debug_next_type
);
1410 tcc_get_debug_info (s1
, t
->type
.ref
, result
);
1417 cstr_printf (result
, "%d", debug_type
);
1420 static int tcc_get_dwarf_info(TCCState
*s1
, Sym
*s
)
1423 int debug_type
= -1;
1432 type
= t
->type
.t
& ~(VT_STORAGE
| VT_CONSTANT
| VT_VOLATILE
| VT_VLA
);
1433 if ((type
& VT_BTYPE
) != VT_BYTE
)
1434 type
&= ~VT_DEFSIGN
;
1435 if (type
== VT_PTR
|| type
== (VT_PTR
| VT_ARRAY
))
1440 if ((type
& VT_BTYPE
) == VT_STRUCT
) {
1442 debug_type
= tcc_debug_find(s1
, t
, 1);
1443 if (debug_type
== -1) {
1444 int pos_sib
= 0, i
, *pos_type
;
1446 debug_type
= tcc_debug_add(s1
, t
, 1);
1451 if (STRUCT_NODEBUG(e
))
1455 pos_type
= (int *) tcc_malloc(i
* sizeof(int));
1456 dwarf_data1(dwarf_info_section
,
1457 IS_UNION (t
->type
.t
)
1458 ? t
->next
? DWARF_ABBREV_UNION_TYPE
1459 : DWARF_ABBREV_UNION_EMPTY_TYPE
1460 : t
->next
? DWARF_ABBREV_STRUCTURE_TYPE
1461 : DWARF_ABBREV_STRUCTURE_EMPTY_TYPE
);
1462 dwarf_strp(dwarf_info_section
,
1463 (t
->v
& ~SYM_STRUCT
) >= SYM_FIRST_ANOM
1464 ? "" : get_tok_str(t
->v
, NULL
));
1465 dwarf_uleb128(dwarf_info_section
, t
->c
);
1466 dwarf_uleb128(dwarf_info_section
, dwarf_line
.cur_file
);
1467 dwarf_uleb128(dwarf_info_section
, file
->line_num
);
1469 pos_sib
= dwarf_info_section
->data_offset
;
1470 dwarf_data4(dwarf_info_section
, 0);
1476 if (STRUCT_NODEBUG(e
))
1478 dwarf_data1(dwarf_info_section
,
1479 e
->type
.t
& VT_BITFIELD
? DWARF_ABBREV_MEMBER_BF
1480 : DWARF_ABBREV_MEMBER
);
1481 dwarf_strp(dwarf_info_section
,
1482 get_tok_str(e
->v
, NULL
));
1483 dwarf_uleb128(dwarf_info_section
, dwarf_line
.cur_file
);
1484 dwarf_uleb128(dwarf_info_section
, file
->line_num
);
1485 pos_type
[i
++] = dwarf_info_section
->data_offset
;
1486 dwarf_data4(dwarf_info_section
, 0);
1487 if (e
->type
.t
& VT_BITFIELD
) {
1488 int pos
= e
->c
* 8 + BIT_POS(e
->type
.t
);
1489 int size
= BIT_SIZE(e
->type
.t
);
1491 dwarf_uleb128(dwarf_info_section
, size
);
1492 dwarf_uleb128(dwarf_info_section
, pos
);
1495 dwarf_uleb128(dwarf_info_section
, e
->c
);
1498 dwarf_data1(dwarf_info_section
, 0);
1499 write32le(dwarf_info_section
->data
+ pos_sib
,
1500 dwarf_info_section
->data_offset
- dwarf_info
.start
);
1506 if (STRUCT_NODEBUG(e
))
1508 type
= tcc_get_dwarf_info(s1
, e
);
1509 tcc_debug_check_anon(s1
, e
, pos_type
[i
]);
1510 write32le(dwarf_info_section
->data
+ pos_type
[i
++],
1511 type
- dwarf_info
.start
);
1515 tcc_debug_remove(s1
, t
);
1518 else if (IS_ENUM(type
)) {
1520 debug_type
= tcc_debug_find(s1
, t
, 1);
1521 if (debug_type
== -1) {
1522 int pos_sib
, pos_type
;
1523 Sym sym
= {0}; sym
.type
.t
= VT_INT
| (type
& VT_UNSIGNED
);
1525 pos_type
= tcc_get_dwarf_info(s1
, &sym
);
1526 debug_type
= tcc_debug_add(s1
, t
, 1);
1527 dwarf_data1(dwarf_info_section
, DWARF_ABBREV_ENUMERATION_TYPE
);
1528 dwarf_strp(dwarf_info_section
,
1529 (t
->v
& ~SYM_STRUCT
) >= SYM_FIRST_ANOM
1530 ? "" : get_tok_str(t
->v
, NULL
));
1531 dwarf_data1(dwarf_info_section
,
1532 type
& VT_UNSIGNED
? DW_ATE_unsigned
: DW_ATE_signed
);
1533 dwarf_data1(dwarf_info_section
, 4);
1534 dwarf_data4(dwarf_info_section
, pos_type
- dwarf_info
.start
);
1535 dwarf_uleb128(dwarf_info_section
, dwarf_line
.cur_file
);
1536 dwarf_uleb128(dwarf_info_section
, file
->line_num
);
1537 pos_sib
= dwarf_info_section
->data_offset
;
1538 dwarf_data4(dwarf_info_section
, 0);
1542 dwarf_data1(dwarf_info_section
,
1543 type
& VT_UNSIGNED
? DWARF_ABBREV_ENUMERATOR_UNSIGNED
1544 : DWARF_ABBREV_ENUMERATOR_SIGNED
);
1545 dwarf_strp(dwarf_info_section
,
1546 (e
->v
& ~SYM_FIELD
) >= SYM_FIRST_ANOM
1547 ? "" : get_tok_str(e
->v
, NULL
));
1548 if (type
& VT_UNSIGNED
)
1549 dwarf_uleb128(dwarf_info_section
, e
->enum_val
);
1551 dwarf_sleb128(dwarf_info_section
, e
->enum_val
);
1553 dwarf_data1(dwarf_info_section
, 0);
1554 write32le(dwarf_info_section
->data
+ pos_sib
,
1555 dwarf_info_section
->data_offset
- dwarf_info
.start
);
1557 tcc_debug_remove(s1
, t
);
1560 else if ((type
& VT_BTYPE
) != VT_FUNC
) {
1561 type
&= ~VT_STRUCT_MASK
;
1562 for (i
= 1; i
<= N_DEFAULT_DEBUG
; i
++)
1563 if (default_debug
[i
- 1].type
== type
)
1565 if (i
> N_DEFAULT_DEBUG
)
1567 debug_type
= dwarf_info
.base_type_used
[i
- 1];
1568 if (debug_type
== 0) {
1571 debug_type
= dwarf_info_section
->data_offset
;
1572 dwarf_data1(dwarf_info_section
, DWARF_ABBREV_BASE_TYPE
);
1573 dwarf_uleb128(dwarf_info_section
, default_debug
[i
- 1].size
);
1574 dwarf_data1(dwarf_info_section
, default_debug
[i
- 1].encoding
);
1575 strncpy(name
, default_debug
[i
- 1].name
, sizeof(name
) -1);
1576 *strchr(name
, ':') = 0;
1577 dwarf_strp(dwarf_info_section
, name
);
1578 dwarf_info
.base_type_used
[i
- 1] = debug_type
;
1581 retval
= debug_type
;
1585 type
= t
->type
.t
& ~(VT_STORAGE
| VT_CONSTANT
| VT_VOLATILE
| VT_VLA
);
1586 if ((type
& VT_BTYPE
) != VT_BYTE
)
1587 type
&= ~VT_DEFSIGN
;
1588 if (type
== VT_PTR
) {
1589 i
= dwarf_info_section
->data_offset
;
1590 if (retval
== debug_type
)
1592 dwarf_data1(dwarf_info_section
, DWARF_ABBREV_POINTER
);
1593 dwarf_data1(dwarf_info_section
, PTR_SIZE
);
1594 if (last_pos
!= -1) {
1595 tcc_debug_check_anon(s1
, e
, last_pos
);
1596 write32le(dwarf_info_section
->data
+ last_pos
,
1597 i
- dwarf_info
.start
);
1599 last_pos
= dwarf_info_section
->data_offset
;
1601 dwarf_data4(dwarf_info_section
, 0);
1603 else if (type
== (VT_PTR
| VT_ARRAY
)) {
1604 int sib_pos
, sub_type
;
1606 Sym sym
= {0}; sym
.type
.t
= VT_LONG
| VT_INT
| VT_UNSIGNED
;
1608 Sym sym
= {0}; sym
.type
.t
= VT_LLONG
| VT_LONG
| VT_UNSIGNED
;
1611 sub_type
= tcc_get_dwarf_info(s1
, &sym
);
1612 i
= dwarf_info_section
->data_offset
;
1613 if (retval
== debug_type
)
1615 dwarf_data1(dwarf_info_section
, DWARF_ABBREV_ARRAY_TYPE
);
1616 if (last_pos
!= -1) {
1617 tcc_debug_check_anon(s1
, e
, last_pos
);
1618 write32le(dwarf_info_section
->data
+ last_pos
,
1619 i
- dwarf_info
.start
);
1621 last_pos
= dwarf_info_section
->data_offset
;
1623 dwarf_data4(dwarf_info_section
, 0);
1624 sib_pos
= dwarf_info_section
->data_offset
;
1625 dwarf_data4(dwarf_info_section
, 0);
1627 dwarf_data1(dwarf_info_section
, DWARF_ABBREV_SUBRANGE_TYPE
);
1628 dwarf_data4(dwarf_info_section
, sub_type
- dwarf_info
.start
);
1629 dwarf_uleb128(dwarf_info_section
, t
->type
.ref
->c
- 1);
1631 type
= s
->type
.t
& ~(VT_STORAGE
| VT_CONSTANT
| VT_VOLATILE
);
1632 if (type
!= (VT_PTR
| VT_ARRAY
))
1636 dwarf_data1(dwarf_info_section
, 0);
1637 write32le(dwarf_info_section
->data
+ sib_pos
,
1638 dwarf_info_section
->data_offset
- dwarf_info
.start
);
1640 else if (type
== VT_FUNC
) {
1641 int sib_pos
= 0, *pos_type
;
1644 i
= dwarf_info_section
->data_offset
;
1645 debug_type
= tcc_get_dwarf_info(s1
, t
->type
.ref
);
1646 if (retval
== debug_type
)
1648 dwarf_data1(dwarf_info_section
,
1649 t
->type
.ref
->next
? DWARF_ABBREV_SUBROUTINE_TYPE
1650 : DWARF_ABBREV_SUBROUTINE_EMPTY_TYPE
);
1651 if (last_pos
!= -1) {
1652 tcc_debug_check_anon(s1
, e
, last_pos
);
1653 write32le(dwarf_info_section
->data
+ last_pos
,
1654 i
- dwarf_info
.start
);
1656 last_pos
= dwarf_info_section
->data_offset
;
1658 dwarf_data4(dwarf_info_section
, 0);
1659 if (t
->type
.ref
->next
) {
1660 sib_pos
= dwarf_info_section
->data_offset
;
1661 dwarf_data4(dwarf_info_section
, 0);
1669 pos_type
= (int *) tcc_malloc(i
* sizeof(int));
1674 dwarf_data1(dwarf_info_section
, DWARF_ABBREV_FORMAL_PARAMETER2
);
1675 pos_type
[i
++] = dwarf_info_section
->data_offset
;
1676 dwarf_data4(dwarf_info_section
, 0);
1678 if (t
->type
.ref
->next
) {
1679 dwarf_data1(dwarf_info_section
, 0);
1680 write32le(dwarf_info_section
->data
+ sib_pos
,
1681 dwarf_info_section
->data_offset
- dwarf_info
.start
);
1687 type
= tcc_get_dwarf_info(s1
, f
);
1688 tcc_debug_check_anon(s1
, f
, pos_type
[i
]);
1689 write32le(dwarf_info_section
->data
+ pos_type
[i
++],
1690 type
- dwarf_info
.start
);
1695 if (last_pos
!= -1) {
1696 tcc_debug_check_anon(s1
, e
, last_pos
);
1697 write32le(dwarf_info_section
->data
+ last_pos
,
1698 debug_type
- dwarf_info
.start
);
1707 static void tcc_debug_finish (TCCState
*s1
, struct _debug_info
*cur
)
1710 struct _debug_info
*next
= cur
->next
;
1715 for (i
= cur
->n_sym
- 1; i
>= 0; i
--) {
1716 struct debug_sym
*s
= &cur
->sym
[i
];
1718 dwarf_data1(dwarf_info_section
,
1720 ? DWARF_ABBREV_FORMAL_PARAMETER
1722 ? DWARF_ABBREV_VARIABLE_EXTERNAL
1723 : s
->type
== N_STSYM
1724 ? DWARF_ABBREV_VARIABLE_STATIC
1725 : DWARF_ABBREV_VARIABLE_LOCAL
);
1726 dwarf_strp(dwarf_info_section
, s
->str
);
1727 if (s
->type
== N_GSYM
|| s
->type
== N_STSYM
) {
1728 dwarf_uleb128(dwarf_info_section
, s
->file
);
1729 dwarf_uleb128(dwarf_info_section
, s
->line
);
1731 dwarf_data4(dwarf_info_section
, s
->info
- dwarf_info
.start
);
1732 if (s
->type
== N_GSYM
|| s
->type
== N_STSYM
) {
1734 if (s
->type
== N_GSYM
)
1735 dwarf_data1(dwarf_info_section
, 1);
1736 dwarf_data1(dwarf_info_section
, PTR_SIZE
+ 1);
1737 dwarf_data1(dwarf_info_section
, DW_OP_addr
);
1738 if (s
->type
== N_STSYM
)
1739 dwarf_reloc(dwarf_info_section
, section_sym
, R_DATA_PTR
);
1741 dwarf_data4(dwarf_info_section
, s
->value
);
1743 dwarf_data8(dwarf_info_section
, s
->value
);
1748 dwarf_data1(dwarf_info_section
, dwarf_sleb128_size(s
->value
) + 1);
1749 dwarf_data1(dwarf_info_section
, DW_OP_fbreg
);
1750 dwarf_sleb128(dwarf_info_section
, s
->value
);
1754 tcc_free (cur
->sym
);
1755 dwarf_data1(dwarf_info_section
,
1756 cur
->child
? DWARF_ABBREV_LEXICAL_BLOCK
1757 : DWARF_ABBREV_LEXICAL_EMPTY_BLOCK
);
1758 dwarf_reloc(dwarf_info_section
, section_sym
, R_DATA_PTR
);
1760 dwarf_data4(dwarf_info_section
, func_ind
+ cur
->start
);
1761 dwarf_data4(dwarf_info_section
, cur
->end
- cur
->start
);
1763 dwarf_data8(dwarf_info_section
, func_ind
+ cur
->start
);
1764 dwarf_data8(dwarf_info_section
, cur
->end
- cur
->start
);
1766 tcc_debug_finish (s1
, cur
->child
);
1768 dwarf_data1(dwarf_info_section
, 0);
1772 for (i
= 0; i
< cur
->n_sym
; i
++) {
1773 struct debug_sym
*s
= &cur
->sym
[i
];
1776 put_stabs_r(s1
, s
->str
, s
->type
, 0, 0, s
->value
,
1777 s
->sec
, s
->sym_index
);
1779 put_stabs(s1
, s
->str
, s
->type
, 0, 0, s
->value
);
1782 tcc_free (cur
->sym
);
1783 put_stabn(s1
, N_LBRAC
, 0, 0, cur
->start
);
1784 tcc_debug_finish (s1
, cur
->child
);
1785 put_stabn(s1
, N_RBRAC
, 0, 0, cur
->end
);
1792 ST_FUNC
void tcc_add_debug_info(TCCState
*s1
, int param
, Sym
*s
, Sym
*e
)
1796 if (!(s1
->do_debug
& 2))
1799 cstr_new (&debug_str
);
1800 for (; s
!= e
; s
= s
->prev
) {
1801 if (!s
->v
|| (s
->r
& VT_VALMASK
) != VT_LOCAL
)
1804 tcc_debug_stabs(s1
, get_tok_str(s
->v
, NULL
),
1805 param
? N_PSYM
: N_LSYM
, s
->c
, NULL
, 0,
1806 tcc_get_dwarf_info(s1
, s
));
1810 cstr_reset (&debug_str
);
1811 cstr_printf (&debug_str
, "%s:%s", get_tok_str(s
->v
, NULL
),
1813 tcc_get_debug_info(s1
, s
, &debug_str
);
1814 tcc_debug_stabs(s1
, debug_str
.data
, param
? N_PSYM
: N_LSYM
,
1818 cstr_free (&debug_str
);
1821 /* put function symbol */
1822 ST_FUNC
void tcc_debug_funcstart(TCCState
*s1
, Sym
*sym
)
1829 debug_info_root
= NULL
;
1831 tcc_debug_stabn(s1
, N_LBRAC
, ind
- func_ind
);
1832 f
= put_new_file(s1
);
1838 dwarf_info
.func
= sym
;
1839 dwarf_info
.line
= file
->line_num
;
1840 if (s1
->do_backtrace
) {
1843 dwarf_line_op(s1
, 0); // extended
1844 dwarf_uleb128_op(s1
, strlen(funcname
) + 2);
1845 dwarf_line_op(s1
, DW_LNE_hi_user
- 1);
1846 len
= strlen(funcname
) + 1;
1847 for (i
= 0; i
< len
; i
++)
1848 dwarf_line_op(s1
, funcname
[i
]);
1853 cstr_new (&debug_str
);
1854 cstr_printf(&debug_str
, "%s:%c", funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
1855 tcc_get_debug_info(s1
, sym
->type
.ref
, &debug_str
);
1856 put_stabs_r(s1
, debug_str
.data
, N_FUN
, 0, f
->line_num
, 0, cur_text_section
, sym
->c
);
1857 cstr_free (&debug_str
);
1862 ST_FUNC
void tcc_debug_prolog_epilog(TCCState
*s1
, int value
)
1867 dwarf_line_op(s1
, value
== 0 ? DW_LNS_set_prologue_end
1868 : DW_LNS_set_epilogue_begin
);
1872 /* put function size */
1873 ST_FUNC
void tcc_debug_funcend(TCCState
*s1
, int size
)
1875 /* lldb does not like function end and next function start at same pc */
1880 min_instr_len
= dwarf_line
.last_pc
== ind
? 0 : DWARF_MIN_INSTR_LEN
;
1881 ind
-= min_instr_len
;
1883 ind
+= min_instr_len
;
1884 tcc_debug_stabn(s1
, N_RBRAC
, size
);
1887 Sym
*sym
= dwarf_info
.func
;
1888 int n_debug_info
= tcc_get_dwarf_info(s1
, sym
->type
.ref
);
1890 dwarf_data1(dwarf_info_section
,
1891 sym
->type
.t
& VT_STATIC
? DWARF_ABBREV_SUBPROGRAM_STATIC
1892 : DWARF_ABBREV_SUBPROGRAM_EXTERNAL
);
1893 if ((sym
->type
.t
& VT_STATIC
) == 0)
1894 dwarf_data1(dwarf_info_section
, 1);
1895 dwarf_strp(dwarf_info_section
, funcname
);
1896 dwarf_uleb128(dwarf_info_section
, dwarf_line
.cur_file
);
1897 dwarf_uleb128(dwarf_info_section
, dwarf_info
.line
);
1898 tcc_debug_check_anon(s1
, sym
->type
.ref
, dwarf_info_section
->data_offset
);
1899 dwarf_data4(dwarf_info_section
, n_debug_info
- dwarf_info
.start
);
1900 dwarf_reloc(dwarf_info_section
, section_sym
, R_DATA_PTR
);
1902 dwarf_data4(dwarf_info_section
, func_ind
); // low_pc
1903 dwarf_data4(dwarf_info_section
, size
); // high_pc
1905 dwarf_data8(dwarf_info_section
, func_ind
); // low_pc
1906 dwarf_data8(dwarf_info_section
, size
); // high_pc
1908 func_sib
= dwarf_info_section
->data_offset
;
1909 dwarf_data4(dwarf_info_section
, 0); // sibling
1910 dwarf_data1(dwarf_info_section
, 1);
1911 #if defined(TCC_TARGET_I386)
1912 dwarf_data1(dwarf_info_section
, DW_OP_reg5
); // ebp
1913 #elif defined(TCC_TARGET_X86_64)
1914 dwarf_data1(dwarf_info_section
, DW_OP_reg6
); // rbp
1915 #elif defined TCC_TARGET_ARM
1916 dwarf_data1(dwarf_info_section
, DW_OP_reg13
); // sp
1917 #elif defined TCC_TARGET_ARM64
1918 dwarf_data1(dwarf_info_section
, DW_OP_reg29
); // reg 29
1919 #elif defined TCC_TARGET_RISCV64
1920 dwarf_data1(dwarf_info_section
, DW_OP_reg8
); // r8(s0)
1922 dwarf_data1(dwarf_info_section
, DW_OP_call_frame_cfa
);
1924 tcc_debug_finish (s1
, debug_info_root
);
1925 dwarf_data1(dwarf_info_section
, 0);
1926 write32le(dwarf_info_section
->data
+ func_sib
,
1927 dwarf_info_section
->data_offset
- dwarf_info
.start
);
1931 tcc_debug_finish (s1
, debug_info_root
);
1933 debug_info_root
= 0;
1937 ST_FUNC
void tcc_debug_extern_sym(TCCState
*s1
, Sym
*sym
, int sh_num
, int sym_bind
, int sym_type
)
1939 if (!(s1
->do_debug
& 2))
1942 if (sym_type
== STT_FUNC
|| sym
->v
>= SYM_FIRST_ANOM
)
1947 debug_type
= tcc_get_dwarf_info(s1
, sym
);
1948 dwarf_data1(dwarf_info_section
,
1949 sym_bind
== STB_GLOBAL
1950 ? DWARF_ABBREV_VARIABLE_EXTERNAL
1951 : DWARF_ABBREV_VARIABLE_STATIC
);
1952 dwarf_strp(dwarf_info_section
, get_tok_str(sym
->v
, NULL
));
1953 dwarf_uleb128(dwarf_info_section
, dwarf_line
.cur_file
);
1954 dwarf_uleb128(dwarf_info_section
, file
->line_num
);
1955 tcc_debug_check_anon(s1
, sym
, dwarf_info_section
->data_offset
);
1956 dwarf_data4(dwarf_info_section
, debug_type
- dwarf_info
.start
);
1957 if (sym_bind
== STB_GLOBAL
)
1958 dwarf_data1(dwarf_info_section
, 1);
1959 dwarf_data1(dwarf_info_section
, PTR_SIZE
+ 1);
1960 dwarf_data1(dwarf_info_section
, DW_OP_addr
);
1961 greloca(dwarf_info_section
, sym
, dwarf_info_section
->data_offset
,
1964 dwarf_data4(dwarf_info_section
, 0);
1966 dwarf_data8(dwarf_info_section
, 0);
1971 Section
*s
= sh_num
== SHN_COMMON
? common_section
1972 : s1
->sections
[sh_num
];
1976 cstr_printf (&str
, "%s:%c",
1977 get_tok_str(sym
->v
, NULL
),
1978 sym_bind
== STB_GLOBAL
? 'G' : func_ind
!= -1 ? 'V' : 'S'
1980 tcc_get_debug_info(s1
, sym
, &str
);
1981 if (sym_bind
== STB_GLOBAL
)
1982 tcc_debug_stabs(s1
, str
.data
, N_GSYM
, 0, NULL
, 0, 0);
1984 tcc_debug_stabs(s1
, str
.data
,
1985 (sym
->type
.t
& VT_STATIC
) && data_section
== s
1986 ? N_STSYM
: N_LCSYM
, 0, s
, sym
->c
, 0);
1991 ST_FUNC
void tcc_debug_typedef(TCCState
*s1
, Sym
*sym
)
1993 if (!(s1
->do_debug
& 2))
1999 debug_type
= tcc_get_dwarf_info(s1
, sym
);
2000 if (debug_type
!= -1) {
2001 dwarf_data1(dwarf_info_section
, DWARF_ABBREV_TYPEDEF
);
2002 dwarf_strp(dwarf_info_section
, get_tok_str(sym
->v
, NULL
));
2003 dwarf_uleb128(dwarf_info_section
, dwarf_line
.cur_file
);
2004 dwarf_uleb128(dwarf_info_section
, file
->line_num
);
2005 tcc_debug_check_anon(s1
, sym
, dwarf_info_section
->data_offset
);
2006 dwarf_data4(dwarf_info_section
, debug_type
- dwarf_info
.start
);
2013 cstr_printf (&str
, "%s:t",
2014 (sym
->v
& ~SYM_FIELD
) >= SYM_FIRST_ANOM
2015 ? "" : get_tok_str(sym
->v
, NULL
));
2016 tcc_get_debug_info(s1
, sym
, &str
);
2017 tcc_debug_stabs(s1
, str
.data
, N_LSYM
, 0, NULL
, 0, 0);
2022 /* ------------------------------------------------------------------------- */
2023 /* for section layout see lib/tcov.c */
2025 ST_FUNC
void tcc_tcov_block_end(TCCState
*s1
, int line
);
2027 ST_FUNC
void tcc_tcov_block_begin(TCCState
*s1
)
2031 unsigned long last_offset
= tcov_data
.offset
;
2033 tcc_tcov_block_end (tcc_state
, 0);
2034 if (s1
->test_coverage
== 0 || nocode_wanted
)
2037 if (tcov_data
.last_file_name
== 0 ||
2038 strcmp ((const char *)(tcov_section
->data
+ tcov_data
.last_file_name
),
2039 file
->true_filename
) != 0) {
2043 if (tcov_data
.last_func_name
)
2044 section_ptr_add(tcov_section
, 1);
2045 if (tcov_data
.last_file_name
)
2046 section_ptr_add(tcov_section
, 1);
2047 tcov_data
.last_func_name
= 0;
2049 if (file
->true_filename
[0] == '/') {
2050 tcov_data
.last_file_name
= tcov_section
->data_offset
;
2051 cstr_printf (&cstr
, "%s", file
->true_filename
);
2054 getcwd (wd
, sizeof(wd
));
2055 tcov_data
.last_file_name
= tcov_section
->data_offset
+ strlen(wd
) + 1;
2056 cstr_printf (&cstr
, "%s/%s", wd
, file
->true_filename
);
2058 ptr
= section_ptr_add(tcov_section
, cstr
.size
+ 1);
2059 strcpy((char *)ptr
, cstr
.data
);
2061 normalize_slashes((char *)ptr
);
2065 if (tcov_data
.last_func_name
== 0 ||
2066 strcmp ((const char *)(tcov_section
->data
+ tcov_data
.last_func_name
),
2070 if (tcov_data
.last_func_name
)
2071 section_ptr_add(tcov_section
, 1);
2072 tcov_data
.last_func_name
= tcov_section
->data_offset
;
2073 len
= strlen (funcname
);
2074 ptr
= section_ptr_add(tcov_section
, len
+ 1);
2075 strcpy((char *)ptr
, funcname
);
2076 section_ptr_add(tcov_section
, -tcov_section
->data_offset
& 7);
2077 ptr
= section_ptr_add(tcov_section
, 8);
2078 write64le (ptr
, file
->line_num
);
2080 if (ind
== tcov_data
.ind
&& tcov_data
.line
== file
->line_num
)
2081 tcov_data
.offset
= last_offset
;
2084 label
.type
.t
= VT_LLONG
| VT_STATIC
;
2086 ptr
= section_ptr_add(tcov_section
, 16);
2087 tcov_data
.line
= file
->line_num
;
2088 write64le (ptr
, (tcov_data
.line
<< 8) | 0xff);
2089 put_extern_sym(&label
, tcov_section
,
2090 ((unsigned char *)ptr
- tcov_section
->data
) + 8, 0);
2091 sv
.type
= label
.type
;
2092 sv
.r
= VT_SYM
| VT_LVAL
| VT_CONST
;
2096 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64 || \
2097 defined TCC_TARGET_ARM || defined TCC_TARGET_ARM64 || \
2098 defined TCC_TARGET_RISCV64
2099 gen_increment_tcov (&sv
);
2105 tcov_data
.offset
= (unsigned char *)ptr
- tcov_section
->data
;
2106 tcov_data
.ind
= ind
;
2110 ST_FUNC
void tcc_tcov_block_end(TCCState
*s1
, int line
)
2112 if (s1
->test_coverage
== 0)
2115 line
= tcov_data
.line
;
2116 if (tcov_data
.offset
) {
2117 void *ptr
= tcov_section
->data
+ tcov_data
.offset
;
2118 unsigned long long nline
= line
? line
: file
->line_num
;
2120 write64le (ptr
, (read64le (ptr
) & 0xfffffffffull
) | (nline
<< 36));
2121 tcov_data
.offset
= 0;
2125 ST_FUNC
void tcc_tcov_check_line(TCCState
*s1
, int start
)
2127 if (s1
->test_coverage
== 0)
2129 if (tcov_data
.line
!= file
->line_num
) {
2130 if ((tcov_data
.line
+ 1) != file
->line_num
) {
2131 tcc_tcov_block_end (s1
, -1);
2133 tcc_tcov_block_begin (s1
);
2136 tcov_data
.line
= file
->line_num
;
2140 ST_FUNC
void tcc_tcov_start(TCCState
*s1
)
2142 if (s1
->test_coverage
== 0)
2145 s1
->dState
= tcc_mallocz(sizeof *s1
->dState
);
2146 memset (&tcov_data
, 0, sizeof (tcov_data
));
2147 if (tcov_section
== NULL
) {
2148 tcov_section
= new_section(tcc_state
, ".tcov", SHT_PROGBITS
,
2149 SHF_ALLOC
| SHF_WRITE
);
2150 section_ptr_add(tcov_section
, 4); // pointer to executable name
2154 ST_FUNC
void tcc_tcov_end(TCCState
*s1
)
2156 if (s1
->test_coverage
== 0)
2158 if (tcov_data
.last_func_name
)
2159 section_ptr_add(tcov_section
, 1);
2160 if (tcov_data
.last_file_name
)
2161 section_ptr_add(tcov_section
, 1);
2164 ST_FUNC
void tcc_tcov_reset_ind(TCCState
*s1
)
2169 /* ------------------------------------------------------------------------- */
2170 #undef last_line_num
2173 #undef debug_next_type
2176 #undef debug_anon_hash
2177 #undef n_debug_anon_hash
2179 #undef debug_info_root