LLDB mainline
DumpRegisterInfo.cpp
Go to the documentation of this file.
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
12#include "lldb/Utility/Stream.h"
13
14using namespace lldb;
15using namespace lldb_private;
16
17using SetInfo = std::pair<const char *, uint32_t>;
18
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 =
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 =
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
69template <typename ElementType>
70static 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
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}
std::pair< const char *, uint32_t > SetInfo
static void DumpList(Stream &strm, const char *title, const std::vector< ElementType > &list, std::function< void(Stream &, ElementType)> emitter)
virtual const RegisterSet * GetRegisterSet(size_t reg_set)=0
virtual const RegisterInfo * GetRegisterInfoAtIndex(size_t reg)=0
const RegisterInfo * GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num)
virtual size_t GetRegisterSetCount()=0
std::string AsTable(uint32_t max_width) const
Produce a text table showing the layout of all the fields.
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:155
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:87
A class that represents a running process on the host machine.
void DoDumpRegisterInfo(Stream &strm, const char *name, const char *alt_name, uint32_t byte_size, const std::vector< const char * > &invalidates, const std::vector< const char * > &read_from, const std::vector< std::pair< const char *, uint32_t > > &in_sets, const RegisterFlags *flags_type, uint32_t terminal_width)
void DumpRegisterInfo(Stream &strm, RegisterContext &ctx, const RegisterInfo &info, uint32_t terminal_width)
Definition: SBAddress.h:15
@ eRegisterKindLLDB
lldb's internal register numbers
Every register is described in detail including its name, alternate name (optional),...
const char * alt_name
Alternate name of this register, can be NULL.
uint32_t * value_regs
List of registers (terminated with LLDB_INVALID_REGNUM).
uint32_t byte_size
Size in bytes of the register.
const RegisterFlags * flags_type
If not nullptr, a type defined by XML descriptions.
const char * name
Name of this register, can't be NULL.
uint32_t * invalidate_regs
List of registers (terminated with LLDB_INVALID_REGNUM).
Registers are grouped into register sets.
size_t num_registers
The number of registers in REGISTERS array below.
const uint32_t * registers
An array of register indices in this set.
const char * name
Name of this register set.