#include <unistd.h>
#include <vector>
-/// \def DISALLOW_COPY_AND_ASSIGN(TypeName)
-/// Macro definition for easily disallowing copy constructor and
-/// assignment operators in C++ classes.
-#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
- TypeName(const TypeName &); \
- const TypeName &operator=(const TypeName &)
-
extern "C" {
int accept$NOCANCEL(int, struct sockaddr *__restrict, socklen_t *__restrict);
int close$NOCANCEL(int);
char *m_str;
private:
- DISALLOW_COPY_AND_ASSIGN(String);
+ String(const String &) = delete;
+ const String &operator=(const String &) = delete;
};
// Type definitions
void *callback_baton);
private:
- DISALLOW_COPY_AND_ASSIGN(SBCommunication);
+ SBCommunication(const SBCommunication &) = delete;
+ const SBCommunication &operator=(const SBCommunication &) = delete;
lldb_private::Communication *m_opaque;
bool m_opaque_owned;
lldb_private::Stream &ref();
private:
- DISALLOW_COPY_AND_ASSIGN(SBStream);
+ SBStream(const SBStream &) = delete;
+ const SBStream &operator=(const SBStream &) = delete;
std::unique_ptr<lldb_private::Stream> m_opaque_up;
bool m_is_file;
};
lldb::BreakpointSP m_new_breakpoint_sp;
BreakpointLocationCollection m_locations;
- DISALLOW_COPY_AND_ASSIGN(BreakpointEventData);
+ BreakpointEventData(const BreakpointEventData &) = delete;
+ const BreakpointEventData &operator=(const BreakpointEventData &) = delete;
};
// Saving & restoring breakpoints:
void SendBreakpointChangedEvent(BreakpointEventData *data);
- DISALLOW_COPY_AND_ASSIGN(Breakpoint);
+ Breakpoint(const Breakpoint &) = delete;
+ const Breakpoint &operator=(const Breakpoint &) = delete;
};
} // namespace lldb_private
BreakpointIDArray m_breakpoint_ids;
BreakpointID m_invalid_id;
- DISALLOW_COPY_AND_ASSIGN(BreakpointIDList);
+ BreakpointIDList(const BreakpointIDList &) = delete;
+ const BreakpointIDList &operator=(const BreakpointIDList &) = delete;
};
} // namespace lldb_private
}
private:
- DISALLOW_COPY_AND_ASSIGN(BreakpointList);
+ BreakpointList(const BreakpointList &) = delete;
+ const BreakpointList &operator=(const BreakpointList &) = delete;
};
} // namespace lldb_private
void SendBreakpointLocationChangedEvent(lldb::BreakpointEventType eventKind);
- DISALLOW_COPY_AND_ASSIGN(BreakpointLocation);
+ BreakpointLocation(const BreakpointLocation &) = delete;
+ const BreakpointLocation &operator=(const BreakpointLocation &) = delete;
};
} // namespace lldb_private
// Subclass identifier (for llvm isa/dyn_cast)
const unsigned char SubclassID;
- DISALLOW_COPY_AND_ASSIGN(BreakpointResolver);
+ BreakpointResolver(const BreakpointResolver &) = delete;
+ const BreakpointResolver &operator=(const BreakpointResolver &) = delete;
};
} // namespace lldb_private
// to a Section+Offset address in this module, whenever that module gets
// around to being loaded.
private:
- DISALLOW_COPY_AND_ASSIGN(BreakpointResolverAddress);
+ BreakpointResolverAddress(const BreakpointResolverAddress &) = delete;
+ const BreakpointResolverAddress &
+ operator=(const BreakpointResolverAddress &) = delete;
};
} // namespace lldb_private
bool m_exact_match;
private:
- DISALLOW_COPY_AND_ASSIGN(BreakpointResolverFileLine);
+ BreakpointResolverFileLine(const BreakpointResolverFileLine &) = delete;
+ const BreakpointResolverFileLine &
+ operator=(const BreakpointResolverFileLine &) = delete;
};
} // namespace lldb_private
// comp_unit passed in.
private:
- DISALLOW_COPY_AND_ASSIGN(BreakpointResolverFileRegex);
+ BreakpointResolverFileRegex(const BreakpointResolverFileRegex &) = delete;
+ const BreakpointResolverFileRegex &
+ operator=(const BreakpointResolverFileRegex &) = delete;
};
} // namespace lldb_private
// SBStructuredData).
StructuredData::GenericSP m_implementation_sp;
- DISALLOW_COPY_AND_ASSIGN(BreakpointResolverScripted);
+ BreakpointResolverScripted(const BreakpointResolverScripted &) = delete;
+ const BreakpointResolverScripted &
+ operator=(const BreakpointResolverScripted &) = delete;
};
} // namespace lldb_private
const lldb::BreakpointLocationSP &owner, lldb::addr_t m_addr,
bool use_hardware);
- DISALLOW_COPY_AND_ASSIGN(BreakpointSite);
+ BreakpointSite(const BreakpointSite &) = delete;
+ const BreakpointSite &operator=(const BreakpointSite &) = delete;
};
} // namespace lldb_private
private:
// For Stoppoint only
- DISALLOW_COPY_AND_ASSIGN(Stoppoint);
+ Stoppoint(const Stoppoint &) = delete;
+ const Stoppoint &operator=(const Stoppoint &) = delete;
};
} // namespace lldb_private
private:
// For StoppointLocation only
- DISALLOW_COPY_AND_ASSIGN(StoppointLocation);
+ StoppointLocation(const StoppointLocation &) = delete;
+ const StoppointLocation &operator=(const StoppointLocation &) = delete;
StoppointLocation() = delete;
};
lldb::WatchpointEventType m_watchpoint_event;
lldb::WatchpointSP m_new_watchpoint_sp;
- DISALLOW_COPY_AND_ASSIGN(WatchpointEventData);
+ WatchpointEventData(const WatchpointEventData &) = delete;
+ const WatchpointEventData &operator=(const WatchpointEventData &) = delete;
};
Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
void SendWatchpointChangedEvent(WatchpointEventData *data);
- DISALLOW_COPY_AND_ASSIGN(Watchpoint);
+ Watchpoint(const Watchpoint &) = delete;
+ const Watchpoint &operator=(const Watchpoint &) = delete;
};
} // namespace lldb_private
std::vector<AddressRange> m_address_ranges;
private:
- DISALLOW_COPY_AND_ASSIGN(AddressResolver);
+ AddressResolver(const AddressResolver &) = delete;
+ const AddressResolver &operator=(const AddressResolver &) = delete;
};
} // namespace lldb_private
// functions or not.
private:
- DISALLOW_COPY_AND_ASSIGN(AddressResolverFileLine);
+ AddressResolverFileLine(const AddressResolverFileLine &) = delete;
+ const AddressResolverFileLine &
+ operator=(const AddressResolverFileLine &) = delete;
};
} // namespace lldb_private
AddressResolver::MatchType m_match_type;
private:
- DISALLOW_COPY_AND_ASSIGN(AddressResolverName);
+ AddressResolverName(const AddressResolverName &) = delete;
+ const AddressResolverName &operator=(const AddressResolverName &) = delete;
};
} // namespace lldb_private
size_t GetCachedBytes(void *dst, size_t dst_len);
private:
- DISALLOW_COPY_AND_ASSIGN(Communication);
+ Communication(const Communication &) = delete;
+ const Communication &operator=(const Communication &) = delete;
};
} // namespace lldb_private
// object
Debugger(lldb::LogOutputCallback m_log_callback, void *baton);
- DISALLOW_COPY_AND_ASSIGN(Debugger);
+ Debugger(const Debugger &) = delete;
+ const Debugger &operator=(const Debugger &) = delete;
};
} // namespace lldb_private
protected:
std::string m_description;
- DISALLOW_COPY_AND_ASSIGN(PseudoInstruction);
+ PseudoInstruction(const PseudoInstruction &) = delete;
+ const PseudoInstruction &operator=(const PseudoInstruction &) = delete;
};
class Disassembler : public std::enable_shared_from_this<Disassembler>,
private:
// For Disassembler only
- DISALLOW_COPY_AND_ASSIGN(Disassembler);
+ Disassembler(const Disassembler &) = delete;
+ const Disassembler &operator=(const Disassembler &) = delete;
};
} // namespace lldb_private
private:
// For EmulateInstruction only
- DISALLOW_COPY_AND_ASSIGN(EmulateInstruction);
+ EmulateInstruction(const EmulateInstruction &) = delete;
+ const EmulateInstruction &operator=(const EmulateInstruction &) = delete;
};
} // namespace lldb_private
// functions or not.
private:
- DISALLOW_COPY_AND_ASSIGN(FileLineResolver);
+ FileLineResolver(const FileLineResolver &) = delete;
+ const FileLineResolver &operator=(const FileLineResolver &) = delete;
};
} // namespace lldb_private
public:
Highlighter() = default;
virtual ~Highlighter() = default;
- DISALLOW_COPY_AND_ASSIGN(Highlighter);
+ Highlighter(const Highlighter &) = delete;
+ const Highlighter &operator=(const Highlighter &) = delete;
/// Returns a human readable name for the selected highlighter.
virtual llvm::StringRef GetName() const = 0;
bool m_active;
private:
- DISALLOW_COPY_AND_ASSIGN(IOHandler);
+ IOHandler(const IOHandler &) = delete;
+ const IOHandler &operator=(const IOHandler &) = delete;
};
/// A delegate class for use with IOHandler subclasses.
IOHandler *m_top = nullptr;
private:
- DISALLOW_COPY_AND_ASSIGN(IOHandlerStack);
+ IOHandlerStack(const IOHandlerStack &) = delete;
+ const IOHandlerStack &operator=(const IOHandlerStack &) = delete;
};
} // namespace lldb_private
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types);
- DISALLOW_COPY_AND_ASSIGN(Module);
+ Module(const Module &) = delete;
+ const Module &operator=(const Module &) = delete;
};
} // namespace lldb_private
// This is specified as
// as a multiple number of a host bytes
private:
- DISALLOW_COPY_AND_ASSIGN(Section);
+ Section(const Section &) = delete;
+ const Section &operator=(const Section &) = delete;
};
} // namespace lldb_private
lldb::DebuggerWP m_debugger_wp;
private:
- DISALLOW_COPY_AND_ASSIGN(SourceManager);
+ SourceManager(const SourceManager &) = delete;
+ const SourceManager &operator=(const SourceManager &) = delete;
};
bool operator==(const SourceManager::File &lhs, const SourceManager::File &rhs);
size_t WriteImpl(const void *s, size_t length) override;
private:
- DISALLOW_COPY_AND_ASSIGN(StreamFile);
+ StreamFile(const StreamFile &) = delete;
+ const StreamFile &operator=(const StreamFile &) = delete;
};
} // namespace lldb_private
mutable std::recursive_mutex m_mutex;
// For ThreadSafeValue only
- DISALLOW_COPY_AND_ASSIGN(ThreadSafeValue);
+ ThreadSafeValue(const ThreadSafeValue &) = delete;
+ const ThreadSafeValue &operator=(const ThreadSafeValue &) = delete;
};
} // namespace lldb_private
const GetValueForExpressionPathOptions &options,
ExpressionPathAftermath *final_task_on_target);
- DISALLOW_COPY_AND_ASSIGN(ValueObject);
+ ValueObject(const ValueObject &) = delete;
+ const ValueObject &operator=(const ValueObject &) = delete;
};
// A value object manager class that is seeded with the static variable value
CompilerType m_cast_type;
private:
- DISALLOW_COPY_AND_ASSIGN(ValueObjectCast);
+ ValueObjectCast(const ValueObjectCast &) = delete;
+ const ValueObjectCast &operator=(const ValueObjectCast &) = delete;
};
} // namespace lldb_private
AddressType child_ptr_or_ref_addr_type,
uint64_t language_flags);
- DISALLOW_COPY_AND_ASSIGN(ValueObjectChild);
+ ValueObjectChild(const ValueObjectChild &) = delete;
+ const ValueObjectChild &operator=(const ValueObjectChild &) = delete;
};
} // namespace lldb_private
ValueObjectConstResult(ExecutionContextScope *exe_scope,
ValueObjectManager &manager, const Status &error);
- DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResult);
+ ValueObjectConstResult(const ValueObjectConstResult &) = delete;
+ const ValueObjectConstResult &
+ operator=(const ValueObjectConstResult &) = delete;
};
} // namespace lldb_private
friend class ValueObjectConstResult;
friend class ValueObjectConstResultImpl;
- DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResultCast);
+ ValueObjectConstResultCast(const ValueObjectConstResultCast &) = delete;
+ const ValueObjectConstResultCast &
+ operator=(const ValueObjectConstResultCast &) = delete;
};
} // namespace lldb_private
friend class ValueObjectConstResult;
friend class ValueObjectConstResultImpl;
- DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResultChild);
+ ValueObjectConstResultChild(const ValueObjectConstResultChild &) = delete;
+ const ValueObjectConstResultChild &
+ operator=(const ValueObjectConstResultChild &) = delete;
};
} // namespace lldb_private
lldb::ValueObjectSP m_load_addr_backend;
lldb::ValueObjectSP m_address_of_backend;
- DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResultImpl);
+ ValueObjectConstResultImpl(const ValueObjectConstResultImpl &) = delete;
+ const ValueObjectConstResultImpl &
+ operator=(const ValueObjectConstResultImpl &) = delete;
};
} // namespace lldb_private
ValueObjectDynamicValue(ValueObject &parent,
lldb::DynamicValueType use_dynamic);
- DISALLOW_COPY_AND_ASSIGN(ValueObjectDynamicValue);
+ ValueObjectDynamicValue(const ValueObjectDynamicValue &) = delete;
+ const ValueObjectDynamicValue &
+ operator=(const ValueObjectDynamicValue &) = delete;
};
} // namespace lldb_private
ValueObjectManager &manager, llvm::StringRef name,
const Address &address, const CompilerType &ast_type);
// For ValueObject only
- DISALLOW_COPY_AND_ASSIGN(ValueObjectMemory);
+ ValueObjectMemory(const ValueObjectMemory &) = delete;
+ const ValueObjectMemory &operator=(const ValueObjectMemory &) = delete;
};
} // namespace lldb_private
lldb::RegisterContextSP ®_ctx_sp, uint32_t set_idx);
// For ValueObject only
- DISALLOW_COPY_AND_ASSIGN(ValueObjectRegisterSet);
+ ValueObjectRegisterSet(const ValueObjectRegisterSet &) = delete;
+ const ValueObjectRegisterSet &
+ operator=(const ValueObjectRegisterSet &) = delete;
};
class ValueObjectRegister : public ValueObject {
lldb::RegisterContextSP ®_ctx_sp, uint32_t reg_num);
// For ValueObject only
- DISALLOW_COPY_AND_ASSIGN(ValueObjectRegister);
+ ValueObjectRegister(const ValueObjectRegister &) = delete;
+ const ValueObjectRegister &operator=(const ValueObjectRegister &) = delete;
};
} // namespace lldb_private
void CopyValueData(ValueObject *source);
- DISALLOW_COPY_AND_ASSIGN(ValueObjectSynthetic);
+ ValueObjectSynthetic(const ValueObjectSynthetic &) = delete;
+ const ValueObjectSynthetic &operator=(const ValueObjectSynthetic &) = delete;
};
} // namespace lldb_private
ValueObjectManager &manager,
const lldb::VariableSP &var_sp);
// For ValueObject only
- DISALLOW_COPY_AND_ASSIGN(ValueObjectVariable);
+ ValueObjectVariable(const ValueObjectVariable &) = delete;
+ const ValueObjectVariable &operator=(const ValueObjectVariable &) = delete;
};
} // namespace lldb_private
TypeOrName m_type;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeNameSpecifierImpl);
+ TypeNameSpecifierImpl(const TypeNameSpecifierImpl &) = delete;
+ const TypeNameSpecifierImpl &
+ operator=(const TypeNameSpecifierImpl &) = delete;
};
} // namespace lldb_private
BackEndType m_format_map;
std::string m_name;
- DISALLOW_COPY_AND_ASSIGN(FormattersContainer);
+ FormattersContainer(const FormattersContainer &) = delete;
+ const FormattersContainer &operator=(const FormattersContainer &) = delete;
void Add_Impl(MapKeyType type, const MapValueType &entry,
RegularExpression *dummy) {
uint32_t m_my_revision;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl);
+ TypeFormatImpl(const TypeFormatImpl &) = delete;
+ const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete;
};
class TypeFormatImpl_Format : public TypeFormatImpl {
lldb::Format m_format;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_Format);
+ TypeFormatImpl_Format(const TypeFormatImpl_Format &) = delete;
+ const TypeFormatImpl_Format &
+ operator=(const TypeFormatImpl_Format &) = delete;
};
class TypeFormatImpl_EnumType : public TypeFormatImpl {
mutable std::unordered_map<void *, CompilerType> m_types;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_EnumType);
+ TypeFormatImpl_EnumType(const TypeFormatImpl_EnumType &) = delete;
+ const TypeFormatImpl_EnumType &
+ operator=(const TypeFormatImpl_EnumType &) = delete;
};
} // namespace lldb_private
private:
Kind m_kind;
- DISALLOW_COPY_AND_ASSIGN(TypeSummaryImpl);
+ TypeSummaryImpl(const TypeSummaryImpl &) = delete;
+ const TypeSummaryImpl &operator=(const TypeSummaryImpl &) = delete;
};
// simple string-based summaries, using ${var to show data
}
private:
- DISALLOW_COPY_AND_ASSIGN(StringSummaryFormat);
+ StringSummaryFormat(const StringSummaryFormat &) = delete;
+ const StringSummaryFormat &operator=(const StringSummaryFormat &) = delete;
};
// summaries implemented via a C++ function
typedef std::shared_ptr<CXXFunctionSummaryFormat> SharedPointer;
private:
- DISALLOW_COPY_AND_ASSIGN(CXXFunctionSummaryFormat);
+ CXXFunctionSummaryFormat(const CXXFunctionSummaryFormat &) = delete;
+ const CXXFunctionSummaryFormat &
+ operator=(const CXXFunctionSummaryFormat &) = delete;
};
// Python-based summaries, running script code to show data
typedef std::shared_ptr<ScriptSummaryFormat> SharedPointer;
private:
- DISALLOW_COPY_AND_ASSIGN(ScriptSummaryFormat);
+ ScriptSummaryFormat(const ScriptSummaryFormat &) = delete;
+ const ScriptSummaryFormat &operator=(const ScriptSummaryFormat &) = delete;
};
} // namespace lldb_private
private:
bool m_valid;
- DISALLOW_COPY_AND_ASSIGN(SyntheticChildrenFrontEnd);
+ SyntheticChildrenFrontEnd(const SyntheticChildrenFrontEnd &) = delete;
+ const SyntheticChildrenFrontEnd &
+ operator=(const SyntheticChildrenFrontEnd &) = delete;
};
class SyntheticValueProviderFrontEnd : public SyntheticChildrenFrontEnd {
lldb::ValueObjectSP GetSyntheticValue() override = 0;
private:
- DISALLOW_COPY_AND_ASSIGN(SyntheticValueProviderFrontEnd);
+ SyntheticValueProviderFrontEnd(const SyntheticValueProviderFrontEnd &) =
+ delete;
+ const SyntheticValueProviderFrontEnd &
+ operator=(const SyntheticValueProviderFrontEnd &) = delete;
};
class SyntheticChildren {
Flags m_flags;
private:
- DISALLOW_COPY_AND_ASSIGN(SyntheticChildren);
+ SyntheticChildren(const SyntheticChildren &) = delete;
+ const SyntheticChildren &operator=(const SyntheticChildren &) = delete;
};
class TypeFilterImpl : public SyntheticChildren {
private:
TypeFilterImpl *filter;
- DISALLOW_COPY_AND_ASSIGN(FrontEnd);
+ FrontEnd(const FrontEnd &) = delete;
+ const FrontEnd &operator=(const FrontEnd &) = delete;
};
SyntheticChildrenFrontEnd::AutoPointer
typedef std::shared_ptr<TypeFilterImpl> SharedPointer;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeFilterImpl);
+ TypeFilterImpl(const TypeFilterImpl &) = delete;
+ const TypeFilterImpl &operator=(const TypeFilterImpl &) = delete;
};
class CXXSyntheticChildren : public SyntheticChildren {
std::string m_description;
private:
- DISALLOW_COPY_AND_ASSIGN(CXXSyntheticChildren);
+ CXXSyntheticChildren(const CXXSyntheticChildren &) = delete;
+ const CXXSyntheticChildren &operator=(const CXXSyntheticChildren &) = delete;
};
class ScriptedSyntheticChildren : public SyntheticChildren {
StructuredData::ObjectSP m_wrapper_sp;
ScriptInterpreter *m_interpreter;
- DISALLOW_COPY_AND_ASSIGN(FrontEnd);
+ FrontEnd(const FrontEnd &) = delete;
+ const FrontEnd &operator=(const FrontEnd &) = delete;
};
SyntheticChildrenFrontEnd::AutoPointer
}
private:
- DISALLOW_COPY_AND_ASSIGN(ScriptedSyntheticChildren);
+ ScriptedSyntheticChildren(const ScriptedSyntheticChildren &) = delete;
+ const ScriptedSyntheticChildren &
+ operator=(const ScriptedSyntheticChildren &) = delete;
};
} // namespace lldb_private
friend struct StringSummaryFormat;
- DISALLOW_COPY_AND_ASSIGN(ValueObjectPrinter);
+ ValueObjectPrinter(const ValueObjectPrinter &) = delete;
+ const ValueObjectPrinter &operator=(const ValueObjectPrinter &) = delete;
};
} // namespace lldb_private
size_t size, uint32_t permissions, uint8_t alignment,
AllocationPolicy m_policy);
- DISALLOW_COPY_AND_ASSIGN(Allocation);
+ Allocation(const Allocation &) = delete;
+ const Allocation &operator=(const Allocation &) = delete;
};
static_assert(sizeof(Allocation) <=
void CalculateInteractiveAndTerminal();
private:
- DISALLOW_COPY_AND_ASSIGN(File);
+ File(const File &) = delete;
+ const File &operator=(const File &) = delete;
};
class NativeFile : public File {
std::mutex offset_access_mutex;
private:
- DISALLOW_COPY_AND_ASSIGN(NativeFile);
+ NativeFile(const NativeFile &) = delete;
+ const NativeFile &operator=(const NativeFile &) = delete;
};
} // namespace lldb_private
class HostThread;
class HostNativeProcessBase {
- DISALLOW_COPY_AND_ASSIGN(HostNativeProcessBase);
+ HostNativeProcessBase(const HostNativeProcessBase &) = delete;
+ const HostNativeProcessBase &
+ operator=(const HostNativeProcessBase &) = delete;
public:
HostNativeProcessBase() : m_process(LLDB_INVALID_PROCESS) {}
class HostNativeThreadBase {
friend class ThreadLauncher;
- DISALLOW_COPY_AND_ASSIGN(HostNativeThreadBase);
+ HostNativeThreadBase(const HostNativeThreadBase &) = delete;
+ const HostNativeThreadBase &operator=(const HostNativeThreadBase &) = delete;
public:
HostNativeThreadBase();
int m_signo;
friend class MainLoop;
- DISALLOW_COPY_AND_ASSIGN(SignalHandle);
+ SignalHandle(const SignalHandle &) = delete;
+ const SignalHandle &operator=(const SignalHandle &) = delete;
};
struct SignalInfo {
IOObject::WaitableHandle m_handle;
friend class MainLoopBase;
- DISALLOW_COPY_AND_ASSIGN(ReadHandle);
+ ReadHandle(const ReadHandle &) = delete;
+ const ReadHandle &operator=(const ReadHandle &) = delete;
};
private:
- DISALLOW_COPY_AND_ASSIGN(MainLoopBase);
+ MainLoopBase(const MainLoopBase &) = delete;
+ const MainLoopBase &operator=(const MainLoopBase &) = delete;
};
} // namespace lldb_private
ProcessRunLock *m_lock;
private:
- DISALLOW_COPY_AND_ASSIGN(ProcessRunLocker);
+ ProcessRunLocker(const ProcessRunLocker &) = delete;
+ const ProcessRunLocker &operator=(const ProcessRunLocker &) = delete;
};
protected:
bool m_running;
private:
- DISALLOW_COPY_AND_ASSIGN(ProcessRunLock);
+ ProcessRunLock(const ProcessRunLock &) = delete;
+ const ProcessRunLock &operator=(const ProcessRunLock &) = delete;
};
} // namespace lldb_private
int m_slave_fd; ///< The file descriptor for the slave.
private:
- DISALLOW_COPY_AND_ASSIGN(PseudoTerminal);
+ PseudoTerminal(const PseudoTerminal &) = delete;
+ const PseudoTerminal &operator=(const PseudoTerminal &) = delete;
};
} // namespace lldb_private
private:
// For RegisterContext only
- DISALLOW_COPY_AND_ASSIGN(NativeRegisterContext);
+ NativeRegisterContext(const NativeRegisterContext &) = delete;
+ const NativeRegisterContext &
+ operator=(const NativeRegisterContext &) = delete;
};
} // namespace lldb_private
private:
void InitializeSocket(Socket *socket);
- DISALLOW_COPY_AND_ASSIGN(ConnectionFileDescriptor);
+ ConnectionFileDescriptor(const ConnectionFileDescriptor &) = delete;
+ const ConnectionFileDescriptor &
+ operator=(const ConnectionFileDescriptor &) = delete;
};
} // namespace lldb_private
namespace lldb_private {
class HostThreadPosix : public HostNativeThreadBase {
- DISALLOW_COPY_AND_ASSIGN(HostThreadPosix);
+ HostThreadPosix(const HostThreadPosix &) = delete;
+ const HostThreadPosix &operator=(const HostThreadPosix &) = delete;
public:
HostThreadPosix();
std::string m_uri;
- DISALLOW_COPY_AND_ASSIGN(ConnectionGenericFile);
+ ConnectionGenericFile(const ConnectionGenericFile &) = delete;
+ const ConnectionGenericFile &
+ operator=(const ConnectionGenericFile &) = delete;
};
}
namespace lldb_private {
class HostThreadWindows : public HostNativeThreadBase {
- DISALLOW_COPY_AND_ASSIGN(HostThreadWindows);
+ HostThreadWindows(const HostThreadWindows &) = delete;
+ const HostThreadWindows &operator=(const HostThreadWindows &) = delete;
public:
HostThreadWindows();
static const char g_repeat_char = '!';
private:
- DISALLOW_COPY_AND_ASSIGN(CommandHistory);
+ CommandHistory(const CommandHistory &) = delete;
+ const CommandHistory &operator=(const CommandHistory &) = delete;
typedef std::vector<std::string> History;
mutable std::recursive_mutex m_mutex;
bool m_is_removable;
private:
- DISALLOW_COPY_AND_ASSIGN(CommandObjectRegexCommand);
+ CommandObjectRegexCommand(const CommandObjectRegexCommand &) = delete;
+ const CommandObjectRegexCommand &
+ operator=(const CommandObjectRegexCommand &) = delete;
};
} // namespace lldb_private
OptionValueString summary_string; // a summary string
private:
- DISALLOW_COPY_AND_ASSIGN(OptionGroupVariable);
+ OptionGroupVariable(const OptionGroupVariable &) = delete;
+ const OptionGroupVariable &operator=(const OptionGroupVariable &) = delete;
};
} // namespace lldb_private
bool watch_type_specified;
private:
- DISALLOW_COPY_AND_ASSIGN(OptionGroupWatchpoint);
+ OptionGroupWatchpoint(const OptionGroupWatchpoint &) = delete;
+ const OptionGroupWatchpoint &
+ operator=(const OptionGroupWatchpoint &) = delete;
};
} // namespace lldb_private
virtual ~ScriptInterpreterLocker() = default;
private:
- DISALLOW_COPY_AND_ASSIGN(ScriptInterpreterLocker);
+ ScriptInterpreterLocker(const ScriptInterpreterLocker &) = delete;
+ const ScriptInterpreterLocker &
+ operator=(const ScriptInterpreterLocker &) = delete;
};
class ScriptInterpreter : public PluginInterface {
Block *GetSiblingForChild(const Block *child_block) const;
private:
- DISALLOW_COPY_AND_ASSIGN(Block);
+ Block(const Block &) = delete;
+ const Block &operator=(const Block &) = delete;
};
} // namespace lldb_private
(1u << 6) ///< Have we parsed the debug macros already?
};
- DISALLOW_COPY_AND_ASSIGN(CompileUnit);
+ CompileUnit(const CompileUnit &) = delete;
+ const CompileUnit &operator=(const CompileUnit &) = delete;
};
} // namespace lldb_private
}
private:
- DISALLOW_COPY_AND_ASSIGN(DebugMacros);
+ DebugMacros(const DebugMacros &) = delete;
+ const DebugMacros &operator=(const DebugMacros &) = delete;
std::vector<DebugMacroEntry> m_macro_entries;
};
private:
// For DeclVendor only
- DISALLOW_COPY_AND_ASSIGN(DeclVendor);
+ DeclVendor(const DeclVendor &) = delete;
+ const DeclVendor &operator=(const DeclVendor &) = delete;
const DeclVendorKind m_kind;
};
Address m_first_non_prologue_insn;
- DISALLOW_COPY_AND_ASSIGN(FuncUnwinders);
+ FuncUnwinders(const FuncUnwinders &) = delete;
+ const FuncUnwinders &operator=(const FuncUnwinders &) = delete;
}; // class FuncUnwinders
/// parsed.
std::vector<std::unique_ptr<CallEdge>> m_call_edges; ///< Outgoing call edges.
private:
- DISALLOW_COPY_AND_ASSIGN(Function);
+ Function(const Function &) = delete;
+ const Function &operator=(const Function &) = delete;
};
} // namespace lldb_private
virtual void Clear() = 0;
private:
- DISALLOW_COPY_AND_ASSIGN(LineSequence);
+ LineSequence(const LineSequence &) = delete;
+ const LineSequence &operator=(const LineSequence &) = delete;
};
/// \class LineTable LineTable.h "lldb/Symbol/LineTable.h"
bool ConvertEntryAtIndexToLineEntry(uint32_t idx, LineEntry &line_entry);
private:
- DISALLOW_COPY_AND_ASSIGN(LineTable);
+ LineTable(const LineTable &) = delete;
+ const LineTable &operator=(const LineTable &) = delete;
};
} // namespace lldb_private
m_data; ///< The data for this object file so things can be parsed lazily.
private:
- DISALLOW_COPY_AND_ASSIGN(ObjectContainer);
+ ObjectContainer(const ObjectContainer &) = delete;
+ const ObjectContainer &operator=(const ObjectContainer &) = delete;
};
} // namespace lldb_private
uint64_t Offset);
private:
- DISALLOW_COPY_AND_ASSIGN(ObjectFile);
+ ObjectFile(const ObjectFile &) = delete;
+ const ObjectFile &operator=(const ObjectFile &) = delete;
};
} // namespace lldb_private
bool m_calculated_abilities;
private:
- DISALLOW_COPY_AND_ASSIGN(SymbolFile);
+ SymbolFile(const SymbolFile &) = delete;
+ const SymbolFile &operator=(const SymbolFile &) = delete;
};
} // namespace lldb_private
private:
// For SymbolVendor only
- DISALLOW_COPY_AND_ASSIGN(SymbolVendor);
+ SymbolVendor(const SymbolVendor &) = delete;
+ const SymbolVendor &operator=(const SymbolVendor &) = delete;
};
} // namespace lldb_private
const char *decl_context,
const std::set<const char *> &class_contexts);
- DISALLOW_COPY_AND_ASSIGN(Symtab);
+ Symtab(const Symtab &) = delete;
+ const Symtab &operator=(const Symtab &) = delete;
};
} // namespace lldb_private
collection m_types;
- DISALLOW_COPY_AND_ASSIGN(TypeList);
+ TypeList(const TypeList &) = delete;
+ const TypeList &operator=(const TypeList &) = delete;
};
} // namespace lldb_private
collection m_types;
- DISALLOW_COPY_AND_ASSIGN(TypeMap);
+ TypeMap(const TypeMap &) = delete;
+ const TypeMap &operator=(const TypeMap &) = delete;
};
} // namespace lldb_private
std::unique_ptr<CompactUnwindInfo> m_compact_unwind_up;
std::unique_ptr<ArmUnwindInfo> m_arm_unwind_up;
- DISALLOW_COPY_AND_ASSIGN(UnwindTable);
+ UnwindTable(const UnwindTable &) = delete;
+ const UnwindTable &operator=(const UnwindTable &) = delete;
};
} // namespace lldb_private
private:
// For VariableList only
- DISALLOW_COPY_AND_ASSIGN(VariableList);
+ VariableList(const VariableList &) = delete;
+ const VariableList &operator=(const VariableList &) = delete;
};
} // namespace lldb_private
std::unique_ptr<llvm::MCRegisterInfo> m_mc_register_info_up;
private:
- DISALLOW_COPY_AND_ASSIGN(ABI);
+ ABI(const ABI &) = delete;
+ const ABI &operator=(const ABI &) = delete;
};
class RegInfoBasedABI : public ABI {
*m_process; ///< The process that this dynamic loader plug-in is tracking.
private:
- DISALLOW_COPY_AND_ASSIGN(DynamicLoader);
+ DynamicLoader(const DynamicLoader &) = delete;
+ const DynamicLoader &operator=(const DynamicLoader &) = delete;
};
} // namespace lldb_private
Language();
private:
- DISALLOW_COPY_AND_ASSIGN(Language);
+ Language(const Language &) = delete;
+ const Language &operator=(const Language &) = delete;
};
} // namespace lldb_private
Process *m_process;
private:
- DISALLOW_COPY_AND_ASSIGN(LanguageRuntime);
+ LanguageRuntime(const LanguageRuntime &) = delete;
+ const LanguageRuntime &operator=(const LanguageRuntime &) = delete;
};
} // namespace lldb_private
uint32_t m_L2_cache_line_byte_size;
private:
- DISALLOW_COPY_AND_ASSIGN(MemoryCache);
+ MemoryCache(const MemoryCache &) = delete;
+ const MemoryCache &operator=(const MemoryCache &) = delete;
};
PermissionsToBlockMap m_memory_map;
private:
- DISALLOW_COPY_AND_ASSIGN(AllocatedMemoryCache);
+ AllocatedMemoryCache(const AllocatedMemoryCache &) = delete;
+ const AllocatedMemoryCache &operator=(const AllocatedMemoryCache &) = delete;
};
} // namespace lldb_private
Process
*m_process; ///< The process that this dynamic loader plug-in is tracking.
private:
- DISALLOW_COPY_AND_ASSIGN(OperatingSystem);
+ OperatingSystem(const OperatingSystem &) = delete;
+ const OperatingSystem &operator=(const OperatingSystem &) = delete;
};
} // namespace lldb_private
FileSpec GetModuleCacheRoot();
- DISALLOW_COPY_AND_ASSIGN(Platform);
+ Platform(const Platform &) = delete;
+ const Platform &operator=(const Platform &) = delete;
};
class PlatformList {
lldb::PlatformSP m_selected_platform_sp;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformList);
+ PlatformList(const PlatformList &) = delete;
+ const PlatformList &operator=(const PlatformList &) = delete;
};
class OptionGroupPlatformRSync : public lldb_private::OptionGroup {
bool m_ignores_remote_hostname;
private:
- DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformRSync);
+ OptionGroupPlatformRSync(const OptionGroupPlatformRSync &) = delete;
+ const OptionGroupPlatformRSync &
+ operator=(const OptionGroupPlatformRSync &) = delete;
};
class OptionGroupPlatformSSH : public lldb_private::OptionGroup {
std::string m_ssh_opts;
private:
- DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformSSH);
+ OptionGroupPlatformSSH(const OptionGroupPlatformSSH &) = delete;
+ const OptionGroupPlatformSSH &
+ operator=(const OptionGroupPlatformSSH &) = delete;
};
class OptionGroupPlatformCaching : public lldb_private::OptionGroup {
std::string m_cache_dir;
private:
- DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformCaching);
+ OptionGroupPlatformCaching(const OptionGroupPlatformCaching &) = delete;
+ const OptionGroupPlatformCaching &
+ operator=(const OptionGroupPlatformCaching &) = delete;
};
} // namespace lldb_private
int m_update_state;
bool m_interrupted;
- DISALLOW_COPY_AND_ASSIGN(ProcessEventData);
+ ProcessEventData(const ProcessEventData &) = delete;
+ const ProcessEventData &operator=(const ProcessEventData &) = delete;
};
/// Construct with a shared pointer to a target, and the Process listener.
void ControlPrivateStateThread(uint32_t signal);
- DISALLOW_COPY_AND_ASSIGN(Process);
+ Process(const Process &) = delete;
+ const Process &operator=(const Process &) = delete;
};
/// RAII guard that should be acquired when an utility function is called within
// dispatch_queue_t for this Queue
lldb::QueueKind m_kind;
- DISALLOW_COPY_AND_ASSIGN(Queue);
+ Queue(const Queue &) = delete;
+ const Queue &operator=(const Queue &) = delete;
};
} // namespace lldb_private
std::string m_target_queue_label;
private:
- DISALLOW_COPY_AND_ASSIGN(QueueItem);
+ QueueItem(const QueueItem &) = delete;
+ const QueueItem &operator=(const QueueItem &) = delete;
};
} // namespace lldb_private
Reason m_reason;
// Make RegisterCheckpointSP if you wish to share the data in this class.
- DISALLOW_COPY_AND_ASSIGN(RegisterCheckpoint);
+ RegisterCheckpoint(const RegisterCheckpoint &) = delete;
+ const RegisterCheckpoint &operator=(const RegisterCheckpoint &) = delete;
};
} // namespace lldb_private
uint32_t m_stop_id; // The stop ID that any data in this context is valid for
private:
// For RegisterContext only
- DISALLOW_COPY_AND_ASSIGN(RegisterContext);
+ RegisterContext(const RegisterContext &) = delete;
+ const RegisterContext &operator=(const RegisterContext &) = delete;
};
} // namespace lldb_private
lldb_private::UnwindLLDB &m_parent_unwind; // The UnwindLLDB that is creating
// this RegisterContextUnwind
- DISALLOW_COPY_AND_ASSIGN(RegisterContextUnwind);
+ RegisterContextUnwind(const RegisterContextUnwind &) = delete;
+ const RegisterContextUnwind &
+ operator=(const RegisterContextUnwind &) = delete;
};
} // namespace lldb_private
mutable std::recursive_mutex m_mutex;
private:
- DISALLOW_COPY_AND_ASSIGN(SectionLoadHistory);
+ SectionLoadHistory(const SectionLoadHistory &) = delete;
+ const SectionLoadHistory &operator=(const SectionLoadHistory &) = delete;
};
} // namespace lldb_private
StreamString m_disassembly;
std::recursive_mutex m_mutex;
- DISALLOW_COPY_AND_ASSIGN(StackFrame);
+ StackFrame(const StackFrame &) = delete;
+ const StackFrame &operator=(const StackFrame &) = delete;
};
} // namespace lldb_private
const bool m_show_inlined_frames;
private:
- DISALLOW_COPY_AND_ASSIGN(StackFrameList);
+ StackFrameList(const StackFrameList &) = delete;
+ const StackFrameList &operator=(const StackFrameList &) = delete;
};
} // namespace lldb_private
lldb::StackFrameSP frame) override;
private:
- DISALLOW_COPY_AND_ASSIGN(ScriptedStackFrameRecognizer);
+ ScriptedStackFrameRecognizer(const ScriptedStackFrameRecognizer &) = delete;
+ const ScriptedStackFrameRecognizer &
+ operator=(const ScriptedStackFrameRecognizer &) = delete;
};
/// \class StackFrameRecognizerManager
private:
friend class Thread;
- DISALLOW_COPY_AND_ASSIGN(StopInfo);
+ StopInfo(const StopInfo &) = delete;
+ const StopInfo &operator=(const StopInfo &) = delete;
};
} // namespace lldb_private
private:
lldb::ProcessWP m_process_wp;
- DISALLOW_COPY_AND_ASSIGN(StructuredDataPlugin);
+ StructuredDataPlugin(const StructuredDataPlugin &) = delete;
+ const StructuredDataPlugin &operator=(const StructuredDataPlugin &) = delete;
};
}
std::vector<ConstString> m_types;
private:
- DISALLOW_COPY_AND_ASSIGN(SystemRuntime);
+ SystemRuntime(const SystemRuntime &) = delete;
+ const SystemRuntime &operator=(const SystemRuntime &) = delete;
};
} // namespace lldb_private
lldb::TargetSP m_target_sp;
ModuleList m_module_list;
- DISALLOW_COPY_AND_ASSIGN(TargetEventData);
+ TargetEventData(const TargetEventData &) = delete;
+ const TargetEventData &operator=(const TargetEventData &) = delete;
};
~Target() override;
void FinalizeFileActions(ProcessLaunchInfo &info);
- DISALLOW_COPY_AND_ASSIGN(Target);
+ Target(const Target &) = delete;
+ const Target &operator=(const Target &) = delete;
};
} // namespace lldb_private
lldb::PlatformSP &platform_sp,
lldb::TargetSP &target_sp, bool is_dummy_target);
- DISALLOW_COPY_AND_ASSIGN(TargetList);
+ TargetList(const TargetList &) = delete;
+ const TargetList &operator=(const TargetList &) = delete;
};
} // namespace lldb_private
lldb::ThreadSP m_thread_sp;
StackID m_stack_id;
- DISALLOW_COPY_AND_ASSIGN(ThreadEventData);
+ ThreadEventData(const ThreadEventData &) = delete;
+ const ThreadEventData &operator=(const ThreadEventData &) = delete;
};
struct ThreadStateCheckpoint {
private:
void BroadcastSelectedFrameChange(StackID &new_frame_id);
- DISALLOW_COPY_AND_ASSIGN(Thread);
+ Thread(const Thread &) = delete;
+ const Thread &operator=(const Thread &) = delete;
};
} // namespace lldb_private
lldb::ThreadPlanTracerSP m_tracer_sp;
private:
- DISALLOW_COPY_AND_ASSIGN(ThreadPlan);
+ ThreadPlan(const ThreadPlan &) = delete;
+ const ThreadPlan &operator=(const ThreadPlan &) = delete;
};
// ThreadPlanNull:
lldb::StateType GetPlanRunState() override;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanNull);
+ ThreadPlanNull(const ThreadPlanNull &) = delete;
+ const ThreadPlanNull &operator=(const ThreadPlanNull &) = delete;
};
} // namespace lldb_private
friend lldb::ThreadPlanSP
Thread::QueueFundamentalPlan(bool abort_other_plans);
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanBase);
+ ThreadPlanBase(const ThreadPlanBase &) = delete;
+ const ThreadPlanBase &operator=(const ThreadPlanBase &) = delete;
};
} // namespace lldb_private
private:
CompilerType m_return_type;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanCallFunction);
+ ThreadPlanCallFunction(const ThreadPlanCallFunction &) = delete;
+ const ThreadPlanCallFunction &
+ operator=(const ThreadPlanCallFunction &) = delete;
};
} // namespace lldb_private
private:
llvm::Type &m_return_type;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanCallFunctionUsingABI);
+ ThreadPlanCallFunctionUsingABI(const ThreadPlanCallFunctionUsingABI &) =
+ delete;
+ const ThreadPlanCallFunctionUsingABI &
+ operator=(const ThreadPlanCallFunctionUsingABI &) = delete;
};
} // namespace lldb_private
m_result_var_sp; // If we are left to manage the materialization,
// then stuff the result expression variable here.
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanCallUserExpression);
+ ThreadPlanCallUserExpression(const ThreadPlanCallUserExpression &) = delete;
+ const ThreadPlanCallUserExpression &
+ operator=(const ThreadPlanCallUserExpression &) = delete;
};
} // namespace lldb_private
StructuredData::ObjectSP m_implementation_sp;
bool m_did_push;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanPython);
+ ThreadPlanPython(const ThreadPlanPython &) = delete;
+ const ThreadPlanPython &operator=(const ThreadPlanPython &) = delete;
};
} // namespace lldb_private
std::vector<lldb::break_id_t> m_break_ids; // This is the breakpoint we are
// using to stop us at m_address.
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanRunToAddress);
+ ThreadPlanRunToAddress(const ThreadPlanRunToAddress &) = delete;
+ const ThreadPlanRunToAddress &
+ operator=(const ThreadPlanRunToAddress &) = delete;
};
} // namespace lldb_private
lldb_private::Flags m_flags;
private:
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanShouldStopHere);
+ ThreadPlanShouldStopHere(const ThreadPlanShouldStopHere &) = delete;
+ const ThreadPlanShouldStopHere &
+ operator=(const ThreadPlanShouldStopHere &) = delete;
};
} // namespace lldb_private
bool m_virtual_step; // true if we've just done a "virtual step", i.e. just
// moved the inline stack depth.
ConstString m_step_into_target;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepInRange);
+ ThreadPlanStepInRange(const ThreadPlanStepInRange &) = delete;
+ const ThreadPlanStepInRange &
+ operator=(const ThreadPlanStepInRange &) = delete;
};
} // namespace lldb_private
StackID m_stack_id;
StackID m_parent_frame_id;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepInstruction);
+ ThreadPlanStepInstruction(const ThreadPlanStepInstruction &) = delete;
+ const ThreadPlanStepInstruction &
+ operator=(const ThreadPlanStepInstruction &) = delete;
};
} // namespace lldb_private
void CalculateReturnValue();
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepOut);
+ ThreadPlanStepOut(const ThreadPlanStepOut &) = delete;
+ const ThreadPlanStepOut &operator=(const ThreadPlanStepOut &) = delete;
};
} // namespace lldb_private
bool m_auto_continue;
bool m_reenabled_breakpoint_site;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepOverBreakpoint);
+ ThreadPlanStepOverBreakpoint(const ThreadPlanStepOverBreakpoint &) = delete;
+ const ThreadPlanStepOverBreakpoint &
+ operator=(const ThreadPlanStepOverBreakpoint &) = delete;
};
} // namespace lldb_private
bool m_first_resume;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepOverRange);
+ ThreadPlanStepOverRange(const ThreadPlanStepOverRange &) = delete;
+ const ThreadPlanStepOverRange &
+ operator=(const ThreadPlanStepOverRange &) = delete;
};
} // namespace lldb_private
private:
std::vector<lldb::DisassemblerSP> m_instruction_ranges;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepRange);
+ ThreadPlanStepRange(const ThreadPlanStepRange &) = delete;
+ const ThreadPlanStepRange &operator=(const ThreadPlanStepRange &) = delete;
};
} // namespace lldb_private
StackID m_return_stack_id;
bool m_stop_others;
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepThrough);
+ ThreadPlanStepThrough(const ThreadPlanStepThrough &) = delete;
+ const ThreadPlanStepThrough &
+ operator=(const ThreadPlanStepThrough &) = delete;
};
} // namespace lldb_private
// Need an appropriate marker for the current stack so we can tell step out
// from step in.
- DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepUntil);
+ ThreadPlanStepUntil(const ThreadPlanStepUntil &) = delete;
+ const ThreadPlanStepUntil &operator=(const ThreadPlanStepUntil &) = delete;
};
} // namespace lldb_private
std::recursive_mutex m_unwind_mutex;
private:
- DISALLOW_COPY_AND_ASSIGN(Unwind);
+ Unwind(const Unwind &) = delete;
+ const Unwind &operator=(const Unwind &) = delete;
};
} // namespace lldb_private
private:
UnwindAssembly() = delete;
- DISALLOW_COPY_AND_ASSIGN(UnwindAssembly);
+ UnwindAssembly(const UnwindAssembly &) = delete;
+ const UnwindAssembly &operator=(const UnwindAssembly &) = delete;
};
} // namespace lldb_private
reg_ctx_lldb_sp() {}
private:
- DISALLOW_COPY_AND_ASSIGN(Cursor);
+ Cursor(const Cursor &) = delete;
+ const Cursor &operator=(const Cursor &) = delete;
};
typedef std::shared_ptr<Cursor> CursorSP;
bool AddFirstFrame();
// For UnwindLLDB only
- DISALLOW_COPY_AND_ASSIGN(UnwindLLDB);
+ UnwindLLDB(const UnwindLLDB &) = delete;
+ const UnwindLLDB &operator=(const UnwindLLDB &) = delete;
};
} // namespace lldb_private
std::vector<uint32_t> m_hijacking_masks;
private:
- DISALLOW_COPY_AND_ASSIGN(BroadcasterImpl);
+ BroadcasterImpl(const BroadcasterImpl &) = delete;
+ const BroadcasterImpl &operator=(const BroadcasterImpl &) = delete;
};
typedef std::shared_ptr<BroadcasterImpl> BroadcasterImplSP;
/// The name of this broadcaster object.
const ConstString m_broadcaster_name;
- DISALLOW_COPY_AND_ASSIGN(Broadcaster);
+ Broadcaster(const Broadcaster &) = delete;
+ const Broadcaster &operator=(const Broadcaster &) = delete;
};
} // namespace lldb_private
private:
// For Connection only
- DISALLOW_COPY_AND_ASSIGN(Connection);
+ Connection(const Connection &) = delete;
+ const Connection &operator=(const Connection &) = delete;
};
} // namespace lldb_private
/// be shared among multiple instances
mutable lldb::DataBufferSP m_data_sp;
- DISALLOW_COPY_AND_ASSIGN(DataEncoder);
+ DataEncoder(const DataEncoder &) = delete;
+ const DataEncoder &operator=(const DataEncoder &) = delete;
};
} // namespace lldb_private
private:
virtual void DoOnRemoval(Event *event_ptr) {}
- DISALLOW_COPY_AND_ASSIGN(EventData);
+ EventData(const EventData &) = delete;
+ const EventData &operator=(const EventData &) = delete;
};
// lldb::EventDataBytes
private:
std::string m_bytes;
- DISALLOW_COPY_AND_ASSIGN(EventDataBytes);
+ EventDataBytes(const EventDataBytes &) = delete;
+ const EventDataBytes &operator=(const EventDataBytes &) = delete;
};
class EventDataReceipt : public EventData {
StructuredData::ObjectSP m_object_sp;
lldb::StructuredDataPluginSP m_plugin_sp;
- DISALLOW_COPY_AND_ASSIGN(EventDataStructuredData);
+ EventDataStructuredData(const EventDataStructuredData &) = delete;
+ const EventDataStructuredData &
+ operator=(const EventDataStructuredData &) = delete;
};
// lldb::Event
uint32_t m_type; // The bit describing this event
lldb::EventDataSP m_data_sp; // User specific data for this event
- DISALLOW_COPY_AND_ASSIGN(Event);
+ Event(const Event &) = delete;
+ const Event &operator=(const Event &) = delete;
Event() = delete;
};
FDType m_fd_type;
private:
- DISALLOW_COPY_AND_ASSIGN(IOObject);
+ IOObject(const IOObject &) = delete;
+ const IOObject &operator=(const IOObject &) = delete;
};
} // namespace lldb_private
// bool exact);
// For Listener only
- DISALLOW_COPY_AND_ASSIGN(Listener);
+ Listener(const Listener &) = delete;
+ const Listener &operator=(const Listener &) = delete;
};
} // namespace lldb_private
m_condition.notify_all();
}
- DISALLOW_COPY_AND_ASSIGN(Predicate);
+ Predicate(const Predicate &) = delete;
+ const Predicate &operator=(const Predicate &) = delete;
};
} // namespace lldb_private
std::atomic<uint64_t> m_count;
std::atomic<Category *> m_next;
- DISALLOW_COPY_AND_ASSIGN(Category);
+ Category(const Category &) = delete;
+ const Category &operator=(const Category &) = delete;
};
/// Default constructor.
static std::atomic<unsigned> g_display_depth;
private:
- DISALLOW_COPY_AND_ASSIGN(Timer);
+ Timer(const Timer &) = delete;
+ const Timer &operator=(const Timer &) = delete;
};
} // namespace lldb_private
#define UNUSED_IF_ASSERT_DISABLED(x) ((void)(x))
-#if defined(__cplusplus)
-
-/// \def DISALLOW_COPY_AND_ASSIGN(TypeName)
-/// Macro definition for easily disallowing copy constructor and
-/// assignment operators in C++ classes.
-#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
- TypeName(const TypeName &) = delete; \
- const TypeName &operator=(const TypeName &) = delete
-
-#endif // #if defined(__cplusplus)
-
#endif // LLDB_LLDB_DEFINES_H
CompletionRequest &m_request;
private:
- DISALLOW_COPY_AND_ASSIGN(Completer);
+ Completer(const Completer &) = delete;
+ const Completer &operator=(const Completer &) = delete;
};
} // namespace
const char *m_file_name;
const char *m_dir_name;
- DISALLOW_COPY_AND_ASSIGN(SourceFileCompleter);
+ SourceFileCompleter(const SourceFileCompleter &) = delete;
+ const SourceFileCompleter &operator=(const SourceFileCompleter &) = delete;
};
} // namespace
typedef std::set<ConstString> collection;
collection m_match_set;
- DISALLOW_COPY_AND_ASSIGN(SymbolCompleter);
+ SymbolCompleter(const SymbolCompleter &) = delete;
+ const SymbolCompleter &operator=(const SymbolCompleter &) = delete;
};
} // namespace
const char *m_file_name;
const char *m_dir_name;
- DISALLOW_COPY_AND_ASSIGN(ModuleCompleter);
+ ModuleCompleter(const ModuleCompleter &) = delete;
+ const ModuleCompleter &operator=(const ModuleCompleter &) = delete;
};
} // namespace
private:
// For CommandObjectLog only
- DISALLOW_COPY_AND_ASSIGN(CommandObjectLog);
+ CommandObjectLog(const CommandObjectLog &) = delete;
+ const CommandObjectLog &operator=(const CommandObjectLog &) = delete;
};
} // namespace lldb_private
uint32_t m_permissions;
private:
- DISALLOW_COPY_AND_ASSIGN(OptionPermissions);
+ OptionPermissions(const OptionPermissions &) = delete;
+ const OptionPermissions &operator=(const OptionPermissions &) = delete;
};
// "platform select <platform-name>"
private:
// For CommandObjectPlatform only
- DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformFile);
+ CommandObjectPlatformFile(const CommandObjectPlatformFile &) = delete;
+ const CommandObjectPlatformFile &
+ operator=(const CommandObjectPlatformFile &) = delete;
};
// "platform get-file remote-file-path host-file-path"
private:
// For CommandObjectPlatform only
- DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformProcess);
+ CommandObjectPlatformProcess(const CommandObjectPlatformProcess &) = delete;
+ const CommandObjectPlatformProcess &
+ operator=(const CommandObjectPlatformProcess &) = delete;
};
// "platform shell"
~CommandObjectPlatform() override;
private:
- DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatform);
+ CommandObjectPlatform(const CommandObjectPlatform &) = delete;
+ const CommandObjectPlatform &
+ operator=(const CommandObjectPlatform &) = delete;
};
} // namespace lldb_private
private:
// For CommandObjectRegister only
- DISALLOW_COPY_AND_ASSIGN(CommandObjectRegister);
+ CommandObjectRegister(const CommandObjectRegister &) = delete;
+ const CommandObjectRegister &
+ operator=(const CommandObjectRegister &) = delete;
};
} // namespace lldb_private
LoadDependentFiles m_load_dependent_files;
private:
- DISALLOW_COPY_AND_ASSIGN(OptionGroupDependents);
+ OptionGroupDependents(const OptionGroupDependents &) = delete;
+ const OptionGroupDependents &
+ operator=(const OptionGroupDependents &) = delete;
};
#pragma mark CommandObjectTargetCreate
private:
// For CommandObjectTargetModules only
- DISALLOW_COPY_AND_ASSIGN(CommandObjectTargetModules);
+ CommandObjectTargetModules(const CommandObjectTargetModules &) = delete;
+ const CommandObjectTargetModules &
+ operator=(const CommandObjectTargetModules &) = delete;
};
class CommandObjectTargetSymbolsAdd : public CommandObjectParsed {
private:
// For CommandObjectTargetModules only
- DISALLOW_COPY_AND_ASSIGN(CommandObjectTargetSymbols);
+ CommandObjectTargetSymbols(const CommandObjectTargetSymbols &) = delete;
+ const CommandObjectTargetSymbols &
+ operator=(const CommandObjectTargetSymbols &) = delete;
};
#pragma mark CommandObjectTargetStopHookAdd
bool m_is_subwin;
private:
- DISALLOW_COPY_AND_ASSIGN(Window);
+ Window(const Window &) = delete;
+ const Window &operator=(const Window &) = delete;
};
class MenuDelegate {
NSAutoreleasePool *m_pool;
private:
- DISALLOW_COPY_AND_ASSIGN(MacOSXDarwinThread);
+ MacOSXDarwinThread(const MacOSXDarwinThread &) = delete;
+ const MacOSXDarwinThread &operator=(const MacOSXDarwinThread &) = delete;
};
void InitThreadCreated() {
lldb::user_id_t m_break_id;
private:
- DISALLOW_COPY_AND_ASSIGN(DynamicLoaderDarwinKernel);
+ DynamicLoaderDarwinKernel(const DynamicLoaderDarwinKernel &) = delete;
+ const DynamicLoaderDarwinKernel &
+ operator=(const DynamicLoaderDarwinKernel &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_DARWIN_KERNEL_DYNAMICLOADERDARWINKERNEL_H
const lldb_private::SectionList *
GetSectionListFromModule(const lldb::ModuleSP module) const;
- DISALLOW_COPY_AND_ASSIGN(DynamicLoaderHexagonDYLD);
+ DynamicLoaderHexagonDYLD(const DynamicLoaderHexagonDYLD &) = delete;
+ const DynamicLoaderHexagonDYLD &
+ operator=(const DynamicLoaderHexagonDYLD &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_HEXAGON_DYLD_DYNAMICLOADERHEXAGONDYLD_H
mutable std::recursive_mutex m_mutex;
private:
- DISALLOW_COPY_AND_ASSIGN(DynamicLoaderDarwin);
+ DynamicLoaderDarwin(const DynamicLoaderDarwin &) = delete;
+ const DynamicLoaderDarwin &operator=(const DynamicLoaderDarwin &) = delete;
};
} // namespace lldb_private
// the "reason:exec" annotation.
private:
- DISALLOW_COPY_AND_ASSIGN(DynamicLoaderMacOS);
+ DynamicLoaderMacOS(const DynamicLoaderMacOS &) = delete;
+ const DynamicLoaderMacOS &operator=(const DynamicLoaderMacOS &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOS_H
bool m_process_image_addr_is_all_images_infos;
private:
- DISALLOW_COPY_AND_ASSIGN(DynamicLoaderMacOSXDYLD);
+ DynamicLoaderMacOSXDYLD(const DynamicLoaderMacOSXDYLD &) = delete;
+ const DynamicLoaderMacOSXDYLD &
+ operator=(const DynamicLoaderMacOSXDYLD &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOSXDYLD_H
bool AlwaysRelyOnEHUnwindInfo(lldb_private::SymbolContext &sym_ctx) override;
private:
- DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
+ DynamicLoaderPOSIXDYLD(const DynamicLoaderPOSIXDYLD &) = delete;
+ const DynamicLoaderPOSIXDYLD &
+ operator=(const DynamicLoaderPOSIXDYLD &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_POSIX_DYLD_DYNAMICLOADERPOSIXDYLD_H
private:
void LoadAllImagesAtFileAddresses();
- DISALLOW_COPY_AND_ASSIGN(DynamicLoaderStatic);
+ DynamicLoaderStatic(const DynamicLoaderStatic &) = delete;
+ const DynamicLoaderStatic &operator=(const DynamicLoaderStatic &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_STATIC_DYNAMICLOADERSTATIC_H
}
private:
- DISALLOW_COPY_AND_ASSIGN(ClangDeclVendor);
+ ClangDeclVendor(const ClangDeclVendor &) = delete;
+ const ClangDeclVendor &operator=(const ClangDeclVendor &) = delete;
};
} // namespace lldb_private
///that receives new top-level
///functions.
private:
- DISALLOW_COPY_AND_ASSIGN(ParserVars);
+ ParserVars(const ParserVars &) = delete;
+ const ParserVars &operator=(const ParserVars &) = delete;
};
std::unique_ptr<ParserVars> m_parser_vars;
}
/// Members
- DISALLOW_COPY_AND_ASSIGN(ClangExpressionVariable);
+ ClangExpressionVariable(const ClangExpressionVariable &) = delete;
+ const ClangExpressionVariable &
+ operator=(const ClangExpressionVariable &) = delete;
};
} // namespace lldb_private
// uint32_t to a data buffer heap
// type.
- DISALLOW_COPY_AND_ASSIGN(EmulationStateARM);
+ EmulationStateARM(const EmulationStateARM &) = delete;
+ const EmulationStateARM &operator=(const EmulationStateARM &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_INSTRUCTION_ARM_EMULATIONSTATEARM_H
OperatorStringToCallableInfoMap CallableLookupCache;
- DISALLOW_COPY_AND_ASSIGN(CPPLanguageRuntime);
+ CPPLanguageRuntime(const CPPLanguageRuntime &) = delete;
+ const CPPLanguageRuntime &operator=(const CPPLanguageRuntime &) = delete;
};
} // namespace lldb_private
friend class AppleObjCRuntimeV2;
- DISALLOW_COPY_AND_ASSIGN(NonPointerISACache);
+ NonPointerISACache(const NonPointerISACache &) = delete;
+ const NonPointerISACache &operator=(const NonPointerISACache &) = delete;
};
class TaggedPointerVendorV2
: TaggedPointerVendor(), m_runtime(runtime) {}
private:
- DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorV2);
+ TaggedPointerVendorV2(const TaggedPointerVendorV2 &) = delete;
+ const TaggedPointerVendorV2 &
+ operator=(const TaggedPointerVendorV2 &) = delete;
};
class TaggedPointerVendorRuntimeAssisted : public TaggedPointerVendorV2 {
friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
- DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorRuntimeAssisted);
+ TaggedPointerVendorRuntimeAssisted(
+ const TaggedPointerVendorRuntimeAssisted &) = delete;
+ const TaggedPointerVendorRuntimeAssisted &
+ operator=(const TaggedPointerVendorRuntimeAssisted &) = delete;
};
class TaggedPointerVendorExtended
friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
- DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorExtended);
+ TaggedPointerVendorExtended(const TaggedPointerVendorExtended &) = delete;
+ const TaggedPointerVendorExtended &
+ operator=(const TaggedPointerVendorExtended &) = delete;
};
class TaggedPointerVendorLegacy : public TaggedPointerVendorV2 {
friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
- DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorLegacy);
+ TaggedPointerVendorLegacy(const TaggedPointerVendorLegacy &) = delete;
+ const TaggedPointerVendorLegacy &
+ operator=(const TaggedPointerVendorLegacy &) = delete;
};
struct DescriptorMapUpdateResult {
TaggedPointerVendor() = default;
private:
- DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendor);
+ TaggedPointerVendor(const TaggedPointerVendor &) = delete;
+ const TaggedPointerVendor &operator=(const TaggedPointerVendor &) = delete;
};
~ObjCLanguageRuntime() override;
void ReadObjCLibraryIfNeeded(const ModuleList &module_list);
- DISALLOW_COPY_AND_ASSIGN(ObjCLanguageRuntime);
+ ObjCLanguageRuntime(const ObjCLanguageRuntime &) = delete;
+ const ObjCLanguageRuntime &operator=(const ObjCLanguageRuntime &) = delete;
};
} // namespace lldb_private
std::string m_device_id;
uint32_t m_sdk_version;
- DISALLOW_COPY_AND_ASSIGN(PlatformAndroid);
+ PlatformAndroid(const PlatformAndroid &) = delete;
+ const PlatformAndroid &operator=(const PlatformAndroid &) = delete;
};
} // namespace platofor_android
std::string &connect_url);
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformAndroidRemoteGDBServer);
+ PlatformAndroidRemoteGDBServer(const PlatformAndroidRemoteGDBServer &) =
+ delete;
+ const PlatformAndroidRemoteGDBServer &
+ operator=(const PlatformAndroidRemoteGDBServer &) = delete;
};
} // namespace platform_android
lldb::addr_t offset) override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformFreeBSD);
+ PlatformFreeBSD(const PlatformFreeBSD &) = delete;
+ const PlatformFreeBSD &operator=(const PlatformFreeBSD &) = delete;
};
} // namespace platform_freebsd
lldb::addr_t offset) override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformLinux);
+ PlatformLinux(const PlatformLinux &) = delete;
+ const PlatformLinux &operator=(const PlatformLinux &) = delete;
};
} // namespace platform_linux
#endif
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformAppleSimulator);
+ PlatformAppleSimulator(const PlatformAppleSimulator &) = delete;
+ const PlatformAppleSimulator &
+ operator=(const PlatformAppleSimulator &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMAPPLESIMULATOR_H
const char *GetSDKDirectoryAsCString();
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformAppleTVSimulator);
+ PlatformAppleTVSimulator(const PlatformAppleTVSimulator &) = delete;
+ const PlatformAppleTVSimulator &
+ operator=(const PlatformAppleTVSimulator &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMAPPLETVSIMULATOR_H
const char *GetSDKDirectoryAsCString();
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformAppleWatchSimulator);
+ PlatformAppleWatchSimulator(const PlatformAppleWatchSimulator &) = delete;
+ const PlatformAppleWatchSimulator &
+ operator=(const PlatformAppleWatchSimulator &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMAPPLEWATCHSIMULATOR_H
std::mutex m_sdk_path_mutex;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformDarwin);
+ PlatformDarwin(const PlatformDarwin &) = delete;
+ const PlatformDarwin &operator=(const PlatformDarwin &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMDARWIN_H
// dSYMs next to them
lldb_private::LazyBool m_ios_debug_session;
- DISALLOW_COPY_AND_ASSIGN(PlatformDarwinKernel);
+ PlatformDarwinKernel(const PlatformDarwinKernel &) = delete;
+ const PlatformDarwinKernel &operator=(const PlatformDarwinKernel &) = delete;
};
#else // __APPLE__
}
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformMacOSX);
+ PlatformMacOSX(const PlatformMacOSX &) = delete;
+ const PlatformMacOSX &operator=(const PlatformMacOSX &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMMACOSX_H
std::string GetPlatformName () override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformRemoteAppleBridge);
+ PlatformRemoteAppleBridge(const PlatformRemoteAppleBridge &) = delete;
+ const PlatformRemoteAppleBridge &
+ operator=(const PlatformRemoteAppleBridge &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLEBRIDGE_H
std::string GetPlatformName () override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformRemoteAppleTV);
+ PlatformRemoteAppleTV(const PlatformRemoteAppleTV &) = delete;
+ const PlatformRemoteAppleTV &
+ operator=(const PlatformRemoteAppleTV &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLETV_H
std::string GetPlatformName () override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformRemoteAppleWatch);
+ PlatformRemoteAppleWatch(const PlatformRemoteAppleWatch &) = delete;
+ const PlatformRemoteAppleWatch &
+ operator=(const PlatformRemoteAppleWatch &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLEWATCH_H
virtual std::string GetPlatformName () = 0;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformRemoteDarwinDevice);
+ PlatformRemoteDarwinDevice(const PlatformRemoteDarwinDevice &) = delete;
+ const PlatformRemoteDarwinDevice &
+ operator=(const PlatformRemoteDarwinDevice &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEDARWINDEVICE_H
std::string GetPlatformName () override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformRemoteiOS);
+ PlatformRemoteiOS(const PlatformRemoteiOS &) = delete;
+ const PlatformRemoteiOS &operator=(const PlatformRemoteiOS &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEIOS_H
const char *GetSDKDirectoryAsCString();
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformiOSSimulator);
+ PlatformiOSSimulator(const PlatformiOSSimulator &) = delete;
+ const PlatformiOSSimulator &operator=(const PlatformiOSSimulator &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMIOSSIMULATOR_H
lldb::addr_t offset) override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformNetBSD);
+ PlatformNetBSD(const PlatformNetBSD &) = delete;
+ const PlatformNetBSD &operator=(const PlatformNetBSD &) = delete;
};
} // namespace platform_netbsd
lldb::addr_t offset) override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformOpenBSD);
+ PlatformOpenBSD(const PlatformOpenBSD &) = delete;
+ const PlatformOpenBSD &operator=(const PlatformOpenBSD &) = delete;
};
} // namespace platform_openbsd
llvm::StringRef GetLibdlFunctionDeclarations(lldb_private::Process *process);
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformPOSIX);
+ PlatformPOSIX(const PlatformPOSIX &) = delete;
+ const PlatformPOSIX &operator=(const PlatformPOSIX &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PLATFORM_POSIX_PLATFORMPOSIX_H
ConstString GetFullNameForDylib(ConstString basename) override;
private:
- DISALLOW_COPY_AND_ASSIGN(PlatformWindows);
+ PlatformWindows(const PlatformWindows &) = delete;
+ const PlatformWindows &operator=(const PlatformWindows &) = delete;
};
} // namespace lldb_private
llvm::Optional<std::string> DoGetUserName(UserIDResolver::id_t uid) override;
llvm::Optional<std::string> DoGetGroupName(UserIDResolver::id_t uid) override;
- DISALLOW_COPY_AND_ASSIGN(PlatformRemoteGDBServer);
+ PlatformRemoteGDBServer(const PlatformRemoteGDBServer &) = delete;
+ const PlatformRemoteGDBServer &
+ operator=(const PlatformRemoteGDBServer &) = delete;
};
} // namespace platform_gdb_server
lldb::addr_t m_last_read_memory_addr; // Last memory read address for logging
private:
// For CommunicationKDP only
- DISALLOW_COPY_AND_ASSIGN(CommunicationKDP);
+ CommunicationKDP(const CommunicationKDP &) = delete;
+ const CommunicationKDP &operator=(const CommunicationKDP &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PROCESS_MACOSX_KERNEL_COMMUNICATIONKDP_H
private:
// For ProcessKDP only
- DISALLOW_COPY_AND_ASSIGN(ProcessKDP);
+ ProcessKDP(const ProcessKDP &) = delete;
+ const ProcessKDP &operator=(const ProcessKDP &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PROCESS_MACOSX_KERNEL_PROCESSKDP_H
lldb_private::RegisterSet m_reg_set0; // register set 0 (PC only)
lldb_private::RegisterInfo m_pc_reg_info;
- DISALLOW_COPY_AND_ASSIGN(RegisterContextDummy);
+ RegisterContextDummy(const RegisterContextDummy &) = delete;
+ const RegisterContextDummy &operator=(const RegisterContextDummy &) = delete;
};
} // namespace lldb_private
lldb::addr_t m_pc_value;
- DISALLOW_COPY_AND_ASSIGN(RegisterContextHistory);
+ RegisterContextHistory(const RegisterContextHistory &) = delete;
+ const RegisterContextHistory &
+ operator=(const RegisterContextHistory &) = delete;
};
} // namespace lldb_private
// context that is stored in memmory
private:
- DISALLOW_COPY_AND_ASSIGN(RegisterContextMemory);
+ RegisterContextMemory(const RegisterContextMemory &) = delete;
+ const RegisterContextMemory &
+ operator=(const RegisterContextMemory &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTMEMORY_H
uint32_t m_stop_id;
private:
- DISALLOW_COPY_AND_ASSIGN(RegisterContextThreadMemory);
+ RegisterContextThreadMemory(const RegisterContextThreadMemory &) = delete;
+ const RegisterContextThreadMemory &
+ operator=(const RegisterContextThreadMemory &) = delete;
};
} // namespace lldb_private
lldb::addr_t m_register_data_addr;
private:
- DISALLOW_COPY_AND_ASSIGN(ThreadMemory);
+ ThreadMemory(const ThreadMemory &) = delete;
+ const ThreadMemory &operator=(const ThreadMemory &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_THREADMEMORY_H
lldb::ModuleSP m_core_module_sp;
lldb_private::FileSpec m_core_file;
std::string m_dyld_plugin_name;
- DISALLOW_COPY_AND_ASSIGN(ProcessElfCore);
+ ProcessElfCore(const ProcessElfCore &) = delete;
+ const ProcessElfCore &operator=(const ProcessElfCore &) = delete;
// True if m_thread_contexts contains valid entries
bool m_thread_data_valid = false;
void *m_decompression_scratch = nullptr;
#endif
- DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunication);
+ GDBRemoteCommunication(const GDBRemoteCommunication &) = delete;
+ const GDBRemoteCommunication &
+ operator=(const GDBRemoteCommunication &) = delete;
};
} // namespace process_gdb_remote
LazyBool GetThreadPacketSupported(lldb::tid_t tid, llvm::StringRef packetStr);
private:
- DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationClient);
+ GDBRemoteCommunicationClient(const GDBRemoteCommunicationClient &) = delete;
+ const GDBRemoteCommunicationClient &
+ operator=(const GDBRemoteCommunicationClient &) = delete;
};
} // namespace process_gdb_remote
bool m_skip_acks;
private:
- DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationReplayServer);
+ GDBRemoteCommunicationReplayServer(
+ const GDBRemoteCommunicationReplayServer &) = delete;
+ const GDBRemoteCommunicationReplayServer &
+ operator=(const GDBRemoteCommunicationReplayServer &) = delete;
};
} // namespace process_gdb_remote
PacketResult SendOKResponse();
private:
- DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationServer);
+ GDBRemoteCommunicationServer(const GDBRemoteCommunicationServer &) = delete;
+ const GDBRemoteCommunicationServer &
+ operator=(const GDBRemoteCommunicationServer &) = delete;
};
class PacketUnimplementedError
void StopSTDIOForwarding();
// For GDBRemoteCommunicationServerLLGS only
- DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationServerLLGS);
+ GDBRemoteCommunicationServerLLGS(const GDBRemoteCommunicationServerLLGS &) =
+ delete;
+ const GDBRemoteCommunicationServerLLGS &
+ operator=(const GDBRemoteCommunicationServerLLGS &) = delete;
};
} // namespace process_gdb_remote
static FileSpec GetDomainSocketPath(const char *prefix);
- DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationServerPlatform);
+ GDBRemoteCommunicationServerPlatform(
+ const GDBRemoteCommunicationServerPlatform &) = delete;
+ const GDBRemoteCommunicationServerPlatform &
+ operator=(const GDBRemoteCommunicationServerPlatform &) = delete;
};
} // namespace process_gdb_remote
bool SetPrimordialRegister(const RegisterInfo *reg_info,
GDBRemoteCommunicationClient &gdb_comm);
- DISALLOW_COPY_AND_ASSIGN(GDBRemoteRegisterContext);
+ GDBRemoteRegisterContext(const GDBRemoteRegisterContext &) = delete;
+ const GDBRemoteRegisterContext &
+ operator=(const GDBRemoteRegisterContext &) = delete;
};
} // namespace process_gdb_remote
llvm::DenseMap<ModuleCacheKey, ModuleSpec, ModuleCacheInfo>
m_cached_module_specs;
- DISALLOW_COPY_AND_ASSIGN(ProcessGDBRemote);
+ ProcessGDBRemote(const ProcessGDBRemote &) = delete;
+ const ProcessGDBRemote &operator=(const ProcessGDBRemote &) = delete;
};
} // namespace process_gdb_remote
lldb::addr_t m_mach_kernel_addr;
lldb_private::ConstString m_dyld_plugin_name;
- DISALLOW_COPY_AND_ASSIGN(ProcessMachCore);
+ ProcessMachCore(const ProcessMachCore &) = delete;
+ const ProcessMachCore &operator=(const ProcessMachCore &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_PROCESS_MACH_CORE_PROCESSMACHCORE_H
void Serialize(llvm::json::OStream &s) const override;
private:
- DISALLOW_COPY_AND_ASSIGN(StructuredPythonObject);
+ StructuredPythonObject(const StructuredPythonObject &) = delete;
+ const StructuredPythonObject &
+ operator=(const StructuredPythonObject &) = delete;
};
enum class PyObjectType {
DIERef::Section section, bool is_dwo)
: DWARFUnit(dwarf, uid, header, abbrevs, section, is_dwo) {}
- DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
+ DWARFCompileUnit(const DWARFCompileUnit &) = delete;
+ const DWARFCompileUnit &operator=(const DWARFCompileUnit &) = delete;
friend class DWARFUnit;
};
uint32_t FindUnitIndex(DIERef::Section section, dw_offset_t offset);
- DISALLOW_COPY_AND_ASSIGN(DWARFDebugInfo);
+ DWARFDebugInfo(const DWARFDebugInfo &) = delete;
+ const DWARFDebugInfo &operator=(const DWARFDebugInfo &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDEBUGINFO_H
bool m_clear_dies = false;
ScopedExtractDIEs(DWARFUnit &cu);
~ScopedExtractDIEs();
- DISALLOW_COPY_AND_ASSIGN(ScopedExtractDIEs);
+ ScopedExtractDIEs(const ScopedExtractDIEs &) = delete;
+ const ScopedExtractDIEs &operator=(const ScopedExtractDIEs &) = delete;
ScopedExtractDIEs(ScopedExtractDIEs &&rhs);
ScopedExtractDIEs &operator=(ScopedExtractDIEs &&rhs);
};
void ComputeCompDirAndGuessPathStyle();
void ComputeAbsolutePath();
- DISALLOW_COPY_AND_ASSIGN(DWARFUnit);
+ DWARFUnit(const DWARFUnit &) = delete;
+ const DWARFUnit &operator=(const DWARFUnit &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFUNIT_H
DIEToClangType;
typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
- DISALLOW_COPY_AND_ASSIGN(SymbolFileDWARF);
+ SymbolFileDWARF(const SymbolFileDWARF &) = delete;
+ const SymbolFileDWARF &operator=(const SymbolFileDWARF &) = delete;
virtual void LoadSectionData(lldb::SectionType sect_type,
lldb_private::DWARFDataExtractor &data);
TypeMap m_objc_class_types;
private:
- DISALLOW_COPY_AND_ASSIGN(SymbolFileSymtab);
+ SymbolFileSymtab(const SymbolFileSymtab &) = delete;
+ const SymbolFileSymtab &operator=(const SymbolFileSymtab &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_SYMTAB_SYMBOLFILESYMTAB_H
uint32_t GetPluginVersion() override;
private:
- DISALLOW_COPY_AND_ASSIGN(SymbolVendorELF);
+ SymbolVendorELF(const SymbolVendorELF &) = delete;
+ const SymbolVendorELF &operator=(const SymbolVendorELF &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_SYMBOLVENDOR_ELF_SYMBOLVENDORELF_H
virtual uint32_t GetPluginVersion();
private:
- DISALLOW_COPY_AND_ASSIGN(SymbolVendorMacOSX);
+ SymbolVendorMacOSX(const SymbolVendorMacOSX &) = delete;
+ const SymbolVendorMacOSX &operator=(const SymbolVendorMacOSX &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_SYMBOLVENDOR_MACOSX_SYMBOLVENDORMACOSX_H
/// \}
private:
- DISALLOW_COPY_AND_ASSIGN(SymbolVendorWasm);
+ SymbolVendorWasm(const SymbolVendorWasm &) = delete;
+ const SymbolVendorWasm &operator=(const SymbolVendorWasm &) = delete;
};
} // namespace wasm
lldb::addr_t m_dispatch_voucher_offsets_addr;
struct LibdispatchVoucherOffsets m_libdispatch_voucher_offsets;
- DISALLOW_COPY_AND_ASSIGN(SystemRuntimeMacOSX);
+ SystemRuntimeMacOSX(const SystemRuntimeMacOSX &) = delete;
+ const SystemRuntimeMacOSX &operator=(const SystemRuntimeMacOSX &) = delete;
};
#endif // LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_SYSTEMRUNTIMEMACOSX_H
::LLVMDisasmContextRef m_disasm_context;
- DISALLOW_COPY_AND_ASSIGN(x86AssemblyInspectionEngine);
+ x86AssemblyInspectionEngine(const x86AssemblyInspectionEngine &) = delete;
+ const x86AssemblyInspectionEngine &
+ operator=(const x86AssemblyInspectionEngine &) = delete;
};
} // namespace lldb_private
projects / platform / upstream / llvm.git / commitdiff