lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

   1 //===-- BlockPointer.cpp --------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "BlockPointer.h"
  10
  11 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
  12 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
  13 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
  14 #include "lldb/DataFormatters/FormattersHelpers.h"
  15 #include "lldb/Symbol/CompilerType.h"
  16 #include "lldb/Symbol/TypeSystem.h"
  17 #include "lldb/Target/Target.h"
  18 #include "lldb/Utility/LLDBAssert.h"
  19 #include "lldb/Utility/LLDBLog.h"
  20 #include "lldb/Utility/Log.h"
  21 #include "lldb/ValueObject/ValueObject.h"
  22 #include "lldb/ValueObject/ValueObjectConstResult.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26 using namespace lldb_private::formatters;
  27
  28 namespace lldb_private {
  29 namespace formatters {
  30
  31 class BlockPointerSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
  32 public:
  33   BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
  34       : SyntheticChildrenFrontEnd(*valobj_sp), m_block_struct_type() {
  35     CompilerType block_pointer_type(m_backend.GetCompilerType());
  36     CompilerType function_pointer_type;
  37     block_pointer_type.IsBlockPointerType(&function_pointer_type);
  38
  39     TargetSP target_sp(m_backend.GetTargetSP());
  40
  41     if (!target_sp) {
  42       return;
  43     }
  44
  45     auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage(
  46         lldb::eLanguageTypeC_plus_plus);
  47     if (auto err = type_system_or_err.takeError()) {
  48       LLDB_LOG_ERROR(GetLog(LLDBLog::DataFormatters), std::move(err),
  49                      "Failed to get scratch TypeSystemClang: {0}");
  50       return;
  51     }
  52
  53     auto ts = block_pointer_type.GetTypeSystem();
  54     auto clang_ast_context = ts.dyn_cast_or_null<TypeSystemClang>();
  55     if (!clang_ast_context)
  56       return;
  57
  58     const char *const isa_name("__isa");
  59     const CompilerType isa_type =
  60         clang_ast_context->GetBasicType(lldb::eBasicTypeObjCClass);
  61     const char *const flags_name("__flags");
  62     const CompilerType flags_type =
  63         clang_ast_context->GetBasicType(lldb::eBasicTypeInt);
  64     const char *const reserved_name("__reserved");
  65     const CompilerType reserved_type =
  66         clang_ast_context->GetBasicType(lldb::eBasicTypeInt);
  67     const char *const FuncPtr_name("__FuncPtr");
  68
  69     m_block_struct_type = clang_ast_context->CreateStructForIdentifier(
  70         llvm::StringRef(), {{isa_name, isa_type},
  71                             {flags_name, flags_type},
  72                             {reserved_name, reserved_type},
  73                             {FuncPtr_name, function_pointer_type}});
  74   }
  75
  76   ~BlockPointerSyntheticFrontEnd() override = default;
  77
  78   llvm::Expected<uint32_t> CalculateNumChildren() override {
  79     const bool omit_empty_base_classes = false;
  80     return m_block_struct_type.GetNumChildren(omit_empty_base_classes, nullptr);
  81   }
  82
  83   lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override {
  84     if (!m_block_struct_type.IsValid()) {
  85       return lldb::ValueObjectSP();
  86     }
  87
  88     if (idx >= CalculateNumChildrenIgnoringErrors()) {
  89       return lldb::ValueObjectSP();
  90     }
  91
  92     const bool thread_and_frame_only_if_stopped = true;
  93     ExecutionContext exe_ctx = m_backend.GetExecutionContextRef().Lock(
  94         thread_and_frame_only_if_stopped);
  95     const bool transparent_pointers = false;
  96     const bool omit_empty_base_classes = false;
  97     const bool ignore_array_bounds = false;
  98     ValueObject *value_object = nullptr;
  99
 100     std::string child_name;
 101     uint32_t child_byte_size = 0;
 102     int32_t child_byte_offset = 0;
 103     uint32_t child_bitfield_bit_size = 0;
 104     uint32_t child_bitfield_bit_offset = 0;
 105     bool child_is_base_class = false;
 106     bool child_is_deref_of_parent = false;
 107     uint64_t language_flags = 0;
 108
 109     auto child_type_or_err = m_block_struct_type.GetChildCompilerTypeAtIndex(
 110         &exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
 111         ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
 112         child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
 113         child_is_deref_of_parent, value_object, language_flags);
 114     if (!child_type_or_err)
 115       return ValueObjectConstResult::Create(
 116           exe_ctx.GetBestExecutionContextScope(),
 117           Status::FromError(child_type_or_err.takeError()));
 118     CompilerType child_type = *child_type_or_err;
 119
 120     ValueObjectSP struct_pointer_sp =
 121         m_backend.Cast(m_block_struct_type.GetPointerType());
 122
 123     if (!struct_pointer_sp) {
 124       return lldb::ValueObjectSP();
 125     }
 126
 127     Status err;
 128     ValueObjectSP struct_sp = struct_pointer_sp->Dereference(err);
 129
 130     if (!struct_sp || !err.Success()) {
 131       return lldb::ValueObjectSP();
 132     }
 133
 134     ValueObjectSP child_sp(struct_sp->GetSyntheticChildAtOffset(
 135         child_byte_offset, child_type, true,
 136         ConstString(child_name.c_str(), child_name.size())));
 137
 138     return child_sp;
 139   }
 140
 141   // return true if this object is now safe to use forever without ever
 142   // updating again; the typical (and tested) answer here is 'false'
 143   lldb::ChildCacheState Update() override {
 144     return lldb::ChildCacheState::eRefetch;
 145   }
 146
 147   // maybe return false if the block pointer is, say, null
 148   bool MightHaveChildren() override { return true; }
 149
 150   size_t GetIndexOfChildWithName(ConstString name) override {
 151     if (!m_block_struct_type.IsValid())
 152       return UINT32_MAX;
 153
 154     const bool omit_empty_base_classes = false;
 155     return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(),
 156                                                        omit_empty_base_classes);
 157   }
 158
 159 private:
 160   CompilerType m_block_struct_type;
 161 };
 162
 163 } // namespace formatters
 164 } // namespace lldb_private
 165
 166 bool lldb_private::formatters::BlockPointerSummaryProvider(
 167     ValueObject &valobj, Stream &s, const TypeSummaryOptions &) {
 168   lldb_private::SyntheticChildrenFrontEnd *synthetic_children =
 169       BlockPointerSyntheticFrontEndCreator(nullptr, valobj.GetSP());
 170   if (!synthetic_children) {
 171     return false;
 172   }
 173
 174   synthetic_children->Update();
 175
 176   static const ConstString s_FuncPtr_name("__FuncPtr");
 177
 178   lldb::ValueObjectSP child_sp = synthetic_children->GetChildAtIndex(
 179       synthetic_children->GetIndexOfChildWithName(s_FuncPtr_name));
 180
 181   if (!child_sp) {
 182     return false;
 183   }
 184
 185   lldb::ValueObjectSP qualified_child_representation_sp =
 186       child_sp->GetQualifiedRepresentationIfAvailable(
 187           lldb::eDynamicDontRunTarget, true);
 188
 189   const char *child_value =
 190       qualified_child_representation_sp->GetValueAsCString();
 191
 192   s.Printf("%s", child_value);
 193
 194   return true;
 195 }
 196
 197 lldb_private::SyntheticChildrenFrontEnd *
 198 lldb_private::formatters::BlockPointerSyntheticFrontEndCreator(
 199     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
 200   if (!valobj_sp)
 201     return nullptr;
 202   return new BlockPointerSyntheticFrontEnd(valobj_sp);
 203 }