[lldb] Upstream support for Foundation constant classes

[JDevlieghere]

Summary

Upstream support for NSConstantArray, NSConstantIntegerNumber, NSConstant{Float,Double}Number and NSConstantDictionary. We would've upstreamed this earlier but testing it requires -fno-constant-nsnumber-literals, -fno-constant-nsarray-literals and -fno-constant-nsdictionary-literals which haven't been upstreamed yet. As a temporary workaround use the system compiler (xcrun clang) for the constant variant of the tests.

I'm just upstreaming this. The patch and the tests were all authored by Fred Riss.

[jingham]

Just a few little nits.

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

509

Shouldn't this be done with a DataExtractor? The code is assuming that you can get a valid host float by pasting target bytes into a host float. While most likely everybody is using the same float & double representations these days, that doesn't seem like something we should rely on.

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

908–913

These are pointers, shouldn't we be using ReadPointerFromMemory?

[JDevlieghere]

• Use ReadPointerFromMemory

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

509

This seems pretty common across the existing code. I agree we should fix that, but probably as a follow-up patch that fixes this across the whole file.

[jingham]

If the float/double pattern wasn't introduced here, then it's fine by me to fix it in a follow-on patch.
Otherwise, LGTM.

[saugustine]

This change breaks various build bots with a missing file. See below. Reverting shortly.

For example:

https://lab.llvm.org/buildbot/#/builders/68/builds/16816

/usr/bin/clang++ -DGTEST_HAS_RTTI=0 -DHAVE_ROUND -D_DEBUG -D_GNU_SOURCE -DSTDC_CONSTANT_MACROS -DSTDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/lldb/source/Plugins/Language/ObjC -I/home/worker/2.0.1/lldb-x86_64-debian/llvm-project/lldb/source/Plugins/Language/ObjC -Itools/lldb/source -I/home/worker/2.0.1/lldb-x86_64-debian/llvm-project/lldb/include -Itools/lldb/include -Iinclude -I/home/worker/2.0.1/lldb-x86_64-debian/llvm-project/llvm/include -I/usr/include/python3.7m -I/home/worker/2.0.1/lldb-x86_64-debian/llvm-project/llvm/../clang/include -Itools/lldb/../clang/include -I/home/worker/2.0.1/lldb-x86_64-debian/llvm-project/lldb/source/. -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -O3 -DNDEBUG -fno-exceptions -fno-rtti -UNDEBUG -std=c++14 -MD -MT tools/lldb/source/Plugins/Language/ObjC/CMakeFiles/lldbPluginObjCLanguage.dir/Cocoa.cpp.o -MF tools/lldb/source/Plugins/Language/ObjC/CMakeFiles/lldbPluginObjCLanguage.dir/Cocoa.cpp.o.d -o tools/lldb/source/Plugins/Language/ObjC/CMakeFiles/lldbPluginObjCLanguage.dir/Cocoa.cpp.o -c /home/worker/2.0.1/lldb-x86_64-debian/llvm-project/lldb/source/Plugins/Language/ObjC/Cocoa.cpp
/home/worker/2.0.1/lldb-x86_64-debian/llvm-project/lldb/source/Plugins/Language/ObjC/Cocoa.cpp:10:10: fatal error: 'objc/runtime.h' file not found
#include "objc/runtime.h"

^~~~~~~~~~~~~~~~

[JDevlieghere]

Yep, I'm looking into it.

[saugustine]

Thanks for looking. Reverted with 4e5af6ef48590e7248e344ddabf245bb3de71c51.

[JDevlieghere]

In D107660#2932321, @saugustine wrote:

Thanks for looking. Reverted with 4e5af6ef48590e7248e344ddabf245bb3de71c51.

What's the point of giving a heads up if you're goin to revert it immediately, even after you know I'm already looking into it? To be clear, I have no issue with the revert-to-green policy, I do it all the time myself, but if you're going to do that, you might as well revert it right away and skip the heads up.

[saugustine]

Some people complain if I revert without notification. So I always notify as soon as I find the patch with the problem. Some reverts are more complicated than others too.

I guess it adds more noise but I try to default to more communication over less.

[JDevlieghere]

In D107660#2932334, @saugustine wrote:

Some people complain if I revert without notification. So I always notify as soon as I find the patch with the problem. Some reverts are more complicated than others too.

I guess it adds more noise but I try to default to more communication over less.

Gotcha, I was genuinely curious, thanks for the context.

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

 //===-- Cocoa.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Cocoa.h"
+#include "objc/runtime.h"
 
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeSummary.h"
if (class_name.empty())
     return false;
 
   if (class_name == "__NSCFBoolean")
     return ObjCBooleanSummaryProvider(valobj, stream, options);
 
   if (class_name == "NSDecimalNumber")
     return NSDecimalNumberSummaryProvider(valobj, stream, options);
 
+  if (class_name == "NSConstantIntegerNumber") {
+    Status error;
+    int64_t value = process_sp->ReadSignedIntegerFromMemory(
+        valobj_addr + 2 * ptr_size, 8, 0, error);
+    if (error.Fail())
+      return false;
+    uint64_t encoding_addr = process_sp->ReadUnsignedIntegerFromMemory(
+        valobj_addr + ptr_size, ptr_size, 0, error);
+    if (error.Fail())
+      return false;
+    char encoding =
+        process_sp->ReadUnsignedIntegerFromMemory(encoding_addr, 1, 0, error);
+    if (error.Fail())
+      return false;
+
+    switch (encoding) {
+    case _C_CHR:
+      NSNumber_FormatChar(valobj, stream, (char)value, options.GetLanguage());
+      return true;
+    case _C_SHT:
+      NSNumber_FormatShort(valobj, stream, (short)value, options.GetLanguage());
+      return true;
+    case _C_INT:
+      NSNumber_FormatInt(valobj, stream, (int)value, options.GetLanguage());
+      return true;
+    case _C_LNG:
+    case _C_LNG_LNG:
+      NSNumber_FormatLong(valobj, stream, value, options.GetLanguage());
+      return true;
+
+    case _C_UCHR:
+    case _C_USHT:
+    case _C_UINT:
+    case _C_ULNG:
+    case _C_ULNG_LNG:
+      stream.Printf("%" PRIu64, value);
+      return true;
+    }
+
+    return false;
+  }
+
+  if (class_name == "NSConstantFloatNumber") {
+    Status error;
+    uint32_t flt_as_int = process_sp->ReadUnsignedIntegerFromMemory(
+        valobj_addr + ptr_size, 4, 0, error);
+    if (error.Fail())
+      return false;
+    float flt_value = 0.0f;
+    memcpy(&flt_value, &flt_as_int, sizeof(flt_as_int));
+    NSNumber_FormatFloat(valobj, stream, flt_value, options.GetLanguage());
+    return true;
+  }
+
+  if (class_name == "NSConstantDoubleNumber") {
+    Status error;
+    uint64_t dbl_as_lng = process_sp->ReadUnsignedIntegerFromMemory(
+        valobj_addr + ptr_size, 8, 0, error);
+    if (error.Fail())
+      return false;
+    double dbl_value = 0.0;
+    memcpy(&dbl_value, &dbl_as_lng, sizeof(dbl_as_lng));
+    NSNumber_FormatDouble(valobj, stream, dbl_value, options.GetLanguage());
+    return true;
+  }
+
   if (class_name == "NSNumber" || class_name == "__NSCFNumber") {
     int64_t value = 0;
     uint64_t i_bits = 0;
     if (descriptor->GetTaggedPointerInfoSigned(&i_bits, &value)) {
       // Check for "preserved" numbers.  We still don't support them yet.
       if (i_bits & 0x8) {
         if (log)
           log->Printf(

lldb/source/Plugins/Language/ObjC/NSArray.cpp

namespace Foundation1436 {
 
     uint64_t
     __NSFrozenArrayMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
                          Status &error) {
       return Foundation1437::__NSArrayMSize(process, valobj_addr, error);
     }
 }
 
+namespace ConstantArray {
+
+struct ConstantArray32 {
+  uint64_t used;
+  uint32_t list;
+};
+
+struct ConstantArray64 {
+  uint64_t used;
+  uint64_t list;
+};
+
+using NSConstantArraySyntheticFrontEnd =
+    GenericNSArrayISyntheticFrontEnd<ConstantArray32, ConstantArray64, false>;
+} // namespace ConstantArray
+
 class NSArray0SyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSArray0SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
   ~NSArray0SyntheticFrontEnd() override = default;
 
   size_t CalculateNumChildren() override;
 
bool lldb_private::formatters::NSArraySummaryProvider(
   static const ConstString g_NSArrayI_Transfer("__NSArrayI_Transfer");
   static const ConstString g_NSFrozenArrayM("__NSFrozenArrayM");
   static const ConstString g_NSArray0("__NSArray0");
   static const ConstString g_NSArray1("__NSSingleObjectArrayI");
   static const ConstString g_NSArrayCF("__NSCFArray");
   static const ConstString g_NSArrayMLegacy("__NSArrayM_Legacy");
   static const ConstString g_NSArrayMImmutable("__NSArrayM_Immutable");
   static const ConstString g_NSCallStackArray("_NSCallStackArray");
+  static const ConstString g_NSConstantArray("NSConstantArray");
 
   if (class_name.IsEmpty())
     return false;
 
   if (class_name == g_NSArrayI) {
     Status error;
     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
                                                       ptr_size, 0, error);
     if (error.Fail())
       return false;
+  } else if (class_name == g_NSConstantArray) {
+    Status error;
+    value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, 8,
+                                                      0, error);
+    if (error.Fail())
+      return false;
   } else if (class_name == g_NSArrayM) {
     AppleObjCRuntime *apple_runtime =
     llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
     Status error;
     if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {
       value = Foundation1437::__NSArrayMSize(*process_sp, valobj_addr, error);
     } else {
       value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(*valobj_sp));
 
   if (!descriptor || !descriptor->IsValid())
     return nullptr;
 
   ConstString class_name(descriptor->GetClassName());
 
   static const ConstString g_NSArrayI("__NSArrayI");
+  static const ConstString g_NSConstantArray("NSConstantArray");
   static const ConstString g_NSArrayI_Transfer("__NSArrayI_Transfer");
   static const ConstString g_NSFrozenArrayM("__NSFrozenArrayM");
   static const ConstString g_NSArrayM("__NSArrayM");
   static const ConstString g_NSArray0("__NSArray0");
   static const ConstString g_NSArray1("__NSSingleObjectArrayI");
   static const ConstString g_NSArrayMLegacy("__NSArrayM_Legacy");
   static const ConstString g_NSArrayMImmutable("__NSArrayM_Immutable");
   static const ConstString g_NSCallStackArray("_NSCallStackArray");
 
   if (class_name.IsEmpty())
     return nullptr;
 
   if (class_name == g_NSArrayI) {
     if (runtime->GetFoundationVersion() >= 1436)
       return (new Foundation1436::NSArrayISyntheticFrontEnd(valobj_sp));
     if (runtime->GetFoundationVersion() >= 1430)
       return (new Foundation1430::NSArrayISyntheticFrontEnd(valobj_sp));
     return (new Foundation1300::NSArrayISyntheticFrontEnd(valobj_sp));
   } else if (class_name == g_NSArrayI_Transfer) {
       return (new Foundation1436::NSArrayI_TransferSyntheticFrontEnd(valobj_sp));
+  } else if (class_name == g_NSConstantArray) {
+    return new ConstantArray::NSConstantArraySyntheticFrontEnd(valobj_sp);
   } else if (class_name == g_NSFrozenArrayM) {
     return (new Foundation1436::NSFrozenArrayMSyntheticFrontEnd(valobj_sp));
   } else if (class_name == g_NSArray0) {
     return (new NSArray0SyntheticFrontEnd(valobj_sp));
   } else if (class_name == g_NSArray1) {
     return (new NSArray1SyntheticFrontEnd(valobj_sp));
   } else if (class_name == g_NSArrayM) {
     if (runtime->GetFoundationVersion() >= 1437)

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

private:
   lldb::ByteOrder m_order;
   DataDescriptor_32 *m_data_32;
   DataDescriptor_64 *m_data_64;
   lldb::addr_t m_data_ptr;
   CompilerType m_pair_type;
   std::vector<DictionaryItemDescriptor> m_children;
 };
 
+class NSConstantDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+  NSConstantDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
+
+  size_t CalculateNumChildren() override;
+
+  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
+
+  bool Update() override;
+
+  bool MightHaveChildren() override;
+
+  size_t GetIndexOfChildWithName(ConstString name) override;
+
+private:
+  ExecutionContextRef m_exe_ctx_ref;
+  CompilerType m_pair_type;
+  uint8_t m_ptr_size = 8;
+  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;
+  unsigned int m_size = 0;
+  lldb::addr_t m_keys_ptr = LLDB_INVALID_ADDRESS;
+  lldb::addr_t m_objects_ptr = LLDB_INVALID_ADDRESS;
+
+  struct DictionaryItemDescriptor {
+    lldb::addr_t key_ptr;
+    lldb::addr_t val_ptr;
+    lldb::ValueObjectSP valobj_sp;
+  };
+
+  std::vector<DictionaryItemDescriptor> m_children;
+};
+
 class NSCFDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSCFDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
   size_t CalculateNumChildren() override;
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 
bool lldb_private::formatters::NSDictionarySummaryProvider(
   static const ConstString g_DictionaryMLegacy("__NSDictionaryM_Legacy");
   static const ConstString g_DictionaryMImmutable("__NSDictionaryM_Immutable");
   static const ConstString g_DictionaryMFrozen("__NSFrozenDictionaryM");
   static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI");
   static const ConstString g_Dictionary0("__NSDictionary0");
   static const ConstString g_DictionaryCF("__CFDictionary");
   static const ConstString g_DictionaryNSCF("__NSCFDictionary");
   static const ConstString g_DictionaryCFRef("CFDictionaryRef");
+  static const ConstString g_ConstantDictionary("NSConstantDictionary");
 
   if (class_name.IsEmpty())
     return false;
 
   if (class_name == g_DictionaryI || class_name == g_DictionaryMImmutable) {
     Status error;
     value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
                                                       ptr_size, 0, error);
     if (error.Fail())
       return false;
 
     value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
-  } else if (class_name == g_DictionaryM || class_name == g_DictionaryMLegacy 
-             || class_name == g_DictionaryMFrozen) {
+  } else if (class_name == g_ConstantDictionary) {
+    Status error;
+    value = process_sp->ReadUnsignedIntegerFromMemory(
+        valobj_addr + 2 * ptr_size, ptr_size, 0, error);
+    if (error.Fail())
+      return false;
+  } else if (class_name == g_DictionaryM || class_name == g_DictionaryMLegacy ||
+             class_name == g_DictionaryMFrozen) {
     AppleObjCRuntime *apple_runtime =
     llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
     Status error;
     if (apple_runtime && apple_runtime->GetFoundationVersion() >= 1437) {
       value = Foundation1437::__NSDictionaryMSize(*process_sp, valobj_addr,
                                                   error);
     } else {
       value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size,
                                                         ptr_size, 0, error);
       value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
     }
     if (error.Fail())
       return false;
   } else if (class_name == g_Dictionary1) {
     value = 1;
   } else if (class_name == g_Dictionary0) {
     value = 0;
-  } else if (class_name == g_DictionaryCF ||
-             class_name == g_DictionaryNSCF ||
+  } else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||
              class_name == g_DictionaryCFRef) {
     ExecutionContext exe_ctx(process_sp);
     CFBasicHash cfbh;
     if (!cfbh.Update(valobj_addr, exe_ctx))
       return false;
     value = cfbh.GetCount();
   } else {
     auto &map(NSDictionary_Additionals::GetAdditionalSummaries());
lldb_private::formatters::NSDictionarySyntheticFrontEndCreator(
   static const ConstString g_Dictionary1("__NSSingleEntryDictionaryI");
   static const ConstString g_DictionaryImmutable("__NSDictionaryM_Immutable");
   static const ConstString g_DictionaryMFrozen("__NSFrozenDictionaryM");
   static const ConstString g_DictionaryMLegacy("__NSDictionaryM_Legacy");
   static const ConstString g_Dictionary0("__NSDictionary0");
   static const ConstString g_DictionaryCF("__CFDictionary");
   static const ConstString g_DictionaryNSCF("__NSCFDictionary");
   static const ConstString g_DictionaryCFRef("CFDictionaryRef");
+  static const ConstString g_ConstantDictionary("NSConstantDictionary");
 
   if (class_name.IsEmpty())
     return nullptr;
 
   if (class_name == g_DictionaryI) {
     return (new NSDictionaryISyntheticFrontEnd(valobj_sp));
+  } else if (class_name == g_ConstantDictionary) {
+    return (new NSConstantDictionarySyntheticFrontEnd(valobj_sp));
   } else if (class_name == g_DictionaryM || class_name == g_DictionaryMFrozen) {
     if (runtime->GetFoundationVersion() >= 1437) {
       return (new Foundation1437::NSDictionaryMSyntheticFrontEnd(valobj_sp));
     } else if (runtime->GetFoundationVersion() >= 1428) {
       return (new Foundation1428::NSDictionaryMSyntheticFrontEnd(valobj_sp));
     } else {
       return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));
     }
   } else if (class_name == g_DictionaryMLegacy) {
-      return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));
   } else if (class_name == g_Dictionary1) {
     return (new NSDictionary1SyntheticFrontEnd(valobj_sp));
-  } else if (class_name == g_DictionaryCF ||
-             class_name == g_DictionaryNSCF ||
+  } else if (class_name == g_DictionaryCF || class_name == g_DictionaryNSCF ||
              class_name == g_DictionaryCFRef) {
     return (new NSCFDictionarySyntheticFrontEnd(valobj_sp));
   } else {
     auto &map(NSDictionary_Additionals::GetAdditionalSynthetics());
     for (auto &candidate : map) {
       if (candidate.first && candidate.first->Match((class_name)))
         return candidate.second(synth, valobj_sp);
     }
if (!dict_item.valobj_sp) {
     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
     DataExtractor data(buffer_sp, m_order, m_ptr_size);
     dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
                                                     m_exe_ctx_ref, m_pair_type);
   }
   return dict_item.valobj_sp;
 }
 
+lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::
+    NSConstantDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+    : SyntheticChildrenFrontEnd(*valobj_sp) {}
+
+size_t lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::
+    GetIndexOfChildWithName(ConstString name) {
+  const char *item_name = name.GetCString();
+  uint32_t idx = ExtractIndexFromString(item_name);
+  if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+    return UINT32_MAX;
+  return idx;
+}
+
+size_t lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::
+    CalculateNumChildren() {
+  return m_size;
+}
+
+bool lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::Update() {
+  ValueObjectSP valobj_sp = m_backend.GetSP();
+  if (!valobj_sp)
+    return false;
+  m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+  Status error;
+  error.Clear();
+  lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
+  if (!process_sp)
+    return false;
+  m_ptr_size = process_sp->GetAddressByteSize();
+  m_order = process_sp->GetByteOrder();
+  uint64_t valobj_addr = valobj_sp->GetValueAsUnsigned(0);
+  m_size = process_sp->ReadUnsignedIntegerFromMemory(
+      valobj_addr + 2 * m_ptr_size, m_ptr_size, 0, error);
+  if (error.Fail())
+    return false;
+  m_keys_ptr =
+      process_sp->ReadPointerFromMemory(valobj_addr + 3 * m_ptr_size, error);
+  if (error.Fail())
+    return false;
+  m_objects_ptr =
+      process_sp->ReadPointerFromMemory(valobj_addr + 4 * m_ptr_size, error);
+  return !error.Fail();
+}
+
+bool lldb_private::formatters::NSConstantDictionarySyntheticFrontEnd::
+    MightHaveChildren() {
+  return true;
+}
+
+lldb::ValueObjectSP lldb_private::formatters::
+    NSConstantDictionarySyntheticFrontEnd::GetChildAtIndex(size_t idx) {
+  uint32_t num_children = CalculateNumChildren();
+
+  if (idx >= num_children)
+    return lldb::ValueObjectSP();
+
+  if (m_children.empty()) {
+    // do the scan phase
+    lldb::addr_t key_at_idx = 0, val_at_idx = 0;
+    ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
+    if (!process_sp)
+      return lldb::ValueObjectSP();
+
+    for (unsigned int child = 0; child < num_children; ++child) {
+      Status error;
+      key_at_idx = process_sp->ReadPointerFromMemory(
+          m_keys_ptr + child * m_ptr_size, error);
+      if (error.Fail())
+        return lldb::ValueObjectSP();
+      val_at_idx = process_sp->ReadPointerFromMemory(
+          m_objects_ptr + child * m_ptr_size, error);
+      if (error.Fail())
+        return lldb::ValueObjectSP();
+      DictionaryItemDescriptor descriptor = {key_at_idx, val_at_idx,
+                                             lldb::ValueObjectSP()};
+      m_children.push_back(descriptor);
+    }
+  }
+
+  if (idx >= m_children.size()) // should never happen
+    return lldb::ValueObjectSP();
+
+  DictionaryItemDescriptor &dict_item = m_children[idx];
+  if (!dict_item.valobj_sp) {
+    if (!m_pair_type.IsValid()) {
+      TargetSP target_sp(m_backend.GetTargetSP());
+      if (!target_sp)
+        return ValueObjectSP();
+      m_pair_type = GetLLDBNSPairType(target_sp);
+    }
+    if (!m_pair_type.IsValid())
+      return ValueObjectSP();
+
+    DataBufferSP buffer_sp(new DataBufferHeap(2 * m_ptr_size, 0));
+
+    if (m_ptr_size == 8) {
+      uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
+      *data_ptr = dict_item.key_ptr;
+      *(data_ptr + 1) = dict_item.val_ptr;
+    } else {
+      uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
+      *data_ptr = dict_item.key_ptr;
+      *(data_ptr + 1) = dict_item.val_ptr;
+    }
+
+    StreamString idx_name;
+    idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
+    DataExtractor data(buffer_sp, m_order, m_ptr_size);
+    dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
+                                                    m_exe_ctx_ref, m_pair_type);
+  }
+  return dict_item.valobj_sp;
+}
+
 lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
     NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp.get()), m_pair(nullptr) {}
 
 size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
     GetIndexOfChildWithName(ConstString name) {
   static const ConstString g_zero("[0]");
   return name == g_zero ? 0 : UINT32_MAX;

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
 
   appkit_flags.SetDontShowChildren(false);
 
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
       "NSArray summary provider", ConstString("NSArray"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
+      "NSArray summary provider", ConstString("NSConstantArray"), appkit_flags);
+  AddCXXSummary(
+      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
       "NSArray summary provider", ConstString("NSMutableArray"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
       "NSArray summary provider", ConstString("__NSArrayI"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
       "NSArray summary provider", ConstString("__NSArray0"), appkit_flags);
   AddCXXSummary(objc_category_sp,
static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
                 "NSDictionary summary provider", ConstString("NSDictionary"),
                 appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
                 "NSDictionary summary provider",
+                ConstString("NSConstantDictionary"), appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSDictionarySummaryProvider<false>,
+                "NSDictionary summary provider",
                 ConstString("NSMutableDictionary"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
                 "NSDictionary summary provider",
                 ConstString("__NSCFDictionary"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
                 "NSDictionary summary provider", ConstString("__NSDictionaryI"),
AddCXXSynthetic(objc_category_sp,
                   ConstString("__NSSingleObjectArrayI"),
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
                   "NSArray synthetic children", ConstString("NSArray"),
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
+                  "NSArray synthetic children", ConstString("NSConstantArray"),
+                  ScriptedSyntheticChildren::Flags());
+  AddCXXSynthetic(objc_category_sp,
+                  lldb_private::formatters::NSArraySyntheticFrontEndCreator,
                   "NSArray synthetic children", ConstString("NSMutableArray"),
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
                   "NSArray synthetic children", ConstString("__NSCFArray"),
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
       "NSDictionary synthetic children", ConstString("__NSDictionaryM"),
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
+      "NSDictionary synthetic children", ConstString("NSConstantDictionary"),
+      ScriptedSyntheticChildren::Flags());
+  AddCXXSynthetic(
+      objc_category_sp,
+      lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
       "NSDictionary synthetic children", ConstString("__NSDictionaryI"),
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
       "NSDictionary synthetic children",
       ConstString("__NSSingleEntryDictionaryI"),
       ScriptedSyntheticChildren::Flags());
static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSNotificationSummaryProvider,
                 "NSNotification summary provider",
                 ConstString("NSConcreteNotification"), appkit_flags);
 
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
       "NSNumber summary provider", ConstString("NSNumber"), appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSNumberSummaryProvider,
+                "NSNumber summary provider",
+                ConstString("NSConstantIntegerNumber"), appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSNumberSummaryProvider,
+                "NSNumber summary provider",
+                ConstString("NSConstantDoubleNumber"), appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSNumberSummaryProvider,
+                "NSNumber summary provider",
+                ConstString("NSConstantFloatNumber"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
       "CFNumberRef summary provider", ConstString("CFNumberRef"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
       "NSNumber summary provider", ConstString("__NSCFBoolean"), appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,

lldb/test/API/functionalities/data-formatter/data-formatter-objc/ObjCDataFormatterTestCase.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ObjCDataFormatterTestCase(TestBase):
 
    mydir = TestBase.compute_mydir(__file__)
 
-   def appkit_tester_impl(self, commands):
+   def appkit_tester_impl(self, commands, use_constant_classes):
+      if use_constant_classes:
          self.build()
+      else:
+         disable_constant_classes = {
+            'CC':
+            'xcrun clang', # FIXME: Remove when flags are available upstream.
+            'CFLAGS_EXTRAS':
+            '-fno-constant-nsnumber-literals ' +
+            '-fno-constant-nsarray-literals ' +
+            '-fno-constant-nsdictionary-literals'
+         }
+         self.build(dictionary=disable_constant_classes)
       self.appkit_common_data_formatters_command()
       commands()
 
    def appkit_common_data_formatters_command(self):
       """Test formatters for AppKit classes."""
       self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
           self, '// Set break point at this line.',
           lldb.SBFileSpec('main.m', False))

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSBundle.py

 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSBundle(ObjCDataFormatterTestCase):
 
     def test_nsbundle_with_run_command(self):
         """Test formatters for NSBundle."""
-        self.appkit_tester_impl(self.nsbundle_data_formatter_commands)
+        self.appkit_tester_impl(self.nsbundle_data_formatter_commands, True)
+
+    @skipUnlessDarwin
+    def test_nsbundle_with_run_command_no_sonct(self):
+        """Test formatters for NSBundle."""
+        self.appkit_tester_impl(self.nsbundle_data_formatter_commands, False)
 
     def nsbundle_data_formatter_commands(self):
         self.expect(
             'frame variable bundle_string bundle_url main_bundle',
             substrs=[
                 '(NSBundle *) bundle_string = ',
                 ' @"/System/Library/Frameworks/Accelerate.framework"',
                 '(NSBundle *) bundle_url = ',
                 ' @"/System/Library/Frameworks/Foundation.framework"',
                 '(NSBundle *) main_bundle = ', 'data-formatter-objc'
             ])

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSContainer.py

 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSContainer(ObjCDataFormatterTestCase):
 
     def test_nscontainers_with_run_command(self):
         """Test formatters for  NS container classes."""
-        self.appkit_tester_impl(self.nscontainers_data_formatter_commands)
+        self.appkit_tester_impl(self.nscontainers_data_formatter_commands, False)
 
     def nscontainers_data_formatter_commands(self):
         self.expect(
             'frame variable newArray nsDictionary newDictionary nscfDictionary cfDictionaryRef newMutableDictionary copyDictionary newMutableDictionaryRef cfarray_ref mutable_array_ref',
             substrs=[
                 '(NSArray *) newArray = ',
                 ' @"50 elements"',
                 '(NSDictionary *) nsDictionary = ',

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSData.py

 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSData(ObjCDataFormatterTestCase):
 
     def test_nsdata_with_run_command(self):
         """Test formatters for  NSData."""
-        self.appkit_tester_impl(self.nsdata_data_formatter_commands)
+        self.appkit_tester_impl(self.nsdata_data_formatter_commands, True)
+
+    @skipUnlessDarwin
+    def test_nsdata_with_run_command_no_const(self):
+        """Test formatters for  NSData."""
+        self.appkit_tester_impl(self.nsdata_data_formatter_commands, False)
 
     def nsdata_data_formatter_commands(self):
         self.expect(
             'frame variable immutableData mutableData data_ref mutable_data_ref mutable_string_ref concreteData concreteMutableData',
             substrs=[
                 '(NSData *) immutableData = ', ' 5 bytes',
                 '(NSData *) mutableData = ', ' 14 bytes',
                 '(CFDataRef) data_ref = ', '@"5 bytes"',
                 '(CFMutableDataRef) mutable_data_ref = ', '@"5 bytes"',
                 '(CFMutableStringRef) mutable_string_ref = ',
                 ' @"Wish ya knew"', '(NSData *) concreteData = ',
                 ' 100000 bytes', '(NSMutableData *) concreteMutableData = ',
                 ' 100000 bytes'
             ])

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSDate.py

 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 import datetime
 
 class ObjCDataFormatterNSDate(ObjCDataFormatterTestCase):
 
     def test_nsdate_with_run_command(self):
         """Test formatters for  NSDate."""
-        self.appkit_tester_impl(self.nsdate_data_formatter_commands)
+        self.appkit_tester_impl(self.nsdate_data_formatter_commands, False)
 
     def nsdate_data_formatter_commands(self):
         self.expect(
             'frame variable date1 date2',
             patterns=[
                 '(1985-04-10|1985-04-11)',
                 '(2011-01-01|2010-12-31)'])
 

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSError.py

 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSError(ObjCDataFormatterTestCase):
 
     def test_nserror_with_run_command(self):
         """Test formatters for NSError."""
-        self.appkit_tester_impl(self.nserror_data_formatter_commands)
+        self.appkit_tester_impl(self.nserror_data_formatter_commands, True)
+
+    @skipUnlessDarwin
+    def test_nserror_with_run_command_no_const(self):
+        """Test formatters for NSError."""
+        self.appkit_tester_impl(self.nserror_data_formatter_commands, False)
 
     def nserror_data_formatter_commands(self):
         self.expect(
             'frame variable nserror', substrs=['domain: @"Foobar" - code: 12'])
 
         self.expect(
             'frame variable nserrorptr',
             substrs=['domain: @"Foobar" - code: 12'])
 
         self.expect(
             'frame variable nserror->_userInfo', substrs=['2 key/value pairs'])
 
         self.expect(
             'frame variable nserror->_userInfo --ptr-depth 1 -d run-target',
             substrs=['@"a"', "1", '@"b"', "2"])

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSNumber.py

+# encoding: utf-8
+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
+
+
+class ObjCDataFormatterNSNumber(ObjCDataFormatterTestCase):
+
+    @skipUnlessDarwin
+    def test_nsnumber_with_run_command(self):
+        """Test formatters for  NS container classes."""
+        self.appkit_tester_impl(self.nscontainers_data_formatter_commands, True)
+
+    @skipUnlessDarwin
+    def test_nsnumber_with_run_command_no_const(self):
+        """Test formatters for  NS container classes."""
+        self.appkit_tester_impl(self.nscontainers_data_formatter_commands, False)
+
+    def nscontainers_data_formatter_commands(self):
+        self.expect(
+            'frame variable newArray nsDictionary newDictionary nscfDictionary cfDictionaryRef newMutableDictionary cfarray_ref mutable_array_ref',
+            substrs=[
+                '(NSArray *) newArray = ', '@"50 elements"',
+                '(NSDictionary *) nsDictionary = ', ' 2 key/value pairs',
+                '(NSDictionary *) newDictionary = ', ' 12 key/value pairs',
+                '(CFDictionaryRef) cfDictionaryRef = ', ' 2 key/value pairs',
+                '(NSDictionary *) newMutableDictionary = ', ' 21 key/value pairs',
+                '(CFArrayRef) cfarray_ref = ', '@"3 elements"',
+                '(CFMutableArrayRef) mutable_array_ref = ', '@"11 elements"'
+            ])
+
+        numbers = [ ("num1", "(int)5"),
+                    ("num2", "(float)3.140000"),
+                    ("num3", "(double)3.14"),
+                    ("num4", "(int128_t)18446744073709551614"),
+                    ("num5", "(char)65"),
+                    ("num6", "(long)255"),
+                    ("num7", "(long)2000000"),
+                    ("num8_Y", "YES"),
+                    ("num8_N", "NO"),
+                    ("num9", "(short)-31616"),
+                    ("num_at1", "(int)12"),
+                    ("num_at2", "(int)-12"),
+                    ("num_at3", "(double)12.5"),
+                    ("num_at4", "(double)-12.5"),
+                    ("num_at5", "(char)97"),
+                    ("num_at6", "(float)42.123"),
+                    ("num_at7", "(double)43.123"),
+                    ("num_at8", "(long)12345"),
+                    ("num_at9", "17375808098308635870"),
+                    ("num_at9b", "-1070935975400915746"),
+                    ("num_at10", "YES"),
+                    ("num_at11", "NO"),
+        ]
+
+        for var, res in numbers:
+            self.expect('frame variable ' + var, substrs=[res])
+

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSURL.py

 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSURL(ObjCDataFormatterTestCase):
 
     def test_nsurl_with_run_command(self):
         """Test formatters for NSURL."""
-        self.appkit_tester_impl(self.nsurl_data_formatter_commands)
+        self.appkit_tester_impl(self.nsurl_data_formatter_commands, True)
+
+    @skipUnlessDarwin
+    def test_nsurl_with_run_command_no_const(self):
+        """Test formatters for NSURL."""
+        self.appkit_tester_impl(self.nsurl_data_formatter_commands, False)
 
     def nsurl_data_formatter_commands(self):
         self.expect(
             'frame variable cfurl_ref cfchildurl_ref cfgchildurl_ref',
             substrs=[
                 '(CFURLRef) cfurl_ref = ', '@"http://www.foo.bar',
                 'cfchildurl_ref = ', '@"page.html -- http://www.foo.bar',
                 '(CFURLRef) cfgchildurl_ref = ',

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjNSException.py

 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSException(ObjCDataFormatterTestCase):
 
     def test_nsexception_with_run_command(self):
         """Test formatters for NSException."""
-        self.appkit_tester_impl(self.nsexception_data_formatter_commands)
+        self.appkit_tester_impl(self.nsexception_data_formatter_commands, True)
+
+    @skipUnlessDarwin
+    def test_nsexception_with_run_command_no_const(self):
+        """Test formatters for NSException."""
+        self.appkit_tester_impl(self.nsexception_data_formatter_commands, False)
 
     def nsexception_data_formatter_commands(self):
         self.expect(
             'frame variable except0 except1 except2 except3',
             substrs=[
                 '(NSException *) except0 = ',
                 '@"First"',
                 '(NSException *) except1 = ',
                 '@"Second"',
                 '(NSException *) except2 = ',
                 ' @"Third"',
                 '(NSException *) except3 = ',
                 ' @"Fourth"'
             ])

lldb/test/API/functionalities/data-formatter/data-formatter-objc/main.m

int main(int argc, const char *argv[]) {
   NSNumber *num7 = [NSNumber numberWithLong:0x1E8480];
   NSNumber *num8_Y = [NSNumber numberWithBool:YES];
   NSNumber *num8_N = [NSNumber numberWithBool:NO];
   NSNumber *num9 = [NSNumber numberWithShort:0x1E8480];
   NSNumber *num_at1 = @12;
   NSNumber *num_at2 = @-12;
   NSNumber *num_at3 = @12.5;
   NSNumber *num_at4 = @-12.5;
+  NSNumber *num_at5 = @'a';
+  NSNumber *num_at6 = @42.123f;
+  NSNumber *num_at7 = @43.123;
+  NSNumber *num_at8 = @12345ll;
+  NSNumber *num_at9 = @0xF1234567890abcdeull;
+  NSNumber *num_at9b = @-1070935975400915746;
+  NSNumber *num_at10 = @YES;
+  NSNumber *num_at11 = @NO;
 
   NSDecimalNumber *decimal_number =
       [NSDecimalNumber decimalNumberWithMantissa:123456
                                         exponent:-10
                                       isNegative:NO];
   NSDecimalNumber *decimal_number_neg =
       [NSDecimalNumber decimalNumberWithMantissa:123456
                                         exponent:10

lldb/test/API/functionalities/data-formatter/nsdictionarysynth/TestNSDictionarySynthetic.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.m', '// Set break point at this line.')
 
     @skipUnlessDarwin
     def test_rdar11988289_with_run_command(self):
         """Test that NSDictionary reports its synthetic children properly."""
         self.build()
+        self.run_tests()
+
+    @skipUnlessDarwin
+    def test_rdar11988289_with_run_command_no_const(self):
+        """Test that NSDictionary reports its synthetic children properly."""
+        disable_constant_classes = {
+            'CC':
+            'xcrun clang',  # FIXME: Remove when flags are available upstream.
+            'CFLAGS_EXTRAS':
+            '-fno-constant-nsnumber-literals ' +
+            '-fno-constant-nsarray-literals ' +
+            '-fno-constant-nsdictionary-literals'
+        }
+        self.build(dictionary=disable_constant_classes)
+        self.run_tests()
+
+    def run_tests(self):
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.

lldb/test/API/functionalities/data-formatter/nssetsynth/TestNSSetSynthetic.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.m', '// Set break point at this line.')
 
     @skipUnlessDarwin
     def test_rdar12529957_with_run_command(self):
         """Test that NSSet reports its synthetic children properly."""
         self.build()
+        self.run_tests()
+
+    @skipUnlessDarwin
+    def test_rdar12529957_with_run_command_no_const(self):
+        """Test that NSSet reports its synthetic children properly."""
+        disable_constant_classes = {
+            'CC':
+            'xcrun clang',  # FIXME: Remove when flags are available upstream.
+            'CFLAGS_EXTRAS':
+            '-fno-constant-nsnumber-literals ' +
+            '-fno-constant-nsarray-literals ' +
+            '-fno-constant-nsdictionary-literals'
+        }
+        self.build(dictionary=disable_constant_classes)
+        self.run_tests()
+
+    def run_tests(self):
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.

lldb/test/API/functionalities/data-formatter/poarray/TestPrintObjectArray.py

class PrintObjectArrayTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @skipUnlessDarwin
     def test_print_array(self):
         """Test that expr -O -Z works"""
         self.build()
         self.printarray_data_formatter_commands()
 
+    @skipUnlessDarwin
+    def test_print_array_no_const(self):
+        """Test that expr -O -Z works"""
+        disable_constant_classes = {
+            'CC':
+            'xcrun clang',  # FIXME: Remove when flags are available upstream.
+            'CFLAGS_EXTRAS':
+            '-fno-constant-nsnumber-literals ' +
+            '-fno-constant-nsarray-literals ' +
+            '-fno-constant-nsdictionary-literals'
+        }
+        self.build(dictionary=disable_constant_classes)
+        self.printarray_data_formatter_commands()
+
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.mm', 'break here')
 
     def printarray_data_formatter_commands(self):
         """Test that expr -O -Z works"""

lldb/test/API/lang/objc/orderedset/TestOrderedSet.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestOrderedSet(TestBase):
   mydir = TestBase.compute_mydir(__file__)
 
   def test_ordered_set(self):
     self.build()
+    self.run_tests()
+
+  @skipUnlessDarwin
+  def test_ordered_set_no_const(self):
+    disable_constant_classes = {
+        'CC':
+        'xcrun clang',  # FIXME: Remove when flags are available upstream.
+        'CFLAGS_EXTRAS':
+        '-fno-constant-nsnumber-literals ' +
+        '-fno-constant-nsarray-literals ' +
+        '-fno-constant-nsdictionary-literals'
+    }
+    self.build(dictionary=disable_constant_classes)
+    self.run_tests()
+
+  def run_tests(self):
     src_file = "main.m"
     src_file_spec = lldb.SBFileSpec(src_file)
     (target, process, thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self,
           "break here", src_file_spec, exe_name = "a.out")
     frame = thread.GetSelectedFrame()
     self.expect("expr -d run -- orderedSet", substrs=["3 elements"])
     self.expect("expr -d run -- *orderedSet", substrs=["(int)1", "(int)2", "(int)3"])

lldb/test/API/lang/objc/single-entry-dictionary/TestObjCSingleEntryDictionary.py

class ObjCSingleEntryDictionaryTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.m', '// break here')
 
+    @skipUnlessDarwin
     @expectedFailureAll(oslist=['watchos'], bugnumber="rdar://problem/34642736") # bug in NSDictionary formatting on watchos
     def test_single_entry_dict(self):
         self.build()
+        self.run_tests()
+
+    @skipUnlessDarwin
+    @expectedFailureAll(oslist=['watchos'], bugnumber="rdar://problem/34642736") # bug in NSDictionary formatting on watchos
+    def test_single_entry_dict_no_const(self):
+        disable_constant_classes = {
+            'CC':
+            'xcrun clang',  # FIXME: Remove when flags are available upstream.
+            'CFLAGS_EXTRAS':
+            '-fno-constant-nsnumber-literals ' +
+            '-fno-constant-nsarray-literals ' +
+            '-fno-constant-nsdictionary-literals'
+        }
+        self.build(dictionary=disable_constant_classes)
+        self.run_tests()
+
+    def run_tests(self):
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the foo function which takes a bar_ptr argument.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)