?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update README.s390
[valgrind.git] / coregrind / m_debuginfo / d3basics.c
blob97ecbdaf4cbfa6dea952361f5620751d2b30ac06
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 const HChar* ML_(pp_DW_LLE) ( DW_LLE entry )
439 {
440 switch (entry) {
441 case DW_LLE_end_of_list: return "DW_LLE_end_of_list";
442 case DW_LLE_base_addressx: return "DW_LLE_base_addressx";
443 case DW_LLE_startx_endx: return "DW_LLE_startx_endx";
444 case DW_LLE_startx_length: return "DW_LLE_startx_length";
445 case DW_LLE_offset_pair: return "DW_LLE_offset_pair";
446 case DW_LLE_default_location: return "DW_LLE_default_location";
447 case DW_LLE_base_address: return "DW_LLE_base_address";
448 case DW_LLE_start_end: return "DW_LLE_start_end";
449 case DW_LLE_start_length: return "DW_LLE_start_length";
450 case DW_LLE_GNU_view_pair: return "DW_LLE_GNU_view_pair";
451 }
452 return "DW_LLE_???";
453 }
454
455 const HChar* ML_(pp_DW_RLE) ( DW_RLE entry )
456 {
457 switch (entry) {
458 case DW_RLE_end_of_list: return "DW_RLE_end_of_list";
459 case DW_RLE_base_addressx: return "DW_RLE_base_addressx";
460 case DW_RLE_startx_endx: return "DW_RLE_startx_endx";
461 case DW_RLE_startx_length: return "DW_RLE_startx_length";
462 case DW_RLE_offset_pair: return "DW_RLE_offset_pair";
463 case DW_RLE_base_address: return "DW_RLE_base_address";
464 case DW_RLE_start_end: return "DW_RLE_start_end";
465 case DW_RLE_start_length: return "DW_RLE_start_length";
466 }
467 return "DW_RLE_???";
468 }
469
470 /* ------ To do with evaluation of Dwarf expressions ------ */
471
472 /* FIXME: duplicated in readdwarf.c */
473 static
474 ULong read_leb128 ( const UChar* data, Int* length_return, Int sign )
475 {
476 ULong result = 0;
477 UInt num_read = 0;
478 Int shift = 0;
479 UChar byte;
480
481 vg_assert(sign == 0 || sign == 1);
482
483 do
484 {
485 byte = * data ++;
486 num_read ++;
487
488 result |= ((ULong)(byte & 0x7f)) << shift;
489
490 shift += 7;
491
492 }
493 while (byte & 0x80);
494
495 if (length_return != NULL)
496 * length_return = num_read;
497
498 if (sign && (shift < 64) && (byte & 0x40))
499 result |= -(1ULL << shift);
500
501 return result;
502 }
503
504 /* Small helper functions easier to use
505 * value is returned and the given pointer is
506 * moved past end of leb128 data */
507 /* FIXME: duplicated in readdwarf.c */
508 static ULong read_leb128U( const UChar **data )
509 {
510 Int len;
511 ULong val = read_leb128( *data, &len, 0 );
512 *data += len;
513 return val;
514 }
515
516 /* Same for signed data */
517 /* FIXME: duplicated in readdwarf.c */
518 static Long read_leb128S( const UChar **data )
519 {
520 Int len;
521 ULong val = read_leb128( *data, &len, 1 );
522 *data += len;
523 return (Long)val;
524 }
525
526 /* FIXME: duplicates logic in readdwarf.c: copy_convert_CfiExpr_tree
527 and {FP,SP}_REG decls */
528 static Bool get_Dwarf_Reg( /*OUT*/Addr* a, Word regno, const RegSummary* regs )
529 {
530 vg_assert(regs);
531 # if defined(VGP_x86_linux) || defined(VGP_x86_darwin) \
532 || defined(VGP_x86_solaris) || defined(VGP_x86_freebsd)
533 if (regno == 5/*EBP*/) { *a = regs->fp; return True; }
534 if (regno == 4/*ESP*/) { *a = regs->sp; return True; }
535 # elif defined(VGP_amd64_linux) || defined(VGP_amd64_darwin) \
536 || defined(VGP_amd64_solaris) || defined(VGP_amd64_freebsd)
537 if (regno == 6/*RBP*/) { *a = regs->fp; return True; }
538 if (regno == 7/*RSP*/) { *a = regs->sp; return True; }
539 # elif defined(VGP_ppc32_linux)
540 if (regno == 1/*SP*/) { *a = regs->sp; return True; }
541 # elif defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
542 if (regno == 1/*SP*/) { *a = regs->sp; return True; }
543 # elif defined(VGP_arm_linux)
544 if (regno == 13) { *a = regs->sp; return True; }
545 if (regno == 11) { *a = regs->fp; return True; }
546 # elif defined(VGP_s390x_linux)
547 if (regno == 15) { *a = regs->sp; return True; }
548 if (regno == 11) { *a = regs->fp; return True; }
549 # elif defined(VGP_mips32_linux) || defined(VGP_nanomips_linux)
550 if (regno == 29) { *a = regs->sp; return True; }
551 if (regno == 30) { *a = regs->fp; return True; }
552 # elif defined(VGP_mips64_linux)
553 if (regno == 29) { *a = regs->sp; return True; }
554 if (regno == 30) { *a = regs->fp; return True; }
555 # elif defined(VGP_arm64_linux) || defined(VGP_arm64_freebsd)
556 if (regno == 31) { *a = regs->sp; return True; }
557 if (regno == 29) { *a = regs->fp; return True; }
558 # else
559 # error "Unknown platform"
560 # endif
561 return False;
562 }
563
564 /* Convert a stated address to an actual address */
565 static Bool bias_address( Addr* a, const DebugInfo* di )
566 {
567 if (di->text_present
568 && di->text_size > 0
569 && *a >= di->text_debug_svma && *a < di->text_debug_svma + di->text_size) {
570 *a += di->text_debug_bias;
571 }
572 else if (di->data_present
573 && di->data_size > 0
574 && *a >= di->data_debug_svma && *a < di->data_debug_svma + di->data_size) {
575 *a += di->data_debug_bias;
576 }
577 else if (di->sdata_present
578 && di->sdata_size > 0
579 && *a >= di->sdata_debug_svma && *a < di->sdata_debug_svma + di->sdata_size) {
580 *a += di->sdata_debug_bias;
581 }
582 else if (di->rodata_present
583 && di->rodata_size > 0
584 && *a >= di->rodata_debug_svma && *a < di->rodata_debug_svma + di->rodata_size) {
585 *a += di->rodata_debug_bias;
586 }
587 else if (di->bss_present
588 && di->bss_size > 0
589 && *a >= di->bss_debug_svma && *a < di->bss_debug_svma + di->bss_size) {
590 *a += di->bss_debug_bias;
591 }
592 else if (di->sbss_present
593 && di->sbss_size > 0
594 && *a >= di->sbss_debug_svma && *a < di->sbss_debug_svma + di->sbss_size) {
595 *a += di->sbss_debug_bias;
596 }
597 else {
598 return False;
599 }
600
601 return True;
602 }
603
604
605 /* Evaluate a standard DWARF3 expression. See detailed description in
606 priv_d3basics.h. Doesn't handle DW_OP_piece/DW_OP_bit_piece yet. */
607 GXResult ML_(evaluate_Dwarf3_Expr) ( const UChar* expr, UWord exprszB,
608 const GExpr* fbGX, const RegSummary* regs,
609 const DebugInfo* di,
610 Bool push_initial_zero )
611 {
612 # define N_EXPR_STACK 20
613
614 # define FAIL(_str) \
615 do { \
616 res.kind = GXR_Failure; \
617 res.word = (UWord)(_str); \
618 return res; \
619 } while (0)
620
621 # define PUSH(_arg) \
622 do { \
623 vg_assert(sp >= -1 && sp < N_EXPR_STACK); \
624 if (sp == N_EXPR_STACK-1) \
625 FAIL("evaluate_Dwarf3_Expr: stack overflow(1)"); \
626 sp++; \
627 stack[sp] = (_arg); \
628 } while (0)
629
630 # define POP(_lval) \
631 do { \
632 vg_assert(sp >= -1 && sp < N_EXPR_STACK); \
633 if (sp == -1) \
634 FAIL("evaluate_Dwarf3_Expr: stack underflow(1)"); \
635 _lval = stack[sp]; \
636 sp--; \
637 } while (0)
638
639 UChar opcode;
640 const UChar* limit;
641 Int sp; /* # of top element: valid is -1 .. N_EXPR_STACK-1 */
642 Addr stack[N_EXPR_STACK]; /* stack of addresses, as per D3 spec */
643 GXResult fbval, res;
644 Addr a1;
645 Word sw1, sw2;
646 UWord uw1, uw2;
647 Bool ok;
648
649 sp = -1;
650 vg_assert(expr);
651 limit = expr + exprszB;
652
653 /* Deal with the case where the entire expression is a single
654 Register Name Operation (D3 spec sec 2.6.1). Then the
655 denotation of the expression as a whole is a register name. */
656 if (exprszB == 1
657 && expr[0] >= DW_OP_reg0 && expr[0] <= DW_OP_reg31) {
658 res.kind = GXR_RegNo;
659 res.word = (UWord)(expr[0] - DW_OP_reg0);
660 return res;
661 }
662 if (exprszB > 1
663 && expr[0] == DW_OP_regx) {
664 /* JRS: 2008Feb20: I believe the following is correct, but would
665 like to see a test case show up before enabling it. */
666 expr++;
667 res.kind = GXR_RegNo;
668 res.word = (UWord)read_leb128U( &expr );
669 if (expr != limit)
670 FAIL("evaluate_Dwarf3_Expr: DW_OP_regx*: invalid expr size");
671 else
672 return res;
673 /*NOTREACHED*/
674 }
675
676 /* Evidently this expression denotes a value, not a register name.
677 So evaluate it accordingly. */
678
679 if (push_initial_zero)
680 PUSH(0);
681
682 while (True) {
683
684 vg_assert(sp >= -1 && sp < N_EXPR_STACK);
685
686 if (expr > limit)
687 /* overrun - something's wrong */
688 FAIL("evaluate_Dwarf3_Expr: ran off end of expr");
689
690 if (expr == limit) {
691 /* end of expr - return expr on the top of stack. */
692 if (sp == -1)
693 /* stack empty. Bad. */
694 FAIL("evaluate_Dwarf3_Expr: stack empty at end of expr");
695 else
696 break;
697 }
698
699 opcode = *expr++;
700 switch (opcode) {
701 case DW_OP_addr:
702 /* Presumably what is given in the Dwarf3 is a SVMA (how
703 could it be otherwise?) So we add the appropriate bias
704 on before pushing the result. */
705 a1 = ML_(read_Addr)(expr);
706 if (bias_address(&a1, di)) {
707 PUSH( a1 );
708 expr += sizeof(Addr);
709 }
710 else {
711 FAIL("evaluate_Dwarf3_Expr: DW_OP_addr with address "
712 "in unknown section");
713 }
714 break;
715 case DW_OP_fbreg:
716 if (!fbGX)
717 FAIL("evaluate_Dwarf3_Expr: DW_OP_fbreg with "
718 "no expr for fbreg present");
719 fbval = ML_(evaluate_GX)(fbGX, NULL, regs, di);
720 /* Convert fbval into something we can use. If we got a
721 Value, no problem. However, as per D3 spec sec 3.3.5
722 (Low Level Information) sec 2, we could also get a
723 RegNo, and that is taken to mean the value in the
724 indicated register. So we have to manually
725 "dereference" it. */
726 a1 = 0;
727 switch (fbval.kind) {
728 case GXR_Failure:
729 return fbval; /* propagate failure */
730 case GXR_Addr:
731 a1 = fbval.word; break; /* use as-is */
732 case GXR_RegNo:
733 ok = get_Dwarf_Reg( &a1, fbval.word, regs );
734 if (!ok) return fbval; /* propagate failure */
735 break;
736 case GXR_Value:
737 FAIL("evaluate_Dwarf3_Expr: DW_OP_{implicit,stack}_value "
738 "in DW_AT_frame_base");
739 default:
740 vg_assert(0);
741 }
742 sw1 = (Word)read_leb128S( &expr );
743 PUSH( a1 + sw1 );
744 break;
745 /* DW_OP_breg* denotes 'contents of specified register, plus
746 constant offset'. So provided we know what the register's
747 value is, we can evaluate this. Contrast DW_OP_reg*,
748 which indicates that denoted location is in a register
749 itself. If DW_OP_reg* shows up here the expression is
750 malformed, since we are evaluating for value now, and
751 DW_OP_reg* denotes a register location, not a value. See
752 D3 Spec sec 2.6.1 ("Register Name Operations") for
753 details. */
754 case DW_OP_breg0 ... DW_OP_breg31:
755 if (!regs)
756 FAIL("evaluate_Dwarf3_Expr: DW_OP_breg* but no reg info");
757 a1 = 0;
758 if (!get_Dwarf_Reg( &a1, opcode - DW_OP_breg0, regs ))
759 FAIL("evaluate_Dwarf3_Expr: unhandled DW_OP_breg*");
760 sw1 = (Word)read_leb128S( &expr );
761 a1 += sw1;
762 PUSH( a1 );
763 break;
764 case DW_OP_bregx:
765 if (!regs)
766 FAIL("evaluate_Dwarf3_Expr: DW_OP_bregx but no reg info");
767 a1 = 0;
768 uw1 = (UWord)read_leb128U( &expr );
769 if (!get_Dwarf_Reg( &a1, uw1, regs ))
770 FAIL("evaluate_Dwarf3_Expr: unhandled DW_OP_bregx reg value");
771 sw1 = (Word)read_leb128S( &expr );
772 a1 += sw1;
773 PUSH( a1 );
774 break;
775 /* As per comment on DW_OP_breg*, the following denote that
776 the value in question is in a register, not in memory. So
777 we simply return failure. (iow, the expression is
778 malformed). */
779 case DW_OP_reg0 ... DW_OP_reg31:
780 case DW_OP_regx:
781 FAIL("evaluate_Dwarf3_Expr: DW_OP_reg* "
782 "whilst evaluating for a value");
783 break;
784 case DW_OP_plus_uconst:
785 POP(uw1);
786 uw1 += (UWord)read_leb128U( &expr );
787 PUSH(uw1);
788 break;
789 case DW_OP_GNU_push_tls_address:
790 /* GDB contains the following cryptic comment: */
791 /* Variable is at a constant offset in the thread-local
792 storage block into the objfile for the current thread and
793 the dynamic linker module containing this expression. Here
794 we return returns the offset from that base. The top of the
795 stack has the offset from the beginning of the thread
796 control block at which the variable is located. Nothing
797 should follow this operator, so the top of stack would be
798 returned. */
799 /* But no spec resulting from Googling. Punt for now. */
800 FAIL("warning: evaluate_Dwarf3_Expr: unhandled "
801 "DW_OP_GNU_push_tls_address");
802 /*NOTREACHED*/
803 case DW_OP_deref:
804 POP(uw1);
805 if (VG_(am_is_valid_for_client)( (Addr)uw1, sizeof(Addr),
806 VKI_PROT_READ )) {
807 uw1 = ML_(read_UWord)((void *)uw1);
808 PUSH(uw1);
809 } else {
810 FAIL("warning: evaluate_Dwarf3_Expr: DW_OP_deref: "
811 "address not valid for client");
812 }
813 break;
814 case DW_OP_deref_size:
815 POP(uw1);
816 uw2 = *expr++;
817 if (VG_(am_is_valid_for_client)( (Addr)uw1, uw2,
818 VKI_PROT_READ )) {
819 switch (uw2) {
820 case 1: uw1 = ML_(read_UChar)((void*)uw1); break;
821 case 2: uw1 = ML_(read_UShort)((void*)uw1); break;
822 case 4: uw1 = ML_(read_UInt)((void*)uw1); break;
823 case 8: uw1 = ML_(read_ULong)((void*)uw1); break;
824 default:
825 FAIL("warning: evaluate_Dwarf3_Expr: unhandled "
826 "DW_OP_deref_size size");
827 }
828 PUSH(uw1);
829 } else {
830 FAIL("warning: evaluate_Dwarf3_Expr: DW_OP_deref_size: "
831 "address not valid for client");
832 }
833 break;
834 case DW_OP_lit0 ... DW_OP_lit31:
835 PUSH(opcode - DW_OP_lit0);
836 break;
837 case DW_OP_const1u:
838 uw1 = *expr++;
839 PUSH(uw1);
840 break;
841 case DW_OP_const2u:
842 uw1 = ML_(read_UShort)(expr);
843 expr += 2;
844 PUSH(uw1);
845 break;
846 case DW_OP_const4u:
847 uw1 = ML_(read_UInt)(expr);
848 expr += 4;
849 PUSH(uw1);
850 break;
851 case DW_OP_const8u:
852 uw1 = ML_(read_ULong)(expr);
853 expr += 8;
854 PUSH(uw1);
855 break;
856 case DW_OP_constu:
857 uw1 = read_leb128U( &expr );
858 PUSH(uw1);
859 break;
860 case DW_OP_const1s:
861 uw1 = *(const Char *)expr;
862 expr++;
863 PUSH(uw1);
864 break;
865 case DW_OP_const2s:
866 uw1 = ML_(read_Short)(expr);
867 expr += 2;
868 PUSH(uw1);
869 break;
870 case DW_OP_const4s:
871 uw1 = ML_(read_Int)(expr);
872 expr += 4;
873 PUSH(uw1);
874 break;
875 case DW_OP_const8s:
876 uw1 = ML_(read_Long)(expr);
877 expr += 8;
878 PUSH(uw1);
879 break;
880 case DW_OP_consts:
881 uw1 = read_leb128S( &expr );
882 PUSH(uw1);
883 break;
884 case DW_OP_dup:
885 POP(uw1);
886 PUSH(uw1);
887 PUSH(uw1);
888 break;
889 case DW_OP_drop:
890 POP(uw1);
891 break;
892 case DW_OP_over:
893 uw1 = 1;
894 goto do_pick;
895 case DW_OP_pick:
896 uw1 = *expr++;
897 do_pick:
898 if (sp < (Int)uw1)
899 FAIL("evaluate_Dwarf3_Expr: stack underflow");
900 uw1 = stack[sp - uw1];
901 PUSH(uw1);
902 break;
903 case DW_OP_swap:
904 if (sp < 1)
905 FAIL("evaluate_Dwarf3_Expr: stack underflow");
906 uw1 = stack[sp];
907 stack[sp] = stack[sp - 1];
908 stack[sp - 1] = uw1;
909 break;
910 case DW_OP_rot:
911 if (sp < 2)
912 FAIL("evaluate_Dwarf3_Expr: stack underflow");
913 uw1 = stack[sp];
914 stack[sp] = stack[sp - 1];
915 stack[sp - 1] = stack[sp - 2];
916 stack[sp - 2] = uw1;
917 break;
918 case DW_OP_abs:
919 POP(sw1);
920 if (sw1 < 0)
921 sw1 = -sw1;
922 PUSH(sw1);
923 break;
924 case DW_OP_div:
925 POP(sw2);
926 if (sw2 == 0)
927 FAIL("evaluate_Dwarf3_Expr: division by zero");
928 POP(sw1);
929 sw1 /= sw2;
930 PUSH(sw1);
931 break;
932 case DW_OP_mod:
933 POP(uw2);
934 if (uw2 == 0)
935 FAIL("evaluate_Dwarf3_Expr: division by zero");
936 POP(uw1);
937 uw1 %= uw2;
938 PUSH(uw1);
939 break;
940 #define BINARY(name, op, s) \
941 case DW_OP_##name: \
942 POP(s##w2); \
943 POP(s##w1); \
944 s##w1 = s##w1 op s##w2; \
945 PUSH(s##w1); \
946 break
947 #define UNARY(name, op, s) \
948 case DW_OP_##name: \
949 POP(s##w1); \
950 s##w1 = op s##w1; \
951 PUSH(s##w1); \
952 break
953 BINARY (and, &, u);
954 BINARY (minus, -, u);
955 BINARY (mul, *, u);
956 UNARY (neg, -, u);
957 UNARY (not, ~, u);
958 BINARY (or, |, u);
959 BINARY (plus, +, u);
960 BINARY (shl, <<, u);
961 BINARY (shr, >>, u);
962 BINARY (shra, >>, s);
963 BINARY (xor, ^, u);
964 BINARY (le, <=, s);
965 BINARY (lt, <, s);
966 BINARY (ge, >=, s);
967 BINARY (gt, >, s);
968 BINARY (ne, !=, u);
969 BINARY (eq, ==, u);
970 #undef UNARY
971 #undef BINARY
972 case DW_OP_skip:
973 sw1 = ML_(read_Short)(expr);
974 expr += 2;
975 if (expr + sw1 < limit - exprszB)
976 FAIL("evaluate_Dwarf3_Expr: DW_OP_skip before start of expr");
977 if (expr + sw1 >= limit)
978 FAIL("evaluate_Dwarf3_Expr: DW_OP_skip after end of expr");
979 expr += sw1;
980 break;
981 case DW_OP_bra:
982 sw1 = ML_(read_Short)(expr);
983 expr += 2;
984 if (expr + sw1 < limit - exprszB)
985 FAIL("evaluate_Dwarf3_Expr: DW_OP_bra before start of expr");
986 if (expr + sw1 >= limit)
987 FAIL("evaluate_Dwarf3_Expr: DW_OP_bra after end of expr");
988 POP(uw1);
989 if (uw1)
990 expr += sw1;
991 break;
992 case DW_OP_nop:
993 break;
994 case DW_OP_call_frame_cfa:
995 if (!regs)
996 FAIL("evaluate_Dwarf3_Expr: "
997 "DW_OP_call_frame_cfa but no reg info");
998 #if defined(VGP_ppc32_linux) || defined(VGP_ppc64be_linux) \
999 || defined(VGP_ppc64le_linux)
1000 /* Valgrind on ppc32/ppc64 currently doesn't use unwind info. */
1001 uw1 = ML_(read_Addr)((UChar*)regs->sp);
1002 #else
1003 uw1 = ML_(get_CFA)(regs->ip, regs->sp, regs->fp, 0, ~(UWord) 0);
1004 #endif
1005 /* we expect this to fail on arm-linux, since ML_(get_CFA)
1006 always returns zero at present. */
1007 if (!uw1)
1008 FAIL("evaluate_Dwarf3_Expr: Could not resolve "
1009 "DW_OP_call_frame_cfa");
1010 PUSH(uw1);
1011 break;
1012 case DW_OP_implicit_value:
1013 sw1 = (Word)read_leb128S( &expr );
1014 uw1 = 0;
1015 switch (sw1) {
1016 case 1:
1017 uw1 = ML_(read_UChar)(expr);
1018 expr += 1;
1019 break;
1020 case 2:
1021 uw1 = ML_(read_UShort)(expr);
1022 expr += 2;
1023 break;
1024 case 4:
1025 uw1 = ML_(read_UInt)(expr);
1026 expr += 4;
1027 break;
1028 case 8:
1029 uw1 = ML_(read_ULong)(expr);
1030 expr += 8;
1031 break;
1032 default:
1033 FAIL("evaluate_Dwarf3_Expr: Unhandled "
1034 "DW_OP_implicit_value size");
1035 }
1036 if (expr != limit)
1037 FAIL("evaluate_Dwarf3_Expr: DW_OP_implicit_value "
1038 "does not terminate expression");
1039 res.word = uw1;
1040 res.kind = GXR_Value;
1041 return res;
1042 case DW_OP_stack_value:
1043 POP (uw1);
1044 res.word = uw1;
1045 res.kind = GXR_Value;
1046 if (expr != limit)
1047 FAIL("evaluate_Dwarf3_Expr: DW_OP_stack_value "
1048 "does not terminate expression");
1049 break;
1050 case DW_OP_entry_value:
1051 case DW_OP_GNU_entry_value:
1052 /* This provides a DWARF expression where any register op
1053 needs tobe evaluated as if the value that register had
1054 upon entering the function. Which is non-trivial to
1055 implement. */
1056 FAIL("evaluate_Dwarf3_Expr: Unhandled DW_OP entry_value");
1057 return res;
1058 default:
1059 if (!VG_(clo_xml))
1060 VG_(message)(Vg_DebugMsg,
1061 "warning: evaluate_Dwarf3_Expr: unhandled "
1062 "DW_OP_ 0x%x\n", (Int)opcode);
1063 FAIL("evaluate_Dwarf3_Expr: unhandled DW_OP_");
1064 /*NOTREACHED*/
1065 }
1066
1067 }
1068
1069 vg_assert(sp >= 0 && sp < N_EXPR_STACK);
1070 res.word = stack[sp];
1071 res.kind = GXR_Addr;
1072 return res;
1073
1074 # undef POP
1075 # undef PUSH
1076 # undef FAIL
1077 # undef N_EXPR_STACK
1078 }
1079
1080
1081 /* Evaluate a so-called Guarded (DWARF3) expression. See detailed
1082 description in priv_d3basics.h. */
1083 GXResult ML_(evaluate_GX)( const GExpr* gx, const GExpr* fbGX,
1084 const RegSummary* regs, const DebugInfo* di )
1085 {
1086 GXResult res;
1087 Addr aMin, aMax;
1088 UChar uc;
1089 UShort nbytes;
1090 UWord nGuards = 0;
1091 const UChar* p = &gx->payload[0];
1092 uc = *p++; /*biasMe*/
1093 vg_assert(uc == 0 || uc == 1);
1094 /* in fact it's senseless to evaluate if the guards need biasing.
1095 So don't. */
1096 vg_assert(uc == 0);
1097 while (True) {
1098 uc = *p++;
1099 if (uc == 1) { /*isEnd*/
1100 /* didn't find any matching range. */
1101 res.kind = GXR_Failure;
1102 res.word = (UWord)"no matching range";
1103 return res;
1104 }
1105 vg_assert(uc == 0);
1106 aMin = ML_(read_Addr)(p); p += sizeof(Addr);
1107 aMax = ML_(read_Addr)(p); p += sizeof(Addr);
1108 nbytes = ML_(read_UShort)(p); p += sizeof(UShort);
1109 nGuards++;
1110 if (0) VG_(printf)(" guard %lu: %#lx %#lx\n",
1111 nGuards, aMin,aMax);
1112 if (regs == NULL) {
1113 vg_assert(aMin == (Addr)0);
1114 vg_assert(aMax == ~(Addr)0);
1115 /* Assert this is the first guard. */
1116 vg_assert(nGuards == 1);
1117 res = ML_(evaluate_Dwarf3_Expr)(
1118 p, (UWord)nbytes, fbGX, regs, di,
1119 False/*push_initial_zero*/ );
1120 /* Now check there are no more guards. */
1121 p += (UWord)nbytes;
1122 vg_assert(*p == 1); /*isEnd*/
1123 return res;
1124 } else {
1125 if (aMin <= regs->ip && regs->ip <= aMax) {
1126 /* found a matching range. Evaluate the expression. */
1127 return ML_(evaluate_Dwarf3_Expr)(
1128 p, (UWord)nbytes, fbGX, regs, di,
1129 False/*push_initial_zero*/ );
1130 }
1131 }
1132 /* else keep searching */
1133 p += (UWord)nbytes;
1134 }
1135 }
1136
1137
1138 /* Evaluate a very simple Guarded (DWARF3) expression. The expression
1139 is expected to denote a constant, with no reference to any
1140 registers nor to any frame base expression. The expression is
1141 expected to have at least one guard. If there is more than one
1142 guard, all the sub-expressions are evaluated and compared. The
1143 address ranges on the guards are ignored. GXR_Failure is returned
1144 in the following circumstances:
1145 * no guards
1146 * any of the subexpressions require a frame base expression
1147 * any of the subexpressions denote a register location
1148 * any of the subexpressions do not produce a manifest constant
1149 * there's more than one subexpression, all of which successfully
1150 evaluate to a constant, but they don't all produce the same constant.
1151 JRS 23Jan09: the special-casing in this function is a nasty kludge.
1152 Really it ought to be pulled out and turned into a general
1153 constant- expression evaluator.
1154 */
1155 GXResult ML_(evaluate_trivial_GX)( const GExpr* gx, const DebugInfo* di )
1156 {
1157 GXResult res;
1158 Addr aMin, aMax;
1159 UChar uc;
1160 UShort nbytes;
1161 Word i, nGuards;
1162 MaybeULong *mul, *mul2;
1163
1164 const HChar* badness = NULL;
1165 const UChar* p = &gx->payload[0]; /* must remain unsigned */
1166 XArray* results = VG_(newXA)( ML_(dinfo_zalloc), "di.d3basics.etG.1",
1167 ML_(dinfo_free),
1168 sizeof(MaybeULong) );
1169
1170 uc = *p++; /*biasMe*/
1171 vg_assert(uc == 0 || uc == 1);
1172 /* in fact it's senseless to evaluate if the guards need biasing.
1173 So don't. */
1174 vg_assert(uc == 0);
1175
1176 nGuards = 0;
1177 while (True) {
1178 MaybeULong thisResult;
1179 uc = *p++;
1180 if (uc == 1) /*isEnd*/
1181 break;
1182 vg_assert(uc == 0);
1183 aMin = ML_(read_Addr)(p); p += sizeof(Addr);
1184 aMax = ML_(read_Addr)(p); p += sizeof(Addr);
1185 nbytes = ML_(read_UShort)(p); p += sizeof(UShort);
1186 nGuards++;
1187 if (0) VG_(printf)(" guard %ld: %#lx %#lx\n",
1188 nGuards, aMin,aMax);
1189
1190 thisResult.b = False;
1191 thisResult.ul = 0;
1192
1193 /* Peer at this particular subexpression, to see if it's
1194 obviously a constant. */
1195 if (nbytes == 1 + sizeof(Addr) && *p == DW_OP_addr) {
1196 /* DW_OP_addr a */
1197 Addr a = ML_(read_Addr)((p+1));
1198 if (bias_address(&a, di)) {
1199 thisResult.b = True;
1200 thisResult.ul = (ULong)a;
1201 } else {
1202 if (!badness)
1203 badness = "trivial GExpr denotes constant address "
1204 "in unknown section (1)";
1205 }
1206 }
1207 else
1208 if (nbytes == 1 + sizeof(Addr) + 1 + 1
1209 /* 11 byte block: 3 c0 b6 2b 0 0 0 0 0 23 4
1210 (DW_OP_addr: 2bb6c0; DW_OP_plus_uconst: 4)
1211 This is really a nasty kludge - only matches if the
1212 trailing ULEB denotes a number in the range 0 .. 127
1213 inclusive. */
1214 && p[0] == DW_OP_addr
1215 && p[1 + sizeof(Addr)] == DW_OP_plus_uconst
1216 && p[1 + sizeof(Addr) + 1] < 0x80 /*1-byte ULEB*/) {
1217 Addr a = ML_(read_Addr)(&p[1]);
1218 if (bias_address(&a, di)) {
1219 thisResult.b = True;
1220 thisResult.ul = (ULong)a + (ULong)p[1 + sizeof(Addr) + 1];
1221 } else {
1222 if (!badness)
1223 badness = "trivial GExpr denotes constant address "
1224 "in unknown section (2)";
1225 }
1226 }
1227 else
1228 if (nbytes == 2 + sizeof(Addr)
1229 && *p == DW_OP_addr
1230 && *(p + 1 + sizeof(Addr)) == DW_OP_GNU_push_tls_address) {
1231 if (!badness)
1232 badness = "trivial GExpr is DW_OP_addr plus trailing junk";
1233 }
1234 else if (nbytes >= 1 && *p >= DW_OP_reg0 && *p <= DW_OP_reg31) {
1235 if (!badness)
1236 badness = "trivial GExpr denotes register (1)";
1237 }
1238 else if (nbytes >= 1 && *p == DW_OP_fbreg) {
1239 if (!badness)
1240 badness = "trivial GExpr requires fbGX";
1241 }
1242 else if (nbytes >= 1 && *p >= DW_OP_breg0 && *p <= DW_OP_breg31) {
1243 if (!badness)
1244 badness = "trivial GExpr requires register value";
1245 }
1246 else if (nbytes >= 1 && *p == DW_OP_regx) {
1247 if (!badness)
1248 badness = "trivial GExpr denotes register (2)";
1249 }
1250 else if (0) {
1251 VG_(printf)(" ML_(evaluate_trivial_GX): unhandled:\n ");
1252 ML_(pp_GX)( gx );
1253 VG_(printf)("\n");
1254 vg_assert(0);
1255 }
1256 else
1257 if (!badness)
1258 badness = "non-trivial GExpr";
1259
1260 VG_(addToXA)( results, &thisResult );
1261
1262 p += (UWord)nbytes;
1263 }
1264
1265 res.kind = GXR_Failure;
1266
1267 vg_assert(nGuards == VG_(sizeXA)( results ));
1268 vg_assert(nGuards >= 0);
1269 if (nGuards == 0) {
1270 vg_assert(!badness);
1271 res.word = (UWord)"trivial GExpr has no guards (!)";
1272 VG_(deleteXA)( results );
1273 return res;
1274 }
1275
1276 for (i = 0; i < nGuards; i++) {
1277 mul = VG_(indexXA)( results, i );
1278 if (mul->b == False)
1279 break;
1280 }
1281
1282 vg_assert(i >= 0 && i <= nGuards);
1283 if (i < nGuards) {
1284 /* at least one subexpression failed to produce a manifest constant. */
1285 vg_assert(badness);
1286 res.word = (UWord)badness;
1287 VG_(deleteXA)( results );
1288 return res;
1289 }
1290
1291 /* All the subexpressions produced a constant, but did they all produce
1292 the same one? */
1293 mul = VG_(indexXA)( results, 0 );
1294 vg_assert(mul->b == True); /* we just established that all exprs are ok */
1295
1296 for (i = 1; i < nGuards; i++) {
1297 mul2 = VG_(indexXA)( results, i );
1298 vg_assert(mul2->b == True);
1299 if (mul2->ul != mul->ul) {
1300 res.word = (UWord)"trivial GExpr: subexpressions disagree";
1301 VG_(deleteXA)( results );
1302 return res;
1303 }
1304 }
1305
1306 /* Well, we have success. All subexpressions evaluated, and
1307 they all agree. Hurrah. */
1308 res.kind = GXR_Addr;
1309 res.word = (UWord)mul->ul; /* NB: narrowing from ULong */
1310 VG_(deleteXA)( results );
1311 return res;
1312 }
1313
1314
1315 void ML_(pp_GXResult) ( GXResult res )
1316 {
1317 switch (res.kind) {
1318 case GXR_Failure:
1319 VG_(printf)("GXR_Failure(%s)", (HChar*)res.word); break;
1320 case GXR_Addr:
1321 VG_(printf)("GXR_Addr(0x%lx)", res.word); break;
1322 case GXR_Value:
1323 VG_(printf)("GXR_Value(0x%lx)", res.word); break;
1324 case GXR_RegNo:
1325 VG_(printf)("GXR_RegNo(%lu)", res.word); break;
1326 default:
1327 VG_(printf)("GXR_???"); break;
1328 }
1329 }
1330
1331
1332 void ML_(pp_GX) ( const GExpr* gx )
1333 {
1334 Addr aMin, aMax;
1335 UChar uc;
1336 UShort nbytes;
1337 const UChar* p = &gx->payload[0];
1338 uc = *p++;
1339 VG_(printf)("GX(%s){", uc == 0 ? "final" : "Breqd" );
1340 vg_assert(uc == 0 || uc == 1);
1341 while (True) {
1342 uc = *p++;
1343 if (uc == 1)
1344 break; /*isEnd*/
1345 vg_assert(uc == 0);
1346 aMin = ML_(read_Addr)(p); p += sizeof(Addr);
1347 aMax = ML_(read_Addr)(p); p += sizeof(Addr);
1348 nbytes = ML_(read_UShort)(p); p += sizeof(UShort);
1349 VG_(printf)("[%#lx,%#lx]=", aMin, aMax);
1350 while (nbytes > 0) {
1351 VG_(printf)("%02x", (UInt)*p++);
1352 nbytes--;
1353 }
1354 if (*p == 0)
1355 VG_(printf)(",");
1356 }
1357 VG_(printf)("}");
1358 }
1359
1360
1361 /*--------------------------------------------------------------------*/
1362 /*--- end d3basics.c ---*/
1363 /*--------------------------------------------------------------------*/
Instrumentation framework for detecting many memory management and threading bugs, and profile your programs in detail.