/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/lldb/include/lldb/Target/StackFrameRecognizer.h

Bug Summary

File:	build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/lldb/include/lldb/Target/StackFrameRecognizer.h
Warning:	line 149, column 5 Potential memory leak

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name AppleObjCRuntimeV2.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-16/lib/clang/16.0.0 -isystem /usr/include/libxml2 -D HAVE_ROUND -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime -I /build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime -I tools/lldb/source/Plugins/LanguageRuntime/ObjC -I /build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/lldb/include -I tools/lldb/include -I include -I /build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/llvm/include -I /usr/include/python3.9 -I /build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/clang/include -I tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/lldb/source -I tools/lldb/source -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-stringop-truncation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-17-052721-121489-1 -x c++ /build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

→

1//===-- AppleObjCRuntimeV2.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//===----------------------------------------------------------------------===//

9#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
10#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"

12#include "lldb/Core/Debugger.h"
13#include "lldb/Core/DebuggerEvents.h"
14#include "lldb/Core/Module.h"
15#include "lldb/Core/PluginManager.h"
16#include "lldb/Core/Section.h"
17#include "lldb/Core/ValueObjectConstResult.h"
18#include "lldb/Core/ValueObjectVariable.h"
19#include "lldb/Expression/DiagnosticManager.h"
20#include "lldb/Expression/FunctionCaller.h"
21#include "lldb/Expression/UtilityFunction.h"
22#include "lldb/Host/OptionParser.h"
23#include "lldb/Interpreter/CommandObject.h"
24#include "lldb/Interpreter/CommandObjectMultiword.h"
25#include "lldb/Interpreter/CommandReturnObject.h"
26#include "lldb/Interpreter/OptionArgParser.h"
27#include "lldb/Interpreter/OptionValueBoolean.h"
28#include "lldb/Symbol/CompilerType.h"
29#include "lldb/Symbol/ObjectFile.h"
30#include "lldb/Symbol/Symbol.h"
31#include "lldb/Symbol/TypeList.h"
32#include "lldb/Symbol/VariableList.h"
33#include "lldb/Target/ABI.h"
34#include "lldb/Target/DynamicLoader.h"
35#include "lldb/Target/ExecutionContext.h"
36#include "lldb/Target/Platform.h"
37#include "lldb/Target/Process.h"
38#include "lldb/Target/RegisterContext.h"
39#include "lldb/Target/StackFrameRecognizer.h"
40#include "lldb/Target/Target.h"
41#include "lldb/Target/Thread.h"
42#include "lldb/Utility/ConstString.h"
43#include "lldb/Utility/LLDBLog.h"
44#include "lldb/Utility/Log.h"
45#include "lldb/Utility/Scalar.h"
46#include "lldb/Utility/Status.h"
47#include "lldb/Utility/Stream.h"
48#include "lldb/Utility/StreamString.h"
49#include "lldb/Utility/Timer.h"
50#include "lldb/lldb-enumerations.h"

52#include "AppleObjCClassDescriptorV2.h"
53#include "AppleObjCDeclVendor.h"
54#include "AppleObjCRuntimeV2.h"
55#include "AppleObjCTrampolineHandler.h"
56#include "AppleObjCTypeEncodingParser.h"

58#include "clang/AST/ASTContext.h"
59#include "clang/AST/DeclObjC.h"
60#include "clang/Basic/TargetInfo.h"
61#include "llvm/ADT/ScopeExit.h"

63#include <cstdint>
64#include <memory>
65#include <string>
66#include <vector>

68using namespace lldb;
69using namespace lldb_private;

71char AppleObjCRuntimeV2::ID = 0;

73static const char *g_get_dynamic_class_info_name =
  "__lldb_apple_objc_v2_get_dynamic_class_info";

76static const char *g_get_dynamic_class_info_body = R"(

78extern "C"
79{
  size_t strlen(const char *);
  char *strncpy (char * s1, const char * s2, size_t n);
  int printf(const char * format, ...);
83}
84#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__)

86typedef struct _NXMapTable {
  void *prototype;
  unsigned num_classes;
  unsigned num_buckets_minus_one;
  void *buckets;
91} NXMapTable;

93#define NX_MAPNOTAKEY   ((void *)(-1))

95typedef struct BucketInfo
96{
  const char *name_ptr;
  Class isa;
99} BucketInfo;

101struct ClassInfo
102{
  Class isa;
  uint32_t hash;
105} __attribute__((__packed__));

107uint32_t
108__lldb_apple_objc_v2_get_dynamic_class_info (void *gdb_objc_realized_classes_ptr,
                                           void *class_infos_ptr,
                                           uint32_t class_infos_byte_size,
                                           uint32_t should_log)
112{
  DEBUG_PRINTF ("gdb_objc_realized_classes_ptr = %p\n", gdb_objc_realized_classes_ptr);
  DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
  DEBUG_PRINTF ("class_infos_byte_size = %u\n", class_infos_byte_size);
  const NXMapTable *grc = (const NXMapTable *)gdb_objc_realized_classes_ptr;
  if (grc)
  {
      const unsigned num_classes = grc->num_classes;
      DEBUG_PRINTF ("num_classes = %u\n", grc->num_classes);
      if (class_infos_ptr)
      {
          const unsigned num_buckets_minus_one = grc->num_buckets_minus_one;
          DEBUG_PRINTF ("num_buckets_minus_one = %u\n", num_buckets_minus_one);

          const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
          DEBUG_PRINTF ("max_class_infos = %u\n", max_class_infos);

          ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
          BucketInfo *buckets = (BucketInfo *)grc->buckets;

          uint32_t idx = 0;
          for (unsigned i=0; i<=num_buckets_minus_one; ++i)
          {
              if (buckets[i].name_ptr != NX_MAPNOTAKEY)
              {
                  if (idx < max_class_infos)
                  {
                      const char *s = buckets[i].name_ptr;
                      uint32_t h = 5381;
                      for (unsigned char c = *s; c; c = *++s)
                          h = ((h << 5) + h) + c;
                      class_infos[idx].hash = h;
                      class_infos[idx].isa = buckets[i].isa;
                      DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, buckets[i].name_ptr);
                  }
                  ++idx;
              }
          }
          if (idx < max_class_infos)
          {
              class_infos[idx].isa = NULL;
              class_infos[idx].hash = 0;
          }
      }
      return num_classes;
  }
  return 0;
159}

161)";

163static const char *g_get_dynamic_class_info2_name =
  "__lldb_apple_objc_v2_get_dynamic_class_info2";

166static const char *g_get_dynamic_class_info2_body = R"(

168extern "C" {
  int printf(const char * format, ...);
  void free(void *ptr);
  Class* objc_copyRealizedClassList_nolock(unsigned int *outCount);
  const char* objc_debug_class_getNameRaw(Class cls);
173}

175#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__)

177struct ClassInfo
178{
  Class isa;
  uint32_t hash;
181} __attribute__((__packed__));

183uint32_t
184__lldb_apple_objc_v2_get_dynamic_class_info2(void *gdb_objc_realized_classes_ptr,
                                           void *class_infos_ptr,
                                           uint32_t class_infos_byte_size,
                                           uint32_t should_log)
188{
  DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
  DEBUG_PRINTF ("class_infos_byte_size = %u\n", class_infos_byte_size);

  const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
  DEBUG_PRINTF ("max_class_infos = %u\n", max_class_infos);

  ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;

  uint32_t count = 0;
  Class* realized_class_list = objc_copyRealizedClassList_nolock(&count);
  DEBUG_PRINTF ("count = %u\n", count);

  uint32_t idx = 0;
  for (uint32_t i=0; i<count; ++i)
  {
      if (idx < max_class_infos)
      {
          Class isa = realized_class_list[i];
          const char *name_ptr = objc_debug_class_getNameRaw(isa);
          if (!name_ptr)
              continue;
          const char *s = name_ptr;
          uint32_t h = 5381;
          for (unsigned char c = *s; c; c = *++s)
              h = ((h << 5) + h) + c;
          class_infos[idx].hash = h;
          class_infos[idx].isa = isa;
          DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name_ptr);
      }
      idx++;
  }

  if (idx < max_class_infos)
  {
      class_infos[idx].isa = NULL;
      class_infos[idx].hash = 0;
  }

  free(realized_class_list);
  return count;
229}
230)";

232static const char *g_get_dynamic_class_info3_name =
  "__lldb_apple_objc_v2_get_dynamic_class_info3";

235static const char *g_get_dynamic_class_info3_body = R"(

237extern "C" {
  int printf(const char * format, ...);
  void free(void *ptr);
  size_t objc_getRealizedClassList_trylock(Class *buffer, size_t len);
  const char* objc_debug_class_getNameRaw(Class cls);
  const char* class_getName(Class cls);
243}

245#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__)

247struct ClassInfo
248{
  Class isa;
  uint32_t hash;
251} __attribute__((__packed__));

253uint32_t
254__lldb_apple_objc_v2_get_dynamic_class_info3(void *gdb_objc_realized_classes_ptr,
                                           void *class_infos_ptr,
                                           uint32_t class_infos_byte_size,
                                           void *class_buffer,
                                           uint32_t class_buffer_len,
                                           uint32_t should_log)
260{
  DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
  DEBUG_PRINTF ("class_infos_byte_size = %u\n", class_infos_byte_size);

  const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
  DEBUG_PRINTF ("max_class_infos = %u\n", max_class_infos);

  ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;

  Class *realized_class_list = (Class*)class_buffer;

  uint32_t count = objc_getRealizedClassList_trylock(realized_class_list,
                                                     class_buffer_len);
  DEBUG_PRINTF ("count = %u\n", count);

  uint32_t idx = 0;
  for (uint32_t i=0; i<count; ++i)
  {
      if (idx < max_class_infos)
      {
          Class isa = realized_class_list[i];
          const char *name_ptr = objc_debug_class_getNameRaw(isa);
          if (!name_ptr) {
             class_getName(isa); // Realize name of lazy classes.
             name_ptr = objc_debug_class_getNameRaw(isa);
          }
          if (!name_ptr)
              continue;
          const char *s = name_ptr;
          uint32_t h = 5381;
          for (unsigned char c = *s; c; c = *++s)
              h = ((h << 5) + h) + c;
          class_infos[idx].hash = h;
          class_infos[idx].isa = isa;
          DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name_ptr);
      }
      idx++;
  }

  if (idx < max_class_infos)
  {
      class_infos[idx].isa = NULL;
      class_infos[idx].hash = 0;
  }

  return count;
306}
307)";

309// We'll substitute in class_getName or class_getNameRaw depending
310// on which is present.
311static const char *g_shared_cache_class_name_funcptr = R"(
312extern "C"
313{
  const char *%s(void *objc_class);
  const char *(*class_name_lookup_func)(void *) = %s;
316}
317)";

319static const char *g_get_shared_cache_class_info_name =
  "__lldb_apple_objc_v2_get_shared_cache_class_info";

322static const char *g_get_shared_cache_class_info_body = R"(

324extern "C"
325{
  size_t strlen(const char *);
  char *strncpy (char * s1, const char * s2, size_t n);
  int printf(const char * format, ...);
329}

331#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__)


334struct objc_classheader_t {
  int32_t clsOffset;
  int32_t hiOffset;
337};

339struct objc_classheader_v16_t {
  uint64_t isDuplicate       : 1,
           objectCacheOffset : 47, // Offset from the shared cache base
           dylibObjCIndex    : 16;
343};

345struct objc_clsopt_t {
  uint32_t capacity;
  uint32_t occupied;
  uint32_t shift;
  uint32_t mask;
  uint32_t zero;
  uint32_t unused;
  uint64_t salt;
  uint32_t scramble[256];
  uint8_t tab[0]; // tab[mask+1]
  //  uint8_t checkbytes[capacity];
  //  int32_t offset[capacity];
  //  objc_classheader_t clsOffsets[capacity];
  //  uint32_t duplicateCount;
  //  objc_classheader_t duplicateOffsets[duplicateCount];
360};

362struct objc_clsopt_v16_t {
 uint32_t version;
 uint32_t capacity;
 uint32_t occupied;
 uint32_t shift;
 uint32_t mask;
 uint32_t zero;
 uint64_t salt;
 uint32_t scramble[256];
 uint8_t  tab[0]; // tab[mask+1]
 //  uint8_t checkbytes[capacity];
 //  int32_t offset[capacity];
 //  objc_classheader_t clsOffsets[capacity];
 //  uint32_t duplicateCount;
 //  objc_classheader_t duplicateOffsets[duplicateCount];
377};

379struct objc_opt_t {
  uint32_t version;
  int32_t selopt_offset;
  int32_t headeropt_offset;
  int32_t clsopt_offset;
384};

386struct objc_opt_v14_t {
  uint32_t version;
  uint32_t flags;
  int32_t selopt_offset;
  int32_t headeropt_offset;
  int32_t clsopt_offset;
392};

394struct objc_opt_v16_t {
  uint32_t version;
  uint32_t flags;
  int32_t selopt_offset;
  int32_t headeropt_ro_offset;
  int32_t unused_clsopt_offset;
  int32_t unused_protocolopt_offset;
  int32_t headeropt_rw_offset;
  int32_t unused_protocolopt2_offset;
  int32_t largeSharedCachesClassOffset;
  int32_t largeSharedCachesProtocolOffset;
  uint64_t relativeMethodSelectorBaseAddressCacheOffset;
406};

408struct ClassInfo
409{
  Class isa;
  uint32_t hash;
412}  __attribute__((__packed__));

414uint32_t
415__lldb_apple_objc_v2_get_shared_cache_class_info (void *objc_opt_ro_ptr,
                                                void *shared_cache_base_ptr,
                                                void *class_infos_ptr,
                                                uint64_t *relative_selector_offset,
                                                uint32_t class_infos_byte_size,
                                                uint32_t should_log)
421{
  *relative_selector_offset = 0;
  uint32_t idx = 0;
  DEBUG_PRINTF ("objc_opt_ro_ptr = %p\n", objc_opt_ro_ptr);
  DEBUG_PRINTF ("shared_cache_base_ptr = %p\n", shared_cache_base_ptr);
  DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
  DEBUG_PRINTF ("class_infos_byte_size = %u (%llu class infos)\n", class_infos_byte_size, (uint64_t)(class_infos_byte_size/sizeof(ClassInfo)));
  if (objc_opt_ro_ptr)
  {
      const objc_opt_t *objc_opt = (objc_opt_t *)objc_opt_ro_ptr;
      const objc_opt_v14_t* objc_opt_v14 = (objc_opt_v14_t*)objc_opt_ro_ptr;
      const objc_opt_v16_t* objc_opt_v16 = (objc_opt_v16_t*)objc_opt_ro_ptr;
      if (objc_opt->version >= 16)
      {
          *relative_selector_offset = objc_opt_v16->relativeMethodSelectorBaseAddressCacheOffset;
          DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt_v16->version);
          DEBUG_PRINTF ("objc_opt->flags = %u\n", objc_opt_v16->flags);
          DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt_v16->selopt_offset);
          DEBUG_PRINTF ("objc_opt->headeropt_ro_offset = %d\n", objc_opt_v16->headeropt_ro_offset);
          DEBUG_PRINTF ("objc_opt->relativeMethodSelectorBaseAddressCacheOffset = %d\n", *relative_selector_offset);
      }
      else if (objc_opt->version >= 14)
      {
          DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt_v14->version);
          DEBUG_PRINTF ("objc_opt->flags = %u\n", objc_opt_v14->flags);
          DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt_v14->selopt_offset);
          DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt_v14->headeropt_offset);
          DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt_v14->clsopt_offset);
      }
      else
      {
          DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt->version);
          DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt->selopt_offset);
          DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt->headeropt_offset);
          DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt->clsopt_offset);
      }

      if (objc_opt->version == 16)
      {
          const objc_clsopt_v16_t* clsopt = (const objc_clsopt_v16_t*)((uint8_t *)objc_opt + objc_opt_v16->largeSharedCachesClassOffset);
          const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);

          DEBUG_PRINTF("max_class_infos = %llu\n", (uint64_t)max_class_infos);

          ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;

          const uint8_t *checkbytes = &clsopt->tab[clsopt->mask+1];
          const int32_t *offsets = (const int32_t *)(checkbytes + clsopt->capacity);
          const objc_classheader_v16_t *classOffsets = (const objc_classheader_v16_t *)(offsets + clsopt->capacity);

          DEBUG_PRINTF ("clsopt->capacity = %u\n", clsopt->capacity);
          DEBUG_PRINTF ("clsopt->mask = 0x%8.8x\n", clsopt->mask);
          DEBUG_PRINTF ("classOffsets = %p\n", classOffsets);

          for (uint32_t i=0; i<clsopt->capacity; ++i)
          {
              const uint64_t objectCacheOffset = classOffsets[i].objectCacheOffset;
              DEBUG_PRINTF("objectCacheOffset[%u] = %u\n", i, objectCacheOffset);

              if (classOffsets[i].isDuplicate) {
                  DEBUG_PRINTF("isDuplicate = true\n");
                  continue; // duplicate
              }

              if (objectCacheOffset == 0) {
                  DEBUG_PRINTF("objectCacheOffset == invalidEntryOffset\n");
                  continue; // invalid offset
              }

              if (class_infos && idx < max_class_infos)
              {
                  class_infos[idx].isa = (Class)((uint8_t *)shared_cache_base_ptr + objectCacheOffset);

                  // Lookup the class name.
                  const char *name = class_name_lookup_func(class_infos[idx].isa);
                  DEBUG_PRINTF("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);

                  // Hash the class name so we don't have to read it.
                  const char *s = name;
                  uint32_t h = 5381;
                  for (unsigned char c = *s; c; c = *++s)
                  {
                      // class_getName demangles swift names and the hash must
                      // be calculated on the mangled name.  hash==0 means lldb
                      // will fetch the mangled name and compute the hash in
                      // ParseClassInfoArray.
                      if (c == '.')
                      {
                          h = 0;
                          break;
                      }
                      h = ((h << 5) + h) + c;
                  }
                  class_infos[idx].hash = h;
              }
              else
              {
                  DEBUG_PRINTF("not(class_infos && idx < max_class_infos)\n");
              }
              ++idx;
          }

          const uint32_t *duplicate_count_ptr = (uint32_t *)&classOffsets[clsopt->capacity];
          const uint32_t duplicate_count = *duplicate_count_ptr;
          const objc_classheader_v16_t *duplicateClassOffsets = (const objc_classheader_v16_t *)(&duplicate_count_ptr[1]);

          DEBUG_PRINTF ("duplicate_count = %u\n", duplicate_count);
          DEBUG_PRINTF ("duplicateClassOffsets = %p\n", duplicateClassOffsets);

          for (uint32_t i=0; i<duplicate_count; ++i)
          {
              const uint64_t objectCacheOffset = classOffsets[i].objectCacheOffset;
              DEBUG_PRINTF("objectCacheOffset[%u] = %u\n", i, objectCacheOffset);

              if (classOffsets[i].isDuplicate) {
                  DEBUG_PRINTF("isDuplicate = true\n");
                  continue; // duplicate
              }

              if (objectCacheOffset == 0) {
                  DEBUG_PRINTF("objectCacheOffset == invalidEntryOffset\n");
                  continue; // invalid offset
              }

              if (class_infos && idx < max_class_infos)
              {
                  class_infos[idx].isa = (Class)((uint8_t *)shared_cache_base_ptr + objectCacheOffset);

                  // Lookup the class name.
                  const char *name = class_name_lookup_func(class_infos[idx].isa);
                  DEBUG_PRINTF("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);

                  // Hash the class name so we don't have to read it.
                  const char *s = name;
                  uint32_t h = 5381;
                  for (unsigned char c = *s; c; c = *++s)
                  {
                      // class_getName demangles swift names and the hash must
                      // be calculated on the mangled name.  hash==0 means lldb
                      // will fetch the mangled name and compute the hash in
                      // ParseClassInfoArray.
                      if (c == '.')
                      {
                          h = 0;
                          break;
                      }
                      h = ((h << 5) + h) + c;
                  }
                  class_infos[idx].hash = h;
              }
          }
      }
      else if (objc_opt->version >= 12 && objc_opt->version <= 15)
      {
          const objc_clsopt_t* clsopt = NULL;
          if (objc_opt->version >= 14)
              clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt_v14 + objc_opt_v14->clsopt_offset);
          else
              clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt + objc_opt->clsopt_offset);
          const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
          DEBUG_PRINTF("max_class_infos = %llu\n", (uint64_t)max_class_infos);
          ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
          int32_t invalidEntryOffset = 0;
          // this is safe to do because the version field order is invariant
          if (objc_opt->version == 12)
              invalidEntryOffset = 16;
          const uint8_t *checkbytes = &clsopt->tab[clsopt->mask+1];
          const int32_t *offsets = (const int32_t *)(checkbytes + clsopt->capacity);
          const objc_classheader_t *classOffsets = (const objc_classheader_t *)(offsets + clsopt->capacity);
          DEBUG_PRINTF ("clsopt->capacity = %u\n", clsopt->capacity);
          DEBUG_PRINTF ("clsopt->mask = 0x%8.8x\n", clsopt->mask);
          DEBUG_PRINTF ("classOffsets = %p\n", classOffsets);
          DEBUG_PRINTF("invalidEntryOffset = %d\n", invalidEntryOffset);
          for (uint32_t i=0; i<clsopt->capacity; ++i)
          {
              const int32_t clsOffset = classOffsets[i].clsOffset;
              DEBUG_PRINTF("clsOffset[%u] = %u\n", i, clsOffset);
              if (clsOffset & 1)
              {
                  DEBUG_PRINTF("clsOffset & 1\n");
                  continue; // duplicate
              }
              else if (clsOffset == invalidEntryOffset)
              {
                  DEBUG_PRINTF("clsOffset == invalidEntryOffset\n");
                  continue; // invalid offset
              }

              if (class_infos && idx < max_class_infos)
              {
                  class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset);
                  const char *name = class_name_lookup_func (class_infos[idx].isa);
                  DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);
                  // Hash the class name so we don't have to read it
                  const char *s = name;
                  uint32_t h = 5381;
                  for (unsigned char c = *s; c; c = *++s)
                  {
                      // class_getName demangles swift names and the hash must
                      // be calculated on the mangled name.  hash==0 means lldb
                      // will fetch the mangled name and compute the hash in
                      // ParseClassInfoArray.
                      if (c == '.')
                      {
                          h = 0;
                          break;
                      }
                      h = ((h << 5) + h) + c;
                  }
                  class_infos[idx].hash = h;
              }
              else
              {
                  DEBUG_PRINTF("not(class_infos && idx < max_class_infos)\n");
              }
              ++idx;
          }

          const uint32_t *duplicate_count_ptr = (uint32_t *)&classOffsets[clsopt->capacity];
          const uint32_t duplicate_count = *duplicate_count_ptr;
          const objc_classheader_t *duplicateClassOffsets = (const objc_classheader_t *)(&duplicate_count_ptr[1]);
          DEBUG_PRINTF ("duplicate_count = %u\n", duplicate_count);
          DEBUG_PRINTF ("duplicateClassOffsets = %p\n", duplicateClassOffsets);
          for (uint32_t i=0; i<duplicate_count; ++i)
          {
              const int32_t clsOffset = duplicateClassOffsets[i].clsOffset;
              if (clsOffset & 1)
                  continue; // duplicate
              else if (clsOffset == invalidEntryOffset)
                  continue; // invalid offset

              if (class_infos && idx < max_class_infos)
              {
                  class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset);
                  const char *name = class_name_lookup_func (class_infos[idx].isa);
                  DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);
                  // Hash the class name so we don't have to read it
                  const char *s = name;
                  uint32_t h = 5381;
                  for (unsigned char c = *s; c; c = *++s)
                  {
                      // class_getName demangles swift names and the hash must
                      // be calculated on the mangled name.  hash==0 means lldb
                      // will fetch the mangled name and compute the hash in
                      // ParseClassInfoArray.
                      if (c == '.')
                      {
                          h = 0;
                          break;
                      }
                      h = ((h << 5) + h) + c;
                  }
                  class_infos[idx].hash = h;
              }
              ++idx;
          }
      }
      DEBUG_PRINTF ("%u class_infos\n", idx);
      DEBUG_PRINTF ("done\n");
  }
  return idx;
682}


685)";

687static uint64_t
688ExtractRuntimeGlobalSymbol(Process *process, ConstString name,
                         const ModuleSP &module_sp, Status &error,
                         bool read_value = true, uint8_t byte_size = 0,
                         uint64_t default_value = LLDB_INVALID_ADDRESS(18446744073709551615UL),
                         SymbolType sym_type = lldb::eSymbolTypeData) {
if (!process) {
  error.SetErrorString("no process");
  return default_value;
}

if (!module_sp) {
  error.SetErrorString("no module");
  return default_value;
}

if (!byte_size)
  byte_size = process->GetAddressByteSize();
const Symbol *symbol =
    module_sp->FindFirstSymbolWithNameAndType(name, lldb::eSymbolTypeData);

if (!symbol || !symbol->ValueIsAddress()) {
  error.SetErrorString("no symbol");
  return default_value;
}

lldb::addr_t symbol_load_addr =
    symbol->GetAddressRef().GetLoadAddress(&process->GetTarget());
if (symbol_load_addr == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
  error.SetErrorString("symbol address invalid");
  return default_value;
}

if (read_value)
  return process->ReadUnsignedIntegerFromMemory(symbol_load_addr, byte_size,
                                                default_value, error);
return symbol_load_addr;
724}

726static void RegisterObjCExceptionRecognizer(Process *process);

728AppleObjCRuntimeV2::AppleObjCRuntimeV2(Process *process,
                                     const ModuleSP &objc_module_sp)
  : AppleObjCRuntime(process), m_objc_module_sp(objc_module_sp),
    m_dynamic_class_info_extractor(*this),
    m_shared_cache_class_info_extractor(*this), m_decl_vendor_up(),
    m_tagged_pointer_obfuscator(LLDB_INVALID_ADDRESS(18446744073709551615UL)),
    m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS(18446744073709551615UL)),
    m_relative_selector_base(LLDB_INVALID_ADDRESS(18446744073709551615UL)), m_hash_signature(),
    m_has_object_getClass(false), m_has_objc_copyRealizedClassList(false),
    m_has_objc_getRealizedClassList_trylock(false), m_loaded_objc_opt(false),
    m_non_pointer_isa_cache_up(),
    m_tagged_pointer_vendor_up(
        TaggedPointerVendorV2::CreateInstance(*this, objc_module_sp)),
    m_encoding_to_type_sp(), m_CFBoolean_values(),
    m_realized_class_generation_count(0) {
static const ConstString g_gdb_object_getClass("gdb_object_getClass");
m_has_object_getClass = HasSymbol(g_gdb_object_getClass);
static const ConstString g_objc_copyRealizedClassList(
    "_ZL33objc_copyRealizedClassList_nolockPj");
static const ConstString g_objc_getRealizedClassList_trylock(
    "_objc_getRealizedClassList_trylock");
m_has_objc_copyRealizedClassList = HasSymbol(g_objc_copyRealizedClassList);
m_has_objc_getRealizedClassList_trylock =
    HasSymbol(g_objc_getRealizedClassList_trylock);
WarnIfNoExpandedSharedCache();
RegisterObjCExceptionRecognizer(process);
754}

756bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress(
  ValueObject &in_value, lldb::DynamicValueType use_dynamic,
  TypeAndOrName &class_type_or_name, Address &address,
  Value::ValueType &value_type) {
// We should never get here with a null process...
assert(m_process != nullptr)(static_cast <bool> (m_process != nullptr) ? void (0) :
 __assert_fail ("m_process != nullptr", "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, 761, __extension__ __PRETTY_FUNCTION__));

// The Runtime is attached to a particular process, you shouldn't pass in a
// value from another process. Note, however, the process might be NULL (e.g.
// if the value was made with SBTarget::EvaluateExpression...) in which case
// it is sufficient if the target's match:

Process *process = in_value.GetProcessSP().get();
if (process)
  assert(process == m_process)(static_cast <bool> (process == m_process) ? void (0) :
 __assert_fail ("process == m_process", "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, 770, __extension__ __PRETTY_FUNCTION__));
else
  assert(in_value.GetTargetSP().get() == m_process->CalculateTarget().get())(static_cast <bool> (in_value.GetTargetSP().get() == m_process
->CalculateTarget().get()) ? void (0) : __assert_fail ("in_value.GetTargetSP().get() == m_process->CalculateTarget().get()"
, "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, 772, __extension__ __PRETTY_FUNCTION__));

class_type_or_name.Clear();
value_type = Value::ValueType::Scalar;

// Make sure we can have a dynamic value before starting...
if (CouldHaveDynamicValue(in_value)) {
  // First job, pull out the address at 0 offset from the object  That will
  // be the ISA pointer.
  ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(in_value));
  if (objc_class_sp) {
    const addr_t object_ptr = in_value.GetPointerValue();
    address.SetRawAddress(object_ptr);

    ConstString class_name(objc_class_sp->GetClassName());
    class_type_or_name.SetName(class_name);
    TypeSP type_sp(objc_class_sp->GetType());
    if (type_sp)
      class_type_or_name.SetTypeSP(type_sp);
    else {
      type_sp = LookupInCompleteClassCache(class_name);
      if (type_sp) {
        objc_class_sp->SetType(type_sp);
        class_type_or_name.SetTypeSP(type_sp);
      } else {
        // try to go for a CompilerType at least
        if (auto *vendor = GetDeclVendor()) {
          auto types = vendor->FindTypes(class_name, /*max_matches*/ 1);
          if (!types.empty())
            class_type_or_name.SetCompilerType(types.front());
        }
      }
    }
  }
}
return !class_type_or_name.IsEmpty();
808}

810// Static Functions
811LanguageRuntime *AppleObjCRuntimeV2::CreateInstance(Process *process,
                                                  LanguageType language) {
// FIXME: This should be a MacOS or iOS process, and we need to look for the
// OBJC section to make
// sure we aren't using the V1 runtime.
if (language == eLanguageTypeObjC) {
  ModuleSP objc_module_sp;

  if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) ==
      ObjCRuntimeVersions::eAppleObjC_V2)
    return new AppleObjCRuntimeV2(process, objc_module_sp);
  return nullptr;
}
return nullptr;
825}

827static constexpr OptionDefinition g_objc_classtable_dump_options[] = {
  {LLDB_OPT_SET_ALL0xFFFFFFFFU,
   false,
   "verbose",
   'v',
   OptionParser::eNoArgument,
   nullptr,
   {},
   0,
   eArgTypeNone,
   "Print ivar and method information in detail"}};

839class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed {
840public:
class CommandOptions : public Options {
public:
  CommandOptions() : Options(), m_verbose(false, false) {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;
    switch (short_option) {
    case 'v':
      m_verbose.SetCurrentValue(true);
      m_verbose.SetOptionWasSet();
      break;

    default:
      error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_verbose.Clear();
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_objc_classtable_dump_options);
  }

  OptionValueBoolean m_verbose;
};

CommandObjectObjC_ClassTable_Dump(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "dump",
                          "Dump information on Objective-C classes "
                          "known to the current process.",
                          "language objc class-table dump",
                          eCommandRequiresProcess |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused),
      m_options() {
  CommandArgumentEntry arg;
  CommandArgumentData index_arg;

  // Define the first (and only) variant of this arg.
  index_arg.arg_type = eArgTypeRegularExpression;
  index_arg.arg_repetition = eArgRepeatOptional;

  // There is only one variant this argument could be; put it into the
  // argument entry.
  arg.push_back(index_arg);

  // Push the data for the first argument into the m_arguments vector.
  m_arguments.push_back(arg);
}

~CommandObjectObjC_ClassTable_Dump() override = default;

Options *GetOptions() override { return &m_options; }

905protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  std::unique_ptr<RegularExpression> regex_up;
  switch (command.GetArgumentCount()) {
  case 0:
    break;
  case 1: {
    regex_up =
        std::make_unique<RegularExpression>(command.GetArgumentAtIndex(0));
    if (!regex_up->IsValid()) {
      result.AppendError(
          "invalid argument - please provide a valid regular expression");
      result.SetStatus(lldb::eReturnStatusFailed);
      return false;
    }
    break;
  }
  default: {
    result.AppendError("please provide 0 or 1 arguments");
    result.SetStatus(lldb::eReturnStatusFailed);
    return false;
  }
  }

  Process *process = m_exe_ctx.GetProcessPtr();
  ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process);
  if (objc_runtime) {
    auto iterators_pair = objc_runtime->GetDescriptorIteratorPair();
    auto iterator = iterators_pair.first;
    auto &std_out = result.GetOutputStream();
    for (; iterator != iterators_pair.second; iterator++) {
      if (iterator->second) {
        const char *class_name =
            iterator->second->GetClassName().AsCString("<unknown>");
        if (regex_up && class_name &&
            !regex_up->Execute(llvm::StringRef(class_name)))
          continue;
        std_out.Printf("isa = 0x%" PRIx64"l" "x", iterator->first);
        std_out.Printf(" name = %s", class_name);
        std_out.Printf(" instance size = %" PRIu64"l" "u",
                       iterator->second->GetInstanceSize());
        std_out.Printf(" num ivars = %" PRIuPTR"l" "u",
                       (uintptr_t)iterator->second->GetNumIVars());
        if (auto superclass = iterator->second->GetSuperclass()) {
          std_out.Printf(" superclass = %s",
                         superclass->GetClassName().AsCString("<unknown>"));
        }
        std_out.Printf("\n");
        if (m_options.m_verbose) {
          for (size_t i = 0; i < iterator->second->GetNumIVars(); i++) {
            auto ivar = iterator->second->GetIVarAtIndex(i);
            std_out.Printf(
                "  ivar name = %s type = %s size = %" PRIu64"l" "u"
                " offset = %" PRId32"d" "\n",
                ivar.m_name.AsCString("<unknown>"),
                ivar.m_type.GetDisplayTypeName().AsCString("<unknown>"),
                ivar.m_size, ivar.m_offset);
          }

          iterator->second->Describe(
              nullptr,
              [&std_out](const char *name, const char *type) -> bool {
                std_out.Printf("  instance method name = %s type = %s\n",
                               name, type);
                return false;
              },
              [&std_out](const char *name, const char *type) -> bool {
                std_out.Printf("  class method name = %s type = %s\n", name,
                               type);
                return false;
              },
              nullptr);
        }
      } else {
        if (regex_up && !regex_up->Execute(llvm::StringRef()))
          continue;
        std_out.Printf("isa = 0x%" PRIx64"l" "x" " has no associated class.\n",
                       iterator->first);
      }
    }
    result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
    return true;
  }
  result.AppendError("current process has no Objective-C runtime loaded");
  result.SetStatus(lldb::eReturnStatusFailed);
  return false;
}

CommandOptions m_options;
994};

996class CommandObjectMultiwordObjC_TaggedPointer_Info
  : public CommandObjectParsed {
998public:
CommandObjectMultiwordObjC_TaggedPointer_Info(CommandInterpreter &interpreter)
    : CommandObjectParsed(
          interpreter, "info", "Dump information on a tagged pointer.",
          "language objc tagged-pointer info",
          eCommandRequiresProcess | eCommandProcessMustBeLaunched |
              eCommandProcessMustBePaused) {
  CommandArgumentEntry arg;
  CommandArgumentData index_arg;

  // Define the first (and only) variant of this arg.
  index_arg.arg_type = eArgTypeAddress;
  index_arg.arg_repetition = eArgRepeatPlus;

  // There is only one variant this argument could be; put it into the
  // argument entry.
  arg.push_back(index_arg);

  // Push the data for the first argument into the m_arguments vector.
  m_arguments.push_back(arg);
}

~CommandObjectMultiwordObjC_TaggedPointer_Info() override = default;

1022protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  if (command.GetArgumentCount() == 0) {
    result.AppendError("this command requires arguments");
    result.SetStatus(lldb::eReturnStatusFailed);
    return false;
  }

  Process *process = m_exe_ctx.GetProcessPtr();
  ExecutionContext exe_ctx(process);

  ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process);
  if (!objc_runtime) {
    result.AppendError("current process has no Objective-C runtime loaded");
    result.SetStatus(lldb::eReturnStatusFailed);
    return false;
  }

  ObjCLanguageRuntime::TaggedPointerVendor *tagged_ptr_vendor =
      objc_runtime->GetTaggedPointerVendor();
  if (!tagged_ptr_vendor) {
    result.AppendError("current process has no tagged pointer support");
    result.SetStatus(lldb::eReturnStatusFailed);
    return false;
  }

  for (size_t i = 0; i < command.GetArgumentCount(); i++) {
    const char *arg_str = command.GetArgumentAtIndex(i);
    if (!arg_str)
      continue;

    Status error;
    lldb::addr_t arg_addr = OptionArgParser::ToAddress(
        &exe_ctx, arg_str, LLDB_INVALID_ADDRESS(18446744073709551615UL), &error);
    if (arg_addr == 0 || arg_addr == LLDB_INVALID_ADDRESS(18446744073709551615UL) || error.Fail()) {
      result.AppendErrorWithFormatv(
          "could not convert '{0}' to a valid address\n", arg_str);
      result.SetStatus(lldb::eReturnStatusFailed);
      return false;
    }

    if (!tagged_ptr_vendor->IsPossibleTaggedPointer(arg_addr)) {
      result.GetOutputStream().Format("{0:x16} is not tagged\n", arg_addr);
      continue;
    }

    auto descriptor_sp = tagged_ptr_vendor->GetClassDescriptor(arg_addr);
    if (!descriptor_sp) {
      result.AppendErrorWithFormatv(
          "could not get class descriptor for {0:x16}\n", arg_addr);
      result.SetStatus(lldb::eReturnStatusFailed);
      return false;
    }

    uint64_t info_bits = 0;
    uint64_t value_bits = 0;
    uint64_t payload = 0;
    if (descriptor_sp->GetTaggedPointerInfo(&info_bits, &value_bits,
                                            &payload)) {
      result.GetOutputStream().Format(
          "{0:x} is tagged\n"
          "\tpayload = {1:x16}\n"
          "\tvalue = {2:x16}\n"
          "\tinfo bits = {3:x16}\n"
          "\tclass = {4}\n",
          arg_addr, payload, value_bits, info_bits,
          descriptor_sp->GetClassName().AsCString("<unknown>"));
    } else {
      result.GetOutputStream().Format("{0:x16} is not tagged\n", arg_addr);
    }
  }

  result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
  return true;
}
1097};

1099class CommandObjectMultiwordObjC_ClassTable : public CommandObjectMultiword {
1100public:
CommandObjectMultiwordObjC_ClassTable(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "class-table",
          "Commands for operating on the Objective-C class table.",
          "class-table <subcommand> [<subcommand-options>]") {
  LoadSubCommand(
      "dump",
      CommandObjectSP(new CommandObjectObjC_ClassTable_Dump(interpreter)));
}

~CommandObjectMultiwordObjC_ClassTable() override = default;
1112};

1114class CommandObjectMultiwordObjC_TaggedPointer : public CommandObjectMultiword {
1115public:
CommandObjectMultiwordObjC_TaggedPointer(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "tagged-pointer",
          "Commands for operating on Objective-C tagged pointers.",
          "class-table <subcommand> [<subcommand-options>]") {
  LoadSubCommand(
      "info",
      CommandObjectSP(
          new CommandObjectMultiwordObjC_TaggedPointer_Info(interpreter)));
}

~CommandObjectMultiwordObjC_TaggedPointer() override = default;
1128};

1130class CommandObjectMultiwordObjC : public CommandObjectMultiword {
1131public:
CommandObjectMultiwordObjC(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "objc",
          "Commands for operating on the Objective-C language runtime.",
          "objc <subcommand> [<subcommand-options>]") {
  LoadSubCommand("class-table",
                 CommandObjectSP(
                     new CommandObjectMultiwordObjC_ClassTable(interpreter)));
  LoadSubCommand("tagged-pointer",
                 CommandObjectSP(new CommandObjectMultiwordObjC_TaggedPointer(
                     interpreter)));
}

~CommandObjectMultiwordObjC() override = default;
1146};

1148void AppleObjCRuntimeV2::Initialize() {
PluginManager::RegisterPlugin(
    GetPluginNameStatic(), "Apple Objective-C Language Runtime - Version 2",
    CreateInstance,
    [](CommandInterpreter &interpreter) -> lldb::CommandObjectSP {
      return CommandObjectSP(new CommandObjectMultiwordObjC(interpreter));
    },
    GetBreakpointExceptionPrecondition);
1156}

1158void AppleObjCRuntimeV2::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
1160}

1162BreakpointResolverSP
1163AppleObjCRuntimeV2::CreateExceptionResolver(const BreakpointSP &bkpt,
                                          bool catch_bp, bool throw_bp) {
BreakpointResolverSP resolver_sp;

if (throw_bp)
  resolver_sp = std::make_shared<BreakpointResolverName>(
      bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(),
      eFunctionNameTypeBase, eLanguageTypeUnknown, Breakpoint::Exact, 0,
      eLazyBoolNo);
// FIXME: We don't do catch breakpoints for ObjC yet.
// Should there be some way for the runtime to specify what it can do in this
// regard?
return resolver_sp;
1176}

1178llvm::Expected<std::unique_ptr<UtilityFunction>>
1179AppleObjCRuntimeV2::CreateObjectChecker(std::string name,
                                      ExecutionContext &exe_ctx) {
char check_function_code[2048];

int len = 0;
if (m_has_object_getClass) {
  len = ::snprintf(check_function_code, sizeof(check_function_code), R"(
                   extern "C" void *gdb_object_getClass(void *);
                   extern "C" int printf(const char *format, ...);
                   extern "C" void
                   %s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) {
                     if ($__lldb_arg_obj == (void *)0)
                       return; // nil is ok
                     if (!gdb_object_getClass($__lldb_arg_obj)) {
                       *((volatile int *)0) = 'ocgc';
                     } else if ($__lldb_arg_selector != (void *)0) {
                       signed char $responds = (signed char)
                           [(id)$__lldb_arg_obj respondsToSelector:
                               (void *) $__lldb_arg_selector];
                       if ($responds == (signed char) 0)
                         *((volatile int *)0) = 'ocgc';
                     }
                   })",
                   name.c_str());
} else {
  len = ::snprintf(check_function_code, sizeof(check_function_code), R"(
                   extern "C" void *gdb_class_getClass(void *);
                   extern "C" int printf(const char *format, ...);
                   extern "C" void
                   %s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) {
                     if ($__lldb_arg_obj == (void *)0)
                       return; // nil is ok
                     void **$isa_ptr = (void **)$__lldb_arg_obj;
                     if (*$isa_ptr == (void *)0 ||
                         !gdb_class_getClass(*$isa_ptr))
                       *((volatile int *)0) = 'ocgc';
                     else if ($__lldb_arg_selector != (void *)0) {
                       signed char $responds = (signed char)
                           [(id)$__lldb_arg_obj respondsToSelector:
                               (void *) $__lldb_arg_selector];
                       if ($responds == (signed char) 0)
                         *((volatile int *)0) = 'ocgc';
                     }
                   })",
                   name.c_str());
}

assert(len < (int)sizeof(check_function_code))(static_cast <bool> (len < (int)sizeof(check_function_code
)) ? void (0) : __assert_fail ("len < (int)sizeof(check_function_code)"
, "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, 1226, __extension__ __PRETTY_FUNCTION__));
UNUSED_IF_ASSERT_DISABLED(len)((void)(len));

return GetTargetRef().CreateUtilityFunction(check_function_code, name,
                                            eLanguageTypeC, exe_ctx);
1231}

1233size_t AppleObjCRuntimeV2::GetByteOffsetForIvar(CompilerType &parent_ast_type,
                                              const char *ivar_name) {
uint32_t ivar_offset = LLDB_INVALID_IVAR_OFFSET(4294967295U);

ConstString class_name = parent_ast_type.GetTypeName();
if (!class_name.IsEmpty() && ivar_name && ivar_name[0]) {
  // Make the objective C V2 mangled name for the ivar offset from the class
  // name and ivar name
  std::string buffer("OBJC_IVAR_$_");
  buffer.append(class_name.AsCString());
  buffer.push_back('.');
  buffer.append(ivar_name);
  ConstString ivar_const_str(buffer.c_str());

  // Try to get the ivar offset address from the symbol table first using the
  // name we created above
  SymbolContextList sc_list;
  Target &target = m_process->GetTarget();
  target.GetImages().FindSymbolsWithNameAndType(ivar_const_str,
                                                eSymbolTypeObjCIVar, sc_list);

  addr_t ivar_offset_address = LLDB_INVALID_ADDRESS(18446744073709551615UL);

  Status error;
  SymbolContext ivar_offset_symbol;
  if (sc_list.GetSize() == 1 &&
      sc_list.GetContextAtIndex(0, ivar_offset_symbol)) {
    if (ivar_offset_symbol.symbol)
      ivar_offset_address =
          ivar_offset_symbol.symbol->GetLoadAddress(&target);
  }

  // If we didn't get the ivar offset address from the symbol table, fall
  // back to getting it from the runtime
  if (ivar_offset_address == LLDB_INVALID_ADDRESS(18446744073709551615UL))
    ivar_offset_address = LookupRuntimeSymbol(ivar_const_str);

  if (ivar_offset_address != LLDB_INVALID_ADDRESS(18446744073709551615UL))
    ivar_offset = m_process->ReadUnsignedIntegerFromMemory(
        ivar_offset_address, 4, LLDB_INVALID_IVAR_OFFSET(4294967295U), error);
}
return ivar_offset;
1275}

1277// tagged pointers are special not-a-real-pointer values that contain both type
1278// and value information this routine attempts to check with as little
1279// computational effort as possible whether something could possibly be a
1280// tagged pointer - false positives are possible but false negatives shouldn't
1281bool AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr) {
if (!m_tagged_pointer_vendor_up)
  return false;
return m_tagged_pointer_vendor_up->IsPossibleTaggedPointer(ptr);
1285}

1287class RemoteNXMapTable {
1288public:
RemoteNXMapTable() : m_end_iterator(*this, -1) {}

void Dump() {
  printf("RemoteNXMapTable.m_load_addr = 0x%" PRIx64"l" "x" "\n", m_load_addr);
  printf("RemoteNXMapTable.m_count = %u\n", m_count);
  printf("RemoteNXMapTable.m_num_buckets_minus_one = %u\n",
         m_num_buckets_minus_one);
  printf("RemoteNXMapTable.m_buckets_ptr = 0x%" PRIX64"l" "X" "\n", m_buckets_ptr);
}

bool ParseHeader(Process *process, lldb::addr_t load_addr) {
  m_process = process;
  m_load_addr = load_addr;
  m_map_pair_size = m_process->GetAddressByteSize() * 2;
  m_invalid_key =
      m_process->GetAddressByteSize() == 8 ? UINT64_MAX(18446744073709551615UL) : UINT32_MAX(4294967295U);
  Status err;

  // This currently holds true for all platforms we support, but we might
  // need to change this to use get the actually byte size of "unsigned" from
  // the target AST...
  const uint32_t unsigned_byte_size = sizeof(uint32_t);
  // Skip the prototype as we don't need it (const struct
  // +NXMapTablePrototype *prototype)

  bool success = true;
  if (load_addr == LLDB_INVALID_ADDRESS(18446744073709551615UL))
    success = false;
  else {
    lldb::addr_t cursor = load_addr + m_process->GetAddressByteSize();

    // unsigned count;
    m_count = m_process->ReadUnsignedIntegerFromMemory(
        cursor, unsigned_byte_size, 0, err);
    if (m_count) {
      cursor += unsigned_byte_size;

      // unsigned nbBucketsMinusOne;
      m_num_buckets_minus_one = m_process->ReadUnsignedIntegerFromMemory(
          cursor, unsigned_byte_size, 0, err);
      cursor += unsigned_byte_size;

      // void *buckets;
      m_buckets_ptr = m_process->ReadPointerFromMemory(cursor, err);

      success = m_count > 0 && m_buckets_ptr != LLDB_INVALID_ADDRESS(18446744073709551615UL);
    }
  }

  if (!success) {
    m_count = 0;
    m_num_buckets_minus_one = 0;
    m_buckets_ptr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
  }
  return success;
}

// const_iterator mimics NXMapState and its code comes from NXInitMapState
// and NXNextMapState.
typedef std::pair<ConstString, ObjCLanguageRuntime::ObjCISA> element;

friend class const_iterator;
class const_iterator {
public:
  const_iterator(RemoteNXMapTable &parent, int index)
      : m_parent(parent), m_index(index) {
    AdvanceToValidIndex();
  }

  const_iterator(const const_iterator &rhs)
      : m_parent(rhs.m_parent), m_index(rhs.m_index) {
    // AdvanceToValidIndex() has been called by rhs already.
  }

  const_iterator &operator=(const const_iterator &rhs) {
    // AdvanceToValidIndex() has been called by rhs already.
    assert(&m_parent == &rhs.m_parent)(static_cast <bool> (&m_parent == &rhs.m_parent
) ? void (0) : __assert_fail ("&m_parent == &rhs.m_parent"
, "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, 1365, __extension__ __PRETTY_FUNCTION__));
    m_index = rhs.m_index;
    return *this;
  }

  bool operator==(const const_iterator &rhs) const {
    if (&m_parent != &rhs.m_parent)
      return false;
    if (m_index != rhs.m_index)
      return false;

    return true;
  }

  bool operator!=(const const_iterator &rhs) const {
    return !(operator==(rhs));
  }

  const_iterator &operator++() {
    AdvanceToValidIndex();
    return *this;
  }

  const element operator*() const {
    if (m_index == -1) {
      // TODO find a way to make this an error, but not an assert
      return element();
    }

    lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
    size_t map_pair_size = m_parent.m_map_pair_size;
    lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size);

    Status err;

    lldb::addr_t key =
        m_parent.m_process->ReadPointerFromMemory(pair_ptr, err);
    if (!err.Success())
      return element();
    lldb::addr_t value = m_parent.m_process->ReadPointerFromMemory(
        pair_ptr + m_parent.m_process->GetAddressByteSize(), err);
    if (!err.Success())
      return element();

    std::string key_string;

    m_parent.m_process->ReadCStringFromMemory(key, key_string, err);
    if (!err.Success())
      return element();

    return element(ConstString(key_string.c_str()),
                   (ObjCLanguageRuntime::ObjCISA)value);
  }

private:
  void AdvanceToValidIndex() {
    if (m_index == -1)
      return;

    const lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
    const size_t map_pair_size = m_parent.m_map_pair_size;
    const lldb::addr_t invalid_key = m_parent.m_invalid_key;
    Status err;

    while (m_index--) {
      lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size);
      lldb::addr_t key =
          m_parent.m_process->ReadPointerFromMemory(pair_ptr, err);

      if (!err.Success()) {
        m_index = -1;
        return;
      }

      if (key != invalid_key)
        return;
    }
  }
  RemoteNXMapTable &m_parent;
  int m_index;
};

const_iterator begin() {
  return const_iterator(*this, m_num_buckets_minus_one + 1);
}

const_iterator end() { return m_end_iterator; }

uint32_t GetCount() const { return m_count; }

uint32_t GetBucketCount() const { return m_num_buckets_minus_one; }

lldb::addr_t GetBucketDataPointer() const { return m_buckets_ptr; }

lldb::addr_t GetTableLoadAddress() const { return m_load_addr; }

1461private:
// contents of _NXMapTable struct
uint32_t m_count = 0;
uint32_t m_num_buckets_minus_one = 0;
lldb::addr_t m_buckets_ptr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
lldb_private::Process *m_process = nullptr;
const_iterator m_end_iterator;
lldb::addr_t m_load_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
size_t m_map_pair_size = 0;
lldb::addr_t m_invalid_key = 0;
1471};

1473AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() = default;

1475void AppleObjCRuntimeV2::HashTableSignature::UpdateSignature(
  const RemoteNXMapTable &hash_table) {
m_count = hash_table.GetCount();
m_num_buckets = hash_table.GetBucketCount();
m_buckets_ptr = hash_table.GetBucketDataPointer();
1480}

1482bool AppleObjCRuntimeV2::HashTableSignature::NeedsUpdate(
  Process *process, AppleObjCRuntimeV2 *runtime,
  RemoteNXMapTable &hash_table) {
if (!hash_table.ParseHeader(process, runtime->GetISAHashTablePointer())) {
  return false; // Failed to parse the header, no need to update anything
}

// Check with out current signature and return true if the count, number of
// buckets or the hash table address changes.
if (m_count == hash_table.GetCount() &&
    m_num_buckets == hash_table.GetBucketCount() &&
    m_buckets_ptr == hash_table.GetBucketDataPointer()) {
  // Hash table hasn't changed
  return false;
}
// Hash table data has changed, we need to update
return true;
1499}

1501ObjCLanguageRuntime::ClassDescriptorSP
1502AppleObjCRuntimeV2::GetClassDescriptorFromISA(ObjCISA isa) {
ObjCLanguageRuntime::ClassDescriptorSP class_descriptor_sp;
if (auto *non_pointer_isa_cache = GetNonPointerIsaCache())
  class_descriptor_sp = non_pointer_isa_cache->GetClassDescriptor(isa);
if (!class_descriptor_sp)
  class_descriptor_sp = ObjCLanguageRuntime::GetClassDescriptorFromISA(isa);
return class_descriptor_sp;
1509}

1511ObjCLanguageRuntime::ClassDescriptorSP
1512AppleObjCRuntimeV2::GetClassDescriptor(ValueObject &valobj) {
ClassDescriptorSP objc_class_sp;
if (valobj.IsBaseClass()) {
  ValueObject *parent = valobj.GetParent();
  // if I am my own parent, bail out of here fast..
  if (parent && parent != &valobj) {
    ClassDescriptorSP parent_descriptor_sp = GetClassDescriptor(*parent);
    if (parent_descriptor_sp)
      return parent_descriptor_sp->GetSuperclass();
  }
  return nullptr;
}
// if we get an invalid VO (which might still happen when playing around with
// pointers returned by the expression parser, don't consider this a valid
// ObjC object)
if (!valobj.GetCompilerType().IsValid())
  return objc_class_sp;
addr_t isa_pointer = valobj.GetPointerValue();

// tagged pointer
if (IsTaggedPointer(isa_pointer))
  return m_tagged_pointer_vendor_up->GetClassDescriptor(isa_pointer);
ExecutionContext exe_ctx(valobj.GetExecutionContextRef());

Process *process = exe_ctx.GetProcessPtr();
if (!process)
  return objc_class_sp;

Status error;
ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error);
if (isa == LLDB_INVALID_ADDRESS(18446744073709551615UL))
  return objc_class_sp;

objc_class_sp = GetClassDescriptorFromISA(isa);
if (!objc_class_sp) {
  if (ABISP abi_sp = process->GetABI())
    isa = abi_sp->FixCodeAddress(isa);
  objc_class_sp = GetClassDescriptorFromISA(isa);
}

if (isa && !objc_class_sp) {
  Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);
  LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("0x%" "l" "x" ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "
 "not in class descriptor cache 0x%" "l" "x", isa_pointer, isa
); } while (0)
            "0x%" PRIx64 ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("0x%" "l" "x" ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "
 "not in class descriptor cache 0x%" "l" "x", isa_pointer, isa
); } while (0)
            "not in class descriptor cache 0x%" PRIx64,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("0x%" "l" "x" ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "
 "not in class descriptor cache 0x%" "l" "x", isa_pointer, isa
); } while (0)
            isa_pointer, isa)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("0x%" "l" "x" ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "
 "not in class descriptor cache 0x%" "l" "x", isa_pointer, isa
); } while (0);
}
return objc_class_sp;
1560}

1562lldb::addr_t AppleObjCRuntimeV2::GetTaggedPointerObfuscator() {
if (m_tagged_pointer_obfuscator != LLDB_INVALID_ADDRESS(18446744073709551615UL))
  return m_tagged_pointer_obfuscator;

Process *process = GetProcess();
ModuleSP objc_module_sp(GetObjCModule());

if (!objc_module_sp)
  return LLDB_INVALID_ADDRESS(18446744073709551615UL);

static ConstString g_gdb_objc_obfuscator(
    "objc_debug_taggedpointer_obfuscator");

const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(
    g_gdb_objc_obfuscator, lldb::eSymbolTypeAny);
if (symbol) {
  lldb::addr_t g_gdb_obj_obfuscator_ptr =
      symbol->GetLoadAddress(&process->GetTarget());

  if (g_gdb_obj_obfuscator_ptr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
    Status error;
    m_tagged_pointer_obfuscator =
        process->ReadPointerFromMemory(g_gdb_obj_obfuscator_ptr, error);
  }
}
// If we don't have a correct value at this point, there must be no
// obfuscation.
if (m_tagged_pointer_obfuscator == LLDB_INVALID_ADDRESS(18446744073709551615UL))
  m_tagged_pointer_obfuscator = 0;

return m_tagged_pointer_obfuscator;
1593}

1595lldb::addr_t AppleObjCRuntimeV2::GetISAHashTablePointer() {
if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
  Process *process = GetProcess();

  ModuleSP objc_module_sp(GetObjCModule());

  if (!objc_module_sp)
    return LLDB_INVALID_ADDRESS(18446744073709551615UL);

  static ConstString g_gdb_objc_realized_classes("gdb_objc_realized_classes");

  const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(
      g_gdb_objc_realized_classes, lldb::eSymbolTypeAny);
  if (symbol) {
    lldb::addr_t gdb_objc_realized_classes_ptr =
        symbol->GetLoadAddress(&process->GetTarget());

    if (gdb_objc_realized_classes_ptr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
      Status error;
      m_isa_hash_table_ptr = process->ReadPointerFromMemory(
          gdb_objc_realized_classes_ptr, error);
    }
  }
}
return m_isa_hash_table_ptr;
1620}

1622std::unique_ptr<UtilityFunction>
1623AppleObjCRuntimeV2::DynamicClassInfoExtractor::GetClassInfoUtilityFunctionImpl(
  ExecutionContext &exe_ctx, Helper helper, std::string code,
  std::string name) {
Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);

LLDB_LOG(log, "Creating utility function {0}", name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Creating utility function {0}", name); } while (
0);

TypeSystemClang *ast =
    ScratchTypeSystemClang::GetForTarget(exe_ctx.GetTargetRef());
if (!ast)
  return {};

auto utility_fn_or_error = exe_ctx.GetTargetRef().CreateUtilityFunction(
    std::move(code), std::move(name), eLanguageTypeC, exe_ctx);
if (!utility_fn_or_error) {
  LLDB_LOG_ERROR(do { ::lldb_private::Log *log_private = (log); ::llvm::Error error_private
 = (utility_fn_or_error.takeError()); if (log_private &&
 error_private) { log_private->FormatError(::std::move(error_private
), "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to get utility function for dynamic info extractor: {0}"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0)
      log, utility_fn_or_error.takeError(),do { ::lldb_private::Log *log_private = (log); ::llvm::Error error_private
 = (utility_fn_or_error.takeError()); if (log_private &&
 error_private) { log_private->FormatError(::std::move(error_private
), "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to get utility function for dynamic info extractor: {0}"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0)
      "Failed to get utility function for dynamic info extractor: {0}")do { ::lldb_private::Log *log_private = (log); ::llvm::Error error_private
 = (utility_fn_or_error.takeError()); if (log_private &&
 error_private) { log_private->FormatError(::std::move(error_private
), "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to get utility function for dynamic info extractor: {0}"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0);
  return {};
}

// Make some types for our arguments.
CompilerType clang_uint32_t_type =
    ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
CompilerType clang_void_pointer_type =
    ast->GetBasicType(eBasicTypeVoid).GetPointerType();

// Make the runner function for our implementation utility function.
ValueList arguments;
Value value;
value.SetValueType(Value::ValueType::Scalar);
value.SetCompilerType(clang_void_pointer_type);
arguments.PushValue(value);
arguments.PushValue(value);
value.SetValueType(Value::ValueType::Scalar);
value.SetCompilerType(clang_uint32_t_type);
arguments.PushValue(value);

// objc_getRealizedClassList_trylock takes an additional buffer and length.
if (helper == Helper::objc_getRealizedClassList_trylock) {
  value.SetCompilerType(clang_void_pointer_type);
  arguments.PushValue(value);
  value.SetCompilerType(clang_uint32_t_type);
  arguments.PushValue(value);
}

arguments.PushValue(value);

std::unique_ptr<UtilityFunction> utility_fn = std::move(*utility_fn_or_error);

Status error;
utility_fn->MakeFunctionCaller(clang_uint32_t_type, arguments,
                               exe_ctx.GetThreadSP(), error);

if (error.Fail()) {
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to make function caller for implementation lookup: {0}."
, error.AsCString()); } while (0)
           "Failed to make function caller for implementation lookup: {0}.",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to make function caller for implementation lookup: {0}."
, error.AsCString()); } while (0)
           error.AsCString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to make function caller for implementation lookup: {0}."
, error.AsCString()); } while (0);
  return {};
}

return utility_fn;
1685}

1687UtilityFunction *
1688AppleObjCRuntimeV2::DynamicClassInfoExtractor::GetClassInfoUtilityFunction(
  ExecutionContext &exe_ctx, Helper helper) {
switch (helper) {
case gdb_objc_realized_classes: {
  if (!m_gdb_objc_realized_classes_helper.utility_function)
    m_gdb_objc_realized_classes_helper.utility_function =
        GetClassInfoUtilityFunctionImpl(exe_ctx, helper,
                                        g_get_dynamic_class_info_body,
                                        g_get_dynamic_class_info_name);
  return m_gdb_objc_realized_classes_helper.utility_function.get();
}
case objc_copyRealizedClassList: {
  if (!m_objc_copyRealizedClassList_helper.utility_function)
    m_objc_copyRealizedClassList_helper.utility_function =
        GetClassInfoUtilityFunctionImpl(exe_ctx, helper,
                                        g_get_dynamic_class_info2_body,
                                        g_get_dynamic_class_info2_name);
  return m_objc_copyRealizedClassList_helper.utility_function.get();
}
case objc_getRealizedClassList_trylock: {
  if (!m_objc_getRealizedClassList_trylock_helper.utility_function)
    m_objc_getRealizedClassList_trylock_helper.utility_function =
        GetClassInfoUtilityFunctionImpl(exe_ctx, helper,
                                        g_get_dynamic_class_info3_body,
                                        g_get_dynamic_class_info3_name);
  return m_objc_getRealizedClassList_trylock_helper.utility_function.get();
}
}
llvm_unreachable("Unexpected helper")::llvm::llvm_unreachable_internal("Unexpected helper", "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, 1716);
1717}

1719lldb::addr_t &
1720AppleObjCRuntimeV2::DynamicClassInfoExtractor::GetClassInfoArgs(Helper helper) {
switch (helper) {
case gdb_objc_realized_classes:
  return m_gdb_objc_realized_classes_helper.args;
case objc_copyRealizedClassList:
  return m_objc_copyRealizedClassList_helper.args;
case objc_getRealizedClassList_trylock:
  return m_objc_getRealizedClassList_trylock_helper.args;
}
llvm_unreachable("Unexpected helper")::llvm::llvm_unreachable_internal("Unexpected helper", "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, 1729);
1730}

1732AppleObjCRuntimeV2::DynamicClassInfoExtractor::Helper
1733AppleObjCRuntimeV2::DynamicClassInfoExtractor::ComputeHelper(
  ExecutionContext &exe_ctx) const {
if (!m_runtime.m_has_objc_copyRealizedClassList &&
    !m_runtime.m_has_objc_getRealizedClassList_trylock)
  return DynamicClassInfoExtractor::gdb_objc_realized_classes;

if (Process *process = m_runtime.GetProcess()) {
  if (DynamicLoader *loader = process->GetDynamicLoader()) {
    if (loader->IsFullyInitialized()) {
      switch (exe_ctx.GetTargetRef().GetDynamicClassInfoHelper()) {
      case eDynamicClassInfoHelperAuto:
        [[clang::fallthrough]];
      case eDynamicClassInfoHelperGetRealizedClassList:
        if (m_runtime.m_has_objc_getRealizedClassList_trylock)
          return DynamicClassInfoExtractor::objc_getRealizedClassList_trylock;
        [[clang::fallthrough]];
      case eDynamicClassInfoHelperCopyRealizedClassList:
        if (m_runtime.m_has_objc_copyRealizedClassList)
          return DynamicClassInfoExtractor::objc_copyRealizedClassList;
        [[clang::fallthrough]];
      case eDynamicClassInfoHelperRealizedClassesStruct:
        return DynamicClassInfoExtractor::gdb_objc_realized_classes;
      }
    }
  }
}

return DynamicClassInfoExtractor::gdb_objc_realized_classes;
1761}

1763std::unique_ptr<UtilityFunction>
1764AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::
  GetClassInfoUtilityFunctionImpl(ExecutionContext &exe_ctx) {
Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);

LLDB_LOG(log, "Creating utility function {0}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Creating utility function {0}", g_get_shared_cache_class_info_name
); } while (0)
         g_get_shared_cache_class_info_name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Creating utility function {0}", g_get_shared_cache_class_info_name
); } while (0);

TypeSystemClang *ast =
    ScratchTypeSystemClang::GetForTarget(exe_ctx.GetTargetRef());
if (!ast)
  return {};

// If the inferior objc.dylib has the class_getNameRaw function, use that in
// our jitted expression.  Else fall back to the old class_getName.
static ConstString g_class_getName_symbol_name("class_getName");
static ConstString g_class_getNameRaw_symbol_name(
    "objc_debug_class_getNameRaw");

ConstString class_name_getter_function_name =
    m_runtime.HasSymbol(g_class_getNameRaw_symbol_name)
        ? g_class_getNameRaw_symbol_name
        : g_class_getName_symbol_name;

// Substitute in the correct class_getName / class_getNameRaw function name,
// concatenate the two parts of our expression text.  The format string has
// two %s's, so provide the name twice.
std::string shared_class_expression;
llvm::raw_string_ostream(shared_class_expression)
    << llvm::format(g_shared_cache_class_name_funcptr,
                    class_name_getter_function_name.AsCString(),
                    class_name_getter_function_name.AsCString());

shared_class_expression += g_get_shared_cache_class_info_body;

auto utility_fn_or_error = exe_ctx.GetTargetRef().CreateUtilityFunction(
    std::move(shared_class_expression), g_get_shared_cache_class_info_name,
    eLanguageTypeC, exe_ctx);

if (!utility_fn_or_error) {
  LLDB_LOG_ERROR(do { ::lldb_private::Log *log_private = (log); ::llvm::Error error_private
 = (utility_fn_or_error.takeError()); if (log_private &&
 error_private) { log_private->FormatError(::std::move(error_private
), "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to get utility function for shared class info extractor: {0}"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0)
      log, utility_fn_or_error.takeError(),do { ::lldb_private::Log *log_private = (log); ::llvm::Error error_private
 = (utility_fn_or_error.takeError()); if (log_private &&
 error_private) { log_private->FormatError(::std::move(error_private
), "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to get utility function for shared class info extractor: {0}"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0)
      "Failed to get utility function for shared class info extractor: {0}")do { ::lldb_private::Log *log_private = (log); ::llvm::Error error_private
 = (utility_fn_or_error.takeError()); if (log_private &&
 error_private) { log_private->FormatError(::std::move(error_private
), "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to get utility function for shared class info extractor: {0}"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0);
  return nullptr;
}

// Make some types for our arguments.
CompilerType clang_uint32_t_type =
    ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
CompilerType clang_void_pointer_type =
    ast->GetBasicType(eBasicTypeVoid).GetPointerType();
CompilerType clang_uint64_t_pointer_type =
    ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 64)
        .GetPointerType();

// Next make the function caller for our implementation utility function.
ValueList arguments;
Value value;
value.SetValueType(Value::ValueType::Scalar);
value.SetCompilerType(clang_void_pointer_type);
arguments.PushValue(value);
arguments.PushValue(value);
arguments.PushValue(value);

value.SetValueType(Value::ValueType::Scalar);
value.SetCompilerType(clang_uint64_t_pointer_type);
arguments.PushValue(value);

value.SetValueType(Value::ValueType::Scalar);
value.SetCompilerType(clang_uint32_t_type);
arguments.PushValue(value);
arguments.PushValue(value);

std::unique_ptr<UtilityFunction> utility_fn = std::move(*utility_fn_or_error);

Status error;
utility_fn->MakeFunctionCaller(clang_uint32_t_type, arguments,
                               exe_ctx.GetThreadSP(), error);

if (error.Fail()) {
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to make function caller for implementation lookup: {0}."
, error.AsCString()); } while (0)
           "Failed to make function caller for implementation lookup: {0}.",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to make function caller for implementation lookup: {0}."
, error.AsCString()); } while (0)
           error.AsCString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Failed to make function caller for implementation lookup: {0}."
, error.AsCString()); } while (0);
  return {};
}

return utility_fn;
1850}

1852UtilityFunction *
1853AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::GetClassInfoUtilityFunction(
  ExecutionContext &exe_ctx) {
if (!m_utility_function)
  m_utility_function = GetClassInfoUtilityFunctionImpl(exe_ctx);
return m_utility_function.get();
1858}

1860AppleObjCRuntimeV2::DescriptorMapUpdateResult
1861AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(
  RemoteNXMapTable &hash_table) {
Process *process = m_runtime.GetProcess();
if (process == nullptr)
  return DescriptorMapUpdateResult::Fail();

uint32_t num_class_infos = 0;

Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);

ExecutionContext exe_ctx;

ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();

if (!thread_sp)
  return DescriptorMapUpdateResult::Fail();

thread_sp->CalculateExecutionContext(exe_ctx);
TypeSystemClang *ast =
    ScratchTypeSystemClang::GetForTarget(process->GetTarget());

if (!ast)
  return DescriptorMapUpdateResult::Fail();

Address function_address;

const uint32_t addr_size = process->GetAddressByteSize();

Status err;

// Compute which helper we're going to use for this update.
const DynamicClassInfoExtractor::Helper helper = ComputeHelper(exe_ctx);

// Read the total number of classes from the hash table
const uint32_t num_classes =
    helper == DynamicClassInfoExtractor::gdb_objc_realized_classes
        ? hash_table.GetCount()
        : m_runtime.m_realized_class_generation_count;
if (num_classes == 0) {
  LLDB_LOGF(log, "No dynamic classes found.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("No dynamic classes found."); } while
 (0);
  return DescriptorMapUpdateResult::Success(0);
}

UtilityFunction *get_class_info_code =
    GetClassInfoUtilityFunction(exe_ctx, helper);
if (!get_class_info_code) {
  // The callee will have already logged a useful error message.
  return DescriptorMapUpdateResult::Fail();
}

FunctionCaller *get_class_info_function =
    get_class_info_code->GetFunctionCaller();

if (!get_class_info_function) {
  LLDB_LOGF(log, "Failed to get implementation lookup function caller.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Failed to get implementation lookup function caller."
); } while (0);
  return DescriptorMapUpdateResult::Fail();
}

ValueList arguments = get_class_info_function->GetArgumentValues();

DiagnosticManager diagnostics;

const uint32_t class_info_byte_size = addr_size + 4;
const uint32_t class_infos_byte_size = num_classes * class_info_byte_size;
lldb::addr_t class_infos_addr = process->AllocateMemory(
    class_infos_byte_size, ePermissionsReadable | ePermissionsWritable, err);

if (class_infos_addr == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
  LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_infos_byte_size); } while (0)
            "unable to allocate %" PRIu32do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_infos_byte_size); } while (0)
            " bytes in process for shared cache read",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_infos_byte_size); } while (0)
            class_infos_byte_size)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_infos_byte_size); } while (0);
  return DescriptorMapUpdateResult::Fail();
}

auto deallocate_class_infos = llvm::make_scope_exit([&] {
  // Deallocate the memory we allocated for the ClassInfo array
  if (class_infos_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL))
    process->DeallocateMemory(class_infos_addr);
});

lldb::addr_t class_buffer_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
const uint32_t class_byte_size = addr_size;
const uint32_t class_buffer_len = num_classes;
const uint32_t class_buffer_byte_size = class_buffer_len * class_byte_size;
if (helper == Helper::objc_getRealizedClassList_trylock) {
  class_buffer_addr = process->AllocateMemory(
      class_buffer_byte_size, ePermissionsReadable | ePermissionsWritable,
      err);
  if (class_buffer_addr == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
    LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_buffer_byte_size); } while (0)
              "unable to allocate %" PRIu32do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_buffer_byte_size); } while (0)
              " bytes in process for shared cache read",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_buffer_byte_size); } while (0)
              class_buffer_byte_size)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_buffer_byte_size); } while (0);
    return DescriptorMapUpdateResult::Fail();
  }
}

auto deallocate_class_buffer = llvm::make_scope_exit([&] {
  // Deallocate the memory we allocated for the Class array
  if (class_buffer_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL))
    process->DeallocateMemory(class_buffer_addr);
});

std::lock_guard<std::mutex> guard(m_mutex);

// Fill in our function argument values
uint32_t index = 0;
arguments.GetValueAtIndex(index++)->GetScalar() =
    hash_table.GetTableLoadAddress();
arguments.GetValueAtIndex(index++)->GetScalar() = class_infos_addr;
arguments.GetValueAtIndex(index++)->GetScalar() = class_infos_byte_size;

if (class_buffer_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
  arguments.GetValueAtIndex(index++)->GetScalar() = class_buffer_addr;
  arguments.GetValueAtIndex(index++)->GetScalar() = class_buffer_byte_size;
}

// Only dump the runtime classes from the expression evaluation if the log is
// verbose:
Log *type_log = GetLog(LLDBLog::Types);
bool dump_log = type_log && type_log->GetVerbose();

arguments.GetValueAtIndex(index++)->GetScalar() = dump_log ? 1 : 0;

bool success = false;

diagnostics.Clear();

// Write our function arguments into the process so we can run our function
if (get_class_info_function->WriteFunctionArguments(
        exe_ctx, GetClassInfoArgs(helper), arguments, diagnostics)) {
  EvaluateExpressionOptions options;
  options.SetUnwindOnError(true);
  options.SetTryAllThreads(false);
  options.SetStopOthers(true);
  options.SetIgnoreBreakpoints(true);
  options.SetTimeout(process->GetUtilityExpressionTimeout());
  options.SetIsForUtilityExpr(true);

  CompilerType clang_uint32_t_type =
      ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);

  Value return_value;
  return_value.SetValueType(Value::ValueType::Scalar);
  return_value.SetCompilerType(clang_uint32_t_type);
  return_value.GetScalar() = 0;

  diagnostics.Clear();

  // Run the function
  ExpressionResults results = get_class_info_function->ExecuteFunction(
      exe_ctx, &GetClassInfoArgs(helper), options, diagnostics, return_value);

  if (results == eExpressionCompleted) {
    // The result is the number of ClassInfo structures that were filled in
    num_class_infos = return_value.GetScalar().ULong();
    LLDB_LOG(log, "Discovered {0} Objective-C classes", num_class_infos)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Discovered {0} Objective-C classes", num_class_infos
); } while (0);
    if (num_class_infos > 0) {
      // Read the ClassInfo structures
      DataBufferHeap buffer(num_class_infos * class_info_byte_size, 0);
      if (process->ReadMemory(class_infos_addr, buffer.GetBytes(),
                              buffer.GetByteSize(),
                              err) == buffer.GetByteSize()) {
        DataExtractor class_infos_data(buffer.GetBytes(),
                                       buffer.GetByteSize(),
                                       process->GetByteOrder(), addr_size);
        m_runtime.ParseClassInfoArray(class_infos_data, num_class_infos);
      }
    }
    success = true;
  } else {
    if (log) {
      LLDB_LOGF(log, "Error evaluating our find class name function.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Error evaluating our find class name function."
); } while (0);
      diagnostics.Dump(log);
    }
  }
} else {
  if (log) {
    LLDB_LOGF(log, "Error writing function arguments.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Error writing function arguments.")
; } while (0);
    diagnostics.Dump(log);
  }
}

return DescriptorMapUpdateResult(success, num_class_infos);
2046}

2048uint32_t AppleObjCRuntimeV2::ParseClassInfoArray(const DataExtractor &data,
                                               uint32_t num_class_infos) {
// Parses an array of "num_class_infos" packed ClassInfo structures:
//
//    struct ClassInfo
//    {
//        Class isa;
//        uint32_t hash;
//    } __attribute__((__packed__));

Log *log = GetLog(LLDBLog::Types);
bool should_log = log && log->GetVerbose();

uint32_t num_parsed = 0;

// Iterate through all ClassInfo structures
lldb::offset_t offset = 0;
for (uint32_t i = 0; i < num_class_infos; ++i) {
  ObjCISA isa = data.GetAddress(&offset);

  if (isa == 0) {
    if (should_log)
      LLDB_LOGF(do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 found NULL isa, ignoring this class info"
); } while (0)
          log, "AppleObjCRuntimeV2 found NULL isa, ignoring this class info")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 found NULL isa, ignoring this class info"
); } while (0);
    continue;
  }
  // Check if we already know about this ISA, if we do, the info will never
  // change, so we can just skip it.
  if (ISAIsCached(isa)) {
    if (should_log)
      LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 found cached isa=0x%"
 "l" "x" ", ignoring this class info", isa); } while (0)
                "AppleObjCRuntimeV2 found cached isa=0x%" PRIx64do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 found cached isa=0x%"
 "l" "x" ", ignoring this class info", isa); } while (0)
                ", ignoring this class info",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 found cached isa=0x%"
 "l" "x" ", ignoring this class info", isa); } while (0)
                isa)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 found cached isa=0x%"
 "l" "x" ", ignoring this class info", isa); } while (0);
    offset += 4;
  } else {
    // Read the 32 bit hash for the class name
    const uint32_t name_hash = data.GetU32(&offset);
    ClassDescriptorSP descriptor_sp(
        new ClassDescriptorV2(*this, isa, nullptr));

    // The code in g_get_shared_cache_class_info_body sets the value of the
    // hash to 0 to signal a demangled symbol. We use class_getName() in that
    // code to find the class name, but this returns a demangled name for
    // Swift symbols. For those symbols, recompute the hash here by reading
    // their name from the runtime.
    if (name_hash)
      AddClass(isa, descriptor_sp, name_hash);
    else
      AddClass(isa, descriptor_sp,
               descriptor_sp->GetClassName().AsCString(nullptr));
    num_parsed++;
    if (should_log)
      LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 added isa=0x%" "l"
 "x" ", hash=0x%8.8x, name=%s", isa, name_hash, descriptor_sp
->GetClassName().AsCString("<unknown>")); } while (0
)
                "AppleObjCRuntimeV2 added isa=0x%" PRIx64do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 added isa=0x%" "l"
 "x" ", hash=0x%8.8x, name=%s", isa, name_hash, descriptor_sp
->GetClassName().AsCString("<unknown>")); } while (0
)
                ", hash=0x%8.8x, name=%s",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 added isa=0x%" "l"
 "x" ", hash=0x%8.8x, name=%s", isa, name_hash, descriptor_sp
->GetClassName().AsCString("<unknown>")); } while (0
)
                isa, name_hash,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 added isa=0x%" "l"
 "x" ", hash=0x%8.8x, name=%s", isa, name_hash, descriptor_sp
->GetClassName().AsCString("<unknown>")); } while (0
)
                descriptor_sp->GetClassName().AsCString("<unknown>"))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 added isa=0x%" "l"
 "x" ", hash=0x%8.8x, name=%s", isa, name_hash, descriptor_sp
->GetClassName().AsCString("<unknown>")); } while (0
);
  }
}
if (should_log)
  LLDB_LOGF(log, "AppleObjCRuntimeV2 parsed %" PRIu32 " class infos",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 parsed %" "u" " class infos"
, num_parsed); } while (0)
            num_parsed)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AppleObjCRuntimeV2 parsed %" "u" " class infos"
, num_parsed); } while (0);
return num_parsed;
2112}

2114bool AppleObjCRuntimeV2::HasSymbol(ConstString Name) {
if (!m_objc_module_sp)
  return false;
if (const Symbol *symbol = m_objc_module_sp->FindFirstSymbolWithNameAndType(
        Name, lldb::eSymbolTypeCode)) {
  if (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())
    return true;
}
return false;
2123}

2125AppleObjCRuntimeV2::DescriptorMapUpdateResult
2126AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap() {
Process *process = m_runtime.GetProcess();
if (process == nullptr)
  return DescriptorMapUpdateResult::Fail();

Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);

ExecutionContext exe_ctx;

ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();

if (!thread_sp)
  return DescriptorMapUpdateResult::Fail();

thread_sp->CalculateExecutionContext(exe_ctx);
TypeSystemClang *ast =
    ScratchTypeSystemClang::GetForTarget(process->GetTarget());

if (!ast)
  return DescriptorMapUpdateResult::Fail();

Address function_address;

const uint32_t addr_size = process->GetAddressByteSize();

Status err;

uint32_t num_class_infos = 0;

const lldb::addr_t objc_opt_ptr = m_runtime.GetSharedCacheReadOnlyAddress();
const lldb::addr_t shared_cache_base_addr =
    m_runtime.GetSharedCacheBaseAddress();

if (objc_opt_ptr == LLDB_INVALID_ADDRESS(18446744073709551615UL) ||
    shared_cache_base_addr == LLDB_INVALID_ADDRESS(18446744073709551615UL))
  return DescriptorMapUpdateResult::Fail();

// The number of entries to pre-allocate room for.
// Each entry is (addrsize + 4) bytes
const uint32_t max_num_classes = 163840;

UtilityFunction *get_class_info_code = GetClassInfoUtilityFunction(exe_ctx);
if (!get_class_info_code) {
  // The callee will have already logged a useful error message.
  return DescriptorMapUpdateResult::Fail();
}

FunctionCaller *get_shared_cache_class_info_function =
    get_class_info_code->GetFunctionCaller();

if (!get_shared_cache_class_info_function) {
  LLDB_LOGF(log, "Failed to get implementation lookup function caller.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Failed to get implementation lookup function caller."
); } while (0);
  return DescriptorMapUpdateResult::Fail();
}

ValueList arguments =
    get_shared_cache_class_info_function->GetArgumentValues();

DiagnosticManager diagnostics;

const uint32_t class_info_byte_size = addr_size + 4;
const uint32_t class_infos_byte_size = max_num_classes * class_info_byte_size;
lldb::addr_t class_infos_addr = process->AllocateMemory(
    class_infos_byte_size, ePermissionsReadable | ePermissionsWritable, err);
const uint32_t relative_selector_offset_addr_size = 64;
lldb::addr_t relative_selector_offset_addr =
    process->AllocateMemory(relative_selector_offset_addr_size,
                            ePermissionsReadable | ePermissionsWritable, err);

if (class_infos_addr == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
  LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_infos_byte_size); } while (0)
            "unable to allocate %" PRIu32do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_infos_byte_size); } while (0)
            " bytes in process for shared cache read",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_infos_byte_size); } while (0)
            class_infos_byte_size)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("unable to allocate %" "u" " bytes in process for shared cache read"
, class_infos_byte_size); } while (0);
  return DescriptorMapUpdateResult::Fail();
}

std::lock_guard<std::mutex> guard(m_mutex);

// Fill in our function argument values
arguments.GetValueAtIndex(0)->GetScalar() = objc_opt_ptr;
arguments.GetValueAtIndex(1)->GetScalar() = shared_cache_base_addr;
arguments.GetValueAtIndex(2)->GetScalar() = class_infos_addr;
arguments.GetValueAtIndex(3)->GetScalar() = relative_selector_offset_addr;
arguments.GetValueAtIndex(4)->GetScalar() = class_infos_byte_size;
// Only dump the runtime classes from the expression evaluation if the log is
// verbose:
Log *type_log = GetLog(LLDBLog::Types);
bool dump_log = type_log && type_log->GetVerbose();

arguments.GetValueAtIndex(5)->GetScalar() = dump_log ? 1 : 0;

bool success = false;

diagnostics.Clear();

// Write our function arguments into the process so we can run our function
if (get_shared_cache_class_info_function->WriteFunctionArguments(
        exe_ctx, m_args, arguments, diagnostics)) {
  EvaluateExpressionOptions options;
  options.SetUnwindOnError(true);
  options.SetTryAllThreads(false);
  options.SetStopOthers(true);
  options.SetIgnoreBreakpoints(true);
  options.SetTimeout(process->GetUtilityExpressionTimeout());
  options.SetIsForUtilityExpr(true);

  CompilerType clang_uint32_t_type =
      ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);

  Value return_value;
  return_value.SetValueType(Value::ValueType::Scalar);
  return_value.SetCompilerType(clang_uint32_t_type);
  return_value.GetScalar() = 0;

  diagnostics.Clear();

  // Run the function
  ExpressionResults results =
      get_shared_cache_class_info_function->ExecuteFunction(
          exe_ctx, &m_args, options, diagnostics, return_value);

  if (results == eExpressionCompleted) {
    // The result is the number of ClassInfo structures that were filled in
    num_class_infos = return_value.GetScalar().ULong();
    LLDB_LOG(log, "Discovered {0} Objective-C classes in the shared cache",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Discovered {0} Objective-C classes in the shared cache"
, num_class_infos); } while (0)
             num_class_infos)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "Discovered {0} Objective-C classes in the shared cache"
, num_class_infos); } while (0);
    // Assert if there were more classes than we pre-allocated
    // room for.
    assert(num_class_infos <= max_num_classes)(static_cast <bool> (num_class_infos <= max_num_classes
) ? void (0) : __assert_fail ("num_class_infos <= max_num_classes"
, "lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, 2255, __extension__ __PRETTY_FUNCTION__));
    if (num_class_infos > 0) {
      if (num_class_infos > max_num_classes) {
        num_class_infos = max_num_classes;

        success = false;
      } else {
        success = true;
      }

      // Read the relative selector offset.
      DataBufferHeap relative_selector_offset_buffer(64, 0);
      if (process->ReadMemory(relative_selector_offset_addr,
                              relative_selector_offset_buffer.GetBytes(),
                              relative_selector_offset_buffer.GetByteSize(),
                              err) ==
          relative_selector_offset_buffer.GetByteSize()) {
        DataExtractor relative_selector_offset_data(
            relative_selector_offset_buffer.GetBytes(),
            relative_selector_offset_buffer.GetByteSize(),
            process->GetByteOrder(), addr_size);
        lldb::offset_t offset = 0;
        uint64_t relative_selector_offset =
            relative_selector_offset_data.GetU64(&offset);
        if (relative_selector_offset > 0) {
          // The offset is relative to the objc_opt struct.
          m_runtime.SetRelativeSelectorBaseAddr(objc_opt_ptr +
                                                relative_selector_offset);
        }
      }

      // Read the ClassInfo structures
      DataBufferHeap class_infos_buffer(
          num_class_infos * class_info_byte_size, 0);
      if (process->ReadMemory(class_infos_addr, class_infos_buffer.GetBytes(),
                              class_infos_buffer.GetByteSize(),
                              err) == class_infos_buffer.GetByteSize()) {
        DataExtractor class_infos_data(class_infos_buffer.GetBytes(),
                                       class_infos_buffer.GetByteSize(),
                                       process->GetByteOrder(), addr_size);

        m_runtime.ParseClassInfoArray(class_infos_data, num_class_infos);
      }
    } else {
      success = true;
    }
  } else {
    if (log) {
      LLDB_LOGF(log, "Error evaluating our find class name function.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Error evaluating our find class name function."
); } while (0);
      diagnostics.Dump(log);
    }
  }
} else {
  if (log) {
    LLDB_LOGF(log, "Error writing function arguments.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Error writing function arguments.")
; } while (0);
    diagnostics.Dump(log);
  }
}

// Deallocate the memory we allocated for the ClassInfo array
process->DeallocateMemory(class_infos_addr);

return DescriptorMapUpdateResult(success, num_class_infos);
2318}

2320lldb::addr_t AppleObjCRuntimeV2::GetSharedCacheReadOnlyAddress() {
Process *process = GetProcess();

if (process) {
  ModuleSP objc_module_sp(GetObjCModule());

  if (objc_module_sp) {
    ObjectFile *objc_object = objc_module_sp->GetObjectFile();

    if (objc_object) {
      SectionList *section_list = objc_module_sp->GetSectionList();

      if (section_list) {
        SectionSP text_segment_sp(
            section_list->FindSectionByName(ConstString("__TEXT")));

        if (text_segment_sp) {
          SectionSP objc_opt_section_sp(
              text_segment_sp->GetChildren().FindSectionByName(
                  ConstString("__objc_opt_ro")));

          if (objc_opt_section_sp) {
            return objc_opt_section_sp->GetLoadBaseAddress(
                &process->GetTarget());
          }
        }
      }
    }
  }
}
return LLDB_INVALID_ADDRESS(18446744073709551615UL);
2351}

2353lldb::addr_t AppleObjCRuntimeV2::GetSharedCacheBaseAddress() {
StructuredData::ObjectSP info = m_process->GetSharedCacheInfo();
if (!info)
  return LLDB_INVALID_ADDRESS(18446744073709551615UL);

StructuredData::Dictionary *info_dict = info->GetAsDictionary();
if (!info_dict)
  return LLDB_INVALID_ADDRESS(18446744073709551615UL);

StructuredData::ObjectSP value =
    info_dict->GetValueForKey("shared_cache_base_address");
if (!value)
  return LLDB_INVALID_ADDRESS(18446744073709551615UL);

return value->GetIntegerValue(LLDB_INVALID_ADDRESS(18446744073709551615UL));
2368}

2370void AppleObjCRuntimeV2::UpdateISAToDescriptorMapIfNeeded() {
LLDB_SCOPED_TIMER()static ::lldb_private::Timer::Category _cat(__PRETTY_FUNCTION__
); ::lldb_private::Timer _scoped_timer(_cat, "%s", __PRETTY_FUNCTION__
);

Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);

// Else we need to check with our process to see when the map was updated.
Process *process = GetProcess();

if (process) {
  RemoteNXMapTable hash_table;

  // Update the process stop ID that indicates the last time we updated the
  // map, whether it was successful or not.
  m_isa_to_descriptor_stop_id = process->GetStopID();

  // Ask the runtime is the realized class generation count changed. Unlike
  // the hash table, this accounts for lazily named classes.
  const bool class_count_changed = RealizedClassGenerationCountChanged();

  if (!m_hash_signature.NeedsUpdate(process, this, hash_table) &&
      !class_count_changed)
    return;

  m_hash_signature.UpdateSignature(hash_table);

  // Grab the dynamically loaded Objective-C classes from memory.
  DescriptorMapUpdateResult dynamic_update_result =
      m_dynamic_class_info_extractor.UpdateISAToDescriptorMap(hash_table);

  // Now get the objc classes that are baked into the Objective-C runtime in
  // the shared cache, but only once per process as this data never changes
  if (!m_loaded_objc_opt) {
    // it is legitimately possible for the shared cache to be empty - in that
    // case, the dynamic hash table will contain all the class information we
    // need; the situation we're trying to detect is one where we aren't
    // seeing class information from the runtime - in order to detect that
    // vs. just the shared cache being empty or sparsely populated, we set an
    // arbitrary (very low) threshold for the number of classes that we want
    // to see in a "good" scenario - anything below that is suspicious
    // (Foundation alone has thousands of classes)
    const uint32_t num_classes_to_warn_at = 500;

    DescriptorMapUpdateResult shared_cache_update_result =
        m_shared_cache_class_info_extractor.UpdateISAToDescriptorMap();

    LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("attempted to read objc class data - results: "
 "[dynamic_update]: ran: %s, count: %" "u" " [shared_cache_update]: ran: %s, count: %"
 "u", dynamic_update_result.m_update_ran ? "yes" : "no", dynamic_update_result
.m_num_found, shared_cache_update_result.m_update_ran ? "yes"
 : "no", shared_cache_update_result.m_num_found); } while (0)
              "attempted to read objc class data - results: "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("attempted to read objc class data - results: "
 "[dynamic_update]: ran: %s, count: %" "u" " [shared_cache_update]: ran: %s, count: %"
 "u", dynamic_update_result.m_update_ran ? "yes" : "no", dynamic_update_result
.m_num_found, shared_cache_update_result.m_update_ran ? "yes"
 : "no", shared_cache_update_result.m_num_found); } while (0)
              "[dynamic_update]: ran: %s, count: %" PRIu32do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("attempted to read objc class data - results: "
 "[dynamic_update]: ran: %s, count: %" "u" " [shared_cache_update]: ran: %s, count: %"
 "u", dynamic_update_result.m_update_ran ? "yes" : "no", dynamic_update_result
.m_num_found, shared_cache_update_result.m_update_ran ? "yes"
 : "no", shared_cache_update_result.m_num_found); } while (0)
              " [shared_cache_update]: ran: %s, count: %" PRIu32,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("attempted to read objc class data - results: "
 "[dynamic_update]: ran: %s, count: %" "u" " [shared_cache_update]: ran: %s, count: %"
 "u", dynamic_update_result.m_update_ran ? "yes" : "no", dynamic_update_result
.m_num_found, shared_cache_update_result.m_update_ran ? "yes"
 : "no", shared_cache_update_result.m_num_found); } while (0)
              dynamic_update_result.m_update_ran ? "yes" : "no",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("attempted to read objc class data - results: "
 "[dynamic_update]: ran: %s, count: %" "u" " [shared_cache_update]: ran: %s, count: %"
 "u", dynamic_update_result.m_update_ran ? "yes" : "no", dynamic_update_result
.m_num_found, shared_cache_update_result.m_update_ran ? "yes"
 : "no", shared_cache_update_result.m_num_found); } while (0)
              dynamic_update_result.m_num_found,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("attempted to read objc class data - results: "
 "[dynamic_update]: ran: %s, count: %" "u" " [shared_cache_update]: ran: %s, count: %"
 "u", dynamic_update_result.m_update_ran ? "yes" : "no", dynamic_update_result
.m_num_found, shared_cache_update_result.m_update_ran ? "yes"
 : "no", shared_cache_update_result.m_num_found); } while (0)
              shared_cache_update_result.m_update_ran ? "yes" : "no",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("attempted to read objc class data - results: "
 "[dynamic_update]: ran: %s, count: %" "u" " [shared_cache_update]: ran: %s, count: %"
 "u", dynamic_update_result.m_update_ran ? "yes" : "no", dynamic_update_result
.m_num_found, shared_cache_update_result.m_update_ran ? "yes"
 : "no", shared_cache_update_result.m_num_found); } while (0)
              shared_cache_update_result.m_num_found)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("attempted to read objc class data - results: "
 "[dynamic_update]: ran: %s, count: %" "u" " [shared_cache_update]: ran: %s, count: %"
 "u", dynamic_update_result.m_update_ran ? "yes" : "no", dynamic_update_result
.m_num_found, shared_cache_update_result.m_update_ran ? "yes"
 : "no", shared_cache_update_result.m_num_found); } while (0);

    // warn if:
    // - we could not run either expression
    // - we found fewer than num_classes_to_warn_at classes total
    if ((!shared_cache_update_result.m_update_ran) ||
        (!dynamic_update_result.m_update_ran))
      WarnIfNoClassesCached(
          SharedCacheWarningReason::eExpressionExecutionFailure);
    else if (dynamic_update_result.m_num_found +
                 shared_cache_update_result.m_num_found <
             num_classes_to_warn_at)
      WarnIfNoClassesCached(SharedCacheWarningReason::eNotEnoughClassesRead);
    else
      m_loaded_objc_opt = true;
  }
} else {
  m_isa_to_descriptor_stop_id = UINT32_MAX(4294967295U);
}
2441}

2443bool AppleObjCRuntimeV2::RealizedClassGenerationCountChanged() {
Process *process = GetProcess();
if (!process)
  return false;

Status error;
uint64_t objc_debug_realized_class_generation_count =
    ExtractRuntimeGlobalSymbol(
        process, ConstString("objc_debug_realized_class_generation_count"),
        GetObjCModule(), error);
if (error.Fail())
  return false;

if (m_realized_class_generation_count ==
    objc_debug_realized_class_generation_count)
  return false;

Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);
LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "objc_debug_realized_class_generation_count changed from {0} to {1}"
, m_realized_class_generation_count, objc_debug_realized_class_generation_count
); } while (0)
         "objc_debug_realized_class_generation_count changed from {0} to {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "objc_debug_realized_class_generation_count changed from {0} to {1}"
, m_realized_class_generation_count, objc_debug_realized_class_generation_count
); } while (0)
         m_realized_class_generation_count,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "objc_debug_realized_class_generation_count changed from {0} to {1}"
, m_realized_class_generation_count, objc_debug_realized_class_generation_count
); } while (0)
         objc_debug_realized_class_generation_count)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp"
, __func__, "objc_debug_realized_class_generation_count changed from {0} to {1}"
, m_realized_class_generation_count, objc_debug_realized_class_generation_count
); } while (0);

m_realized_class_generation_count =
    objc_debug_realized_class_generation_count;

return true;
2470}

2472static bool DoesProcessHaveSharedCache(Process &process) {
PlatformSP platform_sp = process.GetTarget().GetPlatform();
if (!platform_sp)
  return true; // this should not happen

llvm::StringRef platform_plugin_name_sr = platform_sp->GetPluginName();
if (platform_plugin_name_sr.endswith("-simulator"))
  return false;

return true;
2482}

2484void AppleObjCRuntimeV2::WarnIfNoClassesCached(
  SharedCacheWarningReason reason) {
if (GetProcess() && !DoesProcessHaveSharedCache(*GetProcess())) {
  // Simulators do not have the objc_opt_ro class table so don't actually
  // complain to the user
  return;
}

Debugger &debugger(GetProcess()->GetTarget().GetDebugger());
switch (reason) {
case SharedCacheWarningReason::eNotEnoughClassesRead:
  Debugger::ReportWarning("could not find Objective-C class data in "
                          "the process. This may reduce the quality of type "
                          "information available.\n",
                          debugger.GetID(), &m_no_classes_cached_warning);
  break;
case SharedCacheWarningReason::eExpressionExecutionFailure:
  Debugger::ReportWarning(
      "could not execute support code to read "
      "Objective-C class data in the process. This may "
      "reduce the quality of type information available.\n",
      debugger.GetID(), &m_no_classes_cached_warning);
  break;
}
2508}

2510void AppleObjCRuntimeV2::WarnIfNoExpandedSharedCache() {
if (!m_objc_module_sp)
  return;

ObjectFile *object_file = m_objc_module_sp->GetObjectFile();
if (!object_file)
  return;

if (!object_file->IsInMemory())
  return;

Target &target = GetProcess()->GetTarget();
Debugger &debugger = target.GetDebugger();

std::string buffer;
llvm::raw_string_ostream os(buffer);

os << "libobjc.A.dylib is being read from process memory. This "
      "indicates that LLDB could not ";
if (PlatformSP platform_sp = target.GetPlatform()) {
  if (platform_sp->IsHost()) {
    os << "read from the host's in-memory shared cache";
  } else {
    os << "find the on-disk shared cache for this device";
  }
} else {
  os << "read from the shared cache";
}
os << ". This will likely reduce debugging performance.\n";

Debugger::ReportWarning(os.str(), debugger.GetID(),
                        &m_no_expanded_cache_warning);
2542}

2544DeclVendor *AppleObjCRuntimeV2::GetDeclVendor() {
if (!m_decl_vendor_up)
  m_decl_vendor_up = std::make_unique<AppleObjCDeclVendor>(*this);

return m_decl_vendor_up.get();
2549}

2551lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(ConstString name) {
lldb::addr_t ret = LLDB_INVALID_ADDRESS(18446744073709551615UL);

const char *name_cstr = name.AsCString();

if (name_cstr) {
  llvm::StringRef name_strref(name_cstr);

  llvm::StringRef ivar_prefix("OBJC_IVAR_$_");
  llvm::StringRef class_prefix("OBJC_CLASS_$_");

  if (name_strref.startswith(ivar_prefix)) {
    llvm::StringRef ivar_skipped_prefix =
        name_strref.substr(ivar_prefix.size());
    std::pair<llvm::StringRef, llvm::StringRef> class_and_ivar =
        ivar_skipped_prefix.split('.');

    if (class_and_ivar.first.size() && class_and_ivar.second.size()) {
      const ConstString class_name_cs(class_and_ivar.first);
      ClassDescriptorSP descriptor =
          ObjCLanguageRuntime::GetClassDescriptorFromClassName(class_name_cs);

      if (descriptor) {
        const ConstString ivar_name_cs(class_and_ivar.second);
        const char *ivar_name_cstr = ivar_name_cs.AsCString();

        auto ivar_func = [&ret,
                          ivar_name_cstr](const char *name, const char *type,
                                          lldb::addr_t offset_addr,
                                          uint64_t size) -> lldb::addr_t {
          if (!strcmp(name, ivar_name_cstr)) {
            ret = offset_addr;
            return true;
          }
          return false;
        };

        descriptor->Describe(
            std::function<void(ObjCISA)>(nullptr),
            std::function<bool(const char *, const char *)>(nullptr),
            std::function<bool(const char *, const char *)>(nullptr),
            ivar_func);
      }
    }
  } else if (name_strref.startswith(class_prefix)) {
    llvm::StringRef class_skipped_prefix =
        name_strref.substr(class_prefix.size());
    const ConstString class_name_cs(class_skipped_prefix);
    ClassDescriptorSP descriptor =
        GetClassDescriptorFromClassName(class_name_cs);

    if (descriptor)
      ret = descriptor->GetISA();
  }
}

return ret;
2608}

2610AppleObjCRuntimeV2::NonPointerISACache *
2611AppleObjCRuntimeV2::NonPointerISACache::CreateInstance(
  AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp) {
Process *process(runtime.GetProcess());

Status error;

Log *log = GetLog(LLDBLog::Types);

auto objc_debug_isa_magic_mask = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_isa_magic_mask"), objc_module_sp, error);
if (error.Fail())
  return nullptr;

auto objc_debug_isa_magic_value = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_isa_magic_value"), objc_module_sp,
    error);
if (error.Fail())
  return nullptr;

auto objc_debug_isa_class_mask = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_isa_class_mask"), objc_module_sp, error);
if (error.Fail())
  return nullptr;

if (log)
  log->PutCString("AOCRT::NPI: Found all the non-indexed ISA masks");

bool foundError = false;
auto objc_debug_indexed_isa_magic_mask = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_indexed_isa_magic_mask"), objc_module_sp,
    error);
foundError |= error.Fail();

auto objc_debug_indexed_isa_magic_value = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_indexed_isa_magic_value"),
    objc_module_sp, error);
foundError |= error.Fail();

auto objc_debug_indexed_isa_index_mask = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_indexed_isa_index_mask"), objc_module_sp,
    error);
foundError |= error.Fail();

auto objc_debug_indexed_isa_index_shift = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_indexed_isa_index_shift"),
    objc_module_sp, error);
foundError |= error.Fail();

auto objc_indexed_classes =
    ExtractRuntimeGlobalSymbol(process, ConstString("objc_indexed_classes"),
                               objc_module_sp, error, false);
foundError |= error.Fail();

if (log)
  log->PutCString("AOCRT::NPI: Found all the indexed ISA masks");

// we might want to have some rules to outlaw these other values (e.g if the
// mask is zero but the value is non-zero, ...)

return new NonPointerISACache(
    runtime, objc_module_sp, objc_debug_isa_class_mask,
    objc_debug_isa_magic_mask, objc_debug_isa_magic_value,
    objc_debug_indexed_isa_magic_mask, objc_debug_indexed_isa_magic_value,
    objc_debug_indexed_isa_index_mask, objc_debug_indexed_isa_index_shift,
    foundError ? 0 : objc_indexed_classes);
2676}

2678AppleObjCRuntimeV2::TaggedPointerVendorV2 *
2679AppleObjCRuntimeV2::TaggedPointerVendorV2::CreateInstance(
  AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp) {
Process *process(runtime.GetProcess());

Status error;

auto objc_debug_taggedpointer_mask = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_taggedpointer_mask"), objc_module_sp,
    error);
if (error.Fail())
  return new TaggedPointerVendorLegacy(runtime);

auto objc_debug_taggedpointer_slot_shift = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_taggedpointer_slot_shift"),
    objc_module_sp, error, true, 4);
if (error.Fail())
  return new TaggedPointerVendorLegacy(runtime);

auto objc_debug_taggedpointer_slot_mask = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_taggedpointer_slot_mask"),
    objc_module_sp, error, true, 4);
if (error.Fail())
  return new TaggedPointerVendorLegacy(runtime);

auto objc_debug_taggedpointer_payload_lshift = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_taggedpointer_payload_lshift"),
    objc_module_sp, error, true, 4);
if (error.Fail())
  return new TaggedPointerVendorLegacy(runtime);

auto objc_debug_taggedpointer_payload_rshift = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_taggedpointer_payload_rshift"),
    objc_module_sp, error, true, 4);
if (error.Fail())
  return new TaggedPointerVendorLegacy(runtime);

auto objc_debug_taggedpointer_classes = ExtractRuntimeGlobalSymbol(
    process, ConstString("objc_debug_taggedpointer_classes"), objc_module_sp,
    error, false);
if (error.Fail())
  return new TaggedPointerVendorLegacy(runtime);

// try to detect the "extended tagged pointer" variables - if any are
// missing, use the non-extended vendor
do {
  auto objc_debug_taggedpointer_ext_mask = ExtractRuntimeGlobalSymbol(
      process, ConstString("objc_debug_taggedpointer_ext_mask"),
      objc_module_sp, error);
  if (error.Fail())
    break;

  auto objc_debug_taggedpointer_ext_slot_shift = ExtractRuntimeGlobalSymbol(
      process, ConstString("objc_debug_taggedpointer_ext_slot_shift"),
      objc_module_sp, error, true, 4);
  if (error.Fail())
    break;

  auto objc_debug_taggedpointer_ext_slot_mask = ExtractRuntimeGlobalSymbol(
      process, ConstString("objc_debug_taggedpointer_ext_slot_mask"),
      objc_module_sp, error, true, 4);
  if (error.Fail())
    break;

  auto objc_debug_taggedpointer_ext_classes = ExtractRuntimeGlobalSymbol(
      process, ConstString("objc_debug_taggedpointer_ext_classes"),
      objc_module_sp, error, false);
  if (error.Fail())
    break;

  auto objc_debug_taggedpointer_ext_payload_lshift =
      ExtractRuntimeGlobalSymbol(
          process, ConstString("objc_debug_taggedpointer_ext_payload_lshift"),
          objc_module_sp, error, true, 4);
  if (error.Fail())
    break;

  auto objc_debug_taggedpointer_ext_payload_rshift =
      ExtractRuntimeGlobalSymbol(
          process, ConstString("objc_debug_taggedpointer_ext_payload_rshift"),
          objc_module_sp, error, true, 4);
  if (error.Fail())
    break;

  return new TaggedPointerVendorExtended(
      runtime, objc_debug_taggedpointer_mask,
      objc_debug_taggedpointer_ext_mask, objc_debug_taggedpointer_slot_shift,
      objc_debug_taggedpointer_ext_slot_shift,
      objc_debug_taggedpointer_slot_mask,
      objc_debug_taggedpointer_ext_slot_mask,
      objc_debug_taggedpointer_payload_lshift,
      objc_debug_taggedpointer_payload_rshift,
      objc_debug_taggedpointer_ext_payload_lshift,
      objc_debug_taggedpointer_ext_payload_rshift,
      objc_debug_taggedpointer_classes, objc_debug_taggedpointer_ext_classes);
} while (false);

// we might want to have some rules to outlaw these values (e.g if the
// table's address is zero)

return new TaggedPointerVendorRuntimeAssisted(
    runtime, objc_debug_taggedpointer_mask,
    objc_debug_taggedpointer_slot_shift, objc_debug_taggedpointer_slot_mask,
    objc_debug_taggedpointer_payload_lshift,
    objc_debug_taggedpointer_payload_rshift,
    objc_debug_taggedpointer_classes);
2784}

2786bool AppleObjCRuntimeV2::TaggedPointerVendorLegacy::IsPossibleTaggedPointer(
  lldb::addr_t ptr) {
return (ptr & 1);
2789}

2791ObjCLanguageRuntime::ClassDescriptorSP
2792AppleObjCRuntimeV2::TaggedPointerVendorLegacy::GetClassDescriptor(
  lldb::addr_t ptr) {
if (!IsPossibleTaggedPointer(ptr))
  return ObjCLanguageRuntime::ClassDescriptorSP();

uint32_t foundation_version = m_runtime.GetFoundationVersion();

if (foundation_version == LLDB_INVALID_MODULE_VERSION(4294967295U))
  return ObjCLanguageRuntime::ClassDescriptorSP();

uint64_t class_bits = (ptr & 0xE) >> 1;
ConstString name;

static ConstString g_NSAtom("NSAtom");
static ConstString g_NSNumber("NSNumber");
static ConstString g_NSDateTS("NSDateTS");
static ConstString g_NSManagedObject("NSManagedObject");
static ConstString g_NSDate("NSDate");

if (foundation_version >= 900) {
  switch (class_bits) {
  case 0:
    name = g_NSAtom;
    break;
  case 3:
    name = g_NSNumber;
    break;
  case 4:
    name = g_NSDateTS;
    break;
  case 5:
    name = g_NSManagedObject;
    break;
  case 6:
    name = g_NSDate;
    break;
  default:
    return ObjCLanguageRuntime::ClassDescriptorSP();
  }
} else {
  switch (class_bits) {
  case 1:
    name = g_NSNumber;
    break;
  case 5:
    name = g_NSManagedObject;
    break;
  case 6:
    name = g_NSDate;
    break;
  case 7:
    name = g_NSDateTS;
    break;
  default:
    return ObjCLanguageRuntime::ClassDescriptorSP();
  }
}

lldb::addr_t unobfuscated = ptr ^ m_runtime.GetTaggedPointerObfuscator();
return ClassDescriptorSP(new ClassDescriptorV2Tagged(name, unobfuscated));
2852}

2854AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::
  TaggedPointerVendorRuntimeAssisted(
      AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
      uint32_t objc_debug_taggedpointer_slot_shift,
      uint32_t objc_debug_taggedpointer_slot_mask,
      uint32_t objc_debug_taggedpointer_payload_lshift,
      uint32_t objc_debug_taggedpointer_payload_rshift,
      lldb::addr_t objc_debug_taggedpointer_classes)
  : TaggedPointerVendorV2(runtime), m_cache(),
    m_objc_debug_taggedpointer_mask(objc_debug_taggedpointer_mask),
    m_objc_debug_taggedpointer_slot_shift(
        objc_debug_taggedpointer_slot_shift),
    m_objc_debug_taggedpointer_slot_mask(objc_debug_taggedpointer_slot_mask),
    m_objc_debug_taggedpointer_payload_lshift(
        objc_debug_taggedpointer_payload_lshift),
    m_objc_debug_taggedpointer_payload_rshift(
        objc_debug_taggedpointer_payload_rshift),
    m_objc_debug_taggedpointer_classes(objc_debug_taggedpointer_classes) {}

2873bool AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::
  IsPossibleTaggedPointer(lldb::addr_t ptr) {
return (ptr & m_objc_debug_taggedpointer_mask) != 0;
2876}

2878ObjCLanguageRuntime::ClassDescriptorSP
2879AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(
  lldb::addr_t ptr) {
ClassDescriptorSP actual_class_descriptor_sp;
uint64_t unobfuscated = (ptr) ^ m_runtime.GetTaggedPointerObfuscator();

if (!IsPossibleTaggedPointer(unobfuscated))
  return ObjCLanguageRuntime::ClassDescriptorSP();

uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_slot_shift) &
                 m_objc_debug_taggedpointer_slot_mask;

CacheIterator iterator = m_cache.find(slot), end = m_cache.end();
if (iterator != end) {
  actual_class_descriptor_sp = iterator->second;
} else {
  Process *process(m_runtime.GetProcess());
  uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
                       m_objc_debug_taggedpointer_classes;
  Status error;
  uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
  if (error.Fail() || slot_data == 0 ||
      slot_data == uintptr_t(LLDB_INVALID_ADDRESS(18446744073709551615UL)))
    return nullptr;
  actual_class_descriptor_sp =
      m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
  if (!actual_class_descriptor_sp) {
    if (ABISP abi_sp = process->GetABI()) {
      ObjCISA fixed_isa = abi_sp->FixCodeAddress((ObjCISA)slot_data);
      actual_class_descriptor_sp =
          m_runtime.GetClassDescriptorFromISA(fixed_isa);
    }
  }
  if (!actual_class_descriptor_sp)
    return ObjCLanguageRuntime::ClassDescriptorSP();
  m_cache[slot] = actual_class_descriptor_sp;
}

uint64_t data_payload =
    ((unobfuscated << m_objc_debug_taggedpointer_payload_lshift) >>
     m_objc_debug_taggedpointer_payload_rshift);
int64_t data_payload_signed =
    ((int64_t)(unobfuscated << m_objc_debug_taggedpointer_payload_lshift) >>
     m_objc_debug_taggedpointer_payload_rshift);
return ClassDescriptorSP(new ClassDescriptorV2Tagged(
    actual_class_descriptor_sp, data_payload, data_payload_signed));
2924}

2926AppleObjCRuntimeV2::TaggedPointerVendorExtended::TaggedPointerVendorExtended(
  AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
  uint64_t objc_debug_taggedpointer_ext_mask,
  uint32_t objc_debug_taggedpointer_slot_shift,
  uint32_t objc_debug_taggedpointer_ext_slot_shift,
  uint32_t objc_debug_taggedpointer_slot_mask,
  uint32_t objc_debug_taggedpointer_ext_slot_mask,
  uint32_t objc_debug_taggedpointer_payload_lshift,
  uint32_t objc_debug_taggedpointer_payload_rshift,
  uint32_t objc_debug_taggedpointer_ext_payload_lshift,
  uint32_t objc_debug_taggedpointer_ext_payload_rshift,
  lldb::addr_t objc_debug_taggedpointer_classes,
  lldb::addr_t objc_debug_taggedpointer_ext_classes)
  : TaggedPointerVendorRuntimeAssisted(
        runtime, objc_debug_taggedpointer_mask,
        objc_debug_taggedpointer_slot_shift,
        objc_debug_taggedpointer_slot_mask,
        objc_debug_taggedpointer_payload_lshift,
        objc_debug_taggedpointer_payload_rshift,
        objc_debug_taggedpointer_classes),
    m_ext_cache(),
    m_objc_debug_taggedpointer_ext_mask(objc_debug_taggedpointer_ext_mask),
    m_objc_debug_taggedpointer_ext_slot_shift(
        objc_debug_taggedpointer_ext_slot_shift),
    m_objc_debug_taggedpointer_ext_slot_mask(
        objc_debug_taggedpointer_ext_slot_mask),
    m_objc_debug_taggedpointer_ext_payload_lshift(
        objc_debug_taggedpointer_ext_payload_lshift),
    m_objc_debug_taggedpointer_ext_payload_rshift(
        objc_debug_taggedpointer_ext_payload_rshift),
    m_objc_debug_taggedpointer_ext_classes(
        objc_debug_taggedpointer_ext_classes) {}

2959bool AppleObjCRuntimeV2::TaggedPointerVendorExtended::
  IsPossibleExtendedTaggedPointer(lldb::addr_t ptr) {
if (!IsPossibleTaggedPointer(ptr))
  return false;

if (m_objc_debug_taggedpointer_ext_mask == 0)
  return false;

return ((ptr & m_objc_debug_taggedpointer_ext_mask) ==
        m_objc_debug_taggedpointer_ext_mask);
2969}

2971ObjCLanguageRuntime::ClassDescriptorSP
2972AppleObjCRuntimeV2::TaggedPointerVendorExtended::GetClassDescriptor(
  lldb::addr_t ptr) {
ClassDescriptorSP actual_class_descriptor_sp;
uint64_t unobfuscated = (ptr) ^ m_runtime.GetTaggedPointerObfuscator();

if (!IsPossibleTaggedPointer(unobfuscated))
  return ObjCLanguageRuntime::ClassDescriptorSP();

if (!IsPossibleExtendedTaggedPointer(unobfuscated))
  return this->TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(ptr);

uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_ext_slot_shift) &
                 m_objc_debug_taggedpointer_ext_slot_mask;

CacheIterator iterator = m_ext_cache.find(slot), end = m_ext_cache.end();
if (iterator != end) {
  actual_class_descriptor_sp = iterator->second;
} else {
  Process *process(m_runtime.GetProcess());
  uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
                       m_objc_debug_taggedpointer_ext_classes;
  Status error;
  uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
  if (error.Fail() || slot_data == 0 ||
      slot_data == uintptr_t(LLDB_INVALID_ADDRESS(18446744073709551615UL)))
    return nullptr;
  actual_class_descriptor_sp =
      m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
  if (!actual_class_descriptor_sp)
    return ObjCLanguageRuntime::ClassDescriptorSP();
  m_ext_cache[slot] = actual_class_descriptor_sp;
}

uint64_t data_payload = (((uint64_t)unobfuscated
                          << m_objc_debug_taggedpointer_ext_payload_lshift) >>
                         m_objc_debug_taggedpointer_ext_payload_rshift);
int64_t data_payload_signed =
    ((int64_t)((int64_t)unobfuscated
               << m_objc_debug_taggedpointer_ext_payload_lshift) >>
     m_objc_debug_taggedpointer_ext_payload_rshift);

return ClassDescriptorSP(new ClassDescriptorV2Tagged(
    actual_class_descriptor_sp, data_payload, data_payload_signed));
3015}

3017AppleObjCRuntimeV2::NonPointerISACache::NonPointerISACache(
  AppleObjCRuntimeV2 &runtime, const ModuleSP &objc_module_sp,
  uint64_t objc_debug_isa_class_mask, uint64_t objc_debug_isa_magic_mask,
  uint64_t objc_debug_isa_magic_value,
  uint64_t objc_debug_indexed_isa_magic_mask,
  uint64_t objc_debug_indexed_isa_magic_value,
  uint64_t objc_debug_indexed_isa_index_mask,
  uint64_t objc_debug_indexed_isa_index_shift,
  lldb::addr_t objc_indexed_classes)
  : m_runtime(runtime), m_cache(), m_objc_module_wp(objc_module_sp),
    m_objc_debug_isa_class_mask(objc_debug_isa_class_mask),
    m_objc_debug_isa_magic_mask(objc_debug_isa_magic_mask),
    m_objc_debug_isa_magic_value(objc_debug_isa_magic_value),
    m_objc_debug_indexed_isa_magic_mask(objc_debug_indexed_isa_magic_mask),
    m_objc_debug_indexed_isa_magic_value(objc_debug_indexed_isa_magic_value),
    m_objc_debug_indexed_isa_index_mask(objc_debug_indexed_isa_index_mask),
    m_objc_debug_indexed_isa_index_shift(objc_debug_indexed_isa_index_shift),
    m_objc_indexed_classes(objc_indexed_classes), m_indexed_isa_cache() {}

3036ObjCLanguageRuntime::ClassDescriptorSP
3037AppleObjCRuntimeV2::NonPointerISACache::GetClassDescriptor(ObjCISA isa) {
ObjCISA real_isa = 0;
if (!EvaluateNonPointerISA(isa, real_isa))
  return ObjCLanguageRuntime::ClassDescriptorSP();
auto cache_iter = m_cache.find(real_isa);
if (cache_iter != m_cache.end())
  return cache_iter->second;
auto descriptor_sp =
    m_runtime.ObjCLanguageRuntime::GetClassDescriptorFromISA(real_isa);
if (descriptor_sp) // cache only positive matches since the table might grow
  m_cache[real_isa] = descriptor_sp;
return descriptor_sp;
3049}

3051bool AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA(
  ObjCISA isa, ObjCISA &ret_isa) {
Log *log = GetLog(LLDBLog::Types);

LLDB_LOGF(log, "AOCRT::NPI Evaluate(isa = 0x%" PRIx64 ")", (uint64_t)isa)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI Evaluate(isa = 0x%" "l" "x"
 ")", (uint64_t)isa); } while (0);

if ((isa & ~m_objc_debug_isa_class_mask) == 0)
  return false;

// If all of the indexed ISA variables are set, then its possible that this
// ISA is indexed, and we should first try to get its value using the index.
// Note, we check these variables first as the ObjC runtime will set at least
// one of their values to 0 if they aren't needed.
if (m_objc_debug_indexed_isa_magic_mask &&
    m_objc_debug_indexed_isa_magic_value &&
    m_objc_debug_indexed_isa_index_mask &&
    m_objc_debug_indexed_isa_index_shift && m_objc_indexed_classes) {
  if ((isa & ~m_objc_debug_indexed_isa_index_mask) == 0)
    return false;

  if ((isa & m_objc_debug_indexed_isa_magic_mask) ==
      m_objc_debug_indexed_isa_magic_value) {
    // Magic bits are correct, so try extract the index.
    uintptr_t index = (isa & m_objc_debug_indexed_isa_index_mask) >>
                      m_objc_debug_indexed_isa_index_shift;
    // If the index is out of bounds of the length of the array then check if
    // the array has been updated.  If that is the case then we should try
    // read the count again, and update the cache if the count has been
    // updated.
    if (index > m_indexed_isa_cache.size()) {
      LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI (index = %" "l" "u" ") exceeds cache (size = %"
 "l" "u" ")", (uint64_t)index, (uint64_t)m_indexed_isa_cache.
size()); } while (0)
                "AOCRT::NPI (index = %" PRIu64do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI (index = %" "l" "u" ") exceeds cache (size = %"
 "l" "u" ")", (uint64_t)index, (uint64_t)m_indexed_isa_cache.
size()); } while (0)
                ") exceeds cache (size = %" PRIu64 ")",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI (index = %" "l" "u" ") exceeds cache (size = %"
 "l" "u" ")", (uint64_t)index, (uint64_t)m_indexed_isa_cache.
size()); } while (0)
                (uint64_t)index, (uint64_t)m_indexed_isa_cache.size())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI (index = %" "l" "u" ") exceeds cache (size = %"
 "l" "u" ")", (uint64_t)index, (uint64_t)m_indexed_isa_cache.
size()); } while (0);

      Process *process(m_runtime.GetProcess());

      ModuleSP objc_module_sp(m_objc_module_wp.lock());
      if (!objc_module_sp)
        return false;

      Status error;
      auto objc_indexed_classes_count = ExtractRuntimeGlobalSymbol(
          process, ConstString("objc_indexed_classes_count"), objc_module_sp,
          error);
      if (error.Fail())
        return false;

      LLDB_LOGF(log, "AOCRT::NPI (new class count = %" PRIu64 ")",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI (new class count = %" "l"
 "u" ")", (uint64_t)objc_indexed_classes_count); } while (0)
                (uint64_t)objc_indexed_classes_count)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI (new class count = %" "l"
 "u" ")", (uint64_t)objc_indexed_classes_count); } while (0);

      if (objc_indexed_classes_count > m_indexed_isa_cache.size()) {
        // Read the class entries we don't have.  We should just read all of
        // them instead of just the one we need as then we can cache those we
        // may need later.
        auto num_new_classes =
            objc_indexed_classes_count - m_indexed_isa_cache.size();
        const uint32_t addr_size = process->GetAddressByteSize();
        DataBufferHeap buffer(num_new_classes * addr_size, 0);

        lldb::addr_t last_read_class =
            m_objc_indexed_classes + (m_indexed_isa_cache.size() * addr_size);
        size_t bytes_read = process->ReadMemory(
            last_read_class, buffer.GetBytes(), buffer.GetByteSize(), error);
        if (error.Fail() || bytes_read != buffer.GetByteSize())
          return false;

        LLDB_LOGF(log, "AOCRT::NPI (read new classes count = %" PRIu64 ")",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI (read new classes count = %"
 "l" "u" ")", (uint64_t)num_new_classes); } while (0)
                  (uint64_t)num_new_classes)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI (read new classes count = %"
 "l" "u" ")", (uint64_t)num_new_classes); } while (0);

        // Append the new entries to the existing cache.
        DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(),
                           process->GetByteOrder(),
                           process->GetAddressByteSize());

        lldb::offset_t offset = 0;
        for (unsigned i = 0; i != num_new_classes; ++i)
          m_indexed_isa_cache.push_back(data.GetAddress(&offset));
      }
    }

    // If the index is still out of range then this isn't a pointer.
    if (index > m_indexed_isa_cache.size())
      return false;

    LLDB_LOGF(log, "AOCRT::NPI Evaluate(ret_isa = 0x%" PRIx64 ")",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI Evaluate(ret_isa = 0x%" "l"
 "x" ")", (uint64_t)m_indexed_isa_cache[index]); } while (0)
              (uint64_t)m_indexed_isa_cache[index])do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("AOCRT::NPI Evaluate(ret_isa = 0x%" "l"
 "x" ")", (uint64_t)m_indexed_isa_cache[index]); } while (0);

    ret_isa = m_indexed_isa_cache[index];
    return (ret_isa != 0); // this is a pointer so 0 is not a valid value
  }

  return false;
}

// Definitely not an indexed ISA, so try to use a mask to extract the pointer
// from the ISA.
if ((isa & m_objc_debug_isa_magic_mask) == m_objc_debug_isa_magic_value) {
  ret_isa = isa & m_objc_debug_isa_class_mask;
  return (ret_isa != 0); // this is a pointer so 0 is not a valid value
}
return false;
3153}

3155ObjCLanguageRuntime::EncodingToTypeSP AppleObjCRuntimeV2::GetEncodingToType() {
if (!m_encoding_to_type_sp)
  m_encoding_to_type_sp =
      std::make_shared<AppleObjCTypeEncodingParser>(*this);
return m_encoding_to_type_sp;
3160}

3162lldb_private::AppleObjCRuntime::ObjCISA
3163AppleObjCRuntimeV2::GetPointerISA(ObjCISA isa) {
ObjCISA ret = isa;

if (auto *non_pointer_isa_cache = GetNonPointerIsaCache())
  non_pointer_isa_cache->EvaluateNonPointerISA(isa, ret);

return ret;
3170}

3172bool AppleObjCRuntimeV2::GetCFBooleanValuesIfNeeded() {
if (m_CFBoolean_values)
  return true;

static ConstString g_dunder_kCFBooleanFalse("__kCFBooleanFalse");
static ConstString g_dunder_kCFBooleanTrue("__kCFBooleanTrue");
static ConstString g_kCFBooleanFalse("kCFBooleanFalse");
static ConstString g_kCFBooleanTrue("kCFBooleanTrue");

std::function<lldb::addr_t(ConstString, ConstString)> get_symbol =
    [this](ConstString sym, ConstString real_sym) -> lldb::addr_t {
  SymbolContextList sc_list;
  GetProcess()->GetTarget().GetImages().FindSymbolsWithNameAndType(
      sym, lldb::eSymbolTypeData, sc_list);
  if (sc_list.GetSize() == 1) {
    SymbolContext sc;
    sc_list.GetContextAtIndex(0, sc);
    if (sc.symbol)
      return sc.symbol->GetLoadAddress(&GetProcess()->GetTarget());
  }
  GetProcess()->GetTarget().GetImages().FindSymbolsWithNameAndType(
      real_sym, lldb::eSymbolTypeData, sc_list);
  if (sc_list.GetSize() != 1)
    return LLDB_INVALID_ADDRESS(18446744073709551615UL);

  SymbolContext sc;
  sc_list.GetContextAtIndex(0, sc);
  if (!sc.symbol)
    return LLDB_INVALID_ADDRESS(18446744073709551615UL);

  lldb::addr_t addr = sc.symbol->GetLoadAddress(&GetProcess()->GetTarget());
  Status error;
  addr = GetProcess()->ReadPointerFromMemory(addr, error);
  if (error.Fail())
    return LLDB_INVALID_ADDRESS(18446744073709551615UL);
  return addr;
};

lldb::addr_t false_addr = get_symbol(g_dunder_kCFBooleanFalse, g_kCFBooleanFalse);
lldb::addr_t true_addr = get_symbol(g_dunder_kCFBooleanTrue, g_kCFBooleanTrue);

return (m_CFBoolean_values = {false_addr, true_addr}).operator bool();
3214}

3216void AppleObjCRuntimeV2::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
                                                    lldb::addr_t &cf_false) {
if (GetCFBooleanValuesIfNeeded()) {
  cf_true = m_CFBoolean_values->second;
  cf_false = m_CFBoolean_values->first;
} else
  this->AppleObjCRuntime::GetValuesForGlobalCFBooleans(cf_true, cf_false);
3223}

3225#pragma mark Frame recognizers

3227class ObjCExceptionRecognizedStackFrame : public RecognizedStackFrame {
3228public:
ObjCExceptionRecognizedStackFrame(StackFrameSP frame_sp) {
  ThreadSP thread_sp = frame_sp->GetThread();
  ProcessSP process_sp = thread_sp->GetProcess();

  const lldb::ABISP &abi = process_sp->GetABI();
  if (!abi)
2
←
Taking false branch→
    return;

  TypeSystemClang *clang_ast_context =
      ScratchTypeSystemClang::GetForTarget(process_sp->GetTarget());
  if (!clang_ast_context)
3
←
Assuming 'clang_ast_context' is non-null→
4
←
Taking false branch→
    return;
  CompilerType voidstar =
      clang_ast_context->GetBasicType(lldb::eBasicTypeVoid).GetPointerType();

  ValueList args;
  Value input_value;
  input_value.SetCompilerType(voidstar);
  args.PushValue(input_value);

  if (!abi->GetArgumentValues(*thread_sp, args))
5
←
Assuming the condition is false→
6
←
Taking false branch→
    return;

  addr_t exception_addr = args.GetValueAtIndex(0)->GetScalar().ULongLong();

  Value value(exception_addr);
  value.SetCompilerType(voidstar);
  exception = ValueObjectConstResult::Create(frame_sp.get(), value,
                                             ConstString("exception"));
  exception = ValueObjectRecognizerSynthesizedValue::Create(
7
←
Calling 'ValueObjectRecognizerSynthesizedValue::Create'→
      *exception, eValueTypeVariableArgument);
  exception = exception->GetDynamicValue(eDynamicDontRunTarget);

  m_arguments = ValueObjectListSP(new ValueObjectList());
  m_arguments->Append(exception);

  m_stop_desc = "hit Objective-C exception";
}

ValueObjectSP exception;

lldb::ValueObjectSP GetExceptionObject() override { return exception; }
3271};

3273class ObjCExceptionThrowFrameRecognizer : public StackFrameRecognizer {
lldb::RecognizedStackFrameSP
RecognizeFrame(lldb::StackFrameSP frame) override {
  return lldb::RecognizedStackFrameSP(
      new ObjCExceptionRecognizedStackFrame(frame));
1
Calling constructor for 'ObjCExceptionRecognizedStackFrame'→
};
std::string GetName() override {
  return "ObjC Exception Throw StackFrame Recognizer";
}
3282};

3284static void RegisterObjCExceptionRecognizer(Process *process) {
FileSpec module;
ConstString function;
std::tie(module, function) = AppleObjCRuntime::GetExceptionThrowLocation();
std::vector<ConstString> symbols = {function};

process->GetTarget().GetFrameRecognizerManager().AddRecognizer(
    StackFrameRecognizerSP(new ObjCExceptionThrowFrameRecognizer()),
    module.GetFilename(), symbols,
    /*first_instruction_only*/ true);
3294}

←

/build/llvm-toolchain-snapshot-16~++20220816100716+b5a18de65169/lldb/include/lldb/Target/StackFrameRecognizer.h

1//===-- StackFrameRecognizer.h ----------------------------------*- C++ -*-===//
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#ifndef LLDB_TARGET_STACKFRAMERECOGNIZER_H
10#define LLDB_TARGET_STACKFRAMERECOGNIZER_H
11 
12#include "lldb/Core/ValueObject.h"
13#include "lldb/Core/ValueObjectList.h"
14#include "lldb/Symbol/VariableList.h"
15#include "lldb/Target/StopInfo.h"
16#include "lldb/Utility/StructuredData.h"
17#include "lldb/lldb-private-forward.h"
18#include "lldb/lldb-public.h"
19 
20#include <vector>
21 
22namespace lldb_private {
23 
24/// \class RecognizedStackFrame
25///
26/// This class provides extra information about a stack frame that was
27/// provided by a specific stack frame recognizer. Right now, this class only
28/// holds recognized arguments (via GetRecognizedArguments).
29 
30class RecognizedStackFrame
31    : public std::enable_shared_from_this<RecognizedStackFrame> {
32public:
33  virtual lldb::ValueObjectListSP GetRecognizedArguments() {
34    return m_arguments;
35  }
36  virtual lldb::ValueObjectSP GetExceptionObject() {
37    return lldb::ValueObjectSP();
38  }
39  virtual lldb::StackFrameSP GetMostRelevantFrame() { return nullptr; };
40  virtual ~RecognizedStackFrame() = default;
41 
42  std::string GetStopDescription() { return m_stop_desc; }
43 
44protected:
45  lldb::ValueObjectListSP m_arguments;
46  std::string m_stop_desc;
47};
48 
49/// \class StackFrameRecognizer
50///
51/// A base class for frame recognizers. Subclasses (actual frame recognizers)
52/// should implement RecognizeFrame to provide a RecognizedStackFrame for a
53/// given stack frame.
54 
55class StackFrameRecognizer
56    : public std::enable_shared_from_this<StackFrameRecognizer> {
57public:
58  virtual lldb::RecognizedStackFrameSP RecognizeFrame(
59      lldb::StackFrameSP frame) {
60    return lldb::RecognizedStackFrameSP();
61  };
62  virtual std::string GetName() {
63    return "";
64  }
65 
66  virtual ~StackFrameRecognizer() = default;
67};
68 
69/// \class ScriptedStackFrameRecognizer
70///
71/// Python implementation for frame recognizers. An instance of this class
72/// tracks a particular Python classobject, which will be asked to recognize
73/// stack frames.
74 
75class ScriptedStackFrameRecognizer : public StackFrameRecognizer {
76  lldb_private::ScriptInterpreter *m_interpreter;
77  lldb_private::StructuredData::ObjectSP m_python_object_sp;
78  std::string m_python_class;
79 
80public:
81  ScriptedStackFrameRecognizer(lldb_private::ScriptInterpreter *interpreter,
82                               const char *pclass);
83  ~ScriptedStackFrameRecognizer() override = default;
84 
85  std::string GetName() override {
86    return GetPythonClassName();
87  }
88 
89  const char *GetPythonClassName() { return m_python_class.c_str(); }
90 
91  lldb::RecognizedStackFrameSP RecognizeFrame(
92      lldb::StackFrameSP frame) override;
93 
94private:
95  ScriptedStackFrameRecognizer(const ScriptedStackFrameRecognizer &) = delete;
96  const ScriptedStackFrameRecognizer &
97  operator=(const ScriptedStackFrameRecognizer &) = delete;
98};
99 
100/// Class that provides a registry of known stack frame recognizers.
101class StackFrameRecognizerManager {
102public:
103  void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
104                     ConstString module, llvm::ArrayRef<ConstString> symbols,
105                     bool first_instruction_only = true);
106 
107  void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
108                     lldb::RegularExpressionSP module,
109                     lldb::RegularExpressionSP symbol,
110                     bool first_instruction_only = true);
111 
112  void ForEach(std::function<
113               void(uint32_t recognizer_id, std::string recognizer_name,
114                    std::string module, llvm::ArrayRef<ConstString> symbols,
115                    bool regexp)> const &callback);
116 
117  bool RemoveRecognizerWithID(uint32_t recognizer_id);
118 
119  void RemoveAllRecognizers();
120 
121  lldb::StackFrameRecognizerSP GetRecognizerForFrame(lldb::StackFrameSP frame);
122 
123  lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame);
124 
125private:
126  struct RegisteredEntry {
127    uint32_t recognizer_id;
128    lldb::StackFrameRecognizerSP recognizer;
129    bool is_regexp;
130    ConstString module;
131    lldb::RegularExpressionSP module_regexp;
132    std::vector<ConstString> symbols;
133    lldb::RegularExpressionSP symbol_regexp;
134    bool first_instruction_only;
135  };
136 
137  std::deque<RegisteredEntry> m_recognizers;
138};
139 
140/// \class ValueObjectRecognizerSynthesizedValue
141///
142/// ValueObject subclass that presents the passed ValueObject as a recognized
143/// value with the specified ValueType. Frame recognizers should return
144/// instances of this class as the returned objects in GetRecognizedArguments().
145 
146class ValueObjectRecognizerSynthesizedValue : public ValueObject {
147 public:
148  static lldb::ValueObjectSP Create(ValueObject &parent, lldb::ValueType type) {
149    return (new ValueObjectRecognizerSynthesizedValue(parent, type))->GetSP();
8
←
Memory is allocated→
9
←
Potential memory leak
150  }
151  ValueObjectRecognizerSynthesizedValue(ValueObject &parent,
152                                        lldb::ValueType type)
153      : ValueObject(parent), m_type(type) {
154    SetName(parent.GetName());
155  }
156 
157  llvm::Optional<uint64_t> GetByteSize() override {
158    return m_parent->GetByteSize();
159  }
160  lldb::ValueType GetValueType() const override { return m_type; }
161  bool UpdateValue() override {
162    if (!m_parent->UpdateValueIfNeeded()) return false;
163    m_value = m_parent->GetValue();
164    return true;
165  }
166  size_t CalculateNumChildren(uint32_t max = UINT32_MAX(4294967295U)) override {
167    return m_parent->GetNumChildren(max);
168  }
169  CompilerType GetCompilerTypeImpl() override {
170    return m_parent->GetCompilerType();
171  }
172  bool IsSynthetic() override { return true; }
173 
174 private:
175  lldb::ValueType m_type;
176};
177 
178} // namespace lldb_private
179 
180#endif // LLDB_TARGET_STACKFRAMERECOGNIZER_H