1 //===-- DWARFDebugInfoEntry.cpp --------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "DWARFDebugInfoEntry.h" 11 #include "DWARFCompileUnit.h" 12 #include "DWARFContext.h" 13 #include "DWARFDebugAbbrev.h" 14 #include "DWARFFormValue.h" 15 #include "llvm/Support/Dwarf.h" 16 #include "llvm/Support/Format.h" 17 #include "llvm/Support/raw_ostream.h" 18 using namespace llvm; 19 using namespace dwarf; 20 21 void DWARFDebugInfoEntryMinimal::dump(raw_ostream &OS, 22 const DWARFCompileUnit *cu, 23 unsigned recurseDepth, 24 unsigned indent) const { 25 DataExtractor debug_info_data = cu->getDebugInfoExtractor(); 26 uint32_t offset = Offset; 27 28 if (debug_info_data.isValidOffset(offset)) { 29 uint64_t abbrCode = debug_info_data.getULEB128(&offset); 30 31 OS << format("\n0x%8.8x: ", Offset); 32 if (abbrCode) { 33 if (AbbrevDecl) { 34 const char *tagString = TagString(getTag()); 35 if (tagString) 36 OS.indent(indent) << tagString; 37 else 38 OS.indent(indent) << format("DW_TAG_Unknown_%x", getTag()); 39 OS << format(" [%u] %c\n", abbrCode, 40 AbbrevDecl->hasChildren() ? '*' : ' '); 41 42 // Dump all data in the .debug_info for the attributes 43 const uint32_t numAttributes = AbbrevDecl->getNumAttributes(); 44 for (uint32_t i = 0; i != numAttributes; ++i) { 45 uint16_t attr = AbbrevDecl->getAttrByIndex(i); 46 uint16_t form = AbbrevDecl->getFormByIndex(i); 47 dumpAttribute(OS, cu, &offset, attr, form, indent); 48 } 49 50 const DWARFDebugInfoEntryMinimal *child = getFirstChild(); 51 if (recurseDepth > 0 && child) { 52 while (child) { 53 child->dump(OS, cu, recurseDepth-1, indent+2); 54 child = child->getSibling(); 55 } 56 } 57 } else { 58 OS << "Abbreviation code not found in 'debug_abbrev' class for code: " 59 << abbrCode << '\n'; 60 } 61 } else { 62 OS.indent(indent) << "NULL\n"; 63 } 64 } 65 } 66 67 void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS, 68 const DWARFCompileUnit *cu, 69 uint32_t* offset_ptr, 70 uint16_t attr, 71 uint16_t form, 72 unsigned indent) const { 73 OS << format("0x%8.8x: ", *offset_ptr); 74 OS.indent(indent+2); 75 const char *attrString = AttributeString(attr); 76 if (attrString) 77 OS << attrString; 78 else 79 OS << format("DW_AT_Unknown_%x", attr); 80 const char *formString = FormEncodingString(form); 81 if (formString) 82 OS << " [" << formString << ']'; 83 else 84 OS << format(" [DW_FORM_Unknown_%x]", form); 85 86 DWARFFormValue formValue(form); 87 88 if (!formValue.extractValue(cu->getDebugInfoExtractor(), offset_ptr, cu)) 89 return; 90 91 OS << "\t("; 92 formValue.dump(OS, cu); 93 OS << ")\n"; 94 } 95 96 bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFCompileUnit *cu, 97 const uint8_t *fixed_form_sizes, 98 uint32_t *offset_ptr) { 99 Offset = *offset_ptr; 100 101 DataExtractor debug_info_data = cu->getDebugInfoExtractor(); 102 uint64_t abbrCode = debug_info_data.getULEB128(offset_ptr); 103 104 assert (fixed_form_sizes); // For best performance this should be specified! 105 106 if (abbrCode) { 107 uint32_t offset = *offset_ptr; 108 109 AbbrevDecl = cu->getAbbreviations()->getAbbreviationDeclaration(abbrCode); 110 111 // Skip all data in the .debug_info for the attributes 112 const uint32_t numAttributes = AbbrevDecl->getNumAttributes(); 113 uint32_t i; 114 uint16_t form; 115 for (i=0; i<numAttributes; ++i) { 116 form = AbbrevDecl->getFormByIndex(i); 117 118 const uint8_t fixed_skip_size = fixed_form_sizes[form]; 119 if (fixed_skip_size) 120 offset += fixed_skip_size; 121 else { 122 bool form_is_indirect = false; 123 do { 124 form_is_indirect = false; 125 uint32_t form_size = 0; 126 switch (form) { 127 // Blocks if inlined data that have a length field and the data bytes 128 // inlined in the .debug_info. 129 case DW_FORM_block: 130 form_size = debug_info_data.getULEB128(&offset); 131 break; 132 case DW_FORM_block1: 133 form_size = debug_info_data.getU8(&offset); 134 break; 135 case DW_FORM_block2: 136 form_size = debug_info_data.getU16(&offset); 137 break; 138 case DW_FORM_block4: 139 form_size = debug_info_data.getU32(&offset); 140 break; 141 142 // Inlined NULL terminated C-strings 143 case DW_FORM_string: 144 debug_info_data.getCStr(&offset); 145 break; 146 147 // Compile unit address sized values 148 case DW_FORM_addr: 149 case DW_FORM_ref_addr: 150 form_size = cu->getAddressByteSize(); 151 break; 152 153 // 1 byte values 154 case DW_FORM_data1: 155 case DW_FORM_flag: 156 case DW_FORM_ref1: 157 form_size = 1; 158 break; 159 160 // 2 byte values 161 case DW_FORM_data2: 162 case DW_FORM_ref2: 163 form_size = 2; 164 break; 165 166 // 4 byte values 167 case DW_FORM_strp: 168 case DW_FORM_data4: 169 case DW_FORM_ref4: 170 form_size = 4; 171 break; 172 173 // 8 byte values 174 case DW_FORM_data8: 175 case DW_FORM_ref8: 176 form_size = 8; 177 break; 178 179 // signed or unsigned LEB 128 values 180 case DW_FORM_sdata: 181 case DW_FORM_udata: 182 case DW_FORM_ref_udata: 183 debug_info_data.getULEB128(&offset); 184 break; 185 186 case DW_FORM_indirect: 187 form_is_indirect = true; 188 form = debug_info_data.getULEB128(&offset); 189 break; 190 191 default: 192 *offset_ptr = Offset; 193 return false; 194 } 195 offset += form_size; 196 197 } while (form_is_indirect); 198 } 199 } 200 *offset_ptr = offset; 201 return true; 202 } else { 203 AbbrevDecl = NULL; 204 return true; // NULL debug tag entry 205 } 206 207 return false; 208 } 209 210 bool 211 DWARFDebugInfoEntryMinimal::extract(const DWARFCompileUnit *cu, 212 uint32_t *offset_ptr) { 213 DataExtractor debug_info_data = cu->getDebugInfoExtractor(); 214 const uint32_t cu_end_offset = cu->getNextCompileUnitOffset(); 215 const uint8_t cu_addr_size = cu->getAddressByteSize(); 216 uint32_t offset = *offset_ptr; 217 if ((offset < cu_end_offset) && debug_info_data.isValidOffset(offset)) { 218 Offset = offset; 219 220 uint64_t abbrCode = debug_info_data.getULEB128(&offset); 221 222 if (abbrCode) { 223 AbbrevDecl = cu->getAbbreviations()->getAbbreviationDeclaration(abbrCode); 224 225 if (AbbrevDecl) { 226 uint16_t tag = AbbrevDecl->getTag(); 227 228 bool isCompileUnitTag = tag == DW_TAG_compile_unit; 229 if(cu && isCompileUnitTag) 230 const_cast<DWARFCompileUnit*>(cu)->setBaseAddress(0); 231 232 // Skip all data in the .debug_info for the attributes 233 const uint32_t numAttributes = AbbrevDecl->getNumAttributes(); 234 for (uint32_t i = 0; i != numAttributes; ++i) { 235 uint16_t attr = AbbrevDecl->getAttrByIndex(i); 236 uint16_t form = AbbrevDecl->getFormByIndex(i); 237 238 if (isCompileUnitTag && 239 ((attr == DW_AT_entry_pc) || (attr == DW_AT_low_pc))) { 240 DWARFFormValue form_value(form); 241 if (form_value.extractValue(debug_info_data, &offset, cu)) { 242 if (attr == DW_AT_low_pc || attr == DW_AT_entry_pc) 243 const_cast<DWARFCompileUnit*>(cu) 244 ->setBaseAddress(form_value.getUnsigned()); 245 } 246 } else { 247 bool form_is_indirect = false; 248 do { 249 form_is_indirect = false; 250 register uint32_t form_size = 0; 251 switch (form) { 252 // Blocks if inlined data that have a length field and the data 253 // bytes // inlined in the .debug_info 254 case DW_FORM_block: 255 form_size = debug_info_data.getULEB128(&offset); 256 break; 257 case DW_FORM_block1: 258 form_size = debug_info_data.getU8(&offset); 259 break; 260 case DW_FORM_block2: 261 form_size = debug_info_data.getU16(&offset); 262 break; 263 case DW_FORM_block4: 264 form_size = debug_info_data.getU32(&offset); 265 break; 266 267 // Inlined NULL terminated C-strings 268 case DW_FORM_string: 269 debug_info_data.getCStr(&offset); 270 break; 271 272 // Compile unit address sized values 273 case DW_FORM_addr: 274 case DW_FORM_ref_addr: 275 form_size = cu_addr_size; 276 break; 277 278 // 1 byte values 279 case DW_FORM_data1: 280 case DW_FORM_flag: 281 case DW_FORM_ref1: 282 form_size = 1; 283 break; 284 285 // 2 byte values 286 case DW_FORM_data2: 287 case DW_FORM_ref2: 288 form_size = 2; 289 break; 290 291 // 4 byte values 292 case DW_FORM_strp: 293 form_size = 4; 294 break; 295 296 case DW_FORM_data4: 297 case DW_FORM_ref4: 298 form_size = 4; 299 break; 300 301 // 8 byte values 302 case DW_FORM_data8: 303 case DW_FORM_ref8: 304 form_size = 8; 305 break; 306 307 // signed or unsigned LEB 128 values 308 case DW_FORM_sdata: 309 case DW_FORM_udata: 310 case DW_FORM_ref_udata: 311 debug_info_data.getULEB128(&offset); 312 break; 313 314 case DW_FORM_indirect: 315 form = debug_info_data.getULEB128(&offset); 316 form_is_indirect = true; 317 break; 318 319 default: 320 *offset_ptr = offset; 321 return false; 322 } 323 324 offset += form_size; 325 } while (form_is_indirect); 326 } 327 } 328 *offset_ptr = offset; 329 return true; 330 } 331 } else { 332 AbbrevDecl = NULL; 333 *offset_ptr = offset; 334 return true; // NULL debug tag entry 335 } 336 } 337 338 return false; 339 } 340 341 uint32_t 342 DWARFDebugInfoEntryMinimal::getAttributeValue(const DWARFCompileUnit *cu, 343 const uint16_t attr, 344 DWARFFormValue &form_value, 345 uint32_t *end_attr_offset_ptr) 346 const { 347 if (AbbrevDecl) { 348 uint32_t attr_idx = AbbrevDecl->findAttributeIndex(attr); 349 350 if (attr_idx != -1U) { 351 uint32_t offset = getOffset(); 352 353 DataExtractor debug_info_data = cu->getDebugInfoExtractor(); 354 355 // Skip the abbreviation code so we are at the data for the attributes 356 debug_info_data.getULEB128(&offset); 357 358 uint32_t idx = 0; 359 while (idx < attr_idx) 360 DWARFFormValue::skipValue(AbbrevDecl->getFormByIndex(idx++), 361 debug_info_data, &offset, cu); 362 363 const uint32_t attr_offset = offset; 364 form_value = DWARFFormValue(AbbrevDecl->getFormByIndex(idx)); 365 if (form_value.extractValue(debug_info_data, &offset, cu)) { 366 if (end_attr_offset_ptr) 367 *end_attr_offset_ptr = offset; 368 return attr_offset; 369 } 370 } 371 } 372 373 return 0; 374 } 375 376 const char* 377 DWARFDebugInfoEntryMinimal::getAttributeValueAsString( 378 const DWARFCompileUnit* cu, 379 const uint16_t attr, 380 const char* fail_value) const { 381 DWARFFormValue form_value; 382 if (getAttributeValue(cu, attr, form_value)) { 383 DataExtractor stringExtractor(cu->getContext().getStringSection(), 384 false, 0); 385 return form_value.getAsCString(&stringExtractor); 386 } 387 return fail_value; 388 } 389 390 uint64_t 391 DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsigned( 392 const DWARFCompileUnit* cu, 393 const uint16_t attr, 394 uint64_t fail_value) const { 395 DWARFFormValue form_value; 396 if (getAttributeValue(cu, attr, form_value)) 397 return form_value.getUnsigned(); 398 return fail_value; 399 } 400 401 int64_t 402 DWARFDebugInfoEntryMinimal::getAttributeValueAsSigned( 403 const DWARFCompileUnit* cu, 404 const uint16_t attr, 405 int64_t fail_value) const { 406 DWARFFormValue form_value; 407 if (getAttributeValue(cu, attr, form_value)) 408 return form_value.getSigned(); 409 return fail_value; 410 } 411 412 uint64_t 413 DWARFDebugInfoEntryMinimal::getAttributeValueAsReference( 414 const DWARFCompileUnit* cu, 415 const uint16_t attr, 416 uint64_t fail_value) const { 417 DWARFFormValue form_value; 418 if (getAttributeValue(cu, attr, form_value)) 419 return form_value.getReference(cu); 420 return fail_value; 421 } 422 423 void 424 DWARFDebugInfoEntryMinimal::buildAddressRangeTable(const DWARFCompileUnit *cu, 425 DWARFDebugAranges *debug_aranges) 426 const { 427 if (AbbrevDecl) { 428 uint16_t tag = AbbrevDecl->getTag(); 429 if (tag == DW_TAG_subprogram) { 430 uint64_t hi_pc = -1ULL; 431 uint64_t lo_pc = getAttributeValueAsUnsigned(cu, DW_AT_low_pc, -1ULL); 432 if (lo_pc != -1ULL) 433 hi_pc = getAttributeValueAsUnsigned(cu, DW_AT_high_pc, -1ULL); 434 if (hi_pc != -1ULL) 435 debug_aranges->appendRange(cu->getOffset(), lo_pc, hi_pc); 436 } 437 438 const DWARFDebugInfoEntryMinimal *child = getFirstChild(); 439 while (child) { 440 child->buildAddressRangeTable(cu, debug_aranges); 441 child = child->getSibling(); 442 } 443 } 444 } 445
