1 //===-- DumpRegisterInfo.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/Core/DumpRegisterInfo.h" 10 #include "lldb/Target/RegisterContext.h" 11 #include "lldb/Target/RegisterFlags.h" 12 #include "lldb/Utility/Stream.h" 13 14 using namespace lldb; 15 using namespace lldb_private; 16 17 using SetInfo = std::pair<const char *, uint32_t>; 18 19 void lldb_private::DumpRegisterInfo(Stream &strm, RegisterContext &ctx, 20 const RegisterInfo &info, 21 uint32_t terminal_width) { 22 std::vector<const char *> invalidates; 23 if (info.invalidate_regs) { 24 for (uint32_t *inv_regs = info.invalidate_regs; 25 *inv_regs != LLDB_INVALID_REGNUM; ++inv_regs) { 26 const RegisterInfo *inv_info = 27 ctx.GetRegisterInfo(lldb::eRegisterKindLLDB, *inv_regs); 28 assert( 29 inv_info && 30 "Register invalidate list refers to a register that does not exist."); 31 invalidates.push_back(inv_info->name); 32 } 33 } 34 35 // We include the index here so that you can use it with "register read -s". 36 std::vector<SetInfo> in_sets; 37 for (uint32_t set_idx = 0; set_idx < ctx.GetRegisterSetCount(); ++set_idx) { 38 const RegisterSet *set = ctx.GetRegisterSet(set_idx); 39 assert(set && "Register set should be valid."); 40 for (uint32_t reg_idx = 0; reg_idx < set->num_registers; ++reg_idx) { 41 const RegisterInfo *set_reg_info = 42 ctx.GetRegisterInfoAtIndex(set->registers[reg_idx]); 43 assert(set_reg_info && "Register info should be valid."); 44 45 if (set_reg_info == &info) { 46 in_sets.push_back({set->name, set_idx}); 47 break; 48 } 49 } 50 } 51 52 std::vector<const char *> read_from; 53 if (info.value_regs) { 54 for (uint32_t *read_regs = info.value_regs; 55 *read_regs != LLDB_INVALID_REGNUM; ++read_regs) { 56 const RegisterInfo *read_info = 57 ctx.GetRegisterInfo(lldb::eRegisterKindLLDB, *read_regs); 58 assert(read_info && "Register value registers list refers to a register " 59 "that does not exist."); 60 read_from.push_back(read_info->name); 61 } 62 } 63 64 DoDumpRegisterInfo(strm, info.name, info.alt_name, info.byte_size, 65 invalidates, read_from, in_sets, info.flags_type, 66 terminal_width); 67 } 68 69 template <typename ElementType> 70 static void DumpList(Stream &strm, const char *title, 71 const std::vector<ElementType> &list, 72 std::function<void(Stream &, ElementType)> emitter) { 73 if (list.empty()) 74 return; 75 76 strm.EOL(); 77 strm << title; 78 bool first = true; 79 for (ElementType elem : list) { 80 if (!first) 81 strm << ", "; 82 first = false; 83 emitter(strm, elem); 84 } 85 } 86 87 void lldb_private::DoDumpRegisterInfo( 88 Stream &strm, const char *name, const char *alt_name, uint32_t byte_size, 89 const std::vector<const char *> &invalidates, 90 const std::vector<const char *> &read_from, 91 const std::vector<SetInfo> &in_sets, const RegisterFlags *flags_type, 92 uint32_t terminal_width) { 93 strm << " Name: " << name; 94 if (alt_name) 95 strm << " (" << alt_name << ")"; 96 strm.EOL(); 97 98 // Size in bits may seem obvious for the usual 32 or 64 bit registers. 99 // When we get to vector registers, then scalable vector registers, it is very 100 // useful to know without the user doing extra work. 101 strm.Printf(" Size: %d bytes (%d bits)", byte_size, byte_size * 8); 102 103 std::function<void(Stream &, const char *)> emit_str = 104 [](Stream &strm, const char *s) { strm << s; }; 105 DumpList(strm, "Invalidates: ", invalidates, emit_str); 106 DumpList(strm, " Read from: ", read_from, emit_str); 107 108 std::function<void(Stream &, SetInfo)> emit_set = [](Stream &strm, 109 SetInfo info) { 110 strm.Printf("%s (index %d)", info.first, info.second); 111 }; 112 DumpList(strm, " In sets: ", in_sets, emit_set); 113 114 if (flags_type) 115 strm.Printf("\n\n%s", flags_type->AsTable(terminal_width).c_str()); 116 } 117