| """ |
| LLDB AppKit formatters |
| |
| part of The LLVM Compiler Infrastructure |
| This file is distributed under the University of Illinois Open Source |
| License. See LICENSE.TXT for details. |
| """ |
| # example synthetic children and summary provider for CFString (and related NSString class) |
| # the real code is part of the LLDB core |
| import lldb |
| import lldb.runtime.objc.objc_runtime |
| import lldb.formatters.Logger |
| |
| def CFString_SummaryProvider (valobj,dict): |
| logger = lldb.formatters.Logger.Logger() |
| provider = CFStringSynthProvider(valobj,dict); |
| if provider.invalid == False: |
| try: |
| summary = provider.get_child_at_index(provider.get_child_index("content")) |
| if type(summary) == lldb.SBValue: |
| summary = summary.GetSummary() |
| else: |
| summary = '"' + summary + '"' |
| except: |
| summary = None |
| if summary == None: |
| summary = '<variable is not NSString>' |
| return '@'+summary |
| return '' |
| |
| def CFAttributedString_SummaryProvider (valobj,dict): |
| logger = lldb.formatters.Logger.Logger() |
| offset = valobj.GetTarget().GetProcess().GetAddressByteSize() |
| pointee = valobj.GetValueAsUnsigned(0) |
| summary = '<variable is not NSAttributedString>' |
| if pointee != None and pointee != 0: |
| pointee = pointee + offset |
| child_ptr = valobj.CreateValueFromAddress("string_ptr",pointee,valobj.GetType()) |
| child = child_ptr.CreateValueFromAddress("string_data",child_ptr.GetValueAsUnsigned(),valobj.GetType()).AddressOf() |
| provider = CFStringSynthProvider(child,dict); |
| if provider.invalid == False: |
| try: |
| summary = provider.get_child_at_index(provider.get_child_index("content")).GetSummary(); |
| except: |
| summary = '<variable is not NSAttributedString>' |
| if summary == None: |
| summary = '<variable is not NSAttributedString>' |
| return '@'+summary |
| |
| |
| def __lldb_init_module(debugger,dict): |
| debugger.HandleCommand("type summary add -F CFString.CFString_SummaryProvider NSString CFStringRef CFMutableStringRef") |
| debugger.HandleCommand("type summary add -F CFString.CFAttributedString_SummaryProvider NSAttributedString") |
| |
| class CFStringSynthProvider: |
| def __init__(self,valobj,dict): |
| logger = lldb.formatters.Logger.Logger() |
| self.valobj = valobj; |
| self.update() |
| |
| # children other than "content" are for debugging only and must not be used in production code |
| def num_children(self): |
| logger = lldb.formatters.Logger.Logger() |
| if self.invalid: |
| return 0; |
| return 6; |
| |
| def read_unicode(self, pointer,max_len=2048): |
| logger = lldb.formatters.Logger.Logger() |
| process = self.valobj.GetTarget().GetProcess() |
| error = lldb.SBError() |
| pystr = u'' |
| # cannot do the read at once because the length value has |
| # a weird encoding. better play it safe here |
| while max_len > 0: |
| content = process.ReadMemory(pointer, 2, error) |
| new_bytes = bytearray(content) |
| b0 = new_bytes[0] |
| b1 = new_bytes[1] |
| pointer = pointer + 2 |
| if b0 == 0 and b1 == 0: |
| break |
| # rearrange bytes depending on endianness |
| # (do we really need this or is Cocoa going to |
| # use Windows-compatible little-endian even |
| # if the target is big endian?) |
| if self.is_little: |
| value = b1 * 256 + b0 |
| else: |
| value = b0 * 256 + b1 |
| pystr = pystr + unichr(value) |
| # read max_len unicode values, not max_len bytes |
| max_len = max_len - 1 |
| return pystr |
| |
| # handle the special case strings |
| # only use the custom code for the tested LP64 case |
| def handle_special(self): |
| logger = lldb.formatters.Logger.Logger() |
| if self.is_64_bit == False: |
| # for 32bit targets, use safe ObjC code |
| return self.handle_unicode_string_safe() |
| offset = 12 |
| pointer = self.valobj.GetValueAsUnsigned(0) + offset |
| pystr = self.read_unicode(pointer) |
| return self.valobj.CreateValueFromExpression("content", |
| "(char*)\"" + pystr.encode('utf-8') + "\"") |
| |
| # last resort call, use ObjC code to read; the final aim is to |
| # be able to strip this call away entirely and only do the read |
| # ourselves |
| def handle_unicode_string_safe(self): |
| return self.valobj.CreateValueFromExpression("content", |
| "(char*)\"" + self.valobj.GetObjectDescription() + "\""); |
| |
| def handle_unicode_string(self): |
| logger = lldb.formatters.Logger.Logger() |
| # step 1: find offset |
| if self.inline: |
| pointer = self.valobj.GetValueAsUnsigned(0) + self.size_of_cfruntime_base(); |
| if self.explicit == False: |
| # untested, use the safe code path |
| return self.handle_unicode_string_safe(); |
| else: |
| # a full pointer is skipped here before getting to the live data |
| pointer = pointer + self.pointer_size |
| else: |
| pointer = self.valobj.GetValueAsUnsigned(0) + self.size_of_cfruntime_base() |
| # read 8 bytes here and make an address out of them |
| try: |
| char_type = self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar).GetPointerType() |
| vopointer = self.valobj.CreateValueFromAddress("dummy",pointer,char_type); |
| pointer = vopointer.GetValueAsUnsigned(0) |
| except: |
| return self.valobj.CreateValueFromExpression("content", |
| '(char*)"@\"invalid NSString\""') |
| # step 2: read Unicode data at pointer |
| pystr = self.read_unicode(pointer) |
| # step 3: return it |
| return pystr.encode('utf-8') |
| |
| def handle_inline_explicit(self): |
| logger = lldb.formatters.Logger.Logger() |
| offset = 3*self.pointer_size |
| offset = offset + self.valobj.GetValueAsUnsigned(0) |
| return self.valobj.CreateValueFromExpression("content", |
| "(char*)(" + str(offset) + ")") |
| |
| def handle_mutable_string(self): |
| logger = lldb.formatters.Logger.Logger() |
| offset = 2 * self.pointer_size |
| data = self.valobj.CreateChildAtOffset("content", |
| offset, self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar).GetPointerType()); |
| data_value = data.GetValueAsUnsigned(0) |
| if self.explicit and self.unicode: |
| return self.read_unicode(data_value).encode('utf-8') |
| else: |
| data_value = data_value + 1 |
| return self.valobj.CreateValueFromExpression("content", "(char*)(" + str(data_value) + ")") |
| |
| def handle_UTF8_inline(self): |
| logger = lldb.formatters.Logger.Logger() |
| offset = self.valobj.GetValueAsUnsigned(0) + self.size_of_cfruntime_base(); |
| if self.explicit == False: |
| offset = offset + 1; |
| return self.valobj.CreateValueFromAddress("content", |
| offset, self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar)).AddressOf(); |
| |
| def handle_UTF8_not_inline(self): |
| logger = lldb.formatters.Logger.Logger() |
| offset = self.size_of_cfruntime_base(); |
| return self.valobj.CreateChildAtOffset("content", |
| offset,self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar).GetPointerType()); |
| |
| def get_child_at_index(self,index): |
| logger = lldb.formatters.Logger.Logger() |
| logger >> "Querying for child [" + str(index) + "]" |
| if index == 0: |
| return self.valobj.CreateValueFromExpression("mutable", |
| str(int(self.mutable))); |
| if index == 1: |
| return self.valobj.CreateValueFromExpression("inline", |
| str(int(self.inline))); |
| if index == 2: |
| return self.valobj.CreateValueFromExpression("explicit", |
| str(int(self.explicit))); |
| if index == 3: |
| return self.valobj.CreateValueFromExpression("unicode", |
| str(int(self.unicode))); |
| if index == 4: |
| return self.valobj.CreateValueFromExpression("special", |
| str(int(self.special))); |
| if index == 5: |
| # we are handling the several possible combinations of flags. |
| # for each known combination we have a function that knows how to |
| # go fetch the data from memory instead of running code. if a string is not |
| # correctly displayed, one should start by finding a combination of flags that |
| # makes it different from these known cases, and provide a new reader function |
| # if this is not possible, a new flag might have to be made up (like the "special" flag |
| # below, which is not a real flag in CFString), or alternatively one might need to use |
| # the ObjC runtime helper to detect the new class and deal with it accordingly |
| #print 'mutable = ' + str(self.mutable) |
| #print 'inline = ' + str(self.inline) |
| #print 'explicit = ' + str(self.explicit) |
| #print 'unicode = ' + str(self.unicode) |
| #print 'special = ' + str(self.special) |
| if self.mutable == True: |
| return self.handle_mutable_string() |
| elif self.inline == True and self.explicit == True and \ |
| self.unicode == False and self.special == False and \ |
| self.mutable == False: |
| return self.handle_inline_explicit() |
| elif self.unicode == True: |
| return self.handle_unicode_string(); |
| elif self.special == True: |
| return self.handle_special(); |
| elif self.inline == True: |
| return self.handle_UTF8_inline(); |
| else: |
| return self.handle_UTF8_not_inline(); |
| |
| def get_child_index(self,name): |
| logger = lldb.formatters.Logger.Logger() |
| logger >> "Querying for child ['" + str(name) + "']" |
| if name == "content": |
| return self.num_children() - 1; |
| if name == "mutable": |
| return 0; |
| if name == "inline": |
| return 1; |
| if name == "explicit": |
| return 2; |
| if name == "unicode": |
| return 3; |
| if name == "special": |
| return 4; |
| |
| # CFRuntimeBase is defined as having an additional |
| # 4 bytes (padding?) on LP64 architectures |
| # to get its size we add up sizeof(pointer)+4 |
| # and then add 4 more bytes if we are on a 64bit system |
| def size_of_cfruntime_base(self): |
| logger = lldb.formatters.Logger.Logger() |
| return self.pointer_size+4+(4 if self.is_64_bit else 0) |
| |
| # the info bits are part of the CFRuntimeBase structure |
| # to get at them we have to skip a uintptr_t and then get |
| # at the least-significant byte of a 4 byte array. If we are |
| # on big-endian this means going to byte 3, if we are on |
| # little endian (OSX & iOS), this means reading byte 0 |
| def offset_of_info_bits(self): |
| logger = lldb.formatters.Logger.Logger() |
| offset = self.pointer_size |
| if self.is_little == False: |
| offset = offset + 3; |
| return offset; |
| |
| def read_info_bits(self): |
| logger = lldb.formatters.Logger.Logger() |
| cfinfo = self.valobj.CreateChildAtOffset("cfinfo", |
| self.offset_of_info_bits(), |
| self.valobj.GetType().GetBasicType(lldb.eBasicTypeChar)); |
| cfinfo.SetFormat(11) |
| info = cfinfo.GetValue(); |
| if info != None: |
| self.invalid = False; |
| return int(info,0); |
| else: |
| self.invalid = True; |
| return None; |
| |
| # calculating internal flag bits of the CFString object |
| # this stuff is defined and discussed in CFString.c |
| def is_mutable(self): |
| logger = lldb.formatters.Logger.Logger() |
| return (self.info_bits & 1) == 1; |
| |
| def is_inline(self): |
| logger = lldb.formatters.Logger.Logger() |
| return (self.info_bits & 0x60) == 0; |
| |
| # this flag's name is ambiguous, it turns out |
| # we must skip a length byte to get at the data |
| # when this flag is False |
| def has_explicit_length(self): |
| logger = lldb.formatters.Logger.Logger() |
| return (self.info_bits & (1 | 4)) != 4; |
| |
| # probably a subclass of NSString. obtained this from [str pathExtension] |
| # here info_bits = 0 and Unicode data at the start of the padding word |
| # in the long run using the isa value might be safer as a way to identify this |
| # instead of reading the info_bits |
| def is_special_case(self): |
| logger = lldb.formatters.Logger.Logger() |
| return self.info_bits == 0; |
| |
| def is_unicode(self): |
| logger = lldb.formatters.Logger.Logger() |
| return (self.info_bits & 0x10) == 0x10; |
| |
| # preparing ourselves to read into memory |
| # by adjusting architecture-specific info |
| def adjust_for_architecture(self): |
| logger = lldb.formatters.Logger.Logger() |
| self.pointer_size = self.valobj.GetTarget().GetProcess().GetAddressByteSize() |
| self.is_64_bit = self.pointer_size == 8 |
| self.is_little = self.valobj.GetTarget().GetProcess().GetByteOrder() == lldb.eByteOrderLittle |
| |
| # reading info bits out of the CFString and computing |
| # useful values to get at the real data |
| def compute_flags(self): |
| logger = lldb.formatters.Logger.Logger() |
| self.info_bits = self.read_info_bits(); |
| if self.info_bits == None: |
| return; |
| self.mutable = self.is_mutable(); |
| self.inline = self.is_inline(); |
| self.explicit = self.has_explicit_length(); |
| self.unicode = self.is_unicode(); |
| self.special = self.is_special_case(); |
| |
| def update(self): |
| logger = lldb.formatters.Logger.Logger() |
| self.adjust_for_architecture(); |
| self.compute_flags(); |
