This is an archive of the discontinued LLVM Phabricator instance.

Differential D120836

[LLDB] Remove cases of using namespace llvm:: from header file
ClosedPublic

Authored by shafik on Mar 2 2022, 10:54 AM.

Details

Reviewers
labath
aprantl
JDevlieghere
jdoerfert
Commits
rGae869d448499: [LLDB] Remove cases of using namespace llvm:: from header file
Summary

We have two cases where we do some form of using namespace llvm:: in LLDB headers. I remove those cases and modified the effected files to either use the fully qualified name of using namespace inside a function.

Diff Detail

Event Timeline

shafik created this revision.Mar 2 2022, 10:54 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 2 2022, 10:54 AM
Herald added a subscriber: arphaman. · View Herald Transcript
shafik requested review of this revision.Mar 2 2022, 10:54 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptMar 2 2022, 10:54 AM
Herald added a subscriber: sstefan1. · View Herald Transcript
shafik added a comment.Mar 2 2022, 10:56 AM

I used using namespace in a few functions but I am not committed to this approach. So I am happy to hear feedback on whether we want to just use fully qualified names everywhere instead or nail down a criteria as to when it is acceptable.

We also have using namespace lldb in a few header files but I wanted to tackle that separately based on the feedback on this.

Harbormaster completed remote builds in B152208: Diff 412473.Mar 2 2022, 10:56 AM
kastiglione added a subscriber: kastiglione.Mar 2 2022, 10:58 AM

For the .cpp files with hundreds of lines modified, what do you think about adding using namespace llvm::dwarf; to those? For starters DWARFExpression.cpp, DWARFAbbreviationDeclaration.cpp, and SymbolFileDWARF.cpp.

kastiglione added a comment.Mar 2 2022, 11:00 AM

sorry Shafik I see that you've asked that very question. I'll give a +1 to making use of using namespace within .cpp files, especially where a namespace is used pervasively. When a file uses it only a namespace infrequently, I think explicit is reasonable.

labath added a comment.Mar 2 2022, 11:18 AM

I think it's reasonable to be able to refer to the dwarf constants from within the dwarf plugin via their base names alone. The implementation -- a top-level using namespace llvm::dwarf -- is not reasonable, but that's because the plugin is very old, and completely unnamespaced.

For the newer plugins, we've started putting them in a sub-namespace of lldb_private, which means they cannot be accidentally referenced from the core code, but they can easily reference (without qualification) symbols defined in the core libraries.

If we put the dwarf plugin into a (e.g.) lldb_private::dwarf namespace, then I think it would be ok to put a using namespace llvm::dwarf into that namespace, even in a header -- because those symbols would only be visible to symbols which are in that namespace.

In other words, I'd have the dwarf plugin do what the minidump plugin is doing (disclaimer: I wrote most of that plugin).

Anyway, I'm not married to that approach, but that's what I would do...

tschuett added a subscriber: tschuett.Mar 2 2022, 11:25 AM

I found this:
https://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

shafik added a comment.Mar 2 2022, 11:48 AM
In D120836#3355167, @labath wrote:

I think it's reasonable to be able to refer to the dwarf constants from within the dwarf plugin via their base names alone. The implementation -- a top-level using namespace llvm::dwarf -- is not reasonable, but that's because the plugin is very old, and completely unnamespaced.

For the newer plugins, we've started putting them in a sub-namespace of lldb_private, which means they cannot be accidentally referenced from the core code, but they can easily reference (without qualification) symbols defined in the core libraries.

If we put the dwarf plugin into a (e.g.) lldb_private::dwarf namespace, then I think it would be ok to put a using namespace llvm::dwarf into that namespace, even in a header -- because those symbols would only be visible to symbols which are in that namespace.

In other words, I'd have the dwarf plugin do what the minidump plugin is doing (disclaimer: I wrote most of that plugin).

Anyway, I'm not married to that approach, but that's what I would do...

If I understand correctly you are proposing that I do:

namespace lldb_private {
namespace dwarf {
  using namespace llvm::dwarf;
}
}

in lldb/include/lldb/Core/dwarf.h and then in the .cpp files:

using namespace lldb_private;
using namespace dwarf;

That sounds reasonable to me.

Then I would revert the changes to the minidump files, since they are already using this strategy.

labath added a comment.Mar 2 2022, 11:57 AM
In D120836#3355245, @shafik wrote:
In D120836#3355167, @labath wrote:

I think it's reasonable to be able to refer to the dwarf constants from within the dwarf plugin via their base names alone. The implementation -- a top-level using namespace llvm::dwarf -- is not reasonable, but that's because the plugin is very old, and completely unnamespaced.

For the newer plugins, we've started putting them in a sub-namespace of lldb_private, which means they cannot be accidentally referenced from the core code, but they can easily reference (without qualification) symbols defined in the core libraries.

If we put the dwarf plugin into a (e.g.) lldb_private::dwarf namespace, then I think it would be ok to put a using namespace llvm::dwarf into that namespace, even in a header -- because those symbols would only be visible to symbols which are in that namespace.

In other words, I'd have the dwarf plugin do what the minidump plugin is doing (disclaimer: I wrote most of that plugin).

Anyway, I'm not married to that approach, but that's what I would do...

If I understand correctly you are proposing that I do:

namespace lldb_private {
namespace dwarf {
  using namespace llvm::dwarf;
}
}

in lldb/include/lldb/Core/dwarf.h and then in the .cpp files:

using namespace lldb_private;
using namespace dwarf;

Yes, that's the general idea. I'm not entirely sure how to apply that to the DWARFExpression class, since it is not really a part of the dwarf plugin. But all of the uses of dwarf constants are in the cpp file, so I suppose a using namespace llvm::dwarf in DWARFExpression.cpp file should suffice.

shafik updated this revision to Diff 412548.Mar 2 2022, 2:41 PM

Updating diff based on comments

Harbormaster completed remote builds in B152250: Diff 412548.Mar 2 2022, 2:44 PM
JDevlieghere added inline comments.Mar 2 2022, 3:59 PM
lldb/source/Expression/DWARFExpression.cpp
46

Why not lldb_private::dwarf?

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp
19

Wouldn't it be more consistent to use lldb_private::dwarf everywhere?

JDevlieghere added inline comments.Mar 2 2022, 4:01 PM
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
34

Oh no...

shafik added inline comments.Mar 2 2022, 7:04 PM
lldb/source/Expression/DWARFExpression.cpp
46

I think I started out with this file and must have written that by mistake.

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp
19

Yeah, I was trying to match the style of how it was done for minidump, see source/Plugins/Process/minidump/MinidumpParser.cpp.

Since we need access to both namespaces but in files that did already have using namespace lldb_private; I just used the less verbose version.

I can see arguments for just being verbose everywhere.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
34

Yeah I noticed that was going to put that on a list of things to do, didn't feel right mixing that in here as well.

JDevlieghere added inline comments.Mar 2 2022, 11:07 PM
lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp
19

Maybe it's just preference? Curious to hear from @labath why he did it that way. Personally I prefer the slightly more verbose one because it's self contained.

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
34

Totally!

labath added inline comments.Mar 3 2022, 1:48 AM
lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp
19

Actually, I totally agree with you here. I think I did not personally write that using directive. I recall noticing it (during review, or during subsequent edits), but not considering it worth the trouble of changing it.

So +1 to verbose using directives.

labath accepted this revision.Mar 3 2022, 1:49 AM
This revision is now accepted and ready to land.Mar 3 2022, 1:49 AM
shafik updated this revision to Diff 412751.Mar 3 2022, 9:52 AM
shafik marked 6 inline comments as done.

Moved to using namespace lldb_private::dwarf everywhere since the consensus is that being verbose is preferred.

Harbormaster completed remote builds in B152399: Diff 412751.Mar 3 2022, 9:55 AM
Closed by commit rGae869d448499: [LLDB] Remove cases of using namespace llvm:: from header file (authored by shafik). · Explain WhyMar 3 2022, 10:42 AM
This revision was automatically updated to reflect the committed changes.
shafik added a commit: rGae869d448499: [LLDB] Remove cases of using namespace llvm:: from header file.
Herald added a project: Restricted Project. · View Herald TranscriptMar 3 2022, 10:42 AM

Revision Contents

PathSize
lldb/
include/
lldb/
Core/
3 lines
Symbol/
3 lines
source/
Expression/
364 lines
Plugins/
Process/
minidump/
21 lines
74 lines
2 lines
4 lines
62 lines
2 lines
3 lines
SymbolFile/
DWARF/
4 lines
459 lines
4 lines
2 lines
115 lines
129 lines
18 lines
16 lines
168 lines
3 lines
63 lines
25 lines
76 lines
82 lines
350 lines
12 lines
PDB/
14 lines
TypeSystem/
Clang/
44 lines
Symbol/
104 lines
22 lines
unittests/
Expression/
166 lines
Process/
minidump/
34 lines
SymbolFile/
DWARF/
4 lines
82 lines

Diff 412473

lldb/include/lldb/Core/dwarf.h

Show All 9 Lines
#define LLDB_CORE_DWARF_H #define LLDB_CORE_DWARF_H
#include "lldb/Utility/RangeMap.h" #include "lldb/Utility/RangeMap.h"
#include <cstdint> #include <cstdint>
// Get the DWARF constant definitions from llvm // Get the DWARF constant definitions from llvm
#include "llvm/BinaryFormat/Dwarf.h" #include "llvm/BinaryFormat/Dwarf.h"
// and stuff them in our default namespace
using namespace llvm::dwarf;
typedef uint32_t dw_uleb128_t; typedef uint32_t dw_uleb128_t;
typedef int32_t dw_sleb128_t; typedef int32_t dw_sleb128_t;
typedef uint16_t dw_attr_t; typedef uint16_t dw_attr_t;
typedef uint16_t dw_form_t; typedef uint16_t dw_form_t;
typedef llvm::dwarf::Tag dw_tag_t; typedef llvm::dwarf::Tag dw_tag_t;
typedef uint64_t dw_addr_t; // Dwarf address define that must be big enough for typedef uint64_t dw_addr_t; // Dwarf address define that must be big enough for
// any addresses in the compile units that get // any addresses in the compile units that get
// parsed // parsed
Show All 15 Lines

lldb/include/lldb/Symbol/DWARFCallFrameInfo.h

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines uint8_t lsda_addr_encoding; // The encoding of the LSDA address in the FDE
// augmentation data // augmentation data
lldb::addr_t personality_loc; // (file) address of the pointer to the lldb::addr_t personality_loc; // (file) address of the pointer to the
// personality routine // personality routine
lldb_private::UnwindPlan::Row initial_row; lldb_private::UnwindPlan::Row initial_row;
CIE(dw_offset_t offset) CIE(dw_offset_t offset)
: cie_offset(offset), version(-1), code_align(0), data_align(0), : cie_offset(offset), version(-1), code_align(0), data_align(0),
return_addr_reg_num(LLDB_INVALID_REGNUM), inst_offset(0), return_addr_reg_num(LLDB_INVALID_REGNUM), inst_offset(0),
inst_length(0), ptr_encoding(0), lsda_addr_encoding(DW_EH_PE_omit), inst_length(0), ptr_encoding(0),
lsda_addr_encoding(llvm::dwarf::DW_EH_PE_omit),
personality_loc(LLDB_INVALID_ADDRESS) {} personality_loc(LLDB_INVALID_ADDRESS) {}
}; };
typedef std::shared_ptr<CIE> CIESP; typedef std::shared_ptr<CIE> CIESP;
typedef std::map<dw_offset_t, CIESP> cie_map_t; typedef std::map<dw_offset_t, CIESP> cie_map_t;
// Start address (file address), size, offset of FDE location used for // Start address (file address), size, offset of FDE location used for
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lldb/source/Expression/DWARFExpression.cpp

Show All 37 Lines
#include "lldb/Target/Thread.h" #include "lldb/Target/Thread.h"
#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h" #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
#include "llvm/DebugInfo/DWARF/DWARFExpression.h" #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
#include "Plugins/SymbolFile/DWARF/DWARFUnit.h" #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
JDevlieghereUnsubmitted
Done
ReplyInline Actions

Why not lldb_private::dwarf?

JDevlieghere: Why not `lldb_private::dwarf`?
shafikAuthorUnsubmitted
Done
ReplyInline Actions

I think I started out with this file and must have written that by mistake.

shafik: I think I started out with this file and must have written that by mistake.
static lldb::addr_t static lldb::addr_t
ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu, ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
uint32_t index) { uint32_t index) {
uint32_t index_size = dwarf_cu->GetAddressByteSize(); uint32_t index_size = dwarf_cu->GetAddressByteSize();
dw_offset_t addr_base = dwarf_cu->GetAddrBase(); dw_offset_t addr_base = dwarf_cu->GetAddrBase();
lldb::offset_t offset = addr_base + index * index_size; lldb::offset_t offset = addr_base + index * index_size;
const DWARFDataExtractor &data = const DWARFDataExtractor &data =
dwarf_cu->GetSymbolFileDWARF().GetDWARFContext().getOrLoadAddrData(); dwarf_cu->GetSymbolFileDWARF().GetDWARFContext().getOrLoadAddrData();
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Lines
/// Return the length in bytes of the set of operands for \p op. No guarantees /// Return the length in bytes of the set of operands for \p op. No guarantees
/// are made on the state of \p data after this call. /// are made on the state of \p data after this call.
static offset_t GetOpcodeDataSize(const DataExtractor &data, static offset_t GetOpcodeDataSize(const DataExtractor &data,
const lldb::offset_t data_offset, const lldb::offset_t data_offset,
const uint8_t op) { const uint8_t op) {
lldb::offset_t offset = data_offset; lldb::offset_t offset = data_offset;
switch (op) { switch (op) {
case DW_OP_addr: case llvm::dwarf::DW_OP_addr:
case DW_OP_call_ref: // 0x9a 1 address sized offset of DIE (DWARF3) case llvm::dwarf::DW_OP_call_ref: // 0x9a 1 address sized offset of DIE
// (DWARF3)
return data.GetAddressByteSize(); return data.GetAddressByteSize();
// Opcodes with no arguments // Opcodes with no arguments
case DW_OP_deref: // 0x06 case llvm::dwarf::DW_OP_deref: // 0x06
case DW_OP_dup: // 0x12 case llvm::dwarf::DW_OP_dup: // 0x12
case DW_OP_drop: // 0x13 case llvm::dwarf::DW_OP_drop: // 0x13
case DW_OP_over: // 0x14 case llvm::dwarf::DW_OP_over: // 0x14
case DW_OP_swap: // 0x16 case llvm::dwarf::DW_OP_swap: // 0x16
case DW_OP_rot: // 0x17 case llvm::dwarf::DW_OP_rot: // 0x17
case DW_OP_xderef: // 0x18 case llvm::dwarf::DW_OP_xderef: // 0x18
case DW_OP_abs: // 0x19 case llvm::dwarf::DW_OP_abs: // 0x19
case DW_OP_and: // 0x1a case llvm::dwarf::DW_OP_and: // 0x1a
case DW_OP_div: // 0x1b case llvm::dwarf::DW_OP_div: // 0x1b
case DW_OP_minus: // 0x1c case llvm::dwarf::DW_OP_minus: // 0x1c
case DW_OP_mod: // 0x1d case llvm::dwarf::DW_OP_mod: // 0x1d
case DW_OP_mul: // 0x1e case llvm::dwarf::DW_OP_mul: // 0x1e
case DW_OP_neg: // 0x1f case llvm::dwarf::DW_OP_neg: // 0x1f
case DW_OP_not: // 0x20 case llvm::dwarf::DW_OP_not: // 0x20
case DW_OP_or: // 0x21 case llvm::dwarf::DW_OP_or: // 0x21
case DW_OP_plus: // 0x22 case llvm::dwarf::DW_OP_plus: // 0x22
case DW_OP_shl: // 0x24 case llvm::dwarf::DW_OP_shl: // 0x24
case DW_OP_shr: // 0x25 case llvm::dwarf::DW_OP_shr: // 0x25
case DW_OP_shra: // 0x26 case llvm::dwarf::DW_OP_shra: // 0x26
case DW_OP_xor: // 0x27 case llvm::dwarf::DW_OP_xor: // 0x27
case DW_OP_eq: // 0x29 case llvm::dwarf::DW_OP_eq: // 0x29
case DW_OP_ge: // 0x2a case llvm::dwarf::DW_OP_ge: // 0x2a
case DW_OP_gt: // 0x2b case llvm::dwarf::DW_OP_gt: // 0x2b
case DW_OP_le: // 0x2c case llvm::dwarf::DW_OP_le: // 0x2c
case DW_OP_lt: // 0x2d case llvm::dwarf::DW_OP_lt: // 0x2d
case DW_OP_ne: // 0x2e case llvm::dwarf::DW_OP_ne: // 0x2e
case DW_OP_lit0: // 0x30 case llvm::dwarf::DW_OP_lit0: // 0x30
case DW_OP_lit1: // 0x31 case llvm::dwarf::DW_OP_lit1: // 0x31
case DW_OP_lit2: // 0x32 case llvm::dwarf::DW_OP_lit2: // 0x32
case DW_OP_lit3: // 0x33 case llvm::dwarf::DW_OP_lit3: // 0x33
case DW_OP_lit4: // 0x34 case llvm::dwarf::DW_OP_lit4: // 0x34
case DW_OP_lit5: // 0x35 case llvm::dwarf::DW_OP_lit5: // 0x35
case DW_OP_lit6: // 0x36 case llvm::dwarf::DW_OP_lit6: // 0x36
case DW_OP_lit7: // 0x37 case llvm::dwarf::DW_OP_lit7: // 0x37
case DW_OP_lit8: // 0x38 case llvm::dwarf::DW_OP_lit8: // 0x38
case DW_OP_lit9: // 0x39 case llvm::dwarf::DW_OP_lit9: // 0x39
case DW_OP_lit10: // 0x3A case llvm::dwarf::DW_OP_lit10: // 0x3A
case DW_OP_lit11: // 0x3B case llvm::dwarf::DW_OP_lit11: // 0x3B
case DW_OP_lit12: // 0x3C case llvm::dwarf::DW_OP_lit12: // 0x3C
case DW_OP_lit13: // 0x3D case llvm::dwarf::DW_OP_lit13: // 0x3D
case DW_OP_lit14: // 0x3E case llvm::dwarf::DW_OP_lit14: // 0x3E
case DW_OP_lit15: // 0x3F case llvm::dwarf::DW_OP_lit15: // 0x3F
case DW_OP_lit16: // 0x40 case llvm::dwarf::DW_OP_lit16: // 0x40
case DW_OP_lit17: // 0x41 case llvm::dwarf::DW_OP_lit17: // 0x41
case DW_OP_lit18: // 0x42 case llvm::dwarf::DW_OP_lit18: // 0x42
case DW_OP_lit19: // 0x43 case llvm::dwarf::DW_OP_lit19: // 0x43
case DW_OP_lit20: // 0x44 case llvm::dwarf::DW_OP_lit20: // 0x44
case DW_OP_lit21: // 0x45 case llvm::dwarf::DW_OP_lit21: // 0x45
case DW_OP_lit22: // 0x46 case llvm::dwarf::DW_OP_lit22: // 0x46
case DW_OP_lit23: // 0x47 case llvm::dwarf::DW_OP_lit23: // 0x47
case DW_OP_lit24: // 0x48 case llvm::dwarf::DW_OP_lit24: // 0x48
case DW_OP_lit25: // 0x49 case llvm::dwarf::DW_OP_lit25: // 0x49
case DW_OP_lit26: // 0x4A case llvm::dwarf::DW_OP_lit26: // 0x4A
case DW_OP_lit27: // 0x4B case llvm::dwarf::DW_OP_lit27: // 0x4B
case DW_OP_lit28: // 0x4C case llvm::dwarf::DW_OP_lit28: // 0x4C
case DW_OP_lit29: // 0x4D case llvm::dwarf::DW_OP_lit29: // 0x4D
case DW_OP_lit30: // 0x4E case llvm::dwarf::DW_OP_lit30: // 0x4E
case DW_OP_lit31: // 0x4f case llvm::dwarf::DW_OP_lit31: // 0x4f
case DW_OP_reg0: // 0x50 case llvm::dwarf::DW_OP_reg0: // 0x50
case DW_OP_reg1: // 0x51 case llvm::dwarf::DW_OP_reg1: // 0x51
case DW_OP_reg2: // 0x52 case llvm::dwarf::DW_OP_reg2: // 0x52
case DW_OP_reg3: // 0x53 case llvm::dwarf::DW_OP_reg3: // 0x53
case DW_OP_reg4: // 0x54 case llvm::dwarf::DW_OP_reg4: // 0x54
case DW_OP_reg5: // 0x55 case llvm::dwarf::DW_OP_reg5: // 0x55
case DW_OP_reg6: // 0x56 case llvm::dwarf::DW_OP_reg6: // 0x56
case DW_OP_reg7: // 0x57 case llvm::dwarf::DW_OP_reg7: // 0x57
case DW_OP_reg8: // 0x58 case llvm::dwarf::DW_OP_reg8: // 0x58
case DW_OP_reg9: // 0x59 case llvm::dwarf::DW_OP_reg9: // 0x59
case DW_OP_reg10: // 0x5A case llvm::dwarf::DW_OP_reg10: // 0x5A
case DW_OP_reg11: // 0x5B case llvm::dwarf::DW_OP_reg11: // 0x5B
case DW_OP_reg12: // 0x5C case llvm::dwarf::DW_OP_reg12: // 0x5C
case DW_OP_reg13: // 0x5D case llvm::dwarf::DW_OP_reg13: // 0x5D
case DW_OP_reg14: // 0x5E case llvm::dwarf::DW_OP_reg14: // 0x5E
case DW_OP_reg15: // 0x5F case llvm::dwarf::DW_OP_reg15: // 0x5F
case DW_OP_reg16: // 0x60 case llvm::dwarf::DW_OP_reg16: // 0x60
case DW_OP_reg17: // 0x61 case llvm::dwarf::DW_OP_reg17: // 0x61
case DW_OP_reg18: // 0x62 case llvm::dwarf::DW_OP_reg18: // 0x62
case DW_OP_reg19: // 0x63 case llvm::dwarf::DW_OP_reg19: // 0x63
case DW_OP_reg20: // 0x64 case llvm::dwarf::DW_OP_reg20: // 0x64
case DW_OP_reg21: // 0x65 case llvm::dwarf::DW_OP_reg21: // 0x65
case DW_OP_reg22: // 0x66 case llvm::dwarf::DW_OP_reg22: // 0x66
case DW_OP_reg23: // 0x67 case llvm::dwarf::DW_OP_reg23: // 0x67
case DW_OP_reg24: // 0x68 case llvm::dwarf::DW_OP_reg24: // 0x68
case DW_OP_reg25: // 0x69 case llvm::dwarf::DW_OP_reg25: // 0x69
case DW_OP_reg26: // 0x6A case llvm::dwarf::DW_OP_reg26: // 0x6A
case DW_OP_reg27: // 0x6B case llvm::dwarf::DW_OP_reg27: // 0x6B
case DW_OP_reg28: // 0x6C case llvm::dwarf::DW_OP_reg28: // 0x6C
case DW_OP_reg29: // 0x6D case llvm::dwarf::DW_OP_reg29: // 0x6D
case DW_OP_reg30: // 0x6E case llvm::dwarf::DW_OP_reg30: // 0x6E
case DW_OP_reg31: // 0x6F case llvm::dwarf::DW_OP_reg31: // 0x6F
case DW_OP_nop: // 0x96 case llvm::dwarf::DW_OP_nop: // 0x96
case DW_OP_push_object_address: // 0x97 DWARF3 case llvm::dwarf::DW_OP_push_object_address: // 0x97 DWARF3
case DW_OP_form_tls_address: // 0x9b DWARF3 case llvm::dwarf::DW_OP_form_tls_address: // 0x9b DWARF3
case DW_OP_call_frame_cfa: // 0x9c DWARF3 case llvm::dwarf::DW_OP_call_frame_cfa: // 0x9c DWARF3
case DW_OP_stack_value: // 0x9f DWARF4 case llvm::dwarf::DW_OP_stack_value: // 0x9f DWARF4
case DW_OP_GNU_push_tls_address: // 0xe0 GNU extension case llvm::dwarf::DW_OP_GNU_push_tls_address: // 0xe0 GNU extension
return 0; return 0;
// Opcodes with a single 1 byte arguments // Opcodes with a single 1 byte arguments
case DW_OP_const1u: // 0x08 1 1-byte constant case llvm::dwarf::DW_OP_const1u: // 0x08 1 1-byte constant
case DW_OP_const1s: // 0x09 1 1-byte constant case llvm::dwarf::DW_OP_const1s: // 0x09 1 1-byte constant
case DW_OP_pick: // 0x15 1 1-byte stack index case llvm::dwarf::DW_OP_pick: // 0x15 1 1-byte stack index
case DW_OP_deref_size: // 0x94 1 1-byte size of data retrieved case llvm::dwarf::DW_OP_deref_size: // 0x94 1 1-byte size of data retrieved
case DW_OP_xderef_size: // 0x95 1 1-byte size of data retrieved case llvm::dwarf::DW_OP_xderef_size: // 0x95 1 1-byte size of data retrieved
return 1; return 1;
// Opcodes with a single 2 byte arguments // Opcodes with a single 2 byte arguments
case DW_OP_const2u: // 0x0a 1 2-byte constant case llvm::dwarf::DW_OP_const2u: // 0x0a 1 2-byte constant
case DW_OP_const2s: // 0x0b 1 2-byte constant case llvm::dwarf::DW_OP_const2s: // 0x0b 1 2-byte constant
case DW_OP_skip: // 0x2f 1 signed 2-byte constant case llvm::dwarf::DW_OP_skip: // 0x2f 1 signed 2-byte constant
case DW_OP_bra: // 0x28 1 signed 2-byte constant case llvm::dwarf::DW_OP_bra: // 0x28 1 signed 2-byte constant
case DW_OP_call2: // 0x98 1 2-byte offset of DIE (DWARF3) case llvm::dwarf::DW_OP_call2: // 0x98 1 2-byte offset of DIE (DWARF3)
return 2; return 2;
// Opcodes with a single 4 byte arguments // Opcodes with a single 4 byte arguments
case DW_OP_const4u: // 0x0c 1 4-byte constant case llvm::dwarf::DW_OP_const4u: // 0x0c 1 4-byte constant
case DW_OP_const4s: // 0x0d 1 4-byte constant case llvm::dwarf::DW_OP_const4s: // 0x0d 1 4-byte constant
case DW_OP_call4: // 0x99 1 4-byte offset of DIE (DWARF3) case llvm::dwarf::DW_OP_call4: // 0x99 1 4-byte offset of DIE (DWARF3)
return 4; return 4;
// Opcodes with a single 8 byte arguments // Opcodes with a single 8 byte arguments
case DW_OP_const8u: // 0x0e 1 8-byte constant case llvm::dwarf::DW_OP_const8u: // 0x0e 1 8-byte constant
case DW_OP_const8s: // 0x0f 1 8-byte constant case llvm::dwarf::DW_OP_const8s: // 0x0f 1 8-byte constant
return 8; return 8;
// All opcodes that have a single ULEB (signed or unsigned) argument // All opcodes that have a single ULEB (signed or unsigned) argument
case DW_OP_addrx: // 0xa1 1 ULEB128 index case llvm::dwarf::DW_OP_addrx: // 0xa1 1 ULEB128 index
case DW_OP_constu: // 0x10 1 ULEB128 constant case llvm::dwarf::DW_OP_constu: // 0x10 1 ULEB128 constant
case DW_OP_consts: // 0x11 1 SLEB128 constant case llvm::dwarf::DW_OP_consts: // 0x11 1 SLEB128 constant
case DW_OP_plus_uconst: // 0x23 1 ULEB128 addend case llvm::dwarf::DW_OP_plus_uconst: // 0x23 1 ULEB128 addend
case DW_OP_breg0: // 0x70 1 ULEB128 register case llvm::dwarf::DW_OP_breg0: // 0x70 1 ULEB128 register
case DW_OP_breg1: // 0x71 1 ULEB128 register case llvm::dwarf::DW_OP_breg1: // 0x71 1 ULEB128 register
case DW_OP_breg2: // 0x72 1 ULEB128 register case llvm::dwarf::DW_OP_breg2: // 0x72 1 ULEB128 register
case DW_OP_breg3: // 0x73 1 ULEB128 register case llvm::dwarf::DW_OP_breg3: // 0x73 1 ULEB128 register
case DW_OP_breg4: // 0x74 1 ULEB128 register case llvm::dwarf::DW_OP_breg4: // 0x74 1 ULEB128 register
case DW_OP_breg5: // 0x75 1 ULEB128 register case llvm::dwarf::DW_OP_breg5: // 0x75 1 ULEB128 register
case DW_OP_breg6: // 0x76 1 ULEB128 register case llvm::dwarf::DW_OP_breg6: // 0x76 1 ULEB128 register
case DW_OP_breg7: // 0x77 1 ULEB128 register case llvm::dwarf::DW_OP_breg7: // 0x77 1 ULEB128 register
case DW_OP_breg8: // 0x78 1 ULEB128 register case llvm::dwarf::DW_OP_breg8: // 0x78 1 ULEB128 register
case DW_OP_breg9: // 0x79 1 ULEB128 register case llvm::dwarf::DW_OP_breg9: // 0x79 1 ULEB128 register
case DW_OP_breg10: // 0x7a 1 ULEB128 register case llvm::dwarf::DW_OP_breg10: // 0x7a 1 ULEB128 register
case DW_OP_breg11: // 0x7b 1 ULEB128 register case llvm::dwarf::DW_OP_breg11: // 0x7b 1 ULEB128 register
case DW_OP_breg12: // 0x7c 1 ULEB128 register case llvm::dwarf::DW_OP_breg12: // 0x7c 1 ULEB128 register
case DW_OP_breg13: // 0x7d 1 ULEB128 register case llvm::dwarf::DW_OP_breg13: // 0x7d 1 ULEB128 register
case DW_OP_breg14: // 0x7e 1 ULEB128 register case llvm::dwarf::DW_OP_breg14: // 0x7e 1 ULEB128 register
case DW_OP_breg15: // 0x7f 1 ULEB128 register case llvm::dwarf::DW_OP_breg15: // 0x7f 1 ULEB128 register
case DW_OP_breg16: // 0x80 1 ULEB128 register case llvm::dwarf::DW_OP_breg16: // 0x80 1 ULEB128 register
case DW_OP_breg17: // 0x81 1 ULEB128 register case llvm::dwarf::DW_OP_breg17: // 0x81 1 ULEB128 register
case DW_OP_breg18: // 0x82 1 ULEB128 register case llvm::dwarf::DW_OP_breg18: // 0x82 1 ULEB128 register
case DW_OP_breg19: // 0x83 1 ULEB128 register case llvm::dwarf::DW_OP_breg19: // 0x83 1 ULEB128 register
case DW_OP_breg20: // 0x84 1 ULEB128 register case llvm::dwarf::DW_OP_breg20: // 0x84 1 ULEB128 register
case DW_OP_breg21: // 0x85 1 ULEB128 register case llvm::dwarf::DW_OP_breg21: // 0x85 1 ULEB128 register
case DW_OP_breg22: // 0x86 1 ULEB128 register case llvm::dwarf::DW_OP_breg22: // 0x86 1 ULEB128 register
case DW_OP_breg23: // 0x87 1 ULEB128 register case llvm::dwarf::DW_OP_breg23: // 0x87 1 ULEB128 register
case DW_OP_breg24: // 0x88 1 ULEB128 register case llvm::dwarf::DW_OP_breg24: // 0x88 1 ULEB128 register
case DW_OP_breg25: // 0x89 1 ULEB128 register case llvm::dwarf::DW_OP_breg25: // 0x89 1 ULEB128 register
case DW_OP_breg26: // 0x8a 1 ULEB128 register case llvm::dwarf::DW_OP_breg26: // 0x8a 1 ULEB128 register
case DW_OP_breg27: // 0x8b 1 ULEB128 register case llvm::dwarf::DW_OP_breg27: // 0x8b 1 ULEB128 register
case DW_OP_breg28: // 0x8c 1 ULEB128 register case llvm::dwarf::DW_OP_breg28: // 0x8c 1 ULEB128 register
case DW_OP_breg29: // 0x8d 1 ULEB128 register case llvm::dwarf::DW_OP_breg29: // 0x8d 1 ULEB128 register
case DW_OP_breg30: // 0x8e 1 ULEB128 register case llvm::dwarf::DW_OP_breg30: // 0x8e 1 ULEB128 register
case DW_OP_breg31: // 0x8f 1 ULEB128 register case llvm::dwarf::DW_OP_breg31: // 0x8f 1 ULEB128 register
case DW_OP_regx: // 0x90 1 ULEB128 register case llvm::dwarf::DW_OP_regx: // 0x90 1 ULEB128 register
case DW_OP_fbreg: // 0x91 1 SLEB128 offset case llvm::dwarf::DW_OP_fbreg: // 0x91 1 SLEB128 offset
case DW_OP_piece: // 0x93 1 ULEB128 size of piece addressed case llvm::dwarf::DW_OP_piece: // 0x93 1 ULEB128 size of piece addressed
case DW_OP_GNU_addr_index: // 0xfb 1 ULEB128 index case llvm::dwarf::DW_OP_GNU_addr_index: // 0xfb 1 ULEB128 index
case DW_OP_GNU_const_index: // 0xfc 1 ULEB128 index case llvm::dwarf::DW_OP_GNU_const_index: // 0xfc 1 ULEB128 index
data.Skip_LEB128(&offset); data.Skip_LEB128(&offset);
return offset - data_offset; return offset - data_offset;
// All opcodes that have a 2 ULEB (signed or unsigned) arguments // All opcodes that have a 2 ULEB (signed or unsigned) arguments
case DW_OP_bregx: // 0x92 2 ULEB128 register followed by SLEB128 offset case llvm::dwarf::DW_OP_bregx: // 0x92 2 ULEB128 register followed by SLEB128
case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3); // offset
case llvm::dwarf::DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit
// offset (DWARF3);
data.Skip_LEB128(&offset); data.Skip_LEB128(&offset);
data.Skip_LEB128(&offset); data.Skip_LEB128(&offset);
return offset - data_offset; return offset - data_offset;
case DW_OP_implicit_value: // 0x9e ULEB128 size followed by block of that size case llvm::dwarf::DW_OP_implicit_value: // 0x9e ULEB128 size followed by block
// (DWARF4) // of that size (DWARF4)
{ {
uint64_t block_len = data.Skip_LEB128(&offset); uint64_t block_len = data.Skip_LEB128(&offset);
offset += block_len; offset += block_len;
return offset - data_offset; return offset - data_offset;
} }
case DW_OP_GNU_entry_value: case llvm::dwarf::DW_OP_GNU_entry_value:
case DW_OP_entry_value: // 0xa3 ULEB128 size + variable-length block case llvm::dwarf::DW_OP_entry_value: // 0xa3 ULEB128 size + variable-length
// block
{ {
uint64_t subexpr_len = data.GetULEB128(&offset); uint64_t subexpr_len = data.GetULEB128(&offset);
return (offset - data_offset) + subexpr_len; return (offset - data_offset) + subexpr_len;
} }
default: default:
break; break;
} }
return LLDB_INVALID_OFFSET; return LLDB_INVALID_OFFSET;
} }
lldb::addr_t DWARFExpression::GetLocation_DW_OP_addr(uint32_t op_addr_idx, lldb::addr_t DWARFExpression::GetLocation_DW_OP_addr(uint32_t op_addr_idx,
bool &error) const { bool &error) const {
error = false; error = false;
if (IsLocationList()) if (IsLocationList())
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
uint32_t curr_op_addr_idx = 0; uint32_t curr_op_addr_idx = 0;
while (m_data.ValidOffset(offset)) { while (m_data.ValidOffset(offset)) {
const uint8_t op = m_data.GetU8(&offset); const uint8_t op = m_data.GetU8(&offset);
if (op == DW_OP_addr) { if (op == llvm::dwarf::DW_OP_addr) {
const lldb::addr_t op_file_addr = m_data.GetAddress(&offset); const lldb::addr_t op_file_addr = m_data.GetAddress(&offset);
if (curr_op_addr_idx == op_addr_idx) if (curr_op_addr_idx == op_addr_idx)
return op_file_addr; return op_file_addr;
else else
++curr_op_addr_idx; ++curr_op_addr_idx;
} else if (op == DW_OP_GNU_addr_index || op == DW_OP_addrx) { } else if (op == llvm::dwarf::DW_OP_GNU_addr_index ||
op == llvm::dwarf::DW_OP_addrx) {
uint64_t index = m_data.GetULEB128(&offset); uint64_t index = m_data.GetULEB128(&offset);
if (curr_op_addr_idx == op_addr_idx) { if (curr_op_addr_idx == op_addr_idx) {
if (!m_dwarf_cu) { if (!m_dwarf_cu) {
error = true; error = true;
break; break;
} }
return ReadAddressFromDebugAddrSection(m_dwarf_cu, index); return ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
Show All 13 Lines
bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) { bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) {
if (IsLocationList()) if (IsLocationList())
return false; return false;
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
while (m_data.ValidOffset(offset)) { while (m_data.ValidOffset(offset)) {
const uint8_t op = m_data.GetU8(&offset); const uint8_t op = m_data.GetU8(&offset);
if (op == DW_OP_addr) { if (op == llvm::dwarf::DW_OP_addr) {
const uint32_t addr_byte_size = m_data.GetAddressByteSize(); const uint32_t addr_byte_size = m_data.GetAddressByteSize();
// We have to make a copy of the data as we don't know if this data is // We have to make a copy of the data as we don't know if this data is
// from a read only memory mapped buffer, so we duplicate all of the data // from a read only memory mapped buffer, so we duplicate all of the data
// first, then modify it, and if all goes well, we then replace the data // first, then modify it, and if all goes well, we then replace the data
// for this expression // for this expression
// Make en encoder that contains a copy of the location expression data // Make en encoder that contains a copy of the location expression data
// so we can write the address into the buffer using the correct byte // so we can write the address into the buffer using the correct byte
Show All 24 Linesbool DWARFExpression::ContainsThreadLocalStorage() const {
// location list. This has been true for all thread local variables we have // location list. This has been true for all thread local variables we have
// seen so far produced by any compiler. // seen so far produced by any compiler.
if (IsLocationList()) if (IsLocationList())
return false; return false;
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
while (m_data.ValidOffset(offset)) { while (m_data.ValidOffset(offset)) {
const uint8_t op = m_data.GetU8(&offset); const uint8_t op = m_data.GetU8(&offset);
if (op == DW_OP_form_tls_address || op == DW_OP_GNU_push_tls_address) if (op == llvm::dwarf::DW_OP_form_tls_address ||
op == llvm::dwarf::DW_OP_GNU_push_tls_address)
return true; return true;
const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
if (op_arg_size == LLDB_INVALID_OFFSET) if (op_arg_size == LLDB_INVALID_OFFSET)
return false; return false;
else else
offset += op_arg_size; offset += op_arg_size;
} }
return false; return false;
Show All 23 Linesbool DWARFExpression::LinkThreadLocalStorage(
lldb::offset_t const_offset = 0; lldb::offset_t const_offset = 0;
lldb::addr_t const_value = 0; lldb::addr_t const_value = 0;
size_t const_byte_size = 0; size_t const_byte_size = 0;
while (m_data.ValidOffset(offset)) { while (m_data.ValidOffset(offset)) {
const uint8_t op = m_data.GetU8(&offset); const uint8_t op = m_data.GetU8(&offset);
bool decoded_data = false; bool decoded_data = false;
switch (op) { switch (op) {
case DW_OP_const4u: case llvm::dwarf::DW_OP_const4u:
// Remember the const offset in case we later have a // Remember the const offset in case we later have a
// DW_OP_form_tls_address or DW_OP_GNU_push_tls_address // DW_OP_form_tls_address or DW_OP_GNU_push_tls_address
const_offset = offset; const_offset = offset;
const_value = m_data.GetU32(&offset); const_value = m_data.GetU32(&offset);
decoded_data = true; decoded_data = true;
const_byte_size = 4; const_byte_size = 4;
break; break;
case DW_OP_const8u: case llvm::dwarf::DW_OP_const8u:
// Remember the const offset in case we later have a // Remember the const offset in case we later have a
// DW_OP_form_tls_address or DW_OP_GNU_push_tls_address // llvm::dwarf::DW_OP_form_tls_address or DW_OP_GNU_push_tls_address
const_offset = offset; const_offset = offset;
const_value = m_data.GetU64(&offset); const_value = m_data.GetU64(&offset);
decoded_data = true; decoded_data = true;
const_byte_size = 8; const_byte_size = 8;
break; break;
case DW_OP_form_tls_address: case llvm::dwarf::DW_OP_form_tls_address:
case DW_OP_GNU_push_tls_address: case llvm::dwarf::DW_OP_GNU_push_tls_address:
// DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be preceded // DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be preceded
// by a file address on the stack. We assume that DW_OP_const4u or // by a file address on the stack. We assume that DW_OP_const4u or
// DW_OP_const8u is used for these values, and we check that the last // DW_OP_const8u is used for these values, and we check that the last
// opcode we got before either of these was DW_OP_const4u or // opcode we got before either of these was DW_OP_const4u or
// DW_OP_const8u. If so, then we can link the value accodingly. For // DW_OP_const8u. If so, then we can link the value accodingly. For
// Darwin, the value in the DW_OP_const4u or DW_OP_const8u is the file // Darwin, the value in the DW_OP_const4u or DW_OP_const8u is the file
// address of a structure that contains a function pointer, the pthread // address of a structure that contains a function pointer, the pthread
// key and the offset into the data pointed to by the pthread key. So we // key and the offset into the data pointed to by the pthread key. So we
▲ Show 20 Lines • Show All 377 Lines • ▼ Show 20 Lines
} // namespace } // namespace
bool DWARFExpression::Evaluate( bool DWARFExpression::Evaluate(
ExecutionContext *exe_ctx, RegisterContext *reg_ctx, ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
lldb::ModuleSP module_sp, const DataExtractor &opcodes, lldb::ModuleSP module_sp, const DataExtractor &opcodes,
const DWARFUnit *dwarf_cu, const lldb::RegisterKind reg_kind, const DWARFUnit *dwarf_cu, const lldb::RegisterKind reg_kind,
const Value *initial_value_ptr, const Value *object_address_ptr, const Value *initial_value_ptr, const Value *object_address_ptr,
Value &result, Status *error_ptr) { Value &result, Status *error_ptr) {
using namespace llvm::dwarf;
if (opcodes.GetByteSize() == 0) { if (opcodes.GetByteSize() == 0) {
if (error_ptr) if (error_ptr)
error_ptr->SetErrorString( error_ptr->SetErrorString(
"no location, value may have been optimized out"); "no location, value may have been optimized out");
return false; return false;
} }
std::vector<Value> stack; std::vector<Value> stack;
▲ Show 20 Lines • Show All 1,783 Lines • ▼ Show 20 Lines else
return false; return false;
} else } else
opcodes = m_data; opcodes = m_data;
lldb::offset_t op_offset = 0; lldb::offset_t op_offset = 0;
uint8_t opcode = opcodes.GetU8(&op_offset); uint8_t opcode = opcodes.GetU8(&op_offset);
if (opcode == DW_OP_fbreg) { if (opcode == llvm::dwarf::DW_OP_fbreg) {
int64_t offset = opcodes.GetSLEB128(&op_offset); int64_t offset = opcodes.GetSLEB128(&op_offset);
DWARFExpression *fb_expr = frame.GetFrameBaseExpression(nullptr); DWARFExpression *fb_expr = frame.GetFrameBaseExpression(nullptr);
if (!fb_expr) { if (!fb_expr) {
return false; return false;
} }
auto recurse = [&frame, fb_expr](const Instruction::Operand &child) { auto recurse = [&frame, fb_expr](const Instruction::Operand &child) {
Show All 11 Lines return MatchUnaryOp(
MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum), MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
MatchImmOp(offset), recurse))(operand); MatchImmOp(offset), recurse))(operand);
} }
bool dereference = false; bool dereference = false;
const RegisterInfo *reg = nullptr; const RegisterInfo *reg = nullptr;
int64_t offset = 0; int64_t offset = 0;
if (opcode >= DW_OP_reg0 && opcode <= DW_OP_reg31) { if (opcode >= llvm::dwarf::DW_OP_reg0 && opcode <= llvm::dwarf::DW_OP_reg31) {
reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_reg0); reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind,
} else if (opcode >= DW_OP_breg0 && opcode <= DW_OP_breg31) { opcode - llvm::dwarf::DW_OP_reg0);
} else if (opcode >= llvm::dwarf::DW_OP_breg0 &&
opcode <= llvm::dwarf::DW_OP_breg31) {
offset = opcodes.GetSLEB128(&op_offset); offset = opcodes.GetSLEB128(&op_offset);
reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_breg0); reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind,
} else if (opcode == DW_OP_regx) { opcode - llvm::dwarf::DW_OP_breg0);
} else if (opcode == llvm::dwarf::DW_OP_regx) {
uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset)); uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset));
reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num); reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num);
} else if (opcode == DW_OP_bregx) { } else if (opcode == llvm::dwarf::DW_OP_bregx) {
uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset)); uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset));
offset = opcodes.GetSLEB128(&op_offset); offset = opcodes.GetSLEB128(&op_offset);
reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num); reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num);
} else { } else {
return false; return false;
} }
if (!reg) { if (!reg) {
Show All 19 Lines

lldb/source/Plugins/Process/minidump/MinidumpParser.h

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
class MinidumpParser { class MinidumpParser {
public: public:
static llvm::Expected<MinidumpParser> static llvm::Expected<MinidumpParser>
Create(const lldb::DataBufferSP &data_buf_sp); Create(const lldb::DataBufferSP &data_buf_sp);
llvm::ArrayRef<uint8_t> GetData(); llvm::ArrayRef<uint8_t> GetData();
llvm::ArrayRef<uint8_t> GetStream(StreamType stream_type); llvm::ArrayRef<uint8_t> GetStream(llvm::minidump::StreamType stream_type);
UUID GetModuleUUID(const minidump::Module *module); UUID GetModuleUUID(const llvm::minidump::Module *module);
llvm::ArrayRef<minidump::Thread> GetThreads(); llvm::ArrayRef<llvm::minidump::Thread> GetThreads();
llvm::ArrayRef<uint8_t> GetThreadContext(const LocationDescriptor &location); llvm::ArrayRef<uint8_t>
GetThreadContext(const llvm::minidump::LocationDescriptor &location);
llvm::ArrayRef<uint8_t> GetThreadContext(const minidump::Thread &td); llvm::ArrayRef<uint8_t> GetThreadContext(const llvm::minidump::Thread &td);
llvm::ArrayRef<uint8_t> GetThreadContextWow64(const minidump::Thread &td); llvm::ArrayRef<uint8_t>
GetThreadContextWow64(const llvm::minidump::Thread &td);
ArchSpec GetArchitecture(); ArchSpec GetArchitecture();
const MinidumpMiscInfo *GetMiscInfo(); const MinidumpMiscInfo *GetMiscInfo();
llvm::Optional<LinuxProcStatus> GetLinuxProcStatus(); llvm::Optional<LinuxProcStatus> GetLinuxProcStatus();
llvm::Optional<lldb::pid_t> GetPid(); llvm::Optional<lldb::pid_t> GetPid();
llvm::ArrayRef<minidump::Module> GetModuleList(); llvm::ArrayRef<llvm::minidump::Module> GetModuleList();
// There are cases in which there is more than one record in the ModuleList // There are cases in which there is more than one record in the ModuleList
// for the same module name.(e.g. when the binary has non contiguous segments) // for the same module name.(e.g. when the binary has non contiguous segments)
// So this function returns a filtered module list - if it finds records that // So this function returns a filtered module list - if it finds records that
// have the same name, it keeps the copy with the lowest load address. // have the same name, it keeps the copy with the lowest load address.
std::vector<const minidump::Module *> GetFilteredModuleList(); std::vector<const llvm::minidump::Module *> GetFilteredModuleList();
const llvm::minidump::ExceptionStream *GetExceptionStream(); const llvm::minidump::ExceptionStream *GetExceptionStream();
llvm::Optional<Range> FindMemoryRange(lldb::addr_t addr); llvm::Optional<Range> FindMemoryRange(lldb::addr_t addr);
llvm::ArrayRef<uint8_t> GetMemory(lldb::addr_t addr, size_t size); llvm::ArrayRef<uint8_t> GetMemory(lldb::addr_t addr, size_t size);
/// Returns a list of memory regions and a flag indicating whether the list is /// Returns a list of memory regions and a flag indicating whether the list is
/// complete (includes all regions mapped into the process memory). /// complete (includes all regions mapped into the process memory).
std::pair<MemoryRegionInfos, bool> BuildMemoryRegions(); std::pair<MemoryRegionInfos, bool> BuildMemoryRegions();
static llvm::StringRef GetStreamTypeAsString(StreamType stream_type); static llvm::StringRef
GetStreamTypeAsString(llvm::minidump::StreamType stream_type);
llvm::object::MinidumpFile &GetMinidumpFile() { return *m_file; } llvm::object::MinidumpFile &GetMinidumpFile() { return *m_file; }
static MemoryRegionInfo GetMemoryRegionInfo(const MemoryRegionInfos &regions, static MemoryRegionInfo GetMemoryRegionInfo(const MemoryRegionInfos &regions,
lldb::addr_t load_addr); lldb::addr_t load_addr);
private: private:
MinidumpParser(lldb::DataBufferSP data_sp, MinidumpParser(lldb::DataBufferSP data_sp,
Show All 10 Lines

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

Show All 38 LinesMinidumpParser::MinidumpParser(lldb::DataBufferSP data_sp,
std::unique_ptr<llvm::object::MinidumpFile> file) std::unique_ptr<llvm::object::MinidumpFile> file)
: m_data_sp(std::move(data_sp)), m_file(std::move(file)) {} : m_data_sp(std::move(data_sp)), m_file(std::move(file)) {}
llvm::ArrayRef<uint8_t> MinidumpParser::GetData() { llvm::ArrayRef<uint8_t> MinidumpParser::GetData() {
return llvm::ArrayRef<uint8_t>(m_data_sp->GetBytes(), return llvm::ArrayRef<uint8_t>(m_data_sp->GetBytes(),
m_data_sp->GetByteSize()); m_data_sp->GetByteSize());
} }
llvm::ArrayRef<uint8_t> MinidumpParser::GetStream(StreamType stream_type) { llvm::ArrayRef<uint8_t>
MinidumpParser::GetStream(llvm::minidump::StreamType stream_type) {
return m_file->getRawStream(stream_type) return m_file->getRawStream(stream_type)
.getValueOr(llvm::ArrayRef<uint8_t>()); .getValueOr(llvm::ArrayRef<uint8_t>());
} }
UUID MinidumpParser::GetModuleUUID(const minidump::Module *module) { UUID MinidumpParser::GetModuleUUID(const llvm::minidump::Module *module) {
auto cv_record = auto cv_record =
GetData().slice(module->CvRecord.RVA, module->CvRecord.DataSize); GetData().slice(module->CvRecord.RVA, module->CvRecord.DataSize);
// Read the CV record signature // Read the CV record signature
const llvm::support::ulittle32_t *signature = nullptr; const llvm::support::ulittle32_t *signature = nullptr;
Status error = consumeObject(cv_record, signature); Status error = consumeObject(cv_record, signature);
if (error.Fail()) if (error.Fail())
return UUID(); return UUID();
Show All 14 Lines if (cv_signature == CvSignature::Pdb70) {
} }
return UUID::fromCvRecord(*pdb70_uuid); return UUID::fromCvRecord(*pdb70_uuid);
} else if (cv_signature == CvSignature::ElfBuildId) } else if (cv_signature == CvSignature::ElfBuildId)
return UUID::fromOptionalData(cv_record); return UUID::fromOptionalData(cv_record);
return UUID(); return UUID();
} }
llvm::ArrayRef<minidump::Thread> MinidumpParser::GetThreads() { llvm::ArrayRef<llvm::minidump::Thread> MinidumpParser::GetThreads() {
auto ExpectedThreads = GetMinidumpFile().getThreadList(); auto ExpectedThreads = GetMinidumpFile().getThreadList();
if (ExpectedThreads) if (ExpectedThreads)
return *ExpectedThreads; return *ExpectedThreads;
LLDB_LOG_ERROR(GetLog(LLDBLog::Thread), ExpectedThreads.takeError(), LLDB_LOG_ERROR(GetLog(LLDBLog::Thread), ExpectedThreads.takeError(),
"Failed to read thread list: {0}"); "Failed to read thread list: {0}");
return {}; return {};
} }
llvm::ArrayRef<uint8_t> llvm::ArrayRef<uint8_t> MinidumpParser::GetThreadContext(
MinidumpParser::GetThreadContext(const LocationDescriptor &location) { const llvm::minidump::LocationDescriptor &location) {
if (location.RVA + location.DataSize > GetData().size()) if (location.RVA + location.DataSize > GetData().size())
return {}; return {};
return GetData().slice(location.RVA, location.DataSize); return GetData().slice(location.RVA, location.DataSize);
} }
llvm::ArrayRef<uint8_t> llvm::ArrayRef<uint8_t>
MinidumpParser::GetThreadContext(const minidump::Thread &td) { MinidumpParser::GetThreadContext(const llvm::minidump::Thread &td) {
return GetThreadContext(td.Context); return GetThreadContext(td.Context);
} }
llvm::ArrayRef<uint8_t> llvm::ArrayRef<uint8_t>
MinidumpParser::GetThreadContextWow64(const minidump::Thread &td) { MinidumpParser::GetThreadContextWow64(const llvm::minidump::Thread &td) {
// On Windows, a 32-bit process can run on a 64-bit machine under WOW64. If // On Windows, a 32-bit process can run on a 64-bit machine under WOW64. If
// the minidump was captured with a 64-bit debugger, then the CONTEXT we just // the minidump was captured with a 64-bit debugger, then the CONTEXT we just
// grabbed from the mini_dump_thread is the one for the 64-bit "native" // grabbed from the mini_dump_thread is the one for the 64-bit "native"
// process rather than the 32-bit "guest" process we care about. In this // process rather than the 32-bit "guest" process we care about. In this
// case, we can get the 32-bit CONTEXT from the TEB (Thread Environment // case, we can get the 32-bit CONTEXT from the TEB (Thread Environment
// Block) of the 64-bit process. // Block) of the 64-bit process.
auto teb_mem = GetMemory(td.EnvironmentBlock, sizeof(TEB64)); auto teb_mem = GetMemory(td.EnvironmentBlock, sizeof(TEB64));
if (teb_mem.empty()) if (teb_mem.empty())
Show All 14 LinesMinidumpParser::GetThreadContextWow64(const llvm::minidump::Thread &td) {
return context; return context;
// NOTE: We don't currently use the TEB for anything else. If we // NOTE: We don't currently use the TEB for anything else. If we
// need it in the future, the 32-bit TEB is located according to the address // need it in the future, the 32-bit TEB is located according to the address
// stored in the first slot of the 64-bit TEB (wow64teb.Reserved1[0]). // stored in the first slot of the 64-bit TEB (wow64teb.Reserved1[0]).
} }
ArchSpec MinidumpParser::GetArchitecture() { ArchSpec MinidumpParser::GetArchitecture() {
using namespace llvm::minidump;
if (m_arch.IsValid()) if (m_arch.IsValid())
return m_arch; return m_arch;
// Set the architecture in m_arch // Set the architecture in m_arch
llvm::Expected<const SystemInfo &> system_info = m_file->getSystemInfo(); llvm::Expected<const llvm::minidump::SystemInfo &> system_info =
m_file->getSystemInfo();
if (!system_info) { if (!system_info) {
LLDB_LOG_ERROR(GetLog(LLDBLog::Process), system_info.takeError(), LLDB_LOG_ERROR(GetLog(LLDBLog::Process), system_info.takeError(),
"Failed to read SystemInfo stream: {0}"); "Failed to read SystemInfo stream: {0}");
return m_arch; return m_arch;
} }
// TODO what to do about big endiand flavors of arm ? // TODO what to do about big endiand flavors of arm ?
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines default: {
break; break;
} }
} }
m_arch.SetTriple(triple); m_arch.SetTriple(triple);
return m_arch; return m_arch;
} }
const MinidumpMiscInfo *MinidumpParser::GetMiscInfo() { const MinidumpMiscInfo *MinidumpParser::GetMiscInfo() {
llvm::ArrayRef<uint8_t> data = GetStream(StreamType::MiscInfo); llvm::ArrayRef<uint8_t> data =
GetStream(llvm::minidump::StreamType::MiscInfo);
if (data.size() == 0) if (data.size() == 0)
return nullptr; return nullptr;
return MinidumpMiscInfo::Parse(data); return MinidumpMiscInfo::Parse(data);
} }
llvm::Optional<LinuxProcStatus> MinidumpParser::GetLinuxProcStatus() { llvm::Optional<LinuxProcStatus> MinidumpParser::GetLinuxProcStatus() {
llvm::ArrayRef<uint8_t> data = GetStream(StreamType::LinuxProcStatus); llvm::ArrayRef<uint8_t> data =
GetStream(llvm::minidump::StreamType::LinuxProcStatus);
if (data.size() == 0) if (data.size() == 0)
return llvm::None; return llvm::None;
return LinuxProcStatus::Parse(data); return LinuxProcStatus::Parse(data);
} }
llvm::Optional<lldb::pid_t> MinidumpParser::GetPid() { llvm::Optional<lldb::pid_t> MinidumpParser::GetPid() {
const MinidumpMiscInfo *misc_info = GetMiscInfo(); const MinidumpMiscInfo *misc_info = GetMiscInfo();
if (misc_info != nullptr) { if (misc_info != nullptr) {
return misc_info->GetPid(); return misc_info->GetPid();
} }
llvm::Optional<LinuxProcStatus> proc_status = GetLinuxProcStatus(); llvm::Optional<LinuxProcStatus> proc_status = GetLinuxProcStatus();
if (proc_status.hasValue()) { if (proc_status.hasValue()) {
return proc_status->GetPid(); return proc_status->GetPid();
} }
return llvm::None; return llvm::None;
} }
llvm::ArrayRef<minidump::Module> MinidumpParser::GetModuleList() { llvm::ArrayRef<llvm::minidump::Module> MinidumpParser::GetModuleList() {
auto ExpectedModules = GetMinidumpFile().getModuleList(); auto ExpectedModules = GetMinidumpFile().getModuleList();
if (ExpectedModules) if (ExpectedModules)
return *ExpectedModules; return *ExpectedModules;
LLDB_LOG_ERROR(GetLog(LLDBLog::Modules), ExpectedModules.takeError(), LLDB_LOG_ERROR(GetLog(LLDBLog::Modules), ExpectedModules.takeError(),
"Failed to read module list: {0}"); "Failed to read module list: {0}");
return {}; return {};
} }
static bool static bool
CreateRegionsCacheFromLinuxMaps(MinidumpParser &parser, CreateRegionsCacheFromLinuxMaps(MinidumpParser &parser,
std::vector<MemoryRegionInfo> &regions) { std::vector<MemoryRegionInfo> &regions) {
auto data = parser.GetStream(StreamType::LinuxMaps); auto data = parser.GetStream(llvm::minidump::StreamType::LinuxMaps);
if (data.empty()) if (data.empty())
return false; return false;
Log *log = GetLog(LLDBLog::Expressions); Log *log = GetLog(LLDBLog::Expressions);
ParseLinuxMapRegions( ParseLinuxMapRegions(
llvm::toStringRef(data), llvm::toStringRef(data),
[&regions, &log](llvm::Expected<MemoryRegionInfo> region) -> bool { [&regions, &log](llvm::Expected<MemoryRegionInfo> region) -> bool {
if (region) if (region)
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines while (region.GetName() == path) {
if (region.GetExecutable() == MemoryRegionInfo::eYes) if (region.GetExecutable() == MemoryRegionInfo::eYes)
return true; return true;
addr += region.GetRange().GetByteSize(); addr += region.GetRange().GetByteSize();
region = MinidumpParser::GetMemoryRegionInfo(regions, addr); region = MinidumpParser::GetMemoryRegionInfo(regions, addr);
} }
return false; return false;
} }
std::vector<const minidump::Module *> MinidumpParser::GetFilteredModuleList() { std::vector<const llvm::minidump::Module *>
MinidumpParser::GetFilteredModuleList() {
Log *log = GetLog(LLDBLog::Modules); Log *log = GetLog(LLDBLog::Modules);
auto ExpectedModules = GetMinidumpFile().getModuleList(); auto ExpectedModules = GetMinidumpFile().getModuleList();
if (!ExpectedModules) { if (!ExpectedModules) {
LLDB_LOG_ERROR(log, ExpectedModules.takeError(), LLDB_LOG_ERROR(log, ExpectedModules.takeError(),
"Failed to read module list: {0}"); "Failed to read module list: {0}");
return {}; return {};
} }
// Create memory regions from the linux maps only. We do this to avoid issues // Create memory regions from the linux maps only. We do this to avoid issues
// with breakpad generated minidumps where if someone has mmap'ed a shared // with breakpad generated minidumps where if someone has mmap'ed a shared
// library into memory to accesss its data in the object file, we can get a // library into memory to accesss its data in the object file, we can get a
// minidump with two mappings for a binary: one whose base image points to a // minidump with two mappings for a binary: one whose base image points to a
// memory region that is read + execute and one that is read only. // memory region that is read + execute and one that is read only.
MemoryRegionInfos linux_regions; MemoryRegionInfos linux_regions;
if (CreateRegionsCacheFromLinuxMaps(*this, linux_regions)) if (CreateRegionsCacheFromLinuxMaps(*this, linux_regions))
llvm::sort(linux_regions); llvm::sort(linux_regions);
// map module_name -> filtered_modules index // map module_name -> filtered_modules index
typedef llvm::StringMap<size_t> MapType; typedef llvm::StringMap<size_t> MapType;
MapType module_name_to_filtered_index; MapType module_name_to_filtered_index;
std::vector<const minidump::Module *> filtered_modules; std::vector<const llvm::minidump::Module *> filtered_modules;
for (const auto &module : *ExpectedModules) { for (const auto &module : *ExpectedModules) {
auto ExpectedName = m_file->getString(module.ModuleNameRVA); auto ExpectedName = m_file->getString(module.ModuleNameRVA);
if (!ExpectedName) { if (!ExpectedName) {
LLDB_LOG_ERROR(log, ExpectedName.takeError(), LLDB_LOG_ERROR(log, ExpectedName.takeError(),
"Failed to get module name: {0}"); "Failed to get module name: {0}");
continue; continue;
} }
Show All 37 Lines if (inserted) {
// the lowest "base_of_image" and use that as the filtered module. // the lowest "base_of_image" and use that as the filtered module.
if (module.BaseOfImage < dup_module->BaseOfImage) if (module.BaseOfImage < dup_module->BaseOfImage)
filtered_modules[iter->second] = &module; filtered_modules[iter->second] = &module;
} }
} }
return filtered_modules; return filtered_modules;
} }
const minidump::ExceptionStream *MinidumpParser::GetExceptionStream() { const llvm::minidump::ExceptionStream *MinidumpParser::GetExceptionStream() {
auto ExpectedStream = GetMinidumpFile().getExceptionStream(); auto ExpectedStream = GetMinidumpFile().getExceptionStream();
if (ExpectedStream) if (ExpectedStream)
return &*ExpectedStream; return &*ExpectedStream;
LLDB_LOG_ERROR(GetLog(LLDBLog::Process), ExpectedStream.takeError(), LLDB_LOG_ERROR(GetLog(LLDBLog::Process), ExpectedStream.takeError(),
"Failed to read minidump exception stream: {0}"); "Failed to read minidump exception stream: {0}");
return nullptr; return nullptr;
} }
llvm::Optional<minidump::Range> llvm::Optional<minidump::Range>
MinidumpParser::FindMemoryRange(lldb::addr_t addr) { MinidumpParser::FindMemoryRange(lldb::addr_t addr) {
llvm::ArrayRef<uint8_t> data64 = GetStream(StreamType::Memory64List); llvm::ArrayRef<uint8_t> data64 =
GetStream(llvm::minidump::StreamType::Memory64List);
Log *log = GetLog(LLDBLog::Modules); Log *log = GetLog(LLDBLog::Modules);
auto ExpectedMemory = GetMinidumpFile().getMemoryList(); auto ExpectedMemory = GetMinidumpFile().getMemoryList();
if (!ExpectedMemory) { if (!ExpectedMemory) {
LLDB_LOG_ERROR(log, ExpectedMemory.takeError(), LLDB_LOG_ERROR(log, ExpectedMemory.takeError(),
"Failed to read memory list: {0}"); "Failed to read memory list: {0}");
} else { } else {
for (const auto &memory_desc : *ExpectedMemory) { for (const auto &memory_desc : *ExpectedMemory) {
const LocationDescriptor &loc_desc = memory_desc.Memory; const llvm::minidump::LocationDescriptor &loc_desc = memory_desc.Memory;
const lldb::addr_t range_start = memory_desc.StartOfMemoryRange; const lldb::addr_t range_start = memory_desc.StartOfMemoryRange;
const size_t range_size = loc_desc.DataSize; const size_t range_size = loc_desc.DataSize;
if (loc_desc.RVA + loc_desc.DataSize > GetData().size()) if (loc_desc.RVA + loc_desc.DataSize > GetData().size())
return llvm::None; return llvm::None;
if (range_start <= addr && addr < range_start + range_size) { if (range_start <= addr && addr < range_start + range_size) {
auto ExpectedSlice = GetMinidumpFile().getRawData(loc_desc); auto ExpectedSlice = GetMinidumpFile().getRawData(loc_desc);
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 LinesCreateRegionsCacheFromMemoryInfoList(MinidumpParser &parser,
auto ExpectedInfo = parser.GetMinidumpFile().getMemoryInfoList(); auto ExpectedInfo = parser.GetMinidumpFile().getMemoryInfoList();
if (!ExpectedInfo) { if (!ExpectedInfo) {
LLDB_LOG_ERROR(log, ExpectedInfo.takeError(), LLDB_LOG_ERROR(log, ExpectedInfo.takeError(),
"Failed to read memory info list: {0}"); "Failed to read memory info list: {0}");
return false; return false;
} }
constexpr auto yes = MemoryRegionInfo::eYes; constexpr auto yes = MemoryRegionInfo::eYes;
constexpr auto no = MemoryRegionInfo::eNo; constexpr auto no = MemoryRegionInfo::eNo;
for (const MemoryInfo &entry : *ExpectedInfo) { for (const llvm::minidump::MemoryInfo &entry : *ExpectedInfo) {
MemoryRegionInfo region; MemoryRegionInfo region;
region.GetRange().SetRangeBase(entry.BaseAddress); region.GetRange().SetRangeBase(entry.BaseAddress);
region.GetRange().SetByteSize(entry.RegionSize); region.GetRange().SetByteSize(entry.RegionSize);
MemoryProtection prot = entry.Protect; llvm::minidump::MemoryProtection prot = entry.Protect;
region.SetReadable(bool(prot & MemoryProtection::NoAccess) ? no : yes); region.SetReadable(
bool(prot & llvm::minidump::MemoryProtection::NoAccess) ? no : yes);
region.SetWritable( region.SetWritable(
bool(prot & (MemoryProtection::ReadWrite | MemoryProtection::WriteCopy | bool(prot & (llvm::minidump::MemoryProtection::ReadWrite |
MemoryProtection::ExecuteReadWrite | llvm::minidump::MemoryProtection::WriteCopy |
MemoryProtection::ExeciteWriteCopy)) llvm::minidump::MemoryProtection::ExecuteReadWrite |
llvm::minidump::MemoryProtection::ExeciteWriteCopy))
? yes ? yes
: no); : no);
region.SetExecutable( region.SetExecutable(
bool(prot & (MemoryProtection::Execute | MemoryProtection::ExecuteRead | bool(prot & (llvm::minidump::MemoryProtection::Execute |
MemoryProtection::ExecuteReadWrite | llvm::minidump::MemoryProtection::ExecuteRead |
MemoryProtection::ExeciteWriteCopy)) llvm::minidump::MemoryProtection::ExecuteReadWrite |
llvm::minidump::MemoryProtection::ExeciteWriteCopy))
? yes ? yes
: no); : no);
region.SetMapped(entry.State != MemoryState::Free ? yes : no); region.SetMapped(entry.State != llvm::minidump::MemoryState::Free ? yes
: no);
regions.push_back(region); regions.push_back(region);
} }
return !regions.empty(); return !regions.empty();
} }
static bool static bool
CreateRegionsCacheFromMemoryList(MinidumpParser &parser, CreateRegionsCacheFromMemoryList(MinidumpParser &parser,
std::vector<MemoryRegionInfo> &regions) { std::vector<MemoryRegionInfo> &regions) {
Log *log = GetLog(LLDBLog::Modules); Log *log = GetLog(LLDBLog::Modules);
auto ExpectedMemory = parser.GetMinidumpFile().getMemoryList(); auto ExpectedMemory = parser.GetMinidumpFile().getMemoryList();
if (!ExpectedMemory) { if (!ExpectedMemory) {
LLDB_LOG_ERROR(log, ExpectedMemory.takeError(), LLDB_LOG_ERROR(log, ExpectedMemory.takeError(),
"Failed to read memory list: {0}"); "Failed to read memory list: {0}");
return false; return false;
} }
regions.reserve(ExpectedMemory->size()); regions.reserve(ExpectedMemory->size());
for (const MemoryDescriptor &memory_desc : *ExpectedMemory) { for (const llvm::minidump::MemoryDescriptor &memory_desc : *ExpectedMemory) {
if (memory_desc.Memory.DataSize == 0) if (memory_desc.Memory.DataSize == 0)
continue; continue;
MemoryRegionInfo region; MemoryRegionInfo region;
region.GetRange().SetRangeBase(memory_desc.StartOfMemoryRange); region.GetRange().SetRangeBase(memory_desc.StartOfMemoryRange);
region.GetRange().SetByteSize(memory_desc.Memory.DataSize); region.GetRange().SetByteSize(memory_desc.Memory.DataSize);
region.SetReadable(MemoryRegionInfo::eYes); region.SetReadable(MemoryRegionInfo::eYes);
region.SetMapped(MemoryRegionInfo::eYes); region.SetMapped(MemoryRegionInfo::eYes);
regions.push_back(region); regions.push_back(region);
} }
regions.shrink_to_fit(); regions.shrink_to_fit();
return !regions.empty(); return !regions.empty();
} }
static bool static bool
CreateRegionsCacheFromMemory64List(MinidumpParser &parser, CreateRegionsCacheFromMemory64List(MinidumpParser &parser,
std::vector<MemoryRegionInfo> &regions) { std::vector<MemoryRegionInfo> &regions) {
llvm::ArrayRef<uint8_t> data = llvm::ArrayRef<uint8_t> data =
parser.GetStream(StreamType::Memory64List); parser.GetStream(llvm::minidump::StreamType::Memory64List);
if (data.empty()) if (data.empty())
return false; return false;
llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list; llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list;
uint64_t base_rva; uint64_t base_rva;
std::tie(memory64_list, base_rva) = std::tie(memory64_list, base_rva) =
MinidumpMemoryDescriptor64::ParseMemory64List(data); MinidumpMemoryDescriptor64::ParseMemory64List(data);
if (memory64_list.empty()) if (memory64_list.empty())
Show All 32 Lines if (CreateRegionsCacheFromMemoryInfoList(*this, result))
return return_sorted(true); return return_sorted(true);
if (CreateRegionsCacheFromMemoryList(*this, result)) if (CreateRegionsCacheFromMemoryList(*this, result))
return return_sorted(false); return return_sorted(false);
CreateRegionsCacheFromMemory64List(*this, result); CreateRegionsCacheFromMemory64List(*this, result);
return return_sorted(false); return return_sorted(false);
} }
#define ENUM_TO_CSTR(ST) \ #define ENUM_TO_CSTR(ST) \
case StreamType::ST: \ case llvm::minidump::StreamType::ST: \
return #ST return #ST
llvm::StringRef llvm::StringRef
MinidumpParser::GetStreamTypeAsString(StreamType stream_type) { MinidumpParser::GetStreamTypeAsString(llvm::minidump::StreamType stream_type) {
using namespace llvm::minidump;
switch (stream_type) { switch (stream_type) {
ENUM_TO_CSTR(Unused); ENUM_TO_CSTR(Unused);
ENUM_TO_CSTR(ThreadList); ENUM_TO_CSTR(ThreadList);
ENUM_TO_CSTR(ModuleList); ENUM_TO_CSTR(ModuleList);
ENUM_TO_CSTR(MemoryList); ENUM_TO_CSTR(MemoryList);
ENUM_TO_CSTR(Exception); ENUM_TO_CSTR(Exception);
ENUM_TO_CSTR(SystemInfo); ENUM_TO_CSTR(SystemInfo);
ENUM_TO_CSTR(ThreadExList); ENUM_TO_CSTR(ThreadExList);
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/minidump/MinidumpTypes.h

Show All 25 Lines
// Reference: // Reference:
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms679293(v=vs.85).aspx // https://msdn.microsoft.com/en-us/library/windows/desktop/ms679293(v=vs.85).aspx
// https://chromium.googlesource.com/breakpad/breakpad/ // https://chromium.googlesource.com/breakpad/breakpad/
namespace lldb_private { namespace lldb_private {
namespace minidump { namespace minidump {
using namespace llvm::minidump;
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
enum class CvSignature : uint32_t { enum class CvSignature : uint32_t {
Pdb70 = 0x53445352, // RSDS Pdb70 = 0x53445352, // RSDS
ElfBuildId = 0x4270454c, // BpEL (Breakpad/Crashpad minidumps) ElfBuildId = 0x4270454c, // BpEL (Breakpad/Crashpad minidumps)
}; };
enum class MinidumpMiscInfoFlags : uint32_t { enum class MinidumpMiscInfoFlags : uint32_t {
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/minidump/ProcessMinidump.h

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines lldb::ModuleSP GetOrCreateModule(lldb_private::UUID minidump_uuid,
llvm::StringRef name, llvm::StringRef name,
lldb_private::ModuleSpec module_spec); lldb_private::ModuleSpec module_spec);
JITLoaderList &GetJITLoaders() override; JITLoaderList &GetJITLoaders() override;
private: private:
FileSpec m_core_file; FileSpec m_core_file;
lldb::DataBufferSP m_core_data; lldb::DataBufferSP m_core_data;
llvm::ArrayRef<minidump::Thread> m_thread_list; llvm::ArrayRef<llvm::minidump::Thread> m_thread_list;
const minidump::ExceptionStream *m_active_exception; const llvm::minidump::ExceptionStream *m_active_exception;
lldb::CommandObjectSP m_command_sp; lldb::CommandObjectSP m_command_sp;
bool m_is_wow64; bool m_is_wow64;
llvm::Optional<MemoryRegionInfos> m_memory_regions; llvm::Optional<MemoryRegionInfos> m_memory_regions;
void BuildMemoryRegions(); void BuildMemoryRegions();
}; };
} // namespace minidump } // namespace minidump
} // namespace lldb_private } // namespace lldb_private
#endif // LLDB_SOURCE_PLUGINS_PROCESS_MINIDUMP_PROCESSMINIDUMP_H #endif // LLDB_SOURCE_PLUGINS_PROCESS_MINIDUMP_PROCESSMINIDUMP_H

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lineslldb::ProcessSP ProcessMinidump::CreateInstance(lldb::TargetSP target_sp,
lldb::ListenerSP listener_sp, lldb::ListenerSP listener_sp,
const FileSpec *crash_file, const FileSpec *crash_file,
bool can_connect) { bool can_connect) {
if (!crash_file || can_connect) if (!crash_file || can_connect)
return nullptr; return nullptr;
lldb::ProcessSP process_sp; lldb::ProcessSP process_sp;
// Read enough data for the Minidump header // Read enough data for the Minidump header
constexpr size_t header_size = sizeof(Header); constexpr size_t header_size = sizeof(llvm::minidump::Header);
auto DataPtr = FileSystem::Instance().CreateDataBuffer(crash_file->GetPath(), auto DataPtr = FileSystem::Instance().CreateDataBuffer(crash_file->GetPath(),
header_size, 0); header_size, 0);
if (!DataPtr) if (!DataPtr)
return nullptr; return nullptr;
lldbassert(DataPtr->GetByteSize() == header_size); lldbassert(DataPtr->GetByteSize() == header_size);
if (identify_magic(toStringRef(DataPtr->GetData())) != llvm::file_magic::minidump) if (identify_magic(toStringRef(DataPtr->GetData())) != llvm::file_magic::minidump)
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 LinesStatus ProcessMinidump::GetMemoryRegions(MemoryRegionInfos &region_list) {
region_list = *m_memory_regions; region_list = *m_memory_regions;
return Status(); return Status();
} }
void ProcessMinidump::Clear() { Process::m_thread_list.Clear(); } void ProcessMinidump::Clear() { Process::m_thread_list.Clear(); }
bool ProcessMinidump::DoUpdateThreadList(ThreadList &old_thread_list, bool ProcessMinidump::DoUpdateThreadList(ThreadList &old_thread_list,
ThreadList &new_thread_list) { ThreadList &new_thread_list) {
for (const minidump::Thread &thread : m_thread_list) { for (const llvm::minidump::Thread &thread : m_thread_list) {
LocationDescriptor context_location = thread.Context; llvm::minidump::LocationDescriptor context_location = thread.Context;
// If the minidump contains an exception context, use it // If the minidump contains an exception context, use it
if (m_active_exception != nullptr && if (m_active_exception != nullptr &&
m_active_exception->ThreadId == thread.ThreadId) { m_active_exception->ThreadId == thread.ThreadId) {
context_location = m_active_exception->ThreadContext; context_location = m_active_exception->ThreadContext;
} }
llvm::ArrayRef<uint8_t> context; llvm::ArrayRef<uint8_t> context;
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 LinesModuleSP ProcessMinidump::GetOrCreateModule(UUID minidump_uuid,
// so remove the module from the target, we will need to create a // so remove the module from the target, we will need to create a
// placeholder object file. // placeholder object file.
GetTarget().GetImages().Remove(module_sp); GetTarget().GetImages().Remove(module_sp);
module_sp.reset(); module_sp.reset();
return module_sp; return module_sp;
} }
void ProcessMinidump::ReadModuleList() { void ProcessMinidump::ReadModuleList() {
std::vector<const minidump::Module *> filtered_modules = std::vector<const llvm::minidump::Module *> filtered_modules =
m_minidump_parser->GetFilteredModuleList(); m_minidump_parser->GetFilteredModuleList();
Log *log = GetLog(LLDBLog::DynamicLoader); Log *log = GetLog(LLDBLog::DynamicLoader);
for (auto module : filtered_modules) { for (auto module : filtered_modules) {
std::string name = cantFail(m_minidump_parser->GetMinidumpFile().getString( std::string name = cantFail(m_minidump_parser->GetMinidumpFile().getString(
module->ModuleNameRVA)); module->ModuleNameRVA));
const uint64_t load_addr = module->BaseOfImage; const uint64_t load_addr = module->BaseOfImage;
▲ Show 20 Lines • Show All 347 Lines • ▼ Show 20 Lines bool DoExecute(Args &command, CommandReturnObject &result) override {
MinidumpParser &minidump = *process->m_minidump_parser; MinidumpParser &minidump = *process->m_minidump_parser;
if (DumpDirectory()) { if (DumpDirectory()) {
s.Printf("RVA SIZE TYPE StreamType\n"); s.Printf("RVA SIZE TYPE StreamType\n");
s.Printf("---------- ---------- ---------- --------------------------\n"); s.Printf("---------- ---------- ---------- --------------------------\n");
for (const auto &stream_desc : minidump.GetMinidumpFile().streams()) for (const auto &stream_desc : minidump.GetMinidumpFile().streams())
s.Printf( s.Printf(
"0x%8.8x 0x%8.8x 0x%8.8x %s\n", (uint32_t)stream_desc.Location.RVA, "0x%8.8x 0x%8.8x 0x%8.8x %s\n", (uint32_t)stream_desc.Location.RVA,
(uint32_t)stream_desc.Location.DataSize, (uint32_t)stream_desc.Location.DataSize,
(unsigned)(StreamType)stream_desc.Type, (unsigned)(llvm::minidump::StreamType)stream_desc.Type,
MinidumpParser::GetStreamTypeAsString(stream_desc.Type).data()); MinidumpParser::GetStreamTypeAsString(stream_desc.Type).data());
s.Printf("\n"); s.Printf("\n");
} }
auto DumpTextStream = [&](StreamType stream_type, auto DumpTextStream = [&](llvm::minidump::StreamType stream_type,
llvm::StringRef label) -> void { llvm::StringRef label) -> void {
auto bytes = minidump.GetStream(stream_type); auto bytes = minidump.GetStream(stream_type);
if (!bytes.empty()) { if (!bytes.empty()) {
if (label.empty()) if (label.empty())
label = MinidumpParser::GetStreamTypeAsString(stream_type); label = MinidumpParser::GetStreamTypeAsString(stream_type);
s.Printf("%s:\n%s\n\n", label.data(), bytes.data()); s.Printf("%s:\n%s\n\n", label.data(), bytes.data());
} }
}; };
auto DumpBinaryStream = [&](StreamType stream_type, auto DumpBinaryStream = [&](llvm::minidump::StreamType stream_type,
llvm::StringRef label) -> void { llvm::StringRef label) -> void {
auto bytes = minidump.GetStream(stream_type); auto bytes = minidump.GetStream(stream_type);
if (!bytes.empty()) { if (!bytes.empty()) {
if (label.empty()) if (label.empty())
label = MinidumpParser::GetStreamTypeAsString(stream_type); label = MinidumpParser::GetStreamTypeAsString(stream_type);
s.Printf("%s:\n", label.data()); s.Printf("%s:\n", label.data());
DataExtractor data(bytes.data(), bytes.size(), eByteOrderLittle, DataExtractor data(bytes.data(), bytes.size(), eByteOrderLittle,
process->GetAddressByteSize()); process->GetAddressByteSize());
DumpDataExtractor(data, &s, 0, lldb::eFormatBytesWithASCII, 1, DumpDataExtractor(data, &s, 0, lldb::eFormatBytesWithASCII, 1,
bytes.size(), 16, 0, 0, 0); bytes.size(), 16, 0, 0, 0);
s.Printf("\n\n"); s.Printf("\n\n");
} }
}; };
if (DumpLinuxCPUInfo()) if (DumpLinuxCPUInfo())
DumpTextStream(StreamType::LinuxCPUInfo, "/proc/cpuinfo"); DumpTextStream(llvm::minidump::StreamType::LinuxCPUInfo, "/proc/cpuinfo");
if (DumpLinuxProcStatus()) if (DumpLinuxProcStatus())
DumpTextStream(StreamType::LinuxProcStatus, "/proc/PID/status"); DumpTextStream(llvm::minidump::StreamType::LinuxProcStatus,
"/proc/PID/status");
if (DumpLinuxLSBRelease()) if (DumpLinuxLSBRelease())
DumpTextStream(StreamType::LinuxLSBRelease, "/etc/lsb-release"); DumpTextStream(llvm::minidump::StreamType::LinuxLSBRelease,
"/etc/lsb-release");
if (DumpLinuxCMDLine()) if (DumpLinuxCMDLine())
DumpTextStream(StreamType::LinuxCMDLine, "/proc/PID/cmdline"); DumpTextStream(llvm::minidump::StreamType::LinuxCMDLine,
"/proc/PID/cmdline");
if (DumpLinuxEnviron()) if (DumpLinuxEnviron())
DumpTextStream(StreamType::LinuxEnviron, "/proc/PID/environ"); DumpTextStream(llvm::minidump::StreamType::LinuxEnviron,
"/proc/PID/environ");
if (DumpLinuxAuxv()) if (DumpLinuxAuxv())
DumpBinaryStream(StreamType::LinuxAuxv, "/proc/PID/auxv"); DumpBinaryStream(llvm::minidump::StreamType::LinuxAuxv, "/proc/PID/auxv");
if (DumpLinuxMaps()) if (DumpLinuxMaps())
DumpTextStream(StreamType::LinuxMaps, "/proc/PID/maps"); DumpTextStream(llvm::minidump::StreamType::LinuxMaps, "/proc/PID/maps");
if (DumpLinuxProcStat()) if (DumpLinuxProcStat())
DumpTextStream(StreamType::LinuxProcStat, "/proc/PID/stat"); DumpTextStream(llvm::minidump::StreamType::LinuxProcStat,
"/proc/PID/stat");
if (DumpLinuxProcUptime()) if (DumpLinuxProcUptime())
DumpTextStream(StreamType::LinuxProcUptime, "uptime"); DumpTextStream(llvm::minidump::StreamType::LinuxProcUptime, "uptime");
if (DumpLinuxProcFD()) if (DumpLinuxProcFD())
DumpTextStream(StreamType::LinuxProcFD, "/proc/PID/fd"); DumpTextStream(llvm::minidump::StreamType::LinuxProcFD, "/proc/PID/fd");
if (DumpFacebookAppData()) if (DumpFacebookAppData())
DumpTextStream(StreamType::FacebookAppCustomData, DumpTextStream(llvm::minidump::StreamType::FacebookAppCustomData,
"Facebook App Data"); "Facebook App Data");
if (DumpFacebookBuildID()) { if (DumpFacebookBuildID()) {
auto bytes = minidump.GetStream(StreamType::FacebookBuildID); auto bytes =
minidump.GetStream(llvm::minidump::StreamType::FacebookBuildID);
if (bytes.size() >= 4) { if (bytes.size() >= 4) {
DataExtractor data(bytes.data(), bytes.size(), eByteOrderLittle, DataExtractor data(bytes.data(), bytes.size(), eByteOrderLittle,
process->GetAddressByteSize()); process->GetAddressByteSize());
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
uint32_t build_id = data.GetU32(&offset); uint32_t build_id = data.GetU32(&offset);
s.Printf("Facebook Build ID:\n"); s.Printf("Facebook Build ID:\n");
s.Printf("%u\n", build_id); s.Printf("%u\n", build_id);
s.Printf("\n"); s.Printf("\n");
} }
} }
if (DumpFacebookVersionName()) if (DumpFacebookVersionName())
DumpTextStream(StreamType::FacebookAppVersionName, DumpTextStream(llvm::minidump::StreamType::FacebookAppVersionName,
"Facebook Version String"); "Facebook Version String");
if (DumpFacebookJavaStack()) if (DumpFacebookJavaStack())
DumpTextStream(StreamType::FacebookJavaStack, DumpTextStream(llvm::minidump::StreamType::FacebookJavaStack,
"Facebook Java Stack"); "Facebook Java Stack");
if (DumpFacebookDalvikInfo()) if (DumpFacebookDalvikInfo())
DumpTextStream(StreamType::FacebookDalvikInfo, DumpTextStream(llvm::minidump::StreamType::FacebookDalvikInfo,
"Facebook Dalvik Info"); "Facebook Dalvik Info");
if (DumpFacebookUnwindSymbols()) if (DumpFacebookUnwindSymbols())
DumpBinaryStream(StreamType::FacebookUnwindSymbols, DumpBinaryStream(llvm::minidump::StreamType::FacebookUnwindSymbols,
"Facebook Unwind Symbols Bytes"); "Facebook Unwind Symbols Bytes");
if (DumpFacebookErrorLog()) if (DumpFacebookErrorLog())
DumpTextStream(StreamType::FacebookDumpErrorLog, DumpTextStream(llvm::minidump::StreamType::FacebookDumpErrorLog,
"Facebook Error Log"); "Facebook Error Log");
if (DumpFacebookAppStateLog()) if (DumpFacebookAppStateLog())
DumpTextStream(StreamType::FacebookAppStateLog, DumpTextStream(llvm::minidump::StreamType::FacebookAppStateLog,
"Faceook Application State Log"); "Faceook Application State Log");
if (DumpFacebookAbortReason()) if (DumpFacebookAbortReason())
DumpTextStream(StreamType::FacebookAbortReason, DumpTextStream(llvm::minidump::StreamType::FacebookAbortReason,
"Facebook Abort Reason"); "Facebook Abort Reason");
if (DumpFacebookThreadName()) if (DumpFacebookThreadName())
DumpTextStream(StreamType::FacebookThreadName, DumpTextStream(llvm::minidump::StreamType::FacebookThreadName,
"Facebook Thread Name"); "Facebook Thread Name");
if (DumpFacebookLogcat()) if (DumpFacebookLogcat())
DumpTextStream(StreamType::FacebookLogcat, DumpTextStream(llvm::minidump::StreamType::FacebookLogcat,
"Facebook Logcat"); "Facebook Logcat");
return true; return true;
} }
}; };
class CommandObjectMultiwordProcessMinidump : public CommandObjectMultiword { class CommandObjectMultiwordProcessMinidump : public CommandObjectMultiword {
public: public:
CommandObjectMultiwordProcessMinidump(CommandInterpreter &interpreter) CommandObjectMultiwordProcessMinidump(CommandInterpreter &interpreter)
Show All 16 Lines

lldb/source/Plugins/Process/minidump/ThreadMinidump.h

Show All 14 Lines
namespace lldb_private { namespace lldb_private {
namespace minidump { namespace minidump {
class ThreadMinidump : public Thread { class ThreadMinidump : public Thread {
public: public:
ThreadMinidump(Process &process, const minidump::Thread &td, ThreadMinidump(Process &process, const llvm::minidump::Thread &td,
llvm::ArrayRef<uint8_t> gpregset_data); llvm::ArrayRef<uint8_t> gpregset_data);
~ThreadMinidump() override; ~ThreadMinidump() override;
void RefreshStateAfterStop() override; void RefreshStateAfterStop() override;
lldb::RegisterContextSP GetRegisterContext() override; lldb::RegisterContextSP GetRegisterContext() override;
Show All 14 Lines

lldb/source/Plugins/Process/minidump/ThreadMinidump.cpp

Show All 27 Lines
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
#include <memory> #include <memory>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace minidump; using namespace minidump;
ThreadMinidump::ThreadMinidump(Process &process, const minidump::Thread &td, ThreadMinidump::ThreadMinidump(Process &process,
const llvm::minidump::Thread &td,
llvm::ArrayRef<uint8_t> gpregset_data) llvm::ArrayRef<uint8_t> gpregset_data)
: Thread(process, td.ThreadId), m_thread_reg_ctx_sp(), : Thread(process, td.ThreadId), m_thread_reg_ctx_sp(),
m_gpregset_data(gpregset_data) {} m_gpregset_data(gpregset_data) {}
ThreadMinidump::~ThreadMinidump() = default; ThreadMinidump::~ThreadMinidump() = default;
void ThreadMinidump::RefreshStateAfterStop() {} void ThreadMinidump::RefreshStateAfterStop() {}
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

Show All 10 Lines
#include "Plugins/SymbolFile/DWARF/DWARFUnit.h" #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
#include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h" #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Symbol/Function.h" #include "lldb/Symbol/Function.h"
using namespace lldb_private; using namespace lldb_private;
using namespace lldb; using namespace lldb;
JDevlieghereUnsubmitted
Done
ReplyInline Actions

Wouldn't it be more consistent to use lldb_private::dwarf everywhere?

JDevlieghere: Wouldn't it be more consistent to use `lldb_private::dwarf` everywhere?
shafikAuthorUnsubmitted
Done
ReplyInline Actions

Yeah, I was trying to match the style of how it was done for minidump, see source/Plugins/Process/minidump/MinidumpParser.cpp.

Since we need access to both namespaces but in files that did already have using namespace lldb_private; I just used the less verbose version.

I can see arguments for just being verbose everywhere.

shafik: Yeah, I was trying to match the style of how it was done for minidump, see…
JDevlieghereUnsubmitted
Done
ReplyInline Actions

Maybe it's just preference? Curious to hear from @labath why he did it that way. Personally I prefer the slightly more verbose one because it's self contained.

JDevlieghere: Maybe it's just preference? Curious to hear from @labath why he did it that way. Personally I…
labathUnsubmitted
Done
ReplyInline Actions

Actually, I totally agree with you here. I think I did not personally write that using directive. I recall noticing it (during review, or during subsequent edits), but not considering it worth the trouble of changing it.

So +1 to verbose using directives.

labath: Actually, I totally agree with you here. I think I did not personally write that using…
std::unique_ptr<AppleDWARFIndex> AppleDWARFIndex::Create( std::unique_ptr<AppleDWARFIndex> AppleDWARFIndex::Create(
Module &module, DWARFDataExtractor apple_names, Module &module, DWARFDataExtractor apple_names,
DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types, DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str) { DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str) {
auto apple_names_table_up = std::make_unique<DWARFMappedHash::MemoryTable>( auto apple_names_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
apple_names, debug_str, ".apple_names"); apple_names, debug_str, ".apple_names");
if (!apple_names_table_up->IsValid()) if (!apple_names_table_up->IsValid())
apple_names_table_up.reset(); apple_names_table_up.reset();
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Linesvoid AppleDWARFIndex::GetTypes(
if (has_tag) { if (has_tag) {
// When searching for a scoped type (for example, // When searching for a scoped type (for example,
// "std::vector<int>::const_iterator") searching for the innermost // "std::vector<int>::const_iterator") searching for the innermost
// name alone ("const_iterator") could yield many false // name alone ("const_iterator") could yield many false
// positives. By searching for the parent type ("vector<int>") // positives. By searching for the parent type ("vector<int>")
// first we can avoid extracting type DIEs from object files that // first we can avoid extracting type DIEs from object files that
// would fail the filter anyway. // would fail the filter anyway.
if (!has_qualified_name_hash && (context.GetSize() > 1) && if (!has_qualified_name_hash && (context.GetSize() > 1) &&
(context[1].tag == DW_TAG_class_type || (context[1].tag == llvm::dwarf::DW_TAG_class_type ||
context[1].tag == DW_TAG_structure_type)) { context[1].tag == llvm::dwarf::DW_TAG_structure_type)) {
if (m_apple_types_up->FindByName(context[1].name, if (m_apple_types_up->FindByName(context[1].name,
[&](DIERef ref) { return false; })) [&](DIERef ref) { return false; }))
return; return;
} }
if (log) if (log)
m_module.LogMessage(log, "FindByNameAndTag()"); m_module.LogMessage(log, "FindByNameAndTag()");
m_apple_types_up->FindByNameAndTag( m_apple_types_up->FindByNameAndTag(
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
using namespace lldb_private; using namespace lldb_private;
DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast) DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast)
: m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {} : m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {}
DWARFASTParserClang::~DWARFASTParserClang() = default; DWARFASTParserClang::~DWARFASTParserClang() = default;
static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) { static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) {
switch (dwarf_accessibility) { switch (dwarf_accessibility) {
case DW_ACCESS_public: case llvm::dwarf::DW_ACCESS_public:
return eAccessPublic; return eAccessPublic;
case DW_ACCESS_private: case llvm::dwarf::DW_ACCESS_private:
return eAccessPrivate; return eAccessPrivate;
case DW_ACCESS_protected: case llvm::dwarf::DW_ACCESS_protected:
return eAccessProtected; return eAccessProtected;
default: default:
break; break;
} }
return eAccessNone; return eAccessNone;
} }
static bool DeclKindIsCXXClass(clang::Decl::Kind decl_kind) { static bool DeclKindIsCXXClass(clang::Decl::Kind decl_kind) {
Show All 12 LinesClangASTImporter &DWARFASTParserClang::GetClangASTImporter() {
if (!m_clang_ast_importer_up) { if (!m_clang_ast_importer_up) {
m_clang_ast_importer_up = std::make_unique<ClangASTImporter>(); m_clang_ast_importer_up = std::make_unique<ClangASTImporter>();
} }
return *m_clang_ast_importer_up; return *m_clang_ast_importer_up;
} }
/// Detect a forward declaration that is nested in a DW_TAG_module. /// Detect a forward declaration that is nested in a DW_TAG_module.
static bool IsClangModuleFwdDecl(const DWARFDIE &Die) { static bool IsClangModuleFwdDecl(const DWARFDIE &Die) {
if (!Die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0)) if (!Die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration, 0))
return false; return false;
auto Parent = Die.GetParent(); auto Parent = Die.GetParent();
while (Parent.IsValid()) { while (Parent.IsValid()) {
if (Parent.Tag() == DW_TAG_module) if (Parent.Tag() == llvm::dwarf::DW_TAG_module)
return true; return true;
Parent = Parent.GetParent(); Parent = Parent.GetParent();
} }
return false; return false;
} }
static DWARFDIE GetContainingClangModuleDIE(const DWARFDIE &die) { static DWARFDIE GetContainingClangModuleDIE(const DWARFDIE &die) {
if (die.IsValid()) { if (die.IsValid()) {
DWARFDIE top_module_die; DWARFDIE top_module_die;
// Now make sure this DIE is scoped in a DW_TAG_module tag and return true // Now make sure this DIE is scoped in a DW_TAG_module tag and return true
// if so // if so
for (DWARFDIE parent = die.GetParent(); parent.IsValid(); for (DWARFDIE parent = die.GetParent(); parent.IsValid();
parent = parent.GetParent()) { parent = parent.GetParent()) {
const dw_tag_t tag = parent.Tag(); const dw_tag_t tag = parent.Tag();
if (tag == DW_TAG_module) if (tag == llvm::dwarf::DW_TAG_module)
top_module_die = parent; top_module_die = parent;
else if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit) else if (tag == llvm::dwarf::DW_TAG_compile_unit ||
tag == llvm::dwarf::DW_TAG_partial_unit)
break; break;
} }
return top_module_die; return top_module_die;
} }
return DWARFDIE(); return DWARFDIE();
} }
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 LinesParsedDWARFTypeAttributes::ParsedDWARFTypeAttributes(const DWARFDIE &die) {
DWARFAttributes attributes; DWARFAttributes attributes;
size_t num_attributes = die.GetAttributes(attributes); size_t num_attributes = die.GetAttributes(attributes);
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
dw_attr_t attr = attributes.AttributeAtIndex(i); dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (!attributes.ExtractFormValueAtIndex(i, form_value)) if (!attributes.ExtractFormValueAtIndex(i, form_value))
continue; continue;
switch (attr) { switch (attr) {
case DW_AT_abstract_origin: case llvm::dwarf::DW_AT_abstract_origin:
abstract_origin = form_value; abstract_origin = form_value;
break; break;
case DW_AT_accessibility: case llvm::dwarf::DW_AT_accessibility:
accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned());
break; break;
case DW_AT_artificial: case llvm::dwarf::DW_AT_artificial:
is_artificial = form_value.Boolean(); is_artificial = form_value.Boolean();
break; break;
case DW_AT_bit_stride: case llvm::dwarf::DW_AT_bit_stride:
bit_stride = form_value.Unsigned(); bit_stride = form_value.Unsigned();
break; break;
case DW_AT_byte_size: case llvm::dwarf::DW_AT_byte_size:
byte_size = form_value.Unsigned(); byte_size = form_value.Unsigned();
break; break;
case DW_AT_byte_stride: case llvm::dwarf::DW_AT_byte_stride:
byte_stride = form_value.Unsigned(); byte_stride = form_value.Unsigned();
break; break;
case DW_AT_calling_convention: case llvm::dwarf::DW_AT_calling_convention:
calling_convention = form_value.Unsigned(); calling_convention = form_value.Unsigned();
break; break;
case DW_AT_containing_type: case llvm::dwarf::DW_AT_containing_type:
containing_type = form_value; containing_type = form_value;
break; break;
case DW_AT_decl_file: case llvm::dwarf::DW_AT_decl_file:
// die.GetCU() can differ if DW_AT_specification uses DW_FORM_ref_addr. // die.GetCU() can differ if DW_AT_specification uses DW_FORM_ref_addr.
decl.SetFile( decl.SetFile(
attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned())); attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned()));
break; break;
case DW_AT_decl_line: case llvm::dwarf::DW_AT_decl_line:
decl.SetLine(form_value.Unsigned()); decl.SetLine(form_value.Unsigned());
break; break;
case DW_AT_decl_column: case llvm::dwarf::DW_AT_decl_column:
decl.SetColumn(form_value.Unsigned()); decl.SetColumn(form_value.Unsigned());
break; break;
case DW_AT_declaration: case llvm::dwarf::DW_AT_declaration:
is_forward_declaration = form_value.Boolean(); is_forward_declaration = form_value.Boolean();
break; break;
case DW_AT_encoding: case llvm::dwarf::DW_AT_encoding:
encoding = form_value.Unsigned(); encoding = form_value.Unsigned();
break; break;
case DW_AT_enum_class: case llvm::dwarf::DW_AT_enum_class:
is_scoped_enum = form_value.Boolean(); is_scoped_enum = form_value.Boolean();
break; break;
case DW_AT_explicit: case llvm::dwarf::DW_AT_explicit:
is_explicit = form_value.Boolean(); is_explicit = form_value.Boolean();
break; break;
case DW_AT_external: case llvm::dwarf::DW_AT_external:
if (form_value.Unsigned()) if (form_value.Unsigned())
storage = clang::SC_Extern; storage = clang::SC_Extern;
break; break;
case DW_AT_inline: case llvm::dwarf::DW_AT_inline:
is_inline = form_value.Boolean(); is_inline = form_value.Boolean();
break; break;
case DW_AT_linkage_name: case llvm::dwarf::DW_AT_linkage_name:
case DW_AT_MIPS_linkage_name: case llvm::dwarf::DW_AT_MIPS_linkage_name:
mangled_name = form_value.AsCString(); mangled_name = form_value.AsCString();
break; break;
case DW_AT_name: case llvm::dwarf::DW_AT_name:
name.SetCString(form_value.AsCString()); name.SetCString(form_value.AsCString());
break; break;
case DW_AT_object_pointer: case llvm::dwarf::DW_AT_object_pointer:
object_pointer = form_value.Reference(); object_pointer = form_value.Reference();
break; break;
case DW_AT_signature: case llvm::dwarf::DW_AT_signature:
signature = form_value; signature = form_value;
break; break;
case DW_AT_specification: case llvm::dwarf::DW_AT_specification:
specification = form_value; specification = form_value;
break; break;
case DW_AT_type: case llvm::dwarf::DW_AT_type:
type = form_value; type = form_value;
break; break;
case DW_AT_virtuality: case llvm::dwarf::DW_AT_virtuality:
is_virtual = form_value.Boolean(); is_virtual = form_value.Boolean();
break; break;
case DW_AT_APPLE_objc_complete_type: case llvm::dwarf::DW_AT_APPLE_objc_complete_type:
is_complete_objc_class = form_value.Signed(); is_complete_objc_class = form_value.Signed();
break; break;
case DW_AT_APPLE_objc_direct: case llvm::dwarf::DW_AT_APPLE_objc_direct:
is_objc_direct_call = true; is_objc_direct_call = true;
break; break;
case DW_AT_APPLE_runtime_class: case llvm::dwarf::DW_AT_APPLE_runtime_class:
class_language = (LanguageType)form_value.Signed(); class_language = (LanguageType)form_value.Signed();
break; break;
case DW_AT_GNU_vector: case llvm::dwarf::DW_AT_GNU_vector:
is_vector = form_value.Boolean(); is_vector = form_value.Boolean();
break; break;
case DW_AT_export_symbols: case llvm::dwarf::DW_AT_export_symbols:
exports_symbols = form_value.Boolean(); exports_symbols = form_value.Boolean();
break; break;
} }
} }
} }
static std::string GetUnitName(const DWARFDIE &die) { static std::string GetUnitName(const DWARFDIE &die) {
if (DWARFUnit *unit = die.GetCU()) if (DWARFUnit *unit = die.GetCU())
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 LinesTypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
if (type_is_new_ptr) if (type_is_new_ptr)
*type_is_new_ptr = true; *type_is_new_ptr = true;
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
TypeSP type_sp; TypeSP type_sp;
switch (tag) { switch (tag) {
case DW_TAG_typedef: case llvm::dwarf::DW_TAG_typedef:
case DW_TAG_base_type: case llvm::dwarf::DW_TAG_base_type:
case DW_TAG_pointer_type: case llvm::dwarf::DW_TAG_pointer_type:
case DW_TAG_reference_type: case llvm::dwarf::DW_TAG_reference_type:
case DW_TAG_rvalue_reference_type: case llvm::dwarf::DW_TAG_rvalue_reference_type:
case DW_TAG_const_type: case llvm::dwarf::DW_TAG_const_type:
case DW_TAG_restrict_type: case llvm::dwarf::DW_TAG_restrict_type:
case DW_TAG_volatile_type: case llvm::dwarf::DW_TAG_volatile_type:
case DW_TAG_atomic_type: case llvm::dwarf::DW_TAG_atomic_type:
case DW_TAG_unspecified_type: { case llvm::dwarf::DW_TAG_unspecified_type: {
type_sp = ParseTypeModifier(sc, die, attrs); type_sp = ParseTypeModifier(sc, die, attrs);
break; break;
} }
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case DW_TAG_class_type: { case llvm::dwarf::DW_TAG_class_type: {
type_sp = ParseStructureLikeDIE(sc, die, attrs); type_sp = ParseStructureLikeDIE(sc, die, attrs);
break; break;
} }
case DW_TAG_enumeration_type: { case llvm::dwarf::DW_TAG_enumeration_type: {
type_sp = ParseEnum(sc, die, attrs); type_sp = ParseEnum(sc, die, attrs);
break; break;
} }
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_subroutine_type: { case llvm::dwarf::DW_TAG_subroutine_type: {
type_sp = ParseSubroutine(die, attrs); type_sp = ParseSubroutine(die, attrs);
break; break;
} }
case DW_TAG_array_type: { case llvm::dwarf::DW_TAG_array_type: {
type_sp = ParseArrayType(die, attrs); type_sp = ParseArrayType(die, attrs);
break; break;
} }
case DW_TAG_ptr_to_member_type: { case llvm::dwarf::DW_TAG_ptr_to_member_type: {
type_sp = ParsePointerToMemberType(die, attrs); type_sp = ParsePointerToMemberType(die, attrs);
break; break;
} }
default: default:
dwarf->GetObjectFile()->GetModule()->ReportError( dwarf->GetObjectFile()->GetModule()->ReportError(
"{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and " "{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and "
"attach the file at the start of this error message", "attach the file at the start of this error message",
die.GetOffset(), tag, DW_TAG_value_to_name(tag)); die.GetOffset(), tag, DW_TAG_value_to_name(tag));
Show All 14 LinesDWARFASTParserClang::ParseTypeModifier(const SymbolContext &sc,
SymbolFileDWARF *dwarf = die.GetDWARF(); SymbolFileDWARF *dwarf = die.GetDWARF();
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU()); LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
Type::ResolveState resolve_state = Type::ResolveState::Unresolved; Type::ResolveState resolve_state = Type::ResolveState::Unresolved;
Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID; Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
TypeSP type_sp; TypeSP type_sp;
CompilerType clang_type; CompilerType clang_type;
if (tag == DW_TAG_typedef) { if (tag == llvm::dwarf::DW_TAG_typedef) {
// DeclContext will be populated when the clang type is materialized in // DeclContext will be populated when the clang type is materialized in
// Type::ResolveCompilerType. // Type::ResolveCompilerType.
PrepareContextToReceiveMembers( PrepareContextToReceiveMembers(
m_ast, GetClangASTImporter(), m_ast, GetClangASTImporter(),
GetClangDeclContextContainingDIE(die, nullptr), die, GetClangDeclContextContainingDIE(die, nullptr), die,
attrs.name.GetCString()); attrs.name.GetCString());
if (attrs.type.IsValid()) { if (attrs.type.IsValid()) {
Show All 22 Lines if (attrs.type.IsValid()) {
// typedefs from the module. // typedefs from the module.
const DWARFDIE encoding_die = attrs.type.Reference(); const DWARFDIE encoding_die = attrs.type.Reference();
// First make sure that the die that this is typedef'ed to _is_ // First make sure that the die that this is typedef'ed to _is_
// just a declaration (DW_AT_declaration == 1), not a full // just a declaration (DW_AT_declaration == 1), not a full
// definition since template types can't be represented in // definition since template types can't be represented in
// modules since only concrete instances of templates are ever // modules since only concrete instances of templates are ever
// emitted and modules won't contain those // emitted and modules won't contain those
if (encoding_die && if (encoding_die && encoding_die.GetAttributeValueAsUnsigned(
encoding_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1) { llvm::dwarf::DW_AT_declaration, 0) == 1) {
type_sp = ParseTypeFromClangModule(sc, die, log); type_sp = ParseTypeFromClangModule(sc, die, log);
if (type_sp) if (type_sp)
return type_sp; return type_sp;
} }
} }
} }
DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8lx\n", die.GetID(), DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8lx\n", die.GetID(),
DW_TAG_value_to_name(tag), type_name_cstr, DW_TAG_value_to_name(tag), type_name_cstr,
encoding_uid.Reference()); encoding_uid.Reference());
switch (tag) { switch (tag) {
default: default:
break; break;
case DW_TAG_unspecified_type: case llvm::dwarf::DW_TAG_unspecified_type:
if (attrs.name == "nullptr_t" || attrs.name == "decltype(nullptr)") { if (attrs.name == "nullptr_t" || attrs.name == "decltype(nullptr)") {
resolve_state = Type::ResolveState::Full; resolve_state = Type::ResolveState::Full;
clang_type = m_ast.GetBasicType(eBasicTypeNullPtr); clang_type = m_ast.GetBasicType(eBasicTypeNullPtr);
break; break;
} }
// Fall through to base type below in case we can handle the type // Fall through to base type below in case we can handle the type
// there... // there...
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case DW_TAG_base_type: case llvm::dwarf::DW_TAG_base_type:
resolve_state = Type::ResolveState::Full; resolve_state = Type::ResolveState::Full;
clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize( clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize(
attrs.name.GetStringRef(), attrs.encoding, attrs.name.GetStringRef(), attrs.encoding,
attrs.byte_size.getValueOr(0) * 8); attrs.byte_size.getValueOr(0) * 8);
break; break;
case DW_TAG_pointer_type: case llvm::dwarf::DW_TAG_pointer_type:
encoding_data_type = Type::eEncodingIsPointerUID; encoding_data_type = Type::eEncodingIsPointerUID;
break; break;
case DW_TAG_reference_type: case llvm::dwarf::DW_TAG_reference_type:
encoding_data_type = Type::eEncodingIsLValueReferenceUID; encoding_data_type = Type::eEncodingIsLValueReferenceUID;
break; break;
case DW_TAG_rvalue_reference_type: case llvm::dwarf::DW_TAG_rvalue_reference_type:
encoding_data_type = Type::eEncodingIsRValueReferenceUID; encoding_data_type = Type::eEncodingIsRValueReferenceUID;
break; break;
case DW_TAG_typedef: case llvm::dwarf::DW_TAG_typedef:
encoding_data_type = Type::eEncodingIsTypedefUID; encoding_data_type = Type::eEncodingIsTypedefUID;
break; break;
case DW_TAG_const_type: case llvm::dwarf::DW_TAG_const_type:
encoding_data_type = Type::eEncodingIsConstUID; encoding_data_type = Type::eEncodingIsConstUID;
break; break;
case DW_TAG_restrict_type: case llvm::dwarf::DW_TAG_restrict_type:
encoding_data_type = Type::eEncodingIsRestrictUID; encoding_data_type = Type::eEncodingIsRestrictUID;
break; break;
case DW_TAG_volatile_type: case llvm::dwarf::DW_TAG_volatile_type:
encoding_data_type = Type::eEncodingIsVolatileUID; encoding_data_type = Type::eEncodingIsVolatileUID;
break; break;
case DW_TAG_atomic_type: case llvm::dwarf::DW_TAG_atomic_type:
encoding_data_type = Type::eEncodingIsAtomicUID; encoding_data_type = Type::eEncodingIsAtomicUID;
break; break;
} }
if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID || if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID ||
encoding_data_type == Type::eEncodingIsTypedefUID)) { encoding_data_type == Type::eEncodingIsTypedefUID)) {
if (tag == DW_TAG_pointer_type) { if (tag == llvm::dwarf::DW_TAG_pointer_type) {
DWARFDIE target_die = die.GetReferencedDIE(DW_AT_type); DWARFDIE target_die = die.GetReferencedDIE(llvm::dwarf::DW_AT_type);
if (target_die.GetAttributeValueAsUnsigned(DW_AT_APPLE_block, 0)) { if (target_die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_APPLE_block,
0)) {
// Blocks have a __FuncPtr inside them which is a pointer to a // Blocks have a __FuncPtr inside them which is a pointer to a
// function of the proper type. // function of the proper type.
for (DWARFDIE child_die : target_die.children()) { for (DWARFDIE child_die : target_die.children()) {
if (!strcmp(child_die.GetAttributeValueAsString(DW_AT_name, ""), if (!strcmp(child_die.GetAttributeValueAsString(
llvm::dwarf::DW_AT_name, ""),
"__FuncPtr")) { "__FuncPtr")) {
DWARFDIE function_pointer_type = DWARFDIE function_pointer_type =
child_die.GetReferencedDIE(DW_AT_type); child_die.GetReferencedDIE(llvm::dwarf::DW_AT_type);
if (function_pointer_type) { if (function_pointer_type) {
DWARFDIE function_type = DWARFDIE function_type = function_pointer_type.GetReferencedDIE(
function_pointer_type.GetReferencedDIE(DW_AT_type); llvm::dwarf::DW_AT_type);
bool function_type_is_new_pointer; bool function_type_is_new_pointer;
TypeSP lldb_function_type_sp = ParseTypeFromDWARF( TypeSP lldb_function_type_sp = ParseTypeFromDWARF(
sc, function_type, &function_type_is_new_pointer); sc, function_type, &function_type_is_new_pointer);
if (lldb_function_type_sp) { if (lldb_function_type_sp) {
clang_type = m_ast.CreateBlockPointerType( clang_type = m_ast.CreateBlockPointerType(
lldb_function_type_sp->GetForwardCompilerType()); lldb_function_type_sp->GetForwardCompilerType());
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines if (cu_language == eLanguageTypeObjC ||
} }
} else if (encoding_data_type == Type::eEncodingIsPointerUID && } else if (encoding_data_type == Type::eEncodingIsPointerUID &&
attrs.type.IsValid()) { attrs.type.IsValid()) {
// Clang sometimes erroneously emits id as objc_object*. In that // Clang sometimes erroneously emits id as objc_object*. In that
// case we fix up the type to "id". // case we fix up the type to "id".
const DWARFDIE encoding_die = attrs.type.Reference(); const DWARFDIE encoding_die = attrs.type.Reference();
if (encoding_die && encoding_die.Tag() == DW_TAG_structure_type) { if (encoding_die &&
encoding_die.Tag() == llvm::dwarf::DW_TAG_structure_type) {
llvm::StringRef struct_name = encoding_die.GetName(); llvm::StringRef struct_name = encoding_die.GetName();
if (struct_name == "objc_object") { if (struct_name == "objc_object") {
if (log) if (log)
dwarf->GetObjectFile()->GetModule()->LogMessage( dwarf->GetObjectFile()->GetModule()->LogMessage(
log, log,
"SymbolFileDWARF::ParseType (die = 0x%8.8x) %s " "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s "
"'%s' is 'objc_object*', which we overrode to " "'%s' is 'objc_object*', which we overrode to "
"'id'.", "'id'.",
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines if (attrs.type.IsValid()) {
dwarf->ResolveTypeUID(attrs.type.Reference(), true); dwarf->ResolveTypeUID(attrs.type.Reference(), true);
if (enumerator_type) if (enumerator_type)
enumerator_clang_type = enumerator_type->GetFullCompilerType(); enumerator_clang_type = enumerator_type->GetFullCompilerType();
} }
if (!enumerator_clang_type) { if (!enumerator_clang_type) {
if (attrs.byte_size) { if (attrs.byte_size) {
enumerator_clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize( enumerator_clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize(
"", DW_ATE_signed, *attrs.byte_size * 8); "", llvm::dwarf::DW_ATE_signed, *attrs.byte_size * 8);
} else { } else {
enumerator_clang_type = m_ast.GetBasicType(eBasicTypeInt); enumerator_clang_type = m_ast.GetBasicType(eBasicTypeInt);
} }
} }
clang_type = m_ast.CreateEnumerationType( clang_type = m_ast.CreateEnumerationType(
attrs.name.GetStringRef(), attrs.name.GetStringRef(),
GetClangDeclContextContainingDIE(die, nullptr), GetClangDeclContextContainingDIE(die, nullptr),
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 LinesTypeSP DWARFASTParserClang::ParseSubroutine(const DWARFDIE &die,
// clang_type will get the function prototype clang type after this // clang_type will get the function prototype clang type after this
// call // call
CompilerType clang_type = m_ast.CreateFunctionType( CompilerType clang_type = m_ast.CreateFunctionType(
return_clang_type, function_param_types.data(), return_clang_type, function_param_types.data(),
function_param_types.size(), is_variadic, type_quals, calling_convention); function_param_types.size(), is_variadic, type_quals, calling_convention);
if (attrs.name) { if (attrs.name) {
bool type_handled = false; bool type_handled = false;
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) { if (tag == llvm::dwarf::DW_TAG_subprogram ||
tag == llvm::dwarf::DW_TAG_inlined_subroutine) {
ObjCLanguage::MethodName objc_method(attrs.name.GetStringRef(), true); ObjCLanguage::MethodName objc_method(attrs.name.GetStringRef(), true);
if (objc_method.IsValid(true)) { if (objc_method.IsValid(true)) {
CompilerType class_opaque_type; CompilerType class_opaque_type;
ConstString class_name(objc_method.GetClassName()); ConstString class_name(objc_method.GetClassName());
if (class_name) { if (class_name) {
TypeSP complete_objc_class_type_sp( TypeSP complete_objc_class_type_sp(
dwarf->FindCompleteObjCDefinitionTypeForDIE(DWARFDIE(), dwarf->FindCompleteObjCDefinitionTypeForDIE(DWARFDIE(),
class_name, false)); class_name, false));
▲ Show 20 Lines • Show All 422 Lines • ▼ Show 20 Linesvoid DWARFASTParserClang::ParseInheritance(
bool is_base_of_class = true; bool is_base_of_class = true;
off_t member_byte_offset = 0; off_t member_byte_offset = 0;
for (uint32_t i = 0; i < num_attributes; ++i) { for (uint32_t i = 0; i < num_attributes; ++i) {
const dw_attr_t attr = attributes.AttributeAtIndex(i); const dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
switch (attr) { switch (attr) {
case DW_AT_type: case llvm::dwarf::DW_AT_type:
encoding_form = form_value; encoding_form = form_value;
break; break;
case DW_AT_data_member_location: case llvm::dwarf::DW_AT_data_member_location:
if (form_value.BlockData()) { if (form_value.BlockData()) {
Value initialValue(0); Value initialValue(0);
Value memberOffset(0); Value memberOffset(0);
const DWARFDataExtractor &debug_info_data = die.GetData(); const DWARFDataExtractor &debug_info_data = die.GetData();
uint32_t block_length = form_value.Unsigned(); uint32_t block_length = form_value.Unsigned();
uint32_t block_offset = uint32_t block_offset =
form_value.BlockData() - debug_info_data.GetDataStart(); form_value.BlockData() - debug_info_data.GetDataStart();
if (DWARFExpression::Evaluate( if (DWARFExpression::Evaluate(
nullptr, nullptr, module_sp, nullptr, nullptr, module_sp,
DataExtractor(debug_info_data, block_offset, block_length), DataExtractor(debug_info_data, block_offset, block_length),
die.GetCU(), eRegisterKindDWARF, &initialValue, nullptr, die.GetCU(), eRegisterKindDWARF, &initialValue, nullptr,
memberOffset, nullptr)) { memberOffset, nullptr)) {
member_byte_offset = memberOffset.ResolveValue(nullptr).UInt(); member_byte_offset = memberOffset.ResolveValue(nullptr).UInt();
} }
} else { } else {
// With DWARF 3 and later, if the value is an integer constant, // With DWARF 3 and later, if the value is an integer constant,
// this form value is the offset in bytes from the beginning of // this form value is the offset in bytes from the beginning of
// the containing entity. // the containing entity.
member_byte_offset = form_value.Unsigned(); member_byte_offset = form_value.Unsigned();
} }
break; break;
case DW_AT_accessibility: case llvm::dwarf::DW_AT_accessibility:
accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned());
break; break;
case DW_AT_virtuality: case llvm::dwarf::DW_AT_virtuality:
is_virtual = form_value.Boolean(); is_virtual = form_value.Boolean();
break; break;
default: default:
break; break;
} }
} }
} }
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 LinesTypeSP DWARFASTParserClang::UpdateSymbolContextScopeForType(
if (!type_sp) if (!type_sp)
return type_sp; return type_sp;
SymbolFileDWARF *dwarf = die.GetDWARF(); SymbolFileDWARF *dwarf = die.GetDWARF();
DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die); DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
dw_tag_t sc_parent_tag = sc_parent_die.Tag(); dw_tag_t sc_parent_tag = sc_parent_die.Tag();
SymbolContextScope *symbol_context_scope = nullptr; SymbolContextScope *symbol_context_scope = nullptr;
if (sc_parent_tag == DW_TAG_compile_unit || if (sc_parent_tag == llvm::dwarf::DW_TAG_compile_unit ||
sc_parent_tag == DW_TAG_partial_unit) { sc_parent_tag == llvm::dwarf::DW_TAG_partial_unit) {
symbol_context_scope = sc.comp_unit; symbol_context_scope = sc.comp_unit;
} else if (sc.function != nullptr && sc_parent_die) { } else if (sc.function != nullptr && sc_parent_die) {
symbol_context_scope = symbol_context_scope =
sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID()); sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
if (symbol_context_scope == nullptr) if (symbol_context_scope == nullptr)
symbol_context_scope = sc.function; symbol_context_scope = sc.function;
} else { } else {
symbol_context_scope = sc.module_sp.get(); symbol_context_scope = sc.module_sp.get();
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines if (attrs.name) {
} }
} }
DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
DW_TAG_value_to_name(tag), type_name_cstr); DW_TAG_value_to_name(tag), type_name_cstr);
int tag_decl_kind = -1; int tag_decl_kind = -1;
AccessType default_accessibility = eAccessNone; AccessType default_accessibility = eAccessNone;
if (tag == DW_TAG_structure_type) { if (tag == llvm::dwarf::DW_TAG_structure_type) {
tag_decl_kind = clang::TTK_Struct; tag_decl_kind = clang::TTK_Struct;
default_accessibility = eAccessPublic; default_accessibility = eAccessPublic;
} else if (tag == DW_TAG_union_type) { } else if (tag == llvm::dwarf::DW_TAG_union_type) {
tag_decl_kind = clang::TTK_Union; tag_decl_kind = clang::TTK_Union;
default_accessibility = eAccessPublic; default_accessibility = eAccessPublic;
} else if (tag == DW_TAG_class_type) { } else if (tag == llvm::dwarf::DW_TAG_class_type) {
tag_decl_kind = clang::TTK_Class; tag_decl_kind = clang::TTK_Class;
default_accessibility = eAccessPrivate; default_accessibility = eAccessPrivate;
} }
if (attrs.byte_size && *attrs.byte_size == 0 && attrs.name && if (attrs.byte_size && *attrs.byte_size == 0 && attrs.name &&
!die.HasChildren() && cu_language == eLanguageTypeObjC) { !die.HasChildren() && cu_language == eLanguageTypeObjC) {
// Work around an issue with clang at the moment where forward // Work around an issue with clang at the moment where forward
// declarations for objective C classes are emitted as: // declarations for objective C classes are emitted as:
▲ Show 20 Lines • Show All 342 Lines • ▼ Show 20 Lines
bool DWARFASTParserClang::ParseTemplateDIE( bool DWARFASTParserClang::ParseTemplateDIE(
const DWARFDIE &die, const DWARFDIE &die,
TypeSystemClang::TemplateParameterInfos &template_param_infos) { TypeSystemClang::TemplateParameterInfos &template_param_infos) {
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
bool is_template_template_argument = false; bool is_template_template_argument = false;
switch (tag) { switch (tag) {
case DW_TAG_GNU_template_parameter_pack: { case llvm::dwarf::DW_TAG_GNU_template_parameter_pack: {
template_param_infos.packed_args = template_param_infos.packed_args =
std::make_unique<TypeSystemClang::TemplateParameterInfos>(); std::make_unique<TypeSystemClang::TemplateParameterInfos>();
for (DWARFDIE child_die : die.children()) { for (DWARFDIE child_die : die.children()) {
if (!ParseTemplateDIE(child_die, *template_param_infos.packed_args)) if (!ParseTemplateDIE(child_die, *template_param_infos.packed_args))
return false; return false;
} }
if (const char *name = die.GetName()) { if (const char *name = die.GetName()) {
template_param_infos.pack_name = name; template_param_infos.pack_name = name;
} }
return true; return true;
} }
case DW_TAG_GNU_template_template_param: case llvm::dwarf::DW_TAG_GNU_template_template_param:
is_template_template_argument = true; is_template_template_argument = true;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case DW_TAG_template_type_parameter: case llvm::dwarf::DW_TAG_template_type_parameter:
case DW_TAG_template_value_parameter: { case llvm::dwarf::DW_TAG_template_value_parameter: {
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_attributes = die.GetAttributes(attributes); const size_t num_attributes = die.GetAttributes(attributes);
const char *name = nullptr; const char *name = nullptr;
const char *template_name = nullptr; const char *template_name = nullptr;
CompilerType clang_type; CompilerType clang_type;
uint64_t uval64 = 0; uint64_t uval64 = 0;
bool uval64_valid = false; bool uval64_valid = false;
if (num_attributes > 0) { if (num_attributes > 0) {
DWARFFormValue form_value; DWARFFormValue form_value;
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
const dw_attr_t attr = attributes.AttributeAtIndex(i); const dw_attr_t attr = attributes.AttributeAtIndex(i);
switch (attr) { switch (attr) {
case DW_AT_name: case llvm::dwarf::DW_AT_name:
if (attributes.ExtractFormValueAtIndex(i, form_value)) if (attributes.ExtractFormValueAtIndex(i, form_value))
name = form_value.AsCString(); name = form_value.AsCString();
break; break;
case DW_AT_GNU_template_name: case llvm::dwarf::DW_AT_GNU_template_name:
if (attributes.ExtractFormValueAtIndex(i, form_value)) if (attributes.ExtractFormValueAtIndex(i, form_value))
template_name = form_value.AsCString(); template_name = form_value.AsCString();
break; break;
case DW_AT_type: case llvm::dwarf::DW_AT_type:
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
Type *lldb_type = die.ResolveTypeUID(form_value.Reference()); Type *lldb_type = die.ResolveTypeUID(form_value.Reference());
if (lldb_type) if (lldb_type)
clang_type = lldb_type->GetForwardCompilerType(); clang_type = lldb_type->GetForwardCompilerType();
} }
break; break;
case DW_AT_const_value: case llvm::dwarf::DW_AT_const_value:
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
uval64_valid = true; uval64_valid = true;
uval64 = form_value.Unsigned(); uval64 = form_value.Unsigned();
} }
break; break;
default: default:
break; break;
} }
} }
clang::ASTContext &ast = m_ast.getASTContext(); clang::ASTContext &ast = m_ast.getASTContext();
if (!clang_type) if (!clang_type)
clang_type = m_ast.GetBasicType(eBasicTypeVoid); clang_type = m_ast.GetBasicType(eBasicTypeVoid);
if (!is_template_template_argument) { if (!is_template_template_argument) {
bool is_signed = false; bool is_signed = false;
if (name && name[0]) if (name && name[0])
template_param_infos.names.push_back(name); template_param_infos.names.push_back(name);
else else
template_param_infos.names.push_back(nullptr); template_param_infos.names.push_back(nullptr);
// Get the signed value for any integer or enumeration if available // Get the signed value for any integer or enumeration if available
clang_type.IsIntegerOrEnumerationType(is_signed); clang_type.IsIntegerOrEnumerationType(is_signed);
if (tag == DW_TAG_template_value_parameter && uval64_valid) { if (tag == llvm::dwarf::DW_TAG_template_value_parameter &&
uval64_valid) {
llvm::Optional<uint64_t> size = clang_type.GetBitSize(nullptr); llvm::Optional<uint64_t> size = clang_type.GetBitSize(nullptr);
if (!size) if (!size)
return false; return false;
llvm::APInt apint(*size, uval64, is_signed); llvm::APInt apint(*size, uval64, is_signed);
template_param_infos.args.push_back( template_param_infos.args.push_back(
clang::TemplateArgument(ast, llvm::APSInt(apint, !is_signed), clang::TemplateArgument(ast, llvm::APSInt(apint, !is_signed),
ClangUtil::GetQualType(clang_type))); ClangUtil::GetQualType(clang_type)));
} else { } else {
Show All 22 Linesbool DWARFASTParserClang::ParseTemplateParameterInfos(
if (!parent_die) if (!parent_die)
return false; return false;
for (DWARFDIE die : parent_die.children()) { for (DWARFDIE die : parent_die.children()) {
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
switch (tag) { switch (tag) {
case DW_TAG_template_type_parameter: case llvm::dwarf::DW_TAG_template_type_parameter:
case DW_TAG_template_value_parameter: case llvm::dwarf::DW_TAG_template_value_parameter:
case DW_TAG_GNU_template_parameter_pack: case llvm::dwarf::DW_TAG_GNU_template_parameter_pack:
case DW_TAG_GNU_template_template_param: case llvm::dwarf::DW_TAG_GNU_template_template_param:
ParseTemplateDIE(die, template_param_infos); ParseTemplateDIE(die, template_param_infos);
break; break;
default: default:
break; break;
} }
} }
return template_param_infos.args.size() == template_param_infos.names.size(); return template_param_infos.args.size() == template_param_infos.names.size();
Show All 12 Lines const bool type_is_objc_object_or_interface =
TypeSystemClang::IsObjCObjectOrInterfaceType(clang_type); TypeSystemClang::IsObjCObjectOrInterfaceType(clang_type);
if (type_is_objc_object_or_interface) { if (type_is_objc_object_or_interface) {
// For objective C we don't start the definition when the class is // For objective C we don't start the definition when the class is
// created. // created.
TypeSystemClang::StartTagDeclarationDefinition(clang_type); TypeSystemClang::StartTagDeclarationDefinition(clang_type);
} }
AccessType default_accessibility = eAccessNone; AccessType default_accessibility = eAccessNone;
if (tag == DW_TAG_structure_type) { if (tag == llvm::dwarf::DW_TAG_structure_type) {
default_accessibility = eAccessPublic; default_accessibility = eAccessPublic;
} else if (tag == DW_TAG_union_type) { } else if (tag == llvm::dwarf::DW_TAG_union_type) {
default_accessibility = eAccessPublic; default_accessibility = eAccessPublic;
} else if (tag == DW_TAG_class_type) { } else if (tag == llvm::dwarf::DW_TAG_class_type) {
default_accessibility = eAccessPrivate; default_accessibility = eAccessPrivate;
} }
std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases; std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
// Parse members and base classes first // Parse members and base classes first
std::vector<DWARFDIE> member_function_dies; std::vector<DWARFDIE> member_function_dies;
DelayedPropertyList delayed_properties; DelayedPropertyList delayed_properties;
Show All 38 Linesbool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
TypeSystemClang::CompleteTagDeclarationDefinition(clang_type); TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
if (!layout_info.field_offsets.empty() || !layout_info.base_offsets.empty() || if (!layout_info.field_offsets.empty() || !layout_info.base_offsets.empty() ||
!layout_info.vbase_offsets.empty()) { !layout_info.vbase_offsets.empty()) {
if (type) if (type)
layout_info.bit_size = type->GetByteSize(nullptr).getValueOr(0) * 8; layout_info.bit_size = type->GetByteSize(nullptr).getValueOr(0) * 8;
if (layout_info.bit_size == 0) if (layout_info.bit_size == 0)
layout_info.bit_size = layout_info.bit_size =
die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8; die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_byte_size, 0) * 8;
clang::CXXRecordDecl *record_decl = clang::CXXRecordDecl *record_decl =
m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType()); m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
if (record_decl) if (record_decl)
GetClangASTImporter().SetRecordLayout(record_decl, layout_info); GetClangASTImporter().SetRecordLayout(record_decl, layout_info);
} }
return (bool)clang_type; return (bool)clang_type;
Show All 29 Linesbool DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die,
if (!die) if (!die)
return false; return false;
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
assert(clang_type); assert(clang_type);
DWARFAttributes attributes; DWARFAttributes attributes;
switch (tag) { switch (tag) {
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
return CompleteRecordType(die, type, clang_type); return CompleteRecordType(die, type, clang_type);
case DW_TAG_enumeration_type: case llvm::dwarf::DW_TAG_enumeration_type:
return CompleteEnumType(die, type, clang_type); return CompleteEnumType(die, type, clang_type);
default: default:
assert(false && "not a forward clang type decl!"); assert(false && "not a forward clang type decl!");
break; break;
} }
return false; return false;
} }
Show All 38 Linessize_t DWARFASTParserClang::ParseChildEnumerators(
uint32_t enumerator_byte_size, const DWARFDIE &parent_die) { uint32_t enumerator_byte_size, const DWARFDIE &parent_die) {
if (!parent_die) if (!parent_die)
return 0; return 0;
size_t enumerators_added = 0; size_t enumerators_added = 0;
for (DWARFDIE die : parent_die.children()) { for (DWARFDIE die : parent_die.children()) {
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
if (tag == DW_TAG_enumerator) { if (tag == llvm::dwarf::DW_TAG_enumerator) {
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_child_attributes = die.GetAttributes(attributes); const size_t num_child_attributes = die.GetAttributes(attributes);
if (num_child_attributes > 0) { if (num_child_attributes > 0) {
const char *name = nullptr; const char *name = nullptr;
bool got_value = false; bool got_value = false;
int64_t enum_value = 0; int64_t enum_value = 0;
Declaration decl; Declaration decl;
uint32_t i; uint32_t i;
for (i = 0; i < num_child_attributes; ++i) { for (i = 0; i < num_child_attributes; ++i) {
const dw_attr_t attr = attributes.AttributeAtIndex(i); const dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
switch (attr) { switch (attr) {
case DW_AT_const_value: case llvm::dwarf::DW_AT_const_value:
got_value = true; got_value = true;
if (is_signed) if (is_signed)
enum_value = form_value.Signed(); enum_value = form_value.Signed();
else else
enum_value = form_value.Unsigned(); enum_value = form_value.Unsigned();
break; break;
case DW_AT_name: case llvm::dwarf::DW_AT_name:
name = form_value.AsCString(); name = form_value.AsCString();
break; break;
case DW_AT_description: case llvm::dwarf::DW_AT_description:
default: default:
case DW_AT_decl_file: case llvm::dwarf::DW_AT_decl_file:
decl.SetFile(attributes.CompileUnitAtIndex(i)->GetFile( decl.SetFile(attributes.CompileUnitAtIndex(i)->GetFile(
form_value.Unsigned())); form_value.Unsigned()));
break; break;
case DW_AT_decl_line: case llvm::dwarf::DW_AT_decl_line:
decl.SetLine(form_value.Unsigned()); decl.SetLine(form_value.Unsigned());
break; break;
case DW_AT_decl_column: case llvm::dwarf::DW_AT_decl_column:
decl.SetColumn(form_value.Unsigned()); decl.SetColumn(form_value.Unsigned());
break; break;
case DW_AT_sibling: case llvm::dwarf::DW_AT_sibling:
break; break;
} }
} }
} }
if (name && name[0] && got_value) { if (name && name[0] && got_value) {
m_ast.AddEnumerationValueToEnumerationType( m_ast.AddEnumerationValueToEnumerationType(
clang_type, decl, name, enum_value, enumerator_byte_size * 8); clang_type, decl, name, enum_value, enumerator_byte_size * 8);
Show All 18 LinesDWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit,
int decl_column = 0; int decl_column = 0;
int call_file = 0; int call_file = 0;
int call_line = 0; int call_line = 0;
int call_column = 0; int call_column = 0;
DWARFExpression frame_base; DWARFExpression frame_base;
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
if (tag != DW_TAG_subprogram) if (tag != llvm::dwarf::DW_TAG_subprogram)
return nullptr; return nullptr;
if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line, if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
decl_column, call_file, call_line, call_column, decl_column, call_file, call_line, call_column,
&frame_base)) { &frame_base)) {
Mangled func_name; Mangled func_name;
if (mangled) if (mangled)
func_name.SetValue(ConstString(mangled), true); func_name.SetValue(ConstString(mangled), true);
else if ((die.GetParent().Tag() == DW_TAG_compile_unit || else if ((die.GetParent().Tag() == llvm::dwarf::DW_TAG_compile_unit ||
die.GetParent().Tag() == DW_TAG_partial_unit) && die.GetParent().Tag() == llvm::dwarf::DW_TAG_partial_unit) &&
Language::LanguageIsCPlusPlus( Language::LanguageIsCPlusPlus(
SymbolFileDWARF::GetLanguage(*die.GetCU())) && SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
!Language::LanguageIsObjC( !Language::LanguageIsObjC(
SymbolFileDWARF::GetLanguage(*die.GetCU())) && SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
name && strcmp(name, "main") != 0) { name && strcmp(name, "main") != 0) {
// If the mangled name is not present in the DWARF, generate the // If the mangled name is not present in the DWARF, generate the
// demangled name using the decl context. We skip if the function is // demangled name using the decl context. We skip if the function is
// "main" as its name is never mangled. // "main" as its name is never mangled.
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Linesstruct PropertyAttributes {
/// \see clang::ObjCPropertyAttribute /// \see clang::ObjCPropertyAttribute
uint32_t prop_attributes = 0; uint32_t prop_attributes = 0;
}; };
} // namespace } // namespace
MemberAttributes::MemberAttributes(const DWARFDIE &die, MemberAttributes::MemberAttributes(const DWARFDIE &die,
const DWARFDIE &parent_die, const DWARFDIE &parent_die,
ModuleSP module_sp) { ModuleSP module_sp) {
member_byte_offset = (parent_die.Tag() == DW_TAG_union_type) ? 0 : UINT32_MAX; member_byte_offset =
(parent_die.Tag() == llvm::dwarf::DW_TAG_union_type) ? 0 : UINT32_MAX;
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_attributes = die.GetAttributes(attributes); const size_t num_attributes = die.GetAttributes(attributes);
for (std::size_t i = 0; i < num_attributes; ++i) { for (std::size_t i = 0; i < num_attributes; ++i) {
const dw_attr_t attr = attributes.AttributeAtIndex(i); const dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
switch (attr) { switch (attr) {
case DW_AT_name: case llvm::dwarf::DW_AT_name:
name = form_value.AsCString(); name = form_value.AsCString();
break; break;
case DW_AT_type: case llvm::dwarf::DW_AT_type:
encoding_form = form_value; encoding_form = form_value;
break; break;
case DW_AT_bit_offset: case llvm::dwarf::DW_AT_bit_offset:
bit_offset = form_value.Signed(); bit_offset = form_value.Signed();
break; break;
case DW_AT_bit_size: case llvm::dwarf::DW_AT_bit_size:
bit_size = form_value.Unsigned(); bit_size = form_value.Unsigned();
break; break;
case DW_AT_byte_size: case llvm::dwarf::DW_AT_byte_size:
byte_size = form_value.Unsigned(); byte_size = form_value.Unsigned();
break; break;
case DW_AT_data_bit_offset: case llvm::dwarf::DW_AT_data_bit_offset:
data_bit_offset = form_value.Unsigned(); data_bit_offset = form_value.Unsigned();
break; break;
case DW_AT_data_member_location: case llvm::dwarf::DW_AT_data_member_location:
if (form_value.BlockData()) { if (form_value.BlockData()) {
Value initialValue(0); Value initialValue(0);
Value memberOffset(0); Value memberOffset(0);
const DWARFDataExtractor &debug_info_data = die.GetData(); const DWARFDataExtractor &debug_info_data = die.GetData();
uint32_t block_length = form_value.Unsigned(); uint32_t block_length = form_value.Unsigned();
uint32_t block_offset = uint32_t block_offset =
form_value.BlockData() - debug_info_data.GetDataStart(); form_value.BlockData() - debug_info_data.GetDataStart();
if (DWARFExpression::Evaluate( if (DWARFExpression::Evaluate(
nullptr, // ExecutionContext * nullptr, // ExecutionContext *
nullptr, // RegisterContext * nullptr, // RegisterContext *
module_sp, module_sp,
DataExtractor(debug_info_data, block_offset, block_length), DataExtractor(debug_info_data, block_offset, block_length),
die.GetCU(), eRegisterKindDWARF, &initialValue, nullptr, die.GetCU(), eRegisterKindDWARF, &initialValue, nullptr,
memberOffset, nullptr)) { memberOffset, nullptr)) {
member_byte_offset = memberOffset.ResolveValue(nullptr).UInt(); member_byte_offset = memberOffset.ResolveValue(nullptr).UInt();
} }
} else { } else {
// With DWARF 3 and later, if the value is an integer constant, // With DWARF 3 and later, if the value is an integer constant,
// this form value is the offset in bytes from the beginning of // this form value is the offset in bytes from the beginning of
// the containing entity. // the containing entity.
member_byte_offset = form_value.Unsigned(); member_byte_offset = form_value.Unsigned();
} }
break; break;
case DW_AT_accessibility: case llvm::dwarf::DW_AT_accessibility:
accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned());
break; break;
case DW_AT_artificial: case llvm::dwarf::DW_AT_artificial:
is_artificial = form_value.Boolean(); is_artificial = form_value.Boolean();
break; break;
case DW_AT_external: case llvm::dwarf::DW_AT_external:
is_external = form_value.Boolean(); is_external = form_value.Boolean();
break; break;
default: default:
break; break;
} }
} }
} }
Show All 19 LinesPropertyAttributes::PropertyAttributes(const DWARFDIE &die) {
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_attributes = die.GetAttributes(attributes); const size_t num_attributes = die.GetAttributes(attributes);
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
const dw_attr_t attr = attributes.AttributeAtIndex(i); const dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
switch (attr) { switch (attr) {
case DW_AT_APPLE_property_name: case llvm::dwarf::DW_AT_APPLE_property_name:
prop_name = form_value.AsCString(); prop_name = form_value.AsCString();
break; break;
case DW_AT_APPLE_property_getter: case llvm::dwarf::DW_AT_APPLE_property_getter:
prop_getter_name = form_value.AsCString(); prop_getter_name = form_value.AsCString();
break; break;
case DW_AT_APPLE_property_setter: case llvm::dwarf::DW_AT_APPLE_property_setter:
prop_setter_name = form_value.AsCString(); prop_setter_name = form_value.AsCString();
break; break;
case DW_AT_APPLE_property_attribute: case llvm::dwarf::DW_AT_APPLE_property_attribute:
prop_attributes = form_value.Unsigned(); prop_attributes = form_value.Unsigned();
break; break;
default: default:
break; break;
} }
} }
} }
Show All 12 Lines if (prop_setter_name && prop_setter_name[0] == '-') {
ObjCLanguage::MethodName prop_setter_method(prop_setter_name, true); ObjCLanguage::MethodName prop_setter_method(prop_setter_name, true);
prop_setter_name = prop_setter_method.GetSelector().GetCString(); prop_setter_name = prop_setter_method.GetSelector().GetCString();
} }
// If the names haven't been provided, they need to be filled in. // If the names haven't been provided, they need to be filled in.
if (!prop_getter_name) if (!prop_getter_name)
prop_getter_name = prop_name; prop_getter_name = prop_name;
if (!prop_setter_name && prop_name[0] && if (!prop_setter_name && prop_name[0] &&
!(prop_attributes & DW_APPLE_PROPERTY_readonly)) { !(prop_attributes & llvm::dwarf::DW_APPLE_PROPERTY_readonly)) {
StreamString ss; StreamString ss;
ss.Printf("set%c%s:", toupper(prop_name[0]), &prop_name[1]); ss.Printf("set%c%s:", toupper(prop_name[0]), &prop_name[1]);
fixed_setter.SetString(ss.GetString()); fixed_setter.SetString(ss.GetString());
prop_setter_name = fixed_setter.GetCString(); prop_setter_name = fixed_setter.GetCString();
} }
} }
void DWARFASTParserClang::ParseObjCProperty( void DWARFASTParserClang::ParseObjCProperty(
const DWARFDIE &die, const DWARFDIE &parent_die, const DWARFDIE &die, const DWARFDIE &parent_die,
const lldb_private::CompilerType &class_clang_type, const lldb_private::CompilerType &class_clang_type,
DelayedPropertyList &delayed_properties) { DelayedPropertyList &delayed_properties) {
// This function can only parse DW_TAG_APPLE_property. // This function can only parse DW_TAG_APPLE_property.
assert(die.Tag() == DW_TAG_APPLE_property); assert(die.Tag() == llvm::dwarf::DW_TAG_APPLE_property);
ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
const MemberAttributes attrs(die, parent_die, module_sp); const MemberAttributes attrs(die, parent_die, module_sp);
const PropertyAttributes propAttrs(die); const PropertyAttributes propAttrs(die);
if (!propAttrs.prop_name) { if (!propAttrs.prop_name) {
module_sp->ReportError( module_sp->ReportError(
Show All 21 Lines
void DWARFASTParserClang::ParseSingleMember( void DWARFASTParserClang::ParseSingleMember(
const DWARFDIE &die, const DWARFDIE &parent_die, const DWARFDIE &die, const DWARFDIE &parent_die,
const lldb_private::CompilerType &class_clang_type, const lldb_private::CompilerType &class_clang_type,
lldb::AccessType default_accessibility, lldb::AccessType default_accessibility,
lldb_private::ClangASTImporter::LayoutInfo &layout_info, lldb_private::ClangASTImporter::LayoutInfo &layout_info,
FieldInfo &last_field_info) { FieldInfo &last_field_info) {
// This function can only parse DW_TAG_member. // This function can only parse DW_TAG_member.
assert(die.Tag() == DW_TAG_member); assert(die.Tag() == llvm::dwarf::DW_TAG_member);
ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
// Get the parent byte size so we can verify any members will fit // Get the parent byte size so we can verify any members will fit
const uint64_t parent_byte_size = const uint64_t parent_byte_size = parent_die.GetAttributeValueAsUnsigned(
parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX); llvm::dwarf::DW_AT_byte_size, UINT64_MAX);
const uint64_t parent_bit_size = const uint64_t parent_bit_size =
parent_byte_size == UINT64_MAX ? UINT64_MAX : parent_byte_size * 8; parent_byte_size == UINT64_MAX ? UINT64_MAX : parent_byte_size * 8;
// FIXME: Remove the workarounds below and make this const. // FIXME: Remove the workarounds below and make this const.
MemberAttributes attrs(die, parent_die, module_sp); MemberAttributes attrs(die, parent_die, module_sp);
const bool class_is_objc_object_or_interface = const bool class_is_objc_object_or_interface =
TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type); TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type);
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines if (attrs.bit_size > 0) {
// The ObjC runtime knows the byte offset but we still need to provide // The ObjC runtime knows the byte offset but we still need to provide
// the bit-offset in the layout. It just means something different then // the bit-offset in the layout. It just means something different then
// what it does in C and C++. So we skip this check for ObjC types. // what it does in C and C++. So we skip this check for ObjC types.
// //
// We also skip this for fields of a union since they will all have a // We also skip this for fields of a union since they will all have a
// zero offset. // zero offset.
if (!TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type) && if (!TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type) &&
!(parent_die.Tag() == DW_TAG_union_type && !(parent_die.Tag() == llvm::dwarf::DW_TAG_union_type &&
this_field_info.bit_offset == 0) && this_field_info.bit_offset == 0) &&
((this_field_info.bit_offset >= parent_bit_size) || ((this_field_info.bit_offset >= parent_bit_size) ||
(last_field_info.IsBitfield() && (last_field_info.IsBitfield() &&
!last_field_info.NextBitfieldOffsetIsValid( !last_field_info.NextBitfieldOffsetIsValid(
this_field_info.bit_offset)))) { this_field_info.bit_offset)))) {
ObjectFile *objfile = die.GetDWARF()->GetObjectFile(); ObjectFile *objfile = die.GetDWARF()->GetObjectFile();
objfile->GetModule()->ReportWarning( objfile->GetModule()->ReportWarning(
"0x%8.8" PRIx64 ": %s bitfield named \"%s\" has invalid " "0x%8.8" PRIx64 ": %s bitfield named \"%s\" has invalid "
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines if (!member_clang_type.IsCompleteType())
CompilerType member_array_element_type; CompilerType member_array_element_type;
uint64_t member_array_size; uint64_t member_array_size;
bool member_array_is_incomplete; bool member_array_is_incomplete;
if (member_clang_type.IsArrayType(&member_array_element_type, if (member_clang_type.IsArrayType(&member_array_element_type,
&member_array_size, &member_array_size,
&member_array_is_incomplete) && &member_array_is_incomplete) &&
!member_array_is_incomplete) { !member_array_is_incomplete) {
uint64_t parent_byte_size = uint64_t parent_byte_size = parent_die.GetAttributeValueAsUnsigned(
parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX); llvm::dwarf::DW_AT_byte_size, UINT64_MAX);
if (attrs.member_byte_offset >= parent_byte_size) { if (attrs.member_byte_offset >= parent_byte_size) {
if (member_array_size != 1 && if (member_array_size != 1 &&
(member_array_size != 0 || (member_array_size != 0 ||
attrs.member_byte_offset > parent_byte_size)) { attrs.member_byte_offset > parent_byte_size)) {
module_sp->ReportError( module_sp->ReportError(
"0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8x" "0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8x"
" which extends beyond the bounds of 0x%8.8" PRIx64, " which extends beyond the bounds of 0x%8.8" PRIx64,
Show All 37 Lines TypeSystemClang *ast =
llvm::dyn_cast_or_null<TypeSystemClang>(class_clang_type.GetTypeSystem()); llvm::dyn_cast_or_null<TypeSystemClang>(class_clang_type.GetTypeSystem());
if (ast == nullptr) if (ast == nullptr)
return false; return false;
for (DWARFDIE die : parent_die.children()) { for (DWARFDIE die : parent_die.children()) {
dw_tag_t tag = die.Tag(); dw_tag_t tag = die.Tag();
switch (tag) { switch (tag) {
case DW_TAG_APPLE_property: case llvm::dwarf::DW_TAG_APPLE_property:
ParseObjCProperty(die, parent_die, class_clang_type, delayed_properties); ParseObjCProperty(die, parent_die, class_clang_type, delayed_properties);
break; break;
case DW_TAG_member: case llvm::dwarf::DW_TAG_member:
ParseSingleMember(die, parent_die, class_clang_type, ParseSingleMember(die, parent_die, class_clang_type,
default_accessibility, layout_info, last_field_info); default_accessibility, layout_info, last_field_info);
break; break;
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
// Let the type parsing code handle this one for us. // Let the type parsing code handle this one for us.
member_function_dies.push_back(die); member_function_dies.push_back(die);
break; break;
case DW_TAG_inheritance: case llvm::dwarf::DW_TAG_inheritance:
ParseInheritance(die, parent_die, class_clang_type, default_accessibility, ParseInheritance(die, parent_die, class_clang_type, default_accessibility,
module_sp, base_classes, layout_info); module_sp, base_classes, layout_info);
break; break;
default: default:
break; break;
} }
} }
Show All 9 Linessize_t DWARFASTParserClang::ParseChildParameters(
unsigned &type_quals) { unsigned &type_quals) {
if (!parent_die) if (!parent_die)
return 0; return 0;
size_t arg_idx = 0; size_t arg_idx = 0;
for (DWARFDIE die : parent_die.children()) { for (DWARFDIE die : parent_die.children()) {
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
switch (tag) { switch (tag) {
case DW_TAG_formal_parameter: { case llvm::dwarf::DW_TAG_formal_parameter: {
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_attributes = die.GetAttributes(attributes); const size_t num_attributes = die.GetAttributes(attributes);
if (num_attributes > 0) { if (num_attributes > 0) {
const char *name = nullptr; const char *name = nullptr;
DWARFFormValue param_type_die_form; DWARFFormValue param_type_die_form;
bool is_artificial = false; bool is_artificial = false;
// one of None, Auto, Register, Extern, Static, PrivateExtern // one of None, Auto, Register, Extern, Static, PrivateExtern
clang::StorageClass storage = clang::SC_None; clang::StorageClass storage = clang::SC_None;
uint32_t i; uint32_t i;
for (i = 0; i < num_attributes; ++i) { for (i = 0; i < num_attributes; ++i) {
const dw_attr_t attr = attributes.AttributeAtIndex(i); const dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
switch (attr) { switch (attr) {
case DW_AT_name: case llvm::dwarf::DW_AT_name:
name = form_value.AsCString(); name = form_value.AsCString();
break; break;
case DW_AT_type: case llvm::dwarf::DW_AT_type:
param_type_die_form = form_value; param_type_die_form = form_value;
break; break;
case DW_AT_artificial: case llvm::dwarf::DW_AT_artificial:
is_artificial = form_value.Boolean(); is_artificial = form_value.Boolean();
break; break;
case DW_AT_location: case llvm::dwarf::DW_AT_location:
case DW_AT_const_value: case llvm::dwarf::DW_AT_const_value:
case DW_AT_default_value: case llvm::dwarf::DW_AT_default_value:
case DW_AT_description: case llvm::dwarf::DW_AT_description:
case DW_AT_endianity: case llvm::dwarf::DW_AT_endianity:
case DW_AT_is_optional: case llvm::dwarf::DW_AT_is_optional:
case DW_AT_segment: case llvm::dwarf::DW_AT_segment:
case DW_AT_variable_parameter: case llvm::dwarf::DW_AT_variable_parameter:
default: default:
case DW_AT_abstract_origin: case llvm::dwarf::DW_AT_abstract_origin:
case DW_AT_sibling: case llvm::dwarf::DW_AT_sibling:
break; break;
} }
} }
} }
bool skip = false; bool skip = false;
if (skip_artificial && is_artificial) { if (skip_artificial && is_artificial) {
// In order to determine if a C++ member function is "const" we // In order to determine if a C++ member function is "const" we
Show All 35 Lines case llvm::dwarf::DW_TAG_formal_parameter: {
m_ast.SetMetadataAsUserID(param_var_decl, die.GetID()); m_ast.SetMetadataAsUserID(param_var_decl, die.GetID());
} }
} }
} }
arg_idx++; arg_idx++;
} break; } break;
case DW_TAG_unspecified_parameters: case llvm::dwarf::DW_TAG_unspecified_parameters:
is_variadic = true; is_variadic = true;
break; break;
case DW_TAG_template_type_parameter: case llvm::dwarf::DW_TAG_template_type_parameter:
case DW_TAG_template_value_parameter: case llvm::dwarf::DW_TAG_template_value_parameter:
case DW_TAG_GNU_template_parameter_pack: case llvm::dwarf::DW_TAG_GNU_template_parameter_pack:
// The one caller of this was never using the template_param_infos, and // The one caller of this was never using the template_param_infos, and
// the local variable was taking up a large amount of stack space in // the local variable was taking up a large amount of stack space in
// SymbolFileDWARF::ParseType() so this was removed. If we ever need the // SymbolFileDWARF::ParseType() so this was removed. If we ever need the
// template params back, we can add them back. // template params back, we can add them back.
// ParseTemplateDIE (dwarf_cu, die, template_param_infos); // ParseTemplateDIE (dwarf_cu, die, template_param_infos);
has_template_params = true; has_template_params = true;
break; break;
default: default:
break; break;
} }
} }
return arg_idx; return arg_idx;
} }
llvm::Optional<SymbolFile::ArrayInfo> llvm::Optional<SymbolFile::ArrayInfo>
DWARFASTParser::ParseChildArrayInfo(const DWARFDIE &parent_die, DWARFASTParser::ParseChildArrayInfo(const DWARFDIE &parent_die,
const ExecutionContext *exe_ctx) { const ExecutionContext *exe_ctx) {
SymbolFile::ArrayInfo array_info; SymbolFile::ArrayInfo array_info;
if (!parent_die) if (!parent_die)
return llvm::None; return llvm::None;
for (DWARFDIE die : parent_die.children()) { for (DWARFDIE die : parent_die.children()) {
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
if (tag != DW_TAG_subrange_type) if (tag != llvm::dwarf::DW_TAG_subrange_type)
continue; continue;
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_child_attributes = die.GetAttributes(attributes); const size_t num_child_attributes = die.GetAttributes(attributes);
if (num_child_attributes > 0) { if (num_child_attributes > 0) {
uint64_t num_elements = 0; uint64_t num_elements = 0;
uint64_t lower_bound = 0; uint64_t lower_bound = 0;
uint64_t upper_bound = 0; uint64_t upper_bound = 0;
bool upper_bound_valid = false; bool upper_bound_valid = false;
uint32_t i; uint32_t i;
for (i = 0; i < num_child_attributes; ++i) { for (i = 0; i < num_child_attributes; ++i) {
const dw_attr_t attr = attributes.AttributeAtIndex(i); const dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
switch (attr) { switch (attr) {
case DW_AT_name: case llvm::dwarf::DW_AT_name:
break; break;
case DW_AT_count: case llvm::dwarf::DW_AT_count:
if (DWARFDIE var_die = die.GetReferencedDIE(DW_AT_count)) { if (DWARFDIE var_die =
if (var_die.Tag() == DW_TAG_variable) die.GetReferencedDIE(llvm::dwarf::DW_AT_count)) {
if (var_die.Tag() == llvm::dwarf::DW_TAG_variable)
if (exe_ctx) { if (exe_ctx) {
if (auto frame = exe_ctx->GetFrameSP()) { if (auto frame = exe_ctx->GetFrameSP()) {
Status error; Status error;
lldb::VariableSP var_sp; lldb::VariableSP var_sp;
auto valobj_sp = frame->GetValueForVariableExpressionPath( auto valobj_sp = frame->GetValueForVariableExpressionPath(
var_die.GetName(), eNoDynamicValues, 0, var_sp, var_die.GetName(), eNoDynamicValues, 0, var_sp,
error); error);
if (valobj_sp) { if (valobj_sp) {
num_elements = valobj_sp->GetValueAsUnsigned(0); num_elements = valobj_sp->GetValueAsUnsigned(0);
break; break;
} }
} }
} }
} else } else
num_elements = form_value.Unsigned(); num_elements = form_value.Unsigned();
break; break;
case DW_AT_bit_stride: case llvm::dwarf::DW_AT_bit_stride:
array_info.bit_stride = form_value.Unsigned(); array_info.bit_stride = form_value.Unsigned();
break; break;
case DW_AT_byte_stride: case llvm::dwarf::DW_AT_byte_stride:
array_info.byte_stride = form_value.Unsigned(); array_info.byte_stride = form_value.Unsigned();
break; break;
case DW_AT_lower_bound: case llvm::dwarf::DW_AT_lower_bound:
lower_bound = form_value.Unsigned(); lower_bound = form_value.Unsigned();
break; break;
case DW_AT_upper_bound: case llvm::dwarf::DW_AT_upper_bound:
upper_bound_valid = true; upper_bound_valid = true;
upper_bound = form_value.Unsigned(); upper_bound = form_value.Unsigned();
break; break;
default: default:
case DW_AT_abstract_origin: case llvm::dwarf::DW_AT_abstract_origin:
case DW_AT_accessibility: case llvm::dwarf::DW_AT_accessibility:
case DW_AT_allocated: case llvm::dwarf::DW_AT_allocated:
case DW_AT_associated: case llvm::dwarf::DW_AT_associated:
case DW_AT_data_location: case llvm::dwarf::DW_AT_data_location:
case DW_AT_declaration: case llvm::dwarf::DW_AT_declaration:
case DW_AT_description: case llvm::dwarf::DW_AT_description:
case DW_AT_sibling: case llvm::dwarf::DW_AT_sibling:
case DW_AT_threads_scaled: case llvm::dwarf::DW_AT_threads_scaled:
case DW_AT_type: case llvm::dwarf::DW_AT_type:
case DW_AT_visibility: case llvm::dwarf::DW_AT_visibility:
break; break;
} }
} }
} }
if (num_elements == 0) { if (num_elements == 0) {
if (upper_bound_valid && upper_bound >= lower_bound) if (upper_bound_valid && upper_bound >= lower_bound)
num_elements = upper_bound - lower_bound + 1; num_elements = upper_bound - lower_bound + 1;
Show All 11 Lines if (die) {
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_attributes = die.GetAttributes(attributes); const size_t num_attributes = die.GetAttributes(attributes);
if (num_attributes > 0) { if (num_attributes > 0) {
DWARFFormValue type_die_form; DWARFFormValue type_die_form;
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
dw_attr_t attr = attributes.AttributeAtIndex(i); dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (attr == DW_AT_type && if (attr == llvm::dwarf::DW_AT_type &&
attributes.ExtractFormValueAtIndex(i, form_value)) attributes.ExtractFormValueAtIndex(i, form_value))
return dwarf->ResolveTypeUID(form_value.Reference(), true); return dwarf->ResolveTypeUID(form_value.Reference(), true);
} }
} }
} }
return nullptr; return nullptr;
} }
clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) { clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {
if (!die) if (!die)
return nullptr; return nullptr;
switch (die.Tag()) { switch (die.Tag()) {
case DW_TAG_variable: case llvm::dwarf::DW_TAG_variable:
case DW_TAG_constant: case llvm::dwarf::DW_TAG_constant:
case DW_TAG_formal_parameter: case llvm::dwarf::DW_TAG_formal_parameter:
case DW_TAG_imported_declaration: case llvm::dwarf::DW_TAG_imported_declaration:
case DW_TAG_imported_module: case llvm::dwarf::DW_TAG_imported_module:
break; break;
default: default:
return nullptr; return nullptr;
} }
DIEToDeclMap::iterator cache_pos = m_die_to_decl.find(die.GetDIE()); DIEToDeclMap::iterator cache_pos = m_die_to_decl.find(die.GetDIE());
if (cache_pos != m_die_to_decl.end()) if (cache_pos != m_die_to_decl.end())
return cache_pos->second; return cache_pos->second;
if (DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification)) { if (DWARFDIE spec_die =
die.GetReferencedDIE(llvm::dwarf::DW_AT_specification)) {
clang::Decl *decl = GetClangDeclForDIE(spec_die); clang::Decl *decl = GetClangDeclForDIE(spec_die);
m_die_to_decl[die.GetDIE()] = decl; m_die_to_decl[die.GetDIE()] = decl;
return decl; return decl;
} }
if (DWARFDIE abstract_origin_die = if (DWARFDIE abstract_origin_die =
die.GetReferencedDIE(DW_AT_abstract_origin)) { die.GetReferencedDIE(llvm::dwarf::DW_AT_abstract_origin)) {
clang::Decl *decl = GetClangDeclForDIE(abstract_origin_die); clang::Decl *decl = GetClangDeclForDIE(abstract_origin_die);
m_die_to_decl[die.GetDIE()] = decl; m_die_to_decl[die.GetDIE()] = decl;
return decl; return decl;
} }
clang::Decl *decl = nullptr; clang::Decl *decl = nullptr;
switch (die.Tag()) { switch (die.Tag()) {
case DW_TAG_variable: case llvm::dwarf::DW_TAG_variable:
case DW_TAG_constant: case llvm::dwarf::DW_TAG_constant:
case DW_TAG_formal_parameter: { case llvm::dwarf::DW_TAG_formal_parameter: {
SymbolFileDWARF *dwarf = die.GetDWARF(); SymbolFileDWARF *dwarf = die.GetDWARF();
Type *type = GetTypeForDIE(die); Type *type = GetTypeForDIE(die);
if (dwarf && type) { if (dwarf && type) {
const char *name = die.GetName(); const char *name = die.GetName();
clang::DeclContext *decl_context = clang::DeclContext *decl_context =
TypeSystemClang::DeclContextGetAsDeclContext( TypeSystemClang::DeclContextGetAsDeclContext(
dwarf->GetDeclContextContainingUID(die.GetID())); dwarf->GetDeclContextContainingUID(die.GetID()));
decl = m_ast.CreateVariableDeclaration( decl = m_ast.CreateVariableDeclaration(
decl_context, GetOwningClangModule(die), name, decl_context, GetOwningClangModule(die), name,
ClangUtil::GetQualType(type->GetForwardCompilerType())); ClangUtil::GetQualType(type->GetForwardCompilerType()));
} }
break; break;
} }
case DW_TAG_imported_declaration: { case llvm::dwarf::DW_TAG_imported_declaration: {
SymbolFileDWARF *dwarf = die.GetDWARF(); SymbolFileDWARF *dwarf = die.GetDWARF();
DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import); DWARFDIE imported_uid =
die.GetAttributeValueAsReferenceDIE(llvm::dwarf::DW_AT_import);
if (imported_uid) { if (imported_uid) {
CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid); CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid);
if (imported_decl) { if (imported_decl) {
clang::DeclContext *decl_context = clang::DeclContext *decl_context =
TypeSystemClang::DeclContextGetAsDeclContext( TypeSystemClang::DeclContextGetAsDeclContext(
dwarf->GetDeclContextContainingUID(die.GetID())); dwarf->GetDeclContextContainingUID(die.GetID()));
if (clang::NamedDecl *clang_imported_decl = if (clang::NamedDecl *clang_imported_decl =
llvm::dyn_cast<clang::NamedDecl>( llvm::dyn_cast<clang::NamedDecl>(
(clang::Decl *)imported_decl.GetOpaqueDecl())) (clang::Decl *)imported_decl.GetOpaqueDecl()))
decl = m_ast.CreateUsingDeclaration( decl = m_ast.CreateUsingDeclaration(
decl_context, OptionalClangModuleID(), clang_imported_decl); decl_context, OptionalClangModuleID(), clang_imported_decl);
} }
} }
break; break;
} }
case DW_TAG_imported_module: { case llvm::dwarf::DW_TAG_imported_module: {
SymbolFileDWARF *dwarf = die.GetDWARF(); SymbolFileDWARF *dwarf = die.GetDWARF();
DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import); DWARFDIE imported_uid =
die.GetAttributeValueAsReferenceDIE(llvm::dwarf::DW_AT_import);
if (imported_uid) { if (imported_uid) {
CompilerDeclContext imported_decl_ctx = CompilerDeclContext imported_decl_ctx =
SymbolFileDWARF::GetDeclContext(imported_uid); SymbolFileDWARF::GetDeclContext(imported_uid);
if (imported_decl_ctx) { if (imported_decl_ctx) {
clang::DeclContext *decl_context = clang::DeclContext *decl_context =
TypeSystemClang::DeclContextGetAsDeclContext( TypeSystemClang::DeclContextGetAsDeclContext(
dwarf->GetDeclContextContainingUID(die.GetID())); dwarf->GetDeclContextContainingUID(die.GetID()));
Show All 19 Lines
DWARFASTParserClang::GetClangDeclContextForDIE(const DWARFDIE &die) { DWARFASTParserClang::GetClangDeclContextForDIE(const DWARFDIE &die) {
if (die) { if (die) {
clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE(die); clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE(die);
if (decl_ctx) if (decl_ctx)
return decl_ctx; return decl_ctx;
bool try_parsing_type = true; bool try_parsing_type = true;
switch (die.Tag()) { switch (die.Tag()) {
case DW_TAG_compile_unit: case llvm::dwarf::DW_TAG_compile_unit:
case DW_TAG_partial_unit: case llvm::dwarf::DW_TAG_partial_unit:
decl_ctx = m_ast.GetTranslationUnitDecl(); decl_ctx = m_ast.GetTranslationUnitDecl();
try_parsing_type = false; try_parsing_type = false;
break; break;
case DW_TAG_namespace: case llvm::dwarf::DW_TAG_namespace:
decl_ctx = ResolveNamespaceDIE(die); decl_ctx = ResolveNamespaceDIE(die);
try_parsing_type = false; try_parsing_type = false;
break; break;
case DW_TAG_lexical_block: case llvm::dwarf::DW_TAG_lexical_block:
decl_ctx = GetDeclContextForBlock(die); decl_ctx = GetDeclContextForBlock(die);
try_parsing_type = false; try_parsing_type = false;
break; break;
default: default:
break; break;
} }
Show All 14 Lines
OptionalClangModuleID OptionalClangModuleID
DWARFASTParserClang::GetOwningClangModule(const DWARFDIE &die) { DWARFASTParserClang::GetOwningClangModule(const DWARFDIE &die) {
if (!die.IsValid()) if (!die.IsValid())
return {}; return {};
for (DWARFDIE parent = die.GetParent(); parent.IsValid(); for (DWARFDIE parent = die.GetParent(); parent.IsValid();
parent = parent.GetParent()) { parent = parent.GetParent()) {
const dw_tag_t tag = parent.Tag(); const dw_tag_t tag = parent.Tag();
if (tag == DW_TAG_module) { if (tag == llvm::dwarf::DW_TAG_module) {
DWARFDIE module_die = parent; DWARFDIE module_die = parent;
auto it = m_die_to_module.find(module_die.GetDIE()); auto it = m_die_to_module.find(module_die.GetDIE());
if (it != m_die_to_module.end()) if (it != m_die_to_module.end())
return it->second; return it->second;
const char *name = const char *name = module_die.GetAttributeValueAsString(
module_die.GetAttributeValueAsString(DW_AT_name, nullptr); llvm::dwarf::DW_AT_name, nullptr);
if (!name) if (!name)
return {}; return {};
OptionalClangModuleID id = OptionalClangModuleID id =
m_ast.GetOrCreateClangModule(name, GetOwningClangModule(module_die)); m_ast.GetOrCreateClangModule(name, GetOwningClangModule(module_die));
m_die_to_module.insert({module_die.GetDIE(), id}); m_die_to_module.insert({module_die.GetDIE(), id});
return id; return id;
} }
} }
return {}; return {};
} }
static bool IsSubroutine(const DWARFDIE &die) { static bool IsSubroutine(const DWARFDIE &die) {
switch (die.Tag()) { switch (die.Tag()) {
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
return true; return true;
default: default:
return false; return false;
} }
} }
static DWARFDIE GetContainingFunctionWithAbstractOrigin(const DWARFDIE &die) { static DWARFDIE GetContainingFunctionWithAbstractOrigin(const DWARFDIE &die) {
for (DWARFDIE candidate = die; candidate; candidate = candidate.GetParent()) { for (DWARFDIE candidate = die; candidate; candidate = candidate.GetParent()) {
if (IsSubroutine(candidate)) { if (IsSubroutine(candidate)) {
if (candidate.GetReferencedDIE(DW_AT_abstract_origin)) { if (candidate.GetReferencedDIE(llvm::dwarf::DW_AT_abstract_origin)) {
return candidate; return candidate;
} else { } else {
return DWARFDIE(); return DWARFDIE();
} }
} }
} }
assert(0 && "Shouldn't call GetContainingFunctionWithAbstractOrigin on " assert(0 && "Shouldn't call GetContainingFunctionWithAbstractOrigin on "
"something not in a function"); "something not in a function");
return DWARFDIE(); return DWARFDIE();
} }
static DWARFDIE FindAnyChildWithAbstractOrigin(const DWARFDIE &context) { static DWARFDIE FindAnyChildWithAbstractOrigin(const DWARFDIE &context) {
for (DWARFDIE candidate : context.children()) { for (DWARFDIE candidate : context.children()) {
if (candidate.GetReferencedDIE(DW_AT_abstract_origin)) { if (candidate.GetReferencedDIE(llvm::dwarf::DW_AT_abstract_origin)) {
return candidate; return candidate;
} }
} }
return DWARFDIE(); return DWARFDIE();
} }
static DWARFDIE FindFirstChildWithAbstractOrigin(const DWARFDIE &block, static DWARFDIE FindFirstChildWithAbstractOrigin(const DWARFDIE &block,
const DWARFDIE &function) { const DWARFDIE &function) {
assert(IsSubroutine(function)); assert(IsSubroutine(function));
for (DWARFDIE context = block; context != function.GetParent(); for (DWARFDIE context = block; context != function.GetParent();
context = context.GetParent()) { context = context.GetParent()) {
assert(!IsSubroutine(context) || context == function); assert(!IsSubroutine(context) || context == function);
if (DWARFDIE child = FindAnyChildWithAbstractOrigin(context)) { if (DWARFDIE child = FindAnyChildWithAbstractOrigin(context)) {
return child; return child;
} }
} }
return DWARFDIE(); return DWARFDIE();
} }
clang::DeclContext * clang::DeclContext *
DWARFASTParserClang::GetDeclContextForBlock(const DWARFDIE &die) { DWARFASTParserClang::GetDeclContextForBlock(const DWARFDIE &die) {
assert(die.Tag() == DW_TAG_lexical_block); assert(die.Tag() == llvm::dwarf::DW_TAG_lexical_block);
DWARFDIE containing_function_with_abstract_origin = DWARFDIE containing_function_with_abstract_origin =
GetContainingFunctionWithAbstractOrigin(die); GetContainingFunctionWithAbstractOrigin(die);
if (!containing_function_with_abstract_origin) { if (!containing_function_with_abstract_origin) {
return (clang::DeclContext *)ResolveBlockDIE(die); return (clang::DeclContext *)ResolveBlockDIE(die);
} }
DWARFDIE child = FindFirstChildWithAbstractOrigin( DWARFDIE child = FindFirstChildWithAbstractOrigin(
die, containing_function_with_abstract_origin); die, containing_function_with_abstract_origin);
CompilerDeclContext decl_context = CompilerDeclContext decl_context =
GetDeclContextContainingUIDFromDWARF(child); GetDeclContextContainingUIDFromDWARF(child);
return (clang::DeclContext *)decl_context.GetOpaqueDeclContext(); return (clang::DeclContext *)decl_context.GetOpaqueDeclContext();
} }
clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die) { clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die) {
if (die && die.Tag() == DW_TAG_lexical_block) { if (die && die.Tag() == llvm::dwarf::DW_TAG_lexical_block) {
clang::BlockDecl *decl = clang::BlockDecl *decl =
llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]); llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
if (!decl) { if (!decl) {
DWARFDIE decl_context_die; DWARFDIE decl_context_die;
clang::DeclContext *decl_context = clang::DeclContext *decl_context =
GetClangDeclContextContainingDIE(die, &decl_context_die); GetClangDeclContextContainingDIE(die, &decl_context_die);
decl = decl =
m_ast.CreateBlockDeclaration(decl_context, GetOwningClangModule(die)); m_ast.CreateBlockDeclaration(decl_context, GetOwningClangModule(die));
if (decl) if (decl)
LinkDeclContextToDIE((clang::DeclContext *)decl, die); LinkDeclContextToDIE((clang::DeclContext *)decl, die);
} }
return decl; return decl;
} }
return nullptr; return nullptr;
} }
clang::NamespaceDecl * clang::NamespaceDecl *
DWARFASTParserClang::ResolveNamespaceDIE(const DWARFDIE &die) { DWARFASTParserClang::ResolveNamespaceDIE(const DWARFDIE &die) {
if (die && die.Tag() == DW_TAG_namespace) { if (die && die.Tag() == llvm::dwarf::DW_TAG_namespace) {
// See if we already parsed this namespace DIE and associated it with a // See if we already parsed this namespace DIE and associated it with a
// uniqued namespace declaration // uniqued namespace declaration
clang::NamespaceDecl *namespace_decl = clang::NamespaceDecl *namespace_decl =
static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]); static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
if (namespace_decl) if (namespace_decl)
return namespace_decl; return namespace_decl;
else { else {
const char *namespace_name = die.GetName(); const char *namespace_name = die.GetName();
clang::DeclContext *containing_decl_ctx = clang::DeclContext *containing_decl_ctx =
GetClangDeclContextContainingDIE(die, nullptr); GetClangDeclContextContainingDIE(die, nullptr);
bool is_inline = bool is_inline = die.GetAttributeValueAsUnsigned(
die.GetAttributeValueAsUnsigned(DW_AT_export_symbols, 0) != 0; llvm::dwarf::DW_AT_export_symbols, 0) != 0;
namespace_decl = m_ast.GetUniqueNamespaceDeclaration( namespace_decl = m_ast.GetUniqueNamespaceDeclaration(
namespace_name, containing_decl_ctx, GetOwningClangModule(die), namespace_name, containing_decl_ctx, GetOwningClangModule(die),
is_inline); is_inline);
if (namespace_decl) if (namespace_decl)
LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, die); LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, die);
return namespace_decl; return namespace_decl;
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesbool DWARFASTParserClang::CopyUniqueClassMethodTypes(
DWARFDIE src_die; DWARFDIE src_die;
DWARFDIE dst_die; DWARFDIE dst_die;
UniqueCStringMap<DWARFDIE> src_name_to_die; UniqueCStringMap<DWARFDIE> src_name_to_die;
UniqueCStringMap<DWARFDIE> dst_name_to_die; UniqueCStringMap<DWARFDIE> dst_name_to_die;
UniqueCStringMap<DWARFDIE> src_name_to_die_artificial; UniqueCStringMap<DWARFDIE> src_name_to_die_artificial;
UniqueCStringMap<DWARFDIE> dst_name_to_die_artificial; UniqueCStringMap<DWARFDIE> dst_name_to_die_artificial;
for (src_die = src_class_die.GetFirstChild(); src_die.IsValid(); for (src_die = src_class_die.GetFirstChild(); src_die.IsValid();
src_die = src_die.GetSibling()) { src_die = src_die.GetSibling()) {
if (src_die.Tag() == DW_TAG_subprogram) { if (src_die.Tag() == llvm::dwarf::DW_TAG_subprogram) {
// Make sure this is a declaration and not a concrete instance by looking // Make sure this is a declaration and not a concrete instance by looking
// for DW_AT_declaration set to 1. Sometimes concrete function instances // for DW_AT_declaration set to 1. Sometimes concrete function instances
// are placed inside the class definitions and shouldn't be included in // are placed inside the class definitions and shouldn't be included in
// the list of things are are tracking here. // the list of things are are tracking here.
if (src_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1) { if (src_die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration,
0) == 1) {
const char *src_name = src_die.GetMangledName(); const char *src_name = src_die.GetMangledName();
if (src_name) { if (src_name) {
ConstString src_const_name(src_name); ConstString src_const_name(src_name);
if (src_die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0)) if (src_die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_artificial,
0))
src_name_to_die_artificial.Append(src_const_name, src_die); src_name_to_die_artificial.Append(src_const_name, src_die);
else else
src_name_to_die.Append(src_const_name, src_die); src_name_to_die.Append(src_const_name, src_die);
} }
} }
} }
} }
for (dst_die = dst_class_die.GetFirstChild(); dst_die.IsValid(); for (dst_die = dst_class_die.GetFirstChild(); dst_die.IsValid();
dst_die = dst_die.GetSibling()) { dst_die = dst_die.GetSibling()) {
if (dst_die.Tag() == DW_TAG_subprogram) { if (dst_die.Tag() == llvm::dwarf::DW_TAG_subprogram) {
// Make sure this is a declaration and not a concrete instance by looking // Make sure this is a declaration and not a concrete instance by looking
// for DW_AT_declaration set to 1. Sometimes concrete function instances // for DW_AT_declaration set to 1. Sometimes concrete function instances
// are placed inside the class definitions and shouldn't be included in // are placed inside the class definitions and shouldn't be included in
// the list of things are are tracking here. // the list of things are are tracking here.
if (dst_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1) { if (dst_die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration,
0) == 1) {
const char *dst_name = dst_die.GetMangledName(); const char *dst_name = dst_die.GetMangledName();
if (dst_name) { if (dst_name) {
ConstString dst_const_name(dst_name); ConstString dst_const_name(dst_name);
if (dst_die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0)) if (dst_die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_artificial,
0))
dst_name_to_die_artificial.Append(dst_const_name, dst_die); dst_name_to_die_artificial.Append(dst_const_name, dst_die);
else else
dst_name_to_die.Append(dst_const_name, dst_die); dst_name_to_die.Append(dst_const_name, dst_die);
} }
} }
} }
} }
const uint32_t src_size = src_name_to_die.GetSize(); const uint32_t src_size = src_name_to_die.GetSize();
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.cpp

Show All 27 Lines
DWARFAbbreviationDeclaration::extract(const DWARFDataExtractor &data, DWARFAbbreviationDeclaration::extract(const DWARFDataExtractor &data,
lldb::offset_t *offset_ptr) { lldb::offset_t *offset_ptr) {
m_code = data.GetULEB128(offset_ptr); m_code = data.GetULEB128(offset_ptr);
if (m_code == 0) if (m_code == 0)
return DWARFEnumState::Complete; return DWARFEnumState::Complete;
m_attributes.clear(); m_attributes.clear();
m_tag = static_cast<dw_tag_t>(data.GetULEB128(offset_ptr)); m_tag = static_cast<dw_tag_t>(data.GetULEB128(offset_ptr));
if (m_tag == DW_TAG_null) if (m_tag == llvm::dwarf::DW_TAG_null)
return llvm::make_error<llvm::object::GenericBinaryError>( return llvm::make_error<llvm::object::GenericBinaryError>(
"abbrev decl requires non-null tag."); "abbrev decl requires non-null tag.");
m_has_children = data.GetU8(offset_ptr); m_has_children = data.GetU8(offset_ptr);
while (data.ValidOffset(*offset_ptr)) { while (data.ValidOffset(*offset_ptr)) {
dw_attr_t attr = data.GetULEB128(offset_ptr); dw_attr_t attr = data.GetULEB128(offset_ptr);
dw_form_t form = data.GetULEB128(offset_ptr); dw_form_t form = data.GetULEB128(offset_ptr);
// This is the last attribute for this abbrev decl, but there may still be // This is the last attribute for this abbrev decl, but there may still be
// more abbrev decls, so return MoreItems to indicate to the caller that // more abbrev decls, so return MoreItems to indicate to the caller that
// they should call this function again. // they should call this function again.
if (!attr && !form) if (!attr && !form)
return DWARFEnumState::MoreItems; return DWARFEnumState::MoreItems;
if (!attr || !form) if (!attr || !form)
return llvm::make_error<llvm::object::GenericBinaryError>( return llvm::make_error<llvm::object::GenericBinaryError>(
"malformed abbreviation declaration attribute"); "malformed abbreviation declaration attribute");
DWARFFormValue::ValueType val; DWARFFormValue::ValueType val;
if (form == DW_FORM_implicit_const) if (form == llvm::dwarf::DW_FORM_implicit_const)
val.value.sval = data.GetSLEB128(offset_ptr); val.value.sval = data.GetSLEB128(offset_ptr);
m_attributes.push_back(DWARFAttribute(attr, form, val)); m_attributes.push_back(DWARFAttribute(attr, form, val));
} }
return llvm::make_error<llvm::object::GenericBinaryError>( return llvm::make_error<llvm::object::GenericBinaryError>(
"abbreviation declaration attribute list not terminated with a null " "abbreviation declaration attribute list not terminated with a null "
"entry"); "entry");
Show All 16 Lines

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp

Show All 32 Linesvoid DWARFAttributes::Append(const DWARFFormValue &form_value,
m_infos.push_back(attr_value); m_infos.push_back(attr_value);
} }
bool DWARFAttributes::ExtractFormValueAtIndex( bool DWARFAttributes::ExtractFormValueAtIndex(
uint32_t i, DWARFFormValue &form_value) const { uint32_t i, DWARFFormValue &form_value) const {
const DWARFUnit *cu = CompileUnitAtIndex(i); const DWARFUnit *cu = CompileUnitAtIndex(i);
form_value.SetUnit(cu); form_value.SetUnit(cu);
form_value.SetForm(FormAtIndex(i)); form_value.SetForm(FormAtIndex(i));
if (form_value.Form() == DW_FORM_implicit_const) { if (form_value.Form() == llvm::dwarf::DW_FORM_implicit_const) {
form_value.SetValue(ValueAtIndex(i)); form_value.SetValue(ValueAtIndex(i));
return true; return true;
} }
lldb::offset_t offset = DIEOffsetAtIndex(i); lldb::offset_t offset = DIEOffsetAtIndex(i);
return form_value.ExtractValue(cu->GetData(), &offset); return form_value.ExtractValue(cu->GetData(), &offset);
} }
DWARFDIE DWARFDIE
Show All 14 Lines

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

Show All 36 Linesclass ElaboratingDIEIterator
void Next() { void Next() {
assert(!m_worklist.empty() && "Incrementing end iterator?"); assert(!m_worklist.empty() && "Incrementing end iterator?");
// Pop the current item from the list. // Pop the current item from the list.
DWARFDIE die = m_worklist.back(); DWARFDIE die = m_worklist.back();
m_worklist.pop_back(); m_worklist.pop_back();
// And add back any items that elaborate it. // And add back any items that elaborate it.
for (dw_attr_t attr : {DW_AT_specification, DW_AT_abstract_origin}) { for (dw_attr_t attr : {llvm::dwarf::DW_AT_specification,
llvm::dwarf::DW_AT_abstract_origin}) {
if (DWARFDIE d = die.GetReferencedDIE(attr)) if (DWARFDIE d = die.GetReferencedDIE(attr))
if (m_seen.insert(die.GetDIE()).second) if (m_seen.insert(die.GetDIE()).second)
m_worklist.push_back(d); m_worklist.push_back(d);
} }
} }
public: public:
/// An iterator starting at die d. /// An iterator starting at die d.
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
DWARFDIE::LookupDeepestBlock(lldb::addr_t address) const { DWARFDIE::LookupDeepestBlock(lldb::addr_t address) const {
if (!IsValid()) if (!IsValid())
return DWARFDIE(); return DWARFDIE();
DWARFDIE result; DWARFDIE result;
bool check_children = false; bool check_children = false;
bool match_addr_range = false; bool match_addr_range = false;
switch (Tag()) { switch (Tag()) {
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
case DW_TAG_namespace: case llvm::dwarf::DW_TAG_namespace:
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_common_block: case llvm::dwarf::DW_TAG_common_block:
check_children = true; check_children = true;
break; break;
case DW_TAG_compile_unit: case llvm::dwarf::DW_TAG_compile_unit:
case DW_TAG_module: case llvm::dwarf::DW_TAG_module:
case DW_TAG_catch_block: case llvm::dwarf::DW_TAG_catch_block:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_try_block: case llvm::dwarf::DW_TAG_try_block:
case DW_TAG_partial_unit: case llvm::dwarf::DW_TAG_partial_unit:
match_addr_range = true; match_addr_range = true;
break; break;
case DW_TAG_lexical_block: case llvm::dwarf::DW_TAG_lexical_block:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
check_children = true; check_children = true;
match_addr_range = true; match_addr_range = true;
break; break;
default: default:
break; break;
} }
if (match_addr_range) { if (match_addr_range) {
DWARFRangeList ranges; DWARFRangeList ranges;
if (m_die->GetAttributeAddressRanges(m_cu, ranges, if (m_die->GetAttributeAddressRanges(m_cu, ranges,
/*check_hi_lo_pc=*/true) && /*check_hi_lo_pc=*/true) &&
ranges.FindEntryThatContains(address)) { ranges.FindEntryThatContains(address)) {
check_children = true; check_children = true;
switch (Tag()) { switch (Tag()) {
default: default:
break; break;
case DW_TAG_inlined_subroutine: // Inlined Function case llvm::dwarf::DW_TAG_inlined_subroutine: // Inlined Function
case DW_TAG_lexical_block: // Block { } in code case llvm::dwarf::DW_TAG_lexical_block: // Block { } in code
result = *this; result = *this;
break; break;
} }
} else { } else {
check_children = false; check_children = false;
} }
} }
Show All 34 Lines
// and if no DW_AT_name attribute exists for the DIE then nothing is printed. // and if no DW_AT_name attribute exists for the DIE then nothing is printed.
void DWARFDIE::GetName(Stream &s) const { void DWARFDIE::GetName(Stream &s) const {
if (!IsValid()) if (!IsValid())
return; return;
if (GetDIE()->IsNULL()) { if (GetDIE()->IsNULL()) {
s.PutCString("NULL"); s.PutCString("NULL");
return; return;
} }
const char *name = GetDIE()->GetAttributeValueAsString(GetCU(), DW_AT_name, nullptr, true); const char *name = GetDIE()->GetAttributeValueAsString(
GetCU(), llvm::dwarf::DW_AT_name, nullptr, true);
if (!name) if (!name)
return; return;
s.PutCString(name); s.PutCString(name);
} }
// AppendTypeName // AppendTypeName
// //
// Follows the type name definition down through all needed tags to end up with // Follows the type name definition down through all needed tags to end up with
// a fully qualified type name and dump the results to the supplied stream. // a fully qualified type name and dump the results to the supplied stream.
// This is used to show the name of types given a type identifier. // This is used to show the name of types given a type identifier.
void DWARFDIE::AppendTypeName(Stream &s) const { void DWARFDIE::AppendTypeName(Stream &s) const {
if (!IsValid()) if (!IsValid())
return; return;
if (GetDIE()->IsNULL()) { if (GetDIE()->IsNULL()) {
s.PutCString("NULL"); s.PutCString("NULL");
return; return;
} }
if (const char *name = GetPubname()) { if (const char *name = GetPubname()) {
s.PutCString(name); s.PutCString(name);
return; return;
} }
switch (Tag()) { switch (Tag()) {
case DW_TAG_array_type: case llvm::dwarf::DW_TAG_array_type:
break; // print out a "[]" after printing the full type of the element break; // print out a "[]" after printing the full type of the element
// below // below
case DW_TAG_base_type: case llvm::dwarf::DW_TAG_base_type:
s.PutCString("base "); s.PutCString("base ");
break; break;
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
s.PutCString("class "); s.PutCString("class ");
break; break;
case DW_TAG_const_type: case llvm::dwarf::DW_TAG_const_type:
s.PutCString("const "); s.PutCString("const ");
break; break;
case DW_TAG_enumeration_type: case llvm::dwarf::DW_TAG_enumeration_type:
s.PutCString("enum "); s.PutCString("enum ");
break; break;
case DW_TAG_file_type: case llvm::dwarf::DW_TAG_file_type:
s.PutCString("file "); s.PutCString("file ");
break; break;
case DW_TAG_interface_type: case llvm::dwarf::DW_TAG_interface_type:
s.PutCString("interface "); s.PutCString("interface ");
break; break;
case DW_TAG_packed_type: case llvm::dwarf::DW_TAG_packed_type:
s.PutCString("packed "); s.PutCString("packed ");
break; break;
case DW_TAG_pointer_type: case llvm::dwarf::DW_TAG_pointer_type:
break; // print out a '*' after printing the full type below break; // print out a '*' after printing the full type below
case DW_TAG_ptr_to_member_type: case llvm::dwarf::DW_TAG_ptr_to_member_type:
break; // print out a '*' after printing the full type below break; // print out a '*' after printing the full type below
case DW_TAG_reference_type: case llvm::dwarf::DW_TAG_reference_type:
break; // print out a '&' after printing the full type below break; // print out a '&' after printing the full type below
case DW_TAG_restrict_type: case llvm::dwarf::DW_TAG_restrict_type:
s.PutCString("restrict "); s.PutCString("restrict ");
break; break;
case DW_TAG_set_type: case llvm::dwarf::DW_TAG_set_type:
s.PutCString("set "); s.PutCString("set ");
break; break;
case DW_TAG_shared_type: case llvm::dwarf::DW_TAG_shared_type:
s.PutCString("shared "); s.PutCString("shared ");
break; break;
case DW_TAG_string_type: case llvm::dwarf::DW_TAG_string_type:
s.PutCString("string "); s.PutCString("string ");
break; break;
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
s.PutCString("struct "); s.PutCString("struct ");
break; break;
case DW_TAG_subrange_type: case llvm::dwarf::DW_TAG_subrange_type:
s.PutCString("subrange "); s.PutCString("subrange ");
break; break;
case DW_TAG_subroutine_type: case llvm::dwarf::DW_TAG_subroutine_type:
s.PutCString("function "); s.PutCString("function ");
break; break;
case DW_TAG_thrown_type: case llvm::dwarf::DW_TAG_thrown_type:
s.PutCString("thrown "); s.PutCString("thrown ");
break; break;
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
s.PutCString("union "); s.PutCString("union ");
break; break;
case DW_TAG_unspecified_type: case llvm::dwarf::DW_TAG_unspecified_type:
s.PutCString("unspecified "); s.PutCString("unspecified ");
break; break;
case DW_TAG_volatile_type: case llvm::dwarf::DW_TAG_volatile_type:
s.PutCString("volatile "); s.PutCString("volatile ");
break; break;
default: default:
return; return;
} }
// Follow the DW_AT_type if possible // Follow the DW_AT_type if possible
if (DWARFDIE next_die = GetAttributeValueAsReferenceDIE(DW_AT_type)) if (DWARFDIE next_die =
GetAttributeValueAsReferenceDIE(llvm::dwarf::DW_AT_type))
next_die.AppendTypeName(s); next_die.AppendTypeName(s);
switch (Tag()) { switch (Tag()) {
case DW_TAG_array_type: case llvm::dwarf::DW_TAG_array_type:
s.PutCString("[]"); s.PutCString("[]");
break; break;
case DW_TAG_pointer_type: case llvm::dwarf::DW_TAG_pointer_type:
s.PutChar('*'); s.PutChar('*');
break; break;
case DW_TAG_ptr_to_member_type: case llvm::dwarf::DW_TAG_ptr_to_member_type:
s.PutChar('*'); s.PutChar('*');
break; break;
case DW_TAG_reference_type: case llvm::dwarf::DW_TAG_reference_type:
s.PutChar('&'); s.PutChar('&');
break; break;
default: default:
break; break;
} }
} }
lldb_private::Type *DWARFDIE::ResolveType() const { lldb_private::Type *DWARFDIE::ResolveType() const {
Show All 21 Linesstd::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
} }
return result; return result;
} }
void DWARFDIE::GetDeclContext( void DWARFDIE::GetDeclContext(
llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const { llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const {
const dw_tag_t tag = Tag(); const dw_tag_t tag = Tag();
if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit) if (tag == llvm::dwarf::DW_TAG_compile_unit ||
tag == llvm::dwarf::DW_TAG_partial_unit)
return; return;
DWARFDIE parent = GetParent(); DWARFDIE parent = GetParent();
if (parent) if (parent)
parent.GetDeclContext(context); parent.GetDeclContext(context);
switch (tag) { switch (tag) {
case DW_TAG_module: case llvm::dwarf::DW_TAG_module:
context.push_back({CompilerContextKind::Module, ConstString(GetName())}); context.push_back({CompilerContextKind::Module, ConstString(GetName())});
break; break;
case DW_TAG_namespace: case llvm::dwarf::DW_TAG_namespace:
context.push_back({CompilerContextKind::Namespace, ConstString(GetName())}); context.push_back({CompilerContextKind::Namespace, ConstString(GetName())});
break; break;
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
context.push_back({CompilerContextKind::Struct, ConstString(GetName())}); context.push_back({CompilerContextKind::Struct, ConstString(GetName())});
break; break;
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
context.push_back({CompilerContextKind::Union, ConstString(GetName())}); context.push_back({CompilerContextKind::Union, ConstString(GetName())});
break; break;
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
context.push_back({CompilerContextKind::Class, ConstString(GetName())}); context.push_back({CompilerContextKind::Class, ConstString(GetName())});
break; break;
case DW_TAG_enumeration_type: case llvm::dwarf::DW_TAG_enumeration_type:
context.push_back({CompilerContextKind::Enum, ConstString(GetName())}); context.push_back({CompilerContextKind::Enum, ConstString(GetName())});
break; break;
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
context.push_back( context.push_back(
{CompilerContextKind::Function, ConstString(GetPubname())}); {CompilerContextKind::Function, ConstString(GetPubname())});
break; break;
case DW_TAG_variable: case llvm::dwarf::DW_TAG_variable:
context.push_back( context.push_back(
{CompilerContextKind::Variable, ConstString(GetPubname())}); {CompilerContextKind::Variable, ConstString(GetPubname())});
break; break;
case DW_TAG_typedef: case llvm::dwarf::DW_TAG_typedef:
context.push_back({CompilerContextKind::Typedef, ConstString(GetName())}); context.push_back({CompilerContextKind::Typedef, ConstString(GetName())});
break; break;
default: default:
break; break;
} }
} }
DWARFDIE DWARFDIE
DWARFDIE::GetParentDeclContextDIE() const { DWARFDIE::GetParentDeclContextDIE() const {
if (IsValid()) if (IsValid())
return m_die->GetParentDeclContextDIE(m_cu); return m_die->GetParentDeclContextDIE(m_cu);
else else
return DWARFDIE(); return DWARFDIE();
} }
bool DWARFDIE::IsStructUnionOrClass() const { bool DWARFDIE::IsStructUnionOrClass() const {
const dw_tag_t tag = Tag(); const dw_tag_t tag = Tag();
return tag == DW_TAG_class_type || tag == DW_TAG_structure_type || return tag == llvm::dwarf::DW_TAG_class_type ||
tag == DW_TAG_union_type; tag == llvm::dwarf::DW_TAG_structure_type ||
tag == llvm::dwarf::DW_TAG_union_type;
} }
bool DWARFDIE::IsMethod() const { bool DWARFDIE::IsMethod() const {
for (DWARFDIE d : elaborating_dies(*this)) for (DWARFDIE d : elaborating_dies(*this))
if (d.GetParent().IsStructUnionOrClass()) if (d.GetParent().IsStructUnionOrClass())
return true; return true;
return false; return false;
} }
Show All 17 Lines

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

Show All 25 Lines
#include "DWARFDebugRanges.h" #include "DWARFDebugRanges.h"
#include "DWARFDeclContext.h" #include "DWARFDeclContext.h"
#include "DWARFFormValue.h" #include "DWARFFormValue.h"
#include "DWARFUnit.h" #include "DWARFUnit.h"
#include "SymbolFileDWARF.h" #include "SymbolFileDWARF.h"
#include "SymbolFileDWARFDwo.h" #include "SymbolFileDWARFDwo.h"
using namespace lldb_private; using namespace lldb_private;
using namespace std; using namespace std;
JDevlieghereUnsubmitted
Done
ReplyInline Actions

Oh no...

JDevlieghere: [[ https://llvm.org/docs/CodingStandards.html#do-not-use-using-namespace-std | Oh no... ]]
shafikAuthorUnsubmitted
Done
ReplyInline Actions

Yeah I noticed that was going to put that on a list of things to do, didn't feel right mixing that in here as well.

shafik: Yeah I noticed that was going to put that on a list of things to do, didn't feel right mixing…
JDevlieghereUnsubmitted
Done
ReplyInline Actions

Totally!

JDevlieghere: Totally!
extern int g_verbose; extern int g_verbose;
// Extract a debug info entry for a given DWARFUnit from the data // Extract a debug info entry for a given DWARFUnit from the data
// starting at the offset in offset_ptr // starting at the offset in offset_ptr
bool DWARFDebugInfoEntry::Extract(const DWARFDataExtractor &data, bool DWARFDebugInfoEntry::Extract(const DWARFDataExtractor &data,
const DWARFUnit *cu, const DWARFUnit *cu,
lldb::offset_t *offset_ptr) { lldb::offset_t *offset_ptr) {
using namespace llvm::dwarf;
m_offset = *offset_ptr; m_offset = *offset_ptr;
m_parent_idx = 0; m_parent_idx = 0;
m_sibling_idx = 0; m_sibling_idx = 0;
const uint64_t abbr_idx = data.GetULEB128(offset_ptr); const uint64_t abbr_idx = data.GetULEB128(offset_ptr);
lldbassert(abbr_idx <= UINT16_MAX); lldbassert(abbr_idx <= UINT16_MAX);
m_abbr_idx = abbr_idx; m_abbr_idx = abbr_idx;
// assert (fixed_form_sizes); // For best performance this should be // assert (fixed_form_sizes); // For best performance this should be
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Linesbool DWARFDebugInfoEntry::Extract(const DWARFDataExtractor &data,
*offset_ptr = offset; *offset_ptr = offset;
return true; return true;
} }
static DWARFRangeList GetRangesOrReportError(DWARFUnit &unit, static DWARFRangeList GetRangesOrReportError(DWARFUnit &unit,
const DWARFDebugInfoEntry &die, const DWARFDebugInfoEntry &die,
const DWARFFormValue &value) { const DWARFFormValue &value) {
llvm::Expected<DWARFRangeList> expected_ranges = llvm::Expected<DWARFRangeList> expected_ranges =
(value.Form() == DW_FORM_rnglistx) (value.Form() == llvm::dwarf::DW_FORM_rnglistx)
? unit.FindRnglistFromIndex(value.Unsigned()) ? unit.FindRnglistFromIndex(value.Unsigned())
: unit.FindRnglistFromOffset(value.Unsigned()); : unit.FindRnglistFromOffset(value.Unsigned());
if (expected_ranges) if (expected_ranges)
return std::move(*expected_ranges); return std::move(*expected_ranges);
unit.GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError( unit.GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
"{0x%8.8x}: DIE has DW_AT_ranges(%s 0x%" PRIx64 ") attribute, but " "{0x%8.8x}: DIE has DW_AT_ranges(%s 0x%" PRIx64 ") attribute, but "
"range extraction failed (%s), please file a bug " "range extraction failed (%s), please file a bug "
"and attach the file at the start of this error message", "and attach the file at the start of this error message",
Show All 34 Lines if (abbrevDecl) {
for (uint32_t i = 0; i < numAttributes; ++i) { for (uint32_t i = 0; i < numAttributes; ++i) {
DWARFFormValue form_value(cu); DWARFFormValue form_value(cu);
dw_attr_t attr; dw_attr_t attr;
abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value); abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value);
if (form_value.ExtractValue(data, &offset)) { if (form_value.ExtractValue(data, &offset)) {
switch (attr) { switch (attr) {
case DW_AT_low_pc: case llvm::dwarf::DW_AT_low_pc:
lo_pc = form_value.Address(); lo_pc = form_value.Address();
if (do_offset) if (do_offset)
hi_pc += lo_pc; hi_pc += lo_pc;
do_offset = false; do_offset = false;
break; break;
case DW_AT_entry_pc: case llvm::dwarf::DW_AT_entry_pc:
lo_pc = form_value.Address(); lo_pc = form_value.Address();
break; break;
case DW_AT_high_pc: case llvm::dwarf::DW_AT_high_pc:
if (form_value.Form() == DW_FORM_addr || if (form_value.Form() == llvm::dwarf::DW_FORM_addr ||
form_value.Form() == DW_FORM_addrx || form_value.Form() == llvm::dwarf::DW_FORM_addrx ||
form_value.Form() == DW_FORM_GNU_addr_index) { form_value.Form() == llvm::dwarf::DW_FORM_GNU_addr_index) {
hi_pc = form_value.Address(); hi_pc = form_value.Address();
} else { } else {
hi_pc = form_value.Unsigned(); hi_pc = form_value.Unsigned();
if (lo_pc == LLDB_INVALID_ADDRESS) if (lo_pc == LLDB_INVALID_ADDRESS)
do_offset = hi_pc != LLDB_INVALID_ADDRESS; do_offset = hi_pc != LLDB_INVALID_ADDRESS;
else else
hi_pc += lo_pc; // DWARF 4 introduces <offset-from-lo-pc> to save hi_pc += lo_pc; // DWARF 4 introduces <offset-from-lo-pc> to save
// on relocations // on relocations
} }
break; break;
case DW_AT_ranges: case llvm::dwarf::DW_AT_ranges:
ranges = GetRangesOrReportError(*cu, *this, form_value); ranges = GetRangesOrReportError(*cu, *this, form_value);
break; break;
case DW_AT_name: case llvm::dwarf::DW_AT_name:
if (name == nullptr) if (name == nullptr)
name = form_value.AsCString(); name = form_value.AsCString();
break; break;
case DW_AT_MIPS_linkage_name: case llvm::dwarf::DW_AT_MIPS_linkage_name:
case DW_AT_linkage_name: case llvm::dwarf::DW_AT_linkage_name:
if (mangled == nullptr) if (mangled == nullptr)
mangled = form_value.AsCString(); mangled = form_value.AsCString();
break; break;
case DW_AT_abstract_origin: case llvm::dwarf::DW_AT_abstract_origin:
dies.push_back(form_value.Reference()); dies.push_back(form_value.Reference());
break; break;
case DW_AT_specification: case llvm::dwarf::DW_AT_specification:
dies.push_back(form_value.Reference()); dies.push_back(form_value.Reference());
break; break;
case DW_AT_decl_file: case llvm::dwarf::DW_AT_decl_file:
if (decl_file == 0) if (decl_file == 0)
decl_file = form_value.Unsigned(); decl_file = form_value.Unsigned();
break; break;
case DW_AT_decl_line: case llvm::dwarf::DW_AT_decl_line:
if (decl_line == 0) if (decl_line == 0)
decl_line = form_value.Unsigned(); decl_line = form_value.Unsigned();
break; break;
case DW_AT_decl_column: case llvm::dwarf::DW_AT_decl_column:
if (decl_column == 0) if (decl_column == 0)
decl_column = form_value.Unsigned(); decl_column = form_value.Unsigned();
break; break;
case DW_AT_call_file: case llvm::dwarf::DW_AT_call_file:
if (call_file == 0) if (call_file == 0)
call_file = form_value.Unsigned(); call_file = form_value.Unsigned();
break; break;
case DW_AT_call_line: case llvm::dwarf::DW_AT_call_line:
if (call_line == 0) if (call_line == 0)
call_line = form_value.Unsigned(); call_line = form_value.Unsigned();
break; break;
case DW_AT_call_column: case llvm::dwarf::DW_AT_call_column:
if (call_column == 0) if (call_column == 0)
call_column = form_value.Unsigned(); call_column = form_value.Unsigned();
break; break;
case DW_AT_frame_base: case llvm::dwarf::DW_AT_frame_base:
if (frame_base) { if (frame_base) {
if (form_value.BlockData()) { if (form_value.BlockData()) {
uint32_t block_offset = uint32_t block_offset =
form_value.BlockData() - data.GetDataStart(); form_value.BlockData() - data.GetDataStart();
uint32_t block_length = form_value.Unsigned(); uint32_t block_length = form_value.Unsigned();
*frame_base = DWARFExpression( *frame_base = DWARFExpression(
module, DataExtractor(data, block_offset, block_length), cu); module, DataExtractor(data, block_offset, block_length), cu);
} else { } else {
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines for (uint32_t i = 0; i < num_attributes; ++i) {
dw_attr_t attr; dw_attr_t attr;
abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value); abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value);
const dw_form_t form = form_value.Form(); const dw_form_t form = form_value.Form();
// If we are tracking down DW_AT_specification or DW_AT_abstract_origin // If we are tracking down DW_AT_specification or DW_AT_abstract_origin
// attributes, the depth will be non-zero. We need to omit certain // attributes, the depth will be non-zero. We need to omit certain
// attributes that don't make sense. // attributes that don't make sense.
switch (attr) { switch (attr) {
case DW_AT_sibling: case llvm::dwarf::DW_AT_sibling:
case DW_AT_declaration: case llvm::dwarf::DW_AT_declaration:
if (curr_depth > 0) { if (curr_depth > 0) {
// This attribute doesn't make sense when combined with the DIE that // This attribute doesn't make sense when combined with the DIE that
// references this DIE. We know a DIE is referencing this DIE because // references this DIE. We know a DIE is referencing this DIE because
// curr_depth is not zero // curr_depth is not zero
break; break;
} }
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
default: default:
attributes.Append(form_value, offset, attr); attributes.Append(form_value, offset, attr);
break; break;
} }
if (recurse == Recurse::yes && if (recurse == Recurse::yes &&
((attr == DW_AT_specification) || (attr == DW_AT_abstract_origin))) { ((attr == llvm::dwarf::DW_AT_specification) ||
(attr == llvm::dwarf::DW_AT_abstract_origin))) {
if (form_value.ExtractValue(data, &offset)) { if (form_value.ExtractValue(data, &offset)) {
DWARFDIE spec_die = form_value.Reference(); DWARFDIE spec_die = form_value.Reference();
if (spec_die) if (spec_die)
spec_die.GetDIE()->GetAttributes(spec_die.GetCU(), attributes, spec_die.GetDIE()->GetAttributes(spec_die.GetCU(), attributes,
recurse, curr_depth + 1); recurse, curr_depth + 1);
} }
} else { } else {
llvm::Optional<uint8_t> fixed_skip_size = DWARFFormValue::GetFixedSize(form, cu); llvm::Optional<uint8_t> fixed_skip_size = DWARFFormValue::GetFixedSize(form, cu);
Show All 38 Lines if (attr_idx != DW_INVALID_INDEX) {
if (end_attr_offset_ptr) if (end_attr_offset_ptr)
*end_attr_offset_ptr = offset; *end_attr_offset_ptr = offset;
return attr_offset; return attr_offset;
} }
} }
} }
if (check_specification_or_abstract_origin) { if (check_specification_or_abstract_origin) {
if (GetAttributeValue(cu, DW_AT_specification, form_value)) { if (GetAttributeValue(cu, llvm::dwarf::DW_AT_specification, form_value)) {
DWARFDIE die = form_value.Reference(); DWARFDIE die = form_value.Reference();
if (die) { if (die) {
dw_offset_t die_offset = die.GetDIE()->GetAttributeValue( dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
die.GetCU(), attr, form_value, end_attr_offset_ptr, false); die.GetCU(), attr, form_value, end_attr_offset_ptr, false);
if (die_offset) if (die_offset)
return die_offset; return die_offset;
} }
} }
if (GetAttributeValue(cu, DW_AT_abstract_origin, form_value)) { if (GetAttributeValue(cu, llvm::dwarf::DW_AT_abstract_origin, form_value)) {
DWARFDIE die = form_value.Reference(); DWARFDIE die = form_value.Reference();
if (die) { if (die) {
dw_offset_t die_offset = die.GetDIE()->GetAttributeValue( dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
die.GetCU(), attr, form_value, end_attr_offset_ptr, false); die.GetCU(), attr, form_value, end_attr_offset_ptr, false);
if (die_offset) if (die_offset)
return die_offset; return die_offset;
} }
} }
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
// Get the hi_pc, adding hi_pc to lo_pc when specified as an <offset-from-low- // Get the hi_pc, adding hi_pc to lo_pc when specified as an <offset-from-low-
// pc>. // pc>.
// //
// Returns the hi_pc or fail_value. // Returns the hi_pc or fail_value.
dw_addr_t DWARFDebugInfoEntry::GetAttributeHighPC( dw_addr_t DWARFDebugInfoEntry::GetAttributeHighPC(
const DWARFUnit *cu, dw_addr_t lo_pc, uint64_t fail_value, const DWARFUnit *cu, dw_addr_t lo_pc, uint64_t fail_value,
bool check_specification_or_abstract_origin) const { bool check_specification_or_abstract_origin) const {
DWARFFormValue form_value; DWARFFormValue form_value;
if (GetAttributeValue(cu, DW_AT_high_pc, form_value, nullptr, if (GetAttributeValue(cu, llvm::dwarf::DW_AT_high_pc, form_value, nullptr,
check_specification_or_abstract_origin)) { check_specification_or_abstract_origin)) {
dw_form_t form = form_value.Form(); dw_form_t form = form_value.Form();
if (form == DW_FORM_addr || form == DW_FORM_addrx || if (form == llvm::dwarf::DW_FORM_addr ||
form == DW_FORM_GNU_addr_index) form == llvm::dwarf::DW_FORM_addrx ||
form == llvm::dwarf::DW_FORM_GNU_addr_index)
return form_value.Address(); return form_value.Address();
// DWARF4 can specify the hi_pc as an <offset-from-lowpc> // DWARF4 can specify the hi_pc as an <offset-from-lowpc>
return lo_pc + form_value.Unsigned(); return lo_pc + form_value.Unsigned();
} }
return fail_value; return fail_value;
} }
// GetAttributeAddressRange // GetAttributeAddressRange
// //
// Get the lo_pc and hi_pc, adding hi_pc to lo_pc when specified as an <offset- // Get the lo_pc and hi_pc, adding hi_pc to lo_pc when specified as an <offset-
// from-low-pc>. // from-low-pc>.
// //
// Returns true or sets lo_pc and hi_pc to fail_value. // Returns true or sets lo_pc and hi_pc to fail_value.
bool DWARFDebugInfoEntry::GetAttributeAddressRange( bool DWARFDebugInfoEntry::GetAttributeAddressRange(
const DWARFUnit *cu, dw_addr_t &lo_pc, dw_addr_t &hi_pc, const DWARFUnit *cu, dw_addr_t &lo_pc, dw_addr_t &hi_pc,
uint64_t fail_value, bool check_specification_or_abstract_origin) const { uint64_t fail_value, bool check_specification_or_abstract_origin) const {
lo_pc = GetAttributeValueAsAddress(cu, DW_AT_low_pc, fail_value, lo_pc = GetAttributeValueAsAddress(cu, llvm::dwarf::DW_AT_low_pc, fail_value,
check_specification_or_abstract_origin); check_specification_or_abstract_origin);
if (lo_pc != fail_value) { if (lo_pc != fail_value) {
hi_pc = GetAttributeHighPC(cu, lo_pc, fail_value, hi_pc = GetAttributeHighPC(cu, lo_pc, fail_value,
check_specification_or_abstract_origin); check_specification_or_abstract_origin);
if (hi_pc != fail_value) if (hi_pc != fail_value)
return true; return true;
} }
lo_pc = fail_value; lo_pc = fail_value;
hi_pc = fail_value; hi_pc = fail_value;
return false; return false;
} }
size_t DWARFDebugInfoEntry::GetAttributeAddressRanges( size_t DWARFDebugInfoEntry::GetAttributeAddressRanges(
DWARFUnit *cu, DWARFRangeList &ranges, bool check_hi_lo_pc, DWARFUnit *cu, DWARFRangeList &ranges, bool check_hi_lo_pc,
bool check_specification_or_abstract_origin) const { bool check_specification_or_abstract_origin) const {
ranges.Clear(); ranges.Clear();
DWARFFormValue form_value; DWARFFormValue form_value;
if (GetAttributeValue(cu, DW_AT_ranges, form_value)) { if (GetAttributeValue(cu, llvm::dwarf::DW_AT_ranges, form_value)) {
ranges = GetRangesOrReportError(*cu, *this, form_value); ranges = GetRangesOrReportError(*cu, *this, form_value);
} else if (check_hi_lo_pc) { } else if (check_hi_lo_pc) {
dw_addr_t lo_pc = LLDB_INVALID_ADDRESS; dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
dw_addr_t hi_pc = LLDB_INVALID_ADDRESS; dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
if (GetAttributeAddressRange(cu, lo_pc, hi_pc, LLDB_INVALID_ADDRESS, if (GetAttributeAddressRange(cu, lo_pc, hi_pc, LLDB_INVALID_ADDRESS,
check_specification_or_abstract_origin)) { check_specification_or_abstract_origin)) {
if (lo_pc < hi_pc) if (lo_pc < hi_pc)
ranges.Append(DWARFRangeList::Entry(lo_pc, hi_pc - lo_pc)); ranges.Append(DWARFRangeList::Entry(lo_pc, hi_pc - lo_pc));
} }
} }
return ranges.GetSize(); return ranges.GetSize();
} }
// GetName // GetName
// //
// Get value of the DW_AT_name attribute and return it if one exists, else // Get value of the DW_AT_name attribute and return it if one exists, else
// return NULL. // return NULL.
const char *DWARFDebugInfoEntry::GetName(const DWARFUnit *cu) const { const char *DWARFDebugInfoEntry::GetName(const DWARFUnit *cu) const {
return GetAttributeValueAsString(cu, DW_AT_name, nullptr, true); return GetAttributeValueAsString(cu, llvm::dwarf::DW_AT_name, nullptr, true);
} }
// GetMangledName // GetMangledName
// //
// Get value of the DW_AT_MIPS_linkage_name attribute and return it if one // Get value of the DW_AT_MIPS_linkage_name attribute and return it if one
// exists, else return the value of the DW_AT_name attribute // exists, else return the value of the DW_AT_name attribute
const char * const char *
DWARFDebugInfoEntry::GetMangledName(const DWARFUnit *cu, DWARFDebugInfoEntry::GetMangledName(const DWARFUnit *cu,
bool substitute_name_allowed) const { bool substitute_name_allowed) const {
const char *name = nullptr; const char *name = nullptr;
name = GetAttributeValueAsString(cu, DW_AT_MIPS_linkage_name, nullptr, true); name = GetAttributeValueAsString(cu, llvm::dwarf::DW_AT_MIPS_linkage_name,
nullptr, true);
if (name) if (name)
return name; return name;
name = GetAttributeValueAsString(cu, DW_AT_linkage_name, nullptr, true); name = GetAttributeValueAsString(cu, llvm::dwarf::DW_AT_linkage_name, nullptr,
true);
if (name) if (name)
return name; return name;
if (!substitute_name_allowed) if (!substitute_name_allowed)
return nullptr; return nullptr;
name = GetAttributeValueAsString(cu, DW_AT_name, nullptr, true); name = GetAttributeValueAsString(cu, llvm::dwarf::DW_AT_name, nullptr, true);
return name; return name;
} }
// GetPubname // GetPubname
// //
// Get value the name for a DIE as it should appear for a .debug_pubnames or // Get value the name for a DIE as it should appear for a .debug_pubnames or
// .debug_pubtypes section. // .debug_pubtypes section.
const char *DWARFDebugInfoEntry::GetPubname(const DWARFUnit *cu) const { const char *DWARFDebugInfoEntry::GetPubname(const DWARFUnit *cu) const {
const char *name = nullptr; const char *name = nullptr;
if (!cu) if (!cu)
return name; return name;
name = GetAttributeValueAsString(cu, DW_AT_MIPS_linkage_name, nullptr, true); name = GetAttributeValueAsString(cu, llvm::dwarf::DW_AT_MIPS_linkage_name,
nullptr, true);
if (name) if (name)
return name; return name;
name = GetAttributeValueAsString(cu, DW_AT_linkage_name, nullptr, true); name = GetAttributeValueAsString(cu, llvm::dwarf::DW_AT_linkage_name, nullptr,
true);
if (name) if (name)
return name; return name;
name = GetAttributeValueAsString(cu, DW_AT_name, nullptr, true); name = GetAttributeValueAsString(cu, llvm::dwarf::DW_AT_name, nullptr, true);
return name; return name;
} }
/// This function is builds a table very similar to the standard .debug_aranges /// This function is builds a table very similar to the standard .debug_aranges
/// table, except that the actual DIE offset for the function is placed in the /// table, except that the actual DIE offset for the function is placed in the
/// table instead of the compile unit offset. /// table instead of the compile unit offset.
void DWARFDebugInfoEntry::BuildFunctionAddressRangeTable( void DWARFDebugInfoEntry::BuildFunctionAddressRangeTable(
DWARFUnit *cu, DWARFDebugAranges *debug_aranges) const { DWARFUnit *cu, DWARFDebugAranges *debug_aranges) const {
if (m_tag) { if (m_tag) {
if (m_tag == DW_TAG_subprogram) { if (m_tag == llvm::dwarf::DW_TAG_subprogram) {
DWARFRangeList ranges; DWARFRangeList ranges;
GetAttributeAddressRanges(cu, ranges, GetAttributeAddressRanges(cu, ranges,
/*check_hi_lo_pc=*/true); /*check_hi_lo_pc=*/true);
for (const auto &r : ranges) { for (const auto &r : ranges) {
debug_aranges->AppendRange(GetOffset(), r.GetRangeBase(), debug_aranges->AppendRange(GetOffset(), r.GetRangeBase(),
r.GetRangeEnd()); r.GetRangeEnd());
} }
} }
const DWARFDebugInfoEntry *child = GetFirstChild(); const DWARFDebugInfoEntry *child = GetFirstChild();
while (child) { while (child) {
child->BuildFunctionAddressRangeTable(cu, debug_aranges); child->BuildFunctionAddressRangeTable(cu, debug_aranges);
child = child->GetSibling(); child = child->GetSibling();
} }
} }
} }
DWARFDeclContext DWARFDeclContext
DWARFDebugInfoEntry::GetDWARFDeclContextStatic(const DWARFDebugInfoEntry *die, DWARFDebugInfoEntry::GetDWARFDeclContextStatic(const DWARFDebugInfoEntry *die,
DWARFUnit *cu) { DWARFUnit *cu) {
DWARFDeclContext dwarf_decl_ctx; DWARFDeclContext dwarf_decl_ctx;
for (;;) { for (;;) {
const dw_tag_t tag = die->Tag(); const dw_tag_t tag = die->Tag();
if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit) if (tag == llvm::dwarf::DW_TAG_compile_unit ||
tag == llvm::dwarf::DW_TAG_partial_unit)
return dwarf_decl_ctx; return dwarf_decl_ctx;
dwarf_decl_ctx.AppendDeclContext(tag, die->GetName(cu)); dwarf_decl_ctx.AppendDeclContext(tag, die->GetName(cu));
DWARFDIE parent_decl_ctx_die = die->GetParentDeclContextDIE(cu); DWARFDIE parent_decl_ctx_die = die->GetParentDeclContextDIE(cu);
if (!parent_decl_ctx_die || parent_decl_ctx_die.GetDIE() == die) if (!parent_decl_ctx_die || parent_decl_ctx_die.GetDIE() == die)
return dwarf_decl_ctx; return dwarf_decl_ctx;
if (parent_decl_ctx_die.Tag() == DW_TAG_compile_unit || if (parent_decl_ctx_die.Tag() == llvm::dwarf::DW_TAG_compile_unit ||
parent_decl_ctx_die.Tag() == DW_TAG_partial_unit) parent_decl_ctx_die.Tag() == llvm::dwarf::DW_TAG_partial_unit)
return dwarf_decl_ctx; return dwarf_decl_ctx;
die = parent_decl_ctx_die.GetDIE(); die = parent_decl_ctx_die.GetDIE();
cu = parent_decl_ctx_die.GetCU(); cu = parent_decl_ctx_die.GetCU();
} }
} }
DWARFDeclContext DWARFDebugInfoEntry::GetDWARFDeclContext(DWARFUnit *cu) const { DWARFDeclContext DWARFDebugInfoEntry::GetDWARFDeclContext(DWARFUnit *cu) const {
return GetDWARFDeclContextStatic(this, cu); return GetDWARFDeclContextStatic(this, cu);
Show All 12 LinesDWARFDebugInfoEntry::GetParentDeclContextDIE(
DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this)); DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this));
while (die) { while (die) {
// If this is the original DIE that we are searching for a declaration for, // If this is the original DIE that we are searching for a declaration for,
// then don't look in the cache as we don't want our own decl context to be // then don't look in the cache as we don't want our own decl context to be
// our decl context... // our decl context...
if (die.GetDIE() != this) { if (die.GetDIE() != this) {
switch (die.Tag()) { switch (die.Tag()) {
case DW_TAG_compile_unit: case llvm::dwarf::DW_TAG_compile_unit:
case DW_TAG_partial_unit: case llvm::dwarf::DW_TAG_partial_unit:
case DW_TAG_namespace: case llvm::dwarf::DW_TAG_namespace:
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
return die; return die;
default: default:
break; break;
} }
} }
DWARFDIE spec_die = attributes.FormValueAsReference(DW_AT_specification); DWARFDIE spec_die =
attributes.FormValueAsReference(llvm::dwarf::DW_AT_specification);
if (spec_die) { if (spec_die) {
DWARFDIE decl_ctx_die = spec_die.GetParentDeclContextDIE(); DWARFDIE decl_ctx_die = spec_die.GetParentDeclContextDIE();
if (decl_ctx_die) if (decl_ctx_die)
return decl_ctx_die; return decl_ctx_die;
} }
DWARFDIE abs_die = attributes.FormValueAsReference(DW_AT_abstract_origin); DWARFDIE abs_die =
attributes.FormValueAsReference(llvm::dwarf::DW_AT_abstract_origin);
if (abs_die) { if (abs_die) {
DWARFDIE decl_ctx_die = abs_die.GetParentDeclContextDIE(); DWARFDIE decl_ctx_die = abs_die.GetParentDeclContextDIE();
if (decl_ctx_die) if (decl_ctx_die)
return decl_ctx_die; return decl_ctx_die;
} }
die = die.GetParent(); die = die.GetParent();
} }
Show All 16 LinesDWARFDebugInfoEntry::GetQualifiedName(DWARFUnit *cu,
if (name) { if (name) {
DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(cu); DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(cu);
storage.clear(); storage.clear();
// TODO: change this to get the correct decl context parent.... // TODO: change this to get the correct decl context parent....
while (parent_decl_ctx_die) { while (parent_decl_ctx_die) {
const dw_tag_t parent_tag = parent_decl_ctx_die.Tag(); const dw_tag_t parent_tag = parent_decl_ctx_die.Tag();
switch (parent_tag) { switch (parent_tag) {
case DW_TAG_namespace: { case llvm::dwarf::DW_TAG_namespace: {
const char *namespace_name = parent_decl_ctx_die.GetName(); const char *namespace_name = parent_decl_ctx_die.GetName();
if (namespace_name) { if (namespace_name) {
storage.insert(0, "::"); storage.insert(0, "::");
storage.insert(0, namespace_name); storage.insert(0, namespace_name);
} else { } else {
storage.insert(0, "(anonymous namespace)::"); storage.insert(0, "(anonymous namespace)::");
} }
parent_decl_ctx_die = parent_decl_ctx_die.GetParentDeclContextDIE(); parent_decl_ctx_die = parent_decl_ctx_die.GetParentDeclContextDIE();
} break; } break;
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_union_type: { case llvm::dwarf::DW_TAG_union_type: {
const char *class_union_struct_name = parent_decl_ctx_die.GetName(); const char *class_union_struct_name = parent_decl_ctx_die.GetName();
if (class_union_struct_name) { if (class_union_struct_name) {
storage.insert(0, "::"); storage.insert(0, "::");
storage.insert(0, class_union_struct_name); storage.insert(0, class_union_struct_name);
} }
parent_decl_ctx_die = parent_decl_ctx_die.GetParentDeclContextDIE(); parent_decl_ctx_die = parent_decl_ctx_die.GetParentDeclContextDIE();
} break; } break;
Show All 24 Lines if (cu) {
const DWARFAbbreviationDeclarationSet *abbrev_set = cu->GetAbbreviations(); const DWARFAbbreviationDeclarationSet *abbrev_set = cu->GetAbbreviations();
if (abbrev_set) if (abbrev_set)
return abbrev_set->GetAbbreviationDeclaration(m_abbr_idx); return abbrev_set->GetAbbreviationDeclaration(m_abbr_idx);
} }
return nullptr; return nullptr;
} }
bool DWARFDebugInfoEntry::IsGlobalOrStaticScopeVariable() const { bool DWARFDebugInfoEntry::IsGlobalOrStaticScopeVariable() const {
if (Tag() != DW_TAG_variable) if (Tag() != llvm::dwarf::DW_TAG_variable)
return false; return false;
const DWARFDebugInfoEntry *parent_die = GetParent(); const DWARFDebugInfoEntry *parent_die = GetParent();
while (parent_die != nullptr) { while (parent_die != nullptr) {
switch (parent_die->Tag()) { switch (parent_die->Tag()) {
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_lexical_block: case llvm::dwarf::DW_TAG_lexical_block:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
return false; return false;
case DW_TAG_compile_unit: case llvm::dwarf::DW_TAG_compile_unit:
case DW_TAG_partial_unit: case llvm::dwarf::DW_TAG_partial_unit:
return true; return true;
default: default:
break; break;
} }
parent_die = parent_die->GetParent(); parent_die = parent_die->GetParent();
} }
return false; return false;
Show All 12 Lines

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines llvm::dwarf::MacroEntryType type =
static_cast<llvm::dwarf::MacroEntryType>(debug_macro_data.GetU8(offset)); static_cast<llvm::dwarf::MacroEntryType>(debug_macro_data.GetU8(offset));
while (type != 0) { while (type != 0) {
lldb::offset_t new_offset = 0, str_offset = 0; lldb::offset_t new_offset = 0, str_offset = 0;
uint32_t line = 0; uint32_t line = 0;
const char *macro_str = nullptr; const char *macro_str = nullptr;
uint32_t debug_line_file_idx = 0; uint32_t debug_line_file_idx = 0;
switch (type) { switch (type) {
case DW_MACRO_define: case llvm::dwarf::DW_MACRO_define:
case DW_MACRO_undef: case llvm::dwarf::DW_MACRO_undef:
line = debug_macro_data.GetULEB128(offset); line = debug_macro_data.GetULEB128(offset);
macro_str = debug_macro_data.GetCStr(offset); macro_str = debug_macro_data.GetCStr(offset);
if (type == DW_MACRO_define) if (type == llvm::dwarf::DW_MACRO_define)
debug_macros_sp->AddMacroEntry( debug_macros_sp->AddMacroEntry(
DebugMacroEntry::CreateDefineEntry(line, macro_str)); DebugMacroEntry::CreateDefineEntry(line, macro_str));
else else
debug_macros_sp->AddMacroEntry( debug_macros_sp->AddMacroEntry(
DebugMacroEntry::CreateUndefEntry(line, macro_str)); DebugMacroEntry::CreateUndefEntry(line, macro_str));
break; break;
case DW_MACRO_define_strp: case llvm::dwarf::DW_MACRO_define_strp:
case DW_MACRO_undef_strp: case llvm::dwarf::DW_MACRO_undef_strp:
line = debug_macro_data.GetULEB128(offset); line = debug_macro_data.GetULEB128(offset);
if (offset_is_64_bit) if (offset_is_64_bit)
str_offset = debug_macro_data.GetU64(offset); str_offset = debug_macro_data.GetU64(offset);
else else
str_offset = debug_macro_data.GetU32(offset); str_offset = debug_macro_data.GetU32(offset);
macro_str = debug_str_data.GetCStr(&str_offset); macro_str = debug_str_data.GetCStr(&str_offset);
if (type == DW_MACRO_define_strp) if (type == llvm::dwarf::DW_MACRO_define_strp)
debug_macros_sp->AddMacroEntry( debug_macros_sp->AddMacroEntry(
DebugMacroEntry::CreateDefineEntry(line, macro_str)); DebugMacroEntry::CreateDefineEntry(line, macro_str));
else else
debug_macros_sp->AddMacroEntry( debug_macros_sp->AddMacroEntry(
DebugMacroEntry::CreateUndefEntry(line, macro_str)); DebugMacroEntry::CreateUndefEntry(line, macro_str));
break; break;
case DW_MACRO_start_file: case llvm::dwarf::DW_MACRO_start_file:
line = debug_macro_data.GetULEB128(offset); line = debug_macro_data.GetULEB128(offset);
debug_line_file_idx = debug_macro_data.GetULEB128(offset); debug_line_file_idx = debug_macro_data.GetULEB128(offset);
debug_macros_sp->AddMacroEntry( debug_macros_sp->AddMacroEntry(
DebugMacroEntry::CreateStartFileEntry(line, debug_line_file_idx)); DebugMacroEntry::CreateStartFileEntry(line, debug_line_file_idx));
break; break;
case DW_MACRO_end_file: case llvm::dwarf::DW_MACRO_end_file:
// This operation has no operands. // This operation has no operands.
debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateEndFileEntry()); debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateEndFileEntry());
break; break;
case DW_MACRO_import: case llvm::dwarf::DW_MACRO_import:
if (offset_is_64_bit) if (offset_is_64_bit)
new_offset = debug_macro_data.GetU64(offset); new_offset = debug_macro_data.GetU64(offset);
else else
new_offset = debug_macro_data.GetU32(offset); new_offset = debug_macro_data.GetU32(offset);
debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateIndirectEntry( debug_macros_sp->AddMacroEntry(DebugMacroEntry::CreateIndirectEntry(
sym_file_dwarf->ParseDebugMacros(&new_offset))); sym_file_dwarf->ParseDebugMacros(&new_offset)));
break; break;
default: default:
Show All 9 Lines

lldb/source/Plugins/SymbolFile/DWARF/DWARFDeclContext.cpp

Show All 24 Lines if (!m_entries.empty()) {
} else { } else {
collection::const_reverse_iterator pos; collection::const_reverse_iterator pos;
collection::const_reverse_iterator begin = m_entries.rbegin(); collection::const_reverse_iterator begin = m_entries.rbegin();
collection::const_reverse_iterator end = m_entries.rend(); collection::const_reverse_iterator end = m_entries.rend();
for (pos = begin; pos != end; ++pos) { for (pos = begin; pos != end; ++pos) {
if (pos != begin) if (pos != begin)
m_qualified_name.append("::"); m_qualified_name.append("::");
if (pos->name == nullptr) { if (pos->name == nullptr) {
if (pos->tag == DW_TAG_namespace) if (pos->tag == llvm::dwarf::DW_TAG_namespace)
m_qualified_name.append("(anonymous namespace)"); m_qualified_name.append("(anonymous namespace)");
else if (pos->tag == DW_TAG_class_type) else if (pos->tag == llvm::dwarf::DW_TAG_class_type)
m_qualified_name.append("(anonymous class)"); m_qualified_name.append("(anonymous class)");
else if (pos->tag == DW_TAG_structure_type) else if (pos->tag == llvm::dwarf::DW_TAG_structure_type)
m_qualified_name.append("(anonymous struct)"); m_qualified_name.append("(anonymous struct)");
else if (pos->tag == DW_TAG_union_type) else if (pos->tag == llvm::dwarf::DW_TAG_union_type)
m_qualified_name.append("(anonymous union)"); m_qualified_name.append("(anonymous union)");
else else
m_qualified_name.append("(anonymous)"); m_qualified_name.append("(anonymous)");
} else } else
m_qualified_name.append(pos->name); m_qualified_name.append(pos->name);
} }
} }
} }
Show All 15 Linesbool DWARFDeclContext::operator==(const DWARFDeclContext &rhs) const {
collection::const_iterator rhs_begin = rhs.m_entries.begin(); collection::const_iterator rhs_begin = rhs.m_entries.begin();
// The two entry arrays have the same size // The two entry arrays have the same size
// First compare the tags before we do expensive name compares // First compare the tags before we do expensive name compares
for (pos = begin, rhs_pos = rhs_begin; pos != end; ++pos, ++rhs_pos) { for (pos = begin, rhs_pos = rhs_begin; pos != end; ++pos, ++rhs_pos) {
if (pos->tag != rhs_pos->tag) { if (pos->tag != rhs_pos->tag) {
// Check for DW_TAG_structure_type and DW_TAG_class_type as they are // Check for DW_TAG_structure_type and DW_TAG_class_type as they are
// often used interchangeably in GCC // often used interchangeably in GCC
if (pos->tag == DW_TAG_structure_type && if (pos->tag == llvm::dwarf::DW_TAG_structure_type &&
rhs_pos->tag == DW_TAG_class_type) rhs_pos->tag == llvm::dwarf::DW_TAG_class_type)
continue; continue;
if (pos->tag == DW_TAG_class_type && if (pos->tag == llvm::dwarf::DW_TAG_class_type &&
rhs_pos->tag == DW_TAG_structure_type) rhs_pos->tag == llvm::dwarf::DW_TAG_structure_type)
continue; continue;
return false; return false;
} }
} }
// The tags all match, now compare the names // The tags all match, now compare the names
for (pos = begin, rhs_pos = rhs_begin; pos != end; ++pos, ++rhs_pos) { for (pos = begin, rhs_pos = rhs_begin; pos != end; ++pos, ++rhs_pos) {
if (!pos->NameMatches(*rhs_pos)) if (!pos->NameMatches(*rhs_pos))
return false; return false;
} }
// All tags and names match // All tags and names match
return true; return true;
} }

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

Show All 23 Lines
void DWARFFormValue::Clear() { void DWARFFormValue::Clear() {
m_unit = nullptr; m_unit = nullptr;
m_form = 0; m_form = 0;
m_value = ValueTypeTag(); m_value = ValueTypeTag();
} }
bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data, bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
lldb::offset_t *offset_ptr) { lldb::offset_t *offset_ptr) {
using namespace llvm::dwarf;
if (m_form == DW_FORM_implicit_const) if (m_form == DW_FORM_implicit_const)
return true; return true;
bool indirect = false; bool indirect = false;
bool is_block = false; bool is_block = false;
m_value.data = nullptr; m_value.data = nullptr;
uint8_t ref_addr_size; uint8_t ref_addr_size;
// Read the value for the form into value and follow and DW_FORM_indirect // Read the value for the form into value and follow and DW_FORM_indirect
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Linesstatic FormSize g_form_sizes[] = {
{0, 0}, // 0x1d DW_FORM_strp_sup (4 bytes for DWARF32, 8 bytes for DWARF64) {0, 0}, // 0x1d DW_FORM_strp_sup (4 bytes for DWARF32, 8 bytes for DWARF64)
{1, 16}, // 0x1e DW_FORM_data16 {1, 16}, // 0x1e DW_FORM_data16
{1, 4}, // 0x1f DW_FORM_line_strp {1, 4}, // 0x1f DW_FORM_line_strp
{1, 8}, // 0x20 DW_FORM_ref_sig8 {1, 8}, // 0x20 DW_FORM_ref_sig8
}; };
llvm::Optional<uint8_t> llvm::Optional<uint8_t>
DWARFFormValue::GetFixedSize(dw_form_t form, const DWARFUnit *u) { DWARFFormValue::GetFixedSize(dw_form_t form, const DWARFUnit *u) {
if (form <= DW_FORM_ref_sig8 && g_form_sizes[form].valid) if (form <= llvm::dwarf::DW_FORM_ref_sig8 && g_form_sizes[form].valid)
return g_form_sizes[form].size; return g_form_sizes[form].size;
if (form == DW_FORM_addr && u) if (form == llvm::dwarf::DW_FORM_addr && u)
return u->GetAddressByteSize(); return u->GetAddressByteSize();
return llvm::None; return llvm::None;
} }
llvm::Optional<uint8_t> DWARFFormValue::GetFixedSize() const { llvm::Optional<uint8_t> DWARFFormValue::GetFixedSize() const {
return GetFixedSize(m_form, m_unit); return GetFixedSize(m_form, m_unit);
} }
bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data, bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data,
lldb::offset_t *offset_ptr) const { lldb::offset_t *offset_ptr) const {
return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_unit); return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_unit);
} }
bool DWARFFormValue::SkipValue(dw_form_t form, bool DWARFFormValue::SkipValue(dw_form_t form,
const DWARFDataExtractor &debug_info_data, const DWARFDataExtractor &debug_info_data,
lldb::offset_t *offset_ptr, lldb::offset_t *offset_ptr,
const DWARFUnit *unit) { const DWARFUnit *unit) {
using namespace llvm::dwarf;
uint8_t ref_addr_size; uint8_t ref_addr_size;
switch (form) { switch (form) {
// Blocks if inlined data that have a length field and the data bytes inlined // Blocks if inlined data that have a length field and the data bytes inlined
// in the .debug_info // in the .debug_info
case DW_FORM_exprloc: case DW_FORM_exprloc:
case DW_FORM_block: { case DW_FORM_block: {
dw_uleb128_t size = debug_info_data.GetULEB128(offset_ptr); dw_uleb128_t size = debug_info_data.GetULEB128(offset_ptr);
*offset_ptr += size; *offset_ptr += size;
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Linesbool DWARFFormValue::SkipValue(dw_form_t form,
default: default:
break; break;
} }
return false; return false;
} }
void DWARFFormValue::Dump(Stream &s) const { void DWARFFormValue::Dump(Stream &s) const {
using namespace llvm::dwarf;
uint64_t uvalue = Unsigned(); uint64_t uvalue = Unsigned();
bool unit_relative_offset = false; bool unit_relative_offset = false;
switch (m_form) { switch (m_form) {
case DW_FORM_addr: case DW_FORM_addr:
DumpAddress(s.AsRawOstream(), uvalue, sizeof(uint64_t)); DumpAddress(s.AsRawOstream(), uvalue, sizeof(uint64_t));
break; break;
case DW_FORM_flag: case DW_FORM_flag:
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
// unit relative or we will get this wrong // unit relative or we will get this wrong
s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_unit->GetOffset()); s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_unit->GetOffset());
} }
} }
const char *DWARFFormValue::AsCString() const { const char *DWARFFormValue::AsCString() const {
DWARFContext &context = m_unit->GetSymbolFileDWARF().GetDWARFContext(); DWARFContext &context = m_unit->GetSymbolFileDWARF().GetDWARFContext();
if (m_form == DW_FORM_string) if (m_form == llvm::dwarf::DW_FORM_string)
return m_value.value.cstr; return m_value.value.cstr;
if (m_form == DW_FORM_strp) if (m_form == llvm::dwarf::DW_FORM_strp)
return context.getOrLoadStrData().PeekCStr(m_value.value.uval); return context.getOrLoadStrData().PeekCStr(m_value.value.uval);
if (m_form == DW_FORM_GNU_str_index || m_form == DW_FORM_strx || if (m_form == llvm::dwarf::DW_FORM_GNU_str_index ||
m_form == DW_FORM_strx1 || m_form == DW_FORM_strx2 || m_form == llvm::dwarf::DW_FORM_strx ||
m_form == DW_FORM_strx3 || m_form == DW_FORM_strx4) { m_form == llvm::dwarf::DW_FORM_strx1 ||
m_form == llvm::dwarf::DW_FORM_strx2 ||
m_form == llvm::dwarf::DW_FORM_strx3 ||
m_form == llvm::dwarf::DW_FORM_strx4) {
llvm::Optional<uint64_t> offset = llvm::Optional<uint64_t> offset =
m_unit->GetStringOffsetSectionItem(m_value.value.uval); m_unit->GetStringOffsetSectionItem(m_value.value.uval);
if (!offset) if (!offset)
return nullptr; return nullptr;
return context.getOrLoadStrData().PeekCStr(*offset); return context.getOrLoadStrData().PeekCStr(*offset);
} }
if (m_form == DW_FORM_line_strp) if (m_form == llvm::dwarf::DW_FORM_line_strp)
return context.getOrLoadLineStrData().PeekCStr(m_value.value.uval); return context.getOrLoadLineStrData().PeekCStr(m_value.value.uval);
return nullptr; return nullptr;
} }
dw_addr_t DWARFFormValue::Address() const { dw_addr_t DWARFFormValue::Address() const {
SymbolFileDWARF &symbol_file = m_unit->GetSymbolFileDWARF(); SymbolFileDWARF &symbol_file = m_unit->GetSymbolFileDWARF();
if (m_form == DW_FORM_addr) if (m_form == llvm::dwarf::DW_FORM_addr)
return Unsigned(); return Unsigned();
assert(m_unit); assert(m_unit);
assert(m_form == DW_FORM_GNU_addr_index || m_form == DW_FORM_addrx || assert(m_form == llvm::dwarf::DW_FORM_GNU_addr_index ||
m_form == DW_FORM_addrx1 || m_form == DW_FORM_addrx2 || m_form == llvm::dwarf::DW_FORM_addrx ||
m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4); m_form == llvm::dwarf::DW_FORM_addrx1 ||
m_form == llvm::dwarf::DW_FORM_addrx2 ||
m_form == llvm::dwarf::DW_FORM_addrx3 ||
m_form == llvm::dwarf::DW_FORM_addrx4);
uint32_t index_size = m_unit->GetAddressByteSize(); uint32_t index_size = m_unit->GetAddressByteSize();
dw_offset_t addr_base = m_unit->GetAddrBase(); dw_offset_t addr_base = m_unit->GetAddrBase();
lldb::offset_t offset = addr_base + m_value.value.uval * index_size; lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
return symbol_file.GetDWARFContext().getOrLoadAddrData().GetMaxU64( return symbol_file.GetDWARFContext().getOrLoadAddrData().GetMaxU64(
&offset, index_size); &offset, index_size);
} }
DWARFDIE DWARFFormValue::Reference() const { DWARFDIE DWARFFormValue::Reference() const {
uint64_t value = m_value.value.uval; uint64_t value = m_value.value.uval;
switch (m_form) { switch (m_form) {
case DW_FORM_ref1: case llvm::dwarf::DW_FORM_ref1:
case DW_FORM_ref2: case llvm::dwarf::DW_FORM_ref2:
case DW_FORM_ref4: case llvm::dwarf::DW_FORM_ref4:
case DW_FORM_ref8: case llvm::dwarf::DW_FORM_ref8:
case DW_FORM_ref_udata: case llvm::dwarf::DW_FORM_ref_udata:
assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
// unit relative or we will get this wrong // unit relative or we will get this wrong
value += m_unit->GetOffset(); value += m_unit->GetOffset();
if (!m_unit->ContainsDIEOffset(value)) { if (!m_unit->ContainsDIEOffset(value)) {
m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError( m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
"DW_FORM_ref* DIE reference 0x%" PRIx64 " is outside of its CU", "DW_FORM_ref* DIE reference 0x%" PRIx64 " is outside of its CU",
value); value);
return {}; return {};
} }
return const_cast<DWARFUnit *>(m_unit)->GetDIE(value); return const_cast<DWARFUnit *>(m_unit)->GetDIE(value);
case DW_FORM_ref_addr: { case llvm::dwarf::DW_FORM_ref_addr: {
DWARFUnit *ref_cu = DWARFUnit *ref_cu =
m_unit->GetSymbolFileDWARF().DebugInfo().GetUnitContainingDIEOffset( m_unit->GetSymbolFileDWARF().DebugInfo().GetUnitContainingDIEOffset(
DIERef::Section::DebugInfo, value); DIERef::Section::DebugInfo, value);
if (!ref_cu) { if (!ref_cu) {
m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError( m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
"DW_FORM_ref_addr DIE reference 0x%" PRIx64 " has no matching CU", "DW_FORM_ref_addr DIE reference 0x%" PRIx64 " has no matching CU",
value); value);
return {}; return {};
} }
return ref_cu->GetDIE(value); return ref_cu->GetDIE(value);
} }
case DW_FORM_ref_sig8: { case llvm::dwarf::DW_FORM_ref_sig8: {
DWARFTypeUnit *tu = DWARFTypeUnit *tu =
m_unit->GetSymbolFileDWARF().DebugInfo().GetTypeUnitForHash(value); m_unit->GetSymbolFileDWARF().DebugInfo().GetTypeUnitForHash(value);
if (!tu) if (!tu)
return {}; return {};
return tu->GetDIE(tu->GetTypeOffset()); return tu->GetDIE(tu->GetTypeOffset());
} }
default: default:
return {}; return {};
} }
} }
uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const { uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
uint64_t value = m_value.value.uval; uint64_t value = m_value.value.uval;
switch (m_form) { switch (m_form) {
case DW_FORM_ref1: case llvm::dwarf::DW_FORM_ref1:
case DW_FORM_ref2: case llvm::dwarf::DW_FORM_ref2:
case DW_FORM_ref4: case llvm::dwarf::DW_FORM_ref4:
case DW_FORM_ref8: case llvm::dwarf::DW_FORM_ref8:
case DW_FORM_ref_udata: case llvm::dwarf::DW_FORM_ref_udata:
return value + base_offset; return value + base_offset;
case DW_FORM_ref_addr: case llvm::dwarf::DW_FORM_ref_addr:
case DW_FORM_ref_sig8: case llvm::dwarf::DW_FORM_ref_sig8:
case DW_FORM_GNU_ref_alt: case llvm::dwarf::DW_FORM_GNU_ref_alt:
return value; return value;
default: default:
return DW_INVALID_OFFSET; return DW_INVALID_OFFSET;
} }
} }
const uint8_t *DWARFFormValue::BlockData() const { return m_value.data; } const uint8_t *DWARFFormValue::BlockData() const { return m_value.data; }
bool DWARFFormValue::IsBlockForm(const dw_form_t form) { bool DWARFFormValue::IsBlockForm(const dw_form_t form) {
switch (form) { switch (form) {
case DW_FORM_exprloc: case llvm::dwarf::DW_FORM_exprloc:
case DW_FORM_block: case llvm::dwarf::DW_FORM_block:
case DW_FORM_block1: case llvm::dwarf::DW_FORM_block1:
case DW_FORM_block2: case llvm::dwarf::DW_FORM_block2:
case DW_FORM_block4: case llvm::dwarf::DW_FORM_block4:
return true; return true;
} }
return false; return false;
} }
bool DWARFFormValue::IsDataForm(const dw_form_t form) { bool DWARFFormValue::IsDataForm(const dw_form_t form) {
switch (form) { switch (form) {
case DW_FORM_sdata: case llvm::dwarf::DW_FORM_sdata:
case DW_FORM_udata: case llvm::dwarf::DW_FORM_udata:
case DW_FORM_data1: case llvm::dwarf::DW_FORM_data1:
case DW_FORM_data2: case llvm::dwarf::DW_FORM_data2:
case DW_FORM_data4: case llvm::dwarf::DW_FORM_data4:
case DW_FORM_data8: case llvm::dwarf::DW_FORM_data8:
return true; return true;
} }
return false; return false;
} }
bool DWARFFormValue::FormIsSupported(dw_form_t form) { bool DWARFFormValue::FormIsSupported(dw_form_t form) {
switch (form) { switch (form) {
case DW_FORM_addr: case llvm::dwarf::DW_FORM_addr:
case DW_FORM_addrx: case llvm::dwarf::DW_FORM_addrx:
case DW_FORM_loclistx: case llvm::dwarf::DW_FORM_loclistx:
case DW_FORM_rnglistx: case llvm::dwarf::DW_FORM_rnglistx:
case DW_FORM_block2: case llvm::dwarf::DW_FORM_block2:
case DW_FORM_block4: case llvm::dwarf::DW_FORM_block4:
case DW_FORM_data2: case llvm::dwarf::DW_FORM_data2:
case DW_FORM_data4: case llvm::dwarf::DW_FORM_data4:
case DW_FORM_data8: case llvm::dwarf::DW_FORM_data8:
case DW_FORM_string: case llvm::dwarf::DW_FORM_string:
case DW_FORM_block: case llvm::dwarf::DW_FORM_block:
case DW_FORM_block1: case llvm::dwarf::DW_FORM_block1:
case DW_FORM_data1: case llvm::dwarf::DW_FORM_data1:
case DW_FORM_flag: case llvm::dwarf::DW_FORM_flag:
case DW_FORM_sdata: case llvm::dwarf::DW_FORM_sdata:
case DW_FORM_strp: case llvm::dwarf::DW_FORM_strp:
case DW_FORM_line_strp: case llvm::dwarf::DW_FORM_line_strp:
case DW_FORM_strx: case llvm::dwarf::DW_FORM_strx:
case DW_FORM_strx1: case llvm::dwarf::DW_FORM_strx1:
case DW_FORM_strx2: case llvm::dwarf::DW_FORM_strx2:
case DW_FORM_strx3: case llvm::dwarf::DW_FORM_strx3:
case DW_FORM_strx4: case llvm::dwarf::DW_FORM_strx4:
case DW_FORM_udata: case llvm::dwarf::DW_FORM_udata:
case DW_FORM_ref_addr: case llvm::dwarf::DW_FORM_ref_addr:
case DW_FORM_ref1: case llvm::dwarf::DW_FORM_ref1:
case DW_FORM_ref2: case llvm::dwarf::DW_FORM_ref2:
case DW_FORM_ref4: case llvm::dwarf::DW_FORM_ref4:
case DW_FORM_ref8: case llvm::dwarf::DW_FORM_ref8:
case DW_FORM_ref_udata: case llvm::dwarf::DW_FORM_ref_udata:
case DW_FORM_indirect: case llvm::dwarf::DW_FORM_indirect:
case DW_FORM_sec_offset: case llvm::dwarf::DW_FORM_sec_offset:
case DW_FORM_exprloc: case llvm::dwarf::DW_FORM_exprloc:
case DW_FORM_flag_present: case llvm::dwarf::DW_FORM_flag_present:
case DW_FORM_ref_sig8: case llvm::dwarf::DW_FORM_ref_sig8:
case DW_FORM_GNU_str_index: case llvm::dwarf::DW_FORM_GNU_str_index:
case DW_FORM_GNU_addr_index: case llvm::dwarf::DW_FORM_GNU_addr_index:
case DW_FORM_implicit_const: case llvm::dwarf::DW_FORM_implicit_const:
return true; return true;
default: default:
break; break;
} }
return false; return false;
} }

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linespublic:
uint8_t GetUnitType() const { return m_unit_type; } uint8_t GetUnitType() const { return m_unit_type; }
const llvm::DWARFUnitIndex::Entry *GetIndexEntry() const { const llvm::DWARFUnitIndex::Entry *GetIndexEntry() const {
return m_index_entry; return m_index_entry;
} }
uint64_t GetTypeHash() const { return m_type_hash; } uint64_t GetTypeHash() const { return m_type_hash; }
dw_offset_t GetTypeOffset() const { return m_type_offset; } dw_offset_t GetTypeOffset() const { return m_type_offset; }
uint64_t GetDWOId() const { return m_dwo_id; } uint64_t GetDWOId() const { return m_dwo_id; }
bool IsTypeUnit() const { bool IsTypeUnit() const {
return m_unit_type == DW_UT_type || m_unit_type == DW_UT_split_type; return m_unit_type == llvm::dwarf::DW_UT_type ||
m_unit_type == llvm::dwarf::DW_UT_split_type;
} }
uint32_t GetNextUnitOffset() const { return m_offset + m_length + 4; } uint32_t GetNextUnitOffset() const { return m_offset + m_length + 4; }
static llvm::Expected<DWARFUnitHeader> static llvm::Expected<DWARFUnitHeader>
extract(const lldb_private::DWARFDataExtractor &data, DIERef::Section section, extract(const lldb_private::DWARFDataExtractor &data, DIERef::Section section,
lldb_private::DWARFContext &dwarf_context, lldb_private::DWARFContext &dwarf_context,
lldb::offset_t *offset_ptr); lldb::offset_t *offset_ptr);
}; };
▲ Show 20 Lines • Show All 273 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Linesvoid DWARFUnit::ExtractUnitDIEIfNeeded() {
else if (m_gnu_addr_base) else if (m_gnu_addr_base)
dwo_cu->SetAddrBase(*m_gnu_addr_base); dwo_cu->SetAddrBase(*m_gnu_addr_base);
if (GetVersion() <= 4 && m_gnu_ranges_base) if (GetVersion() <= 4 && m_gnu_ranges_base)
dwo_cu->SetRangesBase(*m_gnu_ranges_base); dwo_cu->SetRangesBase(*m_gnu_ranges_base);
else if (dwo_symbol_file->GetDWARFContext() else if (dwo_symbol_file->GetDWARFContext()
.getOrLoadRngListsData() .getOrLoadRngListsData()
.GetByteSize() > 0) .GetByteSize() > 0)
dwo_cu->SetRangesBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32)); dwo_cu->SetRangesBase(
llvm::DWARFListTableHeader::getHeaderSize(llvm::dwarf::DWARF32));
if (GetVersion() >= 5 && if (GetVersion() >= 5 &&
dwo_symbol_file->GetDWARFContext().getOrLoadLocListsData().GetByteSize() > dwo_symbol_file->GetDWARFContext().getOrLoadLocListsData().GetByteSize() >
0) 0)
dwo_cu->SetLoclistsBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32)); dwo_cu->SetLoclistsBase(
llvm::DWARFListTableHeader::getHeaderSize(llvm::dwarf::DWARF32));
dwo_cu->SetBaseAddress(GetBaseAddress()); dwo_cu->SetBaseAddress(GetBaseAddress());
m_dwo = std::shared_ptr<DWARFUnit>(std::move(dwo_symbol_file), dwo_cu); m_dwo = std::shared_ptr<DWARFUnit>(std::move(dwo_symbol_file), dwo_cu);
} }
// Parses a compile unit and indexes its DIEs if it hasn't already been done. // Parses a compile unit and indexes its DIEs if it hasn't already been done.
// It will leave this compile unit extracted forever. // It will leave this compile unit extracted forever.
▲ Show 20 Lines • Show All 227 Lines • ▼ Show 20 Lines
// m_die_array_mutex must be already held as read/write. // m_die_array_mutex must be already held as read/write.
void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) { void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) {
DWARFAttributes attributes; DWARFAttributes attributes;
size_t num_attributes = cu_die.GetAttributes(this, attributes); size_t num_attributes = cu_die.GetAttributes(this, attributes);
// Extract DW_AT_addr_base first, as other attributes may need it. // Extract DW_AT_addr_base first, as other attributes may need it.
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
if (attributes.AttributeAtIndex(i) != DW_AT_addr_base) if (attributes.AttributeAtIndex(i) != llvm::dwarf::DW_AT_addr_base)
continue; continue;
DWARFFormValue form_value; DWARFFormValue form_value;
if (attributes.ExtractFormValueAtIndex(i, form_value)) { if (attributes.ExtractFormValueAtIndex(i, form_value)) {
SetAddrBase(form_value.Unsigned()); SetAddrBase(form_value.Unsigned());
break; break;
} }
} }
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
dw_attr_t attr = attributes.AttributeAtIndex(i); dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (!attributes.ExtractFormValueAtIndex(i, form_value)) if (!attributes.ExtractFormValueAtIndex(i, form_value))
continue; continue;
switch (attr) { switch (attr) {
case DW_AT_loclists_base: case llvm::dwarf::DW_AT_loclists_base:
SetLoclistsBase(form_value.Unsigned()); SetLoclistsBase(form_value.Unsigned());
break; break;
case DW_AT_rnglists_base: case llvm::dwarf::DW_AT_rnglists_base:
SetRangesBase(form_value.Unsigned()); SetRangesBase(form_value.Unsigned());
break; break;
case DW_AT_str_offsets_base: case llvm::dwarf::DW_AT_str_offsets_base:
SetStrOffsetsBase(form_value.Unsigned()); SetStrOffsetsBase(form_value.Unsigned());
break; break;
case DW_AT_low_pc: case llvm::dwarf::DW_AT_low_pc:
SetBaseAddress(form_value.Address()); SetBaseAddress(form_value.Address());
break; break;
case DW_AT_entry_pc: case llvm::dwarf::DW_AT_entry_pc:
// If the value was already set by DW_AT_low_pc, don't update it. // If the value was already set by DW_AT_low_pc, don't update it.
if (m_base_addr == LLDB_INVALID_ADDRESS) if (m_base_addr == LLDB_INVALID_ADDRESS)
SetBaseAddress(form_value.Address()); SetBaseAddress(form_value.Address());
break; break;
case DW_AT_stmt_list: case llvm::dwarf::DW_AT_stmt_list:
m_line_table_offset = form_value.Unsigned(); m_line_table_offset = form_value.Unsigned();
break; break;
case DW_AT_GNU_addr_base: case llvm::dwarf::DW_AT_GNU_addr_base:
m_gnu_addr_base = form_value.Unsigned(); m_gnu_addr_base = form_value.Unsigned();
break; break;
case DW_AT_GNU_ranges_base: case llvm::dwarf::DW_AT_GNU_ranges_base:
m_gnu_ranges_base = form_value.Unsigned(); m_gnu_ranges_base = form_value.Unsigned();
break; break;
case DW_AT_GNU_dwo_id: case llvm::dwarf::DW_AT_GNU_dwo_id:
m_dwo_id = form_value.Unsigned(); m_dwo_id = form_value.Unsigned();
break; break;
} }
} }
if (m_is_dwo) { if (m_is_dwo) {
m_has_parsed_non_skeleton_unit = true; m_has_parsed_non_skeleton_unit = true;
SetDwoStrOffsetsBase(); SetDwoStrOffsetsBase();
Show All 20 Lines
void DWARFUnit::SetAddrBase(dw_addr_t addr_base) { m_addr_base = addr_base; } void DWARFUnit::SetAddrBase(dw_addr_t addr_base) { m_addr_base = addr_base; }
// Parse the rangelist table header, including the optional array of offsets // Parse the rangelist table header, including the optional array of offsets
// following it (DWARF v5 and later). // following it (DWARF v5 and later).
template <typename ListTableType> template <typename ListTableType>
static llvm::Expected<ListTableType> static llvm::Expected<ListTableType>
ParseListTableHeader(const llvm::DWARFDataExtractor &data, uint64_t offset, ParseListTableHeader(const llvm::DWARFDataExtractor &data, uint64_t offset,
DwarfFormat format) { llvm::dwarf::DwarfFormat format) {
// We are expected to be called with Offset 0 or pointing just past the table // We are expected to be called with Offset 0 or pointing just past the table
// header. Correct Offset in the latter case so that it points to the start // header. Correct Offset in the latter case so that it points to the start
// of the header. // of the header.
if (offset == 0) { if (offset == 0) {
// This means DW_AT_rnglists_base is missing and therefore DW_FORM_rnglistx // This means DW_AT_rnglists_base is missing and therefore DW_FORM_rnglistx
// cannot be handled. Returning a default-constructed ListTableType allows // cannot be handled. Returning a default-constructed ListTableType allows
// DW_FORM_sec_offset to be supported. // DW_FORM_sec_offset to be supported.
return ListTableType(); return ListTableType();
Show All 22 Lines if (!contribution) {
"0x%" PRIx64, "0x%" PRIx64,
this->GetDWOId()); this->GetDWOId());
return; return;
} }
offset += contribution->Offset; offset += contribution->Offset;
} }
m_loclists_base = loclists_base; m_loclists_base = loclists_base;
uint64_t header_size = llvm::DWARFListTableHeader::getHeaderSize(DWARF32); uint64_t header_size =
llvm::DWARFListTableHeader::getHeaderSize(llvm::dwarf::DWARF32);
if (loclists_base < header_size) if (loclists_base < header_size)
return; return;
m_loclist_table_header.emplace(".debug_loclists", "locations"); m_loclist_table_header.emplace(".debug_loclists", "locations");
offset += loclists_base - header_size; offset += loclists_base - header_size;
if (llvm::Error E = m_loclist_table_header->extract( if (llvm::Error E = m_loclist_table_header->extract(
m_dwarf.GetDWARFContext().getOrLoadLocListsData().GetAsLLVM(), m_dwarf.GetDWARFContext().getOrLoadLocListsData().GetAsLLVM(),
&offset)) { &offset)) {
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
} }
const llvm::Optional<llvm::DWARFDebugRnglistTable> & const llvm::Optional<llvm::DWARFDebugRnglistTable> &
DWARFUnit::GetRnglistTable() { DWARFUnit::GetRnglistTable() {
if (GetVersion() >= 5 && !m_rnglist_table_done) { if (GetVersion() >= 5 && !m_rnglist_table_done) {
m_rnglist_table_done = true; m_rnglist_table_done = true;
if (auto table_or_error = if (auto table_or_error =
ParseListTableHeader<llvm::DWARFDebugRnglistTable>( ParseListTableHeader<llvm::DWARFDebugRnglistTable>(
GetRnglistData().GetAsLLVM(), m_ranges_base, DWARF32)) GetRnglistData().GetAsLLVM(), m_ranges_base,
llvm::dwarf::DWARF32))
m_rnglist_table = std::move(table_or_error.get()); m_rnglist_table = std::move(table_or_error.get());
else else
GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError( GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
"Failed to extract range list table at offset 0x%" PRIx64 ": %s", "Failed to extract range list table at offset 0x%" PRIx64 ": %s",
m_ranges_base, toString(table_or_error.takeError()).c_str()); m_ranges_base, toString(table_or_error.takeError()).c_str());
} }
return m_rnglist_table; return m_rnglist_table;
} }
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
} }
void DWARFUnit::ParseProducerInfo() { void DWARFUnit::ParseProducerInfo() {
m_producer = eProducerOther; m_producer = eProducerOther;
const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
if (!die) if (!die)
return; return;
llvm::StringRef producer( llvm::StringRef producer(die->GetAttributeValueAsString(
die->GetAttributeValueAsString(this, DW_AT_producer, nullptr)); this, llvm::dwarf::DW_AT_producer, nullptr));
if (producer.empty()) if (producer.empty())
return; return;
static const RegularExpression g_swiftlang_version_regex( static const RegularExpression g_swiftlang_version_regex(
llvm::StringRef(R"(swiftlang-([0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?))")); llvm::StringRef(R"(swiftlang-([0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?))"));
static const RegularExpression g_clang_version_regex( static const RegularExpression g_clang_version_regex(
llvm::StringRef(R"(clang-([0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?))")); llvm::StringRef(R"(clang-([0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?))"));
static const RegularExpression g_llvm_gcc_regex( static const RegularExpression g_llvm_gcc_regex(
Show All 31 Lines
uint64_t DWARFUnit::GetDWARFLanguageType() { uint64_t DWARFUnit::GetDWARFLanguageType() {
if (m_language_type) if (m_language_type)
return *m_language_type; return *m_language_type;
const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
if (!die) if (!die)
m_language_type = 0; m_language_type = 0;
else else
m_language_type = die->GetAttributeValueAsUnsigned(this, DW_AT_language, 0); m_language_type =
die->GetAttributeValueAsUnsigned(this, llvm::dwarf::DW_AT_language, 0);
return *m_language_type; return *m_language_type;
} }
bool DWARFUnit::GetIsOptimized() { bool DWARFUnit::GetIsOptimized() {
if (m_is_optimized == eLazyBoolCalculate) { if (m_is_optimized == eLazyBoolCalculate) {
const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
if (die) { if (die) {
m_is_optimized = eLazyBoolNo; m_is_optimized = eLazyBoolNo;
if (die->GetAttributeValueAsUnsigned(this, DW_AT_APPLE_optimized, 0) == if (die->GetAttributeValueAsUnsigned(
1) { this, llvm::dwarf::DW_AT_APPLE_optimized, 0) == 1) {
m_is_optimized = eLazyBoolYes; m_is_optimized = eLazyBoolYes;
} }
} }
} }
return m_is_optimized == eLazyBoolYes; return m_is_optimized == eLazyBoolYes;
} }
FileSpec::Style DWARFUnit::GetPathStyle() { FileSpec::Style DWARFUnit::GetPathStyle() {
Show All 39 Lines
} }
void DWARFUnit::ComputeCompDirAndGuessPathStyle() { void DWARFUnit::ComputeCompDirAndGuessPathStyle() {
m_comp_dir = FileSpec(); m_comp_dir = FileSpec();
const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
if (!die) if (!die)
return; return;
llvm::StringRef comp_dir = removeHostnameFromPathname( llvm::StringRef comp_dir =
die->GetAttributeValueAsString(this, DW_AT_comp_dir, nullptr)); removeHostnameFromPathname(die->GetAttributeValueAsString(
this, llvm::dwarf::DW_AT_comp_dir, nullptr));
if (!comp_dir.empty()) { if (!comp_dir.empty()) {
FileSpec::Style comp_dir_style = FileSpec::Style comp_dir_style =
FileSpec::GuessPathStyle(comp_dir).getValueOr(FileSpec::Style::native); FileSpec::GuessPathStyle(comp_dir).getValueOr(FileSpec::Style::native);
m_comp_dir = FileSpec(comp_dir, comp_dir_style); m_comp_dir = FileSpec(comp_dir, comp_dir_style);
} else { } else {
// Try to detect the style based on the DW_AT_name attribute, but just store // Try to detect the style based on the DW_AT_name attribute, but just store
// the detected style in the m_comp_dir field. // the detected style in the m_comp_dir field.
const char *name = const char *name =
die->GetAttributeValueAsString(this, DW_AT_name, nullptr); die->GetAttributeValueAsString(this, llvm::dwarf::DW_AT_name, nullptr);
m_comp_dir = FileSpec( m_comp_dir = FileSpec(
"", FileSpec::GuessPathStyle(name).getValueOr(FileSpec::Style::native)); "", FileSpec::GuessPathStyle(name).getValueOr(FileSpec::Style::native));
} }
} }
void DWARFUnit::ComputeAbsolutePath() { void DWARFUnit::ComputeAbsolutePath() {
m_file_spec = FileSpec(); m_file_spec = FileSpec();
const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly(); const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
if (!die) if (!die)
return; return;
m_file_spec = m_file_spec = FileSpec(
FileSpec(die->GetAttributeValueAsString(this, DW_AT_name, nullptr), die->GetAttributeValueAsString(this, llvm::dwarf::DW_AT_name, nullptr),
GetPathStyle()); GetPathStyle());
if (m_file_spec->IsRelative()) if (m_file_spec->IsRelative())
m_file_spec->MakeAbsolute(GetCompilationDirectory()); m_file_spec->MakeAbsolute(GetCompilationDirectory());
} }
SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() { SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() {
ExtractUnitDIEIfNeeded(); ExtractUnitDIEIfNeeded();
if (m_dwo) if (m_dwo)
Show All 35 Lines if (header.m_version == 5) {
header.m_addr_size = data.GetU8(offset_ptr); header.m_addr_size = data.GetU8(offset_ptr);
header.m_abbr_offset = data.GetDWARFOffset(offset_ptr); header.m_abbr_offset = data.GetDWARFOffset(offset_ptr);
if (header.m_unit_type == llvm::dwarf::DW_UT_skeleton || if (header.m_unit_type == llvm::dwarf::DW_UT_skeleton ||
header.m_unit_type == llvm::dwarf::DW_UT_split_compile) header.m_unit_type == llvm::dwarf::DW_UT_split_compile)
header.m_dwo_id = data.GetU64(offset_ptr); header.m_dwo_id = data.GetU64(offset_ptr);
} else { } else {
header.m_abbr_offset = data.GetDWARFOffset(offset_ptr); header.m_abbr_offset = data.GetDWARFOffset(offset_ptr);
header.m_addr_size = data.GetU8(offset_ptr); header.m_addr_size = data.GetU8(offset_ptr);
header.m_unit_type = header.m_unit_type = section == DIERef::Section::DebugTypes
section == DIERef::Section::DebugTypes ? DW_UT_type : DW_UT_compile; ? llvm::dwarf::DW_UT_type
: llvm::dwarf::DW_UT_compile;
} }
if (context.isDwo()) { if (context.isDwo()) {
if (header.IsTypeUnit()) { if (header.IsTypeUnit()) {
header.m_index_entry = header.m_index_entry =
context.GetAsLLVM().getTUIndex().getFromOffset(header.m_offset); context.GetAsLLVM().getTUIndex().getFromOffset(header.m_offset);
} else { } else {
header.m_index_entry = header.m_index_entry =
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines LLDB_LOG_ERROR(
"Failed to parse index entries for index at {1:x}, name {2}: {0}", "Failed to parse index entries for index at {1:x}, name {2}: {0}",
ni.getUnitOffset(), name); ni.getUnitOffset(), name);
} }
void DebugNamesDWARFIndex::GetGlobalVariables( void DebugNamesDWARFIndex::GetGlobalVariables(
ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) { ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {
for (const DebugNames::Entry &entry : for (const DebugNames::Entry &entry :
m_debug_names_up->equal_range(basename.GetStringRef())) { m_debug_names_up->equal_range(basename.GetStringRef())) {
if (entry.tag() != DW_TAG_variable) if (entry.tag() != llvm::dwarf::DW_TAG_variable)
continue; continue;
if (!ProcessEntry(entry, callback, basename.GetStringRef())) if (!ProcessEntry(entry, callback, basename.GetStringRef()))
return; return;
} }
m_fallback.GetGlobalVariables(basename, callback); m_fallback.GetGlobalVariables(basename, callback);
} }
void DebugNamesDWARFIndex::GetGlobalVariables( void DebugNamesDWARFIndex::GetGlobalVariables(
const RegularExpression &regex, const RegularExpression &regex,
llvm::function_ref<bool(DWARFDIE die)> callback) { llvm::function_ref<bool(DWARFDIE die)> callback) {
for (const DebugNames::NameIndex &ni: *m_debug_names_up) { for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
for (DebugNames::NameTableEntry nte: ni) { for (DebugNames::NameTableEntry nte: ni) {
if (!regex.Execute(nte.getString())) if (!regex.Execute(nte.getString()))
continue; continue;
uint64_t entry_offset = nte.getEntryOffset(); uint64_t entry_offset = nte.getEntryOffset();
llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset); llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
for (; entry_or; entry_or = ni.getEntry(&entry_offset)) { for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
if (entry_or->tag() != DW_TAG_variable) if (entry_or->tag() != llvm::dwarf::DW_TAG_variable)
continue; continue;
if (!ProcessEntry(*entry_or, callback, if (!ProcessEntry(*entry_or, callback,
llvm::StringRef(nte.getString()))) llvm::StringRef(nte.getString())))
return; return;
} }
MaybeLogLookupError(entry_or.takeError(), ni, nte.getString()); MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
} }
} }
m_fallback.GetGlobalVariables(regex, callback); m_fallback.GetGlobalVariables(regex, callback);
} }
void DebugNamesDWARFIndex::GetGlobalVariables( void DebugNamesDWARFIndex::GetGlobalVariables(
DWARFUnit &cu, llvm::function_ref<bool(DWARFDIE die)> callback) { DWARFUnit &cu, llvm::function_ref<bool(DWARFDIE die)> callback) {
lldbassert(!cu.GetSymbolFileDWARF().GetDwoNum()); lldbassert(!cu.GetSymbolFileDWARF().GetDwoNum());
uint64_t cu_offset = cu.GetOffset(); uint64_t cu_offset = cu.GetOffset();
bool found_entry_for_cu = false; bool found_entry_for_cu = false;
for (const DebugNames::NameIndex &ni: *m_debug_names_up) { for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
for (DebugNames::NameTableEntry nte: ni) { for (DebugNames::NameTableEntry nte: ni) {
uint64_t entry_offset = nte.getEntryOffset(); uint64_t entry_offset = nte.getEntryOffset();
llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset); llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
for (; entry_or; entry_or = ni.getEntry(&entry_offset)) { for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
if (entry_or->tag() != DW_TAG_variable) if (entry_or->tag() != llvm::dwarf::DW_TAG_variable)
continue; continue;
if (entry_or->getCUOffset() != cu_offset) if (entry_or->getCUOffset() != cu_offset)
continue; continue;
found_entry_for_cu = true; found_entry_for_cu = true;
if (!ProcessEntry(*entry_or, callback, if (!ProcessEntry(*entry_or, callback,
llvm::StringRef(nte.getString()))) llvm::StringRef(nte.getString())))
return; return;
Show All 11 Linesvoid DebugNamesDWARFIndex::GetCompleteObjCClass(
ConstString class_name, bool must_be_implementation, ConstString class_name, bool must_be_implementation,
llvm::function_ref<bool(DWARFDIE die)> callback) { llvm::function_ref<bool(DWARFDIE die)> callback) {
// Keep a list of incomplete types as fallback for when we don't find the // Keep a list of incomplete types as fallback for when we don't find the
// complete type. // complete type.
DIEArray incomplete_types; DIEArray incomplete_types;
for (const DebugNames::Entry &entry : for (const DebugNames::Entry &entry :
m_debug_names_up->equal_range(class_name.GetStringRef())) { m_debug_names_up->equal_range(class_name.GetStringRef())) {
if (entry.tag() != DW_TAG_structure_type && if (entry.tag() != llvm::dwarf::DW_TAG_structure_type &&
entry.tag() != DW_TAG_class_type) entry.tag() != llvm::dwarf::DW_TAG_class_type)
continue; continue;
llvm::Optional<DIERef> ref = ToDIERef(entry); llvm::Optional<DIERef> ref = ToDIERef(entry);
if (!ref) if (!ref)
continue; continue;
DWARFUnit *cu = m_debug_info.GetUnit(*ref); DWARFUnit *cu = m_debug_info.GetUnit(*ref);
if (!cu || !cu->Supports_DW_AT_APPLE_objc_complete_type()) { if (!cu || !cu->Supports_DW_AT_APPLE_objc_complete_type()) {
incomplete_types.push_back(*ref); incomplete_types.push_back(*ref);
continue; continue;
} }
DWARFDIE die = m_debug_info.GetDIE(*ref); DWARFDIE die = m_debug_info.GetDIE(*ref);
if (!die) { if (!die) {
ReportInvalidDIERef(*ref, class_name.GetStringRef()); ReportInvalidDIERef(*ref, class_name.GetStringRef());
continue; continue;
} }
if (die.GetAttributeValueAsUnsigned(DW_AT_APPLE_objc_complete_type, 0)) { if (die.GetAttributeValueAsUnsigned(
llvm::dwarf::DW_AT_APPLE_objc_complete_type, 0)) {
// If we find the complete version we're done. // If we find the complete version we're done.
callback(die); callback(die);
return; return;
} }
incomplete_types.push_back(*ref); incomplete_types.push_back(*ref);
} }
auto dierefcallback = DIERefCallback(callback, class_name.GetStringRef()); auto dierefcallback = DIERefCallback(callback, class_name.GetStringRef());
Show All 30 Linesvoid DebugNamesDWARFIndex::GetTypes(
m_fallback.GetTypes(context, callback); m_fallback.GetTypes(context, callback);
} }
void DebugNamesDWARFIndex::GetNamespaces( void DebugNamesDWARFIndex::GetNamespaces(
ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) { ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
for (const DebugNames::Entry &entry : for (const DebugNames::Entry &entry :
m_debug_names_up->equal_range(name.GetStringRef())) { m_debug_names_up->equal_range(name.GetStringRef())) {
if (entry.tag() == DW_TAG_namespace) { if (entry.tag() == llvm::dwarf::DW_TAG_namespace) {
if (!ProcessEntry(entry, callback, name.GetStringRef())) if (!ProcessEntry(entry, callback, name.GetStringRef()))
return; return;
} }
} }
m_fallback.GetNamespaces(name, callback); m_fallback.GetNamespaces(name, callback);
} }
void DebugNamesDWARFIndex::GetFunctions( void DebugNamesDWARFIndex::GetFunctions(
ConstString name, SymbolFileDWARF &dwarf, ConstString name, SymbolFileDWARF &dwarf,
const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask, const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
llvm::function_ref<bool(DWARFDIE die)> callback) { llvm::function_ref<bool(DWARFDIE die)> callback) {
std::set<DWARFDebugInfoEntry *> seen; std::set<DWARFDebugInfoEntry *> seen;
for (const DebugNames::Entry &entry : for (const DebugNames::Entry &entry :
m_debug_names_up->equal_range(name.GetStringRef())) { m_debug_names_up->equal_range(name.GetStringRef())) {
Tag tag = entry.tag(); llvm::dwarf::Tag tag = entry.tag();
if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine) if (tag != llvm::dwarf::DW_TAG_subprogram &&
tag != llvm::dwarf::DW_TAG_inlined_subroutine)
continue; continue;
if (llvm::Optional<DIERef> ref = ToDIERef(entry)) { if (llvm::Optional<DIERef> ref = ToDIERef(entry)) {
if (!ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx, if (!ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx,
name_type_mask, [&](DWARFDIE die) { name_type_mask, [&](DWARFDIE die) {
if (!seen.insert(die.GetDIE()).second) if (!seen.insert(die.GetDIE()).second)
return true; return true;
return callback(die); return callback(die);
Show All 12 Linesvoid DebugNamesDWARFIndex::GetFunctions(
for (const DebugNames::NameIndex &ni: *m_debug_names_up) { for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
for (DebugNames::NameTableEntry nte: ni) { for (DebugNames::NameTableEntry nte: ni) {
if (!regex.Execute(nte.getString())) if (!regex.Execute(nte.getString()))
continue; continue;
uint64_t entry_offset = nte.getEntryOffset(); uint64_t entry_offset = nte.getEntryOffset();
llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset); llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
for (; entry_or; entry_or = ni.getEntry(&entry_offset)) { for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
Tag tag = entry_or->tag(); llvm::dwarf::Tag tag = entry_or->tag();
if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine) if (tag != llvm::dwarf::DW_TAG_subprogram &&
tag != llvm::dwarf::DW_TAG_inlined_subroutine)
continue; continue;
if (!ProcessEntry(*entry_or, callback, if (!ProcessEntry(*entry_or, callback,
llvm::StringRef(nte.getString()))) llvm::StringRef(nte.getString())))
return; return;
} }
MaybeLogLookupError(entry_or.takeError(), ni, nte.getString()); MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
} }
Show All 13 Lines

lldb/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp

Show All 26 Lines if (tag == 0) {
return; return;
} }
const size_t count = die_info_array.size(); const size_t count = die_info_array.size();
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
const dw_tag_t die_tag = die_info_array[i].tag; const dw_tag_t die_tag = die_info_array[i].tag;
bool tag_matches = die_tag == 0 || tag == die_tag; bool tag_matches = die_tag == 0 || tag == die_tag;
if (!tag_matches) { if (!tag_matches) {
if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type) if (die_tag == llvm::dwarf::DW_TAG_class_type ||
tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type; die_tag == llvm::dwarf::DW_TAG_structure_type)
tag_matches = tag == llvm::dwarf::DW_TAG_structure_type ||
tag == llvm::dwarf::DW_TAG_class_type;
} }
if (tag_matches) { if (tag_matches) {
if (!callback(DIERef(die_info_array[i]))) if (!callback(DIERef(die_info_array[i])))
return; return;
} }
} }
} }
void DWARFMappedHash::ExtractDIEArray( void DWARFMappedHash::ExtractDIEArray(
const DIEInfoArray &die_info_array, const dw_tag_t tag, const DIEInfoArray &die_info_array, const dw_tag_t tag,
const uint32_t qualified_name_hash, const uint32_t qualified_name_hash,
llvm::function_ref<bool(DIERef ref)> callback) { llvm::function_ref<bool(DIERef ref)> callback) {
if (tag == 0) { if (tag == 0) {
ExtractDIEArray(die_info_array, callback); ExtractDIEArray(die_info_array, callback);
return; return;
} }
const size_t count = die_info_array.size(); const size_t count = die_info_array.size();
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
if (qualified_name_hash != die_info_array[i].qualified_name_hash) if (qualified_name_hash != die_info_array[i].qualified_name_hash)
continue; continue;
const dw_tag_t die_tag = die_info_array[i].tag; const dw_tag_t die_tag = die_info_array[i].tag;
bool tag_matches = die_tag == 0 || tag == die_tag; bool tag_matches = die_tag == 0 || tag == die_tag;
if (!tag_matches) { if (!tag_matches) {
if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type) if (die_tag == llvm::dwarf::DW_TAG_class_type ||
tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type; die_tag == llvm::dwarf::DW_TAG_structure_type)
tag_matches = tag == llvm::dwarf::DW_TAG_structure_type ||
tag == llvm::dwarf::DW_TAG_class_type;
} }
if (tag_matches) { if (tag_matches) {
if (!callback(DIERef(die_info_array[i]))) if (!callback(DIERef(die_info_array[i])))
return; return;
} }
} }
} }
void DWARFMappedHash::ExtractClassOrStructDIEArray( void DWARFMappedHash::ExtractClassOrStructDIEArray(
const DIEInfoArray &die_info_array, const DIEInfoArray &die_info_array,
bool return_implementation_only_if_available, bool return_implementation_only_if_available,
llvm::function_ref<bool(DIERef ref)> callback) { llvm::function_ref<bool(DIERef ref)> callback) {
const size_t count = die_info_array.size(); const size_t count = die_info_array.size();
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
const dw_tag_t die_tag = die_info_array[i].tag; const dw_tag_t die_tag = die_info_array[i].tag;
if (!(die_tag == 0 || die_tag == DW_TAG_class_type || if (!(die_tag == 0 || die_tag == llvm::dwarf::DW_TAG_class_type ||
die_tag == DW_TAG_structure_type)) die_tag == llvm::dwarf::DW_TAG_structure_type))
continue; continue;
bool is_implementation = bool is_implementation =
(die_info_array[i].type_flags & eTypeFlagClassIsImplementation) != 0; (die_info_array[i].type_flags & eTypeFlagClassIsImplementation) != 0;
if (is_implementation != return_implementation_only_if_available) if (is_implementation != return_implementation_only_if_available)
continue; continue;
if (return_implementation_only_if_available) { if (return_implementation_only_if_available) {
// We found the one true definition for this class, so only return // We found the one true definition for this class, so only return
// that // that
Show All 40 Lines
DWARFMappedHash::DIEInfo::DIEInfo(dw_offset_t o, dw_tag_t t, uint32_t f, DWARFMappedHash::DIEInfo::DIEInfo(dw_offset_t o, dw_tag_t t, uint32_t f,
uint32_t h) uint32_t h)
: die_offset(o), tag(t), type_flags(f), qualified_name_hash(h) {} : die_offset(o), tag(t), type_flags(f), qualified_name_hash(h) {}
DWARFMappedHash::Prologue::Prologue(dw_offset_t _die_base_offset) DWARFMappedHash::Prologue::Prologue(dw_offset_t _die_base_offset)
: die_base_offset(_die_base_offset), atoms() { : die_base_offset(_die_base_offset), atoms() {
// Define an array of DIE offsets by first defining an array, and then define // Define an array of DIE offsets by first defining an array, and then define
// the atom type for the array, in this case we have an array of DIE offsets. // the atom type for the array, in this case we have an array of DIE offsets.
AppendAtom(eAtomTypeDIEOffset, DW_FORM_data4); AppendAtom(eAtomTypeDIEOffset, llvm::dwarf::DW_FORM_data4);
} }
void DWARFMappedHash::Prologue::ClearAtoms() { void DWARFMappedHash::Prologue::ClearAtoms() {
hash_data_has_fixed_byte_size = true; hash_data_has_fixed_byte_size = true;
min_hash_data_byte_size = 0; min_hash_data_byte_size = 0;
atom_mask = 0; atom_mask = 0;
atoms.clear(); atoms.clear();
} }
bool DWARFMappedHash::Prologue::ContainsAtom(AtomType atom_type) const { bool DWARFMappedHash::Prologue::ContainsAtom(AtomType atom_type) const {
return (atom_mask & (1u << atom_type)) != 0; return (atom_mask & (1u << atom_type)) != 0;
} }
void DWARFMappedHash::Prologue::Clear() { void DWARFMappedHash::Prologue::Clear() {
die_base_offset = 0; die_base_offset = 0;
ClearAtoms(); ClearAtoms();
} }
void DWARFMappedHash::Prologue::AppendAtom(AtomType type, dw_form_t form) { void DWARFMappedHash::Prologue::AppendAtom(AtomType type, dw_form_t form) {
atoms.push_back({type, form}); atoms.push_back({type, form});
atom_mask |= 1u << type; atom_mask |= 1u << type;
switch (form) { switch (form) {
case DW_FORM_indirect: case llvm::dwarf::DW_FORM_indirect:
case DW_FORM_exprloc: case llvm::dwarf::DW_FORM_exprloc:
case DW_FORM_flag_present: case llvm::dwarf::DW_FORM_flag_present:
case DW_FORM_ref_sig8: case llvm::dwarf::DW_FORM_ref_sig8:
llvm_unreachable("Unhandled atom form"); llvm_unreachable("Unhandled atom form");
case DW_FORM_addrx: case llvm::dwarf::DW_FORM_addrx:
case DW_FORM_string: case llvm::dwarf::DW_FORM_string:
case DW_FORM_block: case llvm::dwarf::DW_FORM_block:
case DW_FORM_block1: case llvm::dwarf::DW_FORM_block1:
case DW_FORM_sdata: case llvm::dwarf::DW_FORM_sdata:
case DW_FORM_udata: case llvm::dwarf::DW_FORM_udata:
case DW_FORM_ref_udata: case llvm::dwarf::DW_FORM_ref_udata:
case DW_FORM_GNU_addr_index: case llvm::dwarf::DW_FORM_GNU_addr_index:
case DW_FORM_GNU_str_index: case llvm::dwarf::DW_FORM_GNU_str_index:
hash_data_has_fixed_byte_size = false; hash_data_has_fixed_byte_size = false;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case DW_FORM_flag: case llvm::dwarf::DW_FORM_flag:
case DW_FORM_data1: case llvm::dwarf::DW_FORM_data1:
case DW_FORM_ref1: case llvm::dwarf::DW_FORM_ref1:
case DW_FORM_sec_offset: case llvm::dwarf::DW_FORM_sec_offset:
min_hash_data_byte_size += 1; min_hash_data_byte_size += 1;
break; break;
case DW_FORM_block2: case llvm::dwarf::DW_FORM_block2:
hash_data_has_fixed_byte_size = false; hash_data_has_fixed_byte_size = false;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case DW_FORM_data2: case llvm::dwarf::DW_FORM_data2:
case DW_FORM_ref2: case llvm::dwarf::DW_FORM_ref2:
min_hash_data_byte_size += 2; min_hash_data_byte_size += 2;
break; break;
case DW_FORM_block4: case llvm::dwarf::DW_FORM_block4:
hash_data_has_fixed_byte_size = false; hash_data_has_fixed_byte_size = false;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case DW_FORM_data4: case llvm::dwarf::DW_FORM_data4:
case DW_FORM_ref4: case llvm::dwarf::DW_FORM_ref4:
case DW_FORM_addr: case llvm::dwarf::DW_FORM_addr:
case DW_FORM_ref_addr: case llvm::dwarf::DW_FORM_ref_addr:
case DW_FORM_strp: case llvm::dwarf::DW_FORM_strp:
min_hash_data_byte_size += 4; min_hash_data_byte_size += 4;
break; break;
case DW_FORM_data8: case llvm::dwarf::DW_FORM_data8:
case DW_FORM_ref8: case llvm::dwarf::DW_FORM_ref8:
min_hash_data_byte_size += 8; min_hash_data_byte_size += 8;
break; break;
} }
} }
lldb::offset_t lldb::offset_t
DWARFMappedHash::Prologue::Read(const lldb_private::DataExtractor &data, DWARFMappedHash::Prologue::Read(const lldb_private::DataExtractor &data,
lldb::offset_t offset) { lldb::offset_t offset) {
ClearAtoms(); ClearAtoms();
die_base_offset = data.GetU32(&offset); die_base_offset = data.GetU32(&offset);
const uint32_t atom_count = data.GetU32(&offset); const uint32_t atom_count = data.GetU32(&offset);
if (atom_count == 0x00060003u) { if (atom_count == 0x00060003u) {
// Old format, deal with contents of old pre-release format. // Old format, deal with contents of old pre-release format.
while (data.GetU32(&offset)) { while (data.GetU32(&offset)) {
/* do nothing */; /* do nothing */;
} }
// Hardcode to the only known value for now. // Hardcode to the only known value for now.
AppendAtom(eAtomTypeDIEOffset, DW_FORM_data4); AppendAtom(eAtomTypeDIEOffset, llvm::dwarf::DW_FORM_data4);
} else { } else {
for (uint32_t i = 0; i < atom_count; ++i) { for (uint32_t i = 0; i < atom_count; ++i) {
AtomType type = (AtomType)data.GetU16(&offset); AtomType type = (AtomType)data.GetU16(&offset);
dw_form_t form = (dw_form_t)data.GetU16(&offset); dw_form_t form = (dw_form_t)data.GetU16(&offset);
AppendAtom(type, form); AppendAtom(type, form);
} }
} }
return offset; return offset;
▲ Show 20 Lines • Show All 359 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

Show First 20 Lines • Show All 163 Lines • ▼ Show 20 Lines
void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit, void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit,
const LanguageType cu_language, const LanguageType cu_language,
IndexSet &set) { IndexSet &set) {
for (const DWARFDebugInfoEntry &die : unit.dies()) { for (const DWARFDebugInfoEntry &die : unit.dies()) {
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
switch (tag) { switch (tag) {
case DW_TAG_array_type: case llvm::dwarf::DW_TAG_array_type:
case DW_TAG_base_type: case llvm::dwarf::DW_TAG_base_type:
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
case DW_TAG_constant: case llvm::dwarf::DW_TAG_constant:
case DW_TAG_enumeration_type: case llvm::dwarf::DW_TAG_enumeration_type:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
case DW_TAG_namespace: case llvm::dwarf::DW_TAG_namespace:
case DW_TAG_string_type: case llvm::dwarf::DW_TAG_string_type:
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_subroutine_type: case llvm::dwarf::DW_TAG_subroutine_type:
case DW_TAG_typedef: case llvm::dwarf::DW_TAG_typedef:
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case DW_TAG_unspecified_type: case llvm::dwarf::DW_TAG_unspecified_type:
case DW_TAG_variable: case llvm::dwarf::DW_TAG_variable:
break; break;
default: default:
continue; continue;
} }
DWARFAttributes attributes; DWARFAttributes attributes;
const char *name = nullptr; const char *name = nullptr;
const char *mangled_cstr = nullptr; const char *mangled_cstr = nullptr;
bool is_declaration = false; bool is_declaration = false;
// bool is_artificial = false; // bool is_artificial = false;
bool has_address = false; bool has_address = false;
bool has_location_or_const_value = false; bool has_location_or_const_value = false;
bool is_global_or_static_variable = false; bool is_global_or_static_variable = false;
DWARFFormValue specification_die_form; DWARFFormValue specification_die_form;
const size_t num_attributes = die.GetAttributes(&unit, attributes); const size_t num_attributes = die.GetAttributes(&unit, attributes);
if (num_attributes > 0) { if (num_attributes > 0) {
for (uint32_t i = 0; i < num_attributes; ++i) { for (uint32_t i = 0; i < num_attributes; ++i) {
dw_attr_t attr = attributes.AttributeAtIndex(i); dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
switch (attr) { switch (attr) {
case DW_AT_name: case llvm::dwarf::DW_AT_name:
if (attributes.ExtractFormValueAtIndex(i, form_value)) if (attributes.ExtractFormValueAtIndex(i, form_value))
name = form_value.AsCString(); name = form_value.AsCString();
break; break;
case DW_AT_declaration: case llvm::dwarf::DW_AT_declaration:
if (attributes.ExtractFormValueAtIndex(i, form_value)) if (attributes.ExtractFormValueAtIndex(i, form_value))
is_declaration = form_value.Unsigned() != 0; is_declaration = form_value.Unsigned() != 0;
break; break;
case DW_AT_MIPS_linkage_name: case llvm::dwarf::DW_AT_MIPS_linkage_name:
case DW_AT_linkage_name: case llvm::dwarf::DW_AT_linkage_name:
if (attributes.ExtractFormValueAtIndex(i, form_value)) if (attributes.ExtractFormValueAtIndex(i, form_value))
mangled_cstr = form_value.AsCString(); mangled_cstr = form_value.AsCString();
break; break;
case DW_AT_low_pc: case llvm::dwarf::DW_AT_low_pc:
case DW_AT_high_pc: case llvm::dwarf::DW_AT_high_pc:
case DW_AT_ranges: case llvm::dwarf::DW_AT_ranges:
has_address = true; has_address = true;
break; break;
case DW_AT_entry_pc: case llvm::dwarf::DW_AT_entry_pc:
has_address = true; has_address = true;
break; break;
case DW_AT_location: case llvm::dwarf::DW_AT_location:
case DW_AT_const_value: case llvm::dwarf::DW_AT_const_value:
has_location_or_const_value = true; has_location_or_const_value = true;
is_global_or_static_variable = die.IsGlobalOrStaticScopeVariable(); is_global_or_static_variable = die.IsGlobalOrStaticScopeVariable();
break; break;
case DW_AT_specification: case llvm::dwarf::DW_AT_specification:
if (attributes.ExtractFormValueAtIndex(i, form_value)) if (attributes.ExtractFormValueAtIndex(i, form_value))
specification_die_form = form_value; specification_die_form = form_value;
break; break;
} }
} }
} }
DIERef ref = *DWARFDIE(&unit, &die).GetDIERef(); DIERef ref = *DWARFDIE(&unit, &die).GetDIERef();
switch (tag) { switch (tag) {
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
if (has_address) { if (has_address) {
if (name) { if (name) {
bool is_objc_method = false; bool is_objc_method = false;
if (cu_language == eLanguageTypeObjC || if (cu_language == eLanguageTypeObjC ||
cu_language == eLanguageTypeObjC_plus_plus) { cu_language == eLanguageTypeObjC_plus_plus) {
ObjCLanguage::MethodName objc_method(name, true); ObjCLanguage::MethodName objc_method(name, true);
if (objc_method.IsValid(true)) { if (objc_method.IsValid(true)) {
is_objc_method = true; is_objc_method = true;
Show All 37 Lines case llvm::dwarf::DW_TAG_subprogram:
((mangled_cstr[0] == '_') || ((mangled_cstr[0] == '_') ||
(::strcmp(name, mangled_cstr) != 0))) { (::strcmp(name, mangled_cstr) != 0))) {
set.function_fullnames.Insert(ConstString(mangled_cstr), ref); set.function_fullnames.Insert(ConstString(mangled_cstr), ref);
} }
} }
} }
break; break;
case DW_TAG_array_type: case llvm::dwarf::DW_TAG_array_type:
case DW_TAG_base_type: case llvm::dwarf::DW_TAG_base_type:
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
case DW_TAG_constant: case llvm::dwarf::DW_TAG_constant:
case DW_TAG_enumeration_type: case llvm::dwarf::DW_TAG_enumeration_type:
case DW_TAG_string_type: case llvm::dwarf::DW_TAG_string_type:
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_subroutine_type: case llvm::dwarf::DW_TAG_subroutine_type:
case DW_TAG_typedef: case llvm::dwarf::DW_TAG_typedef:
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case DW_TAG_unspecified_type: case llvm::dwarf::DW_TAG_unspecified_type:
if (name && !is_declaration) if (name && !is_declaration)
set.types.Insert(ConstString(name), ref); set.types.Insert(ConstString(name), ref);
if (mangled_cstr && !is_declaration) if (mangled_cstr && !is_declaration)
set.types.Insert(ConstString(mangled_cstr), ref); set.types.Insert(ConstString(mangled_cstr), ref);
break; break;
case DW_TAG_namespace: case llvm::dwarf::DW_TAG_namespace:
if (name) if (name)
set.namespaces.Insert(ConstString(name), ref); set.namespaces.Insert(ConstString(name), ref);
break; break;
case DW_TAG_variable: case llvm::dwarf::DW_TAG_variable:
if (name && has_location_or_const_value && is_global_or_static_variable) { if (name && has_location_or_const_value && is_global_or_static_variable) {
set.globals.Insert(ConstString(name), ref); set.globals.Insert(ConstString(name), ref);
// Be sure to include variables by their mangled and demangled names if // Be sure to include variables by their mangled and demangled names if
// they have any since a variable can have a basename "i", a mangled // they have any since a variable can have a basename "i", a mangled
// named "_ZN12_GLOBAL__N_11iE" and a demangled mangled name // named "_ZN12_GLOBAL__N_11iE" and a demangled mangled name
// "(anonymous namespace)::i"... // "(anonymous namespace)::i"...
// Make sure our mangled name isn't the same string table entry as our // Make sure our mangled name isn't the same string table entry as our
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Show First 20 Lines • Show All 284 Lines • ▼ Show 20 Lines if (die_offset >= max_die_offset)
return; return;
if (die_offset >= min_die_offset) { if (die_offset >= min_die_offset) {
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
bool add_type = false; bool add_type = false;
switch (tag) { switch (tag) {
case DW_TAG_array_type: case llvm::dwarf::DW_TAG_array_type:
add_type = (type_mask & eTypeClassArray) != 0; add_type = (type_mask & eTypeClassArray) != 0;
break; break;
case DW_TAG_unspecified_type: case llvm::dwarf::DW_TAG_unspecified_type:
case DW_TAG_base_type: case llvm::dwarf::DW_TAG_base_type:
add_type = (type_mask & eTypeClassBuiltin) != 0; add_type = (type_mask & eTypeClassBuiltin) != 0;
break; break;
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
add_type = (type_mask & eTypeClassClass) != 0; add_type = (type_mask & eTypeClassClass) != 0;
break; break;
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
add_type = (type_mask & eTypeClassStruct) != 0; add_type = (type_mask & eTypeClassStruct) != 0;
break; break;
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
add_type = (type_mask & eTypeClassUnion) != 0; add_type = (type_mask & eTypeClassUnion) != 0;
break; break;
case DW_TAG_enumeration_type: case llvm::dwarf::DW_TAG_enumeration_type:
add_type = (type_mask & eTypeClassEnumeration) != 0; add_type = (type_mask & eTypeClassEnumeration) != 0;
break; break;
case DW_TAG_subroutine_type: case llvm::dwarf::DW_TAG_subroutine_type:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
add_type = (type_mask & eTypeClassFunction) != 0; add_type = (type_mask & eTypeClassFunction) != 0;
break; break;
case DW_TAG_pointer_type: case llvm::dwarf::DW_TAG_pointer_type:
add_type = (type_mask & eTypeClassPointer) != 0; add_type = (type_mask & eTypeClassPointer) != 0;
break; break;
case DW_TAG_rvalue_reference_type: case llvm::dwarf::DW_TAG_rvalue_reference_type:
case DW_TAG_reference_type: case llvm::dwarf::DW_TAG_reference_type:
add_type = (type_mask & eTypeClassReference) != 0; add_type = (type_mask & eTypeClassReference) != 0;
break; break;
case DW_TAG_typedef: case llvm::dwarf::DW_TAG_typedef:
add_type = (type_mask & eTypeClassTypedef) != 0; add_type = (type_mask & eTypeClassTypedef) != 0;
break; break;
case DW_TAG_ptr_to_member_type: case llvm::dwarf::DW_TAG_ptr_to_member_type:
add_type = (type_mask & eTypeClassMemberPointer) != 0; add_type = (type_mask & eTypeClassMemberPointer) != 0;
break; break;
default: default:
break; break;
} }
if (add_type) { if (add_type) {
const bool assert_not_being_parsed = true; const bool assert_not_being_parsed = true;
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
// subroutine, or compile unit. // subroutine, or compile unit.
DWARFDIE DWARFDIE
SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die) { SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die) {
DWARFDIE die; DWARFDIE die;
for (die = child_die.GetParent(); die; die = die.GetParent()) { for (die = child_die.GetParent(); die; die = die.GetParent()) {
dw_tag_t tag = die.Tag(); dw_tag_t tag = die.Tag();
switch (tag) { switch (tag) {
case DW_TAG_compile_unit: case llvm::dwarf::DW_TAG_compile_unit:
case DW_TAG_partial_unit: case llvm::dwarf::DW_TAG_partial_unit:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
case DW_TAG_lexical_block: case llvm::dwarf::DW_TAG_lexical_block:
return die; return die;
default: default:
break; break;
} }
} }
return DWARFDIE(); return DWARFDIE();
} }
▲ Show 20 Lines • Show All 275 Lines • ▼ Show 20 Linesstatic void MakeAbsoluteAndRemap(FileSpec &file_spec, DWARFUnit &dwarf_cu,
if (auto remapped_file = module_sp->RemapSourceFile(file_spec.GetPath())) if (auto remapped_file = module_sp->RemapSourceFile(file_spec.GetPath()))
file_spec.SetFile(*remapped_file, FileSpec::Style::native); file_spec.SetFile(*remapped_file, FileSpec::Style::native);
} }
/// Return the DW_AT_(GNU_)dwo_name. /// Return the DW_AT_(GNU_)dwo_name.
static const char *GetDWOName(DWARFCompileUnit &dwarf_cu, static const char *GetDWOName(DWARFCompileUnit &dwarf_cu,
const DWARFDebugInfoEntry &cu_die) { const DWARFDebugInfoEntry &cu_die) {
const char *dwo_name = const char *dwo_name = cu_die.GetAttributeValueAsString(
cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_GNU_dwo_name, nullptr); &dwarf_cu, llvm::dwarf::DW_AT_GNU_dwo_name, nullptr);
if (!dwo_name) if (!dwo_name)
dwo_name = dwo_name = cu_die.GetAttributeValueAsString(
cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_dwo_name, nullptr); &dwarf_cu, llvm::dwarf::DW_AT_dwo_name, nullptr);
return dwo_name; return dwo_name;
} }
lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) { lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) {
CompUnitSP cu_sp; CompUnitSP cu_sp;
CompileUnit *comp_unit = (CompileUnit *)dwarf_cu.GetUserData(); CompileUnit *comp_unit = (CompileUnit *)dwarf_cu.GetUserData();
if (comp_unit) { if (comp_unit) {
// We already parsed this compile unit, had out a shared pointer to it // We already parsed this compile unit, had out a shared pointer to it
▲ Show 20 Lines • Show All 186 Lines • ▼ Show 20 Lines
XcodeSDK SymbolFileDWARF::ParseXcodeSDK(CompileUnit &comp_unit) { XcodeSDK SymbolFileDWARF::ParseXcodeSDK(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit); DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
if (!dwarf_cu) if (!dwarf_cu)
return {}; return {};
const DWARFBaseDIE cu_die = dwarf_cu->GetNonSkeletonUnit().GetUnitDIEOnly(); const DWARFBaseDIE cu_die = dwarf_cu->GetNonSkeletonUnit().GetUnitDIEOnly();
if (!cu_die) if (!cu_die)
return {}; return {};
const char *sdk = cu_die.GetAttributeValueAsString(DW_AT_APPLE_sdk, nullptr); const char *sdk =
cu_die.GetAttributeValueAsString(llvm::dwarf::DW_AT_APPLE_sdk, nullptr);
if (!sdk) if (!sdk)
return {}; return {};
const char *sysroot = const char *sysroot =
cu_die.GetAttributeValueAsString(DW_AT_LLVM_sysroot, ""); cu_die.GetAttributeValueAsString(llvm::dwarf::DW_AT_LLVM_sysroot, "");
// Register the sysroot path remapping with the module belonging to // Register the sysroot path remapping with the module belonging to
// the CU as well as the one belonging to the symbol file. The two // the CU as well as the one belonging to the symbol file. The two
// would be different if this is an OSO object and module is the // would be different if this is an OSO object and module is the
// corresponding debug map, in which case both should be updated. // corresponding debug map, in which case both should be updated.
ModuleSP module_sp = comp_unit.GetModule(); ModuleSP module_sp = comp_unit.GetModule();
if (module_sp) if (module_sp)
module_sp->RegisterXcodeSDK(sdk, sysroot); module_sp->RegisterXcodeSDK(sdk, sysroot);
Show All 9 Linessize_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit); DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
if (!dwarf_cu) if (!dwarf_cu)
return 0; return 0;
size_t functions_added = 0; size_t functions_added = 0;
dwarf_cu = &dwarf_cu->GetNonSkeletonUnit(); dwarf_cu = &dwarf_cu->GetNonSkeletonUnit();
for (DWARFDebugInfoEntry &entry : dwarf_cu->dies()) { for (DWARFDebugInfoEntry &entry : dwarf_cu->dies()) {
if (entry.Tag() != DW_TAG_subprogram) if (entry.Tag() != llvm::dwarf::DW_TAG_subprogram)
continue; continue;
DWARFDIE die(dwarf_cu, &entry); DWARFDIE die(dwarf_cu, &entry);
if (comp_unit.FindFunctionByUID(die.GetID())) if (comp_unit.FindFunctionByUID(die.GetID()))
continue; continue;
if (ParseFunction(comp_unit, die)) if (ParseFunction(comp_unit, die))
++functions_added; ++functions_added;
} }
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines if (!ClangModulesDeclVendor::LanguageSupportsClangModules(
return false; return false;
UpdateExternalModuleListIfNeeded(); UpdateExternalModuleListIfNeeded();
const DWARFDIE die = dwarf_cu->DIE(); const DWARFDIE die = dwarf_cu->DIE();
if (!die) if (!die)
return false; return false;
for (DWARFDIE child_die : die.children()) { for (DWARFDIE child_die : die.children()) {
if (child_die.Tag() != DW_TAG_imported_declaration) if (child_die.Tag() != llvm::dwarf::DW_TAG_imported_declaration)
continue; continue;
DWARFDIE module_die = child_die.GetReferencedDIE(DW_AT_import); DWARFDIE module_die = child_die.GetReferencedDIE(llvm::dwarf::DW_AT_import);
if (module_die.Tag() != DW_TAG_module) if (module_die.Tag() != llvm::dwarf::DW_TAG_module)
continue; continue;
if (const char *name = if (const char *name = module_die.GetAttributeValueAsString(
module_die.GetAttributeValueAsString(DW_AT_name, nullptr)) { llvm::dwarf::DW_AT_name, nullptr)) {
SourceModule module; SourceModule module;
module.path.push_back(ConstString(name)); module.path.push_back(ConstString(name));
DWARFDIE parent_die = module_die; DWARFDIE parent_die = module_die;
while ((parent_die = parent_die.GetParent())) { while ((parent_die = parent_die.GetParent())) {
if (parent_die.Tag() != DW_TAG_module) if (parent_die.Tag() != llvm::dwarf::DW_TAG_module)
break; break;
if (const char *name = if (const char *name = parent_die.GetAttributeValueAsString(
parent_die.GetAttributeValueAsString(DW_AT_name, nullptr)) llvm::dwarf::DW_AT_name, nullptr))
module.path.push_back(ConstString(name)); module.path.push_back(ConstString(name));
} }
std::reverse(module.path.begin(), module.path.end()); std::reverse(module.path.begin(), module.path.end());
if (const char *include_path = module_die.GetAttributeValueAsString( if (const char *include_path = module_die.GetAttributeValueAsString(
DW_AT_LLVM_include_path, nullptr)) { llvm::dwarf::DW_AT_LLVM_include_path, nullptr)) {
FileSpec include_spec(include_path, dwarf_cu->GetPathStyle()); FileSpec include_spec(include_path, dwarf_cu->GetPathStyle());
MakeAbsoluteAndRemap(include_spec, *dwarf_cu, MakeAbsoluteAndRemap(include_spec, *dwarf_cu,
m_objfile_sp->GetModule()); m_objfile_sp->GetModule());
module.search_path = ConstString(include_spec.GetPath()); module.search_path = ConstString(include_spec.GetPath());
} }
if (const char *sysroot = dwarf_cu->DIE().GetAttributeValueAsString( if (const char *sysroot = dwarf_cu->DIE().GetAttributeValueAsString(
DW_AT_LLVM_sysroot, nullptr)) llvm::dwarf::DW_AT_LLVM_sysroot, nullptr))
module.sysroot = ConstString(sysroot); module.sysroot = ConstString(sysroot);
imported_modules.push_back(module); imported_modules.push_back(module);
} }
} }
return true; return true;
} }
bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) { bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linesbool SymbolFileDWARF::ParseDebugMacros(CompileUnit &comp_unit) {
DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit); DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
if (dwarf_cu == nullptr) if (dwarf_cu == nullptr)
return false; return false;
const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly(); const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
if (!dwarf_cu_die) if (!dwarf_cu_die)
return false; return false;
lldb::offset_t sect_offset = lldb::offset_t sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(
dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET); llvm::dwarf::DW_AT_macros, DW_INVALID_OFFSET);
if (sect_offset == DW_INVALID_OFFSET) if (sect_offset == DW_INVALID_OFFSET)
sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros, sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(
DW_INVALID_OFFSET); llvm::dwarf::DW_AT_GNU_macros, DW_INVALID_OFFSET);
if (sect_offset == DW_INVALID_OFFSET) if (sect_offset == DW_INVALID_OFFSET)
return false; return false;
comp_unit.SetDebugMacros(ParseDebugMacros(&sect_offset)); comp_unit.SetDebugMacros(ParseDebugMacros(&sect_offset));
return true; return true;
} }
size_t SymbolFileDWARF::ParseBlocksRecursive( size_t SymbolFileDWARF::ParseBlocksRecursive(
lldb_private::CompileUnit &comp_unit, Block *parent_block, lldb_private::CompileUnit &comp_unit, Block *parent_block,
const DWARFDIE &orig_die, addr_t subprogram_low_pc, uint32_t depth) { const DWARFDIE &orig_die, addr_t subprogram_low_pc, uint32_t depth) {
size_t blocks_added = 0; size_t blocks_added = 0;
DWARFDIE die = orig_die; DWARFDIE die = orig_die;
while (die) { while (die) {
dw_tag_t tag = die.Tag(); dw_tag_t tag = die.Tag();
switch (tag) { switch (tag) {
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_lexical_block: { case llvm::dwarf::DW_TAG_lexical_block: {
Block *block = nullptr; Block *block = nullptr;
if (tag == DW_TAG_subprogram) { if (tag == llvm::dwarf::DW_TAG_subprogram) {
// Skip any DW_TAG_subprogram DIEs that are inside of a normal or // Skip any DW_TAG_subprogram DIEs that are inside of a normal or
// inlined functions. These will be parsed on their own as separate // inlined functions. These will be parsed on their own as separate
// entities. // entities.
if (depth > 0) if (depth > 0)
break; break;
block = parent_block; block = parent_block;
Show All 10 Lines case llvm::dwarf::DW_TAG_lexical_block: {
int decl_line = 0; int decl_line = 0;
int decl_column = 0; int decl_column = 0;
int call_file = 0; int call_file = 0;
int call_line = 0; int call_line = 0;
int call_column = 0; int call_column = 0;
if (die.GetDIENamesAndRanges(name, mangled_name, ranges, decl_file, if (die.GetDIENamesAndRanges(name, mangled_name, ranges, decl_file,
decl_line, decl_column, call_file, call_line, decl_line, decl_column, call_file, call_line,
call_column, nullptr)) { call_column, nullptr)) {
if (tag == DW_TAG_subprogram) { if (tag == llvm::dwarf::DW_TAG_subprogram) {
assert(subprogram_low_pc == LLDB_INVALID_ADDRESS); assert(subprogram_low_pc == LLDB_INVALID_ADDRESS);
subprogram_low_pc = ranges.GetMinRangeBase(0); subprogram_low_pc = ranges.GetMinRangeBase(0);
} else if (tag == DW_TAG_inlined_subroutine) { } else if (tag == llvm::dwarf::DW_TAG_inlined_subroutine) {
// We get called here for inlined subroutines in two ways. The first // We get called here for inlined subroutines in two ways. The first
// time is when we are making the Function object for this inlined // time is when we are making the Function object for this inlined
// concrete instance. Since we're creating a top level block at // concrete instance. Since we're creating a top level block at
// here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS. So we // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS. So we
// need to adjust the containing address. The second time is when we // need to adjust the containing address. The second time is when we
// are parsing the blocks inside the function that contains the // are parsing the blocks inside the function that contains the
// inlined concrete instance. Since these will be blocks inside the // inlined concrete instance. Since these will be blocks inside the
// containing "real" function the offset will be for that function. // containing "real" function the offset will be for that function.
Show All 16 Lines case llvm::dwarf::DW_TAG_lexical_block: {
"0x%" PRIx64 ". Please file a bug and attach the file at the " "0x%" PRIx64 ". Please file a bug and attach the file at the "
"start of this error message", "start of this error message",
block->GetID(), range_base, range.GetRangeEnd(), block->GetID(), range_base, range.GetRangeEnd(),
subprogram_low_pc); subprogram_low_pc);
} }
} }
block->FinalizeRanges(); block->FinalizeRanges();
if (tag != DW_TAG_subprogram && if (tag != llvm::dwarf::DW_TAG_subprogram &&
(name != nullptr || mangled_name != nullptr)) { (name != nullptr || mangled_name != nullptr)) {
std::unique_ptr<Declaration> decl_up; std::unique_ptr<Declaration> decl_up;
if (decl_file != 0 || decl_line != 0 || decl_column != 0) if (decl_file != 0 || decl_line != 0 || decl_column != 0)
decl_up = std::make_unique<Declaration>( decl_up = std::make_unique<Declaration>(
comp_unit.GetSupportFiles().GetFileSpecAtIndex(decl_file), comp_unit.GetSupportFiles().GetFileSpecAtIndex(decl_file),
decl_line, decl_column); decl_line, decl_column);
std::unique_ptr<Declaration> call_up; std::unique_ptr<Declaration> call_up;
Show All 32 Lines
} }
bool SymbolFileDWARF::ClassOrStructIsVirtual(const DWARFDIE &parent_die) { bool SymbolFileDWARF::ClassOrStructIsVirtual(const DWARFDIE &parent_die) {
if (parent_die) { if (parent_die) {
for (DWARFDIE die : parent_die.children()) { for (DWARFDIE die : parent_die.children()) {
dw_tag_t tag = die.Tag(); dw_tag_t tag = die.Tag();
bool check_virtuality = false; bool check_virtuality = false;
switch (tag) { switch (tag) {
case DW_TAG_inheritance: case llvm::dwarf::DW_TAG_inheritance:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
check_virtuality = true; check_virtuality = true;
break; break;
default: default:
break; break;
} }
if (check_virtuality) { if (check_virtuality) {
if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0) if (die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_virtuality, 0) !=
0)
return true; return true;
} }
} }
} }
return false; return false;
} }
void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) { void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines if (die) {
// We might be coming in in the middle of a type tree (a class within a // We might be coming in in the middle of a type tree (a class within a
// class, an enum within a class), so parse any needed parent DIEs before // class, an enum within a class), so parse any needed parent DIEs before
// we get to this one... // we get to this one...
DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(die); DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(die);
if (decl_ctx_die) { if (decl_ctx_die) {
if (log) { if (log) {
switch (decl_ctx_die.Tag()) { switch (decl_ctx_die.Tag()) {
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case DW_TAG_class_type: { case llvm::dwarf::DW_TAG_class_type: {
// Get the type, which could be a forward declaration // Get the type, which could be a forward declaration
if (log) if (log)
GetObjectFile()->GetModule()->LogMessage( GetObjectFile()->GetModule()->LogMessage(
log, log,
"SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' " "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' "
"resolve parent forward type for 0x%8.8x", "resolve parent forward type for 0x%8.8x",
die.GetOffset(), die.GetTagAsCString(), die.GetName(), die.GetOffset(), die.GetTagAsCString(), die.GetName(),
decl_ctx_die.GetOffset()); decl_ctx_die.GetOffset());
▲ Show 20 Lines • Show All 163 Lines • ▼ Show 20 LinesSymbolFileDWARF::GetDIE(const DIERef &die_ref) {
return DebugInfo().GetDIE(die_ref); return DebugInfo().GetDIE(die_ref);
} }
/// Return the DW_AT_(GNU_)dwo_id. /// Return the DW_AT_(GNU_)dwo_id.
/// FIXME: Technically 0 is a valid hash. /// FIXME: Technically 0 is a valid hash.
static uint64_t GetDWOId(DWARFCompileUnit &dwarf_cu, static uint64_t GetDWOId(DWARFCompileUnit &dwarf_cu,
const DWARFDebugInfoEntry &cu_die) { const DWARFDebugInfoEntry &cu_die) {
uint64_t dwo_id = uint64_t dwo_id = cu_die.GetAttributeValueAsUnsigned(
cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_GNU_dwo_id, 0); &dwarf_cu, llvm::dwarf::DW_AT_GNU_dwo_id, 0);
if (!dwo_id) if (!dwo_id)
dwo_id = cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_dwo_id, 0); dwo_id = cu_die.GetAttributeValueAsUnsigned(&dwarf_cu,
llvm::dwarf::DW_AT_dwo_id, 0);
return dwo_id; return dwo_id;
} }
llvm::Optional<uint64_t> SymbolFileDWARF::GetDWOId() { llvm::Optional<uint64_t> SymbolFileDWARF::GetDWOId() {
if (GetNumCompileUnits() == 1) { if (GetNumCompileUnits() == 1) {
if (auto comp_unit = GetCompileUnitAtIndex(0)) if (auto comp_unit = GetCompileUnitAtIndex(0))
if (DWARFCompileUnit *cu = GetDWARFCompileUnit(comp_unit.get())) if (DWARFCompileUnit *cu = GetDWARFCompileUnit(comp_unit.get()))
if (DWARFDebugInfoEntry *cu_die = cu->DIE().GetDIE()) if (DWARFDebugInfoEntry *cu_die = cu->DIE().GetDIE())
Show All 24 Lines if (!dwo_name)
return nullptr; return nullptr;
if (std::shared_ptr<SymbolFileDWARFDwo> dwp_sp = GetDwpSymbolFile()) if (std::shared_ptr<SymbolFileDWARFDwo> dwp_sp = GetDwpSymbolFile())
return dwp_sp; return dwp_sp;
FileSpec dwo_file(dwo_name); FileSpec dwo_file(dwo_name);
FileSystem::Instance().Resolve(dwo_file); FileSystem::Instance().Resolve(dwo_file);
if (dwo_file.IsRelative()) { if (dwo_file.IsRelative()) {
const char *comp_dir = const char *comp_dir = cu_die.GetAttributeValueAsString(
cu_die.GetAttributeValueAsString(dwarf_cu, DW_AT_comp_dir, nullptr); dwarf_cu, llvm::dwarf::DW_AT_comp_dir, nullptr);
if (!comp_dir) if (!comp_dir)
return nullptr; return nullptr;
dwo_file.SetFile(comp_dir, FileSpec::Style::native); dwo_file.SetFile(comp_dir, FileSpec::Style::native);
if (dwo_file.IsRelative()) { if (dwo_file.IsRelative()) {
// if DW_AT_comp_dir is relative, it should be relative to the location // if DW_AT_comp_dir is relative, it should be relative to the location
// of the executable, not to the location from which the debugger was // of the executable, not to the location from which the debugger was
// launched. // launched.
Show All 34 Lines auto *dwarf_cu =
llvm::dyn_cast<DWARFCompileUnit>(debug_info.GetUnitAtIndex(cu_idx)); llvm::dyn_cast<DWARFCompileUnit>(debug_info.GetUnitAtIndex(cu_idx));
if (!dwarf_cu) if (!dwarf_cu)
continue; continue;
const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly(); const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly();
if (!die || die.HasChildren() || !die.GetDIE()) if (!die || die.HasChildren() || !die.GetDIE())
continue; continue;
const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr); const char *name =
die.GetAttributeValueAsString(llvm::dwarf::DW_AT_name, nullptr);
if (!name) if (!name)
continue; continue;
ConstString const_name(name); ConstString const_name(name);
ModuleSP &module_sp = m_external_type_modules[const_name]; ModuleSP &module_sp = m_external_type_modules[const_name];
if (module_sp) if (module_sp)
continue; continue;
const char *dwo_path = GetDWOName(*dwarf_cu, *die.GetDIE()); const char *dwo_path = GetDWOName(*dwarf_cu, *die.GetDIE());
if (!dwo_path) if (!dwo_path)
continue; continue;
ModuleSpec dwo_module_spec; ModuleSpec dwo_module_spec;
dwo_module_spec.GetFileSpec().SetFile(dwo_path, FileSpec::Style::native); dwo_module_spec.GetFileSpec().SetFile(dwo_path, FileSpec::Style::native);
if (dwo_module_spec.GetFileSpec().IsRelative()) { if (dwo_module_spec.GetFileSpec().IsRelative()) {
const char *comp_dir = const char *comp_dir =
die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr); die.GetAttributeValueAsString(llvm::dwarf::DW_AT_comp_dir, nullptr);
if (comp_dir) { if (comp_dir) {
dwo_module_spec.GetFileSpec().SetFile(comp_dir, dwo_module_spec.GetFileSpec().SetFile(comp_dir,
FileSpec::Style::native); FileSpec::Style::native);
FileSystem::Instance().Resolve(dwo_module_spec.GetFileSpec()); FileSystem::Instance().Resolve(dwo_module_spec.GetFileSpec());
dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path); dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
} }
} }
dwo_module_spec.GetArchitecture() = dwo_module_spec.GetArchitecture() =
▲ Show 20 Lines • Show All 342 Lines • ▼ Show 20 Linesvoid SymbolFileDWARF::FindGlobalVariables(
uint32_t pruned_idx = original_size; uint32_t pruned_idx = original_size;
SymbolContext sc; SymbolContext sc;
m_index->GetGlobalVariables(ConstString(basename), [&](DWARFDIE die) { m_index->GetGlobalVariables(ConstString(basename), [&](DWARFDIE die) {
if (!sc.module_sp) if (!sc.module_sp)
sc.module_sp = m_objfile_sp->GetModule(); sc.module_sp = m_objfile_sp->GetModule();
assert(sc.module_sp); assert(sc.module_sp);
if (die.Tag() != DW_TAG_variable) if (die.Tag() != llvm::dwarf::DW_TAG_variable)
return true; return true;
auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU()); auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
if (!dwarf_cu) if (!dwarf_cu)
return true; return true;
sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu); sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
if (parent_decl_ctx) { if (parent_decl_ctx) {
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Linesbool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
bool include_inlines, bool include_inlines,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
SymbolContext sc; SymbolContext sc;
if (!orig_die) if (!orig_die)
return false; return false;
// If we were passed a die that is not a function, just return false... // If we were passed a die that is not a function, just return false...
if (!(orig_die.Tag() == DW_TAG_subprogram || if (!(orig_die.Tag() == llvm::dwarf::DW_TAG_subprogram ||
(include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine))) (include_inlines &&
orig_die.Tag() == llvm::dwarf::DW_TAG_inlined_subroutine)))
return false; return false;
DWARFDIE die = orig_die; DWARFDIE die = orig_die;
DWARFDIE inlined_die; DWARFDIE inlined_die;
if (die.Tag() == DW_TAG_inlined_subroutine) { if (die.Tag() == llvm::dwarf::DW_TAG_inlined_subroutine) {
inlined_die = die; inlined_die = die;
while (true) { while (true) {
die = die.GetParent(); die = die.GetParent();
if (die) { if (die) {
if (die.Tag() == DW_TAG_subprogram) if (die.Tag() == llvm::dwarf::DW_TAG_subprogram)
break; break;
} else } else
break; break;
} }
} }
assert(die && die.Tag() == DW_TAG_subprogram); assert(die && die.Tag() == llvm::dwarf::DW_TAG_subprogram);
if (GetFunction(die, sc)) { if (GetFunction(die, sc)) {
Address addr; Address addr;
// Parse all blocks if needed // Parse all blocks if needed
if (inlined_die) { if (inlined_die) {
Block &function_block = sc.function->GetBlock(true); Block &function_block = sc.function->GetBlock(true);
sc.block = function_block.FindBlockByID(inlined_die.GetID()); sc.block = function_block.FindBlockByID(inlined_die.GetID());
if (sc.block == nullptr) if (sc.block == nullptr)
sc.block = function_block.FindBlockByID(inlined_die.GetOffset()); sc.block = function_block.FindBlockByID(inlined_die.GetOffset());
▲ Show 20 Lines • Show All 304 Lines • ▼ Show 20 Lines if (type_ptr == nullptr) {
if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU())) if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU()))
scope = GetCompUnitForDWARFCompUnit(*dwarf_cu); scope = GetCompUnitForDWARFCompUnit(*dwarf_cu);
else else
scope = GetObjectFile()->GetModule().get(); scope = GetObjectFile()->GetModule().get();
assert(scope); assert(scope);
SymbolContext sc(scope); SymbolContext sc(scope);
const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE(); const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE();
while (parent_die != nullptr) { while (parent_die != nullptr) {
if (parent_die->Tag() == DW_TAG_subprogram) if (parent_die->Tag() == llvm::dwarf::DW_TAG_subprogram)
break; break;
parent_die = parent_die->GetParent(); parent_die = parent_die->GetParent();
} }
SymbolContext sc_backup = sc; SymbolContext sc_backup = sc;
if (resolve_function_context && parent_die != nullptr && if (resolve_function_context && parent_die != nullptr &&
!GetFunction(DWARFDIE(die.GetCU(), parent_die), sc)) !GetFunction(DWARFDIE(die.GetCU(), parent_die), sc))
sc = sc_backup; sc = sc_backup;
Show All 12 Lines if (orig_die) {
DWARFDIE die = orig_die; DWARFDIE die = orig_die;
while (die) { while (die) {
// If this is the original DIE that we are searching for a declaration // If this is the original DIE that we are searching for a declaration
// for, then don't look in the cache as we don't want our own decl // for, then don't look in the cache as we don't want our own decl
// context to be our decl context... // context to be our decl context...
if (orig_die != die) { if (orig_die != die) {
switch (die.Tag()) { switch (die.Tag()) {
case DW_TAG_compile_unit: case llvm::dwarf::DW_TAG_compile_unit:
case DW_TAG_partial_unit: case llvm::dwarf::DW_TAG_partial_unit:
case DW_TAG_namespace: case llvm::dwarf::DW_TAG_namespace:
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
case DW_TAG_lexical_block: case llvm::dwarf::DW_TAG_lexical_block:
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
return die; return die;
case DW_TAG_inlined_subroutine: { case llvm::dwarf::DW_TAG_inlined_subroutine: {
DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin); DWARFDIE abs_die =
die.GetReferencedDIE(llvm::dwarf::DW_AT_abstract_origin);
if (abs_die) { if (abs_die) {
return abs_die; return abs_die;
} }
break; break;
} }
default: default:
break; break;
} }
} }
DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification); DWARFDIE spec_die =
die.GetReferencedDIE(llvm::dwarf::DW_AT_specification);
if (spec_die) { if (spec_die) {
DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die); DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die);
if (decl_ctx_die) if (decl_ctx_die)
return decl_ctx_die; return decl_ctx_die;
} }
DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin); DWARFDIE abs_die =
die.GetReferencedDIE(llvm::dwarf::DW_AT_abstract_origin);
if (abs_die) { if (abs_die) {
DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die); DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die);
if (decl_ctx_die) if (decl_ctx_die)
return decl_ctx_die; return decl_ctx_die;
} }
die = die.GetParent(); die = die.GetParent();
} }
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 LinesTypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
m_index->GetCompleteObjCClass( m_index->GetCompleteObjCClass(
type_name, must_be_implementation, [&](DWARFDIE type_die) { type_name, must_be_implementation, [&](DWARFDIE type_die) {
bool try_resolving_type = false; bool try_resolving_type = false;
// Don't try and resolve the DIE we are looking for with the DIE // Don't try and resolve the DIE we are looking for with the DIE
// itself! // itself!
if (type_die != die) { if (type_die != die) {
switch (type_die.Tag()) { switch (type_die.Tag()) {
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
try_resolving_type = true; try_resolving_type = true;
break; break;
default: default:
break; break;
} }
} }
if (!try_resolving_type) if (!try_resolving_type)
return true; return true;
if (must_be_implementation && if (must_be_implementation &&
type_die.Supports_DW_AT_APPLE_objc_complete_type()) type_die.Supports_DW_AT_APPLE_objc_complete_type())
try_resolving_type = type_die.GetAttributeValueAsUnsigned( try_resolving_type = type_die.GetAttributeValueAsUnsigned(
DW_AT_APPLE_objc_complete_type, 0); llvm::dwarf::DW_AT_APPLE_objc_complete_type, 0);
if (!try_resolving_type) if (!try_resolving_type)
return true; return true;
Type *resolved_type = ResolveType(type_die, false, true); Type *resolved_type = ResolveType(type_die, false, true);
if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED) if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
return true; return true;
DEBUG_PRINTF( DEBUG_PRINTF(
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
#ifndef NDEBUG #ifndef NDEBUG
// Make sure the top item in the decl context die array is always // Make sure the top item in the decl context die array is always
// DW_TAG_compile_unit or DW_TAG_partial_unit. If it isn't then // DW_TAG_compile_unit or DW_TAG_partial_unit. If it isn't then
// something went wrong in the DWARFDIE::GetDeclContextDIEs() // something went wrong in the DWARFDIE::GetDeclContextDIEs()
// function. // function.
dw_tag_t cu_tag = decl_ctx_1[count1 - 1].Tag(); dw_tag_t cu_tag = decl_ctx_1[count1 - 1].Tag();
UNUSED_IF_ASSERT_DISABLED(cu_tag); UNUSED_IF_ASSERT_DISABLED(cu_tag);
assert(cu_tag == DW_TAG_compile_unit || cu_tag == DW_TAG_partial_unit); assert(cu_tag == llvm::dwarf::DW_TAG_compile_unit ||
cu_tag == llvm::dwarf::DW_TAG_partial_unit);
#endif #endif
// Always skip the compile unit when comparing by only iterating up to "count // Always skip the compile unit when comparing by only iterating up to "count
// - 1". Here we compare the names as we go. // - 1". Here we compare the names as we go.
for (i = 0; i < count1 - 1; i++) { for (i = 0; i < count1 - 1; i++) {
decl_ctx_die1 = decl_ctx_1[i]; decl_ctx_die1 = decl_ctx_1[i];
decl_ctx_die2 = decl_ctx_2[i]; decl_ctx_die2 = decl_ctx_2[i];
const char *name1 = decl_ctx_die1.GetName(); const char *name1 = decl_ctx_die1.GetName();
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines if (type_name) {
if (type_tag == tag) { if (type_tag == tag) {
// The tags match, lets try resolving this type // The tags match, lets try resolving this type
try_resolving_type = true; try_resolving_type = true;
} else { } else {
// The tags don't match, but we need to watch our for a forward // The tags don't match, but we need to watch our for a forward
// declaration for a struct and ("struct foo") ends up being a // declaration for a struct and ("struct foo") ends up being a
// class ("class foo { ... };") or vice versa. // class ("class foo { ... };") or vice versa.
switch (type_tag) { switch (type_tag) {
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
// We had a "class foo", see if we ended up with a "struct foo // We had a "class foo", see if we ended up with a "struct foo
// { ... };" // { ... };"
try_resolving_type = (tag == DW_TAG_structure_type); try_resolving_type = (tag == llvm::dwarf::DW_TAG_structure_type);
break; break;
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
// We had a "struct foo", see if we ended up with a "class foo // We had a "struct foo", see if we ended up with a "class foo
// { ... };" // { ... };"
try_resolving_type = (tag == DW_TAG_class_type); try_resolving_type = (tag == llvm::dwarf::DW_TAG_class_type);
break; break;
default: default:
// Tags don't match, don't event try to resolve using this type // Tags don't match, don't event try to resolve using this type
// whose name matches.... // whose name matches....
break; break;
} }
} }
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 LinesTypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser(); DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
if (!dwarf_ast) if (!dwarf_ast)
return {}; return {};
TypeSP type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, type_is_new_ptr); TypeSP type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, type_is_new_ptr);
if (type_sp) { if (type_sp) {
GetTypeList().Insert(type_sp); GetTypeList().Insert(type_sp);
if (die.Tag() == DW_TAG_subprogram) { if (die.Tag() == llvm::dwarf::DW_TAG_subprogram) {
std::string scope_qualified_name(GetDeclContextForUID(die.GetID()) std::string scope_qualified_name(GetDeclContextForUID(die.GetID())
.GetScopeQualifiedName() .GetScopeQualifiedName()
.AsCString("")); .AsCString(""));
if (scope_qualified_name.size()) { if (scope_qualified_name.size()) {
m_function_scope_qualified_name_map[scope_qualified_name].insert( m_function_scope_qualified_name_map[scope_qualified_name].insert(
*die.GetDIERef()); *die.GetDIERef());
} }
} }
} }
return type_sp; return type_sp;
} }
size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc, size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc,
const DWARFDIE &orig_die, const DWARFDIE &orig_die,
bool parse_siblings, bool parse_children) { bool parse_siblings, bool parse_children) {
size_t types_added = 0; size_t types_added = 0;
DWARFDIE die = orig_die; DWARFDIE die = orig_die;
while (die) { while (die) {
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
bool type_is_new = false; bool type_is_new = false;
Tag dwarf_tag = static_cast<Tag>(tag); llvm::dwarf::Tag dwarf_tag = static_cast<llvm::dwarf::Tag>(tag);
// TODO: Currently ParseTypeFromDWARF(...) which is called by ParseType(...) // TODO: Currently ParseTypeFromDWARF(...) which is called by ParseType(...)
// does not handle DW_TAG_subrange_type. It is not clear if this is a bug or // does not handle DW_TAG_subrange_type. It is not clear if this is a bug or
// not. // not.
if (isType(dwarf_tag) && tag != DW_TAG_subrange_type) if (isType(dwarf_tag) && tag != llvm::dwarf::DW_TAG_subrange_type)
ParseType(sc, die, &type_is_new); ParseType(sc, die, &type_is_new);
if (type_is_new) if (type_is_new)
++types_added; ++types_added;
if (parse_children && die.HasChildren()) { if (parse_children && die.HasChildren()) {
if (die.Tag() == DW_TAG_subprogram) { if (die.Tag() == llvm::dwarf::DW_TAG_subprogram) {
SymbolContext child_sc(sc); SymbolContext child_sc(sc);
child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get(); child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true); types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true);
} else } else
types_added += ParseTypes(sc, die.GetFirstChild(), true, true); types_added += ParseTypes(sc, die.GetFirstChild(), true, true);
} }
if (parse_siblings) if (parse_siblings)
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 LinesVariableSP SymbolFileDWARF::ParseVariableDIECached(const SymbolContext &sc,
VariableSP var_sp = die_to_variable[die.GetDIE()]; VariableSP var_sp = die_to_variable[die.GetDIE()];
if (var_sp) if (var_sp)
return var_sp; return var_sp;
var_sp = ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS); var_sp = ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS);
if (var_sp) { if (var_sp) {
die_to_variable[die.GetDIE()] = var_sp; die_to_variable[die.GetDIE()] = var_sp;
if (DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification)) if (DWARFDIE spec_die =
die.GetReferencedDIE(llvm::dwarf::DW_AT_specification))
die_to_variable[spec_die.GetDIE()] = var_sp; die_to_variable[spec_die.GetDIE()] = var_sp;
} }
return var_sp; return var_sp;
} }
VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc, VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
const DWARFDIE &die, const DWARFDIE &die,
const lldb::addr_t func_low_pc) { const lldb::addr_t func_low_pc) {
if (die.GetDWARF() != this) if (die.GetDWARF() != this)
return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc); return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
if (!die) if (!die)
return nullptr; return nullptr;
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
ModuleSP module = GetObjectFile()->GetModule(); ModuleSP module = GetObjectFile()->GetModule();
if (tag != DW_TAG_variable && tag != DW_TAG_constant && if (tag != llvm::dwarf::DW_TAG_variable &&
(tag != DW_TAG_formal_parameter || !sc.function)) tag != llvm::dwarf::DW_TAG_constant &&
(tag != llvm::dwarf::DW_TAG_formal_parameter || !sc.function))
return nullptr; return nullptr;
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_attributes = die.GetAttributes(attributes); const size_t num_attributes = die.GetAttributes(attributes);
const char *name = nullptr; const char *name = nullptr;
const char *mangled = nullptr; const char *mangled = nullptr;
Declaration decl; Declaration decl;
DWARFFormValue type_die_form; DWARFFormValue type_die_form;
DWARFExpression location; DWARFExpression location;
bool is_external = false; bool is_external = false;
bool is_artificial = false; bool is_artificial = false;
DWARFFormValue const_value_form, location_form; DWARFFormValue const_value_form, location_form;
Variable::RangeList scope_ranges; Variable::RangeList scope_ranges;
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
dw_attr_t attr = attributes.AttributeAtIndex(i); dw_attr_t attr = attributes.AttributeAtIndex(i);
DWARFFormValue form_value; DWARFFormValue form_value;
if (!attributes.ExtractFormValueAtIndex(i, form_value)) if (!attributes.ExtractFormValueAtIndex(i, form_value))
continue; continue;
switch (attr) { switch (attr) {
case DW_AT_decl_file: case llvm::dwarf::DW_AT_decl_file:
decl.SetFile( decl.SetFile(
attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned())); attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned()));
break; break;
case DW_AT_decl_line: case llvm::dwarf::DW_AT_decl_line:
decl.SetLine(form_value.Unsigned()); decl.SetLine(form_value.Unsigned());
break; break;
case DW_AT_decl_column: case llvm::dwarf::DW_AT_decl_column:
decl.SetColumn(form_value.Unsigned()); decl.SetColumn(form_value.Unsigned());
break; break;
case DW_AT_name: case llvm::dwarf::DW_AT_name:
name = form_value.AsCString(); name = form_value.AsCString();
break; break;
case DW_AT_linkage_name: case llvm::dwarf::DW_AT_linkage_name:
case DW_AT_MIPS_linkage_name: case llvm::dwarf::DW_AT_MIPS_linkage_name:
mangled = form_value.AsCString(); mangled = form_value.AsCString();
break; break;
case DW_AT_type: case llvm::dwarf::DW_AT_type:
type_die_form = form_value; type_die_form = form_value;
break; break;
case DW_AT_external: case llvm::dwarf::DW_AT_external:
is_external = form_value.Boolean(); is_external = form_value.Boolean();
break; break;
case DW_AT_const_value: case llvm::dwarf::DW_AT_const_value:
const_value_form = form_value; const_value_form = form_value;
break; break;
case DW_AT_location: case llvm::dwarf::DW_AT_location:
location_form = form_value; location_form = form_value;
break; break;
case DW_AT_start_scope: case llvm::dwarf::DW_AT_start_scope:
// TODO: Implement this. // TODO: Implement this.
break; break;
case DW_AT_artificial: case llvm::dwarf::DW_AT_artificial:
is_artificial = form_value.Boolean(); is_artificial = form_value.Boolean();
break; break;
case DW_AT_declaration: case llvm::dwarf::DW_AT_declaration:
case DW_AT_description: case llvm::dwarf::DW_AT_description:
case DW_AT_endianity: case llvm::dwarf::DW_AT_endianity:
case DW_AT_segment: case llvm::dwarf::DW_AT_segment:
case DW_AT_specification: case llvm::dwarf::DW_AT_specification:
case DW_AT_visibility: case llvm::dwarf::DW_AT_visibility:
default: default:
case DW_AT_abstract_origin: case llvm::dwarf::DW_AT_abstract_origin:
case DW_AT_sibling: case llvm::dwarf::DW_AT_sibling:
break; break;
} }
} }
// Prefer DW_AT_location over DW_AT_const_value. Both can be emitted e.g. // Prefer DW_AT_location over DW_AT_const_value. Both can be emitted e.g.
// for static constexpr member variables -- DW_AT_const_value will be // for static constexpr member variables -- DW_AT_const_value will be
// present in the class declaration and DW_AT_location in the DIE defining // present in the class declaration and DW_AT_location in the DIE defining
// the member. // the member.
bool location_is_const_value_data = false; bool location_is_const_value_data = false;
bool has_explicit_location = false; bool has_explicit_location = false;
bool use_type_size_for_value = false; bool use_type_size_for_value = false;
if (location_form.IsValid()) { if (location_form.IsValid()) {
has_explicit_location = true; has_explicit_location = true;
if (DWARFFormValue::IsBlockForm(location_form.Form())) { if (DWARFFormValue::IsBlockForm(location_form.Form())) {
const DWARFDataExtractor &data = die.GetData(); const DWARFDataExtractor &data = die.GetData();
uint32_t block_offset = location_form.BlockData() - data.GetDataStart(); uint32_t block_offset = location_form.BlockData() - data.GetDataStart();
uint32_t block_length = location_form.Unsigned(); uint32_t block_length = location_form.Unsigned();
location = DWARFExpression( location = DWARFExpression(
module, DataExtractor(data, block_offset, block_length), die.GetCU()); module, DataExtractor(data, block_offset, block_length), die.GetCU());
} else { } else {
DataExtractor data = die.GetCU()->GetLocationData(); DataExtractor data = die.GetCU()->GetLocationData();
dw_offset_t offset = location_form.Unsigned(); dw_offset_t offset = location_form.Unsigned();
if (location_form.Form() == DW_FORM_loclistx) if (location_form.Form() == llvm::dwarf::DW_FORM_loclistx)
offset = die.GetCU()->GetLoclistOffset(offset).getValueOr(-1); offset = die.GetCU()->GetLoclistOffset(offset).getValueOr(-1);
if (data.ValidOffset(offset)) { if (data.ValidOffset(offset)) {
data = DataExtractor(data, offset, data.GetByteSize() - offset); data = DataExtractor(data, offset, data.GetByteSize() - offset);
location = DWARFExpression(module, data, die.GetCU()); location = DWARFExpression(module, data, die.GetCU());
assert(func_low_pc != LLDB_INVALID_ADDRESS); assert(func_low_pc != LLDB_INVALID_ADDRESS);
location.SetLocationListAddresses( location.SetLocationListAddresses(
location_form.GetUnit()->GetBaseAddress(), func_low_pc); location_form.GetUnit()->GetBaseAddress(), func_low_pc);
} }
Show All 24 Lines if (DWARFFormValue::IsBlockForm(const_value_form.Form())) {
die.GetCU()->GetAddressByteSize()), die.GetCU()->GetAddressByteSize()),
die.GetCU()); die.GetCU());
} }
} }
const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die); const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die);
const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die); const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die);
const dw_tag_t parent_tag = sc_parent_die.Tag(); const dw_tag_t parent_tag = sc_parent_die.Tag();
bool is_static_member = (parent_tag == DW_TAG_compile_unit || bool is_static_member =
parent_tag == DW_TAG_partial_unit) && (parent_tag == llvm::dwarf::DW_TAG_compile_unit ||
(parent_context_die.Tag() == DW_TAG_class_type || parent_tag == llvm::dwarf::DW_TAG_partial_unit) &&
parent_context_die.Tag() == DW_TAG_structure_type); (parent_context_die.Tag() == llvm::dwarf::DW_TAG_class_type ||
parent_context_die.Tag() == llvm::dwarf::DW_TAG_structure_type);
ValueType scope = eValueTypeInvalid; ValueType scope = eValueTypeInvalid;
SymbolContextScope *symbol_context_scope = nullptr; SymbolContextScope *symbol_context_scope = nullptr;
bool has_explicit_mangled = mangled != nullptr; bool has_explicit_mangled = mangled != nullptr;
if (!mangled) { if (!mangled) {
// LLDB relies on the mangled name (DW_TAG_linkage_name or // LLDB relies on the mangled name (DW_TAG_linkage_name or
// DW_AT_MIPS_linkage_name) to generate fully qualified names // DW_AT_MIPS_linkage_name) to generate fully qualified names
// of global variables with commands like "frame var j". For // of global variables with commands like "frame var j". For
// example, if j were an int variable holding a value 4 and // example, if j were an int variable holding a value 4 and
// declared in a namespace B which in turn is contained in a // declared in a namespace B which in turn is contained in a
// namespace A, the command "frame var j" returns // namespace A, the command "frame var j" returns
// "(int) A::B::j = 4". // "(int) A::B::j = 4".
// If the compiler does not emit a linkage name, we should be // If the compiler does not emit a linkage name, we should be
// able to generate a fully qualified name from the // able to generate a fully qualified name from the
// declaration context. // declaration context.
if ((parent_tag == DW_TAG_compile_unit || if ((parent_tag == llvm::dwarf::DW_TAG_compile_unit ||
parent_tag == DW_TAG_partial_unit) && parent_tag == llvm::dwarf::DW_TAG_partial_unit) &&
Language::LanguageIsCPlusPlus(GetLanguage(*die.GetCU()))) Language::LanguageIsCPlusPlus(GetLanguage(*die.GetCU())))
mangled = mangled =
GetDWARFDeclContext(die).GetQualifiedNameAsConstString().GetCString(); GetDWARFDeclContext(die).GetQualifiedNameAsConstString().GetCString();
} }
if (tag == DW_TAG_formal_parameter) if (tag == llvm::dwarf::DW_TAG_formal_parameter)
scope = eValueTypeVariableArgument; scope = eValueTypeVariableArgument;
else { else {
// DWARF doesn't specify if a DW_TAG_variable is a local, global // DWARF doesn't specify if a DW_TAG_variable is a local, global
// or static variable, so we have to do a little digging: // or static variable, so we have to do a little digging:
// 1) DW_AT_linkage_name implies static lifetime (but may be missing) // 1) DW_AT_linkage_name implies static lifetime (but may be missing)
// 2) An empty DW_AT_location is an (optimized-out) static lifetime var. // 2) An empty DW_AT_location is an (optimized-out) static lifetime var.
// 3) DW_AT_location containing a DW_OP_addr implies static lifetime. // 3) DW_AT_location containing a DW_OP_addr implies static lifetime.
// Clang likes to combine small global variables into the same symbol // Clang likes to combine small global variables into the same symbol
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines if (is_static_lifetime) {
} }
} }
} }
} }
} }
if (symbol_context_scope == nullptr) { if (symbol_context_scope == nullptr) {
switch (parent_tag) { switch (parent_tag) {
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
case DW_TAG_lexical_block: case llvm::dwarf::DW_TAG_lexical_block:
if (sc.function) { if (sc.function) {
symbol_context_scope = symbol_context_scope =
sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID()); sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
if (symbol_context_scope == nullptr) if (symbol_context_scope == nullptr)
symbol_context_scope = sc.function; symbol_context_scope = sc.function;
} }
break; break;
Show All 34 Lines return FindBlockContainingSpecification(DebugInfo().GetDIE(func_die_ref),
spec_block_die_offset); spec_block_die_offset);
} }
DWARFDIE DWARFDIE
SymbolFileDWARF::FindBlockContainingSpecification( SymbolFileDWARF::FindBlockContainingSpecification(
const DWARFDIE &die, dw_offset_t spec_block_die_offset) { const DWARFDIE &die, dw_offset_t spec_block_die_offset) {
if (die) { if (die) {
switch (die.Tag()) { switch (die.Tag()) {
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
case DW_TAG_lexical_block: { case llvm::dwarf::DW_TAG_lexical_block: {
if (die.GetReferencedDIE(DW_AT_specification).GetOffset() == if (die.GetReferencedDIE(llvm::dwarf::DW_AT_specification).GetOffset() ==
spec_block_die_offset) spec_block_die_offset)
return die; return die;
if (die.GetReferencedDIE(DW_AT_abstract_origin).GetOffset() == if (die.GetReferencedDIE(llvm::dwarf::DW_AT_abstract_origin)
spec_block_die_offset) .GetOffset() == spec_block_die_offset)
return die; return die;
} break; } break;
default: default:
break; break;
} }
// Give the concrete function die specified by "func_die_offset", find the // Give the concrete function die specified by "func_die_offset", find the
// concrete block whose DW_AT_specification or DW_AT_abstract_origin points // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
Show All 11 Lines
void SymbolFileDWARF::ParseAndAppendGlobalVariable( void SymbolFileDWARF::ParseAndAppendGlobalVariable(
const SymbolContext &sc, const DWARFDIE &die, const SymbolContext &sc, const DWARFDIE &die,
VariableList &cc_variable_list) { VariableList &cc_variable_list) {
if (!die) if (!die)
return; return;
dw_tag_t tag = die.Tag(); dw_tag_t tag = die.Tag();
if (tag != DW_TAG_variable && tag != DW_TAG_constant) if (tag != llvm::dwarf::DW_TAG_variable &&
tag != llvm::dwarf::DW_TAG_constant)
return; return;
// Check to see if we have already parsed this variable or constant? // Check to see if we have already parsed this variable or constant?
VariableSP var_sp = GetDIEToVariable()[die.GetDIE()]; VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
if (var_sp) { if (var_sp) {
cc_variable_list.AddVariableIfUnique(var_sp); cc_variable_list.AddVariableIfUnique(var_sp);
return; return;
} }
// We haven't parsed the variable yet, lets do that now. Also, let us include // We haven't parsed the variable yet, lets do that now. Also, let us include
// the variable in the relevant compilation unit's variable list, if it // the variable in the relevant compilation unit's variable list, if it
// exists. // exists.
VariableListSP variable_list_sp; VariableListSP variable_list_sp;
DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die); DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die);
dw_tag_t parent_tag = sc_parent_die.Tag(); dw_tag_t parent_tag = sc_parent_die.Tag();
switch (parent_tag) { switch (parent_tag) {
case DW_TAG_compile_unit: case llvm::dwarf::DW_TAG_compile_unit:
case DW_TAG_partial_unit: case llvm::dwarf::DW_TAG_partial_unit:
if (sc.comp_unit != nullptr) { if (sc.comp_unit != nullptr) {
variable_list_sp = sc.comp_unit->GetVariableList(false); variable_list_sp = sc.comp_unit->GetVariableList(false);
} else { } else {
GetObjectFile()->GetModule()->ReportError( GetObjectFile()->GetModule()->ReportError(
"parent 0x%8.8" PRIx64 " %s with no valid compile unit in " "parent 0x%8.8" PRIx64 " %s with no valid compile unit in "
"symbol context for 0x%8.8" PRIx64 " %s.\n", "symbol context for 0x%8.8" PRIx64 " %s.\n",
sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(), die.GetID(), sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(), die.GetID(),
die.GetTagAsCString()); die.GetTagAsCString());
Show All 26 LinesSymbolFileDWARF::MergeBlockAbstractParameters(const DWARFDIE &block_die,
// location list would be empty). The current DW_TAG_inline_subroutine may // location list would be empty). The current DW_TAG_inline_subroutine may
// refer to another DW_TAG_subprogram that might actually have the definitions // refer to another DW_TAG_subprogram that might actually have the definitions
// of the parameters and we need to include these so they show up in the // of the parameters and we need to include these so they show up in the
// variables for this function (for example, in a stack trace). Let us try to // variables for this function (for example, in a stack trace). Let us try to
// find the abstract subprogram that might contain the parameter definitions // find the abstract subprogram that might contain the parameter definitions
// and merge with the concrete parameters. // and merge with the concrete parameters.
// Nothing to merge if the block is not an inlined function. // Nothing to merge if the block is not an inlined function.
if (block_die.Tag() != DW_TAG_inlined_subroutine) { if (block_die.Tag() != llvm::dwarf::DW_TAG_inlined_subroutine) {
return std::move(variable_dies); return std::move(variable_dies);
} }
// Nothing to merge if the block does not have abstract parameters. // Nothing to merge if the block does not have abstract parameters.
DWARFDIE abs_die = block_die.GetReferencedDIE(DW_AT_abstract_origin); DWARFDIE abs_die =
if (!abs_die || abs_die.Tag() != DW_TAG_subprogram || block_die.GetReferencedDIE(llvm::dwarf::DW_AT_abstract_origin);
if (!abs_die || abs_die.Tag() != llvm::dwarf::DW_TAG_subprogram ||
!abs_die.HasChildren()) { !abs_die.HasChildren()) {
return std::move(variable_dies); return std::move(variable_dies);
} }
// For each abstract parameter, if we have its concrete counterpart, insert // For each abstract parameter, if we have its concrete counterpart, insert
// it. Otherwise, insert the abstract parameter. // it. Otherwise, insert the abstract parameter.
DIEArray::iterator concrete_it = variable_dies.begin(); DIEArray::iterator concrete_it = variable_dies.begin();
DWARFDIE abstract_child = abs_die.GetFirstChild(); DWARFDIE abstract_child = abs_die.GetFirstChild();
DIEArray merged; DIEArray merged;
bool did_merge_abstract = false; bool did_merge_abstract = false;
for (; abstract_child; abstract_child = abstract_child.GetSibling()) { for (; abstract_child; abstract_child = abstract_child.GetSibling()) {
if (abstract_child.Tag() == DW_TAG_formal_parameter) { if (abstract_child.Tag() == llvm::dwarf::DW_TAG_formal_parameter) {
if (concrete_it == variable_dies.end() || if (concrete_it == variable_dies.end() ||
GetDIE(*concrete_it).Tag() != DW_TAG_formal_parameter) { GetDIE(*concrete_it).Tag() != llvm::dwarf::DW_TAG_formal_parameter) {
// We arrived at the end of the concrete parameter list, so all // We arrived at the end of the concrete parameter list, so all
// the remaining abstract parameters must have been omitted. // the remaining abstract parameters must have been omitted.
// Let us insert them to the merged list here. // Let us insert them to the merged list here.
merged.push_back(*abstract_child.GetDIERef()); merged.push_back(*abstract_child.GetDIERef());
did_merge_abstract = true; did_merge_abstract = true;
continue; continue;
} }
DWARFDIE origin_of_concrete = DWARFDIE origin_of_concrete =
GetDIE(*concrete_it).GetReferencedDIE(DW_AT_abstract_origin); GetDIE(*concrete_it)
.GetReferencedDIE(llvm::dwarf::DW_AT_abstract_origin);
if (origin_of_concrete == abstract_child) { if (origin_of_concrete == abstract_child) {
// The current abstract parameter is the origin of the current // The current abstract parameter is the origin of the current
// concrete parameter, just push the concrete parameter. // concrete parameter, just push the concrete parameter.
merged.push_back(*concrete_it); merged.push_back(*concrete_it);
++concrete_it; ++concrete_it;
} else { } else {
// Otherwise, the parameter must have been omitted from the concrete // Otherwise, the parameter must have been omitted from the concrete
// function, so insert the abstract one. // function, so insert the abstract one.
merged.push_back(*abstract_child.GetDIERef()); merged.push_back(*abstract_child.GetDIERef());
did_merge_abstract = true; did_merge_abstract = true;
} }
} }
} }
// Shortcut if no merging happened. // Shortcut if no merging happened.
if (!did_merge_abstract) if (!did_merge_abstract)
return std::move(variable_dies); return std::move(variable_dies);
// We inserted all the abstract parameters (or their concrete counterparts). // We inserted all the abstract parameters (or their concrete counterparts).
// Let us insert all the remaining concrete variables to the merged list. // Let us insert all the remaining concrete variables to the merged list.
// During the insertion, let us check there are no remaining concrete // During the insertion, let us check there are no remaining concrete
// formal parameters. If that's the case, then just bailout from the merge - // formal parameters. If that's the case, then just bailout from the merge -
// the variable list is malformed. // the variable list is malformed.
for (; concrete_it != variable_dies.end(); ++concrete_it) { for (; concrete_it != variable_dies.end(); ++concrete_it) {
if (GetDIE(*concrete_it).Tag() == DW_TAG_formal_parameter) { if (GetDIE(*concrete_it).Tag() == llvm::dwarf::DW_TAG_formal_parameter) {
return std::move(variable_dies); return std::move(variable_dies);
} }
merged.push_back(*concrete_it); merged.push_back(*concrete_it);
} }
return merged; return merged;
} }
size_t SymbolFileDWARF::ParseVariablesInFunctionContext( size_t SymbolFileDWARF::ParseVariablesInFunctionContext(
Show All 15 Lines
// The uninserted variables for the current block are accumulated in // The uninserted variables for the current block are accumulated in
// |accumulator|. // |accumulator|.
size_t SymbolFileDWARF::ParseVariablesInFunctionContextRecursive( size_t SymbolFileDWARF::ParseVariablesInFunctionContextRecursive(
const lldb_private::SymbolContext &sc, const DWARFDIE &die, const lldb_private::SymbolContext &sc, const DWARFDIE &die,
lldb::addr_t func_low_pc, DIEArray &accumulator) { lldb::addr_t func_low_pc, DIEArray &accumulator) {
size_t vars_added = 0; size_t vars_added = 0;
dw_tag_t tag = die.Tag(); dw_tag_t tag = die.Tag();
if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) || if ((tag == llvm::dwarf::DW_TAG_variable) ||
(tag == DW_TAG_formal_parameter)) { (tag == llvm::dwarf::DW_TAG_constant) ||
(tag == llvm::dwarf::DW_TAG_formal_parameter)) {
accumulator.push_back(*die.GetDIERef()); accumulator.push_back(*die.GetDIERef());
} }
switch (tag) { switch (tag) {
case DW_TAG_subprogram: case llvm::dwarf::DW_TAG_subprogram:
case DW_TAG_inlined_subroutine: case llvm::dwarf::DW_TAG_inlined_subroutine:
case DW_TAG_lexical_block: { case llvm::dwarf::DW_TAG_lexical_block: {
// If we start a new block, compute a new block variable list and recurse. // If we start a new block, compute a new block variable list and recurse.
Block *block = Block *block =
sc.function->GetBlock(/*can_create=*/true).FindBlockByID(die.GetID()); sc.function->GetBlock(/*can_create=*/true).FindBlockByID(die.GetID());
if (block == nullptr) { if (block == nullptr) {
// This must be a specification or abstract origin with a // This must be a specification or abstract origin with a
// concrete block counterpart in the current function. We need // concrete block counterpart in the current function. We need
// to find the concrete block so we can correctly add the // to find the concrete block so we can correctly add the
// variable to it. // variable to it.
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linessize_t SymbolFileDWARF::PopulateBlockVariableList(
return variable_dies.size(); return variable_dies.size();
} }
/// Collect call site parameters in a DW_TAG_call_site DIE. /// Collect call site parameters in a DW_TAG_call_site DIE.
static CallSiteParameterArray static CallSiteParameterArray
CollectCallSiteParameters(ModuleSP module, DWARFDIE call_site_die) { CollectCallSiteParameters(ModuleSP module, DWARFDIE call_site_die) {
CallSiteParameterArray parameters; CallSiteParameterArray parameters;
for (DWARFDIE child : call_site_die.children()) { for (DWARFDIE child : call_site_die.children()) {
if (child.Tag() != DW_TAG_call_site_parameter && if (child.Tag() != llvm::dwarf::DW_TAG_call_site_parameter &&
child.Tag() != DW_TAG_GNU_call_site_parameter) child.Tag() != llvm::dwarf::DW_TAG_GNU_call_site_parameter)
continue; continue;
llvm::Optional<DWARFExpression> LocationInCallee; llvm::Optional<DWARFExpression> LocationInCallee;
llvm::Optional<DWARFExpression> LocationInCaller; llvm::Optional<DWARFExpression> LocationInCaller;
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_attributes = child.GetAttributes(attributes); const size_t num_attributes = child.GetAttributes(attributes);
Show All 11 Lines auto parse_simple_location =
uint32_t block_length = form_value.Unsigned(); uint32_t block_length = form_value.Unsigned();
return DWARFExpression(module, return DWARFExpression(module,
DataExtractor(data, block_offset, block_length), DataExtractor(data, block_offset, block_length),
child.GetCU()); child.GetCU());
}; };
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
dw_attr_t attr = attributes.AttributeAtIndex(i); dw_attr_t attr = attributes.AttributeAtIndex(i);
if (attr == DW_AT_location) if (attr == llvm::dwarf::DW_AT_location)
LocationInCallee = parse_simple_location(i); LocationInCallee = parse_simple_location(i);
if (attr == DW_AT_call_value || attr == DW_AT_GNU_call_site_value) if (attr == llvm::dwarf::DW_AT_call_value ||
attr == llvm::dwarf::DW_AT_GNU_call_site_value)
LocationInCaller = parse_simple_location(i); LocationInCaller = parse_simple_location(i);
} }
if (LocationInCallee && LocationInCaller) { if (LocationInCallee && LocationInCaller) {
CallSiteParameter param = {*LocationInCallee, *LocationInCaller}; CallSiteParameter param = {*LocationInCallee, *LocationInCaller};
parameters.push_back(param); parameters.push_back(param);
} }
} }
return parameters; return parameters;
} }
/// Collect call graph edges present in a function DIE. /// Collect call graph edges present in a function DIE.
std::vector<std::unique_ptr<lldb_private::CallEdge>> std::vector<std::unique_ptr<lldb_private::CallEdge>>
SymbolFileDWARF::CollectCallEdges(ModuleSP module, DWARFDIE function_die) { SymbolFileDWARF::CollectCallEdges(ModuleSP module, DWARFDIE function_die) {
// Check if the function has a supported call site-related attribute. // Check if the function has a supported call site-related attribute.
// TODO: In the future it may be worthwhile to support call_all_source_calls. // TODO: In the future it may be worthwhile to support call_all_source_calls.
bool has_call_edges = bool has_call_edges = function_die.GetAttributeValueAsUnsigned(
function_die.GetAttributeValueAsUnsigned(DW_AT_call_all_calls, 0) || llvm::dwarf::DW_AT_call_all_calls, 0) ||
function_die.GetAttributeValueAsUnsigned(DW_AT_GNU_all_call_sites, 0); function_die.GetAttributeValueAsUnsigned(
llvm::dwarf::DW_AT_GNU_all_call_sites, 0);
if (!has_call_edges) if (!has_call_edges)
return {}; return {};
Log *log = GetLog(LLDBLog::Step); Log *log = GetLog(LLDBLog::Step);
LLDB_LOG(log, "CollectCallEdges: Found call site info in {0}", LLDB_LOG(log, "CollectCallEdges: Found call site info in {0}",
function_die.GetPubname()); function_die.GetPubname());
// Scan the DIE for TAG_call_site entries. // Scan the DIE for TAG_call_site entries.
// TODO: A recursive scan of all blocks in the subprogram is needed in order // TODO: A recursive scan of all blocks in the subprogram is needed in order
// to be DWARF5-compliant. This may need to be done lazily to be performant. // to be DWARF5-compliant. This may need to be done lazily to be performant.
// For now, assume that all entries are nested directly under the subprogram // For now, assume that all entries are nested directly under the subprogram
// (this is the kind of DWARF LLVM produces) and parse them eagerly. // (this is the kind of DWARF LLVM produces) and parse them eagerly.
std::vector<std::unique_ptr<CallEdge>> call_edges; std::vector<std::unique_ptr<CallEdge>> call_edges;
for (DWARFDIE child : function_die.children()) { for (DWARFDIE child : function_die.children()) {
if (child.Tag() != DW_TAG_call_site && child.Tag() != DW_TAG_GNU_call_site) if (child.Tag() != llvm::dwarf::DW_TAG_call_site &&
child.Tag() != llvm::dwarf::DW_TAG_GNU_call_site)
continue; continue;
llvm::Optional<DWARFDIE> call_origin; llvm::Optional<DWARFDIE> call_origin;
llvm::Optional<DWARFExpression> call_target; llvm::Optional<DWARFExpression> call_target;
addr_t return_pc = LLDB_INVALID_ADDRESS; addr_t return_pc = LLDB_INVALID_ADDRESS;
addr_t call_inst_pc = LLDB_INVALID_ADDRESS; addr_t call_inst_pc = LLDB_INVALID_ADDRESS;
addr_t low_pc = LLDB_INVALID_ADDRESS; addr_t low_pc = LLDB_INVALID_ADDRESS;
bool tail_call = false; bool tail_call = false;
// Second DW_AT_low_pc may come from DW_TAG_subprogram referenced by // Second DW_AT_low_pc may come from DW_TAG_subprogram referenced by
// DW_TAG_GNU_call_site's DW_AT_abstract_origin overwriting our 'low_pc'. // DW_TAG_GNU_call_site's DW_AT_abstract_origin overwriting our 'low_pc'.
// So do not inherit attributes from DW_AT_abstract_origin. // So do not inherit attributes from DW_AT_abstract_origin.
DWARFAttributes attributes; DWARFAttributes attributes;
const size_t num_attributes = const size_t num_attributes =
child.GetAttributes(attributes, DWARFDIE::Recurse::no); child.GetAttributes(attributes, DWARFDIE::Recurse::no);
for (size_t i = 0; i < num_attributes; ++i) { for (size_t i = 0; i < num_attributes; ++i) {
DWARFFormValue form_value; DWARFFormValue form_value;
if (!attributes.ExtractFormValueAtIndex(i, form_value)) { if (!attributes.ExtractFormValueAtIndex(i, form_value)) {
LLDB_LOG(log, "CollectCallEdges: Could not extract TAG_call_site form"); LLDB_LOG(log, "CollectCallEdges: Could not extract TAG_call_site form");
break; break;
} }
dw_attr_t attr = attributes.AttributeAtIndex(i); dw_attr_t attr = attributes.AttributeAtIndex(i);
if (attr == DW_AT_call_tail_call || attr == DW_AT_GNU_tail_call) if (attr == llvm::dwarf::DW_AT_call_tail_call ||
attr == llvm::dwarf::DW_AT_GNU_tail_call)
tail_call = form_value.Boolean(); tail_call = form_value.Boolean();
// Extract DW_AT_call_origin (the call target's DIE). // Extract DW_AT_call_origin (the call target's DIE).
if (attr == DW_AT_call_origin || attr == DW_AT_abstract_origin) { if (attr == llvm::dwarf::DW_AT_call_origin ||
attr == llvm::dwarf::DW_AT_abstract_origin) {
call_origin = form_value.Reference(); call_origin = form_value.Reference();
if (!call_origin->IsValid()) { if (!call_origin->IsValid()) {
LLDB_LOG(log, "CollectCallEdges: Invalid call origin in {0}", LLDB_LOG(log, "CollectCallEdges: Invalid call origin in {0}",
function_die.GetPubname()); function_die.GetPubname());
break; break;
} }
} }
if (attr == DW_AT_low_pc) if (attr == llvm::dwarf::DW_AT_low_pc)
low_pc = form_value.Address(); low_pc = form_value.Address();
// Extract DW_AT_call_return_pc (the PC the call returns to) if it's // Extract DW_AT_call_return_pc (the PC the call returns to) if it's
// available. It should only ever be unavailable for tail call edges, in // available. It should only ever be unavailable for tail call edges, in
// which case use LLDB_INVALID_ADDRESS. // which case use LLDB_INVALID_ADDRESS.
if (attr == DW_AT_call_return_pc) if (attr == llvm::dwarf::DW_AT_call_return_pc)
return_pc = form_value.Address(); return_pc = form_value.Address();
// Extract DW_AT_call_pc (the PC at the call/branch instruction). It // Extract DW_AT_call_pc (the PC at the call/branch instruction). It
// should only ever be unavailable for non-tail calls, in which case use // should only ever be unavailable for non-tail calls, in which case use
// LLDB_INVALID_ADDRESS. // LLDB_INVALID_ADDRESS.
if (attr == DW_AT_call_pc) if (attr == llvm::dwarf::DW_AT_call_pc)
call_inst_pc = form_value.Address(); call_inst_pc = form_value.Address();
// Extract DW_AT_call_target (the location of the address of the indirect // Extract DW_AT_call_target (the location of the address of the indirect
// call). // call).
if (attr == DW_AT_call_target || attr == DW_AT_GNU_call_site_target) { if (attr == llvm::dwarf::DW_AT_call_target ||
attr == llvm::dwarf::DW_AT_GNU_call_site_target) {
if (!DWARFFormValue::IsBlockForm(form_value.Form())) { if (!DWARFFormValue::IsBlockForm(form_value.Form())) {
LLDB_LOG(log, LLDB_LOG(log,
"CollectCallEdges: AT_call_target does not have block form"); "CollectCallEdges: AT_call_target does not have block form");
break; break;
} }
auto data = child.GetData(); auto data = child.GetData();
uint32_t block_offset = form_value.BlockData() - data.GetDataStart(); uint32_t block_offset = form_value.BlockData() - data.GetDataStart();
▲ Show 20 Lines • Show All 180 Lines • ▼ Show 20 LinesDWARFDeclContext SymbolFileDWARF::GetDWARFDeclContext(const DWARFDIE &die) {
dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetCU())); dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetCU()));
return dwarf_decl_ctx; return dwarf_decl_ctx;
} }
LanguageType SymbolFileDWARF::LanguageTypeFromDWARF(uint64_t val) { LanguageType SymbolFileDWARF::LanguageTypeFromDWARF(uint64_t val) {
// Note: user languages between lo_user and hi_user must be handled // Note: user languages between lo_user and hi_user must be handled
// explicitly here. // explicitly here.
switch (val) { switch (val) {
case DW_LANG_Mips_Assembler: case llvm::dwarf::DW_LANG_Mips_Assembler:
return eLanguageTypeMipsAssembler; return eLanguageTypeMipsAssembler;
case DW_LANG_GOOGLE_RenderScript: case llvm::dwarf::DW_LANG_GOOGLE_RenderScript:
return eLanguageTypeExtRenderScript; return eLanguageTypeExtRenderScript;
default: default:
return static_cast<LanguageType>(val); return static_cast<LanguageType>(val);
} }
} }
LanguageType SymbolFileDWARF::GetLanguage(DWARFUnit &unit) { LanguageType SymbolFileDWARF::GetLanguage(DWARFUnit &unit) {
return LanguageTypeFromDWARF(unit.GetDWARFLanguageType()); return LanguageTypeFromDWARF(unit.GetDWARFLanguageType());
} }
LanguageType SymbolFileDWARF::GetLanguageFamily(DWARFUnit &unit) { LanguageType SymbolFileDWARF::GetLanguageFamily(DWARFUnit &unit) {
auto lang = (llvm::dwarf::SourceLanguage)unit.GetDWARFLanguageType(); auto lang = (llvm::dwarf::SourceLanguage)unit.GetDWARFLanguageType();
if (llvm::dwarf::isCPlusPlus(lang)) if (llvm::dwarf::isCPlusPlus(lang))
lang = DW_LANG_C_plus_plus; lang = llvm::dwarf::DW_LANG_C_plus_plus;
return LanguageTypeFromDWARF(lang); return LanguageTypeFromDWARF(lang);
} }
StatsDuration::Duration SymbolFileDWARF::GetDebugInfoIndexTime() { StatsDuration::Duration SymbolFileDWARF::GetDebugInfoIndexTime() {
if (m_index) if (m_index)
return m_index->GetIndexTime(); return m_index->GetIndexTime();
return {}; return {};
} }

lldb/source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp

Show All 27 Lines if (udt.m_die.Tag() == die.Tag()) {
DWARFDIE parent_pos_die = udt.m_die.GetParent(); DWARFDIE parent_pos_die = udt.m_die.GetParent();
bool match = true; bool match = true;
bool done = false; bool done = false;
while (!done && match && parent_arg_die && parent_pos_die) { while (!done && match && parent_arg_die && parent_pos_die) {
const dw_tag_t parent_arg_tag = parent_arg_die.Tag(); const dw_tag_t parent_arg_tag = parent_arg_die.Tag();
const dw_tag_t parent_pos_tag = parent_pos_die.Tag(); const dw_tag_t parent_pos_tag = parent_pos_die.Tag();
if (parent_arg_tag == parent_pos_tag) { if (parent_arg_tag == parent_pos_tag) {
switch (parent_arg_tag) { switch (parent_arg_tag) {
case DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
case DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case DW_TAG_namespace: { case llvm::dwarf::DW_TAG_namespace: {
const char *parent_arg_die_name = parent_arg_die.GetName(); const char *parent_arg_die_name = parent_arg_die.GetName();
if (parent_arg_die_name == if (parent_arg_die_name ==
nullptr) // Anonymous (i.e. no-name) struct nullptr) // Anonymous (i.e. no-name) struct
{ {
match = false; match = false;
} else { } else {
const char *parent_pos_die_name = parent_pos_die.GetName(); const char *parent_pos_die_name = parent_pos_die.GetName();
if (parent_pos_die_name == nullptr || if (parent_pos_die_name == nullptr ||
((parent_arg_die_name != parent_pos_die_name) && ((parent_arg_die_name != parent_pos_die_name) &&
strcmp(parent_arg_die_name, parent_pos_die_name))) strcmp(parent_arg_die_name, parent_pos_die_name)))
match = false; match = false;
} }
} break; } break;
case DW_TAG_compile_unit: case llvm::dwarf::DW_TAG_compile_unit:
case DW_TAG_partial_unit: case llvm::dwarf::DW_TAG_partial_unit:
done = true; done = true;
break; break;
default: default:
break; break;
} }
} }
parent_arg_die = parent_arg_die.GetParent(); parent_arg_die = parent_arg_die.GetParent();
parent_pos_die = parent_pos_die.GetParent(); parent_pos_die = parent_pos_die.GetParent();
Show All 12 Lines

lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 LinesDWARFExpression ConvertPDBLocationToDWARFExpression(
if (byte_order == eByteOrderInvalid || address_size == 0) if (byte_order == eByteOrderInvalid || address_size == 0)
return DWARFExpression(); return DWARFExpression();
RegisterKind register_kind = eRegisterKindDWARF; RegisterKind register_kind = eRegisterKindDWARF;
StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order); StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order);
switch (symbol.getLocationType()) { switch (symbol.getLocationType()) {
case PDB_LocType::Static: case PDB_LocType::Static:
case PDB_LocType::TLS: { case PDB_LocType::TLS: {
stream.PutHex8(DW_OP_addr); stream.PutHex8(llvm::dwarf::DW_OP_addr);
SectionList *section_list = module->GetSectionList(); SectionList *section_list = module->GetSectionList();
if (!section_list) if (!section_list)
return DWARFExpression(); return DWARFExpression();
uint32_t section_id = symbol.getAddressSection(); uint32_t section_id = symbol.getAddressSection();
auto section = section_list->FindSectionByID(section_id); auto section = section_list->FindSectionByID(section_id);
Show All 11 LinesDWARFExpression ConvertPDBLocationToDWARFExpression(
case PDB_LocType::RegRel: { case PDB_LocType::RegRel: {
uint32_t reg_num; uint32_t reg_num;
auto reg_id = symbol.getRegisterId(); auto reg_id = symbol.getRegisterId();
if (reg_id == llvm::codeview::RegisterId::VFRAME) { if (reg_id == llvm::codeview::RegisterId::VFRAME) {
if (auto fd = GetCorrespondingFrameData(symbol.getSession(), ranges)) { if (auto fd = GetCorrespondingFrameData(symbol.getSession(), ranges)) {
if (EmitVFrameEvaluationDWARFExpression(fd->getProgram(), arch_type, if (EmitVFrameEvaluationDWARFExpression(fd->getProgram(), arch_type,
stream)) { stream)) {
int32_t offset = symbol.getOffset(); int32_t offset = symbol.getOffset();
stream.PutHex8(DW_OP_consts); stream.PutHex8(llvm::dwarf::DW_OP_consts);
stream.PutSLEB128(offset); stream.PutSLEB128(offset);
stream.PutHex8(DW_OP_plus); stream.PutHex8(llvm::dwarf::DW_OP_plus);
register_kind = eRegisterKindLLDB; register_kind = eRegisterKindLLDB;
is_constant = false; is_constant = false;
break; break;
} }
} }
register_kind = eRegisterKindGeneric; register_kind = eRegisterKindGeneric;
reg_num = LLDB_REGNUM_GENERIC_FP; reg_num = LLDB_REGNUM_GENERIC_FP;
} else { } else {
register_kind = eRegisterKindLLDB; register_kind = eRegisterKindLLDB;
reg_num = GetLLDBRegisterNumber(arch_type, reg_id); reg_num = GetLLDBRegisterNumber(arch_type, reg_id);
if (reg_num == LLDB_INVALID_REGNUM) if (reg_num == LLDB_INVALID_REGNUM)
return DWARFExpression(); return DWARFExpression();
} }
if (reg_num > 31) { if (reg_num > 31) {
stream.PutHex8(DW_OP_bregx); stream.PutHex8(llvm::dwarf::DW_OP_bregx);
stream.PutULEB128(reg_num); stream.PutULEB128(reg_num);
} else } else
stream.PutHex8(DW_OP_breg0 + reg_num); stream.PutHex8(llvm::dwarf::DW_OP_breg0 + reg_num);
int32_t offset = symbol.getOffset(); int32_t offset = symbol.getOffset();
stream.PutSLEB128(offset); stream.PutSLEB128(offset);
is_constant = false; is_constant = false;
break; break;
} }
case PDB_LocType::Enregistered: { case PDB_LocType::Enregistered: {
register_kind = eRegisterKindLLDB; register_kind = eRegisterKindLLDB;
uint32_t reg_num = GetLLDBRegisterNumber(arch_type, symbol.getRegisterId()); uint32_t reg_num = GetLLDBRegisterNumber(arch_type, symbol.getRegisterId());
if (reg_num == LLDB_INVALID_REGNUM) if (reg_num == LLDB_INVALID_REGNUM)
return DWARFExpression(); return DWARFExpression();
if (reg_num > 31) { if (reg_num > 31) {
stream.PutHex8(DW_OP_regx); stream.PutHex8(llvm::dwarf::DW_OP_regx);
stream.PutULEB128(reg_num); stream.PutULEB128(reg_num);
} else } else
stream.PutHex8(DW_OP_reg0 + reg_num); stream.PutHex8(llvm::dwarf::DW_OP_reg0 + reg_num);
is_constant = false; is_constant = false;
break; break;
} }
case PDB_LocType::Constant: { case PDB_LocType::Constant: {
Variant value = symbol.getValue(); Variant value = symbol.getValue();
stream.PutRawBytes(&value.Value, sizeof(value.Value), stream.PutRawBytes(&value.Value, sizeof(value.Value),
Show All 15 Lines

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 937 Lines • ▼ Show 20 Lines
CompilerType TypeSystemClang::GetBuiltinTypeForDWARFEncodingAndBitSize( CompilerType TypeSystemClang::GetBuiltinTypeForDWARFEncodingAndBitSize(
llvm::StringRef type_name, uint32_t dw_ate, uint32_t bit_size) { llvm::StringRef type_name, uint32_t dw_ate, uint32_t bit_size) {
ASTContext &ast = getASTContext(); ASTContext &ast = getASTContext();
switch (dw_ate) { switch (dw_ate) {
default: default:
break; break;
case DW_ATE_address: case llvm::dwarf::DW_ATE_address:
if (QualTypeMatchesBitSize(bit_size, ast, ast.VoidPtrTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.VoidPtrTy))
return GetType(ast.VoidPtrTy); return GetType(ast.VoidPtrTy);
break; break;
case DW_ATE_boolean: case llvm::dwarf::DW_ATE_boolean:
if (QualTypeMatchesBitSize(bit_size, ast, ast.BoolTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.BoolTy))
return GetType(ast.BoolTy); return GetType(ast.BoolTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
return GetType(ast.UnsignedCharTy); return GetType(ast.UnsignedCharTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
return GetType(ast.UnsignedShortTy); return GetType(ast.UnsignedShortTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedIntTy))
return GetType(ast.UnsignedIntTy); return GetType(ast.UnsignedIntTy);
break; break;
case DW_ATE_lo_user: case llvm::dwarf::DW_ATE_lo_user:
// This has been seen to mean DW_AT_complex_integer // This has been seen to mean DW_AT_complex_integer
if (type_name.contains("complex")) { if (type_name.contains("complex")) {
CompilerType complex_int_clang_type = CompilerType complex_int_clang_type =
GetBuiltinTypeForDWARFEncodingAndBitSize("int", DW_ATE_signed, GetBuiltinTypeForDWARFEncodingAndBitSize(
bit_size / 2); "int", llvm::dwarf::DW_ATE_signed, bit_size / 2);
return GetType( return GetType(
ast.getComplexType(ClangUtil::GetQualType(complex_int_clang_type))); ast.getComplexType(ClangUtil::GetQualType(complex_int_clang_type)));
} }
break; break;
case DW_ATE_complex_float: { case llvm::dwarf::DW_ATE_complex_float: {
CanQualType FloatComplexTy = ast.getComplexType(ast.FloatTy); CanQualType FloatComplexTy = ast.getComplexType(ast.FloatTy);
if (QualTypeMatchesBitSize(bit_size, ast, FloatComplexTy)) if (QualTypeMatchesBitSize(bit_size, ast, FloatComplexTy))
return GetType(FloatComplexTy); return GetType(FloatComplexTy);
CanQualType DoubleComplexTy = ast.getComplexType(ast.DoubleTy); CanQualType DoubleComplexTy = ast.getComplexType(ast.DoubleTy);
if (QualTypeMatchesBitSize(bit_size, ast, DoubleComplexTy)) if (QualTypeMatchesBitSize(bit_size, ast, DoubleComplexTy))
return GetType(DoubleComplexTy); return GetType(DoubleComplexTy);
CanQualType LongDoubleComplexTy = ast.getComplexType(ast.LongDoubleTy); CanQualType LongDoubleComplexTy = ast.getComplexType(ast.LongDoubleTy);
if (QualTypeMatchesBitSize(bit_size, ast, LongDoubleComplexTy)) if (QualTypeMatchesBitSize(bit_size, ast, LongDoubleComplexTy))
return GetType(LongDoubleComplexTy); return GetType(LongDoubleComplexTy);
CompilerType complex_float_clang_type = CompilerType complex_float_clang_type =
GetBuiltinTypeForDWARFEncodingAndBitSize("float", DW_ATE_float, GetBuiltinTypeForDWARFEncodingAndBitSize(
bit_size / 2); "float", llvm::dwarf::DW_ATE_float, bit_size / 2);
return GetType( return GetType(
ast.getComplexType(ClangUtil::GetQualType(complex_float_clang_type))); ast.getComplexType(ClangUtil::GetQualType(complex_float_clang_type)));
} }
case DW_ATE_float: case llvm::dwarf::DW_ATE_float:
if (type_name == "float" && if (type_name == "float" &&
QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy)) QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy))
return GetType(ast.FloatTy); return GetType(ast.FloatTy);
if (type_name == "double" && if (type_name == "double" &&
QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy)) QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy))
return GetType(ast.DoubleTy); return GetType(ast.DoubleTy);
if (type_name == "long double" && if (type_name == "long double" &&
QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy)) QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy))
return GetType(ast.LongDoubleTy); return GetType(ast.LongDoubleTy);
// Fall back to not requiring a name match // Fall back to not requiring a name match
if (QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.FloatTy))
return GetType(ast.FloatTy); return GetType(ast.FloatTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.DoubleTy))
return GetType(ast.DoubleTy); return GetType(ast.DoubleTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.LongDoubleTy))
return GetType(ast.LongDoubleTy); return GetType(ast.LongDoubleTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.HalfTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.HalfTy))
return GetType(ast.HalfTy); return GetType(ast.HalfTy);
break; break;
case DW_ATE_signed: case llvm::dwarf::DW_ATE_signed:
if (!type_name.empty()) { if (!type_name.empty()) {
if (type_name == "wchar_t" && if (type_name == "wchar_t" &&
QualTypeMatchesBitSize(bit_size, ast, ast.WCharTy) && QualTypeMatchesBitSize(bit_size, ast, ast.WCharTy) &&
(getTargetInfo() && (getTargetInfo() &&
TargetInfo::isTypeSigned(getTargetInfo()->getWCharType()))) TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
return GetType(ast.WCharTy); return GetType(ast.WCharTy);
if (type_name == "void" && if (type_name == "void" &&
QualTypeMatchesBitSize(bit_size, ast, ast.VoidTy)) QualTypeMatchesBitSize(bit_size, ast, ast.VoidTy))
Show All 30 Lines case llvm::dwarf::DW_ATE_signed:
if (QualTypeMatchesBitSize(bit_size, ast, ast.LongTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.LongTy))
return GetType(ast.LongTy); return GetType(ast.LongTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.LongLongTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.LongLongTy))
return GetType(ast.LongLongTy); return GetType(ast.LongLongTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.Int128Ty)) if (QualTypeMatchesBitSize(bit_size, ast, ast.Int128Ty))
return GetType(ast.Int128Ty); return GetType(ast.Int128Ty);
break; break;
case DW_ATE_signed_char: case llvm::dwarf::DW_ATE_signed_char:
if (ast.getLangOpts().CharIsSigned && type_name == "char") { if (ast.getLangOpts().CharIsSigned && type_name == "char") {
if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
return GetType(ast.CharTy); return GetType(ast.CharTy);
} }
if (QualTypeMatchesBitSize(bit_size, ast, ast.SignedCharTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.SignedCharTy))
return GetType(ast.SignedCharTy); return GetType(ast.SignedCharTy);
break; break;
case DW_ATE_unsigned: case llvm::dwarf::DW_ATE_unsigned:
if (!type_name.empty()) { if (!type_name.empty()) {
if (type_name == "wchar_t") { if (type_name == "wchar_t") {
if (QualTypeMatchesBitSize(bit_size, ast, ast.WCharTy)) { if (QualTypeMatchesBitSize(bit_size, ast, ast.WCharTy)) {
if (!(getTargetInfo() && if (!(getTargetInfo() &&
TargetInfo::isTypeSigned(getTargetInfo()->getWCharType()))) TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
return GetType(ast.WCharTy); return GetType(ast.WCharTy);
} }
} }
Show All 26 Lines case llvm::dwarf::DW_ATE_unsigned:
if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongTy))
return GetType(ast.UnsignedLongTy); return GetType(ast.UnsignedLongTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongLongTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedLongLongTy))
return GetType(ast.UnsignedLongLongTy); return GetType(ast.UnsignedLongLongTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedInt128Ty)) if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedInt128Ty))
return GetType(ast.UnsignedInt128Ty); return GetType(ast.UnsignedInt128Ty);
break; break;
case DW_ATE_unsigned_char: case llvm::dwarf::DW_ATE_unsigned_char:
if (!ast.getLangOpts().CharIsSigned && type_name == "char") { if (!ast.getLangOpts().CharIsSigned && type_name == "char") {
if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.CharTy))
return GetType(ast.CharTy); return GetType(ast.CharTy);
} }
if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedCharTy))
return GetType(ast.UnsignedCharTy); return GetType(ast.UnsignedCharTy);
if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy)) if (QualTypeMatchesBitSize(bit_size, ast, ast.UnsignedShortTy))
return GetType(ast.UnsignedShortTy); return GetType(ast.UnsignedShortTy);
break; break;
case DW_ATE_imaginary_float: case llvm::dwarf::DW_ATE_imaginary_float:
break; break;
case DW_ATE_UTF: case llvm::dwarf::DW_ATE_UTF:
switch (bit_size) { switch (bit_size) {
case 8: case 8:
return GetType(ast.Char8Ty); return GetType(ast.Char8Ty);
case 16: case 16:
return GetType(ast.Char16Ty); return GetType(ast.Char16Ty);
case 32: case 32:
return GetType(ast.Char32Ty); return GetType(ast.Char32Ty);
default: default:
▲ Show 20 Lines • Show All 6,727 Lines • ▼ Show 20 Linesbool TypeSystemClang::AddObjCClassProperty(
clang::Selector setter_sel, getter_sel; clang::Selector setter_sel, getter_sel;
if (property_setter_name) { if (property_setter_name) {
std::string property_setter_no_colon(property_setter_name, std::string property_setter_no_colon(property_setter_name,
strlen(property_setter_name) - 1); strlen(property_setter_name) - 1);
clang::IdentifierInfo *setter_ident = clang::IdentifierInfo *setter_ident =
&clang_ast.Idents.get(property_setter_no_colon); &clang_ast.Idents.get(property_setter_no_colon);
setter_sel = clang_ast.Selectors.getSelector(1, &setter_ident); setter_sel = clang_ast.Selectors.getSelector(1, &setter_ident);
} else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) { } else if (!(property_attributes & llvm::dwarf::DW_APPLE_PROPERTY_readonly)) {
std::string setter_sel_string("set"); std::string setter_sel_string("set");
setter_sel_string.push_back(::toupper(property_name[0])); setter_sel_string.push_back(::toupper(property_name[0]));
setter_sel_string.append(&property_name[1]); setter_sel_string.append(&property_name[1]);
clang::IdentifierInfo *setter_ident = clang::IdentifierInfo *setter_ident =
&clang_ast.Idents.get(setter_sel_string); &clang_ast.Idents.get(setter_sel_string);
setter_sel = clang_ast.Selectors.getSelector(1, &setter_ident); setter_sel = clang_ast.Selectors.getSelector(1, &setter_ident);
} }
property_decl->setSetterName(setter_sel); property_decl->setSetterName(setter_sel);
property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_setter); property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_setter);
if (property_getter_name != nullptr) { if (property_getter_name != nullptr) {
clang::IdentifierInfo *getter_ident = clang::IdentifierInfo *getter_ident =
&clang_ast.Idents.get(property_getter_name); &clang_ast.Idents.get(property_getter_name);
getter_sel = clang_ast.Selectors.getSelector(0, &getter_ident); getter_sel = clang_ast.Selectors.getSelector(0, &getter_ident);
} else { } else {
clang::IdentifierInfo *getter_ident = &clang_ast.Idents.get(property_name); clang::IdentifierInfo *getter_ident = &clang_ast.Idents.get(property_name);
getter_sel = clang_ast.Selectors.getSelector(0, &getter_ident); getter_sel = clang_ast.Selectors.getSelector(0, &getter_ident);
} }
property_decl->setGetterName(getter_sel); property_decl->setGetterName(getter_sel);
property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_getter); property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_getter);
if (ivar_decl) if (ivar_decl)
property_decl->setPropertyIvarDecl(ivar_decl); property_decl->setPropertyIvarDecl(ivar_decl);
if (property_attributes & DW_APPLE_PROPERTY_readonly) if (property_attributes & llvm::dwarf::DW_APPLE_PROPERTY_readonly)
property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_readonly); property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_readonly);
if (property_attributes & DW_APPLE_PROPERTY_readwrite) if (property_attributes & llvm::dwarf::DW_APPLE_PROPERTY_readwrite)
property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_readwrite); property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_readwrite);
if (property_attributes & DW_APPLE_PROPERTY_assign) if (property_attributes & llvm::dwarf::DW_APPLE_PROPERTY_assign)
property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_assign); property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_assign);
if (property_attributes & DW_APPLE_PROPERTY_retain) if (property_attributes & llvm::dwarf::DW_APPLE_PROPERTY_retain)
property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_retain); property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_retain);
if (property_attributes & DW_APPLE_PROPERTY_copy) if (property_attributes & llvm::dwarf::DW_APPLE_PROPERTY_copy)
property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_copy); property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_copy);
if (property_attributes & DW_APPLE_PROPERTY_nonatomic) if (property_attributes & llvm::dwarf::DW_APPLE_PROPERTY_nonatomic)
property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_nonatomic); property_decl->setPropertyAttributes(ObjCPropertyAttribute::kind_nonatomic);
if (property_attributes & ObjCPropertyAttribute::kind_nullability) if (property_attributes & ObjCPropertyAttribute::kind_nullability)
property_decl->setPropertyAttributes( property_decl->setPropertyAttributes(
ObjCPropertyAttribute::kind_nullability); ObjCPropertyAttribute::kind_nullability);
if (property_attributes & ObjCPropertyAttribute::kind_null_resettable) if (property_attributes & ObjCPropertyAttribute::kind_null_resettable)
property_decl->setPropertyAttributes( property_decl->setPropertyAttributes(
ObjCPropertyAttribute::kind_null_resettable); ObjCPropertyAttribute::kind_null_resettable);
if (property_attributes & ObjCPropertyAttribute::kind_class) if (property_attributes & ObjCPropertyAttribute::kind_class)
▲ Show 20 Lines • Show All 2,007 Lines • Show Last 20 Lines

lldb/source/Symbol/DWARFCallFrameInfo.cpp

Show All 28 Lines
// //
// Used for calls when the value type is specified by a DWARF EH Frame pointer // Used for calls when the value type is specified by a DWARF EH Frame pointer
// encoding. // encoding.
static uint64_t static uint64_t
GetGNUEHPointer(const DataExtractor &DE, offset_t *offset_ptr, GetGNUEHPointer(const DataExtractor &DE, offset_t *offset_ptr,
uint32_t eh_ptr_enc, addr_t pc_rel_addr, addr_t text_addr, uint32_t eh_ptr_enc, addr_t pc_rel_addr, addr_t text_addr,
addr_t data_addr) //, BSDRelocs *data_relocs) const addr_t data_addr) //, BSDRelocs *data_relocs) const
{ {
if (eh_ptr_enc == DW_EH_PE_omit) if (eh_ptr_enc == llvm::dwarf::DW_EH_PE_omit)
return ULLONG_MAX; // Value isn't in the buffer... return ULLONG_MAX; // Value isn't in the buffer...
uint64_t baseAddress = 0; uint64_t baseAddress = 0;
uint64_t addressValue = 0; uint64_t addressValue = 0;
const uint32_t addr_size = DE.GetAddressByteSize(); const uint32_t addr_size = DE.GetAddressByteSize();
assert(addr_size == 4 || addr_size == 8); assert(addr_size == 4 || addr_size == 8);
bool signExtendValue = false; bool signExtendValue = false;
// Decode the base part or adjust our offset // Decode the base part or adjust our offset
switch (eh_ptr_enc & 0x70) { switch (eh_ptr_enc & 0x70) {
case DW_EH_PE_pcrel: case llvm::dwarf::DW_EH_PE_pcrel:
signExtendValue = true; signExtendValue = true;
baseAddress = *offset_ptr; baseAddress = *offset_ptr;
if (pc_rel_addr != LLDB_INVALID_ADDRESS) if (pc_rel_addr != LLDB_INVALID_ADDRESS)
baseAddress += pc_rel_addr; baseAddress += pc_rel_addr;
// else // else
// Log::GlobalWarning ("PC relative pointer encoding found with // Log::GlobalWarning ("PC relative pointer encoding found with
// invalid pc relative address."); // invalid pc relative address.");
break; break;
case DW_EH_PE_textrel: case llvm::dwarf::DW_EH_PE_textrel:
signExtendValue = true; signExtendValue = true;
if (text_addr != LLDB_INVALID_ADDRESS) if (text_addr != LLDB_INVALID_ADDRESS)
baseAddress = text_addr; baseAddress = text_addr;
// else // else
// Log::GlobalWarning ("text relative pointer encoding being // Log::GlobalWarning ("text relative pointer encoding being
// decoded with invalid text section address, setting base address // decoded with invalid text section address, setting base address
// to zero."); // to zero.");
break; break;
case DW_EH_PE_datarel: case llvm::dwarf::DW_EH_PE_datarel:
signExtendValue = true; signExtendValue = true;
if (data_addr != LLDB_INVALID_ADDRESS) if (data_addr != LLDB_INVALID_ADDRESS)
baseAddress = data_addr; baseAddress = data_addr;
// else // else
// Log::GlobalWarning ("data relative pointer encoding being // Log::GlobalWarning ("data relative pointer encoding being
// decoded with invalid data section address, setting base address // decoded with invalid data section address, setting base address
// to zero."); // to zero.");
break; break;
case DW_EH_PE_funcrel: case llvm::dwarf::DW_EH_PE_funcrel:
signExtendValue = true; signExtendValue = true;
break; break;
case DW_EH_PE_aligned: { case llvm::dwarf::DW_EH_PE_aligned: {
// SetPointerSize should be called prior to extracting these so the pointer // SetPointerSize should be called prior to extracting these so the pointer
// size is cached // size is cached
assert(addr_size != 0); assert(addr_size != 0);
if (addr_size) { if (addr_size) {
// Align to a address size boundary first // Align to a address size boundary first
uint32_t alignOffset = *offset_ptr % addr_size; uint32_t alignOffset = *offset_ptr % addr_size;
if (alignOffset) if (alignOffset)
offset_ptr += addr_size - alignOffset; offset_ptr += addr_size - alignOffset;
} }
} break; } break;
default: default:
break; break;
} }
// Decode the value part // Decode the value part
switch (eh_ptr_enc & DW_EH_PE_MASK_ENCODING) { switch (eh_ptr_enc & DW_EH_PE_MASK_ENCODING) {
case DW_EH_PE_absptr: { case llvm::dwarf::DW_EH_PE_absptr: {
addressValue = DE.GetAddress(offset_ptr); addressValue = DE.GetAddress(offset_ptr);
// if (data_relocs) // if (data_relocs)
// addressValue = data_relocs->Relocate(*offset_ptr - // addressValue = data_relocs->Relocate(*offset_ptr -
// addr_size, *this, addressValue); // addr_size, *this, addressValue);
} break; } break;
case DW_EH_PE_uleb128: case llvm::dwarf::DW_EH_PE_uleb128:
addressValue = DE.GetULEB128(offset_ptr); addressValue = DE.GetULEB128(offset_ptr);
break; break;
case DW_EH_PE_udata2: case llvm::dwarf::DW_EH_PE_udata2:
addressValue = DE.GetU16(offset_ptr); addressValue = DE.GetU16(offset_ptr);
break; break;
case DW_EH_PE_udata4: case llvm::dwarf::DW_EH_PE_udata4:
addressValue = DE.GetU32(offset_ptr); addressValue = DE.GetU32(offset_ptr);
break; break;
case DW_EH_PE_udata8: case llvm::dwarf::DW_EH_PE_udata8:
addressValue = DE.GetU64(offset_ptr); addressValue = DE.GetU64(offset_ptr);
break; break;
case DW_EH_PE_sleb128: case llvm::dwarf::DW_EH_PE_sleb128:
addressValue = DE.GetSLEB128(offset_ptr); addressValue = DE.GetSLEB128(offset_ptr);
break; break;
case DW_EH_PE_sdata2: case llvm::dwarf::DW_EH_PE_sdata2:
addressValue = (int16_t)DE.GetU16(offset_ptr); addressValue = (int16_t)DE.GetU16(offset_ptr);
break; break;
case DW_EH_PE_sdata4: case llvm::dwarf::DW_EH_PE_sdata4:
addressValue = (int32_t)DE.GetU32(offset_ptr); addressValue = (int32_t)DE.GetU32(offset_ptr);
break; break;
case DW_EH_PE_sdata8: case llvm::dwarf::DW_EH_PE_sdata8:
addressValue = (int64_t)DE.GetU64(offset_ptr); addressValue = (int64_t)DE.GetU64(offset_ptr);
break; break;
default: default:
// Unhandled encoding type // Unhandled encoding type
assert(eh_ptr_enc); assert(eh_ptr_enc);
break; break;
} }
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines if (is_64bit) {
end_offset = cie_offset + length + 4; end_offset = cie_offset + length + 4;
} }
if (length > 0 && ((m_type == DWARF && cie_id == UINT32_MAX) || if (length > 0 && ((m_type == DWARF && cie_id == UINT32_MAX) ||
(m_type == EH && cie_id == 0ul))) { (m_type == EH && cie_id == 0ul))) {
size_t i; size_t i;
// cie.offset = cie_offset; // cie.offset = cie_offset;
// cie.length = length; // cie.length = length;
// cie.cieID = cieID; // cie.cieID = cieID;
cie_sp->ptr_encoding = DW_EH_PE_absptr; // default cie_sp->ptr_encoding = llvm::dwarf::DW_EH_PE_absptr; // default
cie_sp->version = m_cfi_data.GetU8(&offset); cie_sp->version = m_cfi_data.GetU8(&offset);
if (cie_sp->version > CFI_VERSION4) { if (cie_sp->version > CFI_VERSION4) {
Host::SystemLog(Host::eSystemLogError, Host::SystemLog(Host::eSystemLogError,
"CIE parse error: CFI version %d is not supported\n", "CIE parse error: CFI version %d is not supported\n",
cie_sp->version); cie_sp->version);
return nullptr; return nullptr;
} }
▲ Show 20 Lines • Show All 307 Lines • ▼ Show 20 Linesbool DWARFCallFrameInfo::FDEToUnwindPlan(dw_offset_t dwarf_offset,
AddressRange range(range_base, m_objfile.GetAddressByteSize(), AddressRange range(range_base, m_objfile.GetAddressByteSize(),
m_objfile.GetSectionList()); m_objfile.GetSectionList());
range.SetByteSize(range_len); range.SetByteSize(range_len);
addr_t lsda_data_file_address = LLDB_INVALID_ADDRESS; addr_t lsda_data_file_address = LLDB_INVALID_ADDRESS;
if (cie->augmentation[0] == 'z') { if (cie->augmentation[0] == 'z') {
uint32_t aug_data_len = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t aug_data_len = (uint32_t)m_cfi_data.GetULEB128(&offset);
if (aug_data_len != 0 && cie->lsda_addr_encoding != DW_EH_PE_omit) { if (aug_data_len != 0 &&
cie->lsda_addr_encoding != llvm::dwarf::DW_EH_PE_omit) {
offset_t saved_offset = offset; offset_t saved_offset = offset;
lsda_data_file_address = lsda_data_file_address =
GetGNUEHPointer(m_cfi_data, &offset, cie->lsda_addr_encoding, GetGNUEHPointer(m_cfi_data, &offset, cie->lsda_addr_encoding,
pc_rel_addr, text_addr, data_addr); pc_rel_addr, text_addr, data_addr);
if (offset - saved_offset != aug_data_len) { if (offset - saved_offset != aug_data_len) {
// There is more in the augmentation region than we know how to process; // There is more in the augmentation region than we know how to process;
// don't read anything. // don't read anything.
lsda_data_file_address = LLDB_INVALID_ADDRESS; lsda_data_file_address = LLDB_INVALID_ADDRESS;
Show All 39 Lines while (m_cfi_data.ValidOffset(offset) && offset < end_offset) {
uint8_t inst = m_cfi_data.GetU8(&offset); uint8_t inst = m_cfi_data.GetU8(&offset);
uint8_t primary_opcode = inst & 0xC0; uint8_t primary_opcode = inst & 0xC0;
uint8_t extended_opcode = inst & 0x3F; uint8_t extended_opcode = inst & 0x3F;
if (!HandleCommonDwarfOpcode(primary_opcode, extended_opcode, data_align, if (!HandleCommonDwarfOpcode(primary_opcode, extended_opcode, data_align,
offset, *row)) { offset, *row)) {
if (primary_opcode) { if (primary_opcode) {
switch (primary_opcode) { switch (primary_opcode) {
case DW_CFA_advance_loc: // (Row Creation Instruction) case llvm::dwarf::DW_CFA_advance_loc: // (Row Creation Instruction)
{ // 0x40 - high 2 bits are 0x1, lower 6 bits are delta { // 0x40 - high 2 bits are 0x1, lower 6 bits are delta
// takes a single argument that represents a constant delta. The // takes a single argument that represents a constant delta. The
// required action is to create a new table row with a location value // required action is to create a new table row with a location value
// that is computed by taking the current entry's location value and // that is computed by taking the current entry's location value and
// adding (delta * code_align). All other values in the new row are // adding (delta * code_align). All other values in the new row are
// initially identical to the current row. // initially identical to the current row.
unwind_plan.AppendRow(row); unwind_plan.AppendRow(row);
UnwindPlan::Row *newrow = new UnwindPlan::Row; UnwindPlan::Row *newrow = new UnwindPlan::Row;
*newrow = *row.get(); *newrow = *row.get();
row.reset(newrow); row.reset(newrow);
row->SlideOffset(extended_opcode * code_align); row->SlideOffset(extended_opcode * code_align);
break; break;
} }
case DW_CFA_restore: { // 0xC0 - high 2 bits are 0x3, lower 6 bits are case llvm::dwarf::DW_CFA_restore: { // 0xC0 - high 2 bits are 0x3, lower
// 6 bits are
// register // register
// takes a single argument that represents a register number. The // takes a single argument that represents a register number. The
// required action is to change the rule for the indicated register // required action is to change the rule for the indicated register
// to the rule assigned it by the initial_instructions in the CIE. // to the rule assigned it by the initial_instructions in the CIE.
uint32_t reg_num = extended_opcode; uint32_t reg_num = extended_opcode;
// We only keep enough register locations around to unwind what is in // We only keep enough register locations around to unwind what is in
// our thread, and these are organized by the register index in that // our thread, and these are organized by the register index in that
// state, so we need to convert our eh_frame register number from the // state, so we need to convert our eh_frame register number from the
// EH frame info, to a register index // EH frame info, to a register index
if (unwind_plan.IsValidRowIndex(0) && if (unwind_plan.IsValidRowIndex(0) &&
unwind_plan.GetRowAtIndex(0)->GetRegisterInfo(reg_num, unwind_plan.GetRowAtIndex(0)->GetRegisterInfo(reg_num,
reg_location)) reg_location))
row->SetRegisterInfo(reg_num, reg_location); row->SetRegisterInfo(reg_num, reg_location);
break; break;
} }
} }
} else { } else {
switch (extended_opcode) { switch (extended_opcode) {
case DW_CFA_set_loc: // 0x1 (Row Creation Instruction) case llvm::dwarf::DW_CFA_set_loc: // 0x1 (Row Creation Instruction)
{ {
// DW_CFA_set_loc takes a single argument that represents an address. // DW_CFA_set_loc takes a single argument that represents an address.
// The required action is to create a new table row using the // The required action is to create a new table row using the
// specified address as the location. All other values in the new row // specified address as the location. All other values in the new row
// are initially identical to the current row. The new location value // are initially identical to the current row. The new location value
// should always be greater than the current one. // should always be greater than the current one.
unwind_plan.AppendRow(row); unwind_plan.AppendRow(row);
UnwindPlan::Row *newrow = new UnwindPlan::Row; UnwindPlan::Row *newrow = new UnwindPlan::Row;
*newrow = *row.get(); *newrow = *row.get();
row.reset(newrow); row.reset(newrow);
row->SetOffset(m_cfi_data.GetAddress(&offset) - row->SetOffset(m_cfi_data.GetAddress(&offset) -
startaddr.GetFileAddress()); startaddr.GetFileAddress());
break; break;
} }
case DW_CFA_advance_loc1: // 0x2 (Row Creation Instruction) case llvm::dwarf::DW_CFA_advance_loc1: // 0x2 (Row Creation Instruction)
{ {
// takes a single uword argument that represents a constant delta. // takes a single uword argument that represents a constant delta.
// This instruction is identical to DW_CFA_advance_loc except for the // This instruction is identical to DW_CFA_advance_loc except for the
// encoding and size of the delta argument. // encoding and size of the delta argument.
unwind_plan.AppendRow(row); unwind_plan.AppendRow(row);
UnwindPlan::Row *newrow = new UnwindPlan::Row; UnwindPlan::Row *newrow = new UnwindPlan::Row;
*newrow = *row.get(); *newrow = *row.get();
row.reset(newrow); row.reset(newrow);
row->SlideOffset(m_cfi_data.GetU8(&offset) * code_align); row->SlideOffset(m_cfi_data.GetU8(&offset) * code_align);
break; break;
} }
case DW_CFA_advance_loc2: // 0x3 (Row Creation Instruction) case llvm::dwarf::DW_CFA_advance_loc2: // 0x3 (Row Creation Instruction)
{ {
// takes a single uword argument that represents a constant delta. // takes a single uword argument that represents a constant delta.
// This instruction is identical to DW_CFA_advance_loc except for the // This instruction is identical to DW_CFA_advance_loc except for the
// encoding and size of the delta argument. // encoding and size of the delta argument.
unwind_plan.AppendRow(row); unwind_plan.AppendRow(row);
UnwindPlan::Row *newrow = new UnwindPlan::Row; UnwindPlan::Row *newrow = new UnwindPlan::Row;
*newrow = *row.get(); *newrow = *row.get();
row.reset(newrow); row.reset(newrow);
row->SlideOffset(m_cfi_data.GetU16(&offset) * code_align); row->SlideOffset(m_cfi_data.GetU16(&offset) * code_align);
break; break;
} }
case DW_CFA_advance_loc4: // 0x4 (Row Creation Instruction) case llvm::dwarf::DW_CFA_advance_loc4: // 0x4 (Row Creation Instruction)
{ {
// takes a single uword argument that represents a constant delta. // takes a single uword argument that represents a constant delta.
// This instruction is identical to DW_CFA_advance_loc except for the // This instruction is identical to DW_CFA_advance_loc except for the
// encoding and size of the delta argument. // encoding and size of the delta argument.
unwind_plan.AppendRow(row); unwind_plan.AppendRow(row);
UnwindPlan::Row *newrow = new UnwindPlan::Row; UnwindPlan::Row *newrow = new UnwindPlan::Row;
*newrow = *row.get(); *newrow = *row.get();
row.reset(newrow); row.reset(newrow);
row->SlideOffset(m_cfi_data.GetU32(&offset) * code_align); row->SlideOffset(m_cfi_data.GetU32(&offset) * code_align);
break; break;
} }
case DW_CFA_restore_extended: // 0x6 case llvm::dwarf::DW_CFA_restore_extended: // 0x6
{ {
// takes a single unsigned LEB128 argument that represents a register // takes a single unsigned LEB128 argument that represents a register
// number. This instruction is identical to DW_CFA_restore except for // number. This instruction is identical to DW_CFA_restore except for
// the encoding and size of the register argument. // the encoding and size of the register argument.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
if (unwind_plan.IsValidRowIndex(0) && if (unwind_plan.IsValidRowIndex(0) &&
unwind_plan.GetRowAtIndex(0)->GetRegisterInfo(reg_num, unwind_plan.GetRowAtIndex(0)->GetRegisterInfo(reg_num,
reg_location)) reg_location))
row->SetRegisterInfo(reg_num, reg_location); row->SetRegisterInfo(reg_num, reg_location);
break; break;
} }
case DW_CFA_remember_state: // 0xA case llvm::dwarf::DW_CFA_remember_state: // 0xA
{ {
// These instructions define a stack of information. Encountering the // These instructions define a stack of information. Encountering the
// DW_CFA_remember_state instruction means to save the rules for // DW_CFA_remember_state instruction means to save the rules for
// every register on the current row on the stack. Encountering the // every register on the current row on the stack. Encountering the
// DW_CFA_restore_state instruction means to pop the set of rules off // DW_CFA_restore_state instruction means to pop the set of rules off
// the stack and place them in the current row. (This operation is // the stack and place them in the current row. (This operation is
// useful for compilers that move epilogue code into the body of a // useful for compilers that move epilogue code into the body of a
// function.) // function.)
stack.push_back(row); stack.push_back(row);
UnwindPlan::Row *newrow = new UnwindPlan::Row; UnwindPlan::Row *newrow = new UnwindPlan::Row;
*newrow = *row.get(); *newrow = *row.get();
row.reset(newrow); row.reset(newrow);
break; break;
} }
case DW_CFA_restore_state: // 0xB case llvm::dwarf::DW_CFA_restore_state: // 0xB
{ {
// These instructions define a stack of information. Encountering the // These instructions define a stack of information. Encountering the
// DW_CFA_remember_state instruction means to save the rules for // DW_CFA_remember_state instruction means to save the rules for
// every register on the current row on the stack. Encountering the // every register on the current row on the stack. Encountering the
// DW_CFA_restore_state instruction means to pop the set of rules off // DW_CFA_restore_state instruction means to pop the set of rules off
// the stack and place them in the current row. (This operation is // the stack and place them in the current row. (This operation is
// useful for compilers that move epilogue code into the body of a // useful for compilers that move epilogue code into the body of a
// function.) // function.)
if (stack.empty()) { if (stack.empty()) {
LLDB_LOGF(log, LLDB_LOGF(log,
"DWARFCallFrameInfo::%s(dwarf_offset: %" PRIx32 "DWARFCallFrameInfo::%s(dwarf_offset: %" PRIx32
", startaddr: %" PRIx64 ", startaddr: %" PRIx64
" encountered DW_CFA_restore_state but state stack " " encountered DW_CFA_restore_state but state stack "
"is empty. Corrupt unwind info?", "is empty. Corrupt unwind info?",
__FUNCTION__, dwarf_offset, startaddr.GetFileAddress()); __FUNCTION__, dwarf_offset, startaddr.GetFileAddress());
break; break;
} }
lldb::addr_t offset = row->GetOffset(); lldb::addr_t offset = row->GetOffset();
row = stack.back(); row = stack.back();
stack.pop_back(); stack.pop_back();
row->SetOffset(offset); row->SetOffset(offset);
break; break;
} }
case DW_CFA_GNU_args_size: // 0x2e case llvm::dwarf::DW_CFA_GNU_args_size: // 0x2e
{ {
// The DW_CFA_GNU_args_size instruction takes an unsigned LEB128 // The DW_CFA_GNU_args_size instruction takes an unsigned LEB128
// operand representing an argument size. This instruction specifies // operand representing an argument size. This instruction specifies
// the total of the size of the arguments which have been pushed onto // the total of the size of the arguments which have been pushed onto
// the stack. // the stack.
// TODO: Figure out how we should handle this. // TODO: Figure out how we should handle this.
m_cfi_data.GetULEB128(&offset); m_cfi_data.GetULEB128(&offset);
break; break;
} }
case DW_CFA_val_offset: // 0x14 case llvm::dwarf::DW_CFA_val_offset: // 0x14
case DW_CFA_val_offset_sf: // 0x15 case llvm::dwarf::DW_CFA_val_offset_sf: // 0x15
default: default:
break; break;
} }
} }
} }
} }
unwind_plan.AppendRow(row); unwind_plan.AppendRow(row);
return true; return true;
} }
bool DWARFCallFrameInfo::HandleCommonDwarfOpcode(uint8_t primary_opcode, bool DWARFCallFrameInfo::HandleCommonDwarfOpcode(uint8_t primary_opcode,
uint8_t extended_opcode, uint8_t extended_opcode,
int32_t data_align, int32_t data_align,
lldb::offset_t &offset, lldb::offset_t &offset,
UnwindPlan::Row &row) { UnwindPlan::Row &row) {
UnwindPlan::Row::RegisterLocation reg_location; UnwindPlan::Row::RegisterLocation reg_location;
if (primary_opcode) { if (primary_opcode) {
switch (primary_opcode) { switch (primary_opcode) {
case DW_CFA_offset: { // 0x80 - high 2 bits are 0x2, lower 6 bits are case llvm::dwarf::DW_CFA_offset: { // 0x80 - high 2 bits are 0x2, lower 6
// bits are
// register // register
// takes two arguments: an unsigned LEB128 constant representing a // takes two arguments: an unsigned LEB128 constant representing a
// factored offset and a register number. The required action is to // factored offset and a register number. The required action is to
// change the rule for the register indicated by the register number to // change the rule for the register indicated by the register number to
// be an offset(N) rule with a value of (N = factored offset * // be an offset(N) rule with a value of (N = factored offset *
// data_align). // data_align).
uint8_t reg_num = extended_opcode; uint8_t reg_num = extended_opcode;
int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset) * data_align; int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset) * data_align;
reg_location.SetAtCFAPlusOffset(op_offset); reg_location.SetAtCFAPlusOffset(op_offset);
row.SetRegisterInfo(reg_num, reg_location); row.SetRegisterInfo(reg_num, reg_location);
return true; return true;
} }
} }
} else { } else {
switch (extended_opcode) { switch (extended_opcode) {
case DW_CFA_nop: // 0x0 case llvm::dwarf::DW_CFA_nop: // 0x0
return true; return true;
case DW_CFA_offset_extended: // 0x5 case llvm::dwarf::DW_CFA_offset_extended: // 0x5
{ {
// takes two unsigned LEB128 arguments representing a register number and // takes two unsigned LEB128 arguments representing a register number and
// a factored offset. This instruction is identical to DW_CFA_offset // a factored offset. This instruction is identical to
// except for the encoding and size of the register argument. // llvm::dwarf::DW_CFA_offset except for the encoding and size of the
// register argument.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset) * data_align; int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset) * data_align;
UnwindPlan::Row::RegisterLocation reg_location; UnwindPlan::Row::RegisterLocation reg_location;
reg_location.SetAtCFAPlusOffset(op_offset); reg_location.SetAtCFAPlusOffset(op_offset);
row.SetRegisterInfo(reg_num, reg_location); row.SetRegisterInfo(reg_num, reg_location);
return true; return true;
} }
case DW_CFA_undefined: // 0x7 case llvm::dwarf::DW_CFA_undefined: // 0x7
{ {
// takes a single unsigned LEB128 argument that represents a register // takes a single unsigned LEB128 argument that represents a register
// number. The required action is to set the rule for the specified // number. The required action is to set the rule for the specified
// register to undefined. // register to undefined.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
UnwindPlan::Row::RegisterLocation reg_location; UnwindPlan::Row::RegisterLocation reg_location;
reg_location.SetUndefined(); reg_location.SetUndefined();
row.SetRegisterInfo(reg_num, reg_location); row.SetRegisterInfo(reg_num, reg_location);
return true; return true;
} }
case DW_CFA_same_value: // 0x8 case llvm::dwarf::DW_CFA_same_value: // 0x8
{ {
// takes a single unsigned LEB128 argument that represents a register // takes a single unsigned LEB128 argument that represents a register
// number. The required action is to set the rule for the specified // number. The required action is to set the rule for the specified
// register to same value. // register to same value.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
UnwindPlan::Row::RegisterLocation reg_location; UnwindPlan::Row::RegisterLocation reg_location;
reg_location.SetSame(); reg_location.SetSame();
row.SetRegisterInfo(reg_num, reg_location); row.SetRegisterInfo(reg_num, reg_location);
return true; return true;
} }
case DW_CFA_register: // 0x9 case llvm::dwarf::DW_CFA_register: // 0x9
{ {
// takes two unsigned LEB128 arguments representing register numbers. The // takes two unsigned LEB128 arguments representing register numbers. The
// required action is to set the rule for the first register to be the // required action is to set the rule for the first register to be the
// second register. // second register.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
uint32_t other_reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t other_reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
UnwindPlan::Row::RegisterLocation reg_location; UnwindPlan::Row::RegisterLocation reg_location;
reg_location.SetInRegister(other_reg_num); reg_location.SetInRegister(other_reg_num);
row.SetRegisterInfo(reg_num, reg_location); row.SetRegisterInfo(reg_num, reg_location);
return true; return true;
} }
case DW_CFA_def_cfa: // 0xC (CFA Definition Instruction) case llvm::dwarf::DW_CFA_def_cfa: // 0xC (CFA Definition Instruction)
{ {
// Takes two unsigned LEB128 operands representing a register number and // Takes two unsigned LEB128 operands representing a register number and
// a (non-factored) offset. The required action is to define the current // a (non-factored) offset. The required action is to define the current
// CFA rule to use the provided register and offset. // CFA rule to use the provided register and offset.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset); int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
row.GetCFAValue().SetIsRegisterPlusOffset(reg_num, op_offset); row.GetCFAValue().SetIsRegisterPlusOffset(reg_num, op_offset);
return true; return true;
} }
case DW_CFA_def_cfa_register: // 0xD (CFA Definition Instruction) case llvm::dwarf::DW_CFA_def_cfa_register: // 0xD (CFA Definition
// Instruction)
{ {
// takes a single unsigned LEB128 argument representing a register // takes a single unsigned LEB128 argument representing a register
// number. The required action is to define the current CFA rule to use // number. The required action is to define the current CFA rule to use
// the provided register (but to keep the old offset). // the provided register (but to keep the old offset).
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
row.GetCFAValue().SetIsRegisterPlusOffset(reg_num, row.GetCFAValue().SetIsRegisterPlusOffset(reg_num,
row.GetCFAValue().GetOffset()); row.GetCFAValue().GetOffset());
return true; return true;
} }
case DW_CFA_def_cfa_offset: // 0xE (CFA Definition Instruction) case llvm::dwarf::DW_CFA_def_cfa_offset: // 0xE (CFA Definition
// Instruction)
{ {
// Takes a single unsigned LEB128 operand representing a (non-factored) // Takes a single unsigned LEB128 operand representing a (non-factored)
// offset. The required action is to define the current CFA rule to use // offset. The required action is to define the current CFA rule to use
// the provided offset (but to keep the old register). // the provided offset (but to keep the old register).
int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset); int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
row.GetCFAValue().SetIsRegisterPlusOffset( row.GetCFAValue().SetIsRegisterPlusOffset(
row.GetCFAValue().GetRegisterNumber(), op_offset); row.GetCFAValue().GetRegisterNumber(), op_offset);
return true; return true;
} }
case DW_CFA_def_cfa_expression: // 0xF (CFA Definition Instruction) case llvm::dwarf::DW_CFA_def_cfa_expression: // 0xF (CFA Definition
// Instruction)
{ {
size_t block_len = (size_t)m_cfi_data.GetULEB128(&offset); size_t block_len = (size_t)m_cfi_data.GetULEB128(&offset);
const uint8_t *block_data = const uint8_t *block_data =
static_cast<const uint8_t *>(m_cfi_data.GetData(&offset, block_len)); static_cast<const uint8_t *>(m_cfi_data.GetData(&offset, block_len));
row.GetCFAValue().SetIsDWARFExpression(block_data, block_len); row.GetCFAValue().SetIsDWARFExpression(block_data, block_len);
return true; return true;
} }
case DW_CFA_expression: // 0x10 case llvm::dwarf::DW_CFA_expression: // 0x10
{ {
// Takes two operands: an unsigned LEB128 value representing a register // Takes two operands: an unsigned LEB128 value representing a register
// number, and a DW_FORM_block value representing a DWARF expression. The // number, and a DW_FORM_block value representing a DWARF expression. The
// required action is to change the rule for the register indicated by // required action is to change the rule for the register indicated by
// the register number to be an expression(E) rule where E is the DWARF // the register number to be an expression(E) rule where E is the DWARF
// expression. That is, the DWARF expression computes the address. The // expression. That is, the DWARF expression computes the address. The
// value of the CFA is pushed on the DWARF evaluation stack prior to // value of the CFA is pushed on the DWARF evaluation stack prior to
// execution of the DWARF expression. // execution of the DWARF expression.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
uint32_t block_len = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t block_len = (uint32_t)m_cfi_data.GetULEB128(&offset);
const uint8_t *block_data = const uint8_t *block_data =
static_cast<const uint8_t *>(m_cfi_data.GetData(&offset, block_len)); static_cast<const uint8_t *>(m_cfi_data.GetData(&offset, block_len));
UnwindPlan::Row::RegisterLocation reg_location; UnwindPlan::Row::RegisterLocation reg_location;
reg_location.SetAtDWARFExpression(block_data, block_len); reg_location.SetAtDWARFExpression(block_data, block_len);
row.SetRegisterInfo(reg_num, reg_location); row.SetRegisterInfo(reg_num, reg_location);
return true; return true;
} }
case DW_CFA_offset_extended_sf: // 0x11 case llvm::dwarf::DW_CFA_offset_extended_sf: // 0x11
{ {
// takes two operands: an unsigned LEB128 value representing a register // takes two operands: an unsigned LEB128 value representing a register
// number and a signed LEB128 factored offset. This instruction is // number and a signed LEB128 factored offset. This instruction is
// identical to DW_CFA_offset_extended except that the second operand is // identical to DW_CFA_offset_extended except that the second operand is
// signed and factored. // signed and factored.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align; int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
UnwindPlan::Row::RegisterLocation reg_location; UnwindPlan::Row::RegisterLocation reg_location;
reg_location.SetAtCFAPlusOffset(op_offset); reg_location.SetAtCFAPlusOffset(op_offset);
row.SetRegisterInfo(reg_num, reg_location); row.SetRegisterInfo(reg_num, reg_location);
return true; return true;
} }
case DW_CFA_def_cfa_sf: // 0x12 (CFA Definition Instruction) case llvm::dwarf::DW_CFA_def_cfa_sf: // 0x12 (CFA Definition Instruction)
{ {
// Takes two operands: an unsigned LEB128 value representing a register // Takes two operands: an unsigned LEB128 value representing a register
// number and a signed LEB128 factored offset. This instruction is // number and a signed LEB128 factored offset. This instruction is
// identical to DW_CFA_def_cfa except that the second operand is signed // identical to DW_CFA_def_cfa except that the second operand is signed
// and factored. // and factored.
uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset); uint32_t reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align; int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
row.GetCFAValue().SetIsRegisterPlusOffset(reg_num, op_offset); row.GetCFAValue().SetIsRegisterPlusOffset(reg_num, op_offset);
return true; return true;
} }
case DW_CFA_def_cfa_offset_sf: // 0x13 (CFA Definition Instruction) case llvm::dwarf::DW_CFA_def_cfa_offset_sf: // 0x13 (CFA Definition
// Instruction)
{ {
// takes a signed LEB128 operand representing a factored offset. This // takes a signed LEB128 operand representing a factored offset. This
// instruction is identical to DW_CFA_def_cfa_offset except that the // instruction is identical to DW_CFA_def_cfa_offset except that the
// operand is signed and factored. // operand is signed and factored.
int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align; int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
uint32_t cfa_regnum = row.GetCFAValue().GetRegisterNumber(); uint32_t cfa_regnum = row.GetCFAValue().GetRegisterNumber();
row.GetCFAValue().SetIsRegisterPlusOffset(cfa_regnum, op_offset); row.GetCFAValue().SetIsRegisterPlusOffset(cfa_regnum, op_offset);
return true; return true;
} }
case DW_CFA_val_expression: // 0x16 case llvm::dwarf::DW_CFA_val_expression: // 0x16
{ {
// takes two operands: an unsigned LEB128 value representing a register // takes two operands: an unsigned LEB128 value representing a register
// number, and a DW_FORM_block value representing a DWARF expression. The // number, and a DW_FORM_block value representing a DWARF expression. The
// required action is to change the rule for the register indicated by // required action is to change the rule for the register indicated by
// the register number to be a val_expression(E) rule where E is the // the register number to be a val_expression(E) rule where E is the
// DWARF expression. That is, the DWARF expression computes the value of // DWARF expression. That is, the DWARF expression computes the value of
// the given register. The value of the CFA is pushed on the DWARF // the given register. The value of the CFA is pushed on the DWARF
// evaluation stack prior to execution of the DWARF expression. // evaluation stack prior to execution of the DWARF expression.
Show All 23 Lines

lldb/source/Symbol/PostfixExpression.cpp

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Linespublic:
using Visitor<>::Dispatch; using Visitor<>::Dispatch;
private: private:
void Visit(BinaryOpNode &binary, Node *&) override; void Visit(BinaryOpNode &binary, Node *&) override;
void Visit(InitialValueNode &val, Node *&) override; void Visit(InitialValueNode &val, Node *&) override;
void Visit(IntegerNode &integer, Node *&) override { void Visit(IntegerNode &integer, Node *&) override {
m_out_stream.PutHex8(DW_OP_consts); m_out_stream.PutHex8(llvm::dwarf::DW_OP_consts);
m_out_stream.PutSLEB128(integer.GetValue()); m_out_stream.PutSLEB128(integer.GetValue());
++m_stack_depth; ++m_stack_depth;
} }
void Visit(RegisterNode &reg, Node *&) override; void Visit(RegisterNode &reg, Node *&) override;
void Visit(SymbolNode &symbol, Node *&) override { void Visit(SymbolNode &symbol, Node *&) override {
llvm_unreachable("Symbols should have been resolved by now!"); llvm_unreachable("Symbols should have been resolved by now!");
Show All 15 Lines
} // namespace } // namespace
void DWARFCodegen::Visit(BinaryOpNode &binary, Node *&) { void DWARFCodegen::Visit(BinaryOpNode &binary, Node *&) {
Dispatch(binary.Left()); Dispatch(binary.Left());
Dispatch(binary.Right()); Dispatch(binary.Right());
switch (binary.GetOpType()) { switch (binary.GetOpType()) {
case BinaryOpNode::Plus: case BinaryOpNode::Plus:
m_out_stream.PutHex8(DW_OP_plus); m_out_stream.PutHex8(llvm::dwarf::DW_OP_plus);
// NOTE: can be optimized by using DW_OP_plus_uconst opcpode // NOTE: can be optimized by using DW_OP_plus_uconst opcpode
// if right child node is constant value // if right child node is constant value
break; break;
case BinaryOpNode::Minus: case BinaryOpNode::Minus:
m_out_stream.PutHex8(DW_OP_minus); m_out_stream.PutHex8(llvm::dwarf::DW_OP_minus);
break; break;
case BinaryOpNode::Align: case BinaryOpNode::Align:
// emit align operator a @ b as // emit align operator a @ b as
// a & ~(b - 1) // a & ~(b - 1)
// NOTE: implicitly assuming that b is power of 2 // NOTE: implicitly assuming that b is power of 2
m_out_stream.PutHex8(DW_OP_lit1); m_out_stream.PutHex8(llvm::dwarf::DW_OP_lit1);
m_out_stream.PutHex8(DW_OP_minus); m_out_stream.PutHex8(llvm::dwarf::DW_OP_minus);
m_out_stream.PutHex8(DW_OP_not); m_out_stream.PutHex8(llvm::dwarf::DW_OP_not);
m_out_stream.PutHex8(DW_OP_and); m_out_stream.PutHex8(llvm::dwarf::DW_OP_and);
break; break;
} }
--m_stack_depth; // Two pops, one push. --m_stack_depth; // Two pops, one push.
} }
void DWARFCodegen::Visit(InitialValueNode &, Node *&) { void DWARFCodegen::Visit(InitialValueNode &, Node *&) {
// We never go below the initial stack, so we can pick the initial value from // We never go below the initial stack, so we can pick the initial value from
// the bottom of the stack at any moment. // the bottom of the stack at any moment.
assert(m_stack_depth >= 1); assert(m_stack_depth >= 1);
m_out_stream.PutHex8(DW_OP_pick); m_out_stream.PutHex8(llvm::dwarf::DW_OP_pick);
m_out_stream.PutHex8(m_stack_depth - 1); m_out_stream.PutHex8(m_stack_depth - 1);
++m_stack_depth; ++m_stack_depth;
} }
void DWARFCodegen::Visit(RegisterNode &reg, Node *&) { void DWARFCodegen::Visit(RegisterNode &reg, Node *&) {
uint32_t reg_num = reg.GetRegNum(); uint32_t reg_num = reg.GetRegNum();
assert(reg_num != LLDB_INVALID_REGNUM); assert(reg_num != LLDB_INVALID_REGNUM);
if (reg_num > 31) { if (reg_num > 31) {
m_out_stream.PutHex8(DW_OP_bregx); m_out_stream.PutHex8(llvm::dwarf::DW_OP_bregx);
m_out_stream.PutULEB128(reg_num); m_out_stream.PutULEB128(reg_num);
} else } else
m_out_stream.PutHex8(DW_OP_breg0 + reg_num); m_out_stream.PutHex8(llvm::dwarf::DW_OP_breg0 + reg_num);
m_out_stream.PutSLEB128(0); m_out_stream.PutSLEB128(0);
++m_stack_depth; ++m_stack_depth;
} }
void DWARFCodegen::Visit(UnaryOpNode &unary, Node *&) { void DWARFCodegen::Visit(UnaryOpNode &unary, Node *&) {
Dispatch(unary.Operand()); Dispatch(unary.Operand());
switch (unary.GetOpType()) { switch (unary.GetOpType()) {
case UnaryOpNode::Deref: case UnaryOpNode::Deref:
m_out_stream.PutHex8(DW_OP_deref); m_out_stream.PutHex8(llvm::dwarf::DW_OP_deref);
break; break;
} }
// Stack depth unchanged. // Stack depth unchanged.
} }
bool postfix::ResolveSymbols( bool postfix::ResolveSymbols(
Node *&node, llvm::function_ref<Node *(SymbolNode &)> replacer) { Node *&node, llvm::function_ref<Node *(SymbolNode &)> replacer) {
return SymbolResolver(replacer).Dispatch(node); return SymbolResolver(replacer).Dispatch(node);
} }
void postfix::ToDWARF(Node &node, Stream &stream) { void postfix::ToDWARF(Node &node, Stream &stream) {
Node *ptr = &node; Node *ptr = &node;
DWARFCodegen(stream).Dispatch(ptr); DWARFCodegen(stream).Dispatch(ptr);
} }

lldb/unittests/Expression/DWARFExpressionTest.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines void TearDown() override {
platform_linux::PlatformLinux::Terminate(); platform_linux::PlatformLinux::Terminate();
HostInfo::Terminate(); HostInfo::Terminate();
FileSystem::Terminate(); FileSystem::Terminate();
repro::Reproducer::Terminate(); repro::Reproducer::Terminate();
} }
}; };
TEST(DWARFExpression, DW_OP_pick) { TEST(DWARFExpression, DW_OP_pick) {
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 0}), EXPECT_THAT_EXPECTED(
Evaluate({llvm::dwarf::DW_OP_lit1, llvm::dwarf::DW_OP_lit0,
llvm::dwarf::DW_OP_pick, 0}),
llvm::HasValue(0)); llvm::HasValue(0));
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 1}), EXPECT_THAT_EXPECTED(
Evaluate({llvm::dwarf::DW_OP_lit1, llvm::dwarf::DW_OP_lit0,
llvm::dwarf::DW_OP_pick, 1}),
llvm::HasValue(1)); llvm::HasValue(1));
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 2}), EXPECT_THAT_EXPECTED(
Evaluate({llvm::dwarf::DW_OP_lit1, llvm::dwarf::DW_OP_lit0,
llvm::dwarf::DW_OP_pick, 2}),
llvm::Failed()); llvm::Failed());
} }
TEST(DWARFExpression, DW_OP_const) { TEST(DWARFExpression, DW_OP_const) {
// Extend to address size. // Extend to address size.
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1u, 0x88}), llvm::HasValue(0x88)); EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_const1u, 0x88}),
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1s, 0x88}), llvm::HasValue(0x88));
EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_const1s, 0x88}),
llvm::HasValue(0xffffff88)); llvm::HasValue(0xffffff88));
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x47, 0x88}), EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_const2u, 0x47, 0x88}),
llvm::HasValue(0x8847)); llvm::HasValue(0x8847));
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2s, 0x47, 0x88}), EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_const2s, 0x47, 0x88}),
llvm::HasValue(0xffff8847)); llvm::HasValue(0xffff8847));
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const4u, 0x44, 0x42, 0x47, 0x88}), EXPECT_THAT_EXPECTED(
Evaluate({llvm::dwarf::DW_OP_const4u, 0x44, 0x42, 0x47, 0x88}),
llvm::HasValue(0x88474244)); llvm::HasValue(0x88474244));
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const4s, 0x44, 0x42, 0x47, 0x88}), EXPECT_THAT_EXPECTED(
Evaluate({llvm::dwarf::DW_OP_const4s, 0x44, 0x42, 0x47, 0x88}),
llvm::HasValue(0x88474244)); llvm::HasValue(0x88474244));
// Truncate to address size. // Truncate to address size.
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_const8u, 0x00, 0x11, 0x22,
Evaluate({DW_OP_const8u, 0x00, 0x11, 0x22, 0x33, 0x44, 0x42, 0x47, 0x88}), 0x33, 0x44, 0x42, 0x47, 0x88}),
llvm::HasValue(0x33221100)); llvm::HasValue(0x33221100));
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_const8s, 0x00, 0x11, 0x22,
Evaluate({DW_OP_const8s, 0x00, 0x11, 0x22, 0x33, 0x44, 0x42, 0x47, 0x88}), 0x33, 0x44, 0x42, 0x47, 0x88}),
llvm::HasValue(0x33221100)); llvm::HasValue(0x33221100));
// Don't truncate to address size for compatibility with clang (pr48087). // Don't truncate to address size for compatibility with clang (pr48087).
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_constu, 0x81, 0x82, 0x84,
Evaluate({DW_OP_constu, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, 0x40}), 0x88, 0x90, 0xa0, 0x40}),
llvm::HasValue(0x01010101010101)); llvm::HasValue(0x01010101010101));
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_consts, 0x81, 0x82, 0x84,
Evaluate({DW_OP_consts, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, 0x40}), 0x88, 0x90, 0xa0, 0x40}),
llvm::HasValue(0xffff010101010101)); llvm::HasValue(0xffff010101010101));
} }
TEST(DWARFExpression, DW_OP_convert) { TEST(DWARFExpression, DW_OP_convert) {
/// Auxiliary debug info. /// Auxiliary debug info.
const char *yamldata = R"( const char *yamldata = R"(
--- !ELF --- !ELF
FileHeader: FileHeader:
Class: ELFCLASS64 Class: ELFCLASS64
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines)";
bool not_signed = false; bool not_signed = false;
// //
// Positive tests. // Positive tests.
// //
// Leave as is. // Leave as is.
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
t.Eval({DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, // t.Eval({llvm::dwarf::DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, //
DW_OP_convert, offs_uint32_t, DW_OP_stack_value}), llvm::dwarf::DW_OP_convert, offs_uint32_t,
llvm::dwarf::DW_OP_stack_value}),
llvm::HasValue(GetScalar(64, 0x44332211, not_signed))); llvm::HasValue(GetScalar(64, 0x44332211, not_signed)));
// Zero-extend to 64 bits. // Zero-extend to 64 bits.
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
t.Eval({DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, // t.Eval({llvm::dwarf::DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, //
DW_OP_convert, offs_uint64_t, DW_OP_stack_value}), llvm::dwarf::DW_OP_convert, offs_uint64_t,
llvm::dwarf::DW_OP_stack_value}),
llvm::HasValue(GetScalar(64, 0x44332211, not_signed))); llvm::HasValue(GetScalar(64, 0x44332211, not_signed)));
// Sign-extend to 64 bits. // Sign-extend to 64 bits.
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // t.Eval({llvm::dwarf::DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, //
DW_OP_convert, offs_sint64_t, DW_OP_stack_value}), llvm::dwarf::DW_OP_convert, offs_sint64_t,
llvm::dwarf::DW_OP_stack_value}),
llvm::HasValue(GetScalar(64, 0xffffffffffeeddcc, is_signed))); llvm::HasValue(GetScalar(64, 0xffffffffffeeddcc, is_signed)));
// Sign-extend, then truncate. // Sign-extend, then truncate.
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // t.Eval({llvm::dwarf::DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, //
DW_OP_convert, offs_sint64_t, // llvm::dwarf::DW_OP_convert, offs_sint64_t, //
DW_OP_convert, offs_uint32_t, DW_OP_stack_value}), llvm::dwarf::DW_OP_convert, offs_uint32_t,
llvm::dwarf::DW_OP_stack_value}),
llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed))); llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed)));
// Truncate to default unspecified (pointer-sized) type. // Truncate to default unspecified (pointer-sized) type.
EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, // EXPECT_THAT_EXPECTED(
DW_OP_convert, offs_sint64_t, // t.Eval({llvm::dwarf::DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, //
DW_OP_convert, 0x00, DW_OP_stack_value}), llvm::dwarf::DW_OP_convert, offs_sint64_t, //
llvm::dwarf::DW_OP_convert, 0x00,
llvm::dwarf::DW_OP_stack_value}),
llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed))); llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed)));
// Truncate to 8 bits. // Truncate to 8 bits.
EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', DW_OP_convert, EXPECT_THAT_EXPECTED(t.Eval({llvm::dwarf::DW_OP_const4s, 'A', 'B', 'C', 'D',
offs_uchar, DW_OP_stack_value}), llvm::dwarf::DW_OP_convert, offs_uchar,
llvm::dwarf::DW_OP_stack_value}),
llvm::HasValue(GetScalar(8, 'A', not_signed))); llvm::HasValue(GetScalar(8, 'A', not_signed)));
// Also truncate to 8 bits. // Also truncate to 8 bits.
EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', DW_OP_convert, EXPECT_THAT_EXPECTED(t.Eval({llvm::dwarf::DW_OP_const4s, 'A', 'B', 'C', 'D',
offs_schar, DW_OP_stack_value}), llvm::dwarf::DW_OP_convert, offs_schar,
llvm::dwarf::DW_OP_stack_value}),
llvm::HasValue(GetScalar(8, 'A', is_signed))); llvm::HasValue(GetScalar(8, 'A', is_signed)));
// //
// Errors. // Errors.
// //
// No Module. // No Module.
EXPECT_THAT_ERROR(Evaluate({DW_OP_const1s, 'X', DW_OP_convert, 0x00}, nullptr, EXPECT_THAT_ERROR(Evaluate({llvm::dwarf::DW_OP_const1s, 'X',
t.GetDwarfUnit()) llvm::dwarf::DW_OP_convert, 0x00},
nullptr, t.GetDwarfUnit())
.takeError(), .takeError(),
llvm::Failed()); llvm::Failed());
// No DIE. // No DIE.
EXPECT_THAT_ERROR( EXPECT_THAT_ERROR(t.Eval({llvm::dwarf::DW_OP_const1s, 'X',
t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x01}).takeError(), llvm::dwarf::DW_OP_convert, 0x01})
.takeError(),
llvm::Failed()); llvm::Failed());
// Unsupported. // Unsupported.
EXPECT_THAT_ERROR( EXPECT_THAT_ERROR(t.Eval({llvm::dwarf::DW_OP_const1s, 'X',
t.Eval({DW_OP_const1s, 'X', DW_OP_convert, 0x1d}).takeError(), llvm::dwarf::DW_OP_convert, 0x1d})
.takeError(),
llvm::Failed()); llvm::Failed());
} }
TEST(DWARFExpression, DW_OP_stack_value) { TEST(DWARFExpression, DW_OP_stack_value) {
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_stack_value}), llvm::Failed()); EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_stack_value}),
llvm::Failed());
} }
TEST(DWARFExpression, DW_OP_piece) { TEST(DWARFExpression, DW_OP_piece) {
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x11, 0x22, DW_OP_piece, 2, EXPECT_THAT_EXPECTED(
DW_OP_const2u, 0x33, 0x44, DW_OP_piece, 2}), Evaluate({llvm::dwarf::DW_OP_const2u, 0x11, 0x22,
llvm::dwarf::DW_OP_piece, 2, llvm::dwarf::DW_OP_const2u, 0x33,
0x44, llvm::dwarf::DW_OP_piece, 2}),
llvm::HasValue(GetScalar(32, 0x44332211, true))); llvm::HasValue(GetScalar(32, 0x44332211, true)));
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
Evaluate({DW_OP_piece, 1, DW_OP_const1u, 0xff, DW_OP_piece, 1}), Evaluate({llvm::dwarf::DW_OP_piece, 1, llvm::dwarf::DW_OP_const1u, 0xff,
llvm::dwarf::DW_OP_piece, 1}),
// Note that the "00" should really be "undef", but we can't // Note that the "00" should really be "undef", but we can't
// represent that yet. // represent that yet.
llvm::HasValue(GetScalar(16, 0xff00, true))); llvm::HasValue(GetScalar(16, 0xff00, true)));
} }
TEST(DWARFExpression, DW_OP_implicit_value) { TEST(DWARFExpression, DW_OP_implicit_value) {
unsigned char bytes = 4; unsigned char bytes = 4;
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_implicit_value, bytes, 0x11,
Evaluate({DW_OP_implicit_value, bytes, 0x11, 0x22, 0x33, 0x44}), 0x22, 0x33, 0x44}),
llvm::HasValue(GetScalar(8 * bytes, 0x44332211, true))); llvm::HasValue(GetScalar(8 * bytes, 0x44332211, true)));
} }
TEST(DWARFExpression, DW_OP_unknown) { TEST(DWARFExpression, DW_OP_unknown) {
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
Evaluate({0xff}), Evaluate({0xff}),
llvm::FailedWithMessage( llvm::FailedWithMessage(
"Unhandled opcode DW_OP_unknown_ff in DWARFExpression")); "Unhandled opcode DW_OP_unknown_ff in DWARFExpression"));
} }
TEST_F(DWARFExpressionMockProcessTest, DW_OP_deref) { TEST_F(DWARFExpressionMockProcessTest, DW_OP_deref) {
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit0, DW_OP_deref}), llvm::Failed()); EXPECT_THAT_EXPECTED(
Evaluate({llvm::dwarf::DW_OP_lit0, llvm::dwarf::DW_OP_deref}),
llvm::Failed());
struct MockProcess : Process { struct MockProcess : Process {
using Process::Process; using Process::Process;
llvm::StringRef GetPluginName() override { return "mock process"; } llvm::StringRef GetPluginName() override { return "mock process"; }
bool CanDebug(lldb::TargetSP target, bool CanDebug(lldb::TargetSP target,
bool plugin_specified_by_name) override { bool plugin_specified_by_name) override {
return false; return false;
}; };
Show All 27 LinesTEST_F(DWARFExpressionMockProcessTest, DW_OP_deref) {
ASSERT_TRUE(platform_sp); ASSERT_TRUE(platform_sp);
lldb::ListenerSP listener_sp(Listener::MakeListener("dummy")); lldb::ListenerSP listener_sp(Listener::MakeListener("dummy"));
lldb::ProcessSP process_sp = lldb::ProcessSP process_sp =
std::make_shared<MockProcess>(target_sp, listener_sp); std::make_shared<MockProcess>(target_sp, listener_sp);
ASSERT_TRUE(process_sp); ASSERT_TRUE(process_sp);
ExecutionContext exe_ctx(process_sp); ExecutionContext exe_ctx(process_sp);
// Implicit location: *0x4. // Implicit location: *0x4.
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value}, EXPECT_THAT_EXPECTED(
Evaluate({llvm::dwarf::DW_OP_lit4, llvm::dwarf::DW_OP_deref,
llvm::dwarf::DW_OP_stack_value},
{}, {}, &exe_ctx), {}, {}, &exe_ctx),
llvm::HasValue(GetScalar(32, 0x07060504, false))); llvm::HasValue(GetScalar(32, 0x07060504, false)));
// Memory location: *(*0x4). // Memory location: *(*0x4).
// Evaluate returns LLDB_INVALID_ADDRESS for all load addresses. // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses.
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4, DW_OP_deref}, {}, {}, &exe_ctx), EXPECT_THAT_EXPECTED(
Evaluate({llvm::dwarf::DW_OP_lit4, llvm::dwarf::DW_OP_deref}, {}, {},
&exe_ctx),
llvm::HasValue(Scalar(LLDB_INVALID_ADDRESS))); llvm::HasValue(Scalar(LLDB_INVALID_ADDRESS)));
// Memory location: *0x4. // Memory location: *0x4.
// Evaluate returns LLDB_INVALID_ADDRESS for all load addresses. // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses.
EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4}, {}, {}, &exe_ctx), EXPECT_THAT_EXPECTED(Evaluate({llvm::dwarf::DW_OP_lit4}, {}, {}, &exe_ctx),
llvm::HasValue(Scalar(4))); llvm::HasValue(Scalar(4)));
// Implicit location: *0x4. // Implicit location: *0x4.
// Evaluate returns LLDB_INVALID_ADDRESS for all load addresses. // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses.
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value}, {}, {}, &exe_ctx), Evaluate({llvm::dwarf::DW_OP_lit4, llvm::dwarf::DW_OP_deref,
llvm::dwarf::DW_OP_stack_value},
{}, {}, &exe_ctx),
llvm::HasValue(GetScalar(32, 0x07060504, false))); llvm::HasValue(GetScalar(32, 0x07060504, false)));
} }

lldb/unittests/Process/minidump/MinidumpParserTest.cpp

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines Threads:
- Thread Id: 0x00003E81 - Thread Id: 0x00003E81
Stack: Stack:
Start of Memory Range: 0x00007FFCEB34A000 Start of Memory Range: 0x00007FFCEB34A000
Content: C84D04BCE97F00 Content: C84D04BCE97F00
Context: 00000000000000 Context: 00000000000000
... ...
)"), )"),
llvm::Succeeded()); llvm::Succeeded());
llvm::ArrayRef<minidump::Thread> thread_list; llvm::ArrayRef<llvm::minidump::Thread> thread_list;
thread_list = parser->GetThreads(); thread_list = parser->GetThreads();
ASSERT_EQ(1UL, thread_list.size()); ASSERT_EQ(1UL, thread_list.size());
const minidump::Thread &thread = thread_list[0]; const llvm::minidump::Thread &thread = thread_list[0];
EXPECT_EQ(0x3e81u, thread.ThreadId); EXPECT_EQ(0x3e81u, thread.ThreadId);
llvm::ArrayRef<uint8_t> context = parser->GetThreadContext(thread); llvm::ArrayRef<uint8_t> context = parser->GetThreadContext(thread);
EXPECT_EQ(7u, context.size()); EXPECT_EQ(7u, context.size());
} }
TEST_F(MinidumpParserTest, GetArchitecture) { TEST_F(MinidumpParserTest, GetArchitecture) {
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines Modules:
CodeView Record: 4C4570426CCF3F60FFA7CC4B86AE8FF44DB2576A68983611 CodeView Record: 4C4570426CCF3F60FFA7CC4B86AE8FF44DB2576A68983611
- Base of Image: 0x0000000000600000 - Base of Image: 0x0000000000600000
Size of Image: 0x00002000 Size of Image: 0x00002000
Module Name: '/tmp/test/linux-x86_64_not_crashed' Module Name: '/tmp/test/linux-x86_64_not_crashed'
CodeView Record: 4C4570426CCF3F60FFA7CC4B86AE8FF44DB2576A68983611 CodeView Record: 4C4570426CCF3F60FFA7CC4B86AE8FF44DB2576A68983611
... ...
)"), )"),
llvm::Succeeded()); llvm::Succeeded());
llvm::ArrayRef<minidump::Module> modules = parser->GetModuleList(); llvm::ArrayRef<llvm::minidump::Module> modules = parser->GetModuleList();
std::vector<const minidump::Module *> filtered_modules = std::vector<const llvm::minidump::Module *> filtered_modules =
parser->GetFilteredModuleList(); parser->GetFilteredModuleList();
EXPECT_EQ(2u, modules.size()); EXPECT_EQ(2u, modules.size());
ASSERT_EQ(1u, filtered_modules.size()); ASSERT_EQ(1u, filtered_modules.size());
const minidump::Module &M = *filtered_modules[0]; const llvm::minidump::Module &M = *filtered_modules[0];
EXPECT_THAT_EXPECTED(parser->GetMinidumpFile().getString(M.ModuleNameRVA), EXPECT_THAT_EXPECTED(parser->GetMinidumpFile().getString(M.ModuleNameRVA),
llvm::HasValue("/tmp/test/linux-x86_64_not_crashed")); llvm::HasValue("/tmp/test/linux-x86_64_not_crashed"));
} }
TEST_F(MinidumpParserTest, GetExceptionStream) { TEST_F(MinidumpParserTest, GetExceptionStream) {
SetUpData("linux-x86_64.dmp"); SetUpData("linux-x86_64.dmp");
const llvm::minidump::ExceptionStream *exception_stream = const llvm::minidump::ExceptionStream *exception_stream =
parser->GetExceptionStream(); parser->GetExceptionStream();
▲ Show 20 Lines • Show All 320 Lines • ▼ Show 20 Lines Threads:
- Thread Id: 0x00026804 - Thread Id: 0x00026804
Stack: Stack:
Start of Memory Range: 0x00000000FF9DD000 Start of Memory Range: 0x00000000FF9DD000
Content: 68D39DFF Content: 68D39DFF
Context: 0F0001000000000000000000000000000000000000000000000000007F03FFFF0000FFFFFFFFFFFF09DC62F72300000088E36CF72B00FFFF00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000063000000000000002B0000002B000000A88204085CD59DFF008077F7A3D49DFF01000000000000003CD59DFFA082040823000000820201002CD59DFF2B0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 Context: 0F0001000000000000000000000000000000000000000000000000007F03FFFF0000FFFFFFFFFFFF09DC62F72300000088E36CF72B00FFFF00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000063000000000000002B0000002B000000A88204085CD59DFF008077F7A3D49DFF01000000000000003CD59DFFA082040823000000820201002CD59DFF2B0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
)"), )"),
llvm::Succeeded()); llvm::Succeeded());
llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads(); llvm::ArrayRef<llvm::minidump::Thread> thread_list = parser->GetThreads();
const minidump::Thread &thread = thread_list[0]; const llvm::minidump::Thread &thread = thread_list[0];
llvm::ArrayRef<uint8_t> registers(parser->GetThreadContext(thread)); llvm::ArrayRef<uint8_t> registers(parser->GetThreadContext(thread));
const MinidumpContext_x86_32 *context; const MinidumpContext_x86_32 *context;
EXPECT_TRUE(consumeObject(registers, context).Success()); EXPECT_TRUE(consumeObject(registers, context).Success());
EXPECT_EQ(MinidumpContext_x86_32_Flags(uint32_t(context->context_flags)), EXPECT_EQ(MinidumpContext_x86_32_Flags(uint32_t(context->context_flags)),
MinidumpContext_x86_32_Flags::x86_32_Flag | MinidumpContext_x86_32_Flags::x86_32_Flag |
MinidumpContext_x86_32_Flags::Full | MinidumpContext_x86_32_Flags::Full |
MinidumpContext_x86_32_Flags::FloatingPoint); MinidumpContext_x86_32_Flags::FloatingPoint);
Show All 25 Lines Threads:
- Thread Id: 0x00003E81 - Thread Id: 0x00003E81
Stack: Stack:
Start of Memory Range: 0x00007FFCEB34A000 Start of Memory Range: 0x00007FFCEB34A000
Content: C84D04BCE97F00 Content: C84D04BCE97F00
Context: 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B0010000000000033000000000000000000000006020100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000010A234EBFC7F000010A234EBFC7F00000000000000000000F09C34EBFC7F0000C0A91ABCE97F00000000000000000000A0163FBCE97F00004602000000000000921C40000000000030A434EBFC7F000000000000000000000000000000000000C61D4000000000007F0300000000000000000000000000000000000000000000801F0000FFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFF00FFFFFFFFFFFFFF00FFFFFFFF25252525252525252525252525252525000000000000000000000000000000000000000000000000000000000000000000FFFF00FFFFFFFFFFFFFF00FFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FF00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 Context: 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B0010000000000033000000000000000000000006020100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000010A234EBFC7F000010A234EBFC7F00000000000000000000F09C34EBFC7F0000C0A91ABCE97F00000000000000000000A0163FBCE97F00004602000000000000921C40000000000030A434EBFC7F000000000000000000000000000000000000C61D4000000000007F0300000000000000000000000000000000000000000000801F0000FFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFF00FFFFFFFFFFFFFF00FFFFFFFF25252525252525252525252525252525000000000000000000000000000000000000000000000000000000000000000000FFFF00FFFFFFFFFFFFFF00FFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FF00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
... ...
)"), )"),
llvm::Succeeded()); llvm::Succeeded());
llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads(); llvm::ArrayRef<llvm::minidump::Thread> thread_list = parser->GetThreads();
const minidump::Thread &thread = thread_list[0]; const llvm::minidump::Thread &thread = thread_list[0];
llvm::ArrayRef<uint8_t> registers(parser->GetThreadContext(thread)); llvm::ArrayRef<uint8_t> registers(parser->GetThreadContext(thread));
const MinidumpContext_x86_64 *context; const MinidumpContext_x86_64 *context;
EXPECT_TRUE(consumeObject(registers, context).Success()); EXPECT_TRUE(consumeObject(registers, context).Success());
EXPECT_EQ(MinidumpContext_x86_64_Flags(uint32_t(context->context_flags)), EXPECT_EQ(MinidumpContext_x86_64_Flags(uint32_t(context->context_flags)),
MinidumpContext_x86_64_Flags::x86_64_Flag | MinidumpContext_x86_64_Flags::x86_64_Flag |
MinidumpContext_x86_64_Flags::Control | MinidumpContext_x86_64_Flags::Control |
MinidumpContext_x86_64_Flags::FloatingPoint | MinidumpContext_x86_64_Flags::FloatingPoint |
Show All 17 Lines)"),
EXPECT_EQ(0x0000000000401dc6u, context->rip); EXPECT_EQ(0x0000000000401dc6u, context->rip);
EXPECT_EQ(0x00010206u, context->eflags); EXPECT_EQ(0x00010206u, context->eflags);
EXPECT_EQ(0x0033u, context->cs); EXPECT_EQ(0x0033u, context->cs);
EXPECT_EQ(0x0000u, context->ss); EXPECT_EQ(0x0000u, context->ss);
} }
TEST_F(MinidumpParserTest, GetThreadContext_x86_32_wow64) { TEST_F(MinidumpParserTest, GetThreadContext_x86_32_wow64) {
SetUpData("fizzbuzz_wow64.dmp"); SetUpData("fizzbuzz_wow64.dmp");
llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads(); llvm::ArrayRef<llvm::minidump::Thread> thread_list = parser->GetThreads();
const minidump::Thread &thread = thread_list[0]; const llvm::minidump::Thread &thread = thread_list[0];
llvm::ArrayRef<uint8_t> registers(parser->GetThreadContextWow64(thread)); llvm::ArrayRef<uint8_t> registers(parser->GetThreadContextWow64(thread));
const MinidumpContext_x86_32 *context; const MinidumpContext_x86_32 *context;
EXPECT_TRUE(consumeObject(registers, context).Success()); EXPECT_TRUE(consumeObject(registers, context).Success());
EXPECT_EQ(MinidumpContext_x86_32_Flags(uint32_t(context->context_flags)), EXPECT_EQ(MinidumpContext_x86_32_Flags(uint32_t(context->context_flags)),
MinidumpContext_x86_32_Flags::x86_32_Flag | MinidumpContext_x86_32_Flags::x86_32_Flag |
MinidumpContext_x86_32_Flags::Full | MinidumpContext_x86_32_Flags::Full |
MinidumpContext_x86_32_Flags::FloatingPoint | MinidumpContext_x86_32_Flags::FloatingPoint |
Show All 31 Lines Modules:
Size of Image: 0x00001000 Size of Image: 0x00001000
Module Name: '/tmp/a' Module Name: '/tmp/a'
CodeView Record: '' CodeView Record: ''
... ...
)"), )"),
llvm::Succeeded()); llvm::Succeeded());
// If we have a module mentioned twice in the module list, the filtered // If we have a module mentioned twice in the module list, the filtered
// module list should contain the instance with the lowest BaseOfImage. // module list should contain the instance with the lowest BaseOfImage.
std::vector<const minidump::Module *> filtered_modules = std::vector<const llvm::minidump::Module *> filtered_modules =
parser->GetFilteredModuleList(); parser->GetFilteredModuleList();
ASSERT_EQ(1u, filtered_modules.size()); ASSERT_EQ(1u, filtered_modules.size());
EXPECT_EQ(0x0000000000001000u, filtered_modules[0]->BaseOfImage); EXPECT_EQ(0x0000000000001000u, filtered_modules[0]->BaseOfImage);
} }
TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedFirst) { TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedFirst) {
ASSERT_THAT_ERROR(SetUpFromYaml(R"( ASSERT_THAT_ERROR(SetUpFromYaml(R"(
--- !minidump --- !minidump
Show All 23 Lines)"),
// permissions. If clients open an object file with mmap, breakpad can create // permissions. If clients open an object file with mmap, breakpad can create
// multiple mappings for a library errnoneously and the lowest address isn't // multiple mappings for a library errnoneously and the lowest address isn't
// always the right address. In this case we check the consective memory // always the right address. In this case we check the consective memory
// regions whose path matches starting at the base of image address and make // regions whose path matches starting at the base of image address and make
// sure one of the regions is executable and prefer that one. // sure one of the regions is executable and prefer that one.
// //
// This test will make sure that if the executable is second in the module // This test will make sure that if the executable is second in the module
// list, that it will become the selected module in the filtered list. // list, that it will become the selected module in the filtered list.
std::vector<const minidump::Module *> filtered_modules = std::vector<const llvm::minidump::Module *> filtered_modules =
parser->GetFilteredModuleList(); parser->GetFilteredModuleList();
ASSERT_EQ(1u, filtered_modules.size()); ASSERT_EQ(1u, filtered_modules.size());
EXPECT_EQ(0x400d3000u, filtered_modules[0]->BaseOfImage); EXPECT_EQ(0x400d3000u, filtered_modules[0]->BaseOfImage);
} }
TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedSecond) { TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedSecond) {
ASSERT_THAT_ERROR(SetUpFromYaml(R"( ASSERT_THAT_ERROR(SetUpFromYaml(R"(
--- !minidump --- !minidump
Show All 24 Lines)"),
// multiple mappings for a library errnoneously and the lowest address isn't // multiple mappings for a library errnoneously and the lowest address isn't
// always the right address. In this case we check the consective memory // always the right address. In this case we check the consective memory
// regions whose path matches starting at the base of image address and make // regions whose path matches starting at the base of image address and make
// sure one of the regions is executable and prefer that one. // sure one of the regions is executable and prefer that one.
// //
// This test will make sure that if the executable is first in the module // This test will make sure that if the executable is first in the module
// list, that it will remain the correctly selected module in the filtered // list, that it will remain the correctly selected module in the filtered
// list. // list.
std::vector<const minidump::Module *> filtered_modules = std::vector<const llvm::minidump::Module *> filtered_modules =
parser->GetFilteredModuleList(); parser->GetFilteredModuleList();
ASSERT_EQ(1u, filtered_modules.size()); ASSERT_EQ(1u, filtered_modules.size());
EXPECT_EQ(0x400d0000u, filtered_modules[0]->BaseOfImage); EXPECT_EQ(0x400d0000u, filtered_modules[0]->BaseOfImage);
} }
TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedSecondHigh) { TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedSecondHigh) {
ASSERT_THAT_ERROR(SetUpFromYaml(R"( ASSERT_THAT_ERROR(SetUpFromYaml(R"(
--- !minidump --- !minidump
Show All 24 Lines)"),
// multiple mappings for a library errnoneously and the lowest address isn't // multiple mappings for a library errnoneously and the lowest address isn't
// always the right address. In this case we check the consective memory // always the right address. In this case we check the consective memory
// regions whose path matches starting at the base of image address and make // regions whose path matches starting at the base of image address and make
// sure one of the regions is executable and prefer that one. // sure one of the regions is executable and prefer that one.
// //
// This test will make sure that if the executable is first in the module // This test will make sure that if the executable is first in the module
// list, that it will remain the correctly selected module in the filtered // list, that it will remain the correctly selected module in the filtered
// list, even if the non-executable module was loaded at a lower base address. // list, even if the non-executable module was loaded at a lower base address.
std::vector<const minidump::Module *> filtered_modules = std::vector<const llvm::minidump::Module *> filtered_modules =
parser->GetFilteredModuleList(); parser->GetFilteredModuleList();
ASSERT_EQ(1u, filtered_modules.size()); ASSERT_EQ(1u, filtered_modules.size());
EXPECT_EQ(0x400d3000u, filtered_modules[0]->BaseOfImage); EXPECT_EQ(0x400d3000u, filtered_modules[0]->BaseOfImage);
} }
TEST_F(MinidumpParserTest, MinidumpDuplicateModuleSeparateCode) { TEST_F(MinidumpParserTest, MinidumpDuplicateModuleSeparateCode) {
ASSERT_THAT_ERROR(SetUpFromYaml(R"( ASSERT_THAT_ERROR(SetUpFromYaml(R"(
--- !minidump --- !minidump
Show All 26 Lines)"),
// always the right address. In this case we check the consective memory // always the right address. In this case we check the consective memory
// regions whose path matches starting at the base of image address and make // regions whose path matches starting at the base of image address and make
// sure one of the regions is executable and prefer that one. // sure one of the regions is executable and prefer that one.
// //
// This test will make sure if binaries are compiled with "-z separate-code", // This test will make sure if binaries are compiled with "-z separate-code",
// where the first region for a binary won't be marked as executable, that // where the first region for a binary won't be marked as executable, that
// it gets selected by detecting the second consecutive mapping at 0x400d7000 // it gets selected by detecting the second consecutive mapping at 0x400d7000
// when asked about the a module mamed "/usr/lib/libc.so" at 0x400d5000. // when asked about the a module mamed "/usr/lib/libc.so" at 0x400d5000.
std::vector<const minidump::Module *> filtered_modules = std::vector<const llvm::minidump::Module *> filtered_modules =
parser->GetFilteredModuleList(); parser->GetFilteredModuleList();
ASSERT_EQ(1u, filtered_modules.size()); ASSERT_EQ(1u, filtered_modules.size());
EXPECT_EQ(0x400d5000u, filtered_modules[0]->BaseOfImage); EXPECT_EQ(0x400d5000u, filtered_modules[0]->BaseOfImage);
} }
TEST_F(MinidumpParserTest, MinidumpModuleOrder) { TEST_F(MinidumpParserTest, MinidumpModuleOrder) {
ASSERT_THAT_ERROR(SetUpFromYaml(R"( ASSERT_THAT_ERROR(SetUpFromYaml(R"(
--- !minidump --- !minidump
Show All 9 Lines Modules:
Module Name: '/tmp/b' Module Name: '/tmp/b'
CodeView Record: '' CodeView Record: ''
... ...
)"), )"),
llvm::Succeeded()); llvm::Succeeded());
// Test module filtering does not affect the overall module order. Previous // Test module filtering does not affect the overall module order. Previous
// versions of the MinidumpParser::GetFilteredModuleList() function would sort // versions of the MinidumpParser::GetFilteredModuleList() function would sort
// all images by address and modify the order of the modules. // all images by address and modify the order of the modules.
std::vector<const minidump::Module *> filtered_modules = std::vector<const llvm::minidump::Module *> filtered_modules =
parser->GetFilteredModuleList(); parser->GetFilteredModuleList();
ASSERT_EQ(2u, filtered_modules.size()); ASSERT_EQ(2u, filtered_modules.size());
EXPECT_EQ(0x0000000000002000u, filtered_modules[0]->BaseOfImage); EXPECT_EQ(0x0000000000002000u, filtered_modules[0]->BaseOfImage);
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
parser->GetMinidumpFile().getString(filtered_modules[0]->ModuleNameRVA), parser->GetMinidumpFile().getString(filtered_modules[0]->ModuleNameRVA),
llvm::HasValue("/tmp/a")); llvm::HasValue("/tmp/a"));
EXPECT_EQ(0x0000000000001000u, filtered_modules[1]->BaseOfImage); EXPECT_EQ(0x0000000000001000u, filtered_modules[1]->BaseOfImage);
EXPECT_THAT_EXPECTED( EXPECT_THAT_EXPECTED(
parser->GetMinidumpFile().getString(filtered_modules[1]->ModuleNameRVA), parser->GetMinidumpFile().getString(filtered_modules[1]->ModuleNameRVA),
llvm::HasValue("/tmp/b")); llvm::HasValue("/tmp/b"));
} }

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

Show First 20 Lines • Show All 234 Lines • ▼ Show 20 Lines - Version: 4
- AbbrCode: 0x0 - AbbrCode: 0x0
... ...
)"; )";
YAMLModuleTester t(yamldata); YAMLModuleTester t(yamldata);
DWARFUnit *unit = t.GetDwarfUnit(); DWARFUnit *unit = t.GetDwarfUnit();
ASSERT_NE(unit, nullptr); ASSERT_NE(unit, nullptr);
const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE(); const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit); ASSERT_EQ(cu_entry->Tag(), llvm::dwarf::DW_TAG_compile_unit);
DWARFDIE cu_die(unit, cu_entry); DWARFDIE cu_die(unit, cu_entry);
TypeSystemClang ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple()); TypeSystemClang ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());
DWARFASTParserClangStub ast_parser(ast_ctx); DWARFASTParserClangStub ast_parser(ast_ctx);
std::vector<std::string> found_function_types; std::vector<std::string> found_function_types;
// The DWARF above is just a list of functions. Parse all of them to // The DWARF above is just a list of functions. Parse all of them to
// extract the function types and their calling convention values. // extract the function types and their calling convention values.
for (DWARFDIE func : cu_die.children()) { for (DWARFDIE func : cu_die.children()) {
ASSERT_EQ(func.Tag(), DW_TAG_subprogram); ASSERT_EQ(func.Tag(), llvm::dwarf::DW_TAG_subprogram);
SymbolContext sc; SymbolContext sc;
bool new_type = false; bool new_type = false;
lldb::TypeSP type = ast_parser.ParseTypeFromDWARF(sc, func, &new_type); lldb::TypeSP type = ast_parser.ParseTypeFromDWARF(sc, func, &new_type);
found_function_types.push_back( found_function_types.push_back(
type->GetForwardCompilerType().GetTypeName().AsCString()); type->GetForwardCompilerType().GetTypeName().AsCString());
} }
// Compare the parsed function types against the expected list of types. // Compare the parsed function types against the expected list of types.
Show All 13 Lines

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
TEST_F(SymbolFileDWARFTests, TestAbbrevOrder1Start1) { TEST_F(SymbolFileDWARFTests, TestAbbrevOrder1Start1) {
// Test that if we have a .debug_abbrev that contains ordered abbreviation // Test that if we have a .debug_abbrev that contains ordered abbreviation
// codes that start at 1, that we get O(1) access. // codes that start at 1, that we get O(1) access.
const auto byte_order = eByteOrderLittle; const auto byte_order = eByteOrderLittle;
const uint8_t addr_size = 4; const uint8_t addr_size = 4;
StreamString encoder(Stream::eBinary, addr_size, byte_order); StreamString encoder(Stream::eBinary, addr_size, byte_order);
encoder.PutULEB128(1); // Abbrev code 1 encoder.PutULEB128(1); // Abbrev code 1
encoder.PutULEB128(DW_TAG_compile_unit); encoder.PutULEB128(llvm::dwarf::DW_TAG_compile_unit);
encoder.PutHex8(DW_CHILDREN_yes); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_yes);
encoder.PutULEB128(DW_AT_name); encoder.PutULEB128(llvm::dwarf::DW_AT_name);
encoder.PutULEB128(DW_FORM_strp); encoder.PutULEB128(llvm::dwarf::DW_FORM_strp);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(2); // Abbrev code 2 encoder.PutULEB128(2); // Abbrev code 2
encoder.PutULEB128(DW_TAG_subprogram); encoder.PutULEB128(llvm::dwarf::DW_TAG_subprogram);
encoder.PutHex8(DW_CHILDREN_no); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_no);
encoder.PutULEB128(DW_AT_name); encoder.PutULEB128(llvm::dwarf::DW_AT_name);
encoder.PutULEB128(DW_FORM_strp); encoder.PutULEB128(llvm::dwarf::DW_FORM_strp);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); // Abbrev code 0 (termination) encoder.PutULEB128(0); // Abbrev code 0 (termination)
DWARFDataExtractor data; DWARFDataExtractor data;
data.SetData(encoder.GetData(), encoder.GetSize(), byte_order); data.SetData(encoder.GetData(), encoder.GetSize(), byte_order);
DWARFAbbreviationDeclarationSet abbrev_set; DWARFAbbreviationDeclarationSet abbrev_set;
lldb::offset_t data_offset = 0; lldb::offset_t data_offset = 0;
llvm::Error error = abbrev_set.extract(data, &data_offset); llvm::Error error = abbrev_set.extract(data, &data_offset);
EXPECT_FALSE(bool(error)); EXPECT_FALSE(bool(error));
// Make sure we have O(1) access to each abbreviation by making sure the // Make sure we have O(1) access to each abbreviation by making sure the
// index offset is 1 and not UINT32_MAX // index offset is 1 and not UINT32_MAX
EXPECT_EQ(abbrev_set.GetIndexOffset(), 1u); EXPECT_EQ(abbrev_set.GetIndexOffset(), 1u);
auto abbrev1 = abbrev_set.GetAbbreviationDeclaration(1); auto abbrev1 = abbrev_set.GetAbbreviationDeclaration(1);
EXPECT_EQ(abbrev1->Tag(), DW_TAG_compile_unit); EXPECT_EQ(abbrev1->Tag(), llvm::dwarf::DW_TAG_compile_unit);
EXPECT_TRUE(abbrev1->HasChildren()); EXPECT_TRUE(abbrev1->HasChildren());
EXPECT_EQ(abbrev1->NumAttributes(), 1u); EXPECT_EQ(abbrev1->NumAttributes(), 1u);
auto abbrev2 = abbrev_set.GetAbbreviationDeclaration(2); auto abbrev2 = abbrev_set.GetAbbreviationDeclaration(2);
EXPECT_EQ(abbrev2->Tag(), DW_TAG_subprogram); EXPECT_EQ(abbrev2->Tag(), llvm::dwarf::DW_TAG_subprogram);
EXPECT_FALSE(abbrev2->HasChildren()); EXPECT_FALSE(abbrev2->HasChildren());
EXPECT_EQ(abbrev2->NumAttributes(), 1u); EXPECT_EQ(abbrev2->NumAttributes(), 1u);
} }
TEST_F(SymbolFileDWARFTests, TestAbbrevOrder1Start5) { TEST_F(SymbolFileDWARFTests, TestAbbrevOrder1Start5) {
// Test that if we have a .debug_abbrev that contains ordered abbreviation // Test that if we have a .debug_abbrev that contains ordered abbreviation
// codes that start at 5, that we get O(1) access. // codes that start at 5, that we get O(1) access.
const auto byte_order = eByteOrderLittle; const auto byte_order = eByteOrderLittle;
const uint8_t addr_size = 4; const uint8_t addr_size = 4;
StreamString encoder(Stream::eBinary, addr_size, byte_order); StreamString encoder(Stream::eBinary, addr_size, byte_order);
encoder.PutULEB128(5); // Abbrev code 5 encoder.PutULEB128(5); // Abbrev code 5
encoder.PutULEB128(DW_TAG_compile_unit); encoder.PutULEB128(llvm::dwarf::DW_TAG_compile_unit);
encoder.PutHex8(DW_CHILDREN_yes); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_yes);
encoder.PutULEB128(DW_AT_name); encoder.PutULEB128(llvm::dwarf::DW_AT_name);
encoder.PutULEB128(DW_FORM_strp); encoder.PutULEB128(llvm::dwarf::DW_FORM_strp);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(6); // Abbrev code 6 encoder.PutULEB128(6); // Abbrev code 6
encoder.PutULEB128(DW_TAG_subprogram); encoder.PutULEB128(llvm::dwarf::DW_TAG_subprogram);
encoder.PutHex8(DW_CHILDREN_no); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_no);
encoder.PutULEB128(DW_AT_name); encoder.PutULEB128(llvm::dwarf::DW_AT_name);
encoder.PutULEB128(DW_FORM_strp); encoder.PutULEB128(llvm::dwarf::DW_FORM_strp);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); // Abbrev code 0 (termination) encoder.PutULEB128(0); // Abbrev code 0 (termination)
DWARFDataExtractor data; DWARFDataExtractor data;
data.SetData(encoder.GetData(), encoder.GetSize(), byte_order); data.SetData(encoder.GetData(), encoder.GetSize(), byte_order);
DWARFAbbreviationDeclarationSet abbrev_set; DWARFAbbreviationDeclarationSet abbrev_set;
lldb::offset_t data_offset = 0; lldb::offset_t data_offset = 0;
llvm::Error error = abbrev_set.extract(data, &data_offset); llvm::Error error = abbrev_set.extract(data, &data_offset);
EXPECT_FALSE(bool(error)); EXPECT_FALSE(bool(error));
// Make sure we have O(1) access to each abbreviation by making sure the // Make sure we have O(1) access to each abbreviation by making sure the
// index offset is 5 and not UINT32_MAX // index offset is 5 and not UINT32_MAX
EXPECT_EQ(abbrev_set.GetIndexOffset(), 5u); EXPECT_EQ(abbrev_set.GetIndexOffset(), 5u);
auto abbrev1 = abbrev_set.GetAbbreviationDeclaration(5); auto abbrev1 = abbrev_set.GetAbbreviationDeclaration(5);
EXPECT_EQ(abbrev1->Tag(), DW_TAG_compile_unit); EXPECT_EQ(abbrev1->Tag(), llvm::dwarf::DW_TAG_compile_unit);
EXPECT_TRUE(abbrev1->HasChildren()); EXPECT_TRUE(abbrev1->HasChildren());
EXPECT_EQ(abbrev1->NumAttributes(), 1u); EXPECT_EQ(abbrev1->NumAttributes(), 1u);
auto abbrev2 = abbrev_set.GetAbbreviationDeclaration(6); auto abbrev2 = abbrev_set.GetAbbreviationDeclaration(6);
EXPECT_EQ(abbrev2->Tag(), DW_TAG_subprogram); EXPECT_EQ(abbrev2->Tag(), llvm::dwarf::DW_TAG_subprogram);
EXPECT_FALSE(abbrev2->HasChildren()); EXPECT_FALSE(abbrev2->HasChildren());
EXPECT_EQ(abbrev2->NumAttributes(), 1u); EXPECT_EQ(abbrev2->NumAttributes(), 1u);
} }
TEST_F(SymbolFileDWARFTests, TestAbbrevOutOfOrder) { TEST_F(SymbolFileDWARFTests, TestAbbrevOutOfOrder) {
// Test that if we have a .debug_abbrev that contains unordered abbreviation // Test that if we have a .debug_abbrev that contains unordered abbreviation
// codes, that we can access the information correctly. // codes, that we can access the information correctly.
const auto byte_order = eByteOrderLittle; const auto byte_order = eByteOrderLittle;
const uint8_t addr_size = 4; const uint8_t addr_size = 4;
StreamString encoder(Stream::eBinary, addr_size, byte_order); StreamString encoder(Stream::eBinary, addr_size, byte_order);
encoder.PutULEB128(2); // Abbrev code 2 encoder.PutULEB128(2); // Abbrev code 2
encoder.PutULEB128(DW_TAG_compile_unit); encoder.PutULEB128(llvm::dwarf::DW_TAG_compile_unit);
encoder.PutHex8(DW_CHILDREN_yes); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_yes);
encoder.PutULEB128(DW_AT_name); encoder.PutULEB128(llvm::dwarf::DW_AT_name);
encoder.PutULEB128(DW_FORM_strp); encoder.PutULEB128(llvm::dwarf::DW_FORM_strp);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(1); // Abbrev code 1 encoder.PutULEB128(1); // Abbrev code 1
encoder.PutULEB128(DW_TAG_subprogram); encoder.PutULEB128(llvm::dwarf::DW_TAG_subprogram);
encoder.PutHex8(DW_CHILDREN_no); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_no);
encoder.PutULEB128(DW_AT_name); encoder.PutULEB128(llvm::dwarf::DW_AT_name);
encoder.PutULEB128(DW_FORM_strp); encoder.PutULEB128(llvm::dwarf::DW_FORM_strp);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); // Abbrev code 0 (termination) encoder.PutULEB128(0); // Abbrev code 0 (termination)
DWARFDataExtractor data; DWARFDataExtractor data;
data.SetData(encoder.GetData(), encoder.GetSize(), byte_order); data.SetData(encoder.GetData(), encoder.GetSize(), byte_order);
DWARFAbbreviationDeclarationSet abbrev_set; DWARFAbbreviationDeclarationSet abbrev_set;
lldb::offset_t data_offset = 0; lldb::offset_t data_offset = 0;
llvm::Error error = abbrev_set.extract(data, &data_offset); llvm::Error error = abbrev_set.extract(data, &data_offset);
EXPECT_FALSE(bool(error)); EXPECT_FALSE(bool(error));
// Make sure we don't have O(1) access to each abbreviation by making sure // Make sure we don't have O(1) access to each abbreviation by making sure
// the index offset is UINT32_MAX // the index offset is UINT32_MAX
EXPECT_EQ(abbrev_set.GetIndexOffset(), UINT32_MAX); EXPECT_EQ(abbrev_set.GetIndexOffset(), UINT32_MAX);
auto abbrev1 = abbrev_set.GetAbbreviationDeclaration(2); auto abbrev1 = abbrev_set.GetAbbreviationDeclaration(2);
EXPECT_EQ(abbrev1->Tag(), DW_TAG_compile_unit); EXPECT_EQ(abbrev1->Tag(), llvm::dwarf::DW_TAG_compile_unit);
EXPECT_TRUE(abbrev1->HasChildren()); EXPECT_TRUE(abbrev1->HasChildren());
EXPECT_EQ(abbrev1->NumAttributes(), 1u); EXPECT_EQ(abbrev1->NumAttributes(), 1u);
auto abbrev2 = abbrev_set.GetAbbreviationDeclaration(1); auto abbrev2 = abbrev_set.GetAbbreviationDeclaration(1);
EXPECT_EQ(abbrev2->Tag(), DW_TAG_subprogram); EXPECT_EQ(abbrev2->Tag(), llvm::dwarf::DW_TAG_subprogram);
EXPECT_FALSE(abbrev2->HasChildren()); EXPECT_FALSE(abbrev2->HasChildren());
EXPECT_EQ(abbrev2->NumAttributes(), 1u); EXPECT_EQ(abbrev2->NumAttributes(), 1u);
} }
TEST_F(SymbolFileDWARFTests, TestAbbrevInvalidNULLTag) { TEST_F(SymbolFileDWARFTests, TestAbbrevInvalidNULLTag) {
// Test that we detect when an abbreviation has a NULL tag and that we get // Test that we detect when an abbreviation has a NULL tag and that we get
// an error when decoding. // an error when decoding.
const auto byte_order = eByteOrderLittle; const auto byte_order = eByteOrderLittle;
const uint8_t addr_size = 4; const uint8_t addr_size = 4;
StreamString encoder(Stream::eBinary, addr_size, byte_order); StreamString encoder(Stream::eBinary, addr_size, byte_order);
encoder.PutULEB128(1); // Abbrev code 1 encoder.PutULEB128(1); // Abbrev code 1
encoder.PutULEB128(0); // Invalid NULL tag here! encoder.PutULEB128(0); // Invalid NULL tag here!
encoder.PutHex8(DW_CHILDREN_no); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_no);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); // Abbrev code 0 (termination) encoder.PutULEB128(0); // Abbrev code 0 (termination)
DWARFDataExtractor data; DWARFDataExtractor data;
data.SetData(encoder.GetData(), encoder.GetSize(), byte_order); data.SetData(encoder.GetData(), encoder.GetSize(), byte_order);
DWARFAbbreviationDeclarationSet abbrev_set; DWARFAbbreviationDeclarationSet abbrev_set;
Show All 9 Lines
TEST_F(SymbolFileDWARFTests, TestAbbrevNullAttrValidForm) { TEST_F(SymbolFileDWARFTests, TestAbbrevNullAttrValidForm) {
// Test that we detect when an abbreviation has a NULL attribute and a non // Test that we detect when an abbreviation has a NULL attribute and a non
// NULL form and that we get an error when decoding. // NULL form and that we get an error when decoding.
const auto byte_order = eByteOrderLittle; const auto byte_order = eByteOrderLittle;
const uint8_t addr_size = 4; const uint8_t addr_size = 4;
StreamString encoder(Stream::eBinary, addr_size, byte_order); StreamString encoder(Stream::eBinary, addr_size, byte_order);
encoder.PutULEB128(1); // Abbrev code 1 encoder.PutULEB128(1); // Abbrev code 1
encoder.PutULEB128(DW_TAG_compile_unit); encoder.PutULEB128(llvm::dwarf::DW_TAG_compile_unit);
encoder.PutHex8(DW_CHILDREN_no); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_no);
encoder.PutULEB128(0); // Invalid NULL DW_AT encoder.PutULEB128(0); // Invalid NULL DW_AT
encoder.PutULEB128(DW_FORM_strp); // With a valid form encoder.PutULEB128(llvm::dwarf::DW_FORM_strp); // With a valid form
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); // Abbrev code 0 (termination) encoder.PutULEB128(0); // Abbrev code 0 (termination)
DWARFDataExtractor data; DWARFDataExtractor data;
data.SetData(encoder.GetData(), encoder.GetSize(), byte_order); data.SetData(encoder.GetData(), encoder.GetSize(), byte_order);
DWARFAbbreviationDeclarationSet abbrev_set; DWARFAbbreviationDeclarationSet abbrev_set;
lldb::offset_t data_offset = 0; lldb::offset_t data_offset = 0;
llvm::Error error = abbrev_set.extract(data, &data_offset); llvm::Error error = abbrev_set.extract(data, &data_offset);
// Verify we get an error // Verify we get an error
EXPECT_TRUE(bool(error)); EXPECT_TRUE(bool(error));
EXPECT_EQ("malformed abbreviation declaration attribute", EXPECT_EQ("malformed abbreviation declaration attribute",
llvm::toString(std::move(error))); llvm::toString(std::move(error)));
} }
TEST_F(SymbolFileDWARFTests, TestAbbrevValidAttrNullForm) { TEST_F(SymbolFileDWARFTests, TestAbbrevValidAttrNullForm) {
// Test that we detect when an abbreviation has a valid attribute and a // Test that we detect when an abbreviation has a valid attribute and a
// NULL form and that we get an error when decoding. // NULL form and that we get an error when decoding.
const auto byte_order = eByteOrderLittle; const auto byte_order = eByteOrderLittle;
const uint8_t addr_size = 4; const uint8_t addr_size = 4;
StreamString encoder(Stream::eBinary, addr_size, byte_order); StreamString encoder(Stream::eBinary, addr_size, byte_order);
encoder.PutULEB128(1); // Abbrev code 1 encoder.PutULEB128(1); // Abbrev code 1
encoder.PutULEB128(DW_TAG_compile_unit); encoder.PutULEB128(llvm::dwarf::DW_TAG_compile_unit);
encoder.PutHex8(DW_CHILDREN_no); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_no);
encoder.PutULEB128(DW_AT_name); // Valid attribute encoder.PutULEB128(llvm::dwarf::DW_AT_name); // Valid attribute
encoder.PutULEB128(0); // NULL form encoder.PutULEB128(0); // NULL form
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); encoder.PutULEB128(0);
encoder.PutULEB128(0); // Abbrev code 0 (termination) encoder.PutULEB128(0); // Abbrev code 0 (termination)
DWARFDataExtractor data; DWARFDataExtractor data;
data.SetData(encoder.GetData(), encoder.GetSize(), byte_order); data.SetData(encoder.GetData(), encoder.GetSize(), byte_order);
Show All 10 LinesTEST_F(SymbolFileDWARFTests, TestAbbrevMissingTerminator) {
// Test that we detect when an abbreviation has a valid attribute and a // Test that we detect when an abbreviation has a valid attribute and a
// form, but is missing the NULL attribute and form that terminates an // form, but is missing the NULL attribute and form that terminates an
// abbreviation // abbreviation
const auto byte_order = eByteOrderLittle; const auto byte_order = eByteOrderLittle;
const uint8_t addr_size = 4; const uint8_t addr_size = 4;
StreamString encoder(Stream::eBinary, addr_size, byte_order); StreamString encoder(Stream::eBinary, addr_size, byte_order);
encoder.PutULEB128(1); // Abbrev code 1 encoder.PutULEB128(1); // Abbrev code 1
encoder.PutULEB128(DW_TAG_compile_unit); encoder.PutULEB128(llvm::dwarf::DW_TAG_compile_unit);
encoder.PutHex8(DW_CHILDREN_no); encoder.PutHex8(llvm::dwarf::DW_CHILDREN_no);
encoder.PutULEB128(DW_AT_name); encoder.PutULEB128(llvm::dwarf::DW_AT_name);
encoder.PutULEB128(DW_FORM_strp); encoder.PutULEB128(llvm::dwarf::DW_FORM_strp);
// Don't add the NULL DW_AT and NULL DW_FORM terminator // Don't add the NULL DW_AT and NULL DW_FORM terminator
DWARFDataExtractor data; DWARFDataExtractor data;
data.SetData(encoder.GetData(), encoder.GetSize(), byte_order); data.SetData(encoder.GetData(), encoder.GetSize(), byte_order);
DWARFAbbreviationDeclarationSet abbrev_set; DWARFAbbreviationDeclarationSet abbrev_set;
lldb::offset_t data_offset = 0; lldb::offset_t data_offset = 0;
llvm::Error error = abbrev_set.extract(data, &data_offset); llvm::Error error = abbrev_set.extract(data, &data_offset);
// Verify we get an error // Verify we get an error
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines