contrib/llvm/tools/lldb/source/DataFormatters/VectorType.cpp

   1 //===-- VectorType.cpp ------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // C Includes
  11 // C++ Includes
  12 // Other libraries and framework includes
  13 // Project includes
  14 #include "lldb/DataFormatters/VectorType.h"
  15
  16 #include "lldb/Core/ValueObject.h"
  17 #include "lldb/DataFormatters/FormattersHelpers.h"
  18 #include "lldb/Symbol/CompilerType.h"
  19 #include "lldb/Symbol/TypeSystem.h"
  20 #include "lldb/Target/Target.h"
  21
  22 #include "lldb/Utility/LLDBAssert.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26 using namespace lldb_private::formatters;
  27
  28 static CompilerType GetCompilerTypeForFormat(lldb::Format format,
  29                                              CompilerType element_type,
  30                                              TypeSystem *type_system) {
  31   lldbassert(type_system && "type_system needs to be not NULL");
  32
  33   switch (format) {
  34   case lldb::eFormatAddressInfo:
  35   case lldb::eFormatPointer:
  36     return type_system->GetBuiltinTypeForEncodingAndBitSize(
  37         eEncodingUint, 8 * type_system->GetPointerByteSize());
  38
  39   case lldb::eFormatBoolean:
  40     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeBool);
  41
  42   case lldb::eFormatBytes:
  43   case lldb::eFormatBytesWithASCII:
  44   case lldb::eFormatChar:
  45   case lldb::eFormatCharArray:
  46   case lldb::eFormatCharPrintable:
  47     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar);
  48
  49   case lldb::eFormatComplex /* lldb::eFormatComplexFloat */:
  50     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloatComplex);
  51
  52   case lldb::eFormatCString:
  53     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar)
  54         .GetPointerType();
  55
  56   case lldb::eFormatFloat:
  57     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloat);
  58
  59   case lldb::eFormatHex:
  60   case lldb::eFormatHexUppercase:
  61   case lldb::eFormatOctal:
  62     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeInt);
  63
  64   case lldb::eFormatHexFloat:
  65     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloat);
  66
  67   case lldb::eFormatUnicode16:
  68   case lldb::eFormatUnicode32:
  69
  70   case lldb::eFormatUnsigned:
  71     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeUnsignedInt);
  72
  73   case lldb::eFormatVectorOfChar:
  74     return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar);
  75
  76   case lldb::eFormatVectorOfFloat32:
  77     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingIEEE754,
  78                                                             32);
  79
  80   case lldb::eFormatVectorOfFloat64:
  81     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingIEEE754,
  82                                                             64);
  83
  84   case lldb::eFormatVectorOfSInt16:
  85     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 16);
  86
  87   case lldb::eFormatVectorOfSInt32:
  88     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 32);
  89
  90   case lldb::eFormatVectorOfSInt64:
  91     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64);
  92
  93   case lldb::eFormatVectorOfSInt8:
  94     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 8);
  95
  96   case lldb::eFormatVectorOfUInt128:
  97     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 128);
  98
  99   case lldb::eFormatVectorOfUInt16:
 100     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 16);
 101
 102   case lldb::eFormatVectorOfUInt32:
 103     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
 104
 105   case lldb::eFormatVectorOfUInt64:
 106     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 64);
 107
 108   case lldb::eFormatVectorOfUInt8:
 109     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8);
 110
 111   case lldb::eFormatDefault:
 112     return element_type;
 113
 114   case lldb::eFormatBinary:
 115   case lldb::eFormatComplexInteger:
 116   case lldb::eFormatDecimal:
 117   case lldb::eFormatEnum:
 118   case lldb::eFormatInstruction:
 119   case lldb::eFormatOSType:
 120   case lldb::eFormatVoid:
 121   default:
 122     return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8);
 123   }
 124 }
 125
 126 static lldb::Format GetItemFormatForFormat(lldb::Format format,
 127                                            CompilerType element_type) {
 128   switch (format) {
 129   case lldb::eFormatVectorOfChar:
 130     return lldb::eFormatChar;
 131
 132   case lldb::eFormatVectorOfFloat32:
 133   case lldb::eFormatVectorOfFloat64:
 134     return lldb::eFormatFloat;
 135
 136   case lldb::eFormatVectorOfSInt16:
 137   case lldb::eFormatVectorOfSInt32:
 138   case lldb::eFormatVectorOfSInt64:
 139   case lldb::eFormatVectorOfSInt8:
 140     return lldb::eFormatDecimal;
 141
 142   case lldb::eFormatVectorOfUInt128:
 143   case lldb::eFormatVectorOfUInt16:
 144   case lldb::eFormatVectorOfUInt32:
 145   case lldb::eFormatVectorOfUInt64:
 146   case lldb::eFormatVectorOfUInt8:
 147     return lldb::eFormatUnsigned;
 148
 149   case lldb::eFormatBinary:
 150   case lldb::eFormatComplexInteger:
 151   case lldb::eFormatDecimal:
 152   case lldb::eFormatEnum:
 153   case lldb::eFormatInstruction:
 154   case lldb::eFormatOSType:
 155   case lldb::eFormatVoid:
 156     return eFormatHex;
 157
 158   case lldb::eFormatDefault: {
 159     // special case the (default, char) combination to actually display as an
 160     // integer value most often, you won't want to see the ASCII characters...
 161     // (and if you do, eFormatChar is a keystroke away)
 162     bool is_char = element_type.IsCharType();
 163     bool is_signed = false;
 164     element_type.IsIntegerType(is_signed);
 165     return is_char ? (is_signed ? lldb::eFormatDecimal : eFormatHex) : format;
 166   } break;
 167
 168   default:
 169     return format;
 170   }
 171 }
 172
 173 static size_t CalculateNumChildren(
 174     CompilerType container_type, CompilerType element_type,
 175     lldb_private::ExecutionContextScope *exe_scope =
 176         nullptr // does not matter here because all we trade in are basic types
 177     ) {
 178   auto container_size = container_type.GetByteSize(exe_scope);
 179   auto element_size = element_type.GetByteSize(exe_scope);
 180
 181   if (element_size) {
 182     if (container_size % element_size)
 183       return 0;
 184     return container_size / element_size;
 185   }
 186   return 0;
 187 }
 188
 189 namespace lldb_private {
 190 namespace formatters {
 191
 192 class VectorTypeSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 193 public:
 194   VectorTypeSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
 195       : SyntheticChildrenFrontEnd(*valobj_sp), m_parent_format(eFormatInvalid),
 196         m_item_format(eFormatInvalid), m_child_type(), m_num_children(0) {}
 197
 198   ~VectorTypeSyntheticFrontEnd() override = default;
 199
 200   size_t CalculateNumChildren() override { return m_num_children; }
 201
 202   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
 203     if (idx >= CalculateNumChildren())
 204       return lldb::ValueObjectSP();
 205     auto offset = idx * m_child_type.GetByteSize(nullptr);
 206     StreamString idx_name;
 207     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
 208     ValueObjectSP child_sp(m_backend.GetSyntheticChildAtOffset(
 209         offset, m_child_type, true, ConstString(idx_name.GetString())));
 210     if (!child_sp)
 211       return child_sp;
 212
 213     child_sp->SetFormat(m_item_format);
 214
 215     return child_sp;
 216   }
 217
 218   bool Update() override {
 219     m_parent_format = m_backend.GetFormat();
 220     CompilerType parent_type(m_backend.GetCompilerType());
 221     CompilerType element_type;
 222     parent_type.IsVectorType(&element_type, nullptr);
 223     TargetSP target_sp(m_backend.GetTargetSP());
 224     m_child_type = ::GetCompilerTypeForFormat(
 225         m_parent_format, element_type,
 226         target_sp
 227             ? target_sp->GetScratchTypeSystemForLanguage(nullptr,
 228                                                          lldb::eLanguageTypeC)
 229             : nullptr);
 230     m_num_children = ::CalculateNumChildren(parent_type, m_child_type);
 231     m_item_format = GetItemFormatForFormat(m_parent_format, m_child_type);
 232     return false;
 233   }
 234
 235   bool MightHaveChildren() override { return true; }
 236
 237   size_t GetIndexOfChildWithName(const ConstString &name) override {
 238     const char *item_name = name.GetCString();
 239     uint32_t idx = ExtractIndexFromString(item_name);
 240     if (idx < UINT32_MAX && idx >= CalculateNumChildren())
 241       return UINT32_MAX;
 242     return idx;
 243   }
 244
 245 private:
 246   lldb::Format m_parent_format;
 247   lldb::Format m_item_format;
 248   CompilerType m_child_type;
 249   size_t m_num_children;
 250 };
 251
 252 } // namespace formatters
 253 } // namespace lldb_private
 254
 255 bool lldb_private::formatters::VectorTypeSummaryProvider(
 256     ValueObject &valobj, Stream &s, const TypeSummaryOptions &) {
 257   auto synthetic_children =
 258       VectorTypeSyntheticFrontEndCreator(nullptr, valobj.GetSP());
 259   if (!synthetic_children)
 260     return false;
 261
 262   synthetic_children->Update();
 263
 264   s.PutChar('(');
 265   bool first = true;
 266
 267   size_t idx = 0, len = synthetic_children->CalculateNumChildren();
 268
 269   for (; idx < len; idx++) {
 270     auto child_sp = synthetic_children->GetChildAtIndex(idx);
 271     if (!child_sp)
 272       continue;
 273     child_sp = child_sp->GetQualifiedRepresentationIfAvailable(
 274         lldb::eDynamicDontRunTarget, true);
 275
 276     const char *child_value = child_sp->GetValueAsCString();
 277     if (child_value && *child_value) {
 278       if (first) {
 279         s.Printf("%s", child_value);
 280         first = false;
 281       } else {
 282         s.Printf(", %s", child_value);
 283       }
 284     }
 285   }
 286
 287   s.PutChar(')');
 288
 289   return true;
 290 }
 291
 292 lldb_private::SyntheticChildrenFrontEnd *
 293 lldb_private::formatters::VectorTypeSyntheticFrontEndCreator(
 294     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
 295   if (!valobj_sp)
 296     return nullptr;
 297   return new VectorTypeSyntheticFrontEnd(valobj_sp);
 298 }