KekenoBSD/src
3
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
4ee8c119c71a06dcad1e0fecc8c675e480e59337
src/include/lldb/Core/ArchSpec.h
T

729 lines
24 KiB
C++
Raw Blame History

//===-- ArchSpec.h ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_ArchSpec_h_
#define liblldb_ArchSpec_h_
#if defined(__cplusplus)
#include "lldb/lldb-forward.h"
#include "lldb/Core/ConstString.h"
#include "llvm/ADT/Triple.h"
namespace lldb_private {
struct CoreDefinition;
//----------------------------------------------------------------------
/// @class ArchSpec ArchSpec.h "lldb/Core/ArchSpec.h"
/// @brief An architecture specification class.
///
/// A class designed to be created from a cpu type and subtype, a
/// string representation, or an llvm::Triple. Keeping all of the
/// conversions of strings to architecture enumeration values confined
/// to this class allows new architecture support to be added easily.
//----------------------------------------------------------------------
class ArchSpec
{
public:
enum MIPSSubType
{
eMIPSSubType_unknown,
eMIPSSubType_mips32,
eMIPSSubType_mips32r2,
eMIPSSubType_mips32r6,
eMIPSSubType_mips32el,
eMIPSSubType_mips32r2el,
eMIPSSubType_mips32r6el,
eMIPSSubType_mips64,
eMIPSSubType_mips64r2,
eMIPSSubType_mips64r6,
eMIPSSubType_mips64el,
eMIPSSubType_mips64r2el,
eMIPSSubType_mips64r6el,
};
// Masks for the ases word of an ABI flags structure.
enum MIPSASE
{
eMIPSAse_dsp = 0x00000001, // DSP ASE
eMIPSAse_dspr2 = 0x00000002, // DSP R2 ASE
eMIPSAse_eva = 0x00000004, // Enhanced VA Scheme
eMIPSAse_mcu = 0x00000008, // MCU (MicroController) ASE
eMIPSAse_mdmx = 0x00000010, // MDMX ASE
eMIPSAse_mips3d = 0x00000020, // MIPS-3D ASE
eMIPSAse_mt = 0x00000040, // MT ASE
eMIPSAse_smartmips = 0x00000080, // SmartMIPS ASE
eMIPSAse_virt = 0x00000100, // VZ ASE
eMIPSAse_msa = 0x00000200, // MSA ASE
eMIPSAse_mips16 = 0x00000400, // MIPS16 ASE
eMIPSAse_micromips = 0x00000800, // MICROMIPS ASE
eMIPSAse_xpa = 0x00001000, // XPA ASE
eMIPSAse_mask = 0x00001fff,
eMIPSABI_O32 = 0x00002000,
eMIPSABI_N32 = 0x00004000,
eMIPSABI_N64 = 0x00008000,
eMIPSABI_O64 = 0x00020000,
eMIPSABI_EABI32 = 0x00040000,
eMIPSABI_EABI64 = 0x00080000,
eMIPSABI_mask = 0x000ff000
};
// MIPS Floating point ABI Values
enum MIPS_ABI_FP
{
eMIPS_ABI_FP_ANY = 0x00000000,
eMIPS_ABI_FP_DOUBLE = 0x00100000, // hard float / -mdouble-float
eMIPS_ABI_FP_SINGLE = 0x00200000, // hard float / -msingle-float
eMIPS_ABI_FP_SOFT = 0x00300000, // soft float
eMIPS_ABI_FP_OLD_64 = 0x00400000, // -mips32r2 -mfp64
eMIPS_ABI_FP_XX = 0x00500000, // -mfpxx
eMIPS_ABI_FP_64 = 0x00600000, // -mips32r2 -mfp64
eMIPS_ABI_FP_64A = 0x00700000, // -mips32r2 -mfp64 -mno-odd-spreg
eMIPS_ABI_FP_mask = 0x00700000
};
// ARM specific e_flags
enum ARMeflags
{
eARM_abi_soft_float = 0x00000200,
eARM_abi_hard_float = 0x00000400
};
enum Core
{
eCore_arm_generic,
eCore_arm_armv4,
eCore_arm_armv4t,
eCore_arm_armv5,
eCore_arm_armv5e,
eCore_arm_armv5t,
eCore_arm_armv6,
eCore_arm_armv6m,
eCore_arm_armv7,
eCore_arm_armv7f,
eCore_arm_armv7s,
eCore_arm_armv7k,
eCore_arm_armv7m,
eCore_arm_armv7em,
eCore_arm_xscale,
eCore_thumb,
eCore_thumbv4t,
eCore_thumbv5,
eCore_thumbv5e,
eCore_thumbv6,
eCore_thumbv6m,
eCore_thumbv7,
eCore_thumbv7s,
eCore_thumbv7k,
eCore_thumbv7f,
eCore_thumbv7m,
eCore_thumbv7em,
eCore_arm_arm64,
eCore_arm_armv8,
eCore_arm_aarch64,
eCore_mips32,
eCore_mips32r2,
eCore_mips32r3,
eCore_mips32r5,
eCore_mips32r6,
eCore_mips32el,
eCore_mips32r2el,
eCore_mips32r3el,
eCore_mips32r5el,
eCore_mips32r6el,
eCore_mips64,
eCore_mips64r2,
eCore_mips64r3,
eCore_mips64r5,
eCore_mips64r6,
eCore_mips64el,
eCore_mips64r2el,
eCore_mips64r3el,
eCore_mips64r5el,
eCore_mips64r6el,
eCore_ppc_generic,
eCore_ppc_ppc601,
eCore_ppc_ppc602,
eCore_ppc_ppc603,
eCore_ppc_ppc603e,
eCore_ppc_ppc603ev,
eCore_ppc_ppc604,
eCore_ppc_ppc604e,
eCore_ppc_ppc620,
eCore_ppc_ppc750,
eCore_ppc_ppc7400,
eCore_ppc_ppc7450,
eCore_ppc_ppc970,
eCore_ppc64_generic,
eCore_ppc64_ppc970_64,
eCore_s390x_generic,
eCore_sparc_generic,
eCore_sparc9_generic,
eCore_x86_32_i386,
eCore_x86_32_i486,
eCore_x86_32_i486sx,
eCore_x86_32_i686,
eCore_x86_64_x86_64,
eCore_x86_64_x86_64h, // Haswell enabled x86_64
eCore_hexagon_generic,
eCore_hexagon_hexagonv4,
eCore_hexagon_hexagonv5,
eCore_uknownMach32,
eCore_uknownMach64,
eCore_kalimba3,
eCore_kalimba4,
eCore_kalimba5,
kNumCores,
kCore_invalid,
// The following constants are used for wildcard matching only
kCore_any,
kCore_arm_any,
kCore_ppc_any,
kCore_ppc64_any,
kCore_x86_32_any,
kCore_x86_64_any,
kCore_hexagon_any,
kCore_arm_first = eCore_arm_generic,
kCore_arm_last = eCore_arm_xscale,
kCore_thumb_first = eCore_thumb,
kCore_thumb_last = eCore_thumbv7em,
kCore_ppc_first = eCore_ppc_generic,
kCore_ppc_last = eCore_ppc_ppc970,
kCore_ppc64_first = eCore_ppc64_generic,
kCore_ppc64_last = eCore_ppc64_ppc970_64,
kCore_x86_32_first = eCore_x86_32_i386,
kCore_x86_32_last = eCore_x86_32_i686,
kCore_x86_64_first = eCore_x86_64_x86_64,
kCore_x86_64_last = eCore_x86_64_x86_64h,
kCore_hexagon_first = eCore_hexagon_generic,
kCore_hexagon_last = eCore_hexagon_hexagonv5,
kCore_kalimba_first = eCore_kalimba3,
kCore_kalimba_last = eCore_kalimba5,
kCore_mips32_first = eCore_mips32,
kCore_mips32_last = eCore_mips32r6,
kCore_mips32el_first = eCore_mips32el,
kCore_mips32el_last = eCore_mips32r6el,
kCore_mips64_first = eCore_mips64,
kCore_mips64_last = eCore_mips64r6,
kCore_mips64el_first = eCore_mips64el,
kCore_mips64el_last = eCore_mips64r6el,
kCore_mips_first = eCore_mips32,
kCore_mips_last = eCore_mips64r6el
};
typedef void (* StopInfoOverrideCallbackType)(lldb_private::Thread &thread);
//------------------------------------------------------------------
/// Default constructor.
///
/// Default constructor that initializes the object with invalid
/// cpu type and subtype values.
//------------------------------------------------------------------
ArchSpec ();
//------------------------------------------------------------------
/// Constructor over triple.
///
/// Constructs an ArchSpec with properties consistent with the given
/// Triple.
//------------------------------------------------------------------
explicit
ArchSpec (const llvm::Triple &triple);
explicit
ArchSpec (const char *triple_cstr);
explicit
ArchSpec (const char *triple_cstr, Platform *platform);
//------------------------------------------------------------------
/// Constructor over architecture name.
///
/// Constructs an ArchSpec with properties consistent with the given
/// object type and architecture name.
//------------------------------------------------------------------
explicit
ArchSpec (ArchitectureType arch_type,
uint32_t cpu_type,
uint32_t cpu_subtype);
//------------------------------------------------------------------
/// Destructor.
//------------------------------------------------------------------
~ArchSpec ();
//------------------------------------------------------------------
/// Assignment operator.
///
/// @param[in] rhs another ArchSpec object to copy.
///
/// @return A const reference to this object.
//------------------------------------------------------------------
const ArchSpec&
operator= (const ArchSpec& rhs);
static size_t
AutoComplete (const char *name,
StringList &matches);
//------------------------------------------------------------------
/// Returns a static string representing the current architecture.
///
/// @return A static string correcponding to the current
/// architecture.
//------------------------------------------------------------------
const char *
GetArchitectureName () const;
//-----------------------------------------------------------------
/// if MIPS architecture return true.
///
/// @return a boolean value.
//-----------------------------------------------------------------
bool
IsMIPS() const;
//------------------------------------------------------------------
/// Returns a string representing current architecture as a target CPU
/// for tools like compiler, disassembler etc.
///
/// @return A string representing target CPU for the current
/// architecture.
//------------------------------------------------------------------
std::string
GetClangTargetCPU ();
//------------------------------------------------------------------
/// Clears the object state.
///
/// Clears the object state back to a default invalid state.
//------------------------------------------------------------------
void
Clear ();
//------------------------------------------------------------------
/// Returns the size in bytes of an address of the current
/// architecture.
///
/// @return The byte size of an address of the current architecture.
//------------------------------------------------------------------
uint32_t
GetAddressByteSize () const;
//------------------------------------------------------------------
/// Returns a machine family for the current architecture.
///
/// @return An LLVM arch type.
//------------------------------------------------------------------
llvm::Triple::ArchType
GetMachine () const;
//------------------------------------------------------------------
/// Returns the distribution id of the architecture.
///
/// This will be something like "ubuntu", "fedora", etc. on Linux.
///
/// @return A ConstString ref containing the distribution id,
/// potentially empty.
//------------------------------------------------------------------
const ConstString&
GetDistributionId () const;
//------------------------------------------------------------------
/// Set the distribution id of the architecture.
///
/// This will be something like "ubuntu", "fedora", etc. on Linux.
/// This should be the same value returned by
/// HostInfo::GetDistributionId ().
///------------------------------------------------------------------
void
SetDistributionId (const char* distribution_id);
//------------------------------------------------------------------
/// Tests if this ArchSpec is valid.
///
/// @return True if the current architecture is valid, false
/// otherwise.
//------------------------------------------------------------------
bool
IsValid () const
{
return m_core >= eCore_arm_generic && m_core < kNumCores;
}
//------------------------------------------------------------------
/// Return a string representing target application ABI.
///
/// @return A string representing target application ABI.
//------------------------------------------------------------------
std::string GetTargetABI() const;
bool
TripleVendorWasSpecified() const
{
return !m_triple.getVendorName().empty();
}
bool
TripleVendorIsUnspecifiedUnknown() const
{
return m_triple.getVendor() == llvm::Triple::UnknownVendor && m_triple.getVendorName().empty();
}
bool
TripleOSWasSpecified() const
{
return !m_triple.getOSName().empty();
}
bool
TripleEnvironmentWasSpecified () const
{
return !m_triple.getEnvironmentName().empty();
}
bool
TripleOSIsUnspecifiedUnknown() const
{
return m_triple.getOS() == llvm::Triple::UnknownOS && m_triple.getOSName().empty();
}
//------------------------------------------------------------------
/// Merges fields from another ArchSpec into this ArchSpec.
///
/// This will use the supplied ArchSpec to fill in any fields of
/// the triple in this ArchSpec which were unspecified. This can
/// be used to refine a generic ArchSpec with a more specific one.
/// For example, if this ArchSpec's triple is something like
/// i386-unknown-unknown-unknown, and we have a triple which is
/// x64-pc-windows-msvc, then merging that triple into this one
/// will result in the triple i386-pc-windows-msvc.
///
//------------------------------------------------------------------
void
MergeFrom(const ArchSpec &other);
//------------------------------------------------------------------
/// Change the architecture object type, CPU type and OS type.
///
/// @param[in] arch_type The object type of this ArchSpec.
///
/// @param[in] cpu The required CPU type.
///
/// @param[in] os The optional OS type
/// The default value of 0 was choosen to from the ELF spec value
/// ELFOSABI_NONE. ELF is the only one using this parameter. If another
/// format uses this parameter and 0 does not work, use a value over
/// 255 because in the ELF header this is value is only a byte.
///
/// @return True if the object, and CPU were successfully set.
///
/// As a side effect, the vendor value is usually set to unknown.
/// The exections are
/// aarch64-apple-ios
/// arm-apple-ios
/// thumb-apple-ios
/// x86-apple-
/// x86_64-apple-
///
/// As a side effect, the os value is usually set to unknown
/// The exceptions are
/// *-*-aix
/// aarch64-apple-ios
/// arm-apple-ios
/// thumb-apple-ios
/// powerpc-apple-darwin
/// *-*-freebsd
/// *-*-linux
/// *-*-netbsd
/// *-*-openbsd
/// *-*-solaris
//------------------------------------------------------------------
bool
SetArchitecture (ArchitectureType arch_type,
uint32_t cpu,
uint32_t sub,
uint32_t os = 0);
//------------------------------------------------------------------
/// Returns the byte order for the architecture specification.
///
/// @return The endian enumeration for the current endianness of
/// the architecture specification
//------------------------------------------------------------------
lldb::ByteOrder
GetByteOrder () const;
//------------------------------------------------------------------
/// Sets this ArchSpec's byte order.
///
/// In the common case there is no need to call this method as the
/// byte order can almost always be determined by the architecture.
/// However, many CPU's are bi-endian (ARM, Alpha, PowerPC, etc)
/// and the default/assumed byte order may be incorrect.
//------------------------------------------------------------------
void
SetByteOrder (lldb::ByteOrder byte_order)
{
m_byte_order = byte_order;
}
uint32_t
GetMinimumOpcodeByteSize() const;
uint32_t
GetMaximumOpcodeByteSize() const;
Core
GetCore () const
{
return m_core;
}
uint32_t
GetMachOCPUType () const;
uint32_t
GetMachOCPUSubType () const;
//------------------------------------------------------------------
/// Architecture data byte width accessor
///
/// @return the size in 8-bit (host) bytes of a minimum addressable
/// unit from the Architecture's data bus
//------------------------------------------------------------------
uint32_t
GetDataByteSize() const;
//------------------------------------------------------------------
/// Architecture code byte width accessor
///
/// @return the size in 8-bit (host) bytes of a minimum addressable
/// unit from the Architecture's code bus
//------------------------------------------------------------------
uint32_t
GetCodeByteSize() const;
//------------------------------------------------------------------
/// Architecture tripple accessor.
///
/// @return A triple describing this ArchSpec.
//------------------------------------------------------------------
llvm::Triple &
GetTriple ()
{
return m_triple;
}
//------------------------------------------------------------------
/// Architecture tripple accessor.
///
/// @return A triple describing this ArchSpec.
//------------------------------------------------------------------
const llvm::Triple &
GetTriple () const
{
return m_triple;
}
void
DumpTriple(Stream &s) const;
//------------------------------------------------------------------
/// Architecture tripple setter.
///
/// Configures this ArchSpec according to the given triple. If the
/// triple has unknown components in all of the vendor, OS, and
/// the optional environment field (i.e. "i386-unknown-unknown")
/// then default values are taken from the host. Architecture and
/// environment components are used to further resolve the CPU type
/// and subtype, endian characteristics, etc.
///
/// @return A triple describing this ArchSpec.
//------------------------------------------------------------------
bool
SetTriple (const llvm::Triple &triple);
bool
SetTriple (const char *triple_cstr);
bool
SetTriple (const char *triple_cstr,
Platform *platform);
//------------------------------------------------------------------
/// Returns the default endianness of the architecture.
///
/// @return The endian enumeration for the default endianness of
/// the architecture.
//------------------------------------------------------------------
lldb::ByteOrder
GetDefaultEndian () const;
//------------------------------------------------------------------
/// Returns true if 'char' is a signed type by defualt in the
/// architecture false otherwise
///
/// @return True if 'char' is a signed type by default on the
/// architecture and false otherwise.
//------------------------------------------------------------------
bool
CharIsSignedByDefault () const;
//------------------------------------------------------------------
/// Compare an ArchSpec to another ArchSpec, requiring an exact cpu
/// type match between them.
/// e.g. armv7s is not an exact match with armv7 - this would return false
///
/// @return true if the two ArchSpecs match.
//------------------------------------------------------------------
bool
IsExactMatch (const ArchSpec& rhs) const;
//------------------------------------------------------------------
/// Compare an ArchSpec to another ArchSpec, requiring a compatible
/// cpu type match between them.
/// e.g. armv7s is compatible with armv7 - this method would return true
///
/// @return true if the two ArchSpecs are compatible
//------------------------------------------------------------------
bool
IsCompatibleMatch (const ArchSpec& rhs) const;
//------------------------------------------------------------------
/// Get a stop info override callback for the current architecture.
///
/// Most platform specific code should go in lldb_private::Platform,
/// but there are cases where no matter which platform you are on
/// certain things hold true.
///
/// This callback is currently intended to handle cases where a
/// program stops at an instruction that won't get executed and it
/// allows the stop reasonm, like "breakpoint hit", to be replaced
/// with a different stop reason like "no stop reason".
///
/// This is specifically used for ARM in Thumb code when we stop in
/// an IT instruction (if/then/else) where the instruction won't get
/// executed and therefore it wouldn't be correct to show the program
/// stopped at the current PC. The code is generic and applies to all
/// ARM CPUs.
///
/// @return NULL or a valid stop info override callback for the
/// current architecture.
//------------------------------------------------------------------
StopInfoOverrideCallbackType
GetStopInfoOverrideCallback () const;
bool
IsFullySpecifiedTriple () const;
void
PiecewiseTripleCompare (const ArchSpec &other,
bool &arch_different,
bool &vendor_different,
bool &os_different,
bool &os_version_different,
bool &env_different);
//------------------------------------------------------------------
/// Detect whether this architecture uses thumb code exclusively
///
/// Some embedded ARM chips (e.g. the ARM Cortex M0-7 line) can
/// only execute the Thumb instructions, never Arm. We should normally
/// pick up arm/thumbness from their the processor status bits (cpsr/xpsr)
/// or hints on each function - but when doing bare-boards low level
/// debugging (especially common with these embedded processors), we may
/// not have those things easily accessible.
///
/// @return true if this is an arm ArchSpec which can only execute Thumb
/// instructions
//------------------------------------------------------------------
bool
IsAlwaysThumbInstructions () const;
uint32_t
GetFlags () const
{
return m_flags;
}
void
SetFlags (uint32_t flags)
{
m_flags = flags;
}
void SetFlags(std::string elf_abi);
protected:
bool
IsEqualTo (const ArchSpec& rhs, bool exact_match) const;
llvm::Triple m_triple;
Core m_core;
lldb::ByteOrder m_byte_order;
// Additional arch flags which we cannot get from triple and core
// For MIPS these are application specific extensions like
// micromips, mips16 etc.
uint32_t m_flags;
ConstString m_distribution_id;
// Called when m_def or m_entry are changed. Fills in all remaining
// members with default values.
void
CoreUpdated (bool update_triple);
};
//------------------------------------------------------------------
/// @fn bool operator< (const ArchSpec& lhs, const ArchSpec& rhs)
/// @brief Less than operator.
///
/// Tests two ArchSpec objects to see if \a lhs is less than \a
/// rhs.
///
/// @param[in] lhs The Left Hand Side ArchSpec object to compare.
/// @param[in] rhs The Left Hand Side ArchSpec object to compare.
///
/// @return true if \a lhs is less than \a rhs
//------------------------------------------------------------------
bool operator< (const ArchSpec& lhs, const ArchSpec& rhs);
} // namespace lldb_private
#endif // #if defined(__cplusplus)
#endif // #ifndef liblldb_ArchSpec_h_
Reference in New Issue View Git Blame Copy Permalink