Replace uses of LazyBool with LazyBool template

[teemperor]

Summary

This patch introduces a LazyMember template that allows specifying member variables
which values will be computed once they are read the first time. This is supposed to
replace the previously used LazyBool enum that is partly providing the same functionality
(but you have to do all the checks yourself).

The advantages of LazyMember over handwritten LazyBool code are:

• No more manual checking when reading the value somewhere.
• The compiler enforces now that we actually set a value before returning to the user.
• We can optimize this code further in the future for space/time without

having to revisit all the different places that use LazyBool.

[davide]

include/lldb/DataFormatters/ValueObjectPrinter.h

146

can you typedef?

[zturner]

I think we should put this in llvm/ADT as it does not seem specific to debugging, and could be useful for others.

[davide]

I agree.

[zturner]

Also I think it doesn't need to be specific to member variables. We could just have

template <typename T> class Lazy {
  std::function<T()> Update;
  Optional<T> Value;
public:
  LazyValue(std::function<T()> Update) : Update(std::move(Update)) {}
};

Then, to get the same member functionality, you could just say:

struct Foo {
  Foo() : LazyBool([this]() { return expensiveComputeBool(); }) {}

  Lazy<bool>  LazyBool;

  bool expensiveComputeBool();
};

[shafik]

include/lldb/DataFormatters/ValueObjectPrinter.h

146

I feel like using ... = is cleaner

[labath]

I've been wanting to implement something like this for a long time, so thank you for working on this. :)

In D51557#1221273, @zturner wrote:

Also I think it doesn't need to be specific to member variables. We could just have

template <typename T> class Lazy {
  std::function<T()> Update;
  Optional<T> Value;
public:
  LazyValue(std::function<T()> Update) : Update(std::move(Update)) {}
};

I think the issue with this approach is size. std::function is huge and heap-allocated, whereas this implementation is the same size as Optional<T> (which might still be too much for some of our use cases -- in some classes we store a bunch of needs_update flags as bitfields to conserve space, which would not be possible here).

include/lldb/DataFormatters/ValueObjectPrinter.h

138–144

I wouldn't call these update as they don't actually update anything and just return the value. In other parts of the codebase we use compute for functions like this.

146

I am actually tempted to have a macro which would define all of this boilerplate for you. :D

Something like

#define LAZY_MEMBER(Class, Type, Name) \
public: \
  Type get ## Name() { return m_ ## Name.get(*this); } \
private: \
  LazyMember<Type, Class, &Class::compute ## Name> m_ ## Name; \
  Type compute ## Name();

Then all that would be left for the user is to define the compute function in the cpp file.

include/lldb/Utility/Lazy.h

26–29

if you use Optional<T> instead of hand-rolling the flag here, you could probably get rid of the "trivial type" limitation.

[teemperor]

• Now using a typedef instead of a macro.
• Using LLVM code style in Lazy.h
• Renamed UpdateX to CalculateX

[clayborg]

Very nice. LGTM

[teemperor]

(Phabricator didn't send my draft, sorry for the delay).

I have more similar patches coming up for the other uses of LazyBool, so I would prefer finishing the implementation in LLDB and then afterwards asking if the ADT folks want it. I moved this patch to LLVM code style to make this easier later on. Sounds good?

To add to @labath's points about performance: If we have the calc* functions as lambdas, then I would have to declare all these lambdas in the constructor, which doesn't look very nice.

include/lldb/Utility/Lazy.h

26–29

Makes sense, thanks!

include/lldb/DataFormatters/ValueObjectPrinter.h

 // C++ Includes
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-public.h"
 
 #include "lldb/Utility/Flags.h"
+#include "lldb/Utility/Lazy.h"
 
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/Symbol/CompilerType.h"
 
 namespace lldb_private {
 
 class ValueObjectPrinter {
 public:
void Init(ValueObject *valobj, Stream *s,
             InstancePointersSetSP printed_instance_pointers);
 
   bool GetMostSpecializedValue();
 
   const char *GetDescriptionForDisplay();
 
   const char *GetRootNameForDisplay(const char *if_fail = nullptr);
 
-  bool ShouldPrintValueObject();
+  bool ShouldPrintValueObject() { return m_should_print.get(*this); }
 
   bool ShouldPrintValidation();
 
-  bool IsNil();
-
-  bool IsUninitialized();
-
-  bool IsPtr();
-
-  bool IsRef();
-
-  bool IsInstancePointer();
-
-  bool IsAggregate();
+  bool IsNil() { return m_is_nil.get(*this); }
+  bool IsUninitialized() { return m_is_uninit.get(*this); }
+  bool IsPtr() { return m_is_ptr.get(*this); }
+  bool IsRef() { return m_is_ref.get(*this); }
+  bool IsInstancePointer() { return m_is_instance_ptr.get(*this); }
+  bool IsAggregate() { return m_is_aggregate.get(*this); }
 
   bool PrintValidationMarkerIfNeeded();
 
   bool PrintValidationErrorIfNeeded();
 
   bool PrintLocationIfNeeded();
 
   void PrintDecl();
private:
   ValueObject *m_orig_valobj;
   ValueObject *m_valobj;
   Stream *m_stream;
   DumpValueObjectOptions m_options;
   Flags m_type_flags;
   CompilerType m_compiler_type;
   DumpValueObjectOptions::PointerDepth m_ptr_depth;
   uint32_t m_curr_depth;
-  LazyBool m_should_print;
-  LazyBool m_is_nil;
-  LazyBool m_is_uninit;
-  LazyBool m_is_ptr;
-  LazyBool m_is_ref;
-  LazyBool m_is_aggregate;
-  LazyBool m_is_instance_ptr;
+
+  bool CalculateShouldPrint();
+  bool CalculateIsNil();
+  bool CalculateIsUnit();
+  bool CalculateIsPtr();
+  bool CalculateIsRef();
+  bool CalculateIsAggregate();
+  bool CalculateIsInstancePtr();
+
+  using Class = ValueObjectPrinter;
+  LazyBoolMember<Class, &Class::CalculateShouldPrint> m_should_print;
+  LazyBoolMember<Class, &Class::CalculateIsNil> m_is_nil;
+  LazyBoolMember<Class, &Class::CalculateIsUnit> m_is_uninit;
+  LazyBoolMember<Class, &Class::CalculateIsPtr> m_is_ptr;
+  LazyBoolMember<Class, &Class::CalculateIsRef> m_is_ref;
+  LazyBoolMember<Class, &Class::CalculateIsAggregate> m_is_aggregate;
+  LazyBoolMember<Class, &Class::CalculateIsInstancePtr> m_is_instance_ptr;
   std::pair<TypeSummaryImpl *, bool> m_summary_formatter;
   std::string m_value;
   std::string m_summary;
   std::string m_error;
   bool m_val_summary_ok;
   std::pair<TypeValidatorResult, std::string> m_validation;
 
   friend struct StringSummaryFormat;
 
   DISALLOW_COPY_AND_ASSIGN(ValueObjectPrinter);
 };
 
 } // namespace lldb_private
 
 #endif // lldb_ValueObjectPrinter_h_

include/lldb/Symbol/CompileUnit.h

 //===-- CompileUnit.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_CompUnit_h_
 #define liblldb_CompUnit_h_
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/Function.h"
+#include "lldb/Utility/Lazy.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
 //----------------------------------------------------------------------
public:
   /// would expect them, stepping through the source lines in the function may
   /// appear strange, etc.
   ///
   /// @return
   ///     Returns 'true' if this compile unit was compiled with
   ///     optimization.  'false' indicates that either the optimization
   ///     is unknown, or this compile unit was built without optimization.
   //------------------------------------------------------------------
-  bool GetIsOptimized();
+  bool GetIsOptimized() { return m_is_optimized.get(*this); }
 
 protected:
   void *m_user_data; ///< User data for the SymbolFile parser to store
                      ///information into.
   lldb::LanguageType
       m_language; ///< The programming language enumeration value.
   Flags m_flags;  ///< Compile unit flags that help with partial parsing.
 
   /// Maps UIDs to functions.
   llvm::DenseMap<lldb::user_id_t, lldb::FunctionSP> m_functions_by_uid;
   std::vector<ConstString> m_imported_modules; ///< All modules, including the
                                                ///current module, imported by
                                                ///this
                                                ///< compile unit.
   FileSpecList m_support_files; ///< Files associated with this compile unit's
                                 ///line table and declarations.
   std::unique_ptr<LineTable>
       m_line_table_ap; ///< Line table that will get parsed on demand.
   DebugMacrosSP
       m_debug_macros_sp; ///< Debug macros that will get parsed on demand.
   lldb::VariableListSP m_variables; ///< Global and static variable list that
                                     ///will get parsed on demand.
-  lldb_private::LazyBool m_is_optimized; /// eLazyBoolYes if this compile unit
-                                         /// was compiled with optimization.
+  bool CalculateOptimized();
+  /// true if this compile unit was compiled with optimization.
+  LazyBoolMember<CompileUnit, &CompileUnit::CalculateOptimized> m_is_optimized;
 
 private:
   enum {
     flagsParsedAllFunctions =
         (1u << 0), ///< Have we already parsed all our functions
     flagsParsedVariables =
         (1u << 1), ///< Have we already parsed globals and statics?
     flagsParsedSupportFiles = (1u << 2), ///< Have we already parsed the support

include/lldb/Target/ObjCLanguageRuntime.h

 
 // Project includes
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/DeclVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/LanguageRuntime.h"
+#include "lldb/Utility/Lazy.h"
 #include "lldb/lldb-private.h"
 
 class CommandObjectObjC_ClassTable_Dump;
 
 namespace lldb_private {
 
 class UtilityFunction;
 
public:
   class ClassDescriptor;
   typedef std::shared_ptr<ClassDescriptor> ClassDescriptorSP;
 
   // the information that we want to support retrieving from an ObjC class this
   // needs to be pure virtual since there are at least 2 different
   // implementations of the runtime, and more might come
   class ClassDescriptor {
   public:
-    ClassDescriptor()
-        : m_is_kvo(eLazyBoolCalculate), m_is_cf(eLazyBoolCalculate),
-          m_type_wp() {}
+    ClassDescriptor() = default;
 
     virtual ~ClassDescriptor() = default;
 
     virtual ConstString GetClassName() = 0;
 
     virtual ClassDescriptorSP GetSuperclass() = 0;
 
     virtual ClassDescriptorSP GetMetaclass() const = 0;
 
     // virtual if any implementation has some other version-specific rules but
     // for the known v1/v2 this is all that needs to be done
-    virtual bool IsKVO() {
-      if (m_is_kvo == eLazyBoolCalculate) {
-        const char *class_name = GetClassName().AsCString();
-        if (class_name && *class_name)
-          m_is_kvo =
-              (LazyBool)(strstr(class_name, "NSKVONotifying_") == class_name);
-      }
-      return (m_is_kvo == eLazyBoolYes);
-    }
+    virtual bool IsKVO() { return m_is_kvo.get(*this); }
 
     // virtual if any implementation has some other version-specific rules but
     // for the known v1/v2 this is all that needs to be done
-    virtual bool IsCFType() {
-      if (m_is_cf == eLazyBoolCalculate) {
-        const char *class_name = GetClassName().AsCString();
-        if (class_name && *class_name)
-          m_is_cf = (LazyBool)(strcmp(class_name, "__NSCFType") == 0 ||
-                               strcmp(class_name, "NSCFType") == 0);
-      }
-      return (m_is_cf == eLazyBoolYes);
-    }
+    virtual bool IsCFType() { return m_is_cf.get(*this); }
 
     virtual bool IsValid() = 0;
 
     virtual bool GetTaggedPointerInfo(uint64_t *info_bits = nullptr,
                                       uint64_t *value_bits = nullptr,
                                       uint64_t *payload = nullptr) = 0;
 
     virtual uint64_t GetInstanceSize() = 0;
public:
     }
 
   protected:
     bool IsPointerValid(lldb::addr_t value, uint32_t ptr_size,
                         bool allow_NULLs = false, bool allow_tagged = false,
                         bool check_version_specific = false) const;
 
   private:
-    LazyBool m_is_kvo;
-    LazyBool m_is_cf;
+    bool CalculateKVO();
+
+    bool CalculateCFType();
+
+    LazyBoolMember<ClassDescriptor, &ClassDescriptor::CalculateKVO> m_is_kvo;
+    LazyBoolMember<ClassDescriptor, &ClassDescriptor::CalculateCFType> m_is_cf;
     lldb::TypeWP m_type_wp;
   };
 
   class EncodingToType {
   public:
     virtual ~EncodingToType();
 
     virtual CompilerType RealizeType(ClangASTContext &ast_ctx, const char *name,
public:
   // Given the name of an Objective-C runtime symbol (e.g., ivar offset
   // symbol), try to determine from the runtime what the value of that symbol
   // would be. Useful when the underlying binary is stripped.
   virtual lldb::addr_t LookupRuntimeSymbol(const ConstString &name) {
     return LLDB_INVALID_ADDRESS;
   }
 
   bool HasNewLiteralsAndIndexing() {
-    if (m_has_new_literals_and_indexing == eLazyBoolCalculate) {
-      if (CalculateHasNewLiteralsAndIndexing())
-        m_has_new_literals_and_indexing = eLazyBoolYes;
-      else
-        m_has_new_literals_and_indexing = eLazyBoolNo;
-    }
-
-    return (m_has_new_literals_and_indexing == eLazyBoolYes);
+    return m_has_new_literals_and_indexing.get(*this);
   }
 
   virtual void SymbolsDidLoad(const ModuleList &module_list) {
     m_negative_complete_class_cache.clear();
   }
 
   bool GetTypeBitSize(const CompilerType &compiler_type,
                       uint64_t &size) override;
private:
   typedef std::map<ClassAndSel, lldb::addr_t> MsgImplMap;
   typedef std::map<ObjCISA, ClassDescriptorSP> ISAToDescriptorMap;
   typedef std::multimap<uint32_t, ObjCISA> HashToISAMap;
   typedef ISAToDescriptorMap::iterator ISAToDescriptorIterator;
   typedef HashToISAMap::iterator HashToISAIterator;
   typedef ThreadSafeDenseMap<void *, uint64_t> TypeSizeCache;
 
   MsgImplMap m_impl_cache;
-  LazyBool m_has_new_literals_and_indexing;
+  LazyBoolMember<ObjCLanguageRuntime,
+                 &ObjCLanguageRuntime::CalculateHasNewLiteralsAndIndexing>
+      m_has_new_literals_and_indexing;
   ISAToDescriptorMap m_isa_to_descriptor;
   HashToISAMap m_hash_to_isa_map;
   TypeSizeCache m_type_size_cache;
 
 protected:
   uint32_t m_isa_to_descriptor_stop_id;
 
   typedef std::map<ConstString, lldb::TypeWP> CompleteClassMap;

include/lldb/Utility/Lazy.h

+//===-- Lazy.h --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_Lazy_h_
+#define liblldb_Lazy_h_
+
+#include <type_traits>
+
+#include "llvm/ADT/Optional.h"
+
+#include "lldb/lldb-private-enumerations.h"
+
+namespace lldb_private {
+
+/// Contains a member variable value that will be lazily calculcated when it's
+/// used for the first time.
+///
+/// The class takes a value type T that should be stored, and a member function
+/// that will be called to calculate the actual value on the first read.
+// FIXME: The class/member pointer pair can be replaced by an auto template with
+// C++17.
+template <typename T, typename Class, T (Class::*Calculate)()>
+class LazyMember {
+  llvm::Optional<T> Value;
+
+public:
+  LazyMember() { reset(); }
+
+  /// Requests that the member should be recalculated on the next read.
+  void reset() { Value.reset(); }
+
+  /// Reads the value of this LazyMember. Potentially recalculates the value
+  /// before returning.
+  const T &get(Class &instance) {
+    if (!Value)
+      set((instance.*Calculate)());
+    return *Value;
+  }
+
+  /// Explicitly sets the value of this instance to a certain value, which will
+  /// also prevent that any future reads recalculate it.
+  void set(const T &value) { Value = value; }
+};
+
+/// Convenience struct for LazyMember with a bool.
+template <typename Class, bool (Class::*Calculate)()>
+class LazyBoolMember : public LazyMember<bool, Class, Calculate> {};
+} // namespace lldb_private
+
+#endif // liblldb_Lazy_h_

source/DataFormatters/ValueObjectPrinter.cpp

void ValueObjectPrinter::Init(
   m_orig_valobj = valobj;
   m_valobj = nullptr;
   m_stream = s;
   m_options = options;
   m_ptr_depth = ptr_depth;
   m_curr_depth = curr_depth;
   assert(m_orig_valobj && "cannot print a NULL ValueObject");
   assert(m_stream && "cannot print to a NULL Stream");
-  m_should_print = eLazyBoolCalculate;
-  m_is_nil = eLazyBoolCalculate;
-  m_is_uninit = eLazyBoolCalculate;
-  m_is_ptr = eLazyBoolCalculate;
-  m_is_ref = eLazyBoolCalculate;
-  m_is_aggregate = eLazyBoolCalculate;
-  m_is_instance_ptr = eLazyBoolCalculate;
   m_summary_formatter = {nullptr, false};
   m_value.assign("");
   m_summary.assign("");
   m_error.assign("");
   m_val_summary_ok = false;
   m_printed_instance_pointers =
       printed_instance_pointers
           ? printed_instance_pointers

 
 const char *ValueObjectPrinter::GetRootNameForDisplay(const char *if_fail) {
   const char *root_valobj_name = m_options.m_root_valobj_name.empty()
                                      ? m_valobj->GetName().AsCString()
                                      : m_options.m_root_valobj_name.c_str();
   return root_valobj_name ? root_valobj_name : if_fail;
 }
 
-bool ValueObjectPrinter::ShouldPrintValueObject() {
-  if (m_should_print == eLazyBoolCalculate)
-    m_should_print =
-        (m_options.m_flat_output == false || m_type_flags.Test(eTypeHasValue))
-            ? eLazyBoolYes
-            : eLazyBoolNo;
-  return m_should_print == eLazyBoolYes;
+bool ValueObjectPrinter::CalculateShouldPrint() {
+  return m_options.m_flat_output == false || m_type_flags.Test(eTypeHasValue);
 }
 
-bool ValueObjectPrinter::IsNil() {
-  if (m_is_nil == eLazyBoolCalculate)
-    m_is_nil = m_valobj->IsNilReference() ? eLazyBoolYes : eLazyBoolNo;
-  return m_is_nil == eLazyBoolYes;
-}
+bool ValueObjectPrinter::CalculateIsNil() { return m_valobj->IsNilReference(); }
 
-bool ValueObjectPrinter::IsUninitialized() {
-  if (m_is_uninit == eLazyBoolCalculate)
-    m_is_uninit =
-        m_valobj->IsUninitializedReference() ? eLazyBoolYes : eLazyBoolNo;
-  return m_is_uninit == eLazyBoolYes;
+bool ValueObjectPrinter::CalculateIsUnit() {
+  return m_valobj->IsUninitializedReference();
 }
 
-bool ValueObjectPrinter::IsPtr() {
-  if (m_is_ptr == eLazyBoolCalculate)
-    m_is_ptr = m_type_flags.Test(eTypeIsPointer) ? eLazyBoolYes : eLazyBoolNo;
-  return m_is_ptr == eLazyBoolYes;
+bool ValueObjectPrinter::CalculateIsPtr() {
+  return m_type_flags.Test(eTypeIsPointer);
 }
 
-bool ValueObjectPrinter::IsRef() {
-  if (m_is_ref == eLazyBoolCalculate)
-    m_is_ref = m_type_flags.Test(eTypeIsReference) ? eLazyBoolYes : eLazyBoolNo;
-  return m_is_ref == eLazyBoolYes;
+bool ValueObjectPrinter::CalculateIsRef() {
+  return m_type_flags.Test(eTypeIsReference);
 }
 
-bool ValueObjectPrinter::IsAggregate() {
-  if (m_is_aggregate == eLazyBoolCalculate)
-    m_is_aggregate =
-        m_type_flags.Test(eTypeHasChildren) ? eLazyBoolYes : eLazyBoolNo;
-  return m_is_aggregate == eLazyBoolYes;
+bool ValueObjectPrinter::CalculateIsAggregate() {
+  return m_type_flags.Test(eTypeHasChildren);
 }
 
-bool ValueObjectPrinter::IsInstancePointer() {
+bool ValueObjectPrinter::CalculateIsInstancePtr() {
   // you need to do this check on the value's clang type
-  if (m_is_instance_ptr == eLazyBoolCalculate)
-    m_is_instance_ptr = (m_valobj->GetValue().GetCompilerType().GetTypeInfo() &
-                         eTypeInstanceIsPointer) != 0
-                            ? eLazyBoolYes
-                            : eLazyBoolNo;
-  if ((eLazyBoolYes == m_is_instance_ptr) && m_valobj->IsBaseClass())
-    m_is_instance_ptr = eLazyBoolNo;
-  return m_is_instance_ptr == eLazyBoolYes;
+  bool result = (m_valobj->GetValue().GetCompilerType().GetTypeInfo() &
+                 eTypeInstanceIsPointer) != 0;
+  if (result && m_valobj->IsBaseClass())
+    result = false;
+  return result;
 }
 
 bool ValueObjectPrinter::PrintLocationIfNeeded() {
   if (m_options.m_show_location) {
     m_stream->Printf("%s: ", m_valobj->GetLocationAsCString());
     return true;
   }
   return false;

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

 //===-- DWARFUnit.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFUnit_h_
 #define SymbolFileDWARF_DWARFUnit_h_
 
 #include "DWARFDIE.h"
 #include "DWARFDebugInfoEntry.h"
+#include "lldb/Utility/Lazy.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/Support/RWMutex.h"
 #include <atomic>
 
 class DWARFUnit;
 class DWARFCompileUnit;
 class NameToDIE;
 class SymbolFileDWARF;
protected:
   uint16_t m_version = 0;
   uint8_t m_addr_size = 0;
   DWARFProducer m_producer = eProducerInvalid;
   uint32_t m_producer_version_major = 0;
   uint32_t m_producer_version_minor = 0;
   uint32_t m_producer_version_update = 0;
   lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
   bool m_is_dwarf64 = false;
-  lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   dw_addr_t m_addr_base = 0;   // Value of DW_AT_addr_base
   dw_addr_t m_ranges_base = 0; // Value of DW_AT_ranges_base
   // If this is a dwo compile unit this is the offset of the base compile unit
   // in the main object file
   dw_offset_t m_base_obj_offset = DW_INVALID_OFFSET;
 
   // Offset of the initial length field.
   dw_offset_t m_offset;
 
 private:
   void ParseProducerInfo();
   void ExtractDIEsRWLocked();
   void ClearDIEsRWLocked();
 
+  bool UpdateIsOptimized();
+  lldb_private::LazyBoolMember<DWARFUnit, &DWARFUnit::UpdateIsOptimized>
+      m_is_optimized;
+
   // Get the DWARF unit DWARF debug informration entry. Parse the single DIE
   // if needed.
   const DWARFDebugInfoEntry *GetUnitDIEPtrOnly() {
     ExtractUnitDIEIfNeeded();
     // m_first_die_mutex is not required as m_first_die is never cleared.
     if (!m_first_die)
       return NULL;
     return &m_first_die;

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 void DWARFUnit::ClearDIEsRWLocked() {
   m_die_array.clear();
   m_die_array.shrink_to_fit();
 
   if (m_dwo_symbol_file)
     m_dwo_symbol_file->GetCompileUnit()->ClearDIEsRWLocked();
 }
 
+bool DWARFUnit::UpdateIsOptimized() {
+  const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
+  if (die)
+    return die->GetAttributeValueAsUnsigned(m_dwarf, this,
+                                            DW_AT_APPLE_optimized, 0) == 1;
+  return false;
+}
+
 void DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF *dwarf,
                                        DWARFDebugAranges *debug_aranges) {
   // This function is usually called if there in no .debug_aranges section in
   // order to produce a compile unit level set of address ranges that is
   // accurate.
 
   size_t num_debug_aranges = debug_aranges->GetNumRanges();
 
LanguageType DWARFUnit::GetLanguageType() {
 
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
   if (die)
     m_language_type = LanguageTypeFromDWARF(
         die->GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_language, 0));
   return m_language_type;
 }
 
-bool DWARFUnit::GetIsOptimized() {
-  if (m_is_optimized == eLazyBoolCalculate) {
-    const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
-    if (die) {
-      m_is_optimized = eLazyBoolNo;
-      if (die->GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_APPLE_optimized,
-                                           0) == 1) {
-        m_is_optimized = eLazyBoolYes;
-      }
-    }
-  }
-  return m_is_optimized == eLazyBoolYes;
-}
+bool DWARFUnit::GetIsOptimized() { return m_is_optimized.get(*this); }
 
 SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() const {
   return m_dwo_symbol_file.get();
 }
 
 dw_offset_t DWARFUnit::GetBaseObjOffset() const { return m_base_obj_offset; }
 
 const DWARFDebugAranges &DWARFUnit::GetFunctionAranges() {

source/Symbol/CompileUnit.cpp

 using namespace lldb_private;
 
 CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
                          const char *pathname, const lldb::user_id_t cu_sym_id,
                          lldb::LanguageType language,
                          lldb_private::LazyBool is_optimized)
     : ModuleChild(module_sp), FileSpec(pathname, false), UserID(cu_sym_id),
       m_user_data(user_data), m_language(language), m_flags(0),
-      m_support_files(), m_line_table_ap(), m_variables(),
-      m_is_optimized(is_optimized) {
+      m_support_files(), m_line_table_ap(), m_variables() {
+  if (is_optimized != eLazyBoolCalculate)
+    m_is_optimized.set(is_optimized == eLazyBoolYes);
   if (language != eLanguageTypeUnknown)
     m_flags.Set(flagsParsedLanguage);
   assert(module_sp);
 }
 
 CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
                          const FileSpec &fspec, const lldb::user_id_t cu_sym_id,
                          lldb::LanguageType language,
                          lldb_private::LazyBool is_optimized)
     : ModuleChild(module_sp), FileSpec(fspec), UserID(cu_sym_id),
       m_user_data(user_data), m_language(language), m_flags(0),
-      m_support_files(), m_line_table_ap(), m_variables(),
-      m_is_optimized(is_optimized) {
+      m_support_files(), m_line_table_ap(), m_variables() {
+  if (is_optimized != eLazyBoolCalculate)
+    m_is_optimized.set(is_optimized == eLazyBoolYes);
   if (language != eLanguageTypeUnknown)
     m_flags.Set(flagsParsedLanguage);
   assert(module_sp);
 }
 
 CompileUnit::~CompileUnit() {}
 
 void CompileUnit::CalculateSymbolContext(SymbolContext *sc) {
uint32_t CompileUnit::ResolveSymbolContext(const FileSpec &file_spec,
   } else if (file_spec_matches_cu_file_spec && !check_inlines) {
     // only append the context if we aren't looking for inline call sites by
     // file and line and if the file spec matches that of the compile unit
     sc_list.Append(sc);
   }
   return sc_list.GetSize() - prev_size;
 }
 
-bool CompileUnit::GetIsOptimized() {
-  if (m_is_optimized == eLazyBoolCalculate) {
-    m_is_optimized = eLazyBoolNo;
-    if (SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor()) {
-      SymbolContext sc;
-      CalculateSymbolContext(&sc);
-      if (symbol_vendor->ParseCompileUnitIsOptimized(sc))
-        m_is_optimized = eLazyBoolYes;
-    }
-  }
-  return m_is_optimized;
+bool CompileUnit::CalculateOptimized() {
+      return true;
+  return false;
 }
 
 void CompileUnit::SetVariableList(VariableListSP &variables) {
   m_variables = variables;
 }
 
 const std::vector<ConstString> &CompileUnit::GetImportedModules() {
   if (m_imported_modules.empty() &&

source/Target/ObjCLanguageRuntime.cpp

 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 ObjCLanguageRuntime::~ObjCLanguageRuntime() {}
 
 ObjCLanguageRuntime::ObjCLanguageRuntime(Process *process)
     : LanguageRuntime(process), m_impl_cache(),
-      m_has_new_literals_and_indexing(eLazyBoolCalculate),
       m_isa_to_descriptor(), m_hash_to_isa_map(), m_type_size_cache(),
       m_isa_to_descriptor_stop_id(UINT32_MAX), m_complete_class_cache(),
       m_negative_complete_class_cache() {}
 
 bool ObjCLanguageRuntime::AddClass(ObjCISA isa,
                                    const ClassDescriptorSP &descriptor_sp,
                                    const char *class_name) {
   if (isa != 0) {
bool ObjCLanguageRuntime::ClassDescriptor::IsPointerValid(
   if ((value % 2) == 1 && allow_tagged)
     return true;
   if ((value % ptr_size) == 0)
     return (check_version_specific ? CheckPointer(value, ptr_size) : true);
   else
     return false;
 }
 
+bool ObjCLanguageRuntime::ClassDescriptor::CalculateKVO() {
+  const char *class_name = GetClassName().AsCString();
+  if (class_name && *class_name)
+    return strstr(class_name, "NSKVONotifying_") == class_name;
+  return false;
+}
+
+bool ObjCLanguageRuntime::ClassDescriptor::CalculateCFType() {
+  const char *class_name = GetClassName().AsCString();
+  if (class_name && *class_name)
+    return strcmp(class_name, "__NSCFType") == 0 ||
+           strcmp(class_name, "NSCFType") == 0;
+  return false;
+}
+
 ObjCLanguageRuntime::ObjCISA
 ObjCLanguageRuntime::GetISA(const ConstString &name) {
   ISAToDescriptorIterator pos = GetDescriptorIterator(name);
   if (pos != m_isa_to_descriptor.end())
     return pos->first;
   return 0;
 }
 

unittests/Utility/CMakeLists.txt

 add_lldb_unittest(UtilityTests
   AnsiTerminalTest.cpp
   ArgsTest.cpp
   OptionsWithRawTest.cpp
   ArchSpecTest.cpp
   CleanUpTest.cpp
   ConstStringTest.cpp
   CompletionRequestTest.cpp
   EnvironmentTest.cpp
   FileSpecTest.cpp
   FlagsTest.cpp
   JSONTest.cpp
+  LazyTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   PredicateTest.cpp
   RegisterValueTest.cpp
   ScalarTest.cpp
   StateTest.cpp
   StatusTest.cpp
   StreamTeeTest.cpp

unittests/Utility/LazyTest.cpp

+//===-- LazyTest.cpp --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/Lazy.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+
+namespace {
+class LazyClass {
+  bool UpdateFoo() {
+    ++m_updates_called;
+    return m_foo_value;
+  }
+
+public:
+  LazyBoolMember<LazyClass, &LazyClass::UpdateFoo> m_foo;
+  bool getFoo() { return m_foo.get(*this); }
+  bool m_foo_value = true;
+  int m_updates_called = 0;
+};
+} // namespace
+
+TEST(LazyTest, UpdateCount) {
+  LazyClass l;
+  EXPECT_EQ(0, l.m_updates_called);
+
+  l.getFoo();
+  EXPECT_EQ(1, l.m_updates_called);
+  l.getFoo();
+  EXPECT_EQ(1, l.m_updates_called);
+  l.getFoo();
+  EXPECT_EQ(1, l.m_updates_called);
+}
+
+TEST(LazyTest, Value) {
+  {
+    LazyClass l1;
+    EXPECT_EQ(l1.m_foo_value, l1.getFoo());
+  }
+
+  {
+    LazyClass l2;
+    bool old_value = l2.m_foo_value;
+    l2.m_foo_value = !l2.m_foo_value;
+    EXPECT_NE(old_value, l2.getFoo());
+  }
+}
+
+TEST(LazyTest, Reset) {
+  LazyClass l;
+  EXPECT_EQ(0, l.m_updates_called);
+  l.m_foo.reset();
+  EXPECT_EQ(0, l.m_updates_called);
+
+  l.getFoo();
+  EXPECT_EQ(1, l.m_updates_called);
+
+  l.m_foo.reset();
+  EXPECT_EQ(1, l.m_updates_called);
+
+  l.getFoo();
+  EXPECT_EQ(2, l.m_updates_called);
+  l.getFoo();
+  EXPECT_EQ(2, l.m_updates_called);
+}