intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-13 02:38:07 +08:00
Code Issues Packages Projects Releases Wiki Activity

Change AddressClass type from 'enum' to 'enum class'.

Browse Source 
If we have a function with signature f(addr_t, AddressClass), it is easy to muddle up the order of arguments without any warnings from compiler. 'enum class' prevents passing integer in place of AddressClass and vice versa.

llvm-svn: 335599
This commit is contained in:
Tatyana Krasnukha
2018-06-26 13:06:54 +00:00
parent bbadbe016f
commit 04803b3ef2
23 changed files with 164 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lldb/include/lldb/Core/Address.h
View File

@@ -11,7 +11,7 @@
#define liblldb_Address_h_
#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
#include "lldb/lldb-enumerations.h" // for AddressClass::eAddressClassInvalid
#include "lldb/lldb-enumerations.h" // for AddressClass::eInvalid
#include "lldb/lldb-forward.h" // for SectionWP, SectionSP, ModuleSP
#include "lldb/lldb-types.h" // for addr_t
@@ -338,7 +338,7 @@ public:
//------------------------------------------------------------------
lldb::addr_t GetOpcodeLoadAddress(
Target *target,
lldb::AddressClass addr_class = lldb::eAddressClassInvalid) const;
lldb::AddressClass addr_class = lldb::AddressClass::eInvalid) const;
//------------------------------------------------------------------
/// Get the section relative offset value.
@@ -432,7 +432,7 @@ public:
bool SetOpcodeLoadAddress(
lldb::addr_t load_addr, Target *target,
lldb::AddressClass addr_class = lldb::eAddressClassInvalid,
lldb::AddressClass addr_class = lldb::AddressClass::eInvalid,
bool allow_section_end = false);
bool SetCallableLoadAddress(lldb::addr_t load_addr, Target *target);

10
lldb/include/lldb/Core/Disassembler.h
View File

@@ -78,7 +78,7 @@ namespace lldb_private {
class Instruction {
public:
Instruction(const Address &address,
lldb::AddressClass addr_class = lldb::eAddressClassInvalid);
lldb::AddressClass addr_class = lldb::AddressClass::eInvalid);
virtual ~Instruction();
@@ -106,7 +106,7 @@ public:
void SetAddress(const Address &addr) {
// Invalidate the address class to lazily discover it if we need to.
m_address_class = lldb::eAddressClassInvalid;
m_address_class = lldb::AddressClass::eInvalid;
m_address = addr;
}
@@ -235,9 +235,9 @@ protected:
Address m_address; // The section offset address of this instruction
// We include an address class in the Instruction class to
// allow the instruction specify the
// eAddressClassCodeAlternateISA (currently used for
// thumb), and also to specify data (eAddressClassData).
// The usual value will be eAddressClassCode, but often
// AddressClass::eCodeAlternateISA (currently used for
// thumb), and also to specify data (AddressClass::eData).
// The usual value will be AddressClass::eCode, but often
// when disassembling memory, you might run into data.
// This can help us to disassemble appropriately.
private:

8
lldb/include/lldb/Target/Target.h
View File

@@ -732,14 +732,14 @@ public:
/// Take \a load_addr and potentially add any address bits that are
/// needed to make the address callable. For ARM this can set bit
/// zero (if it already isn't) if \a load_addr is a thumb function.
/// If \a addr_class is set to eAddressClassInvalid, then the address
/// If \a addr_class is set to AddressClass::eInvalid, then the address
/// adjustment will always happen. If it is set to an address class
/// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
/// returned.
//------------------------------------------------------------------
lldb::addr_t GetCallableLoadAddress(
lldb::addr_t load_addr,
lldb::AddressClass addr_class = lldb::eAddressClassInvalid) const;
lldb::AddressClass addr_class = lldb::AddressClass::eInvalid) const;
//------------------------------------------------------------------
/// Get \a load_addr as an opcode for this target.
@@ -748,14 +748,14 @@ public:
/// needed to make the address point to an opcode. For ARM this can
/// clear bit zero (if it already isn't) if \a load_addr is a
/// thumb function and load_addr is in code.
/// If \a addr_class is set to eAddressClassInvalid, then the address
/// If \a addr_class is set to AddressClass::eInvalid, then the address
/// adjustment will always happen. If it is set to an address class
/// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
/// returned.
//------------------------------------------------------------------
lldb::addr_t GetOpcodeLoadAddress(
lldb::addr_t load_addr,
lldb::AddressClass addr_class = lldb::eAddressClassInvalid) const;
lldb::AddressClass addr_class = lldb::AddressClass::eInvalid) const;
// Get load_addr as breakable load address for this target. Take a addr and
// check if for any reason there is a better address than this to put a

14
lldb/include/lldb/lldb-enumerations.h
View File

@@ -824,13 +824,13 @@ enum FrameComparison {
// in code is data.
//----------------------------------------------------------------------
enum AddressClass {
eAddressClassInvalid,
eAddressClassUnknown,
eAddressClassCode,
eAddressClassCodeAlternateISA,
eAddressClassData,
eAddressClassDebug,
eAddressClassRuntime
eInvalid,
eUnknown,
eCode,
eCodeAlternateISA,
eData,
eDebug,
eRuntime
};
//----------------------------------------------------------------------

2
lldb/source/API/SBAddress.cpp
View File

@@ -244,5 +244,5 @@ SBLineEntry SBAddress::GetLineEntry() {
AddressClass SBAddress::GetAddressClass() {
if (m_opaque_ap->IsValid())
return m_opaque_ap->GetAddressClass();
return eAddressClassInvalid;
return AddressClass::eInvalid;
}

2
lldb/source/API/SBFrame.cpp
View File

@@ -419,7 +419,7 @@ addr_t SBFrame::GetPC() const {
frame = exe_ctx.GetFramePtr();
if (frame) {
addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress(
target, eAddressClassCode);
target, AddressClass::eCode);
} else {
if (log)
log->Printf("SBFrame::GetPC () => error: could not reconstruct frame "

2
lldb/source/API/SBInstruction.cpp
View File

@@ -279,5 +279,5 @@ lldb::AddressClass SBInstruction::GetAddressClass() {
lldb::InstructionSP inst_sp(GetOpaque());
if (inst_sp)
return inst_sp->GetAddressClass();
return eAddressClassInvalid;
return AddressClass::eInvalid;
}

8
lldb/source/Core/Address.cpp
View File

@@ -351,7 +351,7 @@ addr_t Address::GetOpcodeLoadAddress(Target *target,
AddressClass addr_class) const {
addr_t code_addr = GetLoadAddress(target);
if (code_addr != LLDB_INVALID_ADDRESS) {
if (addr_class == eAddressClassInvalid)
if (addr_class == AddressClass::eInvalid)
addr_class = GetAddressClass();
code_addr = target->GetOpcodeLoadAddress(code_addr, addr_class);
}
@@ -363,7 +363,7 @@ bool Address::SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target,
bool allow_section_end) {
if (SetLoadAddress(load_addr, target, allow_section_end)) {
if (target) {
if (addr_class == eAddressClassInvalid)
if (addr_class == AddressClass::eInvalid)
addr_class = GetAddressClass();
m_offset = target->GetOpcodeLoadAddress(m_offset, addr_class);
}
@@ -438,7 +438,7 @@ bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
/*
* MIPS:
* Display address in compressed form for MIPS16 or microMIPS
* if the address belongs to eAddressClassCodeAlternateISA.
* if the address belongs to AddressClass::eCodeAlternateISA.
*/
if (target) {
const llvm::Triple::ArchType llvm_arch =
@@ -992,7 +992,7 @@ AddressClass Address::GetAddressClass() const {
return obj_file->GetAddressClass(GetFileAddress());
}
}
return eAddressClassUnknown;
return AddressClass::eUnknown;
}
bool Address::SetLoadAddress(lldb::addr_t load_addr, Target *target,

4
lldb/source/Core/Disassembler.cpp
View File

@@ -677,7 +677,7 @@ Instruction::Instruction(const Address &address, AddressClass addr_class)
Instruction::~Instruction() = default;
AddressClass Instruction::GetAddressClass() {
if (m_address_class == eAddressClassInvalid)
if (m_address_class == AddressClass::eInvalid)
m_address_class = m_address.GetAddressClass();
return m_address_class;
}
@@ -1279,7 +1279,7 @@ const InstructionList &Disassembler::GetInstructionList() const {
//----------------------------------------------------------------------
PseudoInstruction::PseudoInstruction()
: Instruction(Address(), eAddressClassUnknown), m_description() {}
: Instruction(Address(), AddressClass::eUnknown), m_description() {}
PseudoInstruction::~PseudoInstruction() = default;

6
lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
View File

@@ -173,7 +173,7 @@ public:
if (disasm_sp->m_alternate_disasm_up) {
const AddressClass address_class = GetAddressClass();
if (address_class == eAddressClassCodeAlternateISA) {
if (address_class == AddressClass::eCodeAlternateISA) {
is_alternate_isa = true;
return disasm_sp->m_alternate_disasm_up.get();
}
@@ -300,7 +300,7 @@ public:
if (disasm_sp) {
DisassemblerLLVMC::MCDisasmInstance *mc_disasm_ptr;
if (address_class == eAddressClassCodeAlternateISA)
if (address_class == AddressClass::eCodeAlternateISA)
mc_disasm_ptr = disasm_sp->m_alternate_disasm_up.get();
else
mc_disasm_ptr = disasm_sp->m_disasm_up.get();
@@ -1257,7 +1257,7 @@ size_t DisassemblerLLVMC::DecodeInstructions(const Address &base_addr,
while (data_cursor < data_byte_size &&
instructions_parsed < num_instructions) {
AddressClass address_class = eAddressClassCode;
AddressClass address_class = AddressClass::eCode;
if (m_alternate_disasm_up)
address_class = inst_addr.GetAddressClass();

6
lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp
View File

@@ -13888,10 +13888,10 @@ bool EmulateInstructionARM::SetInstruction(const Opcode &insn_opcode,
else {
AddressClass addr_class = inst_addr.GetAddressClass();
if ((addr_class == eAddressClassCode) ||
(addr_class == eAddressClassUnknown))
if ((addr_class == AddressClass::eCode) ||
(addr_class == AddressClass::eUnknown))
m_opcode_mode = eModeARM;
else if (addr_class == eAddressClassCodeAlternateISA)
else if (addr_class == AddressClass::eCodeAlternateISA)
m_opcode_mode = eModeThumb;
else
return false;

4
lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
View File

@@ -1015,7 +1015,7 @@ bool EmulateInstructionMIPS::SetInstruction(const Opcode &insn_opcode,
m_use_alt_disaasm = false;
if (EmulateInstruction::SetInstruction(insn_opcode, inst_addr, target)) {
if (inst_addr.GetAddressClass() == eAddressClassCodeAlternateISA) {
if (inst_addr.GetAddressClass() == AddressClass::eCodeAlternateISA) {
Status error;
lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
@@ -1044,7 +1044,7 @@ bool EmulateInstructionMIPS::SetInstruction(const Opcode &insn_opcode,
return true;
} else {
/*
* If the address class is not eAddressClassCodeAlternateISA then
* If the address class is not AddressClass::eCodeAlternateISA then
* the function is not microMIPS. In this case instruction size is
* always 4 bytes.
*/

30
lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
View File

@@ -865,7 +865,7 @@ uint32_t ObjectFileELF::GetAddressByteSize() const {
AddressClass ObjectFileELF::GetAddressClass(addr_t file_addr) {
Symtab *symtab = GetSymtab();
if (!symtab)
return eAddressClassUnknown;
return AddressClass::eUnknown;
// The address class is determined based on the symtab. Ask it from the
// object file what contains the symtab information.
@@ -874,14 +874,14 @@ AddressClass ObjectFileELF::GetAddressClass(addr_t file_addr) {
return symtab_objfile->GetAddressClass(file_addr);
auto res = ObjectFile::GetAddressClass(file_addr);
if (res != eAddressClassCode)
if (res != AddressClass::eCode)
return res;
auto ub = m_address_class_map.upper_bound(file_addr);
if (ub == m_address_class_map.begin()) {
// No entry in the address class map before the address. Return default
// address class for an address in a code section.
return eAddressClassCode;
return AddressClass::eCode;
}
// Move iterator to the address class entry preceding address
@@ -2167,18 +2167,18 @@ unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
switch (mapping_symbol) {
case 'a':
// $a[.<any>]* - marks an ARM instruction sequence
m_address_class_map[symbol.st_value] = eAddressClassCode;
m_address_class_map[symbol.st_value] = AddressClass::eCode;
break;
case 'b':
case 't':
// $b[.<any>]* - marks a THUMB BL instruction sequence
// $t[.<any>]* - marks a THUMB instruction sequence
m_address_class_map[symbol.st_value] =
eAddressClassCodeAlternateISA;
AddressClass::eCodeAlternateISA;
break;
case 'd':
// $d[.<any>]* - marks a data item sequence (e.g. lit pool)
m_address_class_map[symbol.st_value] = eAddressClassData;
m_address_class_map[symbol.st_value] = AddressClass::eData;
break;
}
}
@@ -2192,11 +2192,11 @@ unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
switch (mapping_symbol) {
case 'x':
// $x[.<any>]* - marks an A64 instruction sequence
m_address_class_map[symbol.st_value] = eAddressClassCode;
m_address_class_map[symbol.st_value] = AddressClass::eCode;
break;
case 'd':
// $d[.<any>]* - marks a data item sequence (e.g. lit pool)
m_address_class_map[symbol.st_value] = eAddressClassData;
m_address_class_map[symbol.st_value] = AddressClass::eData;
break;
}
}
@@ -2215,10 +2215,10 @@ unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
// symbol_value that we store in the symtab.
symbol_value_offset = -1;
m_address_class_map[symbol.st_value ^ 1] =
eAddressClassCodeAlternateISA;
AddressClass::eCodeAlternateISA;
} else {
// This address is ARM
m_address_class_map[symbol.st_value] = eAddressClassCode;
m_address_class_map[symbol.st_value] = AddressClass::eCode;
}
}
}
@@ -2243,17 +2243,17 @@ unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
llvm_arch == llvm::Triple::mips64 ||
llvm_arch == llvm::Triple::mips64el) {
if (IS_MICROMIPS(symbol.st_other))
m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA;
m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA;
else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) {
symbol.st_value = symbol.st_value & (~1ull);
m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA;
m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA;
} else {
if (symbol_type == eSymbolTypeCode)
m_address_class_map[symbol.st_value] = eAddressClassCode;
m_address_class_map[symbol.st_value] = AddressClass::eCode;
else if (symbol_type == eSymbolTypeData)
m_address_class_map[symbol.st_value] = eAddressClassData;
m_address_class_map[symbol.st_value] = AddressClass::eData;
else
m_address_class_map[symbol.st_value] = eAddressClassUnknown;
m_address_class_map[symbol.st_value] = AddressClass::eUnknown;
}
}
}

74
lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
View File

@@ -1161,19 +1161,19 @@ AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
const lldb::SectionType section_type = section_sp->GetType();
switch (section_type) {
case eSectionTypeInvalid:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSectionTypeCode:
if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM) {
// For ARM we have a bit in the n_desc field of the symbol that
// tells us ARM/Thumb which is bit 0x0008.
if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
return eAddressClassCodeAlternateISA;
return AddressClass::eCodeAlternateISA;
}
return eAddressClassCode;
return AddressClass::eCode;
case eSectionTypeContainer:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSectionTypeData:
case eSectionTypeDataCString:
@@ -1187,7 +1187,7 @@ AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
case eSectionTypeDataObjCMessageRefs:
case eSectionTypeDataObjCCFStrings:
case eSectionTypeGoSymtab:
return eAddressClassData;
return AddressClass::eData;
case eSectionTypeDebug:
case eSectionTypeDWARFDebugAbbrev:
@@ -1212,13 +1212,13 @@ AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
case eSectionTypeDWARFAppleNamespaces:
case eSectionTypeDWARFAppleObjC:
case eSectionTypeDWARFGNUDebugAltLink:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSectionTypeEHFrame:
case eSectionTypeARMexidx:
case eSectionTypeARMextab:
case eSectionTypeCompactUnwind:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSectionTypeAbsoluteAddress:
case eSectionTypeELFSymbolTable:
@@ -1226,7 +1226,7 @@ AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
case eSectionTypeELFRelocationEntries:
case eSectionTypeELFDynamicLinkInfo:
case eSectionTypeOther:
return eAddressClassUnknown;
return AddressClass::eUnknown;
}
}
}
@@ -1234,9 +1234,9 @@ AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
const SymbolType symbol_type = symbol->GetType();
switch (symbol_type) {
case eSymbolTypeAny:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSymbolTypeAbsolute:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSymbolTypeCode:
case eSymbolTypeTrampoline:
@@ -1245,62 +1245,62 @@ AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
// For ARM we have a bit in the n_desc field of the symbol that tells
// us ARM/Thumb which is bit 0x0008.
if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
return eAddressClassCodeAlternateISA;
return AddressClass::eCodeAlternateISA;
}
return eAddressClassCode;
return AddressClass::eCode;
case eSymbolTypeData:
return eAddressClassData;
return AddressClass::eData;
case eSymbolTypeRuntime:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeException:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeSourceFile:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeHeaderFile:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeObjectFile:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeCommonBlock:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeBlock:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeLocal:
return eAddressClassData;
return AddressClass::eData;
case eSymbolTypeParam:
return eAddressClassData;
return AddressClass::eData;
case eSymbolTypeVariable:
return eAddressClassData;
return AddressClass::eData;
case eSymbolTypeVariableType:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeLineEntry:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeLineHeader:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeScopeBegin:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeScopeEnd:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeAdditional:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSymbolTypeCompiler:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeInstrumentation:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeUndefined:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSymbolTypeObjCClass:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeObjCMetaClass:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeObjCIVar:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeReExported:
return eAddressClassRuntime;
return AddressClass::eRuntime;
}
}
}
return eAddressClassUnknown;
return AddressClass::eUnknown;
}
Symtab *ObjectFileMachO::GetSymtab() {

8
lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
View File

@@ -225,16 +225,16 @@ PlatformFreeBSD::GetSoftwareBreakpointTrapOpcode(Target &target,
switch (target.GetArchitecture().GetMachine()) {
case llvm::Triple::arm: {
lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
AddressClass addr_class = eAddressClassUnknown;
AddressClass addr_class = AddressClass::eUnknown;
if (bp_loc_sp) {
addr_class = bp_loc_sp->GetAddress().GetAddressClass();
if (addr_class == eAddressClassUnknown &&
if (addr_class == AddressClass::eUnknown &&
(bp_loc_sp->GetAddress().GetFileAddress() & 1))
addr_class = eAddressClassCodeAlternateISA;
addr_class = AddressClass::eCodeAlternateISA;
}
if (addr_class == eAddressClassCodeAlternateISA) {
if (addr_class == AddressClass::eCodeAlternateISA) {
// TODO: Enable when FreeBSD supports thumb breakpoints.
// FreeBSD kernel as of 10.x, does not support thumb breakpoints
return 0;

2
lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
View File

@@ -466,7 +466,7 @@ PlatformDarwin::GetSoftwareBreakpointTrapOpcode(Target &target,
lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
if (bp_loc_sp)
bp_is_thumb = bp_loc_sp->GetAddress().GetAddressClass() ==
eAddressClassCodeAlternateISA;
AddressClass::eCodeAlternateISA;
}
if (bp_is_thumb) {
trap_opcode = g_thumb_breakpooint_opcode;

6
lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
View File

@@ -661,13 +661,13 @@ ProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
AddressClass addr_class = eAddressClassUnknown;
AddressClass addr_class = AddressClass::eUnknown;
if (bp_loc_sp)
addr_class = bp_loc_sp->GetAddress().GetAddressClass();
if (addr_class == eAddressClassCodeAlternateISA ||
(addr_class == eAddressClassUnknown &&
if (addr_class == AddressClass::eCodeAlternateISA ||
(addr_class == AddressClass::eUnknown &&
bp_loc_sp->GetAddress().GetOffset() & 1)) {
opcode = g_thumb_breakpoint_opcode;
opcode_size = sizeof(g_thumb_breakpoint_opcode);

74
lldb/source/Symbol/ObjectFile.cpp
View File

@@ -324,11 +324,11 @@ AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
const SectionType section_type = section_sp->GetType();
switch (section_type) {
case eSectionTypeInvalid:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSectionTypeCode:
return eAddressClassCode;
return AddressClass::eCode;
case eSectionTypeContainer:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSectionTypeData:
case eSectionTypeDataCString:
case eSectionTypeDataCStringPointers:
@@ -341,7 +341,7 @@ AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
case eSectionTypeDataObjCMessageRefs:
case eSectionTypeDataObjCCFStrings:
case eSectionTypeGoSymtab:
return eAddressClassData;
return AddressClass::eData;
case eSectionTypeDebug:
case eSectionTypeDWARFDebugAbbrev:
case eSectionTypeDWARFDebugAddr:
@@ -365,18 +365,18 @@ AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
case eSectionTypeDWARFAppleNamespaces:
case eSectionTypeDWARFAppleObjC:
case eSectionTypeDWARFGNUDebugAltLink:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSectionTypeEHFrame:
case eSectionTypeARMexidx:
case eSectionTypeARMextab:
case eSectionTypeCompactUnwind:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSectionTypeELFSymbolTable:
case eSectionTypeELFDynamicSymbols:
case eSectionTypeELFRelocationEntries:
case eSectionTypeELFDynamicLinkInfo:
case eSectionTypeOther:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSectionTypeAbsoluteAddress:
// In case of absolute sections decide the address class based on
// the symbol type because the section type isn't specify if it is
@@ -389,67 +389,67 @@ AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
const SymbolType symbol_type = symbol->GetType();
switch (symbol_type) {
case eSymbolTypeAny:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSymbolTypeAbsolute:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSymbolTypeCode:
return eAddressClassCode;
return AddressClass::eCode;
case eSymbolTypeTrampoline:
return eAddressClassCode;
return AddressClass::eCode;
case eSymbolTypeResolver:
return eAddressClassCode;
return AddressClass::eCode;
case eSymbolTypeData:
return eAddressClassData;
return AddressClass::eData;
case eSymbolTypeRuntime:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeException:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeSourceFile:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeHeaderFile:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeObjectFile:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeCommonBlock:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeBlock:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeLocal:
return eAddressClassData;
return AddressClass::eData;
case eSymbolTypeParam:
return eAddressClassData;
return AddressClass::eData;
case eSymbolTypeVariable:
return eAddressClassData;
return AddressClass::eData;
case eSymbolTypeVariableType:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeLineEntry:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeLineHeader:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeScopeBegin:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeScopeEnd:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeAdditional:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSymbolTypeCompiler:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeInstrumentation:
return eAddressClassDebug;
return AddressClass::eDebug;
case eSymbolTypeUndefined:
return eAddressClassUnknown;
return AddressClass::eUnknown;
case eSymbolTypeObjCClass:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeObjCMetaClass:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeObjCIVar:
return eAddressClassRuntime;
return AddressClass::eRuntime;
case eSymbolTypeReExported:
return eAddressClassRuntime;
return AddressClass::eRuntime;
}
}
}
return eAddressClassUnknown;
return AddressClass::eUnknown;
}
DataBufferSP ObjectFile::ReadMemory(const ProcessSP &process_sp,

8
lldb/source/Target/Platform.cpp
View File

@@ -1834,16 +1834,16 @@ size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target,
static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
AddressClass addr_class = eAddressClassUnknown;
AddressClass addr_class = AddressClass::eUnknown;
if (bp_loc_sp) {
addr_class = bp_loc_sp->GetAddress().GetAddressClass();
if (addr_class == eAddressClassUnknown &&
if (addr_class == AddressClass::eUnknown &&
(bp_loc_sp->GetAddress().GetFileAddress() & 1))
addr_class = eAddressClassCodeAlternateISA;
addr_class = AddressClass::eCodeAlternateISA;
}
if (addr_class == eAddressClassCodeAlternateISA) {
if (addr_class == AddressClass::eCodeAlternateISA) {
trap_opcode = g_thumb_breakpoint_opcode;
trap_opcode_size = sizeof(g_thumb_breakpoint_opcode);
} else {

2
lldb/source/Target/RegisterContext.cpp
View File

@@ -135,7 +135,7 @@ uint64_t RegisterContext::GetPC(uint64_t fail_value) {
if (target_sp) {
Target *target = target_sp.get();
if (target)
pc = target->GetOpcodeLoadAddress(pc, eAddressClassCode);
pc = target->GetOpcodeLoadAddress(pc, AddressClass::eCode);
}
}

2
lldb/source/Target/StackFrame.cpp
View File

@@ -194,7 +194,7 @@ const Address &StackFrame::GetFrameCodeAddress() {
const bool allow_section_end = true;
if (m_frame_code_addr.SetOpcodeLoadAddress(
m_frame_code_addr.GetOffset(), target_sp.get(),
eAddressClassCode, allow_section_end)) {
AddressClass::eCode, allow_section_end)) {
ModuleSP module_sp(m_frame_code_addr.GetModule());
if (module_sp) {
m_sc.module_sp = module_sp;

4
lldb/source/Target/StackFrameList.cpp
View File

@@ -324,9 +324,9 @@ void StackFrameList::GetFramesUpTo(uint32_t end_idx) {
// case resolve the address again to the correct section plus
// offset form.
addr_t load_addr = curr_frame_address.GetOpcodeLoadAddress(
target_sp.get(), eAddressClassCode);
target_sp.get(), AddressClass::eCode);
curr_frame_address.SetOpcodeLoadAddress(
load_addr - 1, target_sp.get(), eAddressClassCode);
load_addr - 1, target_sp.get(), AddressClass::eCode);
} else {
curr_frame_address.Slide(-1);
}

46
lldb/source/Target/Target.cpp
View File

@@ -2358,16 +2358,16 @@ lldb::addr_t Target::GetCallableLoadAddress(lldb::addr_t load_addr,
case llvm::Triple::mips64:
case llvm::Triple::mips64el:
switch (addr_class) {
case eAddressClassData:
case eAddressClassDebug:
case AddressClass::eData:
case AddressClass::eDebug:
return LLDB_INVALID_ADDRESS;
case eAddressClassUnknown:
case eAddressClassInvalid:
case eAddressClassCode:
case eAddressClassCodeAlternateISA:
case eAddressClassRuntime:
if ((code_addr & 2ull) || (addr_class == eAddressClassCodeAlternateISA))
case AddressClass::eUnknown:
case AddressClass::eInvalid:
case AddressClass::eCode:
case AddressClass::eCodeAlternateISA:
case AddressClass::eRuntime:
if ((code_addr & 2ull) || (addr_class == AddressClass::eCodeAlternateISA))
code_addr |= 1ull;
break;
}
@@ -2376,22 +2376,22 @@ lldb::addr_t Target::GetCallableLoadAddress(lldb::addr_t load_addr,
case llvm::Triple::arm:
case llvm::Triple::thumb:
switch (addr_class) {
case eAddressClassData:
case eAddressClassDebug:
case AddressClass::eData:
case AddressClass::eDebug:
return LLDB_INVALID_ADDRESS;
case eAddressClassUnknown:
case eAddressClassInvalid:
case eAddressClassCode:
case eAddressClassCodeAlternateISA:
case eAddressClassRuntime:
case AddressClass::eUnknown:
case AddressClass::eInvalid:
case AddressClass::eCode:
case AddressClass::eCodeAlternateISA:
case AddressClass::eRuntime:
// Check if bit zero it no set?
if ((code_addr & 1ull) == 0) {
// Bit zero isn't set, check if the address is a multiple of 2?
if (code_addr & 2ull) {
// The address is a multiple of 2 so it must be thumb, set bit zero
code_addr |= 1ull;
} else if (addr_class == eAddressClassCodeAlternateISA) {
} else if (addr_class == AddressClass::eCodeAlternateISA) {
// We checked the address and the address claims to be the alternate
// ISA which means thumb, so set bit zero.
code_addr |= 1ull;
@@ -2418,15 +2418,15 @@ lldb::addr_t Target::GetOpcodeLoadAddress(lldb::addr_t load_addr,
case llvm::Triple::arm:
case llvm::Triple::thumb:
switch (addr_class) {
case eAddressClassData:
case eAddressClassDebug:
case AddressClass::eData:
case AddressClass::eDebug:
return LLDB_INVALID_ADDRESS;
case eAddressClassInvalid:
case eAddressClassUnknown:
case eAddressClassCode:
case eAddressClassCodeAlternateISA:
case eAddressClassRuntime:
case AddressClass::eInvalid:
case AddressClass::eUnknown:
case AddressClass::eCode:
case AddressClass::eCodeAlternateISA:
case AddressClass::eRuntime:
opcode_addr &= ~(1ull);
break;
}