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