reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

  144     T value;
  172   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
  176   T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
  181   T &&getValue() && noexcept {
  206       ::new ((void *)std::addressof(value)) T(std::move(y));
  216   optional_detail::OptionalStorage<T> Storage;
  219   using value_type = T;
  224   Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
  227   Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
  230   Optional &operator=(T &&y) {
  241   static inline Optional create(const T *y) {
  245   Optional &operator=(const T &y) {
  253   const T *getPointer() const { return &Storage.getValue(); }
  254   T *getPointer() { return &Storage.getValue(); }
  255   const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  256   T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  260   const T *operator->() const { return getPointer(); }
  261   T *operator->() { return getPointer(); }
  262   const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
  263   T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
  266   constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
  271   T &&getValue() && { return std::move(Storage.getValue()); }
  272   T &&operator*() && { return std::move(Storage.getValue()); }
  275   T getValueOr(U &&value) && {

   48   Optional<T> Result;
   67   StringSwitch &Case(StringLiteral S, T Value) {
   74   StringSwitch& EndsWith(StringLiteral S, T Value) {
   81   StringSwitch& StartsWith(StringLiteral S, T Value) {
   88   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, T Value) {
   93                       T Value) {
   98                       StringLiteral S3, T Value) {
  103                       StringLiteral S3, StringLiteral S4, T Value) {
  109                       T Value) {
  115                       StringLiteral S6, T Value) {
  121                       StringLiteral S6, StringLiteral S7, T Value) {
  128                       T Value) {
  135                       StringLiteral S9, T Value) {
  140   StringSwitch &CaseLower(StringLiteral S, T Value) {
  147   StringSwitch &EndsWithLower(StringLiteral S, T Value) {
  154   StringSwitch &StartsWithLower(StringLiteral S, T Value) {
  161   StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, T Value) {
  166                            T Value) {
  171                            StringLiteral S3, T Value) {
  176                            StringLiteral S3, StringLiteral S4, T Value) {
  181   R Default(T Value) {
  181   R Default(T Value) {
  188   operator R() {

   91     T t;
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  145       std::is_copy_constructible<detail::trivial_helper<T>>::value;
  147       !std::is_copy_constructible<T>::value;
  151       std::is_move_constructible<detail::trivial_helper<T>>::value;
  153       !std::is_move_constructible<T>::value;
  157       is_copy_assignable<detail::trivial_helper<T>>::value;
  159       !is_copy_assignable<T>::value;
  163       is_move_assignable<detail::trivial_helper<T>>::value;
  165       !is_move_assignable<T>::value;
  169       std::is_destructible<detail::trivial_helper<T>>::value;

  937   virtual LazyBool CanUpdateWithInvalidExecutionContext() {

   60   LazyBool CanUpdateWithInvalidExecutionContext() override;
   72   llvm::Optional<LazyBool> m_can_update_with_invalid_exe_ctx;

  107   LazyBool CanUpdateWithInvalidExecutionContext() override {

  125   LazyBool CanUpdateWithInvalidExecutionContext() override {
  154   LazyBool m_might_have_children;
  156   LazyBool m_provides_value;

  136   LazyBool m_should_print;
  137   LazyBool m_is_nil;
  138   LazyBool m_is_uninit;
  139   LazyBool m_is_ptr;
  140   LazyBool m_is_ref;
  141   LazyBool m_is_aggregate;
  142   LazyBool m_is_instance_ptr;

  367   LazyBool m_is_interactive;
  368   LazyBool m_is_real_terminal;
  369   LazyBool m_supports_colors;

   78   LazyBool m_is_dashdash_alias;

   64   CommandInterpreterRunOptions(LazyBool stop_on_continue,
   65                                LazyBool stop_on_error, LazyBool stop_on_crash,
   65                                LazyBool stop_on_error, LazyBool stop_on_crash,
   66                                LazyBool echo_commands, LazyBool echo_comments,
   66                                LazyBool echo_commands, LazyBool echo_comments,
   67                                LazyBool print_results, LazyBool print_errors,
   67                                LazyBool print_results, LazyBool print_errors,
   68                                LazyBool add_to_history)
   84     LazyBool value = silent ? eLazyBoolNo : eLazyBoolYes;
  147   LazyBool m_stop_on_continue;
  148   LazyBool m_stop_on_error;
  149   LazyBool m_stop_on_crash;
  150   LazyBool m_echo_commands;
  151   LazyBool m_echo_comment_commands;
  152   LazyBool m_print_results;
  153   LazyBool m_print_errors;
  154   LazyBool m_add_to_history;
  157   static bool DefaultToYes(LazyBool flag) {
  166   static bool DefaultToNo(LazyBool flag) {
  259   bool HandleCommand(const char *command_line, LazyBool add_to_history,

  153   LazyBool m_indexes_computed; // eLazyBoolYes once we've tried to parse the

   77               lldb::LanguageType language, lldb_private::LazyBool is_optimized);
  116               lldb::LanguageType language, lldb_private::LazyBool is_optimized);
  408   lldb_private::LazyBool m_is_optimized;

  331   LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const;

  112   lldb_private::LazyBool CompareUnwindPlansForIdenticalInitialPCLocation(

  480   virtual LazyBool ShouldPrintAsOneLiner(void *type, ValueObject *valobj);

  458   lldb_private::LazyBool GetSourcedFromCompiler() const {
  463   void SetSourcedFromCompiler(lldb_private::LazyBool from_compiler) {
  469   lldb_private::LazyBool GetUnwindPlanValidAtAllInstructions() const {
  476       lldb_private::LazyBool valid_at_all_insn) {
  483   lldb_private::LazyBool GetUnwindPlanForSignalTrap() const {
  487   void SetUnwindPlanForSignalTrap(lldb_private::LazyBool is_for_signal_trap) {
  529   lldb_private::LazyBool m_plan_is_sourced_from_compiler;
  530   lldb_private::LazyBool m_plan_is_valid_at_all_instruction_locations;
  531   lldb_private::LazyBool m_plan_is_for_signal_trap;

  251                                          LazyBool &using_shared_cache,
  252                                          LazyBool &private_shared_cache) {

  215   virtual LazyBool IsLogicalTrue(ValueObject &valobj, Status &error);

  225   lldb_private::LazyBool disable_aslr;

  167   LazyBool m_override_should_notify;
  168   LazyBool m_override_should_stop;

  591                                       LazyBool check_inlines,
  592                                       LazyBool skip_prologue, bool internal,
  594                                       LazyBool move_to_nearest_code);
  604       LazyBool move_to_nearest_code);
  627       lldb::LanguageType requested_language, LazyBool skip_prologue,
  639       lldb::addr_t offset, LazyBool skip_prologue, bool internal,
  663       lldb::LanguageType language, lldb::addr_t offset, LazyBool skip_prologue,
  672                    LazyBool skip_prologue, bool internal,

  297   virtual lldb_private::LazyBool GetAssociatedWithLibdispatchQueue() {
  302       lldb_private::LazyBool associated_with_libdispatch_queue) {}
  498          LazyBool step_in_avoids_code_without_debug_info = eLazyBoolCalculate,
  499          LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
  514       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
  664       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
  673       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
  726       LazyBool step_in_avoids_code_without_debug_info = eLazyBoolCalculate,
  727       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
  736       LazyBool step_in_avoids_code_without_debug_info = eLazyBoolCalculate,
  737       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
  781       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
 1263   LazyBool m_override_should_notify;

  576   LazyBool GetCachedPlanExplainsStop() const {
  599   LazyBool m_cached_plan_explains_stop;

   26                         LazyBool step_in_avoids_code_without_debug_info,
   27                         LazyBool step_out_avoids_code_without_debug_info);
   33                         LazyBool step_in_avoids_code_without_debug_info,
   34                         LazyBool step_out_avoids_code_without_debug_info);
   78       Status &status, LazyBool avoid_code_without_debug_info);
   83       LazyBool step_in_avoids_code_without_debug_info,
   84       LazyBool step_out_avoids_code_without_debug_info);
   86   void SetupAvoidNoDebug(LazyBool step_in_avoids_code_without_debug_info,
   87                          LazyBool step_out_avoids_code_without_debug_info);

   23                     LazyBool step_out_avoids_code_without_debug_info,
   79       Status &status, LazyBool step_out_avoids_code_without_debug_info);
   81   void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info);

   25                           LazyBool step_out_avoids_no_debug);
   43   void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info);

  755     const LazyBool check_inlines = eLazyBoolCalculate;
  756     const LazyBool skip_prologue = eLazyBoolCalculate;
  759     const LazyBool move_to_nearest_code = eLazyBoolCalculate;
  784     const LazyBool skip_prologue = eLazyBoolCalculate;
  846     const LazyBool skip_prologue = eLazyBoolCalculate;
  905     const LazyBool skip_prologue = eLazyBoolCalculate;
  960     const LazyBool skip_prologue = eLazyBoolCalculate;
 1056     const LazyBool move_to_nearest_code = eLazyBoolCalculate;

  615       const LazyBool avoid_no_debug = eLazyBoolCalculate;
  676     const LazyBool step_out_avoids_code_without_debug_info =
  678     const LazyBool step_in_avoids_code_without_debug_info =
  718   const LazyBool avoid_no_debug = eLazyBoolCalculate;

   79   LazyBool m_include_recognized_arguments; // can be overridden with a setting

  521     LazyBool m_skip_prologue;
  524     LazyBool m_move_to_nearest_code;
  591       LazyBool check_inlines = eLazyBoolCalculate;

   48     LazyBool auto_apply_fixits;

  696     LazyBool m_keep_stopped;

  509   LazyBool m_step_in_avoid_no_debug;
  510   LazyBool m_step_out_avoid_no_debug;

  443     LazyBool is_logical_true = language->IsLogicalTrue(*this, error);

   91 LazyBool ValueObjectChild::CanUpdateWithInvalidExecutionContext() {

 1587                                        LazyBool lazy_add_to_history,

  900   LazyBool m_does_branch;
  901   LazyBool m_has_delay_slot;
  902   LazyBool m_is_call;

 1471     const LazyBool skip_prologue = eLazyBoolNo;

  458     lldb::addr_t &base_address, UUID &uuid, LazyBool &using_shared_cache,
  459     LazyBool &private_shared_cache) {

   59       lldb_private::LazyBool &using_shared_cache,
   60       lldb_private::LazyBool &private_shared_cache) override;

 1047     lldb::addr_t &base_address, UUID &uuid, LazyBool &using_shared_cache,
 1048     LazyBool &private_shared_cache) {

   63       lldb_private::LazyBool &using_shared_cache,
   64       lldb_private::LazyBool &private_shared_cache) override;

  138     LazyBool m_is_kvo;
  139     LazyBool m_is_cf;
  389   LazyBool m_has_new_literals_and_indexing;

 5656     LazyBool using_shared_cache;
 5657     LazyBool private_shared_cache;

 1227   LazyBool skip_prologue = eLazyBoolNo;

 1230   if (m_supports_mem_region == LazyBool::eLazyBoolNo) {
 1302     m_supports_mem_region = LazyBool::eLazyBoolNo;
 1314                            m_supports_mem_region = LazyBool::eLazyBoolNo;
 1327     m_supports_mem_region = LazyBool::eLazyBoolNo;
 1338   m_supports_mem_region = LazyBool::eLazyBoolYes;

  134   LazyBool m_supports_mem_region = eLazyBoolCalculate;

  144   LazyBool m_supports_qEcho;

  343   LazyBool SupportsAllocDeallocMemory() // const
  498   LazyBool m_supports_not_sending_acks;
  499   LazyBool m_supports_thread_suffix;
  500   LazyBool m_supports_threads_in_stop_reply;
  501   LazyBool m_supports_vCont_all;
  502   LazyBool m_supports_vCont_any;
  503   LazyBool m_supports_vCont_c;
  504   LazyBool m_supports_vCont_C;
  505   LazyBool m_supports_vCont_s;
  506   LazyBool m_supports_vCont_S;
  507   LazyBool m_qHostInfo_is_valid;
  508   LazyBool m_curr_pid_is_valid;
  509   LazyBool m_qProcessInfo_is_valid;
  510   LazyBool m_qGDBServerVersion_is_valid;
  511   LazyBool m_supports_alloc_dealloc_memory;
  512   LazyBool m_supports_memory_region_info;
  513   LazyBool m_supports_watchpoint_support_info;
  514   LazyBool m_supports_detach_stay_stopped;
  515   LazyBool m_watchpoints_trigger_after_instruction;
  516   LazyBool m_attach_or_wait_reply;
  517   LazyBool m_prepare_for_reg_writing_reply;
  518   LazyBool m_supports_p;
  519   LazyBool m_supports_x;
  520   LazyBool m_avoid_g_packets;
  521   LazyBool m_supports_QSaveRegisterState;
  522   LazyBool m_supports_qXfer_auxv_read;
  523   LazyBool m_supports_qXfer_libraries_read;
  524   LazyBool m_supports_qXfer_libraries_svr4_read;
  525   LazyBool m_supports_qXfer_features_read;
  526   LazyBool m_supports_qXfer_memory_map_read;
  527   LazyBool m_supports_augmented_libraries_svr4_read;
  528   LazyBool m_supports_jThreadExtendedInfo;
  529   LazyBool m_supports_jLoadedDynamicLibrariesInfos;
  530   LazyBool m_supports_jGetSharedCacheInfo;
  531   LazyBool m_supports_QPassSignals;
  532   LazyBool m_supports_error_string_reply;

 1762     LazyBool associated_with_dispatch_queue, addr_t dispatch_queue_t,
 2038   LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
 2195     LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
 3048   LazyBool supported = m_gdb_comm.SupportsAllocDeallocMemory();

  368                     lldb_private::LazyBool associated_with_libdispatch_queue,

   72                                    LazyBool associated_with_libdispatch_queue) {
  205 LazyBool ThreadGDBRemote::GetAssociatedWithLibdispatchQueue() {
  210     LazyBool associated_with_libdispatch_queue) {

   82                     lldb_private::LazyBool associated_with_libdispatch_queue);
   84   lldb_private::LazyBool GetAssociatedWithLibdispatchQueue() override;
   87       lldb_private::LazyBool associated_with_libdispatch_queue) override;
  102   lldb_private::LazyBool m_associated_with_libdispatch_queue;

 1632   const LazyBool skip_prologue = eLazyBoolCalculate;

  281   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;

  481   lldb_private::LazyBool m_supports_DW_AT_APPLE_objc_complete_type;

  303   lldb_private::LazyBool m_supports_DW_AT_APPLE_objc_complete_type;

  431   LazyBool optimized = eLazyBoolNo;

 1750   LazyBool optimized = eLazyBoolNo;

   22                          lldb_private::LazyBool is_optimized)
   35                          lldb_private::LazyBool is_optimized)

  691 LazyBool CompilerType::ShouldPrintAsOneLiner(ValueObject *valobj) const {

  350 LazyBool FuncUnwinders::CompareUnwindPlansForIdenticalInitialPCLocation(
  352   LazyBool plans_are_identical = eLazyBoolCalculate;

  142 LazyBool TypeSystem::ShouldPrintAsOneLiner(void *type, ValueObject *valobj) {

  437 LazyBool Language::IsLogicalTrue(ValueObject &valobj, Status &error) {

  161   LazyBool path_is_relative = eLazyBoolCalculate;

  309     LazyBool move_to_nearest_code) {
  324                                       LazyBool check_inlines,
  325                                       LazyBool skip_prologue, bool internal,
  327                                       LazyBool move_to_nearest_code) {
  417     lldb::addr_t offset, LazyBool skip_prologue, bool internal, bool hardware) {
  442                          LazyBool skip_prologue, bool internal, bool hardware) {
  468                          LazyBool skip_prologue, bool internal, bool hardware) {
  551     lldb::LanguageType requested_language, LazyBool skip_prologue,

 1361     Status &status, LazyBool step_out_avoids_code_withoug_debug_info) {
 1376     Status &status, LazyBool step_out_avoids_code_withoug_debug_info) {
 1389     LazyBool step_in_avoids_code_without_debug_info,
 1390     LazyBool step_out_avoids_code_without_debug_info) {
 1410     LazyBool step_in_avoids_code_without_debug_info,
 1411     LazyBool step_out_avoids_code_without_debug_info) {
 1424     Status &status, LazyBool step_out_avoids_code_without_debug_info) {
 2104                       LazyBool step_in_avoids_code_without_debug_info,
 2105                       LazyBool step_out_avoids_code_without_debug_info)
 2140                         LazyBool step_out_avoids_code_without_debug_info) {

   37     LazyBool step_in_avoids_code_without_debug_info,
   38     LazyBool step_out_avoids_code_without_debug_info)
   53     lldb::RunMode stop_others, LazyBool step_in_avoids_code_without_debug_info,
   54     LazyBool step_out_avoids_code_without_debug_info)
   69     LazyBool step_in_avoids_code_without_debug_info,
   70     LazyBool step_out_avoids_code_without_debug_info) {

   37     LazyBool step_out_avoids_code_without_debug_info,
  152     LazyBool step_out_avoids_code_without_debug_info) {
  451         const LazyBool avoid_no_debug = eLazyBoolNo;

   34     LazyBool step_out_avoids_code_without_debug_info)
   78     LazyBool step_out_avoids_code_without_debug_info) {

  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  475 	{ __a.construct(__p, std::forward<_Args>(__args)...); }

   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
  136     inline _GLIBCXX17_CONSTEXPR _Tp*
  137     addressof(_Tp& __r) noexcept
  143     const _Tp* addressof(const _Tp&&) = delete;
  143     const _Tp* addressof(const _Tp&&) = delete;

  343 		   _Args&&... __args)
  344 	: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
  688     allocate_shared(const _Alloc& __a, _Args&&... __args)
  691 			     std::forward<_Args>(__args)...);
  703     make_shared(_Args&&... __args)
  707 				       std::forward<_Args>(__args)...);

 1317 		     _Args&&... __args)
 1328 			      std::forward<_Args>(__args)...);

  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  825     : public __is_destructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1142     : public is_constructible<_Tp, const _Tp&>
 1142     : public is_constructible<_Tp, const _Tp&>
 1148     : public __is_copy_constructible_impl<_Tp>
 1160     : public is_constructible<_Tp, _Tp&&>
 1160     : public is_constructible<_Tp, _Tp&&>
 1166     : public __is_move_constructible_impl<_Tp>
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };