1 | //===-- UnwindTable.cpp ---------------------------------------------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "lldb/Symbol/UnwindTable.h" |
10 | |
11 | #include <cstdio> |
12 | #include <optional> |
13 | |
14 | #include "lldb/Core/Module.h" |
15 | #include "lldb/Core/Section.h" |
16 | #include "lldb/Symbol/ArmUnwindInfo.h" |
17 | #include "lldb/Symbol/CallFrameInfo.h" |
18 | #include "lldb/Symbol/CompactUnwindInfo.h" |
19 | #include "lldb/Symbol/DWARFCallFrameInfo.h" |
20 | #include "lldb/Symbol/FuncUnwinders.h" |
21 | #include "lldb/Symbol/ObjectFile.h" |
22 | #include "lldb/Symbol/SymbolContext.h" |
23 | #include "lldb/Symbol/SymbolVendor.h" |
24 | |
25 | // There is one UnwindTable object per ObjectFile. It contains a list of Unwind |
26 | // objects -- one per function, populated lazily -- for the ObjectFile. Each |
27 | // Unwind object has multiple UnwindPlans for different scenarios. |
28 | |
29 | using namespace lldb; |
30 | using namespace lldb_private; |
31 | |
32 | UnwindTable::UnwindTable(Module &module) |
33 | : m_module(module), m_unwinds(), m_initialized(false), m_mutex(), |
34 | m_object_file_unwind_up(), m_eh_frame_up(), m_compact_unwind_up(), |
35 | m_arm_unwind_up() {} |
36 | |
37 | // We can't do some of this initialization when the ObjectFile is running its |
38 | // ctor; delay doing it until needed for something. |
39 | |
40 | void UnwindTable::Initialize() { |
41 | if (m_initialized) |
42 | return; |
43 | |
44 | std::lock_guard<std::mutex> guard(m_mutex); |
45 | |
46 | if (m_initialized) // check again once we've acquired the lock |
47 | return; |
48 | m_initialized = true; |
49 | ObjectFile *object_file = m_module.GetObjectFile(); |
50 | if (!object_file) |
51 | return; |
52 | |
53 | m_object_file_unwind_up = object_file->CreateCallFrameInfo(); |
54 | |
55 | SectionList *sl = m_module.GetSectionList(); |
56 | if (!sl) |
57 | return; |
58 | |
59 | SectionSP sect = sl->FindSectionByType(sect_type: eSectionTypeEHFrame, check_children: true); |
60 | if (sect.get()) { |
61 | m_eh_frame_up = std::make_unique<DWARFCallFrameInfo>( |
62 | args&: *object_file, args&: sect, args: DWARFCallFrameInfo::EH); |
63 | } |
64 | |
65 | sect = sl->FindSectionByType(sect_type: eSectionTypeDWARFDebugFrame, check_children: true); |
66 | if (sect) { |
67 | m_debug_frame_up = std::make_unique<DWARFCallFrameInfo>( |
68 | args&: *object_file, args&: sect, args: DWARFCallFrameInfo::DWARF); |
69 | } |
70 | |
71 | sect = sl->FindSectionByType(sect_type: eSectionTypeCompactUnwind, check_children: true); |
72 | if (sect) { |
73 | m_compact_unwind_up = |
74 | std::make_unique<CompactUnwindInfo>(args&: *object_file, args&: sect); |
75 | } |
76 | |
77 | sect = sl->FindSectionByType(sect_type: eSectionTypeARMexidx, check_children: true); |
78 | if (sect) { |
79 | SectionSP sect_extab = sl->FindSectionByType(sect_type: eSectionTypeARMextab, check_children: true); |
80 | if (sect_extab.get()) { |
81 | m_arm_unwind_up = |
82 | std::make_unique<ArmUnwindInfo>(args&: *object_file, args&: sect, args&: sect_extab); |
83 | } |
84 | } |
85 | } |
86 | |
87 | UnwindTable::~UnwindTable() = default; |
88 | |
89 | std::optional<AddressRange> |
90 | UnwindTable::GetAddressRange(const Address &addr, const SymbolContext &sc) { |
91 | AddressRange range; |
92 | |
93 | // First check the unwind info from the object file plugin |
94 | if (m_object_file_unwind_up && |
95 | m_object_file_unwind_up->GetAddressRange(addr, range)) |
96 | return range; |
97 | |
98 | // Check the symbol context |
99 | if (sc.GetAddressRange(scope: eSymbolContextFunction | eSymbolContextSymbol, range_idx: 0, |
100 | use_inline_block_range: false, range) && |
101 | range.GetBaseAddress().IsValid()) |
102 | return range; |
103 | |
104 | // Does the eh_frame unwind info has a function bounds for this addr? |
105 | if (m_eh_frame_up && m_eh_frame_up->GetAddressRange(addr, range)) |
106 | return range; |
107 | |
108 | // Try debug_frame as well |
109 | if (m_debug_frame_up && m_debug_frame_up->GetAddressRange(addr, range)) |
110 | return range; |
111 | |
112 | return std::nullopt; |
113 | } |
114 | |
115 | FuncUnwindersSP |
116 | UnwindTable::GetFuncUnwindersContainingAddress(const Address &addr, |
117 | SymbolContext &sc) { |
118 | Initialize(); |
119 | |
120 | std::lock_guard<std::mutex> guard(m_mutex); |
121 | |
122 | // There is an UnwindTable per object file, so we can safely use file handles |
123 | addr_t file_addr = addr.GetFileAddress(); |
124 | iterator end = m_unwinds.end(); |
125 | iterator insert_pos = end; |
126 | if (!m_unwinds.empty()) { |
127 | insert_pos = m_unwinds.lower_bound(x: file_addr); |
128 | iterator pos = insert_pos; |
129 | if ((pos == m_unwinds.end()) || |
130 | (pos != m_unwinds.begin() && |
131 | pos->second->GetFunctionStartAddress() != addr)) |
132 | --pos; |
133 | |
134 | if (pos->second->ContainsAddress(addr)) |
135 | return pos->second; |
136 | } |
137 | |
138 | auto range_or = GetAddressRange(addr, sc); |
139 | if (!range_or) |
140 | return nullptr; |
141 | |
142 | FuncUnwindersSP func_unwinder_sp(new FuncUnwinders(*this, *range_or)); |
143 | m_unwinds.insert(position: insert_pos, |
144 | x: std::make_pair(x: range_or->GetBaseAddress().GetFileAddress(), |
145 | y&: func_unwinder_sp)); |
146 | return func_unwinder_sp; |
147 | } |
148 | |
149 | // Ignore any existing FuncUnwinders for this function, create a new one and |
150 | // don't add it to the UnwindTable. This is intended for use by target modules |
151 | // show-unwind where we want to create new UnwindPlans, not re-use existing |
152 | // ones. |
153 | FuncUnwindersSP UnwindTable::GetUncachedFuncUnwindersContainingAddress( |
154 | const Address &addr, const SymbolContext &sc) { |
155 | Initialize(); |
156 | |
157 | auto range_or = GetAddressRange(addr, sc); |
158 | if (!range_or) |
159 | return nullptr; |
160 | |
161 | return std::make_shared<FuncUnwinders>(args&: *this, args&: *range_or); |
162 | } |
163 | |
164 | void UnwindTable::Dump(Stream &s) { |
165 | std::lock_guard<std::mutex> guard(m_mutex); |
166 | s.Format(format: "UnwindTable for '{0}':\n" , args: m_module.GetFileSpec()); |
167 | const_iterator begin = m_unwinds.begin(); |
168 | const_iterator end = m_unwinds.end(); |
169 | for (const_iterator pos = begin; pos != end; ++pos) { |
170 | s.Printf(format: "[%u] 0x%16.16" PRIx64 "\n" , (unsigned)std::distance(first: begin, last: pos), |
171 | pos->first); |
172 | } |
173 | s.EOL(); |
174 | } |
175 | |
176 | lldb_private::CallFrameInfo *UnwindTable::GetObjectFileUnwindInfo() { |
177 | Initialize(); |
178 | return m_object_file_unwind_up.get(); |
179 | } |
180 | |
181 | DWARFCallFrameInfo *UnwindTable::GetEHFrameInfo() { |
182 | Initialize(); |
183 | return m_eh_frame_up.get(); |
184 | } |
185 | |
186 | DWARFCallFrameInfo *UnwindTable::GetDebugFrameInfo() { |
187 | Initialize(); |
188 | return m_debug_frame_up.get(); |
189 | } |
190 | |
191 | CompactUnwindInfo *UnwindTable::GetCompactUnwindInfo() { |
192 | Initialize(); |
193 | return m_compact_unwind_up.get(); |
194 | } |
195 | |
196 | ArmUnwindInfo *UnwindTable::GetArmUnwindInfo() { |
197 | Initialize(); |
198 | return m_arm_unwind_up.get(); |
199 | } |
200 | |
201 | SymbolFile *UnwindTable::GetSymbolFile() { return m_module.GetSymbolFile(); } |
202 | |
203 | ArchSpec UnwindTable::GetArchitecture() { return m_module.GetArchitecture(); } |
204 | |
205 | bool UnwindTable::GetAllowAssemblyEmulationUnwindPlans() { |
206 | if (ObjectFile *object_file = m_module.GetObjectFile()) |
207 | return object_file->AllowAssemblyEmulationUnwindPlans(); |
208 | return false; |
209 | } |
210 | |