contrib/llvm/tools/lldb/source/Symbol/GoASTContext.cpp

   1 //===-- GoASTContext.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 #include <mutex>
  11 #include <utility>
  12 #include <vector>
  13
  14 #include "lldb/Core/Module.h"
  15 #include "lldb/Core/PluginManager.h"
  16 #include "lldb/Core/StreamFile.h"
  17 #include "lldb/Core/UniqueCStringMap.h"
  18 #include "lldb/Core/ValueObject.h"
  19 #include "lldb/DataFormatters/StringPrinter.h"
  20 #include "lldb/Symbol/CompilerType.h"
  21 #include "lldb/Symbol/GoASTContext.h"
  22 #include "lldb/Symbol/ObjectFile.h"
  23 #include "lldb/Symbol/SymbolFile.h"
  24 #include "lldb/Symbol/Type.h"
  25 #include "lldb/Target/ExecutionContext.h"
  26 #include "lldb/Target/Target.h"
  27
  28 #include "Plugins/ExpressionParser/Go/GoUserExpression.h"
  29 #include "Plugins/SymbolFile/DWARF/DWARFASTParserGo.h"
  30
  31 using namespace lldb;
  32
  33 namespace lldb_private {
  34 class GoArray;
  35 class GoFunction;
  36 class GoStruct;
  37
  38 class GoType {
  39 public:
  40   enum {
  41     KIND_BOOL = 1,
  42     KIND_INT = 2,
  43     KIND_INT8 = 3,
  44     KIND_INT16 = 4,
  45     KIND_INT32 = 5,
  46     KIND_INT64 = 6,
  47     KIND_UINT = 7,
  48     KIND_UINT8 = 8,
  49     KIND_UINT16 = 9,
  50     KIND_UINT32 = 10,
  51     KIND_UINT64 = 11,
  52     KIND_UINTPTR = 12,
  53     KIND_FLOAT32 = 13,
  54     KIND_FLOAT64 = 14,
  55     KIND_COMPLEX64 = 15,
  56     KIND_COMPLEX128 = 16,
  57     KIND_ARRAY = 17,
  58     KIND_CHAN = 18,
  59     KIND_FUNC = 19,
  60     KIND_INTERFACE = 20,
  61     KIND_MAP = 21,
  62     KIND_PTR = 22,
  63     KIND_SLICE = 23,
  64     KIND_STRING = 24,
  65     KIND_STRUCT = 25,
  66     KIND_UNSAFEPOINTER = 26,
  67     KIND_LLDB_VOID, // Extension for LLDB, not used by go runtime.
  68     KIND_MASK = (1 << 5) - 1,
  69     KIND_DIRECT_IFACE = 1 << 5
  70   };
  71   GoType(int kind, const ConstString &name)
  72       : m_kind(kind & KIND_MASK), m_name(name) {
  73     if (m_kind == KIND_FUNC)
  74       m_kind = KIND_FUNC;
  75   }
  76   virtual ~GoType() {}
  77
  78   int GetGoKind() const { return m_kind; }
  79   const ConstString &GetName() const { return m_name; }
  80   virtual CompilerType GetElementType() const { return CompilerType(); }
  81
  82   bool IsTypedef() const {
  83     switch (m_kind) {
  84     case KIND_CHAN:
  85     case KIND_MAP:
  86     case KIND_INTERFACE:
  87       return true;
  88     default:
  89       return false;
  90     }
  91   }
  92
  93   GoArray *GetArray();
  94   GoFunction *GetFunction();
  95   GoStruct *GetStruct();
  96
  97 private:
  98   int m_kind;
  99   ConstString m_name;
 100   GoType(const GoType &) = delete;
 101   const GoType &operator=(const GoType &) = delete;
 102 };
 103
 104 class GoElem : public GoType {
 105 public:
 106   GoElem(int kind, const ConstString &name, const CompilerType &elem)
 107       : GoType(kind, name), m_elem(elem) {}
 108   virtual CompilerType GetElementType() const { return m_elem; }
 109
 110 private:
 111   // TODO: should we store this differently?
 112   CompilerType m_elem;
 113
 114   GoElem(const GoElem &) = delete;
 115   const GoElem &operator=(const GoElem &) = delete;
 116 };
 117
 118 class GoArray : public GoElem {
 119 public:
 120   GoArray(const ConstString &name, uint64_t length, const CompilerType &elem)
 121       : GoElem(KIND_ARRAY, name, elem), m_length(length) {}
 122
 123   uint64_t GetLength() const { return m_length; }
 124
 125 private:
 126   uint64_t m_length;
 127   GoArray(const GoArray &) = delete;
 128   const GoArray &operator=(const GoArray &) = delete;
 129 };
 130
 131 class GoFunction : public GoType {
 132 public:
 133   GoFunction(const ConstString &name, bool is_variadic)
 134       : GoType(KIND_FUNC, name), m_is_variadic(is_variadic) {}
 135
 136   bool IsVariadic() const { return m_is_variadic; }
 137
 138 private:
 139   bool m_is_variadic;
 140   GoFunction(const GoFunction &) = delete;
 141   const GoFunction &operator=(const GoFunction &) = delete;
 142 };
 143
 144 class GoStruct : public GoType {
 145 public:
 146   struct Field {
 147     Field(const ConstString &name, const CompilerType &type, uint64_t offset)
 148         : m_name(name), m_type(type), m_byte_offset(offset) {}
 149     ConstString m_name;
 150     CompilerType m_type;
 151     uint64_t m_byte_offset;
 152   };
 153
 154   GoStruct(int kind, const ConstString &name, int64_t byte_size)
 155       : GoType(kind == 0 ? KIND_STRUCT : kind, name), m_is_complete(false),
 156         m_byte_size(byte_size) {}
 157
 158   uint32_t GetNumFields() const { return m_fields.size(); }
 159
 160   const Field *GetField(uint32_t i) const {
 161     if (i < m_fields.size())
 162       return &m_fields[i];
 163     return nullptr;
 164   }
 165
 166   void AddField(const ConstString &name, const CompilerType &type,
 167                 uint64_t offset) {
 168     m_fields.push_back(Field(name, type, offset));
 169   }
 170
 171   bool IsComplete() const { return m_is_complete; }
 172
 173   void SetComplete() { m_is_complete = true; }
 174
 175   int64_t GetByteSize() const { return m_byte_size; }
 176
 177 private:
 178   bool m_is_complete;
 179   int64_t m_byte_size;
 180   std::vector<Field> m_fields;
 181
 182   GoStruct(const GoStruct &) = delete;
 183   const GoStruct &operator=(const GoStruct &) = delete;
 184 };
 185
 186 GoArray *GoType::GetArray() {
 187   if (m_kind == KIND_ARRAY) {
 188     return static_cast<GoArray *>(this);
 189   }
 190   return nullptr;
 191 }
 192
 193 GoFunction *GoType::GetFunction() {
 194   if (m_kind == KIND_FUNC) {
 195     return static_cast<GoFunction *>(this);
 196   }
 197   return nullptr;
 198 }
 199
 200 GoStruct *GoType::GetStruct() {
 201   switch (m_kind) {
 202   case KIND_STRING:
 203   case KIND_STRUCT:
 204   case KIND_SLICE:
 205     return static_cast<GoStruct *>(this);
 206   }
 207   return nullptr;
 208 }
 209 } // namespace lldb_private
 210 using namespace lldb_private;
 211
 212 GoASTContext::GoASTContext()
 213     : TypeSystem(eKindGo), m_pointer_byte_size(0), m_int_byte_size(0),
 214       m_types(new TypeMap) {}
 215 GoASTContext::~GoASTContext() {}
 216
 217 //------------------------------------------------------------------
 218 // PluginInterface functions
 219 //------------------------------------------------------------------
 220
 221 ConstString GoASTContext::GetPluginNameStatic() { return ConstString("go"); }
 222
 223 ConstString GoASTContext::GetPluginName() {
 224   return GoASTContext::GetPluginNameStatic();
 225 }
 226
 227 uint32_t GoASTContext::GetPluginVersion() { return 1; }
 228
 229 lldb::TypeSystemSP GoASTContext::CreateInstance(lldb::LanguageType language,
 230                                                 Module *module,
 231                                                 Target *target) {
 232   if (language == eLanguageTypeGo) {
 233     ArchSpec arch;
 234     std::shared_ptr<GoASTContext> go_ast_sp;
 235     if (module) {
 236       arch = module->GetArchitecture();
 237       go_ast_sp = std::shared_ptr<GoASTContext>(new GoASTContext);
 238     } else if (target) {
 239       arch = target->GetArchitecture();
 240       go_ast_sp = std::shared_ptr<GoASTContextForExpr>(
 241           new GoASTContextForExpr(target->shared_from_this()));
 242     }
 243
 244     if (arch.IsValid()) {
 245       go_ast_sp->SetAddressByteSize(arch.GetAddressByteSize());
 246       return go_ast_sp;
 247     }
 248   }
 249   return lldb::TypeSystemSP();
 250 }
 251
 252 void GoASTContext::EnumerateSupportedLanguages(
 253     std::set<lldb::LanguageType> &languages_for_types,
 254     std::set<lldb::LanguageType> &languages_for_expressions) {
 255   static std::vector<lldb::LanguageType> s_supported_languages_for_types(
 256       {lldb::eLanguageTypeGo});
 257
 258   static std::vector<lldb::LanguageType> s_supported_languages_for_expressions(
 259       {});
 260
 261   languages_for_types.insert(s_supported_languages_for_types.begin(),
 262                              s_supported_languages_for_types.end());
 263   languages_for_expressions.insert(
 264       s_supported_languages_for_expressions.begin(),
 265       s_supported_languages_for_expressions.end());
 266 }
 267
 268 void GoASTContext::Initialize() {
 269   PluginManager::RegisterPlugin(GetPluginNameStatic(), "AST context plug-in",
 270                                 CreateInstance, EnumerateSupportedLanguages);
 271 }
 272
 273 void GoASTContext::Terminate() {
 274   PluginManager::UnregisterPlugin(CreateInstance);
 275 }
 276
 277 //----------------------------------------------------------------------
 278 // Tests
 279 //----------------------------------------------------------------------
 280
 281 bool GoASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
 282                                CompilerType *element_type, uint64_t *size,
 283                                bool *is_incomplete) {
 284   if (element_type)
 285     element_type->Clear();
 286   if (size)
 287     *size = 0;
 288   if (is_incomplete)
 289     *is_incomplete = false;
 290   GoArray *array = static_cast<GoType *>(type)->GetArray();
 291   if (array) {
 292     if (size)
 293       *size = array->GetLength();
 294     if (element_type)
 295       *element_type = array->GetElementType();
 296     return true;
 297   }
 298   return false;
 299 }
 300
 301 bool GoASTContext::IsVectorType(lldb::opaque_compiler_type_t type,
 302                                 CompilerType *element_type, uint64_t *size) {
 303   if (element_type)
 304     element_type->Clear();
 305   if (size)
 306     *size = 0;
 307   return false;
 308 }
 309
 310 bool GoASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) {
 311   int kind = static_cast<GoType *>(type)->GetGoKind();
 312   if (kind < GoType::KIND_ARRAY)
 313     return false;
 314   if (kind == GoType::KIND_PTR)
 315     return false;
 316   if (kind == GoType::KIND_CHAN)
 317     return false;
 318   if (kind == GoType::KIND_MAP)
 319     return false;
 320   if (kind == GoType::KIND_STRING)
 321     return false;
 322   if (kind == GoType::KIND_UNSAFEPOINTER)
 323     return false;
 324   return true;
 325 }
 326
 327 bool GoASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) {
 328   return false;
 329 }
 330
 331 bool GoASTContext::IsCharType(lldb::opaque_compiler_type_t type) {
 332   // Go's DWARF doesn't distinguish between rune and int32.
 333   return false;
 334 }
 335
 336 bool GoASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) {
 337   if (!type)
 338     return false;
 339   GoType *t = static_cast<GoType *>(type);
 340   if (GoStruct *s = t->GetStruct())
 341     return s->IsComplete();
 342   if (t->IsTypedef() || t->GetGoKind() == GoType::KIND_PTR)
 343     return t->GetElementType().IsCompleteType();
 344   return true;
 345 }
 346
 347 bool GoASTContext::IsConst(lldb::opaque_compiler_type_t type) { return false; }
 348
 349 bool GoASTContext::IsCStringType(lldb::opaque_compiler_type_t type,
 350                                  uint32_t &length) {
 351   return false;
 352 }
 353
 354 bool GoASTContext::IsDefined(lldb::opaque_compiler_type_t type) {
 355   return type != nullptr;
 356 }
 357
 358 bool GoASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type,
 359                                        uint32_t &count, bool &is_complex) {
 360   int kind = static_cast<GoType *>(type)->GetGoKind();
 361   if (kind >= GoType::KIND_FLOAT32 && kind <= GoType::KIND_COMPLEX128) {
 362     if (kind >= GoType::KIND_COMPLEX64) {
 363       is_complex = true;
 364       count = 2;
 365     } else {
 366       is_complex = false;
 367       count = 1;
 368     }
 369     return true;
 370   }
 371   count = 0;
 372   is_complex = false;
 373   return false;
 374 }
 375
 376 bool GoASTContext::IsFunctionType(lldb::opaque_compiler_type_t type,
 377                                   bool *is_variadic_ptr) {
 378   GoFunction *func = static_cast<GoType *>(type)->GetFunction();
 379   if (func) {
 380     if (is_variadic_ptr)
 381       *is_variadic_ptr = func->IsVariadic();
 382     return true;
 383   }
 384   if (is_variadic_ptr)
 385     *is_variadic_ptr = false;
 386   return false;
 387 }
 388
 389 uint32_t GoASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
 390                                               CompilerType *base_type_ptr) {
 391   return false;
 392 }
 393
 394 size_t
 395 GoASTContext::GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) {
 396   return 0;
 397 }
 398
 399 CompilerType
 400 GoASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
 401                                          const size_t index) {
 402   return CompilerType();
 403 }
 404
 405 bool GoASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
 406   return IsFunctionType(type);
 407 }
 408
 409 bool GoASTContext::IsBlockPointerType(lldb::opaque_compiler_type_t type,
 410                                       CompilerType *function_pointer_type_ptr) {
 411   return false;
 412 }
 413
 414 bool GoASTContext::IsIntegerType(lldb::opaque_compiler_type_t type,
 415                                  bool &is_signed) {
 416   is_signed = false;
 417   // TODO: Is bool an integer?
 418   if (type) {
 419     int kind = static_cast<GoType *>(type)->GetGoKind();
 420     if (kind <= GoType::KIND_UINTPTR) {
 421       is_signed = (kind != GoType::KIND_BOOL) & (kind <= GoType::KIND_INT64);
 422       return true;
 423     }
 424   }
 425   return false;
 426 }
 427
 428 bool GoASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
 429   return false;
 430 }
 431
 432 bool GoASTContext::IsPossibleDynamicType(
 433     lldb::opaque_compiler_type_t type,
 434     CompilerType *target_type, // Can pass NULL
 435     bool check_cplusplus, bool check_objc) {
 436   if (target_type)
 437     target_type->Clear();
 438   if (type)
 439     return static_cast<GoType *>(type)->GetGoKind() == GoType::KIND_INTERFACE;
 440   return false;
 441 }
 442
 443 bool GoASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) {
 444   return false;
 445 }
 446
 447 bool GoASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
 448                                  CompilerType *pointee_type) {
 449   if (!type)
 450     return false;
 451   GoType *t = static_cast<GoType *>(type);
 452   if (pointee_type) {
 453     *pointee_type = t->GetElementType();
 454   }
 455   switch (t->GetGoKind()) {
 456   case GoType::KIND_PTR:
 457   case GoType::KIND_UNSAFEPOINTER:
 458   case GoType::KIND_CHAN:
 459   case GoType::KIND_MAP:
 460     // TODO: is function a pointer?
 461     return true;
 462   default:
 463     return false;
 464   }
 465 }
 466
 467 bool GoASTContext::IsPointerOrReferenceType(lldb::opaque_compiler_type_t type,
 468                                             CompilerType *pointee_type) {
 469   return IsPointerType(type, pointee_type);
 470 }
 471
 472 bool GoASTContext::IsReferenceType(lldb::opaque_compiler_type_t type,
 473                                    CompilerType *pointee_type,
 474                                    bool *is_rvalue) {
 475   return false;
 476 }
 477
 478 bool GoASTContext::IsScalarType(lldb::opaque_compiler_type_t type) {
 479   return !IsAggregateType(type);
 480 }
 481
 482 bool GoASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) {
 483   if (type)
 484     return static_cast<GoType *>(type)->IsTypedef();
 485   return false;
 486 }
 487
 488 bool GoASTContext::IsVoidType(lldb::opaque_compiler_type_t type) {
 489   if (!type)
 490     return false;
 491   return static_cast<GoType *>(type)->GetGoKind() == GoType::KIND_LLDB_VOID;
 492 }
 493
 494 bool GoASTContext::SupportsLanguage(lldb::LanguageType language) {
 495   return language == eLanguageTypeGo;
 496 }
 497
 498 //----------------------------------------------------------------------
 499 // Type Completion
 500 //----------------------------------------------------------------------
 501
 502 bool GoASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) {
 503   if (!type)
 504     return false;
 505   GoType *t = static_cast<GoType *>(type);
 506   if (t->IsTypedef() || t->GetGoKind() == GoType::KIND_PTR || t->GetArray())
 507     return t->GetElementType().GetCompleteType();
 508   if (GoStruct *s = t->GetStruct()) {
 509     if (s->IsComplete())
 510       return true;
 511     CompilerType compiler_type(this, s);
 512     SymbolFile *symbols = GetSymbolFile();
 513     return symbols && symbols->CompleteType(compiler_type);
 514   }
 515   return true;
 516 }
 517
 518 //----------------------------------------------------------------------
 519 // AST related queries
 520 //----------------------------------------------------------------------
 521
 522 uint32_t GoASTContext::GetPointerByteSize() { return m_pointer_byte_size; }
 523
 524 //----------------------------------------------------------------------
 525 // Accessors
 526 //----------------------------------------------------------------------
 527
 528 ConstString GoASTContext::GetTypeName(lldb::opaque_compiler_type_t type) {
 529   if (type)
 530     return static_cast<GoType *>(type)->GetName();
 531   return ConstString();
 532 }
 533
 534 uint32_t
 535 GoASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
 536                           CompilerType *pointee_or_element_compiler_type) {
 537   if (pointee_or_element_compiler_type)
 538     pointee_or_element_compiler_type->Clear();
 539   if (!type)
 540     return 0;
 541   GoType *t = static_cast<GoType *>(type);
 542   if (pointee_or_element_compiler_type)
 543     *pointee_or_element_compiler_type = t->GetElementType();
 544   int kind = t->GetGoKind();
 545   if (kind == GoType::KIND_ARRAY)
 546     return eTypeHasChildren | eTypeIsArray;
 547   if (kind < GoType::KIND_ARRAY) {
 548     uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
 549     if (kind < GoType::KIND_FLOAT32) {
 550       builtin_type_flags |= eTypeIsInteger | eTypeIsScalar;
 551       if (kind >= GoType::KIND_INT && kind <= GoType::KIND_INT64)
 552         builtin_type_flags |= eTypeIsSigned;
 553     } else {
 554       builtin_type_flags |= eTypeIsFloat;
 555       if (kind < GoType::KIND_COMPLEX64)
 556         builtin_type_flags |= eTypeIsComplex;
 557       else
 558         builtin_type_flags |= eTypeIsScalar;
 559     }
 560     return builtin_type_flags;
 561   }
 562   if (kind == GoType::KIND_STRING)
 563     return eTypeHasValue | eTypeIsBuiltIn;
 564   if (kind == GoType::KIND_FUNC)
 565     return eTypeIsFuncPrototype | eTypeHasValue;
 566   if (IsPointerType(type))
 567     return eTypeIsPointer | eTypeHasValue | eTypeHasChildren;
 568   if (kind == GoType::KIND_LLDB_VOID)
 569     return 0;
 570   return eTypeHasChildren | eTypeIsStructUnion;
 571 }
 572
 573 lldb::TypeClass GoASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
 574   if (!type)
 575     return eTypeClassInvalid;
 576   int kind = static_cast<GoType *>(type)->GetGoKind();
 577   if (kind == GoType::KIND_FUNC)
 578     return eTypeClassFunction;
 579   if (IsPointerType(type))
 580     return eTypeClassPointer;
 581   if (kind < GoType::KIND_COMPLEX64)
 582     return eTypeClassBuiltin;
 583   if (kind <= GoType::KIND_COMPLEX128)
 584     return eTypeClassComplexFloat;
 585   if (kind == GoType::KIND_LLDB_VOID)
 586     return eTypeClassInvalid;
 587   return eTypeClassStruct;
 588 }
 589
 590 lldb::BasicType
 591 GoASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
 592   ConstString name = GetTypeName(type);
 593   if (name) {
 594     typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
 595     static TypeNameToBasicTypeMap g_type_map;
 596     static std::once_flag g_once_flag;
 597     std::call_once(g_once_flag, []() {
 598       // "void"
 599       g_type_map.Append(ConstString("void").GetStringRef(), eBasicTypeVoid);
 600       // "int"
 601       g_type_map.Append(ConstString("int").GetStringRef(), eBasicTypeInt);
 602       g_type_map.Append(ConstString("uint").GetStringRef(),
 603                         eBasicTypeUnsignedInt);
 604
 605       // Miscellaneous
 606       g_type_map.Append(ConstString("bool").GetStringRef(), eBasicTypeBool);
 607
 608       // Others. Should these map to C types?
 609       g_type_map.Append(ConstString("byte").GetStringRef(), eBasicTypeOther);
 610       g_type_map.Append(ConstString("uint8").GetStringRef(), eBasicTypeOther);
 611       g_type_map.Append(ConstString("uint16").GetStringRef(), eBasicTypeOther);
 612       g_type_map.Append(ConstString("uint32").GetStringRef(), eBasicTypeOther);
 613       g_type_map.Append(ConstString("uint64").GetStringRef(), eBasicTypeOther);
 614       g_type_map.Append(ConstString("int8").GetStringRef(), eBasicTypeOther);
 615       g_type_map.Append(ConstString("int16").GetStringRef(), eBasicTypeOther);
 616       g_type_map.Append(ConstString("int32").GetStringRef(), eBasicTypeOther);
 617       g_type_map.Append(ConstString("int64").GetStringRef(), eBasicTypeOther);
 618       g_type_map.Append(ConstString("float32").GetStringRef(), eBasicTypeOther);
 619       g_type_map.Append(ConstString("float64").GetStringRef(), eBasicTypeOther);
 620       g_type_map.Append(ConstString("uintptr").GetStringRef(), eBasicTypeOther);
 621
 622       g_type_map.Sort();
 623     });
 624
 625     return g_type_map.Find(name.GetStringRef(), eBasicTypeInvalid);
 626   }
 627   return eBasicTypeInvalid;
 628 }
 629
 630 lldb::LanguageType
 631 GoASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
 632   return lldb::eLanguageTypeGo;
 633 }
 634
 635 unsigned GoASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
 636   return 0;
 637 }
 638
 639 //----------------------------------------------------------------------
 640 // Creating related types
 641 //----------------------------------------------------------------------
 642
 643 CompilerType
 644 GoASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type,
 645                                   uint64_t *stride) {
 646   GoArray *array = static_cast<GoType *>(type)->GetArray();
 647   if (array) {
 648     if (stride) {
 649       *stride = array->GetElementType().GetByteSize(nullptr);
 650     }
 651     return array->GetElementType();
 652   }
 653   return CompilerType();
 654 }
 655
 656 CompilerType GoASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) {
 657   GoType *t = static_cast<GoType *>(type);
 658   if (t->IsTypedef())
 659     return t->GetElementType();
 660   return CompilerType(this, type);
 661 }
 662
 663 CompilerType
 664 GoASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
 665   return CompilerType(this, type);
 666 }
 667
 668 // Returns -1 if this isn't a function of if the function doesn't have a
 669 // prototype
 670 // Returns a value >= 0 if there is a prototype.
 671 int GoASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) {
 672   return GetNumberOfFunctionArguments(type);
 673 }
 674
 675 CompilerType
 676 GoASTContext::GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type,
 677                                              size_t idx) {
 678   return GetFunctionArgumentAtIndex(type, idx);
 679 }
 680
 681 CompilerType
 682 GoASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
 683   CompilerType result;
 684   if (type) {
 685     GoType *t = static_cast<GoType *>(type);
 686     if (t->GetGoKind() == GoType::KIND_FUNC)
 687       result = t->GetElementType();
 688   }
 689   return result;
 690 }
 691
 692 size_t GoASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
 693   return 0;
 694 }
 695
 696 TypeMemberFunctionImpl
 697 GoASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
 698                                        size_t idx) {
 699   return TypeMemberFunctionImpl();
 700 }
 701
 702 CompilerType
 703 GoASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
 704   return CompilerType(this, type);
 705 }
 706
 707 CompilerType GoASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) {
 708   if (!type)
 709     return CompilerType();
 710   return static_cast<GoType *>(type)->GetElementType();
 711 }
 712
 713 CompilerType GoASTContext::GetPointerType(lldb::opaque_compiler_type_t type) {
 714   if (!type)
 715     return CompilerType();
 716   ConstString type_name = GetTypeName(type);
 717   ConstString pointer_name(std::string("*") + type_name.GetCString());
 718   GoType *pointer = (*m_types)[pointer_name].get();
 719   if (pointer == nullptr) {
 720     pointer =
 721         new GoElem(GoType::KIND_PTR, pointer_name, CompilerType(this, type));
 722     (*m_types)[pointer_name].reset(pointer);
 723   }
 724   return CompilerType(this, pointer);
 725 }
 726
 727 // If the current object represents a typedef type, get the underlying type
 728 CompilerType GoASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) {
 729   if (IsTypedefType(type))
 730     return static_cast<GoType *>(type)->GetElementType();
 731   return CompilerType();
 732 }
 733
 734 //----------------------------------------------------------------------
 735 // Create related types using the current type's AST
 736 //----------------------------------------------------------------------
 737 CompilerType GoASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
 738   return CompilerType();
 739 }
 740
 741 CompilerType
 742 GoASTContext::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
 743                                                   size_t bit_size) {
 744   return CompilerType();
 745 }
 746
 747 //----------------------------------------------------------------------
 748 // Exploring the type
 749 //----------------------------------------------------------------------
 750
 751 uint64_t GoASTContext::GetBitSize(lldb::opaque_compiler_type_t type,
 752                                   ExecutionContextScope *exe_scope) {
 753   if (!type)
 754     return 0;
 755   if (!GetCompleteType(type))
 756     return 0;
 757   GoType *t = static_cast<GoType *>(type);
 758   GoArray *array = nullptr;
 759   switch (t->GetGoKind()) {
 760   case GoType::KIND_BOOL:
 761   case GoType::KIND_INT8:
 762   case GoType::KIND_UINT8:
 763     return 8;
 764   case GoType::KIND_INT16:
 765   case GoType::KIND_UINT16:
 766     return 16;
 767   case GoType::KIND_INT32:
 768   case GoType::KIND_UINT32:
 769   case GoType::KIND_FLOAT32:
 770     return 32;
 771   case GoType::KIND_INT64:
 772   case GoType::KIND_UINT64:
 773   case GoType::KIND_FLOAT64:
 774   case GoType::KIND_COMPLEX64:
 775     return 64;
 776   case GoType::KIND_COMPLEX128:
 777     return 128;
 778   case GoType::KIND_INT:
 779   case GoType::KIND_UINT:
 780     return m_int_byte_size * 8;
 781   case GoType::KIND_UINTPTR:
 782   case GoType::KIND_FUNC: // I assume this is a pointer?
 783   case GoType::KIND_CHAN:
 784   case GoType::KIND_PTR:
 785   case GoType::KIND_UNSAFEPOINTER:
 786   case GoType::KIND_MAP:
 787     return m_pointer_byte_size * 8;
 788   case GoType::KIND_ARRAY:
 789     array = t->GetArray();
 790     return array->GetLength() * array->GetElementType().GetBitSize(exe_scope);
 791   case GoType::KIND_INTERFACE:
 792     return t->GetElementType().GetBitSize(exe_scope);
 793   case GoType::KIND_SLICE:
 794   case GoType::KIND_STRING:
 795   case GoType::KIND_STRUCT:
 796     return t->GetStruct()->GetByteSize() * 8;
 797   default:
 798     assert(false);
 799   }
 800   return 0;
 801 }
 802
 803 lldb::Encoding GoASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
 804                                          uint64_t &count) {
 805   count = 1;
 806   bool is_signed;
 807   if (IsIntegerType(type, is_signed))
 808     return is_signed ? lldb::eEncodingSint : eEncodingUint;
 809   bool is_complex;
 810   uint32_t complex_count;
 811   if (IsFloatingPointType(type, complex_count, is_complex)) {
 812     count = complex_count;
 813     return eEncodingIEEE754;
 814   }
 815   if (IsPointerType(type))
 816     return eEncodingUint;
 817   return eEncodingInvalid;
 818 }
 819
 820 lldb::Format GoASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
 821   if (!type)
 822     return eFormatDefault;
 823   switch (static_cast<GoType *>(type)->GetGoKind()) {
 824   case GoType::KIND_BOOL:
 825     return eFormatBoolean;
 826   case GoType::KIND_INT:
 827   case GoType::KIND_INT8:
 828   case GoType::KIND_INT16:
 829   case GoType::KIND_INT32:
 830   case GoType::KIND_INT64:
 831     return eFormatDecimal;
 832   case GoType::KIND_UINT:
 833   case GoType::KIND_UINT8:
 834   case GoType::KIND_UINT16:
 835   case GoType::KIND_UINT32:
 836   case GoType::KIND_UINT64:
 837     return eFormatUnsigned;
 838   case GoType::KIND_FLOAT32:
 839   case GoType::KIND_FLOAT64:
 840     return eFormatFloat;
 841   case GoType::KIND_COMPLEX64:
 842   case GoType::KIND_COMPLEX128:
 843     return eFormatComplexFloat;
 844   case GoType::KIND_UINTPTR:
 845   case GoType::KIND_CHAN:
 846   case GoType::KIND_PTR:
 847   case GoType::KIND_MAP:
 848   case GoType::KIND_UNSAFEPOINTER:
 849     return eFormatHex;
 850   case GoType::KIND_STRING:
 851     return eFormatCString;
 852   case GoType::KIND_ARRAY:
 853   case GoType::KIND_INTERFACE:
 854   case GoType::KIND_SLICE:
 855   case GoType::KIND_STRUCT:
 856   default:
 857     // Don't know how to display this.
 858     return eFormatBytes;
 859   }
 860 }
 861
 862 size_t GoASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) {
 863   return 0;
 864 }
 865
 866 uint32_t GoASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
 867                                       bool omit_empty_base_classes) {
 868   if (!type || !GetCompleteType(type))
 869     return 0;
 870   GoType *t = static_cast<GoType *>(type);
 871   if (t->GetGoKind() == GoType::KIND_PTR) {
 872     CompilerType elem = t->GetElementType();
 873     if (elem.IsAggregateType())
 874       return elem.GetNumChildren(omit_empty_base_classes);
 875     return 1;
 876   } else if (GoArray *array = t->GetArray()) {
 877     return array->GetLength();
 878   } else if (t->IsTypedef()) {
 879     return t->GetElementType().GetNumChildren(omit_empty_base_classes);
 880   }
 881
 882   return GetNumFields(type);
 883 }
 884
 885 uint32_t GoASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
 886   if (!type || !GetCompleteType(type))
 887     return 0;
 888   GoType *t = static_cast<GoType *>(type);
 889   if (t->IsTypedef())
 890     return t->GetElementType().GetNumFields();
 891   GoStruct *s = t->GetStruct();
 892   if (s)
 893     return s->GetNumFields();
 894   return 0;
 895 }
 896
 897 CompilerType GoASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
 898                                            size_t idx, std::string &name,
 899                                            uint64_t *bit_offset_ptr,
 900                                            uint32_t *bitfield_bit_size_ptr,
 901                                            bool *is_bitfield_ptr) {
 902   if (bit_offset_ptr)
 903     *bit_offset_ptr = 0;
 904   if (bitfield_bit_size_ptr)
 905     *bitfield_bit_size_ptr = 0;
 906   if (is_bitfield_ptr)
 907     *is_bitfield_ptr = false;
 908
 909   if (!type || !GetCompleteType(type))
 910     return CompilerType();
 911
 912   GoType *t = static_cast<GoType *>(type);
 913   if (t->IsTypedef())
 914     return t->GetElementType().GetFieldAtIndex(
 915         idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr);
 916
 917   GoStruct *s = t->GetStruct();
 918   if (s) {
 919     const auto *field = s->GetField(idx);
 920     if (field) {
 921       name = field->m_name.GetStringRef();
 922       if (bit_offset_ptr)
 923         *bit_offset_ptr = field->m_byte_offset * 8;
 924       return field->m_type;
 925     }
 926   }
 927   return CompilerType();
 928 }
 929
 930 CompilerType GoASTContext::GetChildCompilerTypeAtIndex(
 931     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
 932     bool transparent_pointers, bool omit_empty_base_classes,
 933     bool ignore_array_bounds, std::string &child_name,
 934     uint32_t &child_byte_size, int32_t &child_byte_offset,
 935     uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
 936     bool &child_is_base_class, bool &child_is_deref_of_parent,
 937     ValueObject *valobj, uint64_t &language_flags) {
 938   child_name.clear();
 939   child_byte_size = 0;
 940   child_byte_offset = 0;
 941   child_bitfield_bit_size = 0;
 942   child_bitfield_bit_offset = 0;
 943   child_is_base_class = false;
 944   child_is_deref_of_parent = false;
 945   language_flags = 0;
 946
 947   if (!type || !GetCompleteType(type))
 948     return CompilerType();
 949
 950   GoType *t = static_cast<GoType *>(type);
 951   if (t->GetStruct()) {
 952     uint64_t bit_offset;
 953     CompilerType ret =
 954         GetFieldAtIndex(type, idx, child_name, &bit_offset, nullptr, nullptr);
 955     child_byte_size = ret.GetByteSize(
 956         exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
 957     child_byte_offset = bit_offset / 8;
 958     return ret;
 959   } else if (t->GetGoKind() == GoType::KIND_PTR) {
 960     CompilerType pointee = t->GetElementType();
 961     if (!pointee.IsValid() || pointee.IsVoidType())
 962       return CompilerType();
 963     if (transparent_pointers && pointee.IsAggregateType()) {
 964       bool tmp_child_is_deref_of_parent = false;
 965       return pointee.GetChildCompilerTypeAtIndex(
 966           exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
 967           ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
 968           child_bitfield_bit_size, child_bitfield_bit_offset,
 969           child_is_base_class, tmp_child_is_deref_of_parent, valobj,
 970           language_flags);
 971     } else {
 972       child_is_deref_of_parent = true;
 973       const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
 974       if (parent_name) {
 975         child_name.assign(1, '*');
 976         child_name += parent_name;
 977       }
 978
 979       // We have a pointer to an simple type
 980       if (idx == 0 && pointee.GetCompleteType()) {
 981         child_byte_size = pointee.GetByteSize(
 982             exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
 983         child_byte_offset = 0;
 984         return pointee;
 985       }
 986     }
 987   } else if (GoArray *a = t->GetArray()) {
 988     if (ignore_array_bounds || idx < a->GetLength()) {
 989       CompilerType element_type = a->GetElementType();
 990       if (element_type.GetCompleteType()) {
 991         char element_name[64];
 992         ::snprintf(element_name, sizeof(element_name), "[%zu]", idx);
 993         child_name.assign(element_name);
 994         child_byte_size = element_type.GetByteSize(
 995             exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
 996         child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
 997         return element_type;
 998       }
 999     }
1000   } else if (t->IsTypedef()) {
1001     return t->GetElementType().GetChildCompilerTypeAtIndex(
1002         exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
1003         ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
1004         child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
1005         child_is_deref_of_parent, valobj, language_flags);
1006   }
1007   return CompilerType();
1008 }
1009
1010 // Lookup a child given a name. This function will match base class names
1011 // and member member names in "clang_type" only, not descendants.
1012 uint32_t
1013 GoASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
1014                                       const char *name,
1015                                       bool omit_empty_base_classes) {
1016   if (!type || !GetCompleteType(type))
1017     return UINT_MAX;
1018
1019   GoType *t = static_cast<GoType *>(type);
1020   GoStruct *s = t->GetStruct();
1021   if (s) {
1022     for (uint32_t i = 0; i < s->GetNumFields(); ++i) {
1023       const GoStruct::Field *f = s->GetField(i);
1024       if (f->m_name.GetStringRef() == name)
1025         return i;
1026     }
1027   } else if (t->GetGoKind() == GoType::KIND_PTR || t->IsTypedef()) {
1028     return t->GetElementType().GetIndexOfChildWithName(name,
1029                                                        omit_empty_base_classes);
1030   }
1031   return UINT_MAX;
1032 }
1033
1034 // Lookup a child member given a name. This function will match member names
1035 // only and will descend into "clang_type" children in search for the first
1036 // member in this class, or any base class that matches "name".
1037 // TODO: Return all matches for a given name by returning a
1038 // vector<vector<uint32_t>>
1039 // so we catch all names that match a given child name, not just the first.
1040 size_t GoASTContext::GetIndexOfChildMemberWithName(
1041     lldb::opaque_compiler_type_t type, const char *name,
1042     bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
1043   uint32_t index = GetIndexOfChildWithName(type, name, omit_empty_base_classes);
1044   if (index == UINT_MAX)
1045     return 0;
1046   child_indexes.push_back(index);
1047   return 1;
1048 }
1049
1050 // Converts "s" to a floating point value and place resulting floating
1051 // point bytes in the "dst" buffer.
1052 size_t
1053 GoASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
1054                                         const char *s, uint8_t *dst,
1055                                         size_t dst_size) {
1056   assert(false);
1057   return 0;
1058 }
1059 //----------------------------------------------------------------------
1060 // Dumping types
1061 //----------------------------------------------------------------------
1062 #define DEPTH_INCREMENT 2
1063
1064 void GoASTContext::DumpValue(lldb::opaque_compiler_type_t type,
1065                              ExecutionContext *exe_ctx, Stream *s,
1066                              lldb::Format format, const DataExtractor &data,
1067                              lldb::offset_t data_byte_offset,
1068                              size_t data_byte_size, uint32_t bitfield_bit_size,
1069                              uint32_t bitfield_bit_offset, bool show_types,
1070                              bool show_summary, bool verbose, uint32_t depth) {
1071   if (IsTypedefType(type))
1072     type = GetTypedefedType(type).GetOpaqueQualType();
1073   if (!type)
1074     return;
1075   GoType *t = static_cast<GoType *>(type);
1076
1077   if (GoStruct *st = t->GetStruct()) {
1078     if (GetCompleteType(type)) {
1079       uint32_t field_idx = 0;
1080       for (auto *field = st->GetField(field_idx); field != nullptr;
1081            field_idx++) {
1082         // Print the starting squiggly bracket (if this is the
1083         // first member) or comma (for member 2 and beyond) for
1084         // the struct/union/class member.
1085         if (field_idx == 0)
1086           s->PutChar('{');
1087         else
1088           s->PutChar(',');
1089
1090         // Indent
1091         s->Printf("\n%*s", depth + DEPTH_INCREMENT, "");
1092
1093         // Print the member type if requested
1094         if (show_types) {
1095           ConstString field_type_name = field->m_type.GetTypeName();
1096           s->Printf("(%s) ", field_type_name.AsCString());
1097         }
1098         // Print the member name and equal sign
1099         s->Printf("%s = ", field->m_name.AsCString());
1100
1101         // Dump the value of the member
1102         CompilerType field_type = field->m_type;
1103         field_type.DumpValue(
1104             exe_ctx,
1105             s, // Stream to dump to
1106             field_type
1107                 .GetFormat(), // The format with which to display the member
1108             data,             // Data buffer containing all bytes for this type
1109             data_byte_offset + field->m_byte_offset, // Offset into "data" where
1110                                                      // to grab value from
1111             field->m_type.GetByteSize(
1112                 exe_ctx->GetBestExecutionContextScope()), // Size of this type
1113                                                           // in bytes
1114             0,                                            // Bitfield bit size
1115             0,                                            // Bitfield bit offset
1116             show_types,   // Boolean indicating if we should show the variable
1117                           // types
1118             show_summary, // Boolean indicating if we should show a summary for
1119                           // the current type
1120             verbose,      // Verbose output?
1121             depth + DEPTH_INCREMENT); // Scope depth for any types that have
1122                                       // children
1123       }
1124
1125       // Indent the trailing squiggly bracket
1126       if (field_idx > 0)
1127         s->Printf("\n%*s}", depth, "");
1128     }
1129   }
1130
1131   if (GoArray *a = t->GetArray()) {
1132     CompilerType element_clang_type = a->GetElementType();
1133     lldb::Format element_format = element_clang_type.GetFormat();
1134     uint32_t element_byte_size =
1135         element_clang_type.GetByteSize(exe_ctx->GetBestExecutionContextScope());
1136
1137     uint64_t element_idx;
1138     for (element_idx = 0; element_idx < a->GetLength(); ++element_idx) {
1139       // Print the starting squiggly bracket (if this is the
1140       // first member) or comman (for member 2 and beyong) for
1141       // the struct/union/class member.
1142       if (element_idx == 0)
1143         s->PutChar('{');
1144       else
1145         s->PutChar(',');
1146
1147       // Indent and print the index
1148       s->Printf("\n%*s[%" PRIu64 "] ", depth + DEPTH_INCREMENT, "",
1149                 element_idx);
1150
1151       // Figure out the field offset within the current struct/union/class type
1152       uint64_t element_offset = element_idx * element_byte_size;
1153
1154       // Dump the value of the member
1155       element_clang_type.DumpValue(
1156           exe_ctx,
1157           s,              // Stream to dump to
1158           element_format, // The format with which to display the element
1159           data,           // Data buffer containing all bytes for this type
1160           data_byte_offset +
1161               element_offset, // Offset into "data" where to grab value from
1162           element_byte_size,  // Size of this type in bytes
1163           0,                  // Bitfield bit size
1164           0,                  // Bitfield bit offset
1165           show_types, // Boolean indicating if we should show the variable types
1166           show_summary, // Boolean indicating if we should show a summary for
1167                         // the current type
1168           verbose,      // Verbose output?
1169           depth +
1170               DEPTH_INCREMENT); // Scope depth for any types that have children
1171     }
1172
1173     // Indent the trailing squiggly bracket
1174     if (element_idx > 0)
1175       s->Printf("\n%*s}", depth, "");
1176   }
1177
1178   if (show_summary)
1179     DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
1180 }
1181
1182 bool GoASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
1183                                  lldb::Format format, const DataExtractor &data,
1184                                  lldb::offset_t byte_offset, size_t byte_size,
1185                                  uint32_t bitfield_bit_size,
1186                                  uint32_t bitfield_bit_offset,
1187                                  ExecutionContextScope *exe_scope) {
1188   if (!type)
1189     return false;
1190   if (IsAggregateType(type)) {
1191     return false;
1192   } else {
1193     GoType *t = static_cast<GoType *>(type);
1194     if (t->IsTypedef()) {
1195       CompilerType typedef_compiler_type = t->GetElementType();
1196       if (format == eFormatDefault)
1197         format = typedef_compiler_type.GetFormat();
1198       uint64_t typedef_byte_size = typedef_compiler_type.GetByteSize(exe_scope);
1199
1200       return typedef_compiler_type.DumpTypeValue(
1201           s,
1202           format,            // The format with which to display the element
1203           data,              // Data buffer containing all bytes for this type
1204           byte_offset,       // Offset into "data" where to grab value from
1205           typedef_byte_size, // Size of this type in bytes
1206           bitfield_bit_size, // Size in bits of a bitfield value, if zero don't
1207                              // treat as a bitfield
1208           bitfield_bit_offset, // Offset in bits of a bitfield value if
1209                                // bitfield_bit_size != 0
1210           exe_scope);
1211     }
1212
1213     uint32_t item_count = 1;
1214     // A few formats, we might need to modify our size and count for depending
1215     // on how we are trying to display the value...
1216     switch (format) {
1217     default:
1218     case eFormatBoolean:
1219     case eFormatBinary:
1220     case eFormatComplex:
1221     case eFormatCString: // NULL terminated C strings
1222     case eFormatDecimal:
1223     case eFormatEnum:
1224     case eFormatHex:
1225     case eFormatHexUppercase:
1226     case eFormatFloat:
1227     case eFormatOctal:
1228     case eFormatOSType:
1229     case eFormatUnsigned:
1230     case eFormatPointer:
1231     case eFormatVectorOfChar:
1232     case eFormatVectorOfSInt8:
1233     case eFormatVectorOfUInt8:
1234     case eFormatVectorOfSInt16:
1235     case eFormatVectorOfUInt16:
1236     case eFormatVectorOfSInt32:
1237     case eFormatVectorOfUInt32:
1238     case eFormatVectorOfSInt64:
1239     case eFormatVectorOfUInt64:
1240     case eFormatVectorOfFloat32:
1241     case eFormatVectorOfFloat64:
1242     case eFormatVectorOfUInt128:
1243       break;
1244
1245     case eFormatChar:
1246     case eFormatCharPrintable:
1247     case eFormatCharArray:
1248     case eFormatBytes:
1249     case eFormatBytesWithASCII:
1250       item_count = byte_size;
1251       byte_size = 1;
1252       break;
1253
1254     case eFormatUnicode16:
1255       item_count = byte_size / 2;
1256       byte_size = 2;
1257       break;
1258
1259     case eFormatUnicode32:
1260       item_count = byte_size / 4;
1261       byte_size = 4;
1262       break;
1263     }
1264     return data.Dump(s, byte_offset, format, byte_size, item_count, UINT32_MAX,
1265                      LLDB_INVALID_ADDRESS, bitfield_bit_size,
1266                      bitfield_bit_offset, exe_scope);
1267   }
1268   return 0;
1269 }
1270
1271 void GoASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
1272                                ExecutionContext *exe_ctx, Stream *s,
1273                                const DataExtractor &data,
1274                                lldb::offset_t data_offset,
1275                                size_t data_byte_size) {
1276   if (type && GoType::KIND_STRING == static_cast<GoType *>(type)->GetGoKind()) {
1277     // TODO(ribrdb): read length and data
1278   }
1279 }
1280
1281 void GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) {
1282   // Dump to stdout
1283   StreamFile s(stdout, false);
1284   DumpTypeDescription(type, &s);
1285 }
1286
1287 void GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type,
1288                                        Stream *s) {
1289   if (!type)
1290     return;
1291   ConstString name = GetTypeName(type);
1292   GoType *t = static_cast<GoType *>(type);
1293
1294   if (GoStruct *st = t->GetStruct()) {
1295     if (GetCompleteType(type)) {
1296       if (NULL == strchr(name.AsCString(), '{'))
1297         s->Printf("type %s ", name.AsCString());
1298       s->PutCString("struct {");
1299       if (st->GetNumFields() == 0) {
1300         s->PutChar('}');
1301         return;
1302       }
1303       s->IndentMore();
1304       uint32_t field_idx = 0;
1305       for (auto *field = st->GetField(field_idx); field != nullptr;
1306            field_idx++) {
1307         s->PutChar('\n');
1308         s->Indent();
1309         s->Printf("%s %s", field->m_name.AsCString(),
1310                   field->m_type.GetTypeName().AsCString());
1311       }
1312       s->IndentLess();
1313       s->PutChar('\n');
1314       s->Indent("}");
1315       return;
1316     }
1317   }
1318
1319   s->PutCString(name.AsCString());
1320 }
1321
1322 CompilerType GoASTContext::CreateArrayType(const ConstString &name,
1323                                            const CompilerType &element_type,
1324                                            uint64_t length) {
1325   GoType *type = new GoArray(name, length, element_type);
1326   (*m_types)[name].reset(type);
1327   return CompilerType(this, type);
1328 }
1329
1330 CompilerType GoASTContext::CreateBaseType(int go_kind,
1331                                           const lldb_private::ConstString &name,
1332                                           uint64_t byte_size) {
1333   if (go_kind == GoType::KIND_UINT || go_kind == GoType::KIND_INT)
1334     m_int_byte_size = byte_size;
1335   GoType *type = new GoType(go_kind, name);
1336   (*m_types)[name].reset(type);
1337   return CompilerType(this, type);
1338 }
1339
1340 CompilerType GoASTContext::CreateTypedefType(int kind, const ConstString &name,
1341                                              CompilerType impl) {
1342   GoType *type = new GoElem(kind, name, impl);
1343   (*m_types)[name].reset(type);
1344   return CompilerType(this, type);
1345 }
1346
1347 CompilerType
1348 GoASTContext::CreateVoidType(const lldb_private::ConstString &name) {
1349   GoType *type = new GoType(GoType::KIND_LLDB_VOID, name);
1350   (*m_types)[name].reset(type);
1351   return CompilerType(this, type);
1352 }
1353
1354 CompilerType
1355 GoASTContext::CreateStructType(int kind, const lldb_private::ConstString &name,
1356                                uint32_t byte_size) {
1357   GoType *type = new GoStruct(kind, name, byte_size);
1358   (*m_types)[name].reset(type);
1359   return CompilerType(this, type);
1360 }
1361
1362 void GoASTContext::AddFieldToStruct(
1363     const lldb_private::CompilerType &struct_type,
1364     const lldb_private::ConstString &name,
1365     const lldb_private::CompilerType &field_type, uint32_t byte_offset) {
1366   if (!struct_type)
1367     return;
1368   GoASTContext *ast =
1369       llvm::dyn_cast_or_null<GoASTContext>(struct_type.GetTypeSystem());
1370   if (!ast)
1371     return;
1372   GoType *type = static_cast<GoType *>(struct_type.GetOpaqueQualType());
1373   if (GoStruct *s = type->GetStruct())
1374     s->AddField(name, field_type, byte_offset);
1375 }
1376
1377 void GoASTContext::CompleteStructType(
1378     const lldb_private::CompilerType &struct_type) {
1379   if (!struct_type)
1380     return;
1381   GoASTContext *ast =
1382       llvm::dyn_cast_or_null<GoASTContext>(struct_type.GetTypeSystem());
1383   if (!ast)
1384     return;
1385   GoType *type = static_cast<GoType *>(struct_type.GetOpaqueQualType());
1386   if (GoStruct *s = type->GetStruct())
1387     s->SetComplete();
1388 }
1389
1390 CompilerType
1391 GoASTContext::CreateFunctionType(const lldb_private::ConstString &name,
1392                                  CompilerType *params, size_t params_count,
1393                                  bool is_variadic) {
1394   GoType *type = new GoFunction(name, is_variadic);
1395   (*m_types)[name].reset(type);
1396   return CompilerType(this, type);
1397 }
1398
1399 bool GoASTContext::IsGoString(const lldb_private::CompilerType &type) {
1400   if (!type.IsValid() ||
1401       !llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
1402     return false;
1403   return GoType::KIND_STRING ==
1404          static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
1405 }
1406
1407 bool GoASTContext::IsGoSlice(const lldb_private::CompilerType &type) {
1408   if (!type.IsValid() ||
1409       !llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
1410     return false;
1411   return GoType::KIND_SLICE ==
1412          static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
1413 }
1414
1415 bool GoASTContext::IsGoInterface(const lldb_private::CompilerType &type) {
1416   if (!type.IsValid() ||
1417       !llvm::dyn_cast_or_null<GoASTContext>(type.GetTypeSystem()))
1418     return false;
1419   return GoType::KIND_INTERFACE ==
1420          static_cast<GoType *>(type.GetOpaqueQualType())->GetGoKind();
1421 }
1422
1423 bool GoASTContext::IsPointerKind(uint8_t kind) {
1424   return (kind & GoType::KIND_MASK) == GoType::KIND_PTR;
1425 }
1426
1427 bool GoASTContext::IsDirectIface(uint8_t kind) {
1428   return (kind & GoType::KIND_DIRECT_IFACE) == GoType::KIND_DIRECT_IFACE;
1429 }
1430
1431 DWARFASTParser *GoASTContext::GetDWARFParser() {
1432   if (!m_dwarf_ast_parser_ap)
1433     m_dwarf_ast_parser_ap.reset(new DWARFASTParserGo(*this));
1434   return m_dwarf_ast_parser_ap.get();
1435 }
1436
1437 UserExpression *GoASTContextForExpr::GetUserExpression(
1438     llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
1439     Expression::ResultType desired_type,
1440     const EvaluateExpressionOptions &options) {
1441   TargetSP target = m_target_wp.lock();
1442   if (target)
1443     return new GoUserExpression(*target, expr, prefix, language, desired_type,
1444                                 options);
1445   return nullptr;
1446 }