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