eInfoTypeISAAndImmediateSigned,
eInfoTypeISA,
eInfoTypeNoArgs
- } InfoType;
+ };
struct Context {
ContextType type = eContextInvalid;
std::vector<lldb::LanguageType> m_languages;
- uint32_t m_enabled_position;
+ uint32_t m_enabled_position = 0;
void Enable(bool value, uint32_t position);
uint32_t &GetRevision() { return m_my_revision; }
protected:
- uint32_t m_my_revision;
+ uint32_t m_my_revision = 0;
Flags m_flags;
private:
OptionValueUInt64 m_num_per_line;
bool m_output_as_binary = false;
OptionValueString m_view_as_type;
- bool m_force;
+ bool m_force = false;
OptionValueUInt64 m_offset;
OptionValueLanguage m_language_for_type;
};
m_class_name.clear();
m_function_name.clear();
m_line_start = 0;
- m_line_end = UINT_MAX;
+ m_line_end = LLDB_INVALID_LINE_NUMBER;
m_file_name.clear();
m_module_name.clear();
m_func_name_type_mask = eFunctionNameTypeAuto;
std::string m_class_name;
std::string m_function_name;
uint32_t m_line_start = 0;
- uint32_t m_line_end;
+ uint32_t m_line_end = LLDB_INVALID_LINE_NUMBER;
std::string m_file_name;
std::string m_module_name;
uint32_t m_func_name_type_mask =
eFunctionNameTypeAuto; // A pick from lldb::FunctionNameType.
- lldb::tid_t m_thread_id;
- uint32_t m_thread_index;
+ lldb::tid_t m_thread_id = LLDB_INVALID_THREAD_ID;
+ uint32_t m_thread_index = UINT32_MAX;
std::string m_thread_name;
std::string m_queue_name;
bool m_sym_ctx_specified = false;
- bool m_no_inlines;
+ bool m_no_inlines = false;
bool m_thread_specified = false;
// Instance variables to hold the values for one_liner options.
bool m_use_one_liner = false;
std::vector<std::string> m_one_liner;
- bool m_auto_continue;
+ bool m_auto_continue = false;
};
CommandObjectTargetStopHookAdd(CommandInterpreter &interpreter)
return llvm::makeArrayRef(g_thread_until_options);
}
- uint32_t m_step_thread_idx;
- bool m_stop_others;
+ uint32_t m_step_thread_idx = LLDB_INVALID_THREAD_ID;
+ bool m_stop_others = false;
std::vector<lldb::addr_t> m_until_addrs;
// Instance variables to hold the values for command options.
// Instance variables to hold the values for command options.
TypeSummaryImpl::Flags m_flags;
- bool m_regex;
+ bool m_regex = false;
std::string m_format_string;
ConstString m_name;
std::string m_python_script;
std::string m_python_function;
- bool m_is_add_script;
+ bool m_is_add_script = false;
std::string m_category;
};
: m_process(process), m_rendezvous_addr(LLDB_INVALID_ADDRESS), m_current(),
m_previous(), m_soentries(), m_added_soentries(), m_removed_soentries() {
m_thread_info.valid = false;
+ m_thread_info.dtv_offset = 0;
+ m_thread_info.dtv_slot_size = 0;
+ m_thread_info.modid_offset = 0;
+ m_thread_info.tls_offset = 0;
// Cache a copy of the executable path
if (m_process) {
EmulateInstructionARM(const ArchSpec &arch)
: EmulateInstruction(arch), m_arm_isa(0), m_opcode_mode(eModeInvalid),
- m_opcode_cpsr(0), m_it_session(), m_ignore_conditions(false) {
+ m_opcode_cpsr(0), m_new_inst_cpsr(0), m_it_session(),
+ m_ignore_conditions(false) {
SetArchitecture(arch);
}
private:
/// Input character until which we have constructed the respective output
/// already.
- const char *Written;
+ const char *Written = "";
llvm::SmallString<128> Result;
/// Whether we have performed any substitutions.
- bool Substituted;
+ bool Substituted = false;
const char *currentParserPos() const { return this->First; }
AbstractListFrontEnd(ValueObject &valobj)
: SyntheticChildrenFrontEnd(valobj) {}
- size_t m_count;
- ValueObject *m_head;
+ size_t m_count = 0;
+ ValueObject *m_head = nullptr;
static constexpr bool g_use_loop_detect = true;
- size_t m_loop_detected; // The number of elements that have had loop detection
- // run over them.
+ size_t m_loop_detected = 0; // The number of elements that have had loop
+ // detection run over them.
ListEntry m_slow_runner; // Used for loop detection
ListEntry m_fast_runner; // Used for loop detection
- size_t m_list_capping_size;
+ size_t m_list_capping_size = 0;
CompilerType m_element_type;
std::map<size_t, ListIterator> m_iterators;
}
MapEntry m_entry;
- size_t m_max_depth;
- bool m_error;
+ size_t m_max_depth = 0;
+ bool m_error = false;
};
namespace lldb_private {
ExecutionContextRef m_exe_ctx_ref;
bool m_mutable = true;
bool m_multi = false;
- HashType m_type;
+ HashType m_type = HashType::set;
};
} // namespace lldb_private
lldb::ByteOrder m_order = lldb::eByteOrderInvalid;
DataDescriptor_32 *m_data_32 = nullptr;
DataDescriptor_64 *m_data_64 = nullptr;
- lldb::addr_t m_data_ptr;
+ lldb::addr_t m_data_ptr = LLDB_INVALID_ADDRESS;
CompilerType m_pair_type;
std::vector<DictionaryItemDescriptor> m_children;
};
// values to leak if the latter, then I need to store a SharedPointer to it -
// so that it only goes away when everyone else in the cluster goes away oh
// joy!
- ValueObject *m_child_ptr;
+ ValueObject *m_child_ptr = nullptr;
ValueObjectSP m_child_sp;
};
uint8_t m_ptr_size = 8;
DataDescriptor_32 *m_data_32 = nullptr;
DataDescriptor_64 *m_data_64 = nullptr;
- lldb::addr_t m_data_ptr;
+ lldb::addr_t m_data_ptr = LLDB_INVALID_ADDRESS;
std::vector<SetItemDescriptor> m_children;
};
private:
ConstString m_name;
- uint8_t m_pointer_size;
- bool m_valid;
- uint64_t m_info_bits;
- uint64_t m_value_bits;
- int64_t m_value_bits_signed;
- uint64_t m_payload;
+ uint8_t m_pointer_size = 0;
+ bool m_valid = false;
+ uint64_t m_info_bits = 0;
+ uint64_t m_value_bits = 0;
+ int64_t m_value_bits_signed = 0;
+ uint64_t m_payload = 0;
};
} // namespace lldb_private
: m_process_wp(), m_objc_module_sp(objc_module_sp),
m_impl_fn_addr(LLDB_INVALID_ADDRESS),
m_impl_stret_fn_addr(LLDB_INVALID_ADDRESS),
- m_msg_forward_addr(LLDB_INVALID_ADDRESS) {
+ m_msg_forward_addr(LLDB_INVALID_ADDRESS),
+ m_msg_forward_stret_addr(LLDB_INVALID_ADDRESS) {
if (process_sp)
m_process_wp = process_sp;
// Look up the known resolution functions:
return nullptr;
}
-void
-AppleObjCTrampolineHandler::ForEachDispatchFunction(
- std::function<void(lldb::addr_t,
- const DispatchFunction &)> callback) {
+void AppleObjCTrampolineHandler::ForEachDispatchFunction(
+ std::function<void(lldb::addr_t, const DispatchFunction &)> callback) {
for (auto elem : m_msgSend_map) {
callback(elem.first, g_dispatch_functions[elem.second]);
}
int m_kernel_types = RSReduceBreakpointResolver::eKernelTypeAll;
llvm::StringRef m_reduce_name;
RSCoordinate m_coord;
- bool m_have_coord;
+ bool m_have_coord = false;
};
Options *GetOptions() override { return &m_options; }
}
RSCoordinate m_coord;
- bool m_have_coord;
+ bool m_have_coord = false;
};
bool DoExecute(Args &command, CommandReturnObject &result) override {
llvm::StringRef halter_name = ".")
: m_module(module), m_reduce_name(name), m_init_name(init_name),
m_accum_name(accum_name), m_comb_name(comb_name),
- m_outc_name(outc_name), m_halter_name(halter_name) {
+ m_outc_name(outc_name), m_halter_name(halter_name), m_accum_sig(0),
+ m_accum_data_size(0), m_comb_name_generated(false) {
// TODO Check whether the combiner is an autogenerated name, and track
// this
}
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
const lldb::offset_t load_cmd_offset = offset;
- llvm::MachO::load_command lc;
+ llvm::MachO::load_command lc = {};
if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
break;
if (lc.cmd == LC_DYSYMTAB) {
lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
const uint32_t cmd_offset = offset;
- llvm::MachO::load_command lc;
+ llvm::MachO::load_command lc = {};
if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
break;
if (lc.cmd == LC_NOTE) {
lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
const uint32_t cmd_offset = offset;
- llvm::MachO::load_command lc;
+ llvm::MachO::load_command lc = {};
if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
break;
if (lc.cmd == LC_NOTE) {
lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
const uint32_t cmd_offset = offset;
- llvm::MachO::load_command lc;
+ llvm::MachO::load_command lc = {};
if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
break;
if (lc.cmd == LC_NOTE) {
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
const lldb::offset_t load_cmd_offset = offset;
- llvm::MachO::version_min_command lc;
+ llvm::MachO::version_min_command lc = {};
if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
break;
if (lc.cmd == llvm::MachO::LC_VERSION_MIN_MACOSX ||
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
const lldb::offset_t load_cmd_offset = offset;
- llvm::MachO::version_min_command lc;
+ llvm::MachO::version_min_command lc = {};
if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
break;
if (lc.cmd == llvm::MachO::LC_VERSION_MIN_MACOSX ||
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
const lldb::offset_t load_cmd_offset = offset;
- llvm::MachO::version_min_command lc;
+ llvm::MachO::version_min_command lc = {};
if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
break;
if (lc.cmd == llvm::MachO::LC_BUILD_VERSION) {
lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
const uint32_t cmd_offset = offset;
- llvm::MachO::load_command lc;
+ llvm::MachO::load_command lc = {};
if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
break;
if (lc.cmd == LC_NOTE) {
typedef lldb_private::RangeVector<uint32_t, uint32_t> FileRangeArray;
lldb_private::Address m_entry_point_address;
FileRangeArray m_thread_context_offsets;
- lldb::offset_t m_linkedit_original_offset;
- lldb::addr_t m_text_address;
+ lldb::offset_t m_linkedit_original_offset = 0;
+ lldb::addr_t m_text_address = LLDB_INVALID_ADDRESS;
bool m_thread_context_offsets_valid;
lldb_private::FileSpecList m_reexported_dylibs;
bool m_allow_assembly_emulation_unwind_plans;
lldb_private::minidump::MinidumpContext_x86_64
GetThreadContext_64(RegisterContext *reg_ctx) {
lldb_private::minidump::MinidumpContext_x86_64 thread_context;
+ thread_context.p1_home = {};
thread_context.context_flags = static_cast<uint32_t>(
lldb_private::minidump::MinidumpContext_x86_64_Flags::x86_64_Flag |
lldb_private::minidump::MinidumpContext_x86_64_Flags::Control |
lldb::offset_t file_offset,
lldb::offset_t length)
: ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
- m_dos_header(), m_coff_header(), m_sect_headers(),
- m_entry_point_address(), m_deps_filespec() {
- ::memset(&m_dos_header, 0, sizeof(m_dos_header));
- ::memset(&m_coff_header, 0, sizeof(m_coff_header));
-}
+ m_dos_header(), m_coff_header(), m_coff_header_opt(), m_sect_headers(),
+ m_image_base(LLDB_INVALID_ADDRESS), m_entry_point_address(),
+ m_deps_filespec() {}
ObjectFilePECOFF::ObjectFilePECOFF(const lldb::ModuleSP &module_sp,
WritableDataBufferSP header_data_sp,
const lldb::ProcessSP &process_sp,
addr_t header_addr)
: ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
- m_dos_header(), m_coff_header(), m_sect_headers(),
- m_entry_point_address(), m_deps_filespec() {
- ::memset(&m_dos_header, 0, sizeof(m_dos_header));
- ::memset(&m_coff_header, 0, sizeof(m_coff_header));
-}
+ m_dos_header(), m_coff_header(), m_coff_header_opt(), m_sect_headers(),
+ m_image_base(LLDB_INVALID_ADDRESS), m_entry_point_address(),
+ m_deps_filespec() {}
ObjectFilePECOFF::~ObjectFilePECOFF() = default;
bool NeedsEndianSwap() const;
typedef struct dos_header { // DOS .EXE header
- uint16_t e_magic; // Magic number
- uint16_t e_cblp; // Bytes on last page of file
- uint16_t e_cp; // Pages in file
- uint16_t e_crlc; // Relocations
- uint16_t e_cparhdr; // Size of header in paragraphs
- uint16_t e_minalloc; // Minimum extra paragraphs needed
- uint16_t e_maxalloc; // Maximum extra paragraphs needed
- uint16_t e_ss; // Initial (relative) SS value
- uint16_t e_sp; // Initial SP value
- uint16_t e_csum; // Checksum
- uint16_t e_ip; // Initial IP value
- uint16_t e_cs; // Initial (relative) CS value
- uint16_t e_lfarlc; // File address of relocation table
- uint16_t e_ovno; // Overlay number
+ uint16_t e_magic = 0; // Magic number
+ uint16_t e_cblp = 0; // Bytes on last page of file
+ uint16_t e_cp = 0; // Pages in file
+ uint16_t e_crlc = 0; // Relocations
+ uint16_t e_cparhdr = 0; // Size of header in paragraphs
+ uint16_t e_minalloc = 0; // Minimum extra paragraphs needed
+ uint16_t e_maxalloc = 0; // Maximum extra paragraphs needed
+ uint16_t e_ss = 0; // Initial (relative) SS value
+ uint16_t e_sp = 0; // Initial SP value
+ uint16_t e_csum = 0; // Checksum
+ uint16_t e_ip = 0; // Initial IP value
+ uint16_t e_cs = 0; // Initial (relative) CS value
+ uint16_t e_lfarlc = 0; // File address of relocation table
+ uint16_t e_ovno = 0; // Overlay number
uint16_t e_res[4]; // Reserved words
- uint16_t e_oemid; // OEM identifier (for e_oeminfo)
- uint16_t e_oeminfo; // OEM information; e_oemid specific
- uint16_t e_res2[10]; // Reserved words
- uint32_t e_lfanew; // File address of new exe header
+ uint16_t e_oemid = 0; // OEM identifier (for e_oeminfo)
+ uint16_t e_oeminfo = 0; // OEM information; e_oemid specific
+ uint16_t e_res2[10] = {}; // Reserved words
+ uint32_t e_lfanew = 0; // File address of new exe header
} dos_header_t;
typedef struct coff_header {
- uint16_t machine;
- uint16_t nsects;
- uint32_t modtime;
- uint32_t symoff;
- uint32_t nsyms;
- uint16_t hdrsize;
- uint16_t flags;
+ uint16_t machine = 0;
+ uint16_t nsects = 0;
+ uint32_t modtime = 0;
+ uint32_t symoff = 0;
+ uint32_t nsyms = 0;
+ uint16_t hdrsize = 0;
+ uint16_t flags = 0;
} coff_header_t;
typedef struct data_directory {
- uint32_t vmaddr;
- uint32_t vmsize;
+ uint32_t vmaddr = 0;
+ uint32_t vmsize = 0;
} data_directory_t;
typedef struct coff_opt_header {
};
typedef struct section_header {
- char name[8];
- uint32_t vmsize; // Virtual Size
- uint32_t vmaddr; // Virtual Addr
- uint32_t size; // File size
- uint32_t offset; // File offset
- uint32_t reloff; // Offset to relocations
- uint32_t lineoff; // Offset to line table entries
- uint16_t nreloc; // Number of relocation entries
- uint16_t nline; // Number of line table entries
- uint32_t flags;
+ char name[8] = {};
+ uint32_t vmsize = 0; // Virtual Size
+ uint32_t vmaddr = 0; // Virtual Addr
+ uint32_t size = 0; // File size
+ uint32_t offset = 0; // File offset
+ uint32_t reloff = 0; // Offset to relocations
+ uint32_t lineoff = 0; // Offset to line table entries
+ uint16_t nreloc = 0; // Number of relocation entries
+ uint16_t nline = 0; // Number of line table entries
+ uint32_t flags = 0;
} section_header_t;
typedef struct coff_symbol {
- char name[8];
- uint32_t value;
- uint16_t sect;
- uint16_t type;
- uint8_t storage;
- uint8_t naux;
+ char name[8] = {};
+ uint32_t value = 0;
+ uint16_t sect = 0;
+ uint16_t type = 0;
+ uint8_t storage = 0;
+ uint8_t naux = 0;
} coff_symbol_t;
typedef struct export_directory_entry {
- uint32_t characteristics;
- uint32_t time_date_stamp;
- uint16_t major_version;
- uint16_t minor_version;
- uint32_t name;
- uint32_t base;
- uint32_t number_of_functions;
- uint32_t number_of_names;
- uint32_t address_of_functions;
- uint32_t address_of_names;
- uint32_t address_of_name_ordinals;
+ uint32_t characteristics = 0;
+ uint32_t time_date_stamp = 0;
+ uint16_t major_version = 0;
+ uint16_t minor_version = 0;
+ uint32_t name = 0;
+ uint32_t base = 0;
+ uint32_t number_of_functions = 0;
+ uint32_t number_of_names = 0;
+ uint32_t address_of_functions = 0;
+ uint32_t address_of_names = 0;
+ uint32_t address_of_name_ordinals = 0;
} export_directory_entry;
static bool ParseDOSHeader(lldb_private::DataExtractor &data,
}
::memset(&m_fpr, 0, sizeof(FPR));
+ ::memset(&m_ymm_set, 0, sizeof(YMM));
m_fpr_type = eNotValid;
}
m_packet_timeout(1),
#endif
m_echo_number(0), m_supports_qEcho(eLazyBoolCalculate), m_history(512),
- m_send_acks(true), m_compression_type(CompressionType::None),
- m_listen_url() {
+ m_send_acks(true), m_is_platform(false),
+ m_compression_type(CompressionType::None), m_listen_url() {
}
// Destructor
GDBRemoteCommunication::ScopedTimeout::ScopedTimeout(
GDBRemoteCommunication &gdb_comm, std::chrono::seconds timeout)
- : m_gdb_comm(gdb_comm), m_timeout_modified(false) {
+ : m_gdb_comm(gdb_comm), m_saved_timeout(0), m_timeout_modified(false) {
auto curr_timeout = gdb_comm.GetPacketTimeout();
// Only update the timeout if the timeout is greater than the current
// timeout. If the current timeout is larger, then just use that.
dqo_target_queue = UINT16_MAX;
dqo_target_queue = UINT16_MAX;
dqo_priority = UINT16_MAX;
+ dqo_label_size = 0;
+ dqo_flags_size = 0;
+ dqo_serialnum_size = 0;
+ dqo_width_size = 0;
+ dqo_running_size = 0;
+ dqo_suspend_cnt_size = 0;
+ dqo_target_queue_size = 0;
+ dqo_priority_size = 0;
}
bool IsValid() { return dqo_version != UINT16_MAX; }
lldb_private::EmulateInstruction *inst_emulator)
: UnwindAssembly(arch), m_inst_emulator_up(inst_emulator),
m_range_ptr(nullptr), m_unwind_plan_ptr(nullptr), m_curr_row(),
- m_cfa_reg_info(), m_fp_is_cfa(false), m_register_values(),
- m_pushed_regs(), m_curr_row_modified(false),
+ m_initial_sp(0), m_cfa_reg_info(), m_fp_is_cfa(false),
+ m_register_values(), m_pushed_regs(), m_curr_row_modified(false),
m_forward_branch_offset(0) {
if (m_inst_emulator_up.get()) {
m_inst_emulator_up->SetBaton(this);
: m_cur_insn(nullptr), m_machine_ip_regnum(LLDB_INVALID_REGNUM),
m_machine_sp_regnum(LLDB_INVALID_REGNUM),
m_machine_fp_regnum(LLDB_INVALID_REGNUM),
+ m_machine_alt_fp_regnum(LLDB_INVALID_REGNUM),
m_lldb_ip_regnum(LLDB_INVALID_REGNUM),
m_lldb_sp_regnum(LLDB_INVALID_REGNUM),
m_lldb_fp_regnum(LLDB_INVALID_REGNUM),
-
- m_reg_map(), m_arch(arch), m_cpu(k_cpu_unspecified), m_wordsize(-1),
+ m_lldb_alt_fp_regnum(LLDB_INVALID_REGNUM), m_reg_map(), m_arch(arch),
+ m_cpu(k_cpu_unspecified), m_wordsize(-1),
m_register_map_initialized(false), m_disasm_context() {
m_disasm_context =
::LLVMCreateDisasm(arch.GetTriple().getTriple().c_str(), nullptr,
projects / platform / upstream / llvm.git / commitdiff