Index: lldb.xcodeproj/project.pbxproj =================================================================== --- lldb.xcodeproj/project.pbxproj +++ lldb.xcodeproj/project.pbxproj @@ -264,6 +264,8 @@ 2579065F1BD0488D00178368 /* DomainSocket.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2579065E1BD0488D00178368 /* DomainSocket.cpp */; }; 26F5C27710F3D9E4009D5894 /* Driver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26F5C27310F3D9E4009D5894 /* Driver.cpp */; }; 4C4EB7811E6A4DCC002035C0 /* DumpDataExtractor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4C4EB77F1E6A4DB8002035C0 /* DumpDataExtractor.cpp */; }; + 2619C4892107ABD4009CDE81 /* DumpRegisterValue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2619C4882107ABD3009CDE81 /* DumpRegisterValue.cpp */; }; + 2619C48B2107ABDD009CDE81 /* DumpRegisterValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 2619C48A2107ABDD009CDE81 /* DumpRegisterValue.h */; }; 9447DE431BD5963300E67212 /* DumpValueObjectOptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9447DE421BD5963300E67212 /* DumpValueObjectOptions.cpp */; }; 268900EA13353E6F00698AC0 /* DynamicLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26BC7E7710F1B85900F91463 /* DynamicLoader.cpp */; }; AF27AD551D3603EA00CF2833 /* DynamicLoaderDarwin.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AF27AD531D3603EA00CF2833 /* DynamicLoaderDarwin.cpp */; }; @@ -659,6 +661,10 @@ 26474CBE18D0CB2D0073DEBA /* RegisterContextMach_i386.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26474CB818D0CB2D0073DEBA /* RegisterContextMach_i386.cpp */; }; 26474CC018D0CB2D0073DEBA /* RegisterContextMach_x86_64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26474CBA18D0CB2D0073DEBA /* RegisterContextMach_x86_64.cpp */; }; 26474CC918D0CB5B0073DEBA /* RegisterContextMemory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26474CC218D0CB5B0073DEBA /* RegisterContextMemory.cpp */; }; + 2619C4852107A9A2009CDE81 /* RegisterContextMinidump_ARM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2619C4812107A9A1009CDE81 /* RegisterContextMinidump_ARM.cpp */; }; + 2619C4872107A9A2009CDE81 /* RegisterContextMinidump_ARM.h in Headers */ = {isa = PBXBuildFile; fileRef = 2619C4832107A9A2009CDE81 /* RegisterContextMinidump_ARM.h */; }; + 2619C4842107A9A2009CDE81 /* RegisterContextMinidump_ARM64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2619C4802107A9A1009CDE81 /* RegisterContextMinidump_ARM64.cpp */; }; + 2619C4862107A9A2009CDE81 /* RegisterContextMinidump_ARM64.h in Headers */ = {isa = PBXBuildFile; fileRef = 2619C4822107A9A2009CDE81 /* RegisterContextMinidump_ARM64.h */; }; 947CF7761DC7B20D00EF980B /* RegisterContextMinidump_x86_32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 947CF7741DC7B20D00EF980B /* RegisterContextMinidump_x86_32.cpp */; }; AFD65C811D9B5B2E00D93120 /* RegisterContextMinidump_x86_64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AFD65C7F1D9B5B2E00D93120 /* RegisterContextMinidump_x86_64.cpp */; }; AFD65C821D9B5B2E00D93120 /* RegisterContextMinidump_x86_64.h in Headers */ = {isa = PBXBuildFile; fileRef = AFD65C801D9B5B2E00D93120 /* RegisterContextMinidump_x86_64.h */; }; @@ -1735,6 +1741,8 @@ 26F5C27410F3D9E4009D5894 /* Driver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Driver.h; path = tools/driver/Driver.h; sourceTree = ""; }; 4C4EB77F1E6A4DB8002035C0 /* DumpDataExtractor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DumpDataExtractor.cpp; path = source/Core/DumpDataExtractor.cpp; sourceTree = ""; }; 4C4EB7821E6A4DE7002035C0 /* DumpDataExtractor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DumpDataExtractor.h; path = include/lldb/Core/DumpDataExtractor.h; sourceTree = ""; }; + 2619C4882107ABD3009CDE81 /* DumpRegisterValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DumpRegisterValue.cpp; path = source/Core/DumpRegisterValue.cpp; sourceTree = ""; }; + 2619C48A2107ABDD009CDE81 /* DumpRegisterValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DumpRegisterValue.h; path = include/lldb/Core/DumpRegisterValue.h; sourceTree = ""; }; 9447DE421BD5963300E67212 /* DumpValueObjectOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DumpValueObjectOptions.cpp; path = source/DataFormatters/DumpValueObjectOptions.cpp; sourceTree = ""; }; 9447DE411BD5962900E67212 /* DumpValueObjectOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = DumpValueObjectOptions.h; path = include/lldb/DataFormatters/DumpValueObjectOptions.h; sourceTree = ""; }; 26BC7E7710F1B85900F91463 /* DynamicLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DynamicLoader.cpp; path = source/Core/DynamicLoader.cpp; sourceTree = ""; }; @@ -2532,6 +2540,10 @@ 26474CC218D0CB5B0073DEBA /* RegisterContextMemory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RegisterContextMemory.cpp; path = Utility/RegisterContextMemory.cpp; sourceTree = ""; }; 262D24E513FB8710002D1960 /* RegisterContextMemory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RegisterContextMemory.h; path = Utility/RegisterContextMemory.h; sourceTree = ""; }; 26474CC318D0CB5B0073DEBA /* RegisterContextMemory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RegisterContextMemory.h; path = Utility/RegisterContextMemory.h; sourceTree = ""; }; + 2619C4812107A9A1009CDE81 /* RegisterContextMinidump_ARM.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterContextMinidump_ARM.cpp; sourceTree = ""; }; + 2619C4832107A9A2009CDE81 /* RegisterContextMinidump_ARM.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegisterContextMinidump_ARM.h; sourceTree = ""; }; + 2619C4802107A9A1009CDE81 /* RegisterContextMinidump_ARM64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterContextMinidump_ARM64.cpp; sourceTree = ""; }; + 2619C4822107A9A2009CDE81 /* RegisterContextMinidump_ARM64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegisterContextMinidump_ARM64.h; sourceTree = ""; }; 947CF7741DC7B20D00EF980B /* RegisterContextMinidump_x86_32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterContextMinidump_x86_32.cpp; sourceTree = ""; }; 947CF7721DC7B20300EF980B /* RegisterContextMinidump_x86_32.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RegisterContextMinidump_x86_32.h; sourceTree = ""; }; AFD65C7F1D9B5B2E00D93120 /* RegisterContextMinidump_x86_64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterContextMinidump_x86_64.cpp; sourceTree = ""; }; @@ -3775,6 +3787,10 @@ 23E2E5351D9048E7006F38BB /* minidump */ = { isa = PBXGroup; children = ( + 2619C4812107A9A1009CDE81 /* RegisterContextMinidump_ARM.cpp */, + 2619C4832107A9A2009CDE81 /* RegisterContextMinidump_ARM.h */, + 2619C4802107A9A1009CDE81 /* RegisterContextMinidump_ARM64.cpp */, + 2619C4822107A9A2009CDE81 /* RegisterContextMinidump_ARM64.h */, AFD65C7F1D9B5B2E00D93120 /* RegisterContextMinidump_x86_64.cpp */, AFD65C801D9B5B2E00D93120 /* RegisterContextMinidump_x86_64.h */, 23E2E5361D9048FB006F38BB /* CMakeLists.txt */, @@ -4981,6 +4997,8 @@ 26BC7E7610F1B85900F91463 /* Disassembler.cpp */, 4C4EB7821E6A4DE7002035C0 /* DumpDataExtractor.h */, 4C4EB77F1E6A4DB8002035C0 /* DumpDataExtractor.cpp */, + 2619C48A2107ABDD009CDE81 /* DumpRegisterValue.h */, + 2619C4882107ABD3009CDE81 /* DumpRegisterValue.cpp */, 26BC7D5F10F1B77400F91463 /* dwarf.h */, 26D9FDC612F784E60003F2EE /* EmulateInstruction.h */, 26D9FDC812F784FD0003F2EE /* EmulateInstruction.cpp */, @@ -6925,8 +6943,11 @@ AF6CA6681FBBAF37005A0DC3 /* ArchSpec.h in Headers */, AF235EB41FBE7858009C5541 /* RegisterInfoPOSIX_ppc64le.h in Headers */, AF2E02A41FA2CEAF00A86C34 /* ArchitectureArm.h in Headers */, + 2619C4872107A9A2009CDE81 /* RegisterContextMinidump_ARM.h in Headers */, 267F685A1CC02EBE0086832B /* RegisterInfos_s390x.h in Headers */, + 2619C48B2107ABDD009CDE81 /* DumpRegisterValue.h in Headers */, 267F68541CC02E920086832B /* RegisterContextLinux_s390x.h in Headers */, + 2619C4862107A9A2009CDE81 /* RegisterContextMinidump_ARM64.h in Headers */, AF235EB11FBE77B6009C5541 /* RegisterContextPOSIX_ppc64le.h in Headers */, 267F68501CC02E270086832B /* RegisterContextPOSIXCore_s390x.h in Headers */, 4984BA181B979C08008658D4 /* ExpressionVariable.h in Headers */, @@ -7627,6 +7648,7 @@ 2689002113353DDE00698AC0 /* CommandObjectQuit.cpp in Sources */, 2689002213353DDE00698AC0 /* CommandObjectRegister.cpp in Sources */, 26BC17AF18C7F4CB00D2196D /* RegisterContextPOSIXCore_x86_64.cpp in Sources */, + 2619C4842107A9A2009CDE81 /* RegisterContextMinidump_ARM64.cpp in Sources */, 2689002313353DDE00698AC0 /* CommandObjectScript.cpp in Sources */, 2689002413353DDE00698AC0 /* CommandObjectSettings.cpp in Sources */, 2689002513353DDE00698AC0 /* CommandObjectSource.cpp in Sources */, @@ -7707,6 +7729,7 @@ 2689005113353E0400698AC0 /* StringList.cpp in Sources */, 2689005213353E0400698AC0 /* Timer.cpp in Sources */, 2689005413353E0400698AC0 /* UserSettingsController.cpp in Sources */, + 2619C4852107A9A2009CDE81 /* RegisterContextMinidump_ARM.cpp in Sources */, 23059A0719532B96007B8189 /* LinuxSignals.cpp in Sources */, 8CCB017E19BA28A80009FD44 /* ThreadCollection.cpp in Sources */, 9A77AD541E64E2760025CE04 /* RegisterInfoPOSIX_arm.cpp in Sources */, @@ -8049,6 +8072,7 @@ 267C01371368C49C006E963E /* OptionGroupOutputFile.cpp in Sources */, 260E07C6136FA69E00CF21D3 /* OptionGroupUUID.cpp in Sources */, AFC2DCF91E6E318000283714 /* StreamGDBRemote.cpp in Sources */, + 2619C4892107ABD4009CDE81 /* DumpRegisterValue.cpp in Sources */, 260E07C8136FAB9200CF21D3 /* OptionGroupFile.cpp in Sources */, 2686536C1370ACB200D186A3 /* OptionGroupBoolean.cpp in Sources */, 268653701370AE7200D186A3 /* OptionGroupUInt64.cpp in Sources */, Index: packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py =================================================================== --- packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py +++ packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py @@ -189,6 +189,137 @@ stop_description = thread.GetStopDescription(256) self.assertEqual(stop_description, "") + def check_register_unsigned(self, set, name, expected): + reg_value = set.GetChildMemberWithName(name) + self.assertTrue(reg_value.IsValid(), + 'Verify we have a register named "%s"' % (name)) + self.assertEqual(reg_value.GetValueAsUnsigned(), expected, + 'Verify "%s" == %i' % (name, expected)) + + def check_register_string_value(self, set, name, expected): + reg_value = set.GetChildMemberWithName(name) + self.assertTrue(reg_value.IsValid(), + 'Verify we have a register named "%s"' % (name)) + self.assertEqual(reg_value.GetValue(), expected, + 'Verify "%s" has string value "%s"' % (name, + expected)) + + def test_arm64_registers(self): + """Test ARM64 registers from a breakpad created minidump.""" + # target create -c arm64-macos.dmp + self.dbg.CreateTarget(None) + self.target = self.dbg.GetSelectedTarget() + self.process = self.target.LoadCore("arm64-macos.dmp") + self.check_state() + self.assertEqual(self.process.GetNumThreads(), 1) + thread = self.process.GetThreadAtIndex(0) + self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone) + stop_description = thread.GetStopDescription(256) + self.assertEqual(stop_description, "") + registers = thread.GetFrameAtIndex(0).GetRegisters() + # Verify the GPR registers are all correct + # Verify x0 - x31 register values + gpr = registers.GetValueAtIndex(0) + for x in range(32): + self.check_register_unsigned(gpr, 'x%i' % (x), x) + # Verify arg1 - arg8 register values + for x in range(8): + self.check_register_unsigned(gpr, 'arg%i' % (x+1), x) + self.check_register_unsigned(gpr, 'fp', 0x1d) + self.check_register_unsigned(gpr, 'lr', 0x1e) + self.check_register_unsigned(gpr, 'sp', 0x1f) + self.check_register_unsigned(gpr, 'pc', 0x1000) + self.check_register_unsigned(gpr, 'cpsr', 0x11223344) + self.check_register_unsigned(gpr, 'psr', 0x11223344) + + # Verify the FPR registers are all correct + fpr = registers.GetValueAtIndex(1) + for v in range(32): + byte_str = "%#2.2x" % (v) + value = ("{{{0} {0} {0} {0} {0} {0} {0} {0} {0} {0} {0} {0} {0} " + "{0} {0} {0}}}").format(byte_str) + self.check_register_string_value(fpr, "v%i" % (v), value) + self.check_register_unsigned(gpr, 'fpsr', 0x55667788) + self.check_register_unsigned(gpr, 'fpcr', 0x99aabbcc) + + def test_apple_arm_registers(self): + """Test Apple ARM registers from a breakpad created minidump. + + The frame pointer is R7 for Apple. + """ + # target create -c arm-macos.dmp + self.dbg.CreateTarget(None) + self.target = self.dbg.GetSelectedTarget() + self.process = self.target.LoadCore("arm-macos.dmp") + self.check_state() + self.assertEqual(self.process.GetNumThreads(), 1) + thread = self.process.GetThreadAtIndex(0) + self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone) + stop_description = thread.GetStopDescription(256) + self.assertEqual(stop_description, "") + registers = thread.GetFrameAtIndex(0).GetRegisters() + # Verify the GPR registers are all correct + # Verify x0 - x31 register values + gpr = registers.GetValueAtIndex(0) + for x in range(16): + self.check_register_unsigned(gpr, 'r%i' % (x), x) + # Verify arg1 - arg4 register values + for x in range(4): + self.check_register_unsigned(gpr, 'arg%i' % (x+1), x) + self.check_register_unsigned(gpr, 'fp', 0x07) + self.check_register_unsigned(gpr, 'lr', 0x0e) + self.check_register_unsigned(gpr, 'sp', 0x0d) + self.check_register_unsigned(gpr, 'pc', 0x0f) + self.check_register_unsigned(gpr, 'cpsr', 0x11223344) + + # Verify the FPR registers are all correct + fpr = registers.GetValueAtIndex(1) + for v in range(32): + byte_str = "%#2.2x" % (v) + format_str = "{{{0} 0x00 0x00 0x00 {0} 0x00 0x00 0x00}}" + value = format_str.format(byte_str) + self.check_register_string_value(fpr, "d%i" % (v), value) + self.check_register_unsigned(gpr, 'fpscr', 0x55667788aabbccdd) + + def test_linux_arm_registers(self): + """Test Linux ARM registers from a breakpad created minidump. + + The frame pointer is R11 for linux. + """ + # target create -c arm-macos.dmp + self.dbg.CreateTarget(None) + self.target = self.dbg.GetSelectedTarget() + self.process = self.target.LoadCore("arm-linux.dmp") + self.check_state() + self.assertEqual(self.process.GetNumThreads(), 1) + thread = self.process.GetThreadAtIndex(0) + self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone) + stop_description = thread.GetStopDescription(256) + self.assertEqual(stop_description, "") + registers = thread.GetFrameAtIndex(0).GetRegisters() + # Verify the GPR registers are all correct + # Verify x0 - x31 register values + gpr = registers.GetValueAtIndex(0) + for x in range(16): + self.check_register_unsigned(gpr, 'r%i' % (x), x) + # Verify arg1 - arg4 register values + for x in range(4): + self.check_register_unsigned(gpr, 'arg%i' % (x+1), x) + self.check_register_unsigned(gpr, 'fp', 0x0b) + self.check_register_unsigned(gpr, 'lr', 0x0e) + self.check_register_unsigned(gpr, 'sp', 0x0d) + self.check_register_unsigned(gpr, 'pc', 0x0f) + self.check_register_unsigned(gpr, 'cpsr', 0x11223344) + + # Verify the FPR registers are all correct + fpr = registers.GetValueAtIndex(1) + for v in range(32): + byte_str = "%#2.2x" % (v) + format_str = "{{{0} 0x00 0x00 0x00 {0} 0x00 0x00 0x00}}" + value = format_str.format(byte_str) + self.check_register_string_value(fpr, "d%i" % (v), value) + self.check_register_unsigned(gpr, 'fpscr', 0x55667788aabbccdd) + def do_test_deeper_stack(self, binary, core, pid): target = self.dbg.CreateTarget(binary) process = target.LoadCore(core) Index: source/Plugins/Process/minidump/MinidumpParser.h =================================================================== --- source/Plugins/Process/minidump/MinidumpParser.h +++ source/Plugins/Process/minidump/MinidumpParser.h @@ -98,6 +98,7 @@ private: lldb::DataBufferSP m_data_sp; llvm::DenseMap m_directory_map; + ArchSpec m_arch; }; } // end namespace minidump Index: source/Plugins/Process/minidump/MinidumpParser.cpp =================================================================== --- source/Plugins/Process/minidump/MinidumpParser.cpp +++ source/Plugins/Process/minidump/MinidumpParser.cpp @@ -146,11 +146,12 @@ } ArchSpec MinidumpParser::GetArchitecture() { - ArchSpec arch_spec; + if (m_arch.IsValid()) + return m_arch; const MinidumpSystemInfo *system_info = GetSystemInfo(); if (!system_info) - return arch_spec; + return m_arch; // TODO what to do about big endiand flavors of arm ? // TODO set the arm subarch stuff if the minidump has info about it @@ -196,19 +197,28 @@ break; case MinidumpOSPlatform::MacOSX: triple.setOS(llvm::Triple::OSType::MacOSX); + triple.setVendor(llvm::Triple::Apple); break; + case MinidumpOSPlatform::IOS: + triple.setOS(llvm::Triple::OSType::IOS); + triple.setVendor(llvm::Triple::Apple); + break; case MinidumpOSPlatform::Android: triple.setOS(llvm::Triple::OSType::Linux); triple.setEnvironment(llvm::Triple::EnvironmentType::Android); break; - default: - triple.setOS(llvm::Triple::OSType::UnknownOS); - break; + default: { + triple.setOS(llvm::Triple::OSType::UnknownOS); + std::string csd_version; + if (auto s = GetMinidumpString(system_info->csd_version_rva)) + csd_version = *s; + if (csd_version.find("Linux") != std::string::npos) + triple.setOS(llvm::Triple::OSType::Linux); + break; + } } - - arch_spec.SetTriple(triple); - - return arch_spec; + m_arch.SetTriple(triple); + return m_arch; } const MinidumpMiscInfo *MinidumpParser::GetMiscInfo() { Index: source/Plugins/Process/minidump/ProcessMinidump.cpp =================================================================== --- source/Plugins/Process/minidump/ProcessMinidump.cpp +++ source/Plugins/Process/minidump/ProcessMinidump.cpp @@ -12,6 +12,7 @@ #include "ThreadMinidump.h" // Other libraries and framework includes +#include "lldb/Core/Architecture.h" #include "lldb/Core/Module.h" #include "lldb/Core/ModuleSpec.h" #include "lldb/Core/PluginManager.h" @@ -19,6 +20,7 @@ #include "lldb/Core/State.h" #include "lldb/Target/DynamicLoader.h" #include "lldb/Target/MemoryRegionInfo.h" +#include "lldb/Target/Platform.h" #include "lldb/Target/SectionLoadList.h" #include "lldb/Target/Target.h" #include "lldb/Target/UnixSignals.h" @@ -29,6 +31,7 @@ #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Threading.h" +#include "Plugins/Process/Utility/StopInfoMachException.h" // C includes // C++ includes @@ -169,14 +172,31 @@ if (error.Fail()) return error; - // Do we support the minidump's architecture? - ArchSpec arch = GetArchitecture(); + Target &target = GetTarget(); + auto arch = GetArchitecture(); + if (arch.IsValid()) { + auto platform_sp = target.GetPlatform(); + if (platform_sp && !platform_sp->IsCompatibleArchitecture(arch, false, nullptr)) { + ArchSpec platform_arch; + auto arch_platform_sp = Platform::GetPlatformForArchitecture( + arch, &platform_arch); + if (arch_platform_sp) { + target.SetPlatform(arch_platform_sp); + if (platform_arch.IsValid()) + arch = platform_arch; + } + } + } + target.SetArchitecture(arch); + switch (arch.GetMachine()) { case llvm::Triple::x86: case llvm::Triple::x86_64: - // supported + case llvm::Triple::arm: + case llvm::Triple::aarch64: + // Any supported architectures must be listed here and also supported in + // ThreadMinidump::CreateRegisterContextForFrame(). break; - default: error.SetErrorStringWithFormat("unsupported minidump architecture: %s", arch.GetArchitectureName()); @@ -186,7 +206,6 @@ m_thread_list = m_minidump_parser.GetThreads(); m_active_exception = m_minidump_parser.GetExceptionStream(); ReadModuleList(); - GetTarget().SetArchitecture(arch); llvm::Optional pid = m_minidump_parser.GetPid(); if (!pid) { @@ -229,6 +248,12 @@ if (arch.GetTriple().getOS() == llvm::Triple::Linux) { stop_info = StopInfo::CreateStopReasonWithSignal( *stop_thread, m_active_exception->exception_record.exception_code); + } else if (arch.GetTriple().getVendor() == llvm::Triple::Apple) { + stop_info = StopInfoMachException::CreateStopReasonWithMachException( + *stop_thread, + m_active_exception->exception_record.exception_code, 2, + m_active_exception->exception_record.exception_flags, + m_active_exception->exception_record.exception_address, 0); } else { std::string desc; llvm::raw_string_ostream desc_stream(desc); Index: source/Plugins/Process/minidump/RegisterContextMinidump_ARM.h =================================================================== --- source/Plugins/Process/minidump/RegisterContextMinidump_ARM.h +++ source/Plugins/Process/minidump/RegisterContextMinidump_ARM.h @@ -0,0 +1,88 @@ +//===-- RegisterContextMinidump_ARM.h ---------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_RegisterContextMinidump_ARM_h_ +#define liblldb_RegisterContextMinidump_ARM_h_ + +// Project includes +#include "MinidumpTypes.h" + +// Other libraries and framework includes +#include "Plugins/Process/Utility/RegisterInfoInterface.h" + +#include "lldb/Target/RegisterContext.h" + +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/BitmaskEnum.h" + +// C includes +// C++ includes + +namespace lldb_private { + +namespace minidump { + +LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(); + +class RegisterContextMinidump_ARM: public lldb_private::RegisterContext { +public: + RegisterContextMinidump_ARM(lldb_private::Thread &thread, + const DataExtractor &data, bool apple); + + ~RegisterContextMinidump_ARM() override {} + + void InvalidateAllRegisters() override { + // Do nothing... registers are always valid... + } + + size_t GetRegisterCount() override; + + const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override; + + size_t GetRegisterSetCount() override; + + const lldb_private::RegisterSet *GetRegisterSet(size_t set) override; + + const char *GetRegisterName(unsigned reg); + + bool ReadRegister(const RegisterInfo *reg_info, + RegisterValue ®_value) override; + + bool WriteRegister(const RegisterInfo *reg_info, + const RegisterValue ®_value) override; + + + uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, + uint32_t num) override; + + // Reference: see breakpad/crashpad source + struct Context { + uint32_t context_flags; + uint32_t r[16]; + uint32_t cpsr; + uint64_t fpscr; + uint64_t d[32]; + uint32_t extra[8]; + }; + + protected: + enum class Flags : uint32_t { + ARM_Flag = 0x40000000, + Integer = ARM_Flag | 0x00000002, + FloatingPoint = ARM_Flag | 0x00000004, + LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ FloatingPoint) + }; + Context m_regs; + RegisterInfo *m_reg_infos; + size_t m_num_reg_infos; +}; + +} // end namespace minidump +} // end namespace lldb_private +#endif // liblldb_RegisterContextMinidump_ARM_h_ Index: source/Plugins/Process/minidump/RegisterContextMinidump_ARM.cpp =================================================================== --- source/Plugins/Process/minidump/RegisterContextMinidump_ARM.cpp +++ source/Plugins/Process/minidump/RegisterContextMinidump_ARM.cpp @@ -0,0 +1,292 @@ +//===-- RegisterContextMinidump_ARM.cpp -------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Project includes +#include "RegisterContextMinidump_ARM.h" + +// Other libraries and framework includes +#include "lldb/lldb-enumerations.h" +#include "lldb/Core/RegisterValue.h" +#include "lldb/Utility/DataExtractor.h" +#include "Utility/ARM_DWARF_Registers.h" + +// C includes +#include + +// C++ includes + +using namespace lldb; +using namespace lldb_private; +using namespace minidump; + +#define INV LLDB_INVALID_REGNUM +#define OFFSET(r) (offsetof(RegisterContextMinidump_ARM::Context, r)) + +#define DEF_R(i) {"r"#i, nullptr, 4, OFFSET(r[i]), eEncodingUint, eFormatHex, \ + {INV, dwarf_r##i, INV, INV, reg_r##i}, \ + nullptr, nullptr, nullptr, 0} + +#define DEF_R_ARG(i, n) {"r"#i, "arg"#n, 4, OFFSET(r[i]), eEncodingUint,\ + eFormatHex, {INV, dwarf_r##i, LLDB_REGNUM_GENERIC_ARG1+i, INV, reg_r##i},\ + nullptr, nullptr, nullptr, 0} + +#define DEF_D(i) {"d"#i, nullptr, 8, OFFSET(d[i]), eEncodingVector,\ + eFormatVectorOfUInt8, {INV, dwarf_d##i, INV, INV, reg_d##i}, \ + nullptr, nullptr, nullptr, 0} + +// Zero based LLDB register numbers for this register context +enum { + // General Purpose Registers + reg_r0, reg_r1, reg_r2, reg_r3, reg_r4, reg_r5, reg_r6, reg_r7, + reg_r8, reg_r9, reg_r10, reg_r11, reg_r12, reg_sp, reg_lr, reg_pc, + reg_cpsr, + // Floating Point Registers + reg_fpscr, + reg_d0, reg_d1, reg_d2, reg_d3, reg_d4, reg_d5, reg_d6, reg_d7, + reg_d8, reg_d9, reg_d10, reg_d11, reg_d12, reg_d13, reg_d14, reg_d15, + reg_d16, reg_d17, reg_d18, reg_d19, reg_d20, reg_d21, reg_d22, reg_d23, + reg_d24, reg_d25, reg_d26, reg_d27, reg_d28, reg_d29, reg_d30, reg_d31, + k_num_regs +}; + +// Register info definitions for this register context +static RegisterInfo g_reg_infos_apple[] = { + DEF_R_ARG(0, 1), + DEF_R_ARG(1, 2), + DEF_R_ARG(2, 3), + DEF_R_ARG(3, 4), + DEF_R(4), + DEF_R(5), + DEF_R(6), + {"fp", "r7", 4, OFFSET(r[7]), eEncodingUint, eFormatHex, + {INV, dwarf_r7, LLDB_REGNUM_GENERIC_FP, INV, reg_r7}, + nullptr, nullptr, nullptr, 0}, + DEF_R(8), + DEF_R(9), + DEF_R(10), + DEF_R(11), + DEF_R(12), + {"sp", "r13", 4, OFFSET(r[13]), eEncodingUint, eFormatHex, + {INV, dwarf_sp, LLDB_REGNUM_GENERIC_SP, INV, reg_sp}, + nullptr, nullptr, nullptr, 0}, + {"lr", "r14", 4, OFFSET(r[14]), eEncodingUint, eFormatHex, + {INV, dwarf_lr, LLDB_REGNUM_GENERIC_RA, INV, reg_lr}, + nullptr, nullptr, nullptr, 0}, + {"pc", "r15", 4, OFFSET(r[15]), eEncodingUint, eFormatHex, + {INV, dwarf_pc, LLDB_REGNUM_GENERIC_PC, INV, reg_pc}, + nullptr, nullptr, nullptr, 0}, + {"cpsr", "psr", 4, OFFSET(cpsr), eEncodingUint, eFormatHex, + {INV, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, INV, reg_cpsr}, + nullptr, nullptr, nullptr, 0}, + {"fpscr", nullptr, 8, OFFSET(fpscr), eEncodingUint, eFormatHex, + {INV, INV, INV, INV, reg_fpscr}, + nullptr, nullptr, nullptr, 0}, + DEF_D(0), + DEF_D(1), + DEF_D(2), + DEF_D(3), + DEF_D(4), + DEF_D(5), + DEF_D(6), + DEF_D(7), + DEF_D(8), + DEF_D(9), + DEF_D(10), + DEF_D(11), + DEF_D(12), + DEF_D(13), + DEF_D(14), + DEF_D(15), + DEF_D(16), + DEF_D(17), + DEF_D(18), + DEF_D(19), + DEF_D(20), + DEF_D(21), + DEF_D(22), + DEF_D(23), + DEF_D(24), + DEF_D(25), + DEF_D(26), + DEF_D(27), + DEF_D(28), + DEF_D(29), + DEF_D(30), + DEF_D(31), +}; + +static size_t k_num_reg_infos_apple = llvm::array_lengthof(g_reg_infos_apple); + +// Register info definitions for this register context +static RegisterInfo g_reg_infos[] = { + DEF_R_ARG(0, 1), + DEF_R_ARG(1, 2), + DEF_R_ARG(2, 3), + DEF_R_ARG(3, 4), + DEF_R(4), + DEF_R(5), + DEF_R(6), + DEF_R(7), + DEF_R(8), + DEF_R(9), + DEF_R(10), + {"fp", "r11", 4, OFFSET(r[11]), eEncodingUint, eFormatHex, + {INV, dwarf_r11, LLDB_REGNUM_GENERIC_FP, INV, reg_r11}, + nullptr, nullptr, nullptr, 0}, + DEF_R(12), + {"sp", "r13", 4, OFFSET(r[13]), eEncodingUint, eFormatHex, + {INV, dwarf_sp, LLDB_REGNUM_GENERIC_SP, INV, reg_sp}, + nullptr, nullptr, nullptr, 0}, + {"lr", "r14", 4, OFFSET(r[14]), eEncodingUint, eFormatHex, + {INV, dwarf_lr, LLDB_REGNUM_GENERIC_RA, INV, reg_lr}, + nullptr, nullptr, nullptr, 0}, + {"pc", "r15", 4, OFFSET(r[15]), eEncodingUint, eFormatHex, + {INV, dwarf_pc, LLDB_REGNUM_GENERIC_PC, INV, reg_pc}, + nullptr, nullptr, nullptr, 0}, + {"cpsr", "psr", 4, OFFSET(cpsr), eEncodingUint, eFormatHex, + {INV, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, INV, reg_cpsr}, + nullptr, nullptr, nullptr, 0}, + {"fpscr", nullptr, 8, OFFSET(fpscr), eEncodingUint, eFormatHex, + {INV, INV, INV, INV, reg_fpscr}, + nullptr, nullptr, nullptr, 0}, + DEF_D(0), + DEF_D(1), + DEF_D(2), + DEF_D(3), + DEF_D(4), + DEF_D(5), + DEF_D(6), + DEF_D(7), + DEF_D(8), + DEF_D(9), + DEF_D(10), + DEF_D(11), + DEF_D(12), + DEF_D(13), + DEF_D(14), + DEF_D(15), + DEF_D(16), + DEF_D(17), + DEF_D(18), + DEF_D(19), + DEF_D(20), + DEF_D(21), + DEF_D(22), + DEF_D(23), + DEF_D(24), + DEF_D(25), + DEF_D(26), + DEF_D(27), + DEF_D(28), + DEF_D(29), + DEF_D(30), + DEF_D(31), +}; + +static size_t k_num_reg_infos = llvm::array_lengthof(g_reg_infos); + +// ARM general purpose registers. +const uint32_t g_gpr_regnums[] = { + reg_r0, reg_r1, reg_r2, reg_r3, reg_r4, reg_r5, reg_r6, reg_r7, + reg_r8, reg_r9, reg_r10, reg_r11, reg_r12, reg_sp, reg_lr, reg_pc, + reg_cpsr, + LLDB_INVALID_REGNUM // register sets need to end with this flag +}; +const uint32_t g_fpu_regnums[] = { + reg_fpscr, + reg_d0, reg_d1, reg_d2, reg_d3, reg_d4, reg_d5, reg_d6, reg_d7, + reg_d8, reg_d9, reg_d10, reg_d11, reg_d12, reg_d13, reg_d14, reg_d15, + reg_d16, reg_d17, reg_d18, reg_d19, reg_d20, reg_d21, reg_d22, reg_d23, + reg_d24, reg_d25, reg_d26, reg_d27, reg_d28, reg_d29, reg_d30, reg_d31, + LLDB_INVALID_REGNUM // register sets need to end with this flag +}; + +// Skip the last LLDB_INVALID_REGNUM in each count below by subtracting 1 +static size_t k_num_gpr_regs = llvm::array_lengthof(g_gpr_regnums) - 1; +static size_t k_num_fpu_regs = llvm::array_lengthof(g_fpu_regnums) - 1; + +static RegisterSet g_reg_sets[] = { + { "General Purpose Registers", "gpr", k_num_gpr_regs, g_gpr_regnums }, + { "Floating Point Registers", "fpu", k_num_fpu_regs, g_fpu_regnums }, +}; + +static size_t k_num_reg_sets = llvm::array_lengthof(g_reg_sets); + +RegisterContextMinidump_ARM::RegisterContextMinidump_ARM( + Thread &thread, const DataExtractor &data, bool apple) : RegisterContext(thread, 0) { + lldb::offset_t offset = 0; + m_regs.context_flags = data.GetU32(&offset); + for (unsigned i=0; i<16; ++i) + m_regs.r[i] = data.GetU32(&offset); + m_regs.cpsr = data.GetU32(&offset); + m_regs.fpscr = data.GetU64(&offset); + for (unsigned i=0; i<32; ++i) + m_regs.d[i] = data.GetU64(&offset); + assert(k_num_regs == k_num_reg_infos_apple); + assert(k_num_regs == k_num_reg_infos); + if (apple) { + m_reg_infos = g_reg_infos_apple; + m_num_reg_infos = k_num_reg_infos_apple; + } else { + m_reg_infos = g_reg_infos; + m_num_reg_infos = k_num_reg_infos; + } + +} +size_t RegisterContextMinidump_ARM::GetRegisterCount() { + return k_num_regs; +} + +const RegisterInfo * +RegisterContextMinidump_ARM::GetRegisterInfoAtIndex(size_t reg) { + if (reg < k_num_reg_infos) + return &m_reg_infos[reg]; + return nullptr; +} + + +size_t RegisterContextMinidump_ARM::GetRegisterSetCount() { + return k_num_reg_sets; +} + +const RegisterSet *RegisterContextMinidump_ARM::GetRegisterSet(size_t set) { + if (set < k_num_reg_sets) + return &g_reg_sets[set]; + return nullptr; +} + +const char *RegisterContextMinidump_ARM::GetRegisterName(unsigned reg) { + if (reg < k_num_reg_infos) + return m_reg_infos[reg].name; + return nullptr; +} + +bool RegisterContextMinidump_ARM::ReadRegister( + const RegisterInfo *reg_info, RegisterValue ®_value) { + Status error; + reg_value.SetFromMemoryData(reg_info, + (const uint8_t *)&m_regs + reg_info->byte_offset, + reg_info->byte_size, lldb::eByteOrderLittle, + error); + return error.Success(); +} + +bool RegisterContextMinidump_ARM::WriteRegister( + const RegisterInfo *reg_info, const RegisterValue ®_value) { + return false; +} + +uint32_t RegisterContextMinidump_ARM::ConvertRegisterKindToRegisterNumber( + lldb::RegisterKind kind, uint32_t num) { + for (size_t i=0; i + +// C++ includes + +using namespace lldb; +using namespace lldb_private; +using namespace minidump; + +#define INV LLDB_INVALID_REGNUM +#define OFFSET(r) (offsetof(RegisterContextMinidump_ARM64::Context, r)) + +#define DEF_X(i) {"x"#i, nullptr, 8, OFFSET(x[i]), eEncodingUint, eFormatHex, \ +{INV, arm64_dwarf::x##i, INV, INV, reg_x##i}, nullptr, nullptr, nullptr, 0} + +#define DEF_X_ARG(i, n) {"x"#i, "arg"#n, 8, OFFSET(x[i]), eEncodingUint,\ + eFormatHex, {INV, arm64_dwarf::x##i, LLDB_REGNUM_GENERIC_ARG1+i, INV, reg_x##i},\ + nullptr, nullptr, nullptr, 0} + +#define DEF_FPR(i) {"v"#i, nullptr, 16, OFFSET(v[i*16]), eEncodingVector,\ + eFormatVectorOfUInt8, {INV, arm64_dwarf::v##i, INV, INV, reg_v##i}, \ + nullptr, nullptr, nullptr, 0} + +// Zero based LLDB register numbers for this register context +enum { + // General Purpose Registers + reg_x0 = 0, reg_x1, reg_x2, reg_x3, reg_x4, reg_x5, reg_x6, reg_x7, reg_x8, + reg_x9, reg_x10, reg_x11, reg_x12, reg_x13, reg_x14, reg_x15, reg_x16, + reg_x17, reg_x18, reg_x19, reg_x20, reg_x21, reg_x22, reg_x23, reg_x24, + reg_x25, reg_x26, reg_x27, reg_x28, reg_fp, reg_lr, reg_sp, reg_pc, reg_cpsr, + // Floating Point Registers + reg_fpsr, reg_fpcr, + reg_v0, reg_v1, reg_v2, reg_v3, reg_v4, reg_v5, reg_v6, reg_v7, reg_v8, + reg_v9, reg_v10, reg_v11, reg_v12, reg_v13, reg_v14, reg_v15, reg_v16, + reg_v17, reg_v18, reg_v19, reg_v20, reg_v21, reg_v22, reg_v23, reg_v24, + reg_v25, reg_v26, reg_v27, reg_v28, reg_v29, reg_v30, reg_v31, + k_num_regs +}; + +// Register info definitions for this register context +static RegisterInfo g_reg_infos[] = { + DEF_X_ARG(0, 1), + DEF_X_ARG(1, 2), + DEF_X_ARG(2, 3), + DEF_X_ARG(3, 4), + DEF_X_ARG(4, 5), + DEF_X_ARG(5, 6), + DEF_X_ARG(6, 7), + DEF_X_ARG(7, 8), + DEF_X(8), + DEF_X(9), + DEF_X(10), + DEF_X(11), + DEF_X(12), + DEF_X(13), + DEF_X(14), + DEF_X(15), + DEF_X(16), + DEF_X(17), + DEF_X(18), + DEF_X(19), + DEF_X(20), + DEF_X(21), + DEF_X(22), + DEF_X(23), + DEF_X(24), + DEF_X(25), + DEF_X(26), + DEF_X(27), + DEF_X(28), + {"fp", "x29", 8, OFFSET(x[29]), eEncodingUint, eFormatHex, + {INV, arm64_dwarf::x29, LLDB_REGNUM_GENERIC_FP, INV, reg_fp}, + nullptr, nullptr, nullptr, 0}, + {"lr", "x30", 8, OFFSET(x[30]), eEncodingUint, eFormatHex, + {INV, arm64_dwarf::x30, LLDB_REGNUM_GENERIC_RA, INV, reg_lr}, + nullptr, nullptr, nullptr, 0}, + {"sp", "x31", 8, OFFSET(x[31]), eEncodingUint, eFormatHex, + {INV, arm64_dwarf::x31, LLDB_REGNUM_GENERIC_SP, INV, reg_sp}, + nullptr, nullptr, nullptr, 0}, + {"pc", nullptr, 8, OFFSET(pc), eEncodingUint, eFormatHex, + {INV, arm64_dwarf::pc, LLDB_REGNUM_GENERIC_PC, INV, reg_pc}, + nullptr, nullptr, nullptr, 0}, + {"cpsr", "psr", 4, OFFSET(cpsr), eEncodingUint, eFormatHex, + {INV, arm64_dwarf::cpsr, LLDB_REGNUM_GENERIC_FLAGS, INV, reg_cpsr}, + nullptr, nullptr, nullptr, 0}, + {"fpsr", nullptr, 4, OFFSET(fpsr), eEncodingUint, eFormatHex, + {INV, INV, INV, INV, reg_fpsr}, + nullptr, nullptr, nullptr, 0}, + {"fpcr", nullptr, 4, OFFSET(fpcr), eEncodingUint, eFormatHex, + {INV, INV, INV, INV, reg_fpcr}, + nullptr, nullptr, nullptr, 0}, + DEF_FPR(0), + DEF_FPR(1), + DEF_FPR(2), + DEF_FPR(3), + DEF_FPR(4), + DEF_FPR(5), + DEF_FPR(6), + DEF_FPR(7), + DEF_FPR(8), + DEF_FPR(9), + DEF_FPR(10), + DEF_FPR(11), + DEF_FPR(12), + DEF_FPR(13), + DEF_FPR(14), + DEF_FPR(15), + DEF_FPR(16), + DEF_FPR(17), + DEF_FPR(18), + DEF_FPR(19), + DEF_FPR(20), + DEF_FPR(21), + DEF_FPR(22), + DEF_FPR(23), + DEF_FPR(24), + DEF_FPR(25), + DEF_FPR(26), + DEF_FPR(27), + DEF_FPR(28), + DEF_FPR(29), + DEF_FPR(30), + DEF_FPR(31), +}; + +static size_t k_num_reg_infos = llvm::array_lengthof(g_reg_infos); + +// ARM64 general purpose registers. +const uint32_t g_gpr_regnums[] = { + reg_x0, reg_x1, reg_x2, reg_x3, reg_x4, reg_x5, reg_x6, reg_x7, + reg_x8, reg_x9, reg_x10, reg_x11, reg_x12, reg_x13, reg_x14, reg_x15, + reg_x16, reg_x17, reg_x18, reg_x19, reg_x20, reg_x21, reg_x22, reg_x23, + reg_x24, reg_x25, reg_x26, reg_x27, reg_x28, reg_fp, reg_lr, reg_sp, + reg_pc, reg_cpsr, + LLDB_INVALID_REGNUM // register sets need to end with this flag +}; +const uint32_t g_fpu_regnums[] = { + reg_v0, reg_v1, reg_v2, reg_v3, reg_v4, reg_v5, reg_v6, reg_v7, + reg_v8, reg_v9, reg_v10, reg_v11, reg_v12, reg_v13, reg_v14, reg_v15, + reg_v16, reg_v17, reg_v18, reg_v19, reg_v20, reg_v21, reg_v22, reg_v23, + reg_v24, reg_v25, reg_v26, reg_v27, reg_v28, reg_v29, reg_v30, reg_v31, + reg_fpsr, reg_fpcr, + LLDB_INVALID_REGNUM // register sets need to end with this flag +}; + +// Skip the last LLDB_INVALID_REGNUM in each count below by subtracting 1 +static size_t k_num_gpr_regs = llvm::array_lengthof(g_gpr_regnums) - 1; +static size_t k_num_fpu_regs = llvm::array_lengthof(g_fpu_regnums) - 1; + +static RegisterSet g_reg_sets[] = { + { "General Purpose Registers", "gpr", k_num_gpr_regs, g_gpr_regnums }, + { "Floating Point Registers", "fpu", k_num_fpu_regs, g_fpu_regnums }, +}; + +static size_t k_num_reg_sets = llvm::array_lengthof(g_reg_sets); + +RegisterContextMinidump_ARM64::RegisterContextMinidump_ARM64( + Thread &thread, const DataExtractor &data) : RegisterContext(thread, 0) { + lldb::offset_t offset = 0; + m_regs.context_flags = data.GetU64(&offset); + for (unsigned i=0; i<32; ++i) + m_regs.x[i] = data.GetU64(&offset); + m_regs.pc = data.GetU64(&offset); + m_regs.cpsr = data.GetU32(&offset); + m_regs.fpsr = data.GetU32(&offset); + m_regs.fpcr = data.GetU32(&offset); + auto regs_data = data.GetData(&offset, sizeof(m_regs.v)); + if (regs_data) + memcpy(m_regs.v, regs_data, sizeof(m_regs.v)); + assert(k_num_regs == k_num_reg_infos); +} +size_t RegisterContextMinidump_ARM64::GetRegisterCount() { + return k_num_regs; +} + +const RegisterInfo * +RegisterContextMinidump_ARM64::GetRegisterInfoAtIndex(size_t reg) { + if (reg < k_num_reg_infos) + return &g_reg_infos[reg]; + return nullptr; +} + + +size_t RegisterContextMinidump_ARM64::GetRegisterSetCount() { + return k_num_reg_sets; +} + +const RegisterSet *RegisterContextMinidump_ARM64::GetRegisterSet(size_t set) { + if (set < k_num_reg_sets) + return &g_reg_sets[set]; + return nullptr; +} + +const char *RegisterContextMinidump_ARM64::GetRegisterName(unsigned reg) { + if (reg < k_num_reg_infos) + return g_reg_infos[reg].name; + return nullptr; +} + +bool RegisterContextMinidump_ARM64::ReadRegister( + const RegisterInfo *reg_info, RegisterValue ®_value) { + Status error; + reg_value.SetFromMemoryData(reg_info, + (const uint8_t *)&m_regs + reg_info->byte_offset, + reg_info->byte_size, lldb::eByteOrderLittle, + error); + return error.Success(); +} + +bool RegisterContextMinidump_ARM64::WriteRegister( + const RegisterInfo *reg_info, const RegisterValue ®_value) { + return false; +} + +uint32_t RegisterContextMinidump_ARM64::ConvertRegisterKindToRegisterNumber( + lldb::RegisterKind kind, uint32_t num) { + for (size_t i=0; i