LLDB mainline
CommandObjectMemory.cpp
Go to the documentation of this file.
1//===-- CommandObjectMemory.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/Core/Section.h"
28#include "lldb/Target/ABI.h"
32#include "lldb/Target/Process.h"
34#include "lldb/Target/Target.h"
35#include "lldb/Target/Thread.h"
36#include "lldb/Utility/Args.h"
39#include "llvm/Support/MathExtras.h"
40#include <cinttypes>
41#include <memory>
42#include <optional>
43
44using namespace lldb;
45using namespace lldb_private;
46
47#define LLDB_OPTIONS_memory_read
48#include "CommandOptions.inc"
49
51public:
53 : m_num_per_line(1, 1), m_offset(0, 0),
55
56 ~OptionGroupReadMemory() override = default;
57
58 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
59 return llvm::ArrayRef(g_memory_read_options);
60 }
61
62 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
63 ExecutionContext *execution_context) override {
65 const int short_option = g_memory_read_options[option_idx].short_option;
66
67 switch (short_option) {
68 case 'l':
71 error.SetErrorStringWithFormat(
72 "invalid value for --num-per-line option '%s'",
73 option_value.str().c_str());
74 break;
75
76 case 'b':
77 m_output_as_binary = true;
78 break;
79
80 case 't':
82 break;
83
84 case 'r':
85 m_force = true;
86 break;
87
88 case 'x':
90 break;
91
92 case 'E':
93 error = m_offset.SetValueFromString(option_value);
94 break;
95
96 default:
97 llvm_unreachable("Unimplemented option");
98 }
99 return error;
100 }
101
102 void OptionParsingStarting(ExecutionContext *execution_context) override {
104 m_output_as_binary = false;
106 m_force = false;
107 m_offset.Clear();
109 }
110
113 OptionValueUInt64 &byte_size_value = format_options.GetByteSizeValue();
114 OptionValueUInt64 &count_value = format_options.GetCountValue();
115 const bool byte_size_option_set = byte_size_value.OptionWasSet();
116 const bool num_per_line_option_set = m_num_per_line.OptionWasSet();
117 const bool count_option_set = format_options.GetCountValue().OptionWasSet();
118
119 switch (format_options.GetFormat()) {
120 default:
121 break;
122
123 case eFormatBoolean:
124 if (!byte_size_option_set)
125 byte_size_value = 1;
126 if (!num_per_line_option_set)
127 m_num_per_line = 1;
128 if (!count_option_set)
129 format_options.GetCountValue() = 8;
130 break;
131
132 case eFormatCString:
133 break;
134
136 if (count_option_set)
137 byte_size_value = target->GetArchitecture().GetMaximumOpcodeByteSize();
138 m_num_per_line = 1;
139 break;
140
142 if (!byte_size_option_set)
143 byte_size_value = target->GetArchitecture().GetAddressByteSize();
144 m_num_per_line = 1;
145 if (!count_option_set)
146 format_options.GetCountValue() = 8;
147 break;
148
149 case eFormatPointer:
150 byte_size_value = target->GetArchitecture().GetAddressByteSize();
151 if (!num_per_line_option_set)
152 m_num_per_line = 4;
153 if (!count_option_set)
154 format_options.GetCountValue() = 8;
155 break;
156
157 case eFormatBinary:
158 case eFormatFloat:
159 case eFormatOctal:
160 case eFormatDecimal:
161 case eFormatEnum:
162 case eFormatUnicode8:
163 case eFormatUnicode16:
164 case eFormatUnicode32:
165 case eFormatUnsigned:
166 case eFormatHexFloat:
167 if (!byte_size_option_set)
168 byte_size_value = 4;
169 if (!num_per_line_option_set)
170 m_num_per_line = 1;
171 if (!count_option_set)
172 format_options.GetCountValue() = 8;
173 break;
174
175 case eFormatBytes:
177 if (byte_size_option_set) {
178 if (byte_size_value > 1)
179 error.SetErrorStringWithFormat(
180 "display format (bytes/bytes with ASCII) conflicts with the "
181 "specified byte size %" PRIu64 "\n"
182 "\tconsider using a different display format or don't specify "
183 "the byte size.",
184 byte_size_value.GetCurrentValue());
185 } else
186 byte_size_value = 1;
187 if (!num_per_line_option_set)
188 m_num_per_line = 16;
189 if (!count_option_set)
190 format_options.GetCountValue() = 32;
191 break;
192
193 case eFormatCharArray:
194 case eFormatChar:
196 if (!byte_size_option_set)
197 byte_size_value = 1;
198 if (!num_per_line_option_set)
199 m_num_per_line = 32;
200 if (!count_option_set)
201 format_options.GetCountValue() = 64;
202 break;
203
204 case eFormatComplex:
205 if (!byte_size_option_set)
206 byte_size_value = 8;
207 if (!num_per_line_option_set)
208 m_num_per_line = 1;
209 if (!count_option_set)
210 format_options.GetCountValue() = 8;
211 break;
212
214 if (!byte_size_option_set)
215 byte_size_value = 8;
216 if (!num_per_line_option_set)
217 m_num_per_line = 1;
218 if (!count_option_set)
219 format_options.GetCountValue() = 8;
220 break;
221
222 case eFormatHex:
223 if (!byte_size_option_set)
224 byte_size_value = 4;
225 if (!num_per_line_option_set) {
226 switch (byte_size_value) {
227 case 1:
228 case 2:
229 m_num_per_line = 8;
230 break;
231 case 4:
232 m_num_per_line = 4;
233 break;
234 case 8:
235 m_num_per_line = 2;
236 break;
237 default:
238 m_num_per_line = 1;
239 break;
240 }
241 }
242 if (!count_option_set)
243 count_value = 8;
244 break;
245
259 if (!byte_size_option_set)
260 byte_size_value = 128;
261 if (!num_per_line_option_set)
262 m_num_per_line = 1;
263 if (!count_option_set)
264 count_value = 4;
265 break;
266 }
267 return error;
268 }
269
270 bool AnyOptionWasSet() const {
274 }
275
277 bool m_output_as_binary = false;
279 bool m_force = false;
282};
283
284// Read memory from the inferior process
286public:
289 interpreter, "memory read",
290 "Read from the memory of the current target process.", nullptr,
291 eCommandRequiresTarget | eCommandProcessMustBePaused),
293 m_memory_tag_options(/*note_binary=*/true),
297 CommandArgumentData start_addr_arg;
298 CommandArgumentData end_addr_arg;
299
300 // Define the first (and only) variant of this arg.
301 start_addr_arg.arg_type = eArgTypeAddressOrExpression;
302 start_addr_arg.arg_repetition = eArgRepeatPlain;
303
304 // There is only one variant this argument could be; put it into the
305 // argument entry.
306 arg1.push_back(start_addr_arg);
307
308 // Define the first (and only) variant of this arg.
310 end_addr_arg.arg_repetition = eArgRepeatOptional;
311
312 // There is only one variant this argument could be; put it into the
313 // argument entry.
314 arg2.push_back(end_addr_arg);
315
316 // Push the data for the first argument into the m_arguments vector.
317 m_arguments.push_back(arg1);
318 m_arguments.push_back(arg2);
319
320 // Add the "--format" and "--count" options to group 1 and 3
328 // Add the "--size" option to group 1 and 2
339 }
340
341 ~CommandObjectMemoryRead() override = default;
342
343 Options *GetOptions() override { return &m_option_group; }
344
345 std::optional<std::string> GetRepeatCommand(Args &current_command_args,
346 uint32_t index) override {
347 return m_cmd_name;
348 }
349
350protected:
351 void DoExecute(Args &command, CommandReturnObject &result) override {
352 // No need to check "target" for validity as eCommandRequiresTarget ensures
353 // it is valid
354 Target *target = m_exe_ctx.GetTargetPtr();
355
356 const size_t argc = command.GetArgumentCount();
357
358 if ((argc == 0 && m_next_addr == LLDB_INVALID_ADDRESS) || argc > 2) {
359 result.AppendErrorWithFormat("%s takes a start address expression with "
360 "an optional end address expression.\n",
361 m_cmd_name.c_str());
362 result.AppendWarning("Expressions should be quoted if they contain "
363 "spaces or other special characters.");
364 return;
365 }
366
367 CompilerType compiler_type;
369
370 const char *view_as_type_cstr =
372 if (view_as_type_cstr && view_as_type_cstr[0]) {
373 // We are viewing memory as a type
374
375 uint32_t reference_count = 0;
376 uint32_t pointer_count = 0;
377 size_t idx;
378
379#define ALL_KEYWORDS \
380 KEYWORD("const") \
381 KEYWORD("volatile") \
382 KEYWORD("restrict") \
383 KEYWORD("struct") \
384 KEYWORD("class") \
385 KEYWORD("union")
386
387#define KEYWORD(s) s,
388 static const char *g_keywords[] = {ALL_KEYWORDS};
389#undef KEYWORD
390
391#define KEYWORD(s) (sizeof(s) - 1),
392 static const int g_keyword_lengths[] = {ALL_KEYWORDS};
393#undef KEYWORD
394
395#undef ALL_KEYWORDS
396
397 static size_t g_num_keywords = sizeof(g_keywords) / sizeof(const char *);
398 std::string type_str(view_as_type_cstr);
399
400 // Remove all instances of g_keywords that are followed by spaces
401 for (size_t i = 0; i < g_num_keywords; ++i) {
402 const char *keyword = g_keywords[i];
403 int keyword_len = g_keyword_lengths[i];
404
405 idx = 0;
406 while ((idx = type_str.find(keyword, idx)) != std::string::npos) {
407 if (type_str[idx + keyword_len] == ' ' ||
408 type_str[idx + keyword_len] == '\t') {
409 type_str.erase(idx, keyword_len + 1);
410 idx = 0;
411 } else {
412 idx += keyword_len;
413 }
414 }
415 }
416 bool done = type_str.empty();
417 //
418 idx = type_str.find_first_not_of(" \t");
419 if (idx > 0 && idx != std::string::npos)
420 type_str.erase(0, idx);
421 while (!done) {
422 // Strip trailing spaces
423 if (type_str.empty())
424 done = true;
425 else {
426 switch (type_str[type_str.size() - 1]) {
427 case '*':
428 ++pointer_count;
429 [[fallthrough]];
430 case ' ':
431 case '\t':
432 type_str.erase(type_str.size() - 1);
433 break;
434
435 case '&':
436 if (reference_count == 0) {
437 reference_count = 1;
438 type_str.erase(type_str.size() - 1);
439 } else {
440 result.AppendErrorWithFormat("invalid type string: '%s'\n",
441 view_as_type_cstr);
442 return;
443 }
444 break;
445
446 default:
447 done = true;
448 break;
449 }
450 }
451 }
452
453 ConstString lookup_type_name(type_str.c_str());
455 ModuleSP search_first;
456 if (frame)
457 search_first = frame->GetSymbolContext(eSymbolContextModule).module_sp;
458 TypeQuery query(lookup_type_name.GetStringRef(),
459 TypeQueryOptions::e_find_one);
460 TypeResults results;
461 target->GetImages().FindTypes(search_first.get(), query, results);
462 TypeSP type_sp = results.GetFirstType();
463
464 if (!type_sp && lookup_type_name.GetCString()) {
465 LanguageType language_for_type =
467 std::set<LanguageType> languages_to_check;
468 if (language_for_type != eLanguageTypeUnknown) {
469 languages_to_check.insert(language_for_type);
470 } else {
471 languages_to_check = Language::GetSupportedLanguages();
472 }
473
474 std::set<CompilerType> user_defined_types;
475 for (auto lang : languages_to_check) {
476 if (auto *persistent_vars =
478 if (std::optional<CompilerType> type =
479 persistent_vars->GetCompilerTypeFromPersistentDecl(
480 lookup_type_name)) {
481 user_defined_types.emplace(*type);
482 }
483 }
484 }
485
486 if (user_defined_types.size() > 1) {
488 "Mutiple types found matching raw type '%s', please disambiguate "
489 "by specifying the language with -x",
490 lookup_type_name.GetCString());
491 return;
492 }
493
494 if (user_defined_types.size() == 1) {
495 compiler_type = *user_defined_types.begin();
496 }
497 }
498
499 if (!compiler_type.IsValid()) {
500 if (type_sp) {
501 compiler_type = type_sp->GetFullCompilerType();
502 } else {
503 result.AppendErrorWithFormat("unable to find any types that match "
504 "the raw type '%s' for full type '%s'\n",
505 lookup_type_name.GetCString(),
506 view_as_type_cstr);
507 return;
508 }
509 }
510
511 while (pointer_count > 0) {
512 CompilerType pointer_type = compiler_type.GetPointerType();
513 if (pointer_type.IsValid())
514 compiler_type = pointer_type;
515 else {
516 result.AppendError("unable make a pointer type\n");
517 return;
518 }
519 --pointer_count;
520 }
521
522 std::optional<uint64_t> size = compiler_type.GetByteSize(nullptr);
523 if (!size) {
525 "unable to get the byte size of the type '%s'\n",
526 view_as_type_cstr);
527 return;
528 }
530
533 } else {
535 }
536
537 // Look for invalid combinations of settings
538 if (error.Fail()) {
539 result.AppendError(error.AsCString());
540 return;
541 }
542
543 lldb::addr_t addr;
544 size_t total_byte_size = 0;
545 if (argc == 0) {
546 // Use the last address and byte size and all options as they were if no
547 // options have been set
548 addr = m_next_addr;
549 total_byte_size = m_prev_byte_size;
550 compiler_type = m_prev_compiler_type;
561 }
562 }
563
564 size_t item_count = m_format_options.GetCountValue().GetCurrentValue();
565
566 // TODO For non-8-bit byte addressable architectures this needs to be
567 // revisited to fully support all lldb's range of formatting options.
568 // Furthermore code memory reads (for those architectures) will not be
569 // correctly formatted even w/o formatting options.
570 size_t item_byte_size =
571 target->GetArchitecture().GetDataByteSize() > 1
572 ? target->GetArchitecture().GetDataByteSize()
574
575 const size_t num_per_line =
577
578 if (total_byte_size == 0) {
579 total_byte_size = item_count * item_byte_size;
580 if (total_byte_size == 0)
581 total_byte_size = 32;
582 }
583
584 if (argc > 0)
585 addr = OptionArgParser::ToAddress(&m_exe_ctx, command[0].ref(),
587
588 if (addr == LLDB_INVALID_ADDRESS) {
589 result.AppendError("invalid start address expression.");
590 result.AppendError(error.AsCString());
591 return;
592 }
593
594 if (argc == 2) {
596 &m_exe_ctx, command[1].ref(), LLDB_INVALID_ADDRESS, nullptr);
597
598 if (end_addr == LLDB_INVALID_ADDRESS) {
599 result.AppendError("invalid end address expression.");
600 result.AppendError(error.AsCString());
601 return;
602 } else if (end_addr <= addr) {
604 "end address (0x%" PRIx64
605 ") must be greater than the start address (0x%" PRIx64 ").\n",
606 end_addr, addr);
607 return;
610 "specify either the end address (0x%" PRIx64
611 ") or the count (--count %" PRIu64 "), not both.\n",
612 end_addr, (uint64_t)item_count);
613 return;
614 }
615
616 total_byte_size = end_addr - addr;
617 item_count = total_byte_size / item_byte_size;
618 }
619
620 uint32_t max_unforced_size = target->GetMaximumMemReadSize();
621
622 if (total_byte_size > max_unforced_size && !m_memory_options.m_force) {
624 "Normally, \'memory read\' will not read over %" PRIu32
625 " bytes of data.\n",
626 max_unforced_size);
628 "Please use --force to override this restriction just once.\n");
629 result.AppendErrorWithFormat("or set target.max-memory-read-size if you "
630 "will often need a larger limit.\n");
631 return;
632 }
633
634 WritableDataBufferSP data_sp;
635 size_t bytes_read = 0;
636 if (compiler_type.GetOpaqueQualType()) {
637 // Make sure we don't display our type as ASCII bytes like the default
638 // memory read
641
642 std::optional<uint64_t> size = compiler_type.GetByteSize(nullptr);
643 if (!size) {
644 result.AppendError("can't get size of type");
645 return;
646 }
647 bytes_read = *size * m_format_options.GetCountValue().GetCurrentValue();
648
649 if (argc > 0)
650 addr = addr + (*size * m_memory_options.m_offset.GetCurrentValue());
653 data_sp = std::make_shared<DataBufferHeap>(total_byte_size, '\0');
654 if (data_sp->GetBytes() == nullptr) {
656 "can't allocate 0x%" PRIx32
657 " bytes for the memory read buffer, specify a smaller size to read",
658 (uint32_t)total_byte_size);
659 return;
660 }
661
662 Address address(addr, nullptr);
663 bytes_read = target->ReadMemory(address, data_sp->GetBytes(),
664 data_sp->GetByteSize(), error, true);
665 if (bytes_read == 0) {
666 const char *error_cstr = error.AsCString();
667 if (error_cstr && error_cstr[0]) {
668 result.AppendError(error_cstr);
669 } else {
671 "failed to read memory from 0x%" PRIx64 ".\n", addr);
672 }
673 return;
674 }
675
676 if (bytes_read < total_byte_size)
678 "Not all bytes (%" PRIu64 "/%" PRIu64
679 ") were able to be read from 0x%" PRIx64 ".\n",
680 (uint64_t)bytes_read, (uint64_t)total_byte_size, addr);
681 } else {
682 // we treat c-strings as a special case because they do not have a fixed
683 // size
687 else
688 item_byte_size = target->GetMaximumSizeOfStringSummary();
690 item_count = 1;
691 data_sp = std::make_shared<DataBufferHeap>(
692 (item_byte_size + 1) * item_count,
693 '\0'); // account for NULLs as necessary
694 if (data_sp->GetBytes() == nullptr) {
696 "can't allocate 0x%" PRIx64
697 " bytes for the memory read buffer, specify a smaller size to read",
698 (uint64_t)((item_byte_size + 1) * item_count));
699 return;
700 }
701 uint8_t *data_ptr = data_sp->GetBytes();
702 auto data_addr = addr;
703 auto count = item_count;
704 item_count = 0;
705 bool break_on_no_NULL = false;
706 while (item_count < count) {
707 std::string buffer;
708 buffer.resize(item_byte_size + 1, 0);
710 size_t read = target->ReadCStringFromMemory(data_addr, &buffer[0],
711 item_byte_size + 1, error);
712 if (error.Fail()) {
714 "failed to read memory from 0x%" PRIx64 ".\n", addr);
715 return;
716 }
717
718 if (item_byte_size == read) {
720 "unable to find a NULL terminated string at 0x%" PRIx64
721 ". Consider increasing the maximum read length.\n",
722 data_addr);
723 --read;
724 break_on_no_NULL = true;
725 } else
726 ++read; // account for final NULL byte
727
728 memcpy(data_ptr, &buffer[0], read);
729 data_ptr += read;
730 data_addr += read;
731 bytes_read += read;
732 item_count++; // if we break early we know we only read item_count
733 // strings
734
735 if (break_on_no_NULL)
736 break;
737 }
738 data_sp =
739 std::make_shared<DataBufferHeap>(data_sp->GetBytes(), bytes_read + 1);
740 }
741
742 m_next_addr = addr + bytes_read;
743 m_prev_byte_size = bytes_read;
749 m_prev_compiler_type = compiler_type;
750
751 std::unique_ptr<Stream> output_stream_storage;
752 Stream *output_stream_p = nullptr;
753 const FileSpec &outfile_spec =
755
756 std::string path = outfile_spec.GetPath();
757 if (outfile_spec) {
758
759 File::OpenOptions open_options =
761 const bool append = m_outfile_options.GetAppend().GetCurrentValue();
762 open_options |=
764
765 auto outfile = FileSystem::Instance().Open(outfile_spec, open_options);
766
767 if (outfile) {
768 auto outfile_stream_up =
769 std::make_unique<StreamFile>(std::move(outfile.get()));
771 const size_t bytes_written =
772 outfile_stream_up->Write(data_sp->GetBytes(), bytes_read);
773 if (bytes_written > 0) {
774 result.GetOutputStream().Printf(
775 "%zi bytes %s to '%s'\n", bytes_written,
776 append ? "appended" : "written", path.c_str());
777 return;
778 } else {
779 result.AppendErrorWithFormat("Failed to write %" PRIu64
780 " bytes to '%s'.\n",
781 (uint64_t)bytes_read, path.c_str());
782 return;
783 }
784 } else {
785 // We are going to write ASCII to the file just point the
786 // output_stream to our outfile_stream...
787 output_stream_storage = std::move(outfile_stream_up);
788 output_stream_p = output_stream_storage.get();
789 }
790 } else {
791 result.AppendErrorWithFormat("Failed to open file '%s' for %s:\n",
792 path.c_str(), append ? "append" : "write");
793
794 result.AppendError(llvm::toString(outfile.takeError()));
795 return;
796 }
797 } else {
798 output_stream_p = &result.GetOutputStream();
799 }
800
802 if (compiler_type.GetOpaqueQualType()) {
803 for (uint32_t i = 0; i < item_count; ++i) {
804 addr_t item_addr = addr + (i * item_byte_size);
805 Address address(item_addr);
806 StreamString name_strm;
807 name_strm.Printf("0x%" PRIx64, item_addr);
809 exe_scope, name_strm.GetString(), address, compiler_type));
810 if (valobj_sp) {
812 if (format != eFormatDefault)
813 valobj_sp->SetFormat(format);
814
817
818 valobj_sp->Dump(*output_stream_p, options);
819 } else {
821 "failed to create a value object for: (%s) %s\n",
822 view_as_type_cstr, name_strm.GetData());
823 return;
824 }
825 }
826 return;
827 }
828
830 DataExtractor data(data_sp, target->GetArchitecture().GetByteOrder(),
832 target->GetArchitecture().GetDataByteSize());
833
835 if (((format == eFormatChar) || (format == eFormatCharPrintable)) &&
836 (item_byte_size != 1)) {
837 // if a count was not passed, or it is 1
838 if (!m_format_options.GetCountValue().OptionWasSet() || item_count == 1) {
839 // this turns requests such as
840 // memory read -fc -s10 -c1 *charPtrPtr
841 // which make no sense (what is a char of size 10?) into a request for
842 // fetching 10 chars of size 1 from the same memory location
843 format = eFormatCharArray;
844 item_count = item_byte_size;
845 item_byte_size = 1;
846 } else {
847 // here we passed a count, and it was not 1 so we have a byte_size and
848 // a count we could well multiply those, but instead let's just fail
850 "reading memory as characters of size %" PRIu64 " is not supported",
851 (uint64_t)item_byte_size);
852 return;
853 }
854 }
855
856 assert(output_stream_p);
857 size_t bytes_dumped = DumpDataExtractor(
858 data, output_stream_p, 0, format, item_byte_size, item_count,
859 num_per_line / target->GetArchitecture().GetDataByteSize(), addr, 0, 0,
861 m_next_addr = addr + bytes_dumped;
862 output_stream_p->EOL();
863 }
864
879};
880
881#define LLDB_OPTIONS_memory_find
882#include "CommandOptions.inc"
883
884// Find the specified data in memory
886public:
888 public:
890
891 ~OptionGroupFindMemory() override = default;
892
893 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
894 return llvm::ArrayRef(g_memory_find_options);
895 }
896
897 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
898 ExecutionContext *execution_context) override {
900 const int short_option = g_memory_find_options[option_idx].short_option;
901
902 switch (short_option) {
903 case 'e':
904 m_expr.SetValueFromString(option_value);
905 break;
906
907 case 's':
908 m_string.SetValueFromString(option_value);
909 break;
910
911 case 'c':
912 if (m_count.SetValueFromString(option_value).Fail())
913 error.SetErrorString("unrecognized value for count");
914 break;
915
916 case 'o':
917 if (m_offset.SetValueFromString(option_value).Fail())
918 error.SetErrorString("unrecognized value for dump-offset");
919 break;
920
921 default:
922 llvm_unreachable("Unimplemented option");
923 }
924 return error;
925 }
926
927 void OptionParsingStarting(ExecutionContext *execution_context) override {
928 m_expr.Clear();
929 m_string.Clear();
930 m_count.Clear();
931 }
932
937 };
938
941 interpreter, "memory find",
942 "Find a value in the memory of the current target process.",
943 nullptr, eCommandRequiresProcess | eCommandProcessMustBeLaunched) {
946 CommandArgumentData addr_arg;
947 CommandArgumentData value_arg;
948
949 // Define the first (and only) variant of this arg.
952
953 // There is only one variant this argument could be; put it into the
954 // argument entry.
955 arg1.push_back(addr_arg);
956
957 // Define the first (and only) variant of this arg.
960
961 // There is only one variant this argument could be; put it into the
962 // argument entry.
963 arg2.push_back(value_arg);
964
965 // Push the data for the first argument into the m_arguments vector.
966 m_arguments.push_back(arg1);
967 m_arguments.push_back(arg2);
968
973 }
974
975 ~CommandObjectMemoryFind() override = default;
976
977 Options *GetOptions() override { return &m_option_group; }
978
979protected:
980 void DoExecute(Args &command, CommandReturnObject &result) override {
981 // No need to check "process" for validity as eCommandRequiresProcess
982 // ensures it is valid
983 Process *process = m_exe_ctx.GetProcessPtr();
984
985 const size_t argc = command.GetArgumentCount();
986
987 if (argc != 2) {
988 result.AppendError("two addresses needed for memory find");
989 return;
990 }
991
994 &m_exe_ctx, command[0].ref(), LLDB_INVALID_ADDRESS, &error);
995 if (low_addr == LLDB_INVALID_ADDRESS || error.Fail()) {
996 result.AppendError("invalid low address");
997 return;
998 }
1000 &m_exe_ctx, command[1].ref(), LLDB_INVALID_ADDRESS, &error);
1001 if (high_addr == LLDB_INVALID_ADDRESS || error.Fail()) {
1002 result.AppendError("invalid high address");
1003 return;
1004 }
1005
1006 if (high_addr <= low_addr) {
1007 result.AppendError(
1008 "starting address must be smaller than ending address");
1009 return;
1010 }
1011
1012 lldb::addr_t found_location = LLDB_INVALID_ADDRESS;
1013
1014 DataBufferHeap buffer;
1015
1017 llvm::StringRef str =
1018 m_memory_options.m_string.GetValueAs<llvm::StringRef>().value_or("");
1019 if (str.empty()) {
1020 result.AppendError("search string must have non-zero length.");
1021 return;
1022 }
1023 buffer.CopyData(str);
1024 } else if (m_memory_options.m_expr.OptionWasSet()) {
1025 StackFrame *frame = m_exe_ctx.GetFramePtr();
1026 ValueObjectSP result_sp;
1027 if ((eExpressionCompleted ==
1028 process->GetTarget().EvaluateExpression(
1029 m_memory_options.m_expr.GetValueAs<llvm::StringRef>().value_or(
1030 ""),
1031 frame, result_sp)) &&
1032 result_sp) {
1033 uint64_t value = result_sp->GetValueAsUnsigned(0);
1034 std::optional<uint64_t> size =
1035 result_sp->GetCompilerType().GetByteSize(nullptr);
1036 if (!size)
1037 return;
1038 switch (*size) {
1039 case 1: {
1040 uint8_t byte = (uint8_t)value;
1041 buffer.CopyData(&byte, 1);
1042 } break;
1043 case 2: {
1044 uint16_t word = (uint16_t)value;
1045 buffer.CopyData(&word, 2);
1046 } break;
1047 case 4: {
1048 uint32_t lword = (uint32_t)value;
1049 buffer.CopyData(&lword, 4);
1050 } break;
1051 case 8: {
1052 buffer.CopyData(&value, 8);
1053 } break;
1054 case 3:
1055 case 5:
1056 case 6:
1057 case 7:
1058 result.AppendError("unknown type. pass a string instead");
1059 return;
1060 default:
1061 result.AppendError(
1062 "result size larger than 8 bytes. pass a string instead");
1063 return;
1064 }
1065 } else {
1066 result.AppendError(
1067 "expression evaluation failed. pass a string instead");
1068 return;
1069 }
1070 } else {
1071 result.AppendError(
1072 "please pass either a block of text, or an expression to evaluate.");
1073 return;
1074 }
1075
1076 size_t count = m_memory_options.m_count.GetCurrentValue();
1077 found_location = low_addr;
1078 bool ever_found = false;
1079 while (count) {
1080 found_location = process->FindInMemory(
1081 found_location, high_addr, buffer.GetBytes(), buffer.GetByteSize());
1082 if (found_location == LLDB_INVALID_ADDRESS) {
1083 if (!ever_found) {
1084 result.AppendMessage("data not found within the range.\n");
1086 } else
1087 result.AppendMessage("no more matches within the range.\n");
1088 break;
1089 }
1090 result.AppendMessageWithFormat("data found at location: 0x%" PRIx64 "\n",
1091 found_location);
1092
1093 DataBufferHeap dumpbuffer(32, 0);
1094 process->ReadMemory(
1095 found_location + m_memory_options.m_offset.GetCurrentValue(),
1096 dumpbuffer.GetBytes(), dumpbuffer.GetByteSize(), error);
1097 if (!error.Fail()) {
1098 DataExtractor data(dumpbuffer.GetBytes(), dumpbuffer.GetByteSize(),
1099 process->GetByteOrder(),
1100 process->GetAddressByteSize());
1102 data, &result.GetOutputStream(), 0, lldb::eFormatBytesWithASCII, 1,
1103 dumpbuffer.GetByteSize(), 16,
1104 found_location + m_memory_options.m_offset.GetCurrentValue(), 0, 0,
1107 result.GetOutputStream().EOL();
1108 }
1109
1110 --count;
1111 found_location++;
1112 ever_found = true;
1113 }
1114
1116 }
1117
1121};
1122
1123#define LLDB_OPTIONS_memory_write
1124#include "CommandOptions.inc"
1125
1126// Write memory to the inferior process
1128public:
1130 public:
1132
1133 ~OptionGroupWriteMemory() override = default;
1134
1135 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1136 return llvm::ArrayRef(g_memory_write_options);
1137 }
1138
1139 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
1140 ExecutionContext *execution_context) override {
1141 Status error;
1142 const int short_option = g_memory_write_options[option_idx].short_option;
1143
1144 switch (short_option) {
1145 case 'i':
1146 m_infile.SetFile(option_value, FileSpec::Style::native);
1148 if (!FileSystem::Instance().Exists(m_infile)) {
1149 m_infile.Clear();
1150 error.SetErrorStringWithFormat("input file does not exist: '%s'",
1151 option_value.str().c_str());
1152 }
1153 break;
1154
1155 case 'o': {
1156 if (option_value.getAsInteger(0, m_infile_offset)) {
1157 m_infile_offset = 0;
1158 error.SetErrorStringWithFormat("invalid offset string '%s'",
1159 option_value.str().c_str());
1160 }
1161 } break;
1162
1163 default:
1164 llvm_unreachable("Unimplemented option");
1165 }
1166 return error;
1167 }
1168
1169 void OptionParsingStarting(ExecutionContext *execution_context) override {
1170 m_infile.Clear();
1171 m_infile_offset = 0;
1172 }
1173
1176 };
1177
1180 interpreter, "memory write",
1181 "Write to the memory of the current target process.", nullptr,
1182 eCommandRequiresProcess | eCommandProcessMustBeLaunched),
1185 {std::make_tuple(
1187 "The format to use for each of the value to be written."),
1188 std::make_tuple(eArgTypeByteSize,
1189 "The size in bytes to write from input file or "
1190 "each value.")}) {
1193 CommandArgumentData addr_arg;
1194 CommandArgumentData value_arg;
1195
1196 // Define the first (and only) variant of this arg.
1197 addr_arg.arg_type = eArgTypeAddress;
1198 addr_arg.arg_repetition = eArgRepeatPlain;
1199
1200 // There is only one variant this argument could be; put it into the
1201 // argument entry.
1202 arg1.push_back(addr_arg);
1203
1204 // Define the first (and only) variant of this arg.
1205 value_arg.arg_type = eArgTypeValue;
1206 value_arg.arg_repetition = eArgRepeatPlus;
1207 value_arg.arg_opt_set_association = LLDB_OPT_SET_1;
1208
1209 // There is only one variant this argument could be; put it into the
1210 // argument entry.
1211 arg2.push_back(value_arg);
1212
1213 // Push the data for the first argument into the m_arguments vector.
1214 m_arguments.push_back(arg1);
1215 m_arguments.push_back(arg2);
1216
1225 }
1226
1227 ~CommandObjectMemoryWrite() override = default;
1228
1229 Options *GetOptions() override { return &m_option_group; }
1230
1231protected:
1232 void DoExecute(Args &command, CommandReturnObject &result) override {
1233 // No need to check "process" for validity as eCommandRequiresProcess
1234 // ensures it is valid
1235 Process *process = m_exe_ctx.GetProcessPtr();
1236
1237 const size_t argc = command.GetArgumentCount();
1238
1240 if (argc < 1) {
1241 result.AppendErrorWithFormat(
1242 "%s takes a destination address when writing file contents.\n",
1243 m_cmd_name.c_str());
1244 return;
1245 }
1246 if (argc > 1) {
1247 result.AppendErrorWithFormat(
1248 "%s takes only a destination address when writing file contents.\n",
1249 m_cmd_name.c_str());
1250 return;
1251 }
1252 } else if (argc < 2) {
1253 result.AppendErrorWithFormat(
1254 "%s takes a destination address and at least one value.\n",
1255 m_cmd_name.c_str());
1256 return;
1257 }
1258
1259 StreamString buffer(
1262 process->GetTarget().GetArchitecture().GetByteOrder());
1263
1265 size_t item_byte_size = byte_size_value.GetCurrentValue();
1266
1267 Status error;
1269 &m_exe_ctx, command[0].ref(), LLDB_INVALID_ADDRESS, &error);
1270
1271 if (addr == LLDB_INVALID_ADDRESS) {
1272 result.AppendError("invalid address expression\n");
1273 result.AppendError(error.AsCString());
1274 return;
1275 }
1276
1278 size_t length = SIZE_MAX;
1279 if (item_byte_size > 1)
1280 length = item_byte_size;
1281 auto data_sp = FileSystem::Instance().CreateDataBuffer(
1284 if (data_sp) {
1285 length = data_sp->GetByteSize();
1286 if (length > 0) {
1287 Status error;
1288 size_t bytes_written =
1289 process->WriteMemory(addr, data_sp->GetBytes(), length, error);
1290
1291 if (bytes_written == length) {
1292 // All bytes written
1293 result.GetOutputStream().Printf(
1294 "%" PRIu64 " bytes were written to 0x%" PRIx64 "\n",
1295 (uint64_t)bytes_written, addr);
1297 } else if (bytes_written > 0) {
1298 // Some byte written
1299 result.GetOutputStream().Printf(
1300 "%" PRIu64 " bytes of %" PRIu64
1301 " requested were written to 0x%" PRIx64 "\n",
1302 (uint64_t)bytes_written, (uint64_t)length, addr);
1304 } else {
1305 result.AppendErrorWithFormat("Memory write to 0x%" PRIx64
1306 " failed: %s.\n",
1307 addr, error.AsCString());
1308 }
1309 }
1310 } else {
1311 result.AppendErrorWithFormat("Unable to read contents of file.\n");
1312 }
1313 return;
1314 } else if (item_byte_size == 0) {
1316 item_byte_size = buffer.GetAddressByteSize();
1317 else
1318 item_byte_size = 1;
1319 }
1320
1321 command.Shift(); // shift off the address argument
1322 uint64_t uval64;
1323 int64_t sval64;
1324 bool success = false;
1325 for (auto &entry : command) {
1326 switch (m_format_options.GetFormat()) {
1327 case kNumFormats:
1328 case eFormatFloat: // TODO: add support for floats soon
1331 case eFormatComplex:
1332 case eFormatEnum:
1333 case eFormatUnicode8:
1334 case eFormatUnicode16:
1335 case eFormatUnicode32:
1349 case eFormatOSType:
1351 case eFormatAddressInfo:
1352 case eFormatHexFloat:
1353 case eFormatInstruction:
1354 case eFormatVoid:
1355 result.AppendError("unsupported format for writing memory");
1356 return;
1357
1358 case eFormatDefault:
1359 case eFormatBytes:
1360 case eFormatHex:
1362 case eFormatPointer: {
1363 // Decode hex bytes
1364 // Be careful, getAsInteger with a radix of 16 rejects "0xab" so we
1365 // have to special case that:
1366 bool success = false;
1367 if (entry.ref().starts_with("0x"))
1368 success = !entry.ref().getAsInteger(0, uval64);
1369 if (!success)
1370 success = !entry.ref().getAsInteger(16, uval64);
1371 if (!success) {
1372 result.AppendErrorWithFormat(
1373 "'%s' is not a valid hex string value.\n", entry.c_str());
1374 return;
1375 } else if (!llvm::isUIntN(item_byte_size * 8, uval64)) {
1376 result.AppendErrorWithFormat("Value 0x%" PRIx64
1377 " is too large to fit in a %" PRIu64
1378 " byte unsigned integer value.\n",
1379 uval64, (uint64_t)item_byte_size);
1380 return;
1381 }
1382 buffer.PutMaxHex64(uval64, item_byte_size);
1383 break;
1384 }
1385 case eFormatBoolean:
1386 uval64 = OptionArgParser::ToBoolean(entry.ref(), false, &success);
1387 if (!success) {
1388 result.AppendErrorWithFormat(
1389 "'%s' is not a valid boolean string value.\n", entry.c_str());
1390 return;
1391 }
1392 buffer.PutMaxHex64(uval64, item_byte_size);
1393 break;
1394
1395 case eFormatBinary:
1396 if (entry.ref().getAsInteger(2, uval64)) {
1397 result.AppendErrorWithFormat(
1398 "'%s' is not a valid binary string value.\n", entry.c_str());
1399 return;
1400 } else if (!llvm::isUIntN(item_byte_size * 8, uval64)) {
1401 result.AppendErrorWithFormat("Value 0x%" PRIx64
1402 " is too large to fit in a %" PRIu64
1403 " byte unsigned integer value.\n",
1404 uval64, (uint64_t)item_byte_size);
1405 return;
1406 }
1407 buffer.PutMaxHex64(uval64, item_byte_size);
1408 break;
1409
1410 case eFormatCharArray:
1411 case eFormatChar:
1412 case eFormatCString: {
1413 if (entry.ref().empty())
1414 break;
1415
1416 size_t len = entry.ref().size();
1417 // Include the NULL for C strings...
1419 ++len;
1420 Status error;
1421 if (process->WriteMemory(addr, entry.c_str(), len, error) == len) {
1422 addr += len;
1423 } else {
1424 result.AppendErrorWithFormat("Memory write to 0x%" PRIx64
1425 " failed: %s.\n",
1426 addr, error.AsCString());
1427 return;
1428 }
1429 break;
1430 }
1431 case eFormatDecimal:
1432 if (entry.ref().getAsInteger(0, sval64)) {
1433 result.AppendErrorWithFormat(
1434 "'%s' is not a valid signed decimal value.\n", entry.c_str());
1435 return;
1436 } else if (!llvm::isIntN(item_byte_size * 8, sval64)) {
1437 result.AppendErrorWithFormat(
1438 "Value %" PRIi64 " is too large or small to fit in a %" PRIu64
1439 " byte signed integer value.\n",
1440 sval64, (uint64_t)item_byte_size);
1441 return;
1442 }
1443 buffer.PutMaxHex64(sval64, item_byte_size);
1444 break;
1445
1446 case eFormatUnsigned:
1447
1448 if (entry.ref().getAsInteger(0, uval64)) {
1449 result.AppendErrorWithFormat(
1450 "'%s' is not a valid unsigned decimal string value.\n",
1451 entry.c_str());
1452 return;
1453 } else if (!llvm::isUIntN(item_byte_size * 8, uval64)) {
1454 result.AppendErrorWithFormat("Value %" PRIu64
1455 " is too large to fit in a %" PRIu64
1456 " byte unsigned integer value.\n",
1457 uval64, (uint64_t)item_byte_size);
1458 return;
1459 }
1460 buffer.PutMaxHex64(uval64, item_byte_size);
1461 break;
1462
1463 case eFormatOctal:
1464 if (entry.ref().getAsInteger(8, uval64)) {
1465 result.AppendErrorWithFormat(
1466 "'%s' is not a valid octal string value.\n", entry.c_str());
1467 return;
1468 } else if (!llvm::isUIntN(item_byte_size * 8, uval64)) {
1469 result.AppendErrorWithFormat("Value %" PRIo64
1470 " is too large to fit in a %" PRIu64
1471 " byte unsigned integer value.\n",
1472 uval64, (uint64_t)item_byte_size);
1473 return;
1474 }
1475 buffer.PutMaxHex64(uval64, item_byte_size);
1476 break;
1477 }
1478 }
1479
1480 if (!buffer.GetString().empty()) {
1481 Status error;
1482 const char *buffer_data = buffer.GetString().data();
1483 const size_t buffer_size = buffer.GetString().size();
1484 const size_t write_size =
1485 process->WriteMemory(addr, buffer_data, buffer_size, error);
1486
1487 if (write_size != buffer_size) {
1488 result.AppendErrorWithFormat("Memory write to 0x%" PRIx64
1489 " failed: %s.\n",
1490 addr, error.AsCString());
1491 return;
1492 }
1493 }
1494 }
1495
1499};
1500
1501// Get malloc/free history of a memory address.
1503public:
1505 : CommandObjectParsed(interpreter, "memory history",
1506 "Print recorded stack traces for "
1507 "allocation/deallocation events "
1508 "associated with an address.",
1509 nullptr,
1510 eCommandRequiresTarget | eCommandRequiresProcess |
1511 eCommandProcessMustBePaused |
1512 eCommandProcessMustBeLaunched) {
1514 CommandArgumentData addr_arg;
1515
1516 // Define the first (and only) variant of this arg.
1517 addr_arg.arg_type = eArgTypeAddress;
1519
1520 // There is only one variant this argument could be; put it into the
1521 // argument entry.
1522 arg1.push_back(addr_arg);
1523
1524 // Push the data for the first argument into the m_arguments vector.
1525 m_arguments.push_back(arg1);
1526 }
1527
1528 ~CommandObjectMemoryHistory() override = default;
1529
1530 std::optional<std::string> GetRepeatCommand(Args &current_command_args,
1531 uint32_t index) override {
1532 return m_cmd_name;
1533 }
1534
1535protected:
1536 void DoExecute(Args &command, CommandReturnObject &result) override {
1537 const size_t argc = command.GetArgumentCount();
1538
1539 if (argc == 0 || argc > 1) {
1540 result.AppendErrorWithFormat("%s takes an address expression",
1541 m_cmd_name.c_str());
1542 return;
1543 }
1544
1545 Status error;
1547 &m_exe_ctx, command[0].ref(), LLDB_INVALID_ADDRESS, &error);
1548
1549 if (addr == LLDB_INVALID_ADDRESS) {
1550 result.AppendError("invalid address expression");
1551 result.AppendError(error.AsCString());
1552 return;
1553 }
1554
1555 Stream *output_stream = &result.GetOutputStream();
1556
1557 const ProcessSP &process_sp = m_exe_ctx.GetProcessSP();
1558 const MemoryHistorySP &memory_history =
1559 MemoryHistory::FindPlugin(process_sp);
1560
1561 if (!memory_history) {
1562 result.AppendError("no available memory history provider");
1563 return;
1564 }
1565
1566 HistoryThreads thread_list = memory_history->GetHistoryThreads(addr);
1567
1568 const bool stop_format = false;
1569 for (auto thread : thread_list) {
1570 thread->GetStatus(*output_stream, 0, UINT32_MAX, 0, stop_format);
1571 }
1572
1574 }
1575};
1576
1577// CommandObjectMemoryRegion
1578#pragma mark CommandObjectMemoryRegion
1579
1580#define LLDB_OPTIONS_memory_region
1581#include "CommandOptions.inc"
1582
1584public:
1586 public:
1587 OptionGroupMemoryRegion() : m_all(false, false) {}
1588
1589 ~OptionGroupMemoryRegion() override = default;
1590
1591 llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
1592 return llvm::ArrayRef(g_memory_region_options);
1593 }
1594
1595 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
1596 ExecutionContext *execution_context) override {
1597 Status status;
1598 const int short_option = g_memory_region_options[option_idx].short_option;
1599
1600 switch (short_option) {
1601 case 'a':
1602 m_all.SetCurrentValue(true);
1604 break;
1605 default:
1606 llvm_unreachable("Unimplemented option");
1607 }
1608
1609 return status;
1610 }
1611
1612 void OptionParsingStarting(ExecutionContext *execution_context) override {
1613 m_all.Clear();
1614 }
1615
1617 };
1618
1620 : CommandObjectParsed(interpreter, "memory region",
1621 "Get information on the memory region containing "
1622 "an address in the current target process.",
1623 "memory region <address-expression> (or --all)",
1624 eCommandRequiresProcess | eCommandTryTargetAPILock |
1625 eCommandProcessMustBeLaunched) {
1626 // Address in option set 1.
1629 // "--all" will go in option set 2.
1632 }
1633
1634 ~CommandObjectMemoryRegion() override = default;
1635
1636 Options *GetOptions() override { return &m_option_group; }
1637
1638protected:
1640 const MemoryRegionInfo &range_info, lldb::addr_t load_addr) {
1642 ConstString section_name;
1643 if (target.ResolveLoadAddress(load_addr, addr)) {
1644 SectionSP section_sp(addr.GetSection());
1645 if (section_sp) {
1646 // Got the top most section, not the deepest section
1647 while (section_sp->GetParent())
1648 section_sp = section_sp->GetParent();
1649 section_name = section_sp->GetName();
1650 }
1651 }
1652
1653 ConstString name = range_info.GetName();
1655 "[{0:x16}-{1:x16}) {2:r}{3:w}{4:x}{5}{6}{7}{8}",
1656 range_info.GetRange().GetRangeBase(),
1657 range_info.GetRange().GetRangeEnd(), range_info.GetReadable(),
1658 range_info.GetWritable(), range_info.GetExecutable(), name ? " " : "",
1659 name, section_name ? " " : "", section_name);
1660 MemoryRegionInfo::OptionalBool memory_tagged = range_info.GetMemoryTagged();
1661 if (memory_tagged == MemoryRegionInfo::OptionalBool::eYes)
1662 result.AppendMessage("memory tagging: enabled");
1663
1664 const std::optional<std::vector<addr_t>> &dirty_page_list =
1665 range_info.GetDirtyPageList();
1666 if (dirty_page_list) {
1667 const size_t page_count = dirty_page_list->size();
1669 "Modified memory (dirty) page list provided, %zu entries.\n",
1670 page_count);
1671 if (page_count > 0) {
1672 bool print_comma = false;
1673 result.AppendMessageWithFormat("Dirty pages: ");
1674 for (size_t i = 0; i < page_count; i++) {
1675 if (print_comma)
1676 result.AppendMessageWithFormat(", ");
1677 else
1678 print_comma = true;
1679 result.AppendMessageWithFormat("0x%" PRIx64, (*dirty_page_list)[i]);
1680 }
1681 result.AppendMessageWithFormat(".\n");
1682 }
1683 }
1684 }
1685
1686 void DoExecute(Args &command, CommandReturnObject &result) override {
1687 ProcessSP process_sp = m_exe_ctx.GetProcessSP();
1688 if (!process_sp) {
1690 result.AppendError("invalid process");
1691 return;
1692 }
1693
1694 Status error;
1695 lldb::addr_t load_addr = m_prev_end_addr;
1697
1698 const size_t argc = command.GetArgumentCount();
1699 const lldb::ABISP &abi = process_sp->GetABI();
1700
1701 if (argc == 1) {
1703 result.AppendError(
1704 "The \"--all\" option cannot be used when an address "
1705 "argument is given");
1706 return;
1707 }
1708
1709 auto load_addr_str = command[0].ref();
1710 load_addr = OptionArgParser::ToAddress(&m_exe_ctx, load_addr_str,
1712 if (error.Fail() || load_addr == LLDB_INVALID_ADDRESS) {
1713 result.AppendErrorWithFormat("invalid address argument \"%s\": %s\n",
1714 command[0].c_str(), error.AsCString());
1715 return;
1716 }
1717 } else if (argc > 1 ||
1718 // When we're repeating the command, the previous end address is
1719 // used for load_addr. If that was 0xF...F then we must have
1720 // reached the end of memory.
1721 (argc == 0 && !m_memory_region_options.m_all &&
1722 load_addr == LLDB_INVALID_ADDRESS) ||
1723 // If the target has non-address bits (tags, limited virtual
1724 // address size, etc.), the end of mappable memory will be lower
1725 // than that. So if we find any non-address bit set, we must be
1726 // at the end of the mappable range.
1727 (abi && (abi->FixAnyAddress(load_addr) != load_addr))) {
1728 result.AppendErrorWithFormat(
1729 "'%s' takes one argument or \"--all\" option:\nUsage: %s\n",
1730 m_cmd_name.c_str(), m_cmd_syntax.c_str());
1731 return;
1732 }
1733
1734 // It is important that we track the address used to request the region as
1735 // this will give the correct section name in the case that regions overlap.
1736 // On Windows we get mutliple regions that start at the same place but are
1737 // different sizes and refer to different sections.
1738 std::vector<std::pair<lldb_private::MemoryRegionInfo, lldb::addr_t>>
1739 region_list;
1741 // We don't use GetMemoryRegions here because it doesn't include unmapped
1742 // areas like repeating the command would. So instead, emulate doing that.
1743 lldb::addr_t addr = 0;
1744 while (error.Success() && addr != LLDB_INVALID_ADDRESS &&
1745 // When there are non-address bits the last range will not extend
1746 // to LLDB_INVALID_ADDRESS but to the max virtual address.
1747 // This prevents us looping forever if that is the case.
1748 (!abi || (abi->FixAnyAddress(addr) == addr))) {
1750 error = process_sp->GetMemoryRegionInfo(addr, region_info);
1751
1752 if (error.Success()) {
1753 region_list.push_back({region_info, addr});
1754 addr = region_info.GetRange().GetRangeEnd();
1755 }
1756 }
1757 } else {
1759 error = process_sp->GetMemoryRegionInfo(load_addr, region_info);
1760 if (error.Success())
1761 region_list.push_back({region_info, load_addr});
1762 }
1763
1764 if (error.Success()) {
1765 for (std::pair<MemoryRegionInfo, addr_t> &range : region_list) {
1766 DumpRegion(result, process_sp->GetTarget(), range.first, range.second);
1767 m_prev_end_addr = range.first.GetRange().GetRangeEnd();
1768 }
1769
1771 return;
1772 }
1773
1774 result.AppendErrorWithFormat("%s\n", error.AsCString());
1775 }
1776
1777 std::optional<std::string> GetRepeatCommand(Args &current_command_args,
1778 uint32_t index) override {
1779 // If we repeat this command, repeat it without any arguments so we can
1780 // show the next memory range
1781 return m_cmd_name;
1782 }
1783
1785
1788};
1789
1790// CommandObjectMemory
1791
1794 interpreter, "memory",
1795 "Commands for operating on memory in the current target process.",
1796 "memory <subcommand> [<subcommand-options>]") {
1797 LoadSubCommand("find",
1798 CommandObjectSP(new CommandObjectMemoryFind(interpreter)));
1799 LoadSubCommand("read",
1800 CommandObjectSP(new CommandObjectMemoryRead(interpreter)));
1801 LoadSubCommand("write",
1802 CommandObjectSP(new CommandObjectMemoryWrite(interpreter)));
1803 LoadSubCommand("history",
1805 LoadSubCommand("region",
1806 CommandObjectSP(new CommandObjectMemoryRegion(interpreter)));
1807 LoadSubCommand("tag",
1808 CommandObjectSP(new CommandObjectMemoryTag(interpreter)));
1809}
1810
#define ALL_KEYWORDS
static llvm::raw_ostream & error(Stream &strm)
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
OptionGroupMemoryTag m_memory_tag_options
OptionGroupOptions m_option_group
Options * GetOptions() override
OptionGroupFindMemory m_memory_options
~CommandObjectMemoryFind() override=default
CommandObjectMemoryFind(CommandInterpreter &interpreter)
void DoExecute(Args &command, CommandReturnObject &result) override
std::optional< std::string > GetRepeatCommand(Args &current_command_args, uint32_t index) override
Get the command that appropriate for a "repeat" of the current command.
void DoExecute(Args &command, CommandReturnObject &result) override
~CommandObjectMemoryHistory() override=default
CommandObjectMemoryHistory(CommandInterpreter &interpreter)
Options * GetOptions() override
~CommandObjectMemoryRead() override=default
OptionGroupOptions m_option_group
OptionGroupMemoryTag m_memory_tag_options
OptionGroupOutputFile m_prev_outfile_options
OptionGroupValueObjectDisplay m_prev_varobj_options
void DoExecute(Args &command, CommandReturnObject &result) override
OptionGroupValueObjectDisplay m_varobj_options
CommandObjectMemoryRead(CommandInterpreter &interpreter)
OptionGroupOutputFile m_outfile_options
OptionGroupReadMemory m_memory_options
OptionGroupFormat m_format_options
std::optional< std::string > GetRepeatCommand(Args &current_command_args, uint32_t index) override
Get the command that appropriate for a "repeat" of the current command.
OptionGroupMemoryTag m_prev_memory_tag_options
OptionGroupFormat m_prev_format_options
OptionGroupReadMemory m_prev_memory_options
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, ExecutionContext *execution_context) override
void OptionParsingStarting(ExecutionContext *execution_context) override
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectMemoryRegion(CommandInterpreter &interpreter)
void DumpRegion(CommandReturnObject &result, Target &target, const MemoryRegionInfo &range_info, lldb::addr_t load_addr)
OptionGroupMemoryRegion m_memory_region_options
std::optional< std::string > GetRepeatCommand(Args &current_command_args, uint32_t index) override
Get the command that appropriate for a "repeat" of the current command.
~CommandObjectMemoryRegion() override=default
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
void OptionParsingStarting(ExecutionContext *execution_context) override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, ExecutionContext *execution_context) override
void DoExecute(Args &command, CommandReturnObject &result) override
CommandObjectMemoryWrite(CommandInterpreter &interpreter)
OptionGroupWriteMemory m_memory_options
Options * GetOptions() override
~CommandObjectMemoryWrite() override=default
Status FinalizeSettings(Target *target, OptionGroupFormat &format_options)
OptionValueUInt64 m_num_per_line
OptionValueString m_view_as_type
void OptionParsingStarting(ExecutionContext *execution_context) override
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, ExecutionContext *execution_context) override
~OptionGroupReadMemory() override=default
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
OptionValueLanguage m_language_for_type
A section + offset based address class.
Definition: Address.h:62
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:439
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:691
uint32_t GetDataByteSize() const
Architecture data byte width accessor.
Definition: ArchSpec.cpp:675
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Definition: ArchSpec.cpp:738
uint32_t GetMaximumOpcodeByteSize() const
Definition: ArchSpec.cpp:934
A command line argument class.
Definition: Args.h:33
void Shift()
Shifts the first argument C string value of the array off the argument array.
Definition: Args.cpp:285
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:116
CommandObjectMemory(CommandInterpreter &interpreter)
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
std::vector< CommandArgumentData > CommandArgumentEntry
ExecutionContext m_exe_ctx
std::vector< CommandArgumentEntry > m_arguments
void AppendMessage(llvm::StringRef in_string)
void void AppendError(llvm::StringRef in_string)
void AppendWarningWithFormat(const char *format,...) __attribute__((format(printf
void SetStatus(lldb::ReturnStatus status)
void void AppendMessageWithFormatv(const char *format, Args &&... args)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
void void AppendWarning(llvm::StringRef in_string)
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
std::optional< uint64_t > GetByteSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bytes.
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
lldb::opaque_compiler_type_t GetOpaqueQualType() const
Definition: CompilerType.h:287
A uniqued constant string class.
Definition: ConstString.h:40
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:197
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
A subclass of DataBuffer that stores a data buffer on the heap.
lldb::offset_t GetByteSize() const override
Get the number of bytes in the data buffer.
void CopyData(const void *src, lldb::offset_t src_len)
Makes a copy of the src_len bytes in src.
An data extractor class.
Definition: DataExtractor.h:48
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
ExecutionContextScope * GetBestExecutionContextScope() const
const lldb::ProcessSP & GetProcessSP() const
Get accessor to get the process shared pointer.
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Target * GetTargetPtr() const
Returns a pointer to the target object.
Process * GetProcessPtr() const
Returns a pointer to the process object.
A file utility class.
Definition: FileSpec.h:56
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:174
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
void Clear()
Clears the object state.
Definition: FileSpec.cpp:259
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
int Open(const char *path, int flags, int mode=0600)
Wraps ::open in a platform-independent way.
static FileSystem & Instance()
std::shared_ptr< DataBuffer > CreateDataBuffer(const llvm::Twine &path, uint64_t size=0, uint64_t offset=0)
Create memory buffer from path.
@ eOpenOptionWriteOnly
Definition: File.h:52
@ eOpenOptionAppend
Definition: File.h:54
@ eOpenOptionCanCreate
Definition: File.h:56
@ eOpenOptionTruncate
Definition: File.h:57
static std::set< lldb::LanguageType > GetSupportedLanguages()
Definition: Language.cpp:415
static lldb::MemoryHistorySP FindPlugin(const lldb::ProcessSP process)
OptionalBool GetWritable() const
OptionalBool GetMemoryTagged() const
const std::optional< std::vector< lldb::addr_t > > & GetDirtyPageList() const
Get a vector of target VM pages that are dirty – that have been modified – within this memory region.
OptionalBool GetReadable() const
OptionalBool GetExecutable() const
void FindTypes(Module *search_first, const TypeQuery &query, lldb_private::TypeResults &results) const
Find types using a type-matching object that contains all search parameters.
Definition: ModuleList.cpp:587
static const uint32_t OPTION_GROUP_GDB_FMT
OptionValueUInt64 & GetByteSizeValue()
static const uint32_t OPTION_GROUP_FORMAT
static const uint32_t OPTION_GROUP_COUNT
static const uint32_t OPTION_GROUP_SIZE
OptionValueFormat & GetFormatValue()
OptionValueUInt64 & GetCountValue()
void Append(OptionGroup *group)
Append options from a OptionGroup class.
Definition: Options.cpp:755
const OptionValueFileSpec & GetFile()
const OptionValueBoolean & GetAppend()
DumpValueObjectOptions GetAsDumpOptions(LanguageRuntimeDescriptionDisplayVerbosity lang_descr_verbosity=eLanguageRuntimeDescriptionDisplayVerbosityFull, lldb::Format format=lldb::eFormatDefault, lldb::TypeSummaryImplSP summary_sp=lldb::TypeSummaryImplSP())
void SetCurrentValue(lldb::Format value)
lldb::Format GetCurrentValue() const
lldb::LanguageType GetCurrentValue() const
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
const char * GetCurrentValue() const
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
std::optional< T > GetValueAs() const
Definition: OptionValue.h:273
A command line option parsing protocol class.
Definition: Options.h:58
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
Definition: Process.cpp:1966
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3454
lldb::addr_t FindInMemory(lldb::addr_t low, lldb::addr_t high, const uint8_t *buf, size_t size)
Find a pattern within a memory region.
Definition: Process.cpp:3221
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3458
size_t WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Status &error)
Write memory to a process.
Definition: Process.cpp:2165
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1277
This base class provides an interface to stack frames.
Definition: StackFrame.h:43
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Definition: StackFrame.cpp:300
An error handling class.
Definition: Status.h:44
bool Fail() const
Test for error condition.
Definition: Status.cpp:180
const char * GetData() const
Definition: StreamString.h:43
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
uint32_t GetAddressByteSize() const
Get the address size in bytes.
Definition: Stream.cpp:206
@ eBinary
Get and put data as binary instead of as the default string mode.
Definition: Stream.h:32
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
size_t PutMaxHex64(uint64_t uvalue, size_t byte_size, lldb::ByteOrder byte_order=lldb::eByteOrderInvalid)
Definition: Stream.cpp:315
lldb::ModuleSP module_sp
The Module for a given query.
uint32_t GetMaximumSizeOfStringSummary() const
Definition: Target.cpp:4600
uint32_t GetMaximumMemReadSize() const
Definition: Target.cpp:4606
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
Definition: Target.cpp:2484
virtual size_t ReadMemory(const Address &addr, void *dst, size_t dst_len, Status &error, bool force_live_memory=false, lldb::addr_t *load_addr_ptr=nullptr)
Definition: Target.cpp:1828
size_t ReadCStringFromMemory(const Address &addr, std::string &out_str, Status &error, bool force_live_memory=false)
Definition: Target.cpp:1949
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow)
Definition: Target.cpp:3104
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:981
const ArchSpec & GetArchitecture() const
Definition: Target.h:1023
lldb::ExpressionResults EvaluateExpression(llvm::StringRef expression, ExecutionContextScope *exe_scope, lldb::ValueObjectSP &result_valobj_sp, const EvaluateExpressionOptions &options=EvaluateExpressionOptions(), std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Definition: Target.cpp:2650
A class that contains all state required for type lookups.
Definition: Type.h:100
This class tracks the state and results of a TypeQuery.
Definition: Type.h:308
lldb::TypeSP GetFirstType() const
Definition: Type.h:349
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, llvm::StringRef name, const Address &address, lldb::TypeSP &type_sp)
uint8_t * GetBytes()
Get a pointer to the data.
Definition: DataBuffer.h:108
#define LLDB_OPT_SET_1
Definition: lldb-defines.h:111
#define UINT64_MAX
Definition: lldb-defines.h:23
#define LLDB_OPT_SET_2
Definition: lldb-defines.h:112
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:110
#define LLDB_OPT_SET_3
Definition: lldb-defines.h:113
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
std::vector< lldb::ThreadSP > HistoryThreads
Definition: MemoryHistory.h:20
lldb::offset_t DumpDataExtractor(const DataExtractor &DE, Stream *s, lldb::offset_t offset, lldb::Format item_format, size_t item_byte_size, size_t item_count, size_t num_per_line, uint64_t base_addr, uint32_t item_bit_size, uint32_t item_bit_offset, ExecutionContextScope *exe_scope=nullptr, bool show_memory_tags=false)
Dumps item_count objects into the stream s.
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::ABI > ABISP
Definition: lldb-forward.h:312
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
Definition: lldb-forward.h:328
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:475
Format
Display format definitions.
@ eFormatCString
NULL terminated C strings.
@ eFormatCharArray
Print characters with no single quotes, used for character arrays that can contain non printable char...
@ eFormatInstruction
Disassemble an opcode.
@ eFormatVectorOfChar
@ eFormatVectorOfUInt64
@ eFormatVoid
Do not print this.
@ eFormatVectorOfFloat16
@ eFormatVectorOfSInt64
@ eFormatComplex
Floating point complex type.
@ eFormatHexFloat
ISO C99 hex float string.
@ eFormatBytesWithASCII
@ eFormatOSType
OS character codes encoded into an integer 'PICT' 'text' etc...
@ eFormatUnicode16
@ eFormatAddressInfo
Describe what an address points to (func + offset.
@ eFormatVectorOfUInt128
@ eFormatVectorOfUInt8
@ eFormatVectorOfFloat32
@ eFormatVectorOfSInt32
@ eFormatUnicode32
@ eFormatVectorOfSInt8
@ eFormatVectorOfUInt16
@ eFormatHexUppercase
@ eFormatVectorOfFloat64
@ eFormatCharPrintable
Only printable characters, '.' if not printable.
@ eFormatComplexInteger
Integer complex type.
@ eFormatVectorOfSInt16
@ eFormatVectorOfUInt32
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
std::shared_ptr< lldb_private::MemoryHistory > MemoryHistorySP
Definition: lldb-forward.h:365
@ eExpressionCompleted
std::shared_ptr< lldb_private::Type > TypeSP
Definition: lldb-forward.h:452
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:384
@ eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishNoResult
@ eArgTypeByteSize
@ eArgTypeAddressOrExpression
std::shared_ptr< lldb_private::Section > SectionSP
Definition: lldb-forward.h:409
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:332
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:368
Used to build individual command argument lists.
Definition: CommandObject.h:93
static lldb::addr_t ToAddress(const ExecutionContext *exe_ctx, llvm::StringRef s, lldb::addr_t fail_value, Status *error_ptr)
Try to parse an address.
static bool ToBoolean(llvm::StringRef s, bool fail_value, bool *success_ptr)
BaseType GetRangeBase() const
Definition: RangeMap.h:45
BaseType GetRangeEnd() const
Definition: RangeMap.h:78