bool
lldb_private::formatters::swift::StaticString_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options, StringPrinter::ReadStringAndDumpToStreamOptions read_options)
{
static ConstString g__startPtrOrData("_startPtrOrData");
static ConstString g__byteSize("_utf8CodeUnitCount");
static ConstString g__flags("_flags");
ValueObjectSP flags_sp(valobj.GetChildMemberWithName(g__flags, true));
if (!flags_sp)
return false;
ProcessSP process_sp(valobj.GetProcessSP());
if (!process_sp)
return false;
// 0 == pointer representation
InferiorSizedWord flags(flags_sp->GetValueAsUnsigned(0), *process_sp);
if (0 != (flags & 0x1).GetValue())
return false;
ValueObjectSP startptr_sp(valobj.GetChildMemberWithName(g__startPtrOrData, true));
ValueObjectSP bytesize_sp(valobj.GetChildMemberWithName(g__byteSize, true));
if (!startptr_sp || !bytesize_sp)
return false;
lldb::addr_t start_ptr = startptr_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
uint64_t size = bytesize_sp->GetValueAsUnsigned(0);
if (start_ptr == LLDB_INVALID_ADDRESS || start_ptr == 0)
return false;
if (size == 0)
{
stream.Printf("\"\"");
return true;
}
read_options.SetProcessSP(process_sp);
read_options.SetLocation(start_ptr);
read_options.SetSourceSize(size);
read_options.SetBinaryZeroIsTerminator(false);
read_options.SetNeedsZeroTermination(false);
read_options.SetStream(&stream);
read_options.SetIgnoreMaxLength(summary_options.GetCapping() == lldb::eTypeSummaryUncapped);
read_options.SetLanguage(lldb::eLanguageTypeSwift);
return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8>(read_options);
}
bool
lldb_private::formatters::swift::StringCore_SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options, StringPrinter::ReadStringAndDumpToStreamOptions read_options)
{
static ConstString g_some("some");
static ConstString g__baseAddress("_baseAddress");
static ConstString g__countAndFlags("_countAndFlags");
static ConstString g_value("_value");
static ConstString g__rawValue("_rawValue");
ProcessSP process_sp(valobj.GetProcessSP());
if (!process_sp)
return false;
ValueObjectSP baseAddress_sp(valobj.GetChildAtNamePath({ g__baseAddress, g_some, g__rawValue }));
ValueObjectSP _countAndFlags_sp(valobj.GetChildAtNamePath({ g__countAndFlags, g_value }));
if (!_countAndFlags_sp)
return false;
lldb::addr_t baseAddress = baseAddress_sp ? baseAddress_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS) : 0;
InferiorSizedWord _countAndFlags = InferiorSizedWord(_countAndFlags_sp->GetValueAsUnsigned(0),*process_sp.get());
if (baseAddress == LLDB_INVALID_ADDRESS)
return false;
bool hasCocoaBuffer = (_countAndFlags << 1).IsNegative();
if (baseAddress == 0)
{
if (hasCocoaBuffer)
{
static ConstString g__owner("_owner");
static ConstString g_Some("some");
static ConstString g_instance_type("instance_type");
ValueObjectSP dyn_inst_type0(valobj.GetChildAtNamePath({g__owner,g_Some,g_instance_type}));
if (!dyn_inst_type0)
return false;
lldb::addr_t dyn_inst_type0_ptr = dyn_inst_type0->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
if (dyn_inst_type0_ptr == 0 || dyn_inst_type0_ptr == LLDB_INVALID_ADDRESS)
return false;
InferiorSizedWord dataAddress_isw = InferiorSizedWord(dyn_inst_type0_ptr, *process_sp.get());
DataExtractor id_ptr = dataAddress_isw.GetAsData(process_sp->GetByteOrder());
CompilerType id_type = process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(lldb::eBasicTypeObjCID);
if (!id_type)
return false;
ValueObjectSP nsstringhere_sp = ValueObject::CreateValueObjectFromData("nsstringhere", id_ptr, valobj.GetExecutionContextRef(), id_type);
if (nsstringhere_sp)
return NSStringSummaryProvider(*nsstringhere_sp.get(), stream, summary_options);
return false;
}
else
{
stream.Printf("\"\"");
return true;
}
}
const InferiorSizedWord _countMask = InferiorSizedWord::GetMaximum(*process_sp.get()) >> 2;
uint64_t count = (_countAndFlags & _countMask).GetValue();
bool isASCII = ((_countAndFlags >> (_countMask.GetBitSize() - 1)).SignExtend() << 8).IsZero();
if (count == 0)
{
stream.Printf("\"\"");
return true;
}
read_options.SetLocation(baseAddress);
read_options.SetProcessSP(process_sp);
read_options.SetStream(&stream);
read_options.SetSourceSize(count);
read_options.SetNeedsZeroTermination(false);
read_options.SetIgnoreMaxLength(summary_options.GetCapping() == lldb::eTypeSummaryUncapped);
read_options.SetBinaryZeroIsTerminator(false);
read_options.SetLanguage(summary_options.GetLanguage());
if (summary_options.GetLanguage() == lldb::eLanguageTypeObjC) read_options.SetPrefixToken("@");
if (isASCII)
return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8>(read_options);
else
return StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16>(read_options);
}
bool
lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options)
{
ProcessSP process_sp = valobj.GetProcessSP();
if (!process_sp)
return false;
ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
if (!runtime)
return false;
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
if (!descriptor.get() || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
if (!valobj_addr)
return false;
const char* class_name = descriptor->GetClassName().GetCString();
if (!class_name || !*class_name)
return false;
bool is_tagged_ptr = (0 == strcmp(class_name,"NSTaggedPointerString")) && descriptor->GetTaggedPointerInfo();
// for a tagged pointer, the descriptor has everything we need
if (is_tagged_ptr)
return NSTaggedString_SummaryProvider(descriptor, stream);
// if not a tagged pointer that we know about, try the normal route
uint64_t info_bits_location = valobj_addr + ptr_size;
if (process_sp->GetByteOrder() != lldb::eByteOrderLittle)
info_bits_location += 3;
Error error;
uint8_t info_bits = process_sp->ReadUnsignedIntegerFromMemory(info_bits_location, 1, 0, error);
if (error.Fail())
return false;
bool is_mutable = (info_bits & 1) == 1;
bool is_inline = (info_bits & 0x60) == 0;
bool has_explicit_length = (info_bits & (1 | 4)) != 4;
bool is_unicode = (info_bits & 0x10) == 0x10;
bool is_path_store = strcmp(class_name,"NSPathStore2") == 0;
bool has_null = (info_bits & 8) == 8;
size_t explicit_length = 0;
if (!has_null && has_explicit_length && !is_path_store)
{
lldb::addr_t explicit_length_offset = 2*ptr_size;
if (is_mutable && !is_inline)
explicit_length_offset = explicit_length_offset + ptr_size; // notInlineMutable.length;
else if (is_inline)
explicit_length = explicit_length + 0; // inline1.length;
else if (!is_inline && !is_mutable)
explicit_length_offset = explicit_length_offset + ptr_size; // notInlineImmutable1.length;
else
explicit_length_offset = 0;
if (explicit_length_offset)
{
explicit_length_offset = valobj_addr + explicit_length_offset;
explicit_length = process_sp->ReadUnsignedIntegerFromMemory(explicit_length_offset, 4, 0, error);
}
}
if (strcmp(class_name,"NSString") &&
strcmp(class_name,"CFStringRef") &&
strcmp(class_name,"CFMutableStringRef") &&
strcmp(class_name,"__NSCFConstantString") &&
strcmp(class_name,"__NSCFString") &&
strcmp(class_name,"NSCFConstantString") &&
strcmp(class_name,"NSCFString") &&
strcmp(class_name,"NSPathStore2"))
{
// not one of us - but tell me class name
stream.Printf("class name = %s",class_name);
return true;
}
if (is_mutable)
{
uint64_t location = 2 * ptr_size + valobj_addr;
location = process_sp->ReadPointerFromMemory(location, error);
if (error.Fail())
return false;
if (has_explicit_length && is_unicode)
{
ReadStringAndDumpToStreamOptions options(valobj);
options.SetLocation(location);
options.SetProcessSP(process_sp);
options.SetStream(&stream);
options.SetPrefixToken('@');
options.SetQuote('"');
options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(false);
options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(false);
return ReadStringAndDumpToStream<StringElementType::UTF16>(options);
}
else
{
ReadStringAndDumpToStreamOptions options(valobj);
options.SetLocation(location+1);
options.SetProcessSP(process_sp);
options.SetStream(&stream);
options.SetPrefixToken('@');
options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(false);
options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(false);
return ReadStringAndDumpToStream<StringElementType::ASCII>(options);
}
}
else if (is_inline && has_explicit_length && !is_unicode && !is_path_store && !is_mutable)
{
uint64_t location = 3 * ptr_size + valobj_addr;
ReadStringAndDumpToStreamOptions options(valobj);
options.SetLocation(location);
options.SetProcessSP(process_sp);
options.SetStream(&stream);
options.SetPrefixToken('@');
options.SetQuote('"');
options.SetSourceSize(explicit_length);
options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
return ReadStringAndDumpToStream<StringElementType::ASCII> (options);
}
else if (is_unicode)
{
uint64_t location = valobj_addr + 2*ptr_size;
if (is_inline)
{
if (!has_explicit_length)
{
stream.Printf("found new combo");
return true;
}
else
location += ptr_size;
}
else
{
location = process_sp->ReadPointerFromMemory(location, error);
if (error.Fail())
return false;
}
ReadStringAndDumpToStreamOptions options(valobj);
options.SetLocation(location);
options.SetProcessSP(process_sp);
options.SetStream(&stream);
options.SetPrefixToken('@');
options.SetQuote('"');
options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(has_explicit_length == false);
options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(has_explicit_length == false);
return ReadStringAndDumpToStream<StringElementType::UTF16> (options);
}
else if (is_path_store)
{
ProcessStructReader reader(valobj.GetProcessSP().get(), valobj.GetValueAsUnsigned(0), GetNSPathStore2Type(*valobj.GetTargetSP()));
explicit_length = reader.GetField<uint32_t>(ConstString("lengthAndRef")) >> 20;
lldb::addr_t location = valobj.GetValueAsUnsigned(0) + ptr_size + 4;
ReadStringAndDumpToStreamOptions options(valobj);
options.SetLocation(location);
options.SetProcessSP(process_sp);
options.SetStream(&stream);
options.SetPrefixToken('@');
options.SetQuote('"');
options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(has_explicit_length == false);
options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(has_explicit_length == false);
return ReadStringAndDumpToStream<StringElementType::UTF16> (options);
}
else if (is_inline)
{
uint64_t location = valobj_addr + 2*ptr_size;
if (!has_explicit_length)
{
// in this kind of string, the byte before the string content is a length byte
// so let's try and use it to handle the embedded NUL case
Error error;
explicit_length = process_sp->ReadUnsignedIntegerFromMemory(location, 1, 0, error);
if (error.Fail() || explicit_length == 0)
has_explicit_length = false;
else
has_explicit_length = true;
location++;
}
ReadStringAndDumpToStreamOptions options(valobj);
options.SetLocation(location);
options.SetProcessSP(process_sp);
options.SetStream(&stream);
options.SetPrefixToken('@');
options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(!has_explicit_length);
options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(!has_explicit_length);
if (has_explicit_length)
return ReadStringAndDumpToStream<StringElementType::UTF8>(options);
else
return ReadStringAndDumpToStream<StringElementType::ASCII>(options);
}
else
{
uint64_t location = valobj_addr + 2*ptr_size;
location = process_sp->ReadPointerFromMemory(location, error);
if (error.Fail())
return false;
if (has_explicit_length && !has_null)
explicit_length++; // account for the fact that there is no NULL and we need to have one added
ReadStringAndDumpToStreamOptions options(valobj);
options.SetLocation(location);
options.SetProcessSP(process_sp);
options.SetPrefixToken('@');
options.SetStream(&stream);
options.SetSourceSize(explicit_length);
options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
return ReadStringAndDumpToStream<StringElementType::ASCII>(options);
}
}
