contrib/llvm/tools/lldb/include/lldb/Core/ArchSpec.h

   1 //===-- ArchSpec.h ----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef liblldb_ArchSpec_h_
  11 #define liblldb_ArchSpec_h_
  12
  13 #if defined(__cplusplus)
  14
  15 #include "lldb/lldb-private.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/ADT/Triple.h"
  18
  19 namespace lldb_private {
  20
  21 struct CoreDefinition;
  22
  23 //----------------------------------------------------------------------
  24 /// @class ArchSpec ArchSpec.h "lldb/Core/ArchSpec.h"
  25 /// @brief An architecture specification class.
  26 ///
  27 /// A class designed to be created from a cpu type and subtype, a
  28 /// string representation, or an llvm::Triple.  Keeping all of the
  29 /// conversions of strings to architecture enumeration values confined
  30 /// to this class allows new architecture support to be added easily.
  31 //----------------------------------------------------------------------
  32 class ArchSpec
  33 {
  34 public:
  35     enum Core
  36     {
  37         eCore_arm_generic,
  38         eCore_arm_armv4,
  39         eCore_arm_armv4t,
  40         eCore_arm_armv5,
  41         eCore_arm_armv5e,
  42         eCore_arm_armv5t,
  43         eCore_arm_armv6,
  44         eCore_arm_armv7,
  45         eCore_arm_armv7f,
  46         eCore_arm_armv7s,
  47         eCore_arm_armv7k,
  48         eCore_arm_armv7m,
  49         eCore_arm_armv7em,
  50         eCore_arm_xscale,
  51         eCore_thumb,
  52         eCore_thumbv4t,
  53         eCore_thumbv5,
  54         eCore_thumbv5e,
  55         eCore_thumbv6,
  56         eCore_thumbv7,
  57         eCore_thumbv7f,
  58         eCore_thumbv7s,
  59         eCore_thumbv7k,
  60         eCore_thumbv7m,
  61         eCore_thumbv7em,
  62
  63         eCore_ppc_generic,
  64         eCore_ppc_ppc601,
  65         eCore_ppc_ppc602,
  66         eCore_ppc_ppc603,
  67         eCore_ppc_ppc603e,
  68         eCore_ppc_ppc603ev,
  69         eCore_ppc_ppc604,
  70         eCore_ppc_ppc604e,
  71         eCore_ppc_ppc620,
  72         eCore_ppc_ppc750,
  73         eCore_ppc_ppc7400,
  74         eCore_ppc_ppc7450,
  75         eCore_ppc_ppc970,
  76
  77         eCore_ppc64_generic,
  78         eCore_ppc64_ppc970_64,
  79
  80         eCore_sparc_generic,
  81
  82         eCore_sparc9_generic,
  83
  84         eCore_x86_32_i386,
  85         eCore_x86_32_i486,
  86         eCore_x86_32_i486sx,
  87
  88         eCore_x86_64_x86_64,
  89         eCore_uknownMach32,
  90         eCore_uknownMach64,
  91         kNumCores,
  92
  93         kCore_invalid,
  94         // The following constants are used for wildcard matching only
  95         kCore_any,
  96         kCore_arm_any,
  97         kCore_ppc_any,
  98         kCore_ppc64_any,
  99         kCore_x86_32_any,
 100
 101         kCore_arm_first     = eCore_arm_generic,
 102         kCore_arm_last      = eCore_arm_xscale,
 103
 104         kCore_thumb_first   = eCore_thumb,
 105         kCore_thumb_last    = eCore_thumbv7em,
 106
 107         kCore_ppc_first     = eCore_ppc_generic,
 108         kCore_ppc_last      = eCore_ppc_ppc970,
 109
 110         kCore_ppc64_first   = eCore_ppc64_generic,
 111         kCore_ppc64_last    = eCore_ppc64_ppc970_64,
 112
 113         kCore_x86_32_first  = eCore_x86_32_i386,
 114         kCore_x86_32_last   = eCore_x86_32_i486sx
 115     };
 116
 117     //------------------------------------------------------------------
 118     /// Default constructor.
 119     ///
 120     /// Default constructor that initializes the object with invalid
 121     /// cpu type and subtype values.
 122     //------------------------------------------------------------------
 123     ArchSpec ();
 124
 125     //------------------------------------------------------------------
 126     /// Constructor over triple.
 127     ///
 128     /// Constructs an ArchSpec with properties consistent with the given
 129     /// Triple.
 130     //------------------------------------------------------------------
 131     explicit
 132     ArchSpec (const llvm::Triple &triple);
 133     explicit
 134     ArchSpec (const char *triple_cstr);
 135     explicit
 136     ArchSpec (const char *triple_cstr, Platform *platform);
 137     //------------------------------------------------------------------
 138     /// Constructor over architecture name.
 139     ///
 140     /// Constructs an ArchSpec with properties consistent with the given
 141     /// object type and architecture name.
 142     //------------------------------------------------------------------
 143     explicit
 144     ArchSpec (ArchitectureType arch_type,
 145               uint32_t cpu_type,
 146               uint32_t cpu_subtype);
 147
 148     //------------------------------------------------------------------
 149     /// Destructor.
 150     //------------------------------------------------------------------
 151     ~ArchSpec ();
 152
 153     //------------------------------------------------------------------
 154     /// Assignment operator.
 155     ///
 156     /// @param[in] rhs another ArchSpec object to copy.
 157     ///
 158     /// @return A const reference to this object.
 159     //------------------------------------------------------------------
 160     const ArchSpec&
 161     operator= (const ArchSpec& rhs);
 162
 163     static size_t
 164     AutoComplete (const char *name,
 165                   StringList &matches);
 166
 167     //------------------------------------------------------------------
 168     /// Returns a static string representing the current architecture.
 169     ///
 170     /// @return A static string correcponding to the current
 171     ///         architecture.
 172     //------------------------------------------------------------------
 173     const char *
 174     GetArchitectureName () const;
 175
 176     //------------------------------------------------------------------
 177     /// Clears the object state.
 178     ///
 179     /// Clears the object state back to a default invalid state.
 180     //------------------------------------------------------------------
 181     void
 182     Clear ();
 183
 184     //------------------------------------------------------------------
 185     /// Returns the size in bytes of an address of the current
 186     /// architecture.
 187     ///
 188     /// @return The byte size of an address of the current architecture.
 189     //------------------------------------------------------------------
 190     uint32_t
 191     GetAddressByteSize () const;
 192
 193     //------------------------------------------------------------------
 194     /// Returns a machine family for the current architecture.
 195     ///
 196     /// @return An LLVM arch type.
 197     //------------------------------------------------------------------
 198     llvm::Triple::ArchType
 199     GetMachine () const;
 200
 201     //------------------------------------------------------------------
 202     /// Tests if this ArchSpec is valid.
 203     ///
 204     /// @return True if the current architecture is valid, false
 205     ///         otherwise.
 206     //------------------------------------------------------------------
 207     bool
 208     IsValid () const
 209     {
 210         return m_core >= eCore_arm_generic && m_core < kNumCores;
 211     }
 212
 213     bool
 214     TripleVendorWasSpecified() const
 215     {
 216         return !m_triple.getVendorName().empty();
 217     }
 218
 219     bool
 220     TripleOSWasSpecified() const
 221     {
 222         return !m_triple.getOSName().empty();
 223     }
 224
 225     //------------------------------------------------------------------
 226     /// Sets this ArchSpec according to the given architecture name.
 227     ///
 228     /// The architecture name can be one of the generic system default
 229     /// values:
 230     ///
 231     /// @li \c LLDB_ARCH_DEFAULT - The arch the current system defaults
 232     ///        to when a program is launched without any extra
 233     ///        attributes or settings.
 234     /// @li \c LLDB_ARCH_DEFAULT_32BIT - The default host architecture
 235     ///        for 32 bit (if any).
 236     /// @li \c LLDB_ARCH_DEFAULT_64BIT - The default host architecture
 237     ///        for 64 bit (if any).
 238     ///
 239     /// Alternatively, if the object type of this ArchSpec has been
 240     /// configured,  a concrete architecture can be specified to set
 241     /// the CPU type ("x86_64" for example).
 242     ///
 243     /// Finally, an encoded object and archetecture format is accepted.
 244     /// The format contains an object type (like "macho" or "elf"),
 245     /// followed by a platform dependent encoding of CPU type and
 246     /// subtype.  For example:
 247     ///
 248     ///     "macho"        : Specifies an object type of MachO.
 249     ///     "macho-16-6"   : MachO specific encoding for ARMv6.
 250     ///     "elf-43        : ELF specific encoding for Sparc V9.
 251     ///
 252     /// @param[in] arch_name The name of an architecture.
 253     ///
 254     /// @return True if @p arch_name was successfully translated, false
 255     ///         otherwise.
 256     //------------------------------------------------------------------
 257 //    bool
 258 //    SetArchitecture (const llvm::StringRef& arch_name);
 259 //
 260 //    bool
 261 //    SetArchitecture (const char *arch_name);
 262
 263     //------------------------------------------------------------------
 264     /// Change the architecture object type and CPU type.
 265     ///
 266     /// @param[in] arch_type The object type of this ArchSpec.
 267     ///
 268     /// @param[in] cpu The required CPU type.
 269     ///
 270     /// @return True if the object and CPU type were sucessfully set.
 271     //------------------------------------------------------------------
 272     bool
 273     SetArchitecture (ArchitectureType arch_type,
 274                      uint32_t cpu,
 275                      uint32_t sub);
 276
 277     //------------------------------------------------------------------
 278     /// Returns the byte order for the architecture specification.
 279     ///
 280     /// @return The endian enumeration for the current endianness of
 281     ///     the architecture specification
 282     //------------------------------------------------------------------
 283     lldb::ByteOrder
 284     GetByteOrder () const;
 285
 286     //------------------------------------------------------------------
 287     /// Sets this ArchSpec's byte order.
 288     ///
 289     /// In the common case there is no need to call this method as the
 290     /// byte order can almost always be determined by the architecture.
 291     /// However, many CPU's are bi-endian (ARM, Alpha, PowerPC, etc)
 292     /// and the default/assumed byte order may be incorrect.
 293     //------------------------------------------------------------------
 294     void
 295     SetByteOrder (lldb::ByteOrder byte_order)
 296     {
 297         m_byte_order = byte_order;
 298     }
 299
 300     uint32_t
 301     GetMinimumOpcodeByteSize() const;
 302
 303     uint32_t
 304     GetMaximumOpcodeByteSize() const;
 305
 306     Core
 307     GetCore () const
 308     {
 309         return m_core;
 310     }
 311
 312     uint32_t
 313     GetMachOCPUType () const;
 314
 315     uint32_t
 316     GetMachOCPUSubType () const;
 317
 318     //------------------------------------------------------------------
 319     /// Architecture tripple accessor.
 320     ///
 321     /// @return A triple describing this ArchSpec.
 322     //------------------------------------------------------------------
 323     llvm::Triple &
 324     GetTriple ()
 325     {
 326         return m_triple;
 327     }
 328
 329     //------------------------------------------------------------------
 330     /// Architecture tripple accessor.
 331     ///
 332     /// @return A triple describing this ArchSpec.
 333     //------------------------------------------------------------------
 334     const llvm::Triple &
 335     GetTriple () const
 336     {
 337         return m_triple;
 338     }
 339
 340     //------------------------------------------------------------------
 341     /// Architecture tripple setter.
 342     ///
 343     /// Configures this ArchSpec according to the given triple.  If the
 344     /// triple has unknown components in all of the vendor, OS, and
 345     /// the optional environment field (i.e. "i386-unknown-unknown")
 346     /// then default values are taken from the host.  Architecture and
 347     /// environment components are used to further resolve the CPU type
 348     /// and subtype, endian characteristics, etc.
 349     ///
 350     /// @return A triple describing this ArchSpec.
 351     //------------------------------------------------------------------
 352     bool
 353     SetTriple (const llvm::Triple &triple);
 354
 355     bool
 356     SetTriple (const char *triple_cstr);
 357
 358     bool
 359     SetTriple (const char *triple_cstr,
 360                Platform *platform);
 361
 362     //------------------------------------------------------------------
 363     /// Returns the default endianness of the architecture.
 364     ///
 365     /// @return The endian enumeration for the default endianness of
 366     ///         the architecture.
 367     //------------------------------------------------------------------
 368     lldb::ByteOrder
 369     GetDefaultEndian () const;
 370
 371     //------------------------------------------------------------------
 372     /// Compare an ArchSpec to another ArchSpec, requiring an exact cpu
 373     /// type match between them.
 374     /// e.g. armv7s is not an exact match with armv7 - this would return false
 375     ///
 376     /// @return true if the two ArchSpecs match.
 377     //------------------------------------------------------------------
 378     bool
 379     IsExactMatch (const ArchSpec& rhs) const;
 380
 381     //------------------------------------------------------------------
 382     /// Compare an ArchSpec to another ArchSpec, requiring a compatible
 383     /// cpu type match between them.
 384     /// e.g. armv7s is compatible with armv7 - this method would return true
 385     ///
 386     /// @return true if the two ArchSpecs are compatible
 387     //------------------------------------------------------------------
 388     bool
 389     IsCompatibleMatch (const ArchSpec& rhs) const;
 390
 391 protected:
 392     bool
 393     IsEqualTo (const ArchSpec& rhs, bool exact_match) const;
 394
 395     llvm::Triple m_triple;
 396     Core m_core;
 397     lldb::ByteOrder m_byte_order;
 398
 399     // Called when m_def or m_entry are changed.  Fills in all remaining
 400     // members with default values.
 401     void
 402     CoreUpdated (bool update_triple);
 403 };
 404
 405 //------------------------------------------------------------------
 406 /// @fn bool operator< (const ArchSpec& lhs, const ArchSpec& rhs)
 407 /// @brief Less than operator.
 408 ///
 409 /// Tests two ArchSpec objects to see if \a lhs is less than \a
 410 /// rhs.
 411 ///
 412 /// @param[in] lhs The Left Hand Side ArchSpec object to compare.
 413 /// @param[in] rhs The Left Hand Side ArchSpec object to compare.
 414 ///
 415 /// @return true if \a lhs is less than \a rhs
 416 //------------------------------------------------------------------
 417 bool operator< (const ArchSpec& lhs, const ArchSpec& rhs);
 418
 419 } // namespace lldb_private
 420
 421 #endif  // #if defined(__cplusplus)
 422 #endif  // #ifndef liblldb_ArchSpec_h_