8461c00435
Commands that take an address expression/address through the OptionArgParser::ToAddress method, which has filtered this user-specified address through one of the Process Fix methods to clear non-addressable bits (MTE, PAC, top byte ignore, etc). We don't know what class of address this is, IMEM or DMEM, but this method is passing the addresses through Process::FixCodeAddress, and on at least one target, FixCodeAddress clears low bits which are invalid for instructions. Correct this to use FixAnyAddress, which doesn't make alignment assumptions. The actual issue found was by people debugging on a 32-bit ARM Cortex-M part, who tried to do a memory read from an odd address, and lldb returned results starting at the next lower even address. rdar://154885727
323 lines
10 KiB
C++
323 lines
10 KiB
C++
//===-- OptionArgParser.cpp -----------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Interpreter/OptionArgParser.h"
|
|
#include "lldb/DataFormatters/FormatManager.h"
|
|
#include "lldb/Target/ABI.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Utility/RegisterValue.h"
|
|
#include "lldb/Utility/Status.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
|
|
using namespace lldb_private;
|
|
using namespace lldb;
|
|
|
|
bool OptionArgParser::ToBoolean(llvm::StringRef ref, bool fail_value,
|
|
bool *success_ptr) {
|
|
if (success_ptr)
|
|
*success_ptr = true;
|
|
ref = ref.trim();
|
|
if (ref.equals_insensitive("false") || ref.equals_insensitive("off") ||
|
|
ref.equals_insensitive("no") || ref.equals_insensitive("0")) {
|
|
return false;
|
|
} else if (ref.equals_insensitive("true") || ref.equals_insensitive("on") ||
|
|
ref.equals_insensitive("yes") || ref.equals_insensitive("1")) {
|
|
return true;
|
|
}
|
|
if (success_ptr)
|
|
*success_ptr = false;
|
|
return fail_value;
|
|
}
|
|
|
|
llvm::Expected<bool> OptionArgParser::ToBoolean(llvm::StringRef option_name,
|
|
llvm::StringRef option_arg) {
|
|
bool parse_success;
|
|
const bool option_value =
|
|
ToBoolean(option_arg, false /* doesn't matter */, &parse_success);
|
|
if (parse_success)
|
|
return option_value;
|
|
else
|
|
return llvm::createStringError(
|
|
"Invalid boolean value for option '%s': '%s'",
|
|
option_name.str().c_str(),
|
|
option_arg.empty() ? "<null>" : option_arg.str().c_str());
|
|
}
|
|
|
|
char OptionArgParser::ToChar(llvm::StringRef s, char fail_value,
|
|
bool *success_ptr) {
|
|
if (success_ptr)
|
|
*success_ptr = false;
|
|
if (s.size() != 1)
|
|
return fail_value;
|
|
|
|
if (success_ptr)
|
|
*success_ptr = true;
|
|
return s[0];
|
|
}
|
|
|
|
int64_t OptionArgParser::ToOptionEnum(llvm::StringRef s,
|
|
const OptionEnumValues &enum_values,
|
|
int32_t fail_value, Status &error) {
|
|
error.Clear();
|
|
if (enum_values.empty()) {
|
|
error = Status::FromErrorString("invalid enumeration argument");
|
|
return fail_value;
|
|
}
|
|
|
|
if (s.empty()) {
|
|
error = Status::FromErrorString("empty enumeration string");
|
|
return fail_value;
|
|
}
|
|
|
|
for (const auto &enum_value : enum_values) {
|
|
llvm::StringRef this_enum(enum_value.string_value);
|
|
if (this_enum.starts_with(s))
|
|
return enum_value.value;
|
|
}
|
|
|
|
StreamString strm;
|
|
strm.PutCString("invalid enumeration value, valid values are: ");
|
|
bool is_first = true;
|
|
for (const auto &enum_value : enum_values) {
|
|
strm.Printf("%s\"%s\"",
|
|
is_first ? is_first = false,"" : ", ", enum_value.string_value);
|
|
}
|
|
error = Status(strm.GetString().str());
|
|
return fail_value;
|
|
}
|
|
|
|
Status OptionArgParser::ToFormat(const char *s, lldb::Format &format,
|
|
size_t *byte_size_ptr) {
|
|
format = eFormatInvalid;
|
|
Status error;
|
|
|
|
if (s && s[0]) {
|
|
if (byte_size_ptr) {
|
|
if (isdigit(s[0])) {
|
|
char *format_char = nullptr;
|
|
unsigned long byte_size = ::strtoul(s, &format_char, 0);
|
|
if (byte_size != ULONG_MAX)
|
|
*byte_size_ptr = byte_size;
|
|
s = format_char;
|
|
} else
|
|
*byte_size_ptr = 0;
|
|
}
|
|
|
|
if (!FormatManager::GetFormatFromCString(s, format)) {
|
|
StreamString error_strm;
|
|
error_strm.Printf(
|
|
"Invalid format character or name '%s'. Valid values are:\n", s);
|
|
for (Format f = eFormatDefault; f < kNumFormats; f = Format(f + 1)) {
|
|
char format_char = FormatManager::GetFormatAsFormatChar(f);
|
|
if (format_char)
|
|
error_strm.Printf("'%c' or ", format_char);
|
|
|
|
error_strm.Printf("\"%s\"", FormatManager::GetFormatAsCString(f));
|
|
error_strm.EOL();
|
|
}
|
|
|
|
if (byte_size_ptr)
|
|
error_strm.PutCString(
|
|
"An optional byte size can precede the format character.\n");
|
|
error = Status(error_strm.GetString().str());
|
|
}
|
|
|
|
if (error.Fail())
|
|
return error;
|
|
} else {
|
|
error = Status::FromErrorStringWithFormat("%s option string",
|
|
s ? "empty" : "invalid");
|
|
}
|
|
return error;
|
|
}
|
|
|
|
lldb::ScriptLanguage OptionArgParser::ToScriptLanguage(
|
|
llvm::StringRef s, lldb::ScriptLanguage fail_value, bool *success_ptr) {
|
|
if (success_ptr)
|
|
*success_ptr = true;
|
|
|
|
if (s.equals_insensitive("python"))
|
|
return eScriptLanguagePython;
|
|
if (s.equals_insensitive("lua"))
|
|
return eScriptLanguageLua;
|
|
if (s.equals_insensitive("default"))
|
|
return eScriptLanguageDefault;
|
|
if (s.equals_insensitive("none"))
|
|
return eScriptLanguageNone;
|
|
|
|
if (success_ptr)
|
|
*success_ptr = false;
|
|
return fail_value;
|
|
}
|
|
|
|
lldb::addr_t OptionArgParser::ToRawAddress(const ExecutionContext *exe_ctx,
|
|
llvm::StringRef s,
|
|
lldb::addr_t fail_value,
|
|
Status *error_ptr) {
|
|
std::optional<lldb::addr_t> maybe_addr = DoToAddress(exe_ctx, s, error_ptr);
|
|
return maybe_addr ? *maybe_addr : fail_value;
|
|
}
|
|
|
|
lldb::addr_t OptionArgParser::ToAddress(const ExecutionContext *exe_ctx,
|
|
llvm::StringRef s,
|
|
lldb::addr_t fail_value,
|
|
Status *error_ptr) {
|
|
std::optional<lldb::addr_t> maybe_addr = DoToAddress(exe_ctx, s, error_ptr);
|
|
if (!maybe_addr)
|
|
return fail_value;
|
|
|
|
lldb::addr_t addr = *maybe_addr;
|
|
|
|
if (Process *process = exe_ctx->GetProcessPtr())
|
|
addr = process->FixAnyAddress(addr);
|
|
|
|
return addr;
|
|
}
|
|
|
|
std::optional<lldb::addr_t>
|
|
OptionArgParser::DoToAddress(const ExecutionContext *exe_ctx, llvm::StringRef s,
|
|
Status *error_ptr) {
|
|
if (s.empty()) {
|
|
if (error_ptr)
|
|
*error_ptr = Status::FromErrorStringWithFormat(
|
|
"invalid address expression \"%s\"", s.str().c_str());
|
|
return {};
|
|
}
|
|
|
|
llvm::StringRef sref = s;
|
|
|
|
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
|
|
if (!s.getAsInteger(0, addr)) {
|
|
if (error_ptr)
|
|
error_ptr->Clear();
|
|
|
|
return addr;
|
|
}
|
|
|
|
// Try base 16 with no prefix...
|
|
if (!s.getAsInteger(16, addr)) {
|
|
if (error_ptr)
|
|
error_ptr->Clear();
|
|
return addr;
|
|
}
|
|
|
|
Target *target = nullptr;
|
|
if (!exe_ctx || !(target = exe_ctx->GetTargetPtr())) {
|
|
if (error_ptr)
|
|
*error_ptr = Status::FromErrorStringWithFormat(
|
|
"invalid address expression \"%s\"", s.str().c_str());
|
|
return {};
|
|
}
|
|
|
|
lldb::ValueObjectSP valobj_sp;
|
|
EvaluateExpressionOptions options;
|
|
options.SetCoerceToId(false);
|
|
options.SetUnwindOnError(true);
|
|
options.SetKeepInMemory(false);
|
|
options.SetTryAllThreads(true);
|
|
|
|
ExpressionResults expr_result =
|
|
target->EvaluateExpression(s, exe_ctx->GetFramePtr(), valobj_sp, options);
|
|
|
|
bool success = false;
|
|
if (expr_result == eExpressionCompleted) {
|
|
if (valobj_sp)
|
|
valobj_sp = valobj_sp->GetQualifiedRepresentationIfAvailable(
|
|
valobj_sp->GetDynamicValueType(), true);
|
|
// Get the address to watch.
|
|
if (valobj_sp)
|
|
addr = valobj_sp->GetValueAsUnsigned(0, &success);
|
|
if (success) {
|
|
if (error_ptr)
|
|
error_ptr->Clear();
|
|
return addr;
|
|
}
|
|
if (error_ptr)
|
|
*error_ptr = Status::FromErrorStringWithFormat(
|
|
"address expression \"%s\" resulted in a value whose type "
|
|
"can't be converted to an address: %s",
|
|
s.str().c_str(), valobj_sp->GetTypeName().GetCString());
|
|
return {};
|
|
}
|
|
|
|
// Since the compiler can't handle things like "main + 12" we should try to
|
|
// do this for now. The compiler doesn't like adding offsets to function
|
|
// pointer types.
|
|
// Some languages also don't have a natural representation for register
|
|
// values (e.g. swift) so handle simple uses of them here as well.
|
|
// We use a regex to parse these forms, the regex handles:
|
|
// $reg_name
|
|
// $reg_name+offset
|
|
// symbol_name+offset
|
|
//
|
|
// The important matching elements in the regex below are:
|
|
// 1: The reg name if there's no +offset
|
|
// 3: The symbol/reg name if there is an offset
|
|
// 4: +/-
|
|
// 5: The offset value.
|
|
// clang-format off
|
|
static RegularExpression g_symbol_plus_offset_regex(
|
|
"^(\\$[^ +-]+)|(([^ +-]+)[[:space:]]*([-\\+])[[:space:]]*(0x[0-9A-Fa-f]+|[0-9]+)[[:space:]]*)$");
|
|
// clang-format on
|
|
|
|
llvm::SmallVector<llvm::StringRef, 4> matches;
|
|
if (g_symbol_plus_offset_regex.Execute(sref, &matches)) {
|
|
uint64_t offset = 0;
|
|
llvm::StringRef name;
|
|
if (!matches[1].empty())
|
|
name = matches[1];
|
|
else
|
|
name = matches[3];
|
|
|
|
llvm::StringRef sign = matches[4];
|
|
llvm::StringRef str_offset = matches[5];
|
|
|
|
// Some languages don't have a natural type for register values, but it
|
|
// is still useful to look them up here:
|
|
std::optional<lldb::addr_t> register_value;
|
|
StackFrame *frame = exe_ctx->GetFramePtr();
|
|
llvm::StringRef reg_name = name;
|
|
if (frame && reg_name.consume_front("$")) {
|
|
RegisterContextSP reg_ctx_sp = frame->GetRegisterContext();
|
|
if (reg_ctx_sp) {
|
|
const RegisterInfo *reg_info = reg_ctx_sp->GetRegisterInfoByName(reg_name);
|
|
if (reg_info) {
|
|
RegisterValue reg_val;
|
|
bool success = reg_ctx_sp->ReadRegister(reg_info, reg_val);
|
|
if (success && reg_val.GetType() != RegisterValue::eTypeInvalid) {
|
|
register_value = reg_val.GetAsUInt64(0, &success);
|
|
if (!success)
|
|
register_value.reset();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!str_offset.empty() && !str_offset.getAsInteger(0, offset)) {
|
|
Status error;
|
|
if (register_value)
|
|
addr = register_value.value();
|
|
else
|
|
addr = ToAddress(exe_ctx, name, LLDB_INVALID_ADDRESS, &error);
|
|
if (addr != LLDB_INVALID_ADDRESS) {
|
|
if (sign[0] == '+')
|
|
return addr + offset;
|
|
return addr - offset;
|
|
}
|
|
} else if (register_value)
|
|
// In the case of register values, someone might just want to get the
|
|
// value in a language whose expression parser doesn't support registers.
|
|
return register_value.value();
|
|
}
|
|
|
|
if (error_ptr)
|
|
*error_ptr = Status::FromErrorStringWithFormat(
|
|
"address expression \"%s\" evaluation failed", s.str().c_str());
|
|
return {};
|
|
}
|