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