?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
arm64: Handle sp, lr, fp as DwReg in CfiExpr
[valgrind.git] / coregrind / m_debuginfo / d3basics.c
blob1bc5f8f0520bb4689fb859babc1564866d861ffe
1
2 /*--------------------------------------------------------------------*/
3 /*--- Basic definitions and helper functions for DWARF3. ---*/
4 /*--- d3basics.c ---*/
5 /*--------------------------------------------------------------------*/
6
7 /*
8 This file is part of Valgrind, a dynamic binary instrumentation
9 framework.
10
11 Copyright (C) 2008-2017 OpenWorks LLP
12 info@open-works.co.uk
13
14 This program is free software; you can redistribute it and/or
15 modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation; either version 2 of the
17 License, or (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, see <http://www.gnu.org/licenses/>.
26
27 The GNU General Public License is contained in the file COPYING.
28
29 Neither the names of the U.S. Department of Energy nor the
30 University of California nor the names of its contributors may be
31 used to endorse or promote products derived from this software
32 without prior written permission.
33 */
34
35 #include "pub_core_basics.h"
36 #include "pub_core_debuginfo.h"
37 #include "pub_core_libcassert.h"
38 #include "pub_core_libcprint.h"
39 #include "pub_core_libcbase.h"
40 #include "pub_core_options.h"
41 #include "pub_core_xarray.h"
42
43 #include "pub_core_vki.h" /* VKI_PROT_READ */
44 #include "pub_core_aspacemgr.h" /* VG_(is_valid_for_client) */
45
46 #include "priv_misc.h"
47 #include "priv_image.h"
48 #include "priv_d3basics.h" /* self */
49 #include "priv_storage.h"
50
51 const HChar* ML_(pp_DW_children) ( DW_children hashch )
52 {
53 switch (hashch) {
54 case DW_children_no: return "no children";
55 case DW_children_yes: return "has children";
56 }
57 return "DW_children_???";
58 }
59
60 const HChar* ML_(pp_DW_TAG) ( DW_TAG tag )
61 {
62 switch (tag) {
63 case DW_TAG_padding: return "DW_TAG_padding";
64 case DW_TAG_array_type: return "DW_TAG_array_type";
65 case DW_TAG_class_type: return "DW_TAG_class_type";
66 case DW_TAG_entry_point: return "DW_TAG_entry_point";
67 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
68 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
69 case DW_TAG_imported_declaration:
70 return "DW_TAG_imported_declaration";
71 case DW_TAG_label: return "DW_TAG_label";
72 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
73 case DW_TAG_member: return "DW_TAG_member";
74 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
75 case DW_TAG_reference_type: return "DW_TAG_reference_type";
76 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
77 case DW_TAG_string_type: return "DW_TAG_string_type";
78 case DW_TAG_structure_type: return "DW_TAG_structure_type";
79 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
80 case DW_TAG_typedef: return "DW_TAG_typedef";
81 case DW_TAG_union_type: return "DW_TAG_union_type";
82 case DW_TAG_unspecified_parameters:
83 return "DW_TAG_unspecified_parameters";
84 case DW_TAG_variant: return "DW_TAG_variant";
85 case DW_TAG_common_block: return "DW_TAG_common_block";
86 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
87 case DW_TAG_inheritance: return "DW_TAG_inheritance";
88 case DW_TAG_inlined_subroutine:
89 return "DW_TAG_inlined_subroutine";
90 case DW_TAG_module: return "DW_TAG_module";
91 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
92 case DW_TAG_set_type: return "DW_TAG_set_type";
93 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
94 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
95 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
96 case DW_TAG_base_type: return "DW_TAG_base_type";
97 case DW_TAG_catch_block: return "DW_TAG_catch_block";
98 case DW_TAG_const_type: return "DW_TAG_const_type";
99 case DW_TAG_constant: return "DW_TAG_constant";
100 case DW_TAG_enumerator: return "DW_TAG_enumerator";
101 case DW_TAG_file_type: return "DW_TAG_file_type";
102 case DW_TAG_friend: return "DW_TAG_friend";
103 case DW_TAG_namelist: return "DW_TAG_namelist";
104 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
105 case DW_TAG_packed_type: return "DW_TAG_packed_type";
106 case DW_TAG_subprogram: return "DW_TAG_subprogram";
107 case DW_TAG_template_type_param:
108 return "DW_TAG_template_type_param";
109 case DW_TAG_template_value_param:
110 return "DW_TAG_template_value_param";
111 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
112 case DW_TAG_try_block: return "DW_TAG_try_block";
113 case DW_TAG_variant_part: return "DW_TAG_variant_part";
114 case DW_TAG_variable: return "DW_TAG_variable";
115 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
116 /* DWARF 3. */
117 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
118 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
119 case DW_TAG_interface_type: return "DW_TAG_interface_type";
120 case DW_TAG_namespace: return "DW_TAG_namespace";
121 case DW_TAG_imported_module: return "DW_TAG_imported_module";
122 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
123 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
124 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
125 case DW_TAG_condition: return "DW_TAG_condition";
126 case DW_TAG_shared_type: return "DW_TAG_shared_type";
127 /* DWARF 4. */
128 case DW_TAG_type_unit: return "DW_TAG_type_unit";
129 case DW_TAG_rvalue_reference_type: return "DW_TAG_rvalue_reference_type";
130 case DW_TAG_template_alias: return "DW_TAG_template_alias";
131 /* DWARF 5. */
132 case DW_TAG_coarray_type: return "DW_TAG_coarray_type";
133 case DW_TAG_generic_subrange: return "DW_TAG_generic_subrange";
134 case DW_TAG_dynamic_type: return "DW_TAG_dynamic_type";
135 case DW_TAG_atomic_type: return "DW_TAG_atomic_type";
136 case DW_TAG_call_site: return "DW_TAG_call_site";
137 case DW_TAG_call_site_parameter:
138 return "DW_TAG_call_site_parameter";
139 case DW_TAG_skeleton_unit: return "DW_TAG_skeleton_unit";
140 case DW_TAG_immutable_type: return "DW_TAG_immutable_type";
141 /* SGI/MIPS Extensions. */
142 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
143 /* HP extensions. See:
144 ftp://ftp.hp.com/pub/lang/tools/WDB/wdb-4.0.tar.gz . */
145 case DW_TAG_HP_array_descriptor:
146 return "DW_TAG_HP_array_descriptor";
147 /* GNU extensions. */
148 case DW_TAG_format_label: return "DW_TAG_format_label";
149 case DW_TAG_function_template: return "DW_TAG_function_template";
150 case DW_TAG_class_template: return "DW_TAG_class_template";
151 case DW_TAG_GNU_BINCL: return "DW_TAG_GNU_BINCL";
152 case DW_TAG_GNU_EINCL: return "DW_TAG_GNU_EINCL";
153 case DW_TAG_GNU_template_template_param:
154 return "DW_TAG_GNU_template_template_param";
155 case DW_TAG_GNU_template_parameter_pack:
156 return"DW_TAG_GNU_template_parameter_pack";
157 case DW_TAG_GNU_formal_parameter_pack:
158 return "DW_TAG_GNU_formal_parameter_pack";
159 case DW_TAG_GNU_call_site:
160 return "DW_TAG_GNU_call_site";
161 case DW_TAG_GNU_call_site_parameter:
162 return "DW_TAG_GNU_call_site_parameter";
163 /* Extensions for UPC. See: http://upc.gwu.edu/~upc. */
164 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
165 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
166 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
167 /* PGI (STMicroelectronics) extensions. No documentation available. */
168 case DW_TAG_PGI_kanji_type: return "DW_TAG_PGI_kanji_type";
169 case DW_TAG_PGI_interface_block:
170 return "DW_TAG_PGI_interface_block";
171 }
172 return "DW_TAG_???";
173 }
174
175 const HChar* ML_(pp_DW_FORM) ( DW_FORM form )
176 {
177 switch (form) {
178 case DW_FORM_addr: return "DW_FORM_addr";
179 case DW_FORM_block2: return "DW_FORM_block2";
180 case DW_FORM_block4: return "DW_FORM_block4";
181 case DW_FORM_data2: return "DW_FORM_data2";
182 case DW_FORM_data4: return "DW_FORM_data4";
183 case DW_FORM_data8: return "DW_FORM_data8";
184 case DW_FORM_string: return "DW_FORM_string";
185 case DW_FORM_block: return "DW_FORM_block";
186 case DW_FORM_block1: return "DW_FORM_block1";
187 case DW_FORM_data1: return "DW_FORM_data1";
188 case DW_FORM_flag: return "DW_FORM_flag";
189 case DW_FORM_sdata: return "DW_FORM_sdata";
190 case DW_FORM_strp: return "DW_FORM_strp";
191 case DW_FORM_udata: return "DW_FORM_udata";
192 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
193 case DW_FORM_ref1: return "DW_FORM_ref1";
194 case DW_FORM_ref2: return "DW_FORM_ref2";
195 case DW_FORM_ref4: return "DW_FORM_ref4";
196 case DW_FORM_ref8: return "DW_FORM_ref8";
197 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
198 case DW_FORM_indirect: return "DW_FORM_indirect";
199 case DW_FORM_sec_offset:return "DW_FORM_sec_offset";
200 case DW_FORM_exprloc: return "DW_FORM_exprloc";
201 case DW_FORM_flag_present:return "DW_FORM_flag_present";
202 case DW_FORM_ref_sig8: return "DW_FORM_ref_sig8";
203 case DW_FORM_strx: return "DW_FORM_strx";
204 case DW_FORM_addrx: return "DW_FORM_addrx";
205 case DW_FORM_ref_sup4: return "DW_FORM_ref_sup4";
206 case DW_FORM_strp_sup: return "DW_FORM_strp_sup";
207 case DW_FORM_data16: return "DW_FORM_data16";
208 case DW_FORM_line_strp: return "DW_FORM_line_strp";
209 case DW_FORM_implicit_const:return "DW_FORM_implicit_const";
210 case DW_FORM_loclistx: return "DW_FORM_loclistx";
211 case DW_FORM_rnglistx: return "DW_FORM_rnglistx";
212 case DW_FORM_ref_sup8: return "DW_FORM_ref_sup8";
213 case DW_FORM_strx1: return "DW_FORM_strx1";
214 case DW_FORM_strx2: return "DW_FORM_strx2";
215 case DW_FORM_strx3: return "DW_FORM_strx3";
216 case DW_FORM_strx4: return "DW_FORM_strx4";
217 case DW_FORM_addrx1: return "DW_FORM_addrx1";
218 case DW_FORM_addrx2: return "DW_FORM_addrx2";
219 case DW_FORM_addrx3: return "DW_FORM_addrx3";
220 case DW_FORM_addrx4: return "DW_FORM_addrx4";
221 /* GNU Debug Fission extensions. */
222 case DW_FORM_GNU_addr_index:return "DW_FORM_GNU_addr_index";
223 case DW_FORM_GNU_str_index:return "DW_FORM_GNU_str_index";
224 case DW_FORM_GNU_ref_alt:return "DW_FORM_GNU_ref_alt";
225 case DW_FORM_GNU_strp_alt:return "DW_FORM_GNU_strp_alt";
226 }
227 return "DW_FORM_???";
228 }
229
230 const HChar* ML_(pp_DW_AT) ( DW_AT attr )
231 {
232 switch (attr) {
233 case DW_AT_sibling: return "DW_AT_sibling";
234 case DW_AT_location: return "DW_AT_location";
235 case DW_AT_name: return "DW_AT_name";
236 case DW_AT_ordering: return "DW_AT_ordering";
237 case DW_AT_subscr_data: return "DW_AT_subscr_data";
238 case DW_AT_byte_size: return "DW_AT_byte_size";
239 case DW_AT_bit_offset: return "DW_AT_bit_offset";
240 case DW_AT_bit_size: return "DW_AT_bit_size";
241 case DW_AT_element_list: return "DW_AT_element_list";
242 case DW_AT_stmt_list: return "DW_AT_stmt_list";
243 case DW_AT_low_pc: return "DW_AT_low_pc";
244 case DW_AT_high_pc: return "DW_AT_high_pc";
245 case DW_AT_language: return "DW_AT_language";
246 case DW_AT_member: return "DW_AT_member";
247 case DW_AT_discr: return "DW_AT_discr";
248 case DW_AT_discr_value: return "DW_AT_discr_value";
249 case DW_AT_visibility: return "DW_AT_visibility";
250 case DW_AT_import: return "DW_AT_import";
251 case DW_AT_string_length: return "DW_AT_string_length";
252 case DW_AT_common_reference: return "DW_AT_common_reference";
253 case DW_AT_comp_dir: return "DW_AT_comp_dir";
254 case DW_AT_const_value: return "DW_AT_const_value";
255 case DW_AT_containing_type: return "DW_AT_containing_type";
256 case DW_AT_default_value: return "DW_AT_default_value";
257 case DW_AT_inline: return "DW_AT_inline";
258 case DW_AT_is_optional: return "DW_AT_is_optional";
259 case DW_AT_lower_bound: return "DW_AT_lower_bound";
260 case DW_AT_producer: return "DW_AT_producer";
261 case DW_AT_prototyped: return "DW_AT_prototyped";
262 case DW_AT_return_addr: return "DW_AT_return_addr";
263 case DW_AT_start_scope: return "DW_AT_start_scope";
264 case DW_AT_stride_size: return "DW_AT_stride_size";
265 case DW_AT_upper_bound: return "DW_AT_upper_bound";
266 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
267 case DW_AT_accessibility: return "DW_AT_accessibility";
268 case DW_AT_address_class: return "DW_AT_address_class";
269 case DW_AT_artificial: return "DW_AT_artificial";
270 case DW_AT_base_types: return "DW_AT_base_types";
271 case DW_AT_calling_convention: return "DW_AT_calling_convention";
272 case DW_AT_count: return "DW_AT_count";
273 case DW_AT_data_member_location: return "DW_AT_data_member_location";
274 case DW_AT_decl_column: return "DW_AT_decl_column";
275 case DW_AT_decl_file: return "DW_AT_decl_file";
276 case DW_AT_decl_line: return "DW_AT_decl_line";
277 case DW_AT_declaration: return "DW_AT_declaration";
278 case DW_AT_discr_list: return "DW_AT_discr_list";
279 case DW_AT_encoding: return "DW_AT_encoding";
280 case DW_AT_external: return "DW_AT_external";
281 case DW_AT_frame_base: return "DW_AT_frame_base";
282 case DW_AT_friend: return "DW_AT_friend";
283 case DW_AT_identifier_case: return "DW_AT_identifier_case";
284 case DW_AT_macro_info: return "DW_AT_macro_info";
285 case DW_AT_namelist_items: return "DW_AT_namelist_items";
286 case DW_AT_priority: return "DW_AT_priority";
287 case DW_AT_segment: return "DW_AT_segment";
288 case DW_AT_specification: return "DW_AT_specification";
289 case DW_AT_static_link: return "DW_AT_static_link";
290 case DW_AT_type: return "DW_AT_type";
291 case DW_AT_use_location: return "DW_AT_use_location";
292 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
293 case DW_AT_virtuality: return "DW_AT_virtuality";
294 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
295 /* DWARF 3 values. */
296 case DW_AT_allocated: return "DW_AT_allocated";
297 case DW_AT_associated: return "DW_AT_associated";
298 case DW_AT_data_location: return "DW_AT_data_location";
299 case DW_AT_stride: return "DW_AT_stride";
300 case DW_AT_entry_pc: return "DW_AT_entry_pc";
301 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
302 case DW_AT_extension: return "DW_AT_extension";
303 case DW_AT_ranges: return "DW_AT_ranges";
304 case DW_AT_trampoline: return "DW_AT_trampoline";
305 case DW_AT_call_column: return "DW_AT_call_column";
306 case DW_AT_call_file: return "DW_AT_call_file";
307 case DW_AT_call_line: return "DW_AT_call_line";
308 case DW_AT_description: return "DW_AT_description";
309 case DW_AT_binary_scale: return "DW_AT_binary_scale";
310 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
311 case DW_AT_small: return "DW_AT_small";
312 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
313 case DW_AT_digit_count: return "DW_AT_digit_count";
314 case DW_AT_picture_string: return "DW_AT_picture_string";
315 case DW_AT_mutable: return "DW_AT_mutable";
316 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
317 case DW_AT_explicit: return "DW_AT_explicit";
318 case DW_AT_object_pointer: return "DW_AT_object_pointer";
319 case DW_AT_endianity: return "DW_AT_endianity";
320 case DW_AT_elemental: return "DW_AT_elemental";
321 case DW_AT_pure: return "DW_AT_pure";
322 case DW_AT_recursive: return "DW_AT_recursive";
323 /* DWARF 4 values. */
324 case DW_AT_signature: return "DW_AT_signature";
325 case DW_AT_main_subprogram: return "DW_AT_main_subprogram";
326 case DW_AT_data_bit_offset: return "DW_AT_data_bit_offset";
327 case DW_AT_const_expr: return "DW_AT_const_expr";
328 case DW_AT_enum_class: return "DW_AT_enum_class";
329 case DW_AT_linkage_name: return "DW_AT_linkage_name";
330 /* DWARF 5 values. */
331 case DW_AT_string_length_bit_size: return "DW_AT_string_length_bit_size";
332 case DW_AT_string_length_byte_size: return "DW_AT_string_length_byte_size";
333 case DW_AT_rank: return "DW_AT_rank";
334 case DW_AT_str_offsets_base: return "DW_AT_str_offsets_base";
335 case DW_AT_addr_base: return "DW_AT_addr_base";
336 case DW_AT_rnglists_base: return "DW_AT_rnglists_base";
337 case DW_AT_dwo_name: return "DW_AT_dwo_name";
338 case DW_AT_reference: return "DW_AT_reference";
339 case DW_AT_rvalue_reference: return "DW_AT_rvalue_reference";
340 case DW_AT_macros: return "DW_AT_macros";
341 case DW_AT_call_all_calls: return "DW_AT_call_all_calls";
342 case DW_AT_call_all_source_calls: return "DW_AT_call_all_source_calls";
343 case DW_AT_call_all_tail_calls: return "DW_AT_call_all_tail_calls";
344 case DW_AT_call_return_pc: return "DW_AT_call_return_pc";
345 case DW_AT_call_value: return "DW_AT_call_value";
346 case DW_AT_call_origin: return "DW_AT_call_origin";
347 case DW_AT_call_parameter: return "DW_AT_call_parameter";
348 case DW_AT_call_pc: return "DW_AT_call_pc";
349 case DW_AT_call_tail_call: return "DW_AT_call_tail_call";
350 case DW_AT_call_target: return "DW_AT_call_target";
351 case DW_AT_call_target_clobbered: return "DW_AT_call_target_clobbered";
352 case DW_AT_call_data_location: return "DW_AT_call_data_location";
353 case DW_AT_call_data_value: return "DW_AT_call_data_value";
354 case DW_AT_noreturn: return "DW_AT_noreturn";
355 case DW_AT_alignment: return "DW_AT_alignment";
356 case DW_AT_export_symbols: return "DW_AT_export_symbols";
357 case DW_AT_deleted: return "DW_AT_deleted";
358 case DW_AT_defaulted: return "DW_AT_defaulted";
359 case DW_AT_loclists_base: return "DW_AT_loclists_base";
360 /* SGI/MIPS extensions. */
361 /* case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde"; */
362 /* DW_AT_MIPS_fde == DW_AT_HP_unmodifiable */
363 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
364 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
365 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
366 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
367 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
368 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
369 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
370 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
371 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
372 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
373 /* HP extensions. */
374 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
375 case DW_AT_HP_unmodifiable: return "DW_AT_HP_unmodifiable";
376 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
377 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
378 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
379 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
380 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
381 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
382 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
383 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
384 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
385 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
386 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
387 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
388 /* GNU extensions. */
389 case DW_AT_sf_names: return "DW_AT_sf_names";
390 case DW_AT_src_info: return "DW_AT_src_info";
391 case DW_AT_mac_info: return "DW_AT_mac_info";
392 case DW_AT_src_coords: return "DW_AT_src_coords";
393 case DW_AT_body_begin: return "DW_AT_body_begin";
394 case DW_AT_body_end: return "DW_AT_body_end";
395 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
396 case DW_AT_GNU_guarded_by: return "DW_AT_GNU_guarded_by";
397 case DW_AT_GNU_pt_guarded_by: return "DW_AT_GNU_pt_guarded_by";
398 case DW_AT_GNU_guarded: return "DW_AT_GNU_guarded";
399 case DW_AT_GNU_pt_guarded: return "DW_AT_GNU_pt_guarded";
400 case DW_AT_GNU_locks_excluded: return "DW_AT_GNU_locks_excluded";
401 case DW_AT_GNU_exclusive_locks_required: return "DW_AT_GNU_exclusive_locks_required";
402 case DW_AT_GNU_shared_locks_required: return "DW_AT_GNU_shared_locks_required";
403 case DW_AT_GNU_odr_signature: return "DW_AT_GNU_odr_signature";
404 case DW_AT_GNU_template_name: return "DW_AT_GNU_template_name";
405 case DW_AT_GNU_call_site_value: return "DW_AT_GNU_call_site_value";
406 case DW_AT_GNU_call_site_data_value: return "DW_AT_GNU_call_site_data_value";
407 case DW_AT_GNU_call_site_target: return "DW_AT_GNU_call_site_target";
408 case DW_AT_GNU_call_site_target_clobbered: return "DW_AT_GNU_call_site_target_clobbered";
409 case DW_AT_GNU_tail_call: return "DW_AT_GNU_tail_call";
410 case DW_AT_GNU_all_tail_call_sites: return "DW_AT_GNU_all_tail_call_sites";
411 case DW_AT_GNU_all_call_sites: return "DW_AT_GNU_all_call_sites";
412 case DW_AT_GNU_all_source_call_sites: return "DW_AT_GNU_all_source_call_sites";
413 case DW_AT_GNU_locviews: return "DW_AT_GNU_locviews";
414 case DW_AT_GNU_entry_view: return "DW_AT_GNU_entry_view";
415 case DW_AT_GNU_macros: return "DW_AT_GNU_macros";
416 case DW_AT_GNU_deleted: return "DW_AT_GNU_deleted";
417 case DW_AT_GNU_dwo_name: return "DW_AT_GNU_dwo_name";
418 case DW_AT_GNU_dwo_id: return "DW_AT_GNU_dwo_id";
419 case DW_AT_GNU_ranges_base: return "DW_AT_GNU_ranges_base";
420 case DW_AT_GNU_addr_base: return "DW_AT_GNU_addr_base";
421 case DW_AT_GNU_pubnames: return "DW_AT_GNU_pubnames";
422 case DW_AT_GNU_pubtypes: return "DW_AT_GNU_pubtypes";
423 case DW_AT_GNU_numerator: return "DW_AT_GNU_numerator";
424 case DW_AT_GNU_denominator: return "DW_AT_GNU_denominator";
425 case DW_AT_GNU_bias: return "DW_AT_GNU_bias";
426 /* VMS extensions. */
427 case DW_AT_VMS_rtnbeg_pd_address: return "DW_AT_VMS_rtnbeg_pd_address";
428 /* UPC extension. */
429 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
430 /* PGI (STMicroelectronics) extensions. */
431 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
432 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
433 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
434 }
435 return "DW_AT_???";
436 }
437
438
439 /* ------ To do with evaluation of Dwarf expressions ------ */
440
441 /* FIXME: duplicated in readdwarf.c */
442 static
443 ULong read_leb128 ( const UChar* data, Int* length_return, Int sign )
444 {
445 ULong result = 0;
446 UInt num_read = 0;
447 Int shift = 0;
448 UChar byte;
449
450 vg_assert(sign == 0 || sign == 1);
451
452 do
453 {
454 byte = * data ++;
455 num_read ++;
456
457 result |= ((ULong)(byte & 0x7f)) << shift;
458
459 shift += 7;
460
461 }
462 while (byte & 0x80);
463
464 if (length_return != NULL)
465 * length_return = num_read;
466
467 if (sign && (shift < 64) && (byte & 0x40))
468 result |= -(1ULL << shift);
469
470 return result;
471 }
472
473 /* Small helper functions easier to use
474 * value is returned and the given pointer is
475 * moved past end of leb128 data */
476 /* FIXME: duplicated in readdwarf.c */
477 static ULong read_leb128U( const UChar **data )
478 {
479 Int len;
480 ULong val = read_leb128( *data, &len, 0 );
481 *data += len;
482 return val;
483 }
484
485 /* Same for signed data */
486 /* FIXME: duplicated in readdwarf.c */
487 static Long read_leb128S( const UChar **data )
488 {
489 Int len;
490 ULong val = read_leb128( *data, &len, 1 );
491 *data += len;
492 return (Long)val;
493 }
494
495 /* FIXME: duplicates logic in readdwarf.c: copy_convert_CfiExpr_tree
496 and {FP,SP}_REG decls */
497 static Bool get_Dwarf_Reg( /*OUT*/Addr* a, Word regno, const RegSummary* regs )
498 {
499 vg_assert(regs);
500 # if defined(VGP_x86_linux) || defined(VGP_x86_darwin) \
501 || defined(VGP_x86_solaris)
502 if (regno == 5/*EBP*/) { *a = regs->fp; return True; }
503 if (regno == 4/*ESP*/) { *a = regs->sp; return True; }
504 # elif defined(VGP_amd64_linux) || defined(VGP_amd64_darwin) \
505 || defined(VGP_amd64_solaris)
506 if (regno == 6/*RBP*/) { *a = regs->fp; return True; }
507 if (regno == 7/*RSP*/) { *a = regs->sp; return True; }
508 # elif defined(VGP_ppc32_linux)
509 if (regno == 1/*SP*/) { *a = regs->sp; return True; }
510 # elif defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
511 if (regno == 1/*SP*/) { *a = regs->sp; return True; }
512 # elif defined(VGP_arm_linux)
513 if (regno == 13) { *a = regs->sp; return True; }
514 if (regno == 11) { *a = regs->fp; return True; }
515 # elif defined(VGP_s390x_linux)
516 if (regno == 15) { *a = regs->sp; return True; }
517 if (regno == 11) { *a = regs->fp; return True; }
518 # elif defined(VGP_mips32_linux) || defined(VGP_nanomips_linux)
519 if (regno == 29) { *a = regs->sp; return True; }
520 if (regno == 30) { *a = regs->fp; return True; }
521 # elif defined(VGP_mips64_linux)
522 if (regno == 29) { *a = regs->sp; return True; }
523 if (regno == 30) { *a = regs->fp; return True; }
524 # elif defined(VGP_arm64_linux)
525 if (regno == 31) { *a = regs->sp; return True; }
526 if (regno == 29) { *a = regs->fp; return True; }
527 # else
528 # error "Unknown platform"
529 # endif
530 return False;
531 }
532
533 /* Convert a stated address to an actual address */
534 static Bool bias_address( Addr* a, const DebugInfo* di )
535 {
536 if (di->text_present
537 && di->text_size > 0
538 && *a >= di->text_debug_svma && *a < di->text_debug_svma + di->text_size) {
539 *a += di->text_debug_bias;
540 }
541 else if (di->data_present
542 && di->data_size > 0
543 && *a >= di->data_debug_svma && *a < di->data_debug_svma + di->data_size) {
544 *a += di->data_debug_bias;
545 }
546 else if (di->sdata_present
547 && di->sdata_size > 0
548 && *a >= di->sdata_debug_svma && *a < di->sdata_debug_svma + di->sdata_size) {
549 *a += di->sdata_debug_bias;
550 }
551 else if (di->rodata_present
552 && di->rodata_size > 0
553 && *a >= di->rodata_debug_svma && *a < di->rodata_debug_svma + di->rodata_size) {
554 *a += di->rodata_debug_bias;
555 }
556 else if (di->bss_present
557 && di->bss_size > 0
558 && *a >= di->bss_debug_svma && *a < di->bss_debug_svma + di->bss_size) {
559 *a += di->bss_debug_bias;
560 }
561 else if (di->sbss_present
562 && di->sbss_size > 0
563 && *a >= di->sbss_debug_svma && *a < di->sbss_debug_svma + di->sbss_size) {
564 *a += di->sbss_debug_bias;
565 }
566 else {
567 return False;
568 }
569
570 return True;
571 }
572
573
574 /* Evaluate a standard DWARF3 expression. See detailed description in
575 priv_d3basics.h. Doesn't handle DW_OP_piece/DW_OP_bit_piece yet. */
576 GXResult ML_(evaluate_Dwarf3_Expr) ( const UChar* expr, UWord exprszB,
577 const GExpr* fbGX, const RegSummary* regs,
578 const DebugInfo* di,
579 Bool push_initial_zero )
580 {
581 # define N_EXPR_STACK 20
582
583 # define FAIL(_str) \
584 do { \
585 res.kind = GXR_Failure; \
586 res.word = (UWord)(_str); \
587 return res; \
588 } while (0)
589
590 # define PUSH(_arg) \
591 do { \
592 vg_assert(sp >= -1 && sp < N_EXPR_STACK); \
593 if (sp == N_EXPR_STACK-1) \
594 FAIL("evaluate_Dwarf3_Expr: stack overflow(1)"); \
595 sp++; \
596 stack[sp] = (_arg); \
597 } while (0)
598
599 # define POP(_lval) \
600 do { \
601 vg_assert(sp >= -1 && sp < N_EXPR_STACK); \
602 if (sp == -1) \
603 FAIL("evaluate_Dwarf3_Expr: stack underflow(1)"); \
604 _lval = stack[sp]; \
605 sp--; \
606 } while (0)
607
608 UChar opcode;
609 const UChar* limit;
610 Int sp; /* # of top element: valid is -1 .. N_EXPR_STACK-1 */
611 Addr stack[N_EXPR_STACK]; /* stack of addresses, as per D3 spec */
612 GXResult fbval, res;
613 Addr a1;
614 Word sw1, sw2;
615 UWord uw1, uw2;
616 Bool ok;
617
618 sp = -1;
619 vg_assert(expr);
620 vg_assert(exprszB >= 0);
621 limit = expr + exprszB;
622
623 /* Deal with the case where the entire expression is a single
624 Register Name Operation (D3 spec sec 2.6.1). Then the
625 denotation of the expression as a whole is a register name. */
626 if (exprszB == 1
627 && expr[0] >= DW_OP_reg0 && expr[0] <= DW_OP_reg31) {
628 res.kind = GXR_RegNo;
629 res.word = (UWord)(expr[0] - DW_OP_reg0);
630 return res;
631 }
632 if (exprszB > 1
633 && expr[0] == DW_OP_regx) {
634 /* JRS: 2008Feb20: I believe the following is correct, but would
635 like to see a test case show up before enabling it. */
636 expr++;
637 res.kind = GXR_RegNo;
638 res.word = (UWord)read_leb128U( &expr );
639 if (expr != limit)
640 FAIL("evaluate_Dwarf3_Expr: DW_OP_regx*: invalid expr size");
641 else
642 return res;
643 /*NOTREACHED*/
644 }
645
646 /* Evidently this expression denotes a value, not a register name.
647 So evaluate it accordingly. */
648
649 if (push_initial_zero)
650 PUSH(0);
651
652 while (True) {
653
654 vg_assert(sp >= -1 && sp < N_EXPR_STACK);
655
656 if (expr > limit)
657 /* overrun - something's wrong */
658 FAIL("evaluate_Dwarf3_Expr: ran off end of expr");
659
660 if (expr == limit) {
661 /* end of expr - return expr on the top of stack. */
662 if (sp == -1)
663 /* stack empty. Bad. */
664 FAIL("evaluate_Dwarf3_Expr: stack empty at end of expr");
665 else
666 break;
667 }
668
669 opcode = *expr++;
670 switch (opcode) {
671 case DW_OP_addr:
672 /* Presumably what is given in the Dwarf3 is a SVMA (how
673 could it be otherwise?) So we add the appropriate bias
674 on before pushing the result. */
675 a1 = ML_(read_Addr)(expr);
676 if (bias_address(&a1, di)) {
677 PUSH( a1 );
678 expr += sizeof(Addr);
679 }
680 else {
681 FAIL("evaluate_Dwarf3_Expr: DW_OP_addr with address "
682 "in unknown section");
683 }
684 break;
685 case DW_OP_fbreg:
686 if (!fbGX)
687 FAIL("evaluate_Dwarf3_Expr: DW_OP_fbreg with "
688 "no expr for fbreg present");
689 fbval = ML_(evaluate_GX)(fbGX, NULL, regs, di);
690 /* Convert fbval into something we can use. If we got a
691 Value, no problem. However, as per D3 spec sec 3.3.5
692 (Low Level Information) sec 2, we could also get a
693 RegNo, and that is taken to mean the value in the
694 indicated register. So we have to manually
695 "dereference" it. */
696 a1 = 0;
697 switch (fbval.kind) {
698 case GXR_Failure:
699 return fbval; /* propagate failure */
700 case GXR_Addr:
701 a1 = fbval.word; break; /* use as-is */
702 case GXR_RegNo:
703 ok = get_Dwarf_Reg( &a1, fbval.word, regs );
704 if (!ok) return fbval; /* propagate failure */
705 break;
706 case GXR_Value:
707 FAIL("evaluate_Dwarf3_Expr: DW_OP_{implicit,stack}_value "
708 "in DW_AT_frame_base");
709 default:
710 vg_assert(0);
711 }
712 sw1 = (Word)read_leb128S( &expr );
713 PUSH( a1 + sw1 );
714 break;
715 /* DW_OP_breg* denotes 'contents of specified register, plus
716 constant offset'. So provided we know what the register's
717 value is, we can evaluate this. Contrast DW_OP_reg*,
718 which indicates that denoted location is in a register
719 itself. If DW_OP_reg* shows up here the expression is
720 malformed, since we are evaluating for value now, and
721 DW_OP_reg* denotes a register location, not a value. See
722 D3 Spec sec 2.6.1 ("Register Name Operations") for
723 details. */
724 case DW_OP_breg0 ... DW_OP_breg31:
725 if (!regs)
726 FAIL("evaluate_Dwarf3_Expr: DW_OP_breg* but no reg info");
727 a1 = 0;
728 if (!get_Dwarf_Reg( &a1, opcode - DW_OP_breg0, regs ))
729 FAIL("evaluate_Dwarf3_Expr: unhandled DW_OP_breg*");
730 sw1 = (Word)read_leb128S( &expr );
731 a1 += sw1;
732 PUSH( a1 );
733 break;
734 case DW_OP_bregx:
735 if (!regs)
736 FAIL("evaluate_Dwarf3_Expr: DW_OP_bregx but no reg info");
737 a1 = 0;
738 uw1 = (UWord)read_leb128U( &expr );
739 if (!get_Dwarf_Reg( &a1, uw1, regs ))
740 FAIL("evaluate_Dwarf3_Expr: unhandled DW_OP_bregx reg value");
741 sw1 = (Word)read_leb128S( &expr );
742 a1 += sw1;
743 PUSH( a1 );
744 break;
745 /* As per comment on DW_OP_breg*, the following denote that
746 the value in question is in a register, not in memory. So
747 we simply return failure. (iow, the expression is
748 malformed). */
749 case DW_OP_reg0 ... DW_OP_reg31:
750 case DW_OP_regx:
751 FAIL("evaluate_Dwarf3_Expr: DW_OP_reg* "
752 "whilst evaluating for a value");
753 break;
754 case DW_OP_plus_uconst:
755 POP(uw1);
756 uw1 += (UWord)read_leb128U( &expr );
757 PUSH(uw1);
758 break;
759 case DW_OP_GNU_push_tls_address:
760 /* GDB contains the following cryptic comment: */
761 /* Variable is at a constant offset in the thread-local
762 storage block into the objfile for the current thread and
763 the dynamic linker module containing this expression. Here
764 we return returns the offset from that base. The top of the
765 stack has the offset from the beginning of the thread
766 control block at which the variable is located. Nothing
767 should follow this operator, so the top of stack would be
768 returned. */
769 /* But no spec resulting from Googling. Punt for now. */
770 FAIL("warning: evaluate_Dwarf3_Expr: unhandled "
771 "DW_OP_GNU_push_tls_address");
772 /*NOTREACHED*/
773 case DW_OP_deref:
774 POP(uw1);
775 if (VG_(am_is_valid_for_client)( (Addr)uw1, sizeof(Addr),
776 VKI_PROT_READ )) {
777 uw1 = ML_(read_UWord)((void *)uw1);
778 PUSH(uw1);
779 } else {
780 FAIL("warning: evaluate_Dwarf3_Expr: DW_OP_deref: "
781 "address not valid for client");
782 }
783 break;
784 case DW_OP_deref_size:
785 POP(uw1);
786 uw2 = *expr++;
787 if (VG_(am_is_valid_for_client)( (Addr)uw1, uw2,
788 VKI_PROT_READ )) {
789 switch (uw2) {
790 case 1: uw1 = ML_(read_UChar)((void*)uw1); break;
791 case 2: uw1 = ML_(read_UShort)((void*)uw1); break;
792 case 4: uw1 = ML_(read_UInt)((void*)uw1); break;
793 case 8: uw1 = ML_(read_ULong)((void*)uw1); break;
794 default:
795 FAIL("warning: evaluate_Dwarf3_Expr: unhandled "
796 "DW_OP_deref_size size");
797 }
798 PUSH(uw1);
799 } else {
800 FAIL("warning: evaluate_Dwarf3_Expr: DW_OP_deref_size: "
801 "address not valid for client");
802 }
803 break;
804 case DW_OP_lit0 ... DW_OP_lit31:
805 PUSH(opcode - DW_OP_lit0);
806 break;
807 case DW_OP_const1u:
808 uw1 = *expr++;
809 PUSH(uw1);
810 break;
811 case DW_OP_const2u:
812 uw1 = ML_(read_UShort)(expr);
813 expr += 2;
814 PUSH(uw1);
815 break;
816 case DW_OP_const4u:
817 uw1 = ML_(read_UInt)(expr);
818 expr += 4;
819 PUSH(uw1);
820 break;
821 case DW_OP_const8u:
822 uw1 = ML_(read_ULong)(expr);
823 expr += 8;
824 PUSH(uw1);
825 break;
826 case DW_OP_constu:
827 uw1 = read_leb128U( &expr );
828 PUSH(uw1);
829 break;
830 case DW_OP_const1s:
831 uw1 = *(const Char *)expr;
832 expr++;
833 PUSH(uw1);
834 break;
835 case DW_OP_const2s:
836 uw1 = ML_(read_Short)(expr);
837 expr += 2;
838 PUSH(uw1);
839 break;
840 case DW_OP_const4s:
841 uw1 = ML_(read_Int)(expr);
842 expr += 4;
843 PUSH(uw1);
844 break;
845 case DW_OP_const8s:
846 uw1 = ML_(read_Long)(expr);
847 expr += 8;
848 PUSH(uw1);
849 break;
850 case DW_OP_consts:
851 uw1 = read_leb128S( &expr );
852 PUSH(uw1);
853 break;
854 case DW_OP_dup:
855 POP(uw1);
856 PUSH(uw1);
857 PUSH(uw1);
858 break;
859 case DW_OP_drop:
860 POP(uw1);
861 break;
862 case DW_OP_over:
863 uw1 = 1;
864 goto do_pick;
865 case DW_OP_pick:
866 uw1 = *expr++;
867 do_pick:
868 if (sp < (Int)uw1)
869 FAIL("evaluate_Dwarf3_Expr: stack underflow");
870 uw1 = stack[sp - uw1];
871 PUSH(uw1);
872 break;
873 case DW_OP_swap:
874 if (sp < 1)
875 FAIL("evaluate_Dwarf3_Expr: stack underflow");
876 uw1 = stack[sp];
877 stack[sp] = stack[sp - 1];
878 stack[sp - 1] = uw1;
879 break;
880 case DW_OP_rot:
881 if (sp < 2)
882 FAIL("evaluate_Dwarf3_Expr: stack underflow");
883 uw1 = stack[sp];
884 stack[sp] = stack[sp - 1];
885 stack[sp - 1] = stack[sp - 2];
886 stack[sp - 2] = uw1;
887 break;
888 case DW_OP_abs:
889 POP(sw1);
890 if (sw1 < 0)
891 sw1 = -sw1;
892 PUSH(sw1);
893 break;
894 case DW_OP_div:
895 POP(sw2);
896 if (sw2 == 0)
897 FAIL("evaluate_Dwarf3_Expr: division by zero");
898 POP(sw1);
899 sw1 /= sw2;
900 PUSH(sw1);
901 break;
902 case DW_OP_mod:
903 POP(uw2);
904 if (uw2 == 0)
905 FAIL("evaluate_Dwarf3_Expr: division by zero");
906 POP(uw1);
907 uw1 %= uw2;
908 PUSH(uw1);
909 break;
910 #define BINARY(name, op, s) \
911 case DW_OP_##name: \
912 POP(s##w2); \
913 POP(s##w1); \
914 s##w1 = s##w1 op s##w2; \
915 PUSH(s##w1); \
916 break
917 #define UNARY(name, op, s) \
918 case DW_OP_##name: \
919 POP(s##w1); \
920 s##w1 = op s##w1; \
921 PUSH(s##w1); \
922 break
923 BINARY (and, &, u);
924 BINARY (minus, -, u);
925 BINARY (mul, *, u);
926 UNARY (neg, -, u);
927 UNARY (not, ~, u);
928 BINARY (or, |, u);
929 BINARY (plus, +, u);
930 BINARY (shl, <<, u);
931 BINARY (shr, >>, u);
932 BINARY (shra, >>, s);
933 BINARY (xor, ^, u);
934 BINARY (le, <=, s);
935 BINARY (lt, <, s);
936 BINARY (ge, >=, s);
937 BINARY (gt, >, s);
938 BINARY (ne, !=, u);
939 BINARY (eq, ==, u);
940 #undef UNARY
941 #undef BINARY
942 case DW_OP_skip:
943 sw1 = ML_(read_Short)(expr);
944 expr += 2;
945 if (expr + sw1 < limit - exprszB)
946 FAIL("evaluate_Dwarf3_Expr: DW_OP_skip before start of expr");
947 if (expr + sw1 >= limit)
948 FAIL("evaluate_Dwarf3_Expr: DW_OP_skip after end of expr");
949 expr += sw1;
950 break;
951 case DW_OP_bra:
952 sw1 = ML_(read_Short)(expr);
953 expr += 2;
954 if (expr + sw1 < limit - exprszB)
955 FAIL("evaluate_Dwarf3_Expr: DW_OP_bra before start of expr");
956 if (expr + sw1 >= limit)
957 FAIL("evaluate_Dwarf3_Expr: DW_OP_bra after end of expr");
958 POP(uw1);
959 if (uw1)
960 expr += sw1;
961 break;
962 case DW_OP_nop:
963 break;
964 case DW_OP_call_frame_cfa:
965 if (!regs)
966 FAIL("evaluate_Dwarf3_Expr: "
967 "DW_OP_call_frame_cfa but no reg info");
968 #if defined(VGP_ppc32_linux) || defined(VGP_ppc64be_linux) \
969 || defined(VGP_ppc64le_linux)
970 /* Valgrind on ppc32/ppc64 currently doesn't use unwind info. */
971 uw1 = ML_(read_Addr)((UChar*)regs->sp);
972 #else
973 uw1 = ML_(get_CFA)(regs->ip, regs->sp, regs->fp, 0, ~(UWord) 0);
974 #endif
975 /* we expect this to fail on arm-linux, since ML_(get_CFA)
976 always returns zero at present. */
977 if (!uw1)
978 FAIL("evaluate_Dwarf3_Expr: Could not resolve "
979 "DW_OP_call_frame_cfa");
980 PUSH(uw1);
981 break;
982 case DW_OP_implicit_value:
983 sw1 = (Word)read_leb128S( &expr );
984 uw1 = 0;
985 switch (sw1) {
986 case 1:
987 uw1 = ML_(read_UChar)(expr);
988 expr += 1;
989 break;
990 case 2:
991 uw1 = ML_(read_UShort)(expr);
992 expr += 2;
993 break;
994 case 4:
995 uw1 = ML_(read_UInt)(expr);
996 expr += 4;
997 break;
998 case 8:
999 uw1 = ML_(read_ULong)(expr);
1000 expr += 8;
1001 break;
1002 default:
1003 FAIL("evaluate_Dwarf3_Expr: Unhandled "
1004 "DW_OP_implicit_value size");
1005 }
1006 if (expr != limit)
1007 FAIL("evaluate_Dwarf3_Expr: DW_OP_implicit_value "
1008 "does not terminate expression");
1009 res.word = uw1;
1010 res.kind = GXR_Value;
1011 return res;
1012 case DW_OP_stack_value:
1013 POP (uw1);
1014 res.word = uw1;
1015 res.kind = GXR_Value;
1016 if (expr != limit)
1017 FAIL("evaluate_Dwarf3_Expr: DW_OP_stack_value "
1018 "does not terminate expression");
1019 break;
1020 default:
1021 if (!VG_(clo_xml))
1022 VG_(message)(Vg_DebugMsg,
1023 "warning: evaluate_Dwarf3_Expr: unhandled "
1024 "DW_OP_ 0x%x\n", (Int)opcode);
1025 FAIL("evaluate_Dwarf3_Expr: unhandled DW_OP_");
1026 /*NOTREACHED*/
1027 }
1028
1029 }
1030
1031 vg_assert(sp >= 0 && sp < N_EXPR_STACK);
1032 res.word = stack[sp];
1033 res.kind = GXR_Addr;
1034 return res;
1035
1036 # undef POP
1037 # undef PUSH
1038 # undef FAIL
1039 # undef N_EXPR_STACK
1040 }
1041
1042
1043 /* Evaluate a so-called Guarded (DWARF3) expression. See detailed
1044 description in priv_d3basics.h. */
1045 GXResult ML_(evaluate_GX)( const GExpr* gx, const GExpr* fbGX,
1046 const RegSummary* regs, const DebugInfo* di )
1047 {
1048 GXResult res;
1049 Addr aMin, aMax;
1050 UChar uc;
1051 UShort nbytes;
1052 UWord nGuards = 0;
1053 const UChar* p = &gx->payload[0];
1054 uc = *p++; /*biasMe*/
1055 vg_assert(uc == 0 || uc == 1);
1056 /* in fact it's senseless to evaluate if the guards need biasing.
1057 So don't. */
1058 vg_assert(uc == 0);
1059 while (True) {
1060 uc = *p++;
1061 if (uc == 1) { /*isEnd*/
1062 /* didn't find any matching range. */
1063 res.kind = GXR_Failure;
1064 res.word = (UWord)"no matching range";
1065 return res;
1066 }
1067 vg_assert(uc == 0);
1068 aMin = ML_(read_Addr)(p); p += sizeof(Addr);
1069 aMax = ML_(read_Addr)(p); p += sizeof(Addr);
1070 nbytes = ML_(read_UShort)(p); p += sizeof(UShort);
1071 nGuards++;
1072 if (0) VG_(printf)(" guard %lu: %#lx %#lx\n",
1073 nGuards, aMin,aMax);
1074 if (regs == NULL) {
1075 vg_assert(aMin == (Addr)0);
1076 vg_assert(aMax == ~(Addr)0);
1077 /* Assert this is the first guard. */
1078 vg_assert(nGuards == 1);
1079 res = ML_(evaluate_Dwarf3_Expr)(
1080 p, (UWord)nbytes, fbGX, regs, di,
1081 False/*push_initial_zero*/ );
1082 /* Now check there are no more guards. */
1083 p += (UWord)nbytes;
1084 vg_assert(*p == 1); /*isEnd*/
1085 return res;
1086 } else {
1087 if (aMin <= regs->ip && regs->ip <= aMax) {
1088 /* found a matching range. Evaluate the expression. */
1089 return ML_(evaluate_Dwarf3_Expr)(
1090 p, (UWord)nbytes, fbGX, regs, di,
1091 False/*push_initial_zero*/ );
1092 }
1093 }
1094 /* else keep searching */
1095 p += (UWord)nbytes;
1096 }
1097 }
1098
1099
1100 /* Evaluate a very simple Guarded (DWARF3) expression. The expression
1101 is expected to denote a constant, with no reference to any
1102 registers nor to any frame base expression. The expression is
1103 expected to have at least one guard. If there is more than one
1104 guard, all the sub-expressions are evaluated and compared. The
1105 address ranges on the guards are ignored. GXR_Failure is returned
1106 in the following circumstances:
1107 * no guards
1108 * any of the subexpressions require a frame base expression
1109 * any of the subexpressions denote a register location
1110 * any of the subexpressions do not produce a manifest constant
1111 * there's more than one subexpression, all of which successfully
1112 evaluate to a constant, but they don't all produce the same constant.
1113 JRS 23Jan09: the special-casing in this function is a nasty kludge.
1114 Really it ought to be pulled out and turned into a general
1115 constant- expression evaluator.
1116 */
1117 GXResult ML_(evaluate_trivial_GX)( const GExpr* gx, const DebugInfo* di )
1118 {
1119 GXResult res;
1120 Addr aMin, aMax;
1121 UChar uc;
1122 UShort nbytes;
1123 Word i, nGuards;
1124 MaybeULong *mul, *mul2;
1125
1126 const HChar* badness = NULL;
1127 const UChar* p = &gx->payload[0]; /* must remain unsigned */
1128 XArray* results = VG_(newXA)( ML_(dinfo_zalloc), "di.d3basics.etG.1",
1129 ML_(dinfo_free),
1130 sizeof(MaybeULong) );
1131
1132 uc = *p++; /*biasMe*/
1133 vg_assert(uc == 0 || uc == 1);
1134 /* in fact it's senseless to evaluate if the guards need biasing.
1135 So don't. */
1136 vg_assert(uc == 0);
1137
1138 nGuards = 0;
1139 while (True) {
1140 MaybeULong thisResult;
1141 uc = *p++;
1142 if (uc == 1) /*isEnd*/
1143 break;
1144 vg_assert(uc == 0);
1145 aMin = ML_(read_Addr)(p); p += sizeof(Addr);
1146 aMax = ML_(read_Addr)(p); p += sizeof(Addr);
1147 nbytes = ML_(read_UShort)(p); p += sizeof(UShort);
1148 nGuards++;
1149 if (0) VG_(printf)(" guard %ld: %#lx %#lx\n",
1150 nGuards, aMin,aMax);
1151
1152 thisResult.b = False;
1153 thisResult.ul = 0;
1154
1155 /* Peer at this particular subexpression, to see if it's
1156 obviously a constant. */
1157 if (nbytes == 1 + sizeof(Addr) && *p == DW_OP_addr) {
1158 /* DW_OP_addr a */
1159 Addr a = ML_(read_Addr)((p+1));
1160 if (bias_address(&a, di)) {
1161 thisResult.b = True;
1162 thisResult.ul = (ULong)a;
1163 } else {
1164 if (!badness)
1165 badness = "trivial GExpr denotes constant address "
1166 "in unknown section (1)";
1167 }
1168 }
1169 else
1170 if (nbytes == 1 + sizeof(Addr) + 1 + 1
1171 /* 11 byte block: 3 c0 b6 2b 0 0 0 0 0 23 4
1172 (DW_OP_addr: 2bb6c0; DW_OP_plus_uconst: 4)
1173 This is really a nasty kludge - only matches if the
1174 trailing ULEB denotes a number in the range 0 .. 127
1175 inclusive. */
1176 && p[0] == DW_OP_addr
1177 && p[1 + sizeof(Addr)] == DW_OP_plus_uconst
1178 && p[1 + sizeof(Addr) + 1] < 0x80 /*1-byte ULEB*/) {
1179 Addr a = ML_(read_Addr)(&p[1]);
1180 if (bias_address(&a, di)) {
1181 thisResult.b = True;
1182 thisResult.ul = (ULong)a + (ULong)p[1 + sizeof(Addr) + 1];
1183 } else {
1184 if (!badness)
1185 badness = "trivial GExpr denotes constant address "
1186 "in unknown section (2)";
1187 }
1188 }
1189 else
1190 if (nbytes == 2 + sizeof(Addr)
1191 && *p == DW_OP_addr
1192 && *(p + 1 + sizeof(Addr)) == DW_OP_GNU_push_tls_address) {
1193 if (!badness)
1194 badness = "trivial GExpr is DW_OP_addr plus trailing junk";
1195 }
1196 else if (nbytes >= 1 && *p >= DW_OP_reg0 && *p <= DW_OP_reg31) {
1197 if (!badness)
1198 badness = "trivial GExpr denotes register (1)";
1199 }
1200 else if (nbytes >= 1 && *p == DW_OP_fbreg) {
1201 if (!badness)
1202 badness = "trivial GExpr requires fbGX";
1203 }
1204 else if (nbytes >= 1 && *p >= DW_OP_breg0 && *p <= DW_OP_breg31) {
1205 if (!badness)
1206 badness = "trivial GExpr requires register value";
1207 }
1208 else if (nbytes >= 1 && *p == DW_OP_regx) {
1209 if (!badness)
1210 badness = "trivial GExpr denotes register (2)";
1211 }
1212 else if (0) {
1213 VG_(printf)(" ML_(evaluate_trivial_GX): unhandled:\n ");
1214 ML_(pp_GX)( gx );
1215 VG_(printf)("\n");
1216 vg_assert(0);
1217 }
1218 else
1219 if (!badness)
1220 badness = "non-trivial GExpr";
1221
1222 VG_(addToXA)( results, &thisResult );
1223
1224 p += (UWord)nbytes;
1225 }
1226
1227 res.kind = GXR_Failure;
1228
1229 vg_assert(nGuards == VG_(sizeXA)( results ));
1230 vg_assert(nGuards >= 0);
1231 if (nGuards == 0) {
1232 vg_assert(!badness);
1233 res.word = (UWord)"trivial GExpr has no guards (!)";
1234 VG_(deleteXA)( results );
1235 return res;
1236 }
1237
1238 for (i = 0; i < nGuards; i++) {
1239 mul = VG_(indexXA)( results, i );
1240 if (mul->b == False)
1241 break;
1242 }
1243
1244 vg_assert(i >= 0 && i <= nGuards);
1245 if (i < nGuards) {
1246 /* at least one subexpression failed to produce a manifest constant. */
1247 vg_assert(badness);
1248 res.word = (UWord)badness;
1249 VG_(deleteXA)( results );
1250 return res;
1251 }
1252
1253 /* All the subexpressions produced a constant, but did they all produce
1254 the same one? */
1255 mul = VG_(indexXA)( results, 0 );
1256 vg_assert(mul->b == True); /* we just established that all exprs are ok */
1257
1258 for (i = 1; i < nGuards; i++) {
1259 mul2 = VG_(indexXA)( results, i );
1260 vg_assert(mul2->b == True);
1261 if (mul2->ul != mul->ul) {
1262 res.word = (UWord)"trivial GExpr: subexpressions disagree";
1263 VG_(deleteXA)( results );
1264 return res;
1265 }
1266 }
1267
1268 /* Well, we have success. All subexpressions evaluated, and
1269 they all agree. Hurrah. */
1270 res.kind = GXR_Addr;
1271 res.word = (UWord)mul->ul; /* NB: narrowing from ULong */
1272 VG_(deleteXA)( results );
1273 return res;
1274 }
1275
1276
1277 void ML_(pp_GXResult) ( GXResult res )
1278 {
1279 switch (res.kind) {
1280 case GXR_Failure:
1281 VG_(printf)("GXR_Failure(%s)", (HChar*)res.word); break;
1282 case GXR_Addr:
1283 VG_(printf)("GXR_Addr(0x%lx)", res.word); break;
1284 case GXR_Value:
1285 VG_(printf)("GXR_Value(0x%lx)", res.word); break;
1286 case GXR_RegNo:
1287 VG_(printf)("GXR_RegNo(%lu)", res.word); break;
1288 default:
1289 VG_(printf)("GXR_???"); break;
1290 }
1291 }
1292
1293
1294 void ML_(pp_GX) ( const GExpr* gx )
1295 {
1296 Addr aMin, aMax;
1297 UChar uc;
1298 UShort nbytes;
1299 const UChar* p = &gx->payload[0];
1300 uc = *p++;
1301 VG_(printf)("GX(%s){", uc == 0 ? "final" : "Breqd" );
1302 vg_assert(uc == 0 || uc == 1);
1303 while (True) {
1304 uc = *p++;
1305 if (uc == 1)
1306 break; /*isEnd*/
1307 vg_assert(uc == 0);
1308 aMin = ML_(read_Addr)(p); p += sizeof(Addr);
1309 aMax = ML_(read_Addr)(p); p += sizeof(Addr);
1310 nbytes = ML_(read_UShort)(p); p += sizeof(UShort);
1311 VG_(printf)("[%#lx,%#lx]=", aMin, aMax);
1312 while (nbytes > 0) {
1313 VG_(printf)("%02x", (UInt)*p++);
1314 nbytes--;
1315 }
1316 if (*p == 0)
1317 VG_(printf)(",");
1318 }
1319 VG_(printf)("}");
1320 }
1321
1322
1323 /*--------------------------------------------------------------------*/
1324 /*--- end d3basics.c ---*/
1325 /*--------------------------------------------------------------------*/
Instrumentation framework for detecting many memory management and threading bugs, and profile your programs in detail.