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-forward.h"
  16 #include "lldb/Core/ConstString.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 MIPSSubType
  36     {
  37         eMIPSSubType_unknown,
  38         eMIPSSubType_mips32,
  39         eMIPSSubType_mips32r2,
  40         eMIPSSubType_mips32r6,
  41         eMIPSSubType_mips32el,
  42         eMIPSSubType_mips32r2el,
  43         eMIPSSubType_mips32r6el,
  44         eMIPSSubType_mips64,
  45         eMIPSSubType_mips64r2,
  46         eMIPSSubType_mips64r6,
  47         eMIPSSubType_mips64el,
  48         eMIPSSubType_mips64r2el,
  49         eMIPSSubType_mips64r6el,
  50     };
  51
  52     // Masks for the ases word of an ABI flags structure.
  53     enum MIPSASE
  54     {
  55         eMIPSAse_dsp        = 0x00000001,   // DSP ASE
  56         eMIPSAse_dspr2      = 0x00000002,   // DSP R2 ASE
  57         eMIPSAse_eva        = 0x00000004,   // Enhanced VA Scheme
  58         eMIPSAse_mcu        = 0x00000008,   // MCU (MicroController) ASE
  59         eMIPSAse_mdmx       = 0x00000010,   // MDMX ASE
  60         eMIPSAse_mips3d     = 0x00000020,   // MIPS-3D ASE
  61         eMIPSAse_mt         = 0x00000040,   // MT ASE
  62         eMIPSAse_smartmips  = 0x00000080,   // SmartMIPS ASE
  63         eMIPSAse_virt       = 0x00000100,   // VZ ASE
  64         eMIPSAse_msa        = 0x00000200,   // MSA ASE
  65         eMIPSAse_mips16     = 0x00000400,   // MIPS16 ASE
  66         eMIPSAse_micromips  = 0x00000800,   // MICROMIPS ASE
  67         eMIPSAse_xpa        = 0x00001000,   // XPA ASE
  68         eMIPSAse_mask       = 0x00001fff,
  69         eMIPSABI_O32        = 0x00002000,
  70         eMIPSABI_N32        = 0x00004000,
  71         eMIPSABI_N64        = 0x00008000,
  72         eMIPSABI_O64        = 0x00020000,
  73         eMIPSABI_EABI32     = 0x00040000,
  74         eMIPSABI_EABI64     = 0x00080000,
  75         eMIPSABI_mask       = 0x000ff000
  76     };
  77
  78     // MIPS Floating point ABI Values
  79     enum MIPS_ABI_FP
  80     {
  81         eMIPS_ABI_FP_ANY     = 0x00000000,
  82         eMIPS_ABI_FP_DOUBLE  = 0x00100000,  // hard float / -mdouble-float
  83         eMIPS_ABI_FP_SINGLE  = 0x00200000,  // hard float / -msingle-float
  84         eMIPS_ABI_FP_SOFT    = 0x00300000,  // soft float
  85         eMIPS_ABI_FP_OLD_64  = 0x00400000,  // -mips32r2 -mfp64
  86         eMIPS_ABI_FP_XX      = 0x00500000,  // -mfpxx
  87         eMIPS_ABI_FP_64      = 0x00600000,  // -mips32r2 -mfp64
  88         eMIPS_ABI_FP_64A     = 0x00700000,  // -mips32r2 -mfp64 -mno-odd-spreg
  89         eMIPS_ABI_FP_mask    = 0x00700000
  90     };
  91
  92     // ARM specific e_flags
  93     enum ARMeflags
  94     {
  95         eARM_abi_soft_float = 0x00000200,
  96         eARM_abi_hard_float = 0x00000400
  97     };
  98
  99     enum Core
 100     {
 101         eCore_arm_generic,
 102         eCore_arm_armv4,
 103         eCore_arm_armv4t,
 104         eCore_arm_armv5,
 105         eCore_arm_armv5e,
 106         eCore_arm_armv5t,
 107         eCore_arm_armv6,
 108         eCore_arm_armv6m,
 109         eCore_arm_armv7,
 110         eCore_arm_armv7f,
 111         eCore_arm_armv7s,
 112         eCore_arm_armv7k,
 113         eCore_arm_armv7m,
 114         eCore_arm_armv7em,
 115         eCore_arm_xscale,
 116
 117         eCore_thumb,
 118         eCore_thumbv4t,
 119         eCore_thumbv5,
 120         eCore_thumbv5e,
 121         eCore_thumbv6,
 122         eCore_thumbv6m,
 123         eCore_thumbv7,
 124         eCore_thumbv7s,
 125         eCore_thumbv7k,
 126         eCore_thumbv7f,
 127         eCore_thumbv7m,
 128         eCore_thumbv7em,
 129         eCore_arm_arm64,
 130         eCore_arm_armv8,
 131         eCore_arm_aarch64,
 132
 133         eCore_mips32,
 134         eCore_mips32r2,
 135         eCore_mips32r3,
 136         eCore_mips32r5,
 137         eCore_mips32r6,
 138         eCore_mips32el,
 139         eCore_mips32r2el,
 140         eCore_mips32r3el,
 141         eCore_mips32r5el,
 142         eCore_mips32r6el,
 143         eCore_mips64,
 144         eCore_mips64r2,
 145         eCore_mips64r3,
 146         eCore_mips64r5,
 147         eCore_mips64r6,
 148         eCore_mips64el,
 149         eCore_mips64r2el,
 150         eCore_mips64r3el,
 151         eCore_mips64r5el,
 152         eCore_mips64r6el,
 153
 154         eCore_ppc_generic,
 155         eCore_ppc_ppc601,
 156         eCore_ppc_ppc602,
 157         eCore_ppc_ppc603,
 158         eCore_ppc_ppc603e,
 159         eCore_ppc_ppc603ev,
 160         eCore_ppc_ppc604,
 161         eCore_ppc_ppc604e,
 162         eCore_ppc_ppc620,
 163         eCore_ppc_ppc750,
 164         eCore_ppc_ppc7400,
 165         eCore_ppc_ppc7450,
 166         eCore_ppc_ppc970,
 167
 168         eCore_ppc64_generic,
 169         eCore_ppc64_ppc970_64,
 170
 171         eCore_s390x_generic,
 172
 173         eCore_sparc_generic,
 174
 175         eCore_sparc9_generic,
 176
 177         eCore_x86_32_i386,
 178         eCore_x86_32_i486,
 179         eCore_x86_32_i486sx,
 180         eCore_x86_32_i686,
 181
 182         eCore_x86_64_x86_64,
 183         eCore_x86_64_x86_64h, // Haswell enabled x86_64
 184         eCore_hexagon_generic,
 185         eCore_hexagon_hexagonv4,
 186         eCore_hexagon_hexagonv5,
 187
 188         eCore_uknownMach32,
 189         eCore_uknownMach64,
 190
 191         eCore_kalimba3,
 192         eCore_kalimba4,
 193         eCore_kalimba5,
 194
 195         kNumCores,
 196
 197         kCore_invalid,
 198         // The following constants are used for wildcard matching only
 199         kCore_any,
 200         kCore_arm_any,
 201         kCore_ppc_any,
 202         kCore_ppc64_any,
 203         kCore_x86_32_any,
 204         kCore_x86_64_any,
 205         kCore_hexagon_any,
 206
 207         kCore_arm_first     = eCore_arm_generic,
 208         kCore_arm_last      = eCore_arm_xscale,
 209
 210         kCore_thumb_first   = eCore_thumb,
 211         kCore_thumb_last    = eCore_thumbv7em,
 212
 213         kCore_ppc_first     = eCore_ppc_generic,
 214         kCore_ppc_last      = eCore_ppc_ppc970,
 215
 216         kCore_ppc64_first   = eCore_ppc64_generic,
 217         kCore_ppc64_last    = eCore_ppc64_ppc970_64,
 218
 219         kCore_x86_32_first  = eCore_x86_32_i386,
 220         kCore_x86_32_last   = eCore_x86_32_i686,
 221
 222         kCore_x86_64_first  = eCore_x86_64_x86_64,
 223         kCore_x86_64_last   = eCore_x86_64_x86_64h,
 224
 225         kCore_hexagon_first  = eCore_hexagon_generic,
 226         kCore_hexagon_last   = eCore_hexagon_hexagonv5,
 227
 228         kCore_kalimba_first = eCore_kalimba3,
 229         kCore_kalimba_last = eCore_kalimba5,
 230
 231         kCore_mips32_first  = eCore_mips32,
 232         kCore_mips32_last   = eCore_mips32r6,
 233
 234         kCore_mips32el_first  = eCore_mips32el,
 235         kCore_mips32el_last   = eCore_mips32r6el,
 236
 237         kCore_mips64_first  = eCore_mips64,
 238         kCore_mips64_last   = eCore_mips64r6,
 239
 240         kCore_mips64el_first  = eCore_mips64el,
 241         kCore_mips64el_last   = eCore_mips64r6el,
 242
 243         kCore_mips_first  = eCore_mips32,
 244         kCore_mips_last   = eCore_mips64r6el
 245
 246     };
 247
 248     typedef void (* StopInfoOverrideCallbackType)(lldb_private::Thread &thread);
 249
 250     //------------------------------------------------------------------
 251     /// Default constructor.
 252     ///
 253     /// Default constructor that initializes the object with invalid
 254     /// cpu type and subtype values.
 255     //------------------------------------------------------------------
 256     ArchSpec ();
 257
 258     //------------------------------------------------------------------
 259     /// Constructor over triple.
 260     ///
 261     /// Constructs an ArchSpec with properties consistent with the given
 262     /// Triple.
 263     //------------------------------------------------------------------
 264     explicit
 265     ArchSpec (const llvm::Triple &triple);
 266     explicit
 267     ArchSpec (const char *triple_cstr);
 268     explicit
 269     ArchSpec (const char *triple_cstr, Platform *platform);
 270     //------------------------------------------------------------------
 271     /// Constructor over architecture name.
 272     ///
 273     /// Constructs an ArchSpec with properties consistent with the given
 274     /// object type and architecture name.
 275     //------------------------------------------------------------------
 276     explicit
 277     ArchSpec (ArchitectureType arch_type,
 278               uint32_t cpu_type,
 279               uint32_t cpu_subtype);
 280
 281     //------------------------------------------------------------------
 282     /// Destructor.
 283     //------------------------------------------------------------------
 284     ~ArchSpec ();
 285
 286     //------------------------------------------------------------------
 287     /// Assignment operator.
 288     ///
 289     /// @param[in] rhs another ArchSpec object to copy.
 290     ///
 291     /// @return A const reference to this object.
 292     //------------------------------------------------------------------
 293     const ArchSpec&
 294     operator= (const ArchSpec& rhs);
 295
 296     static size_t
 297     AutoComplete (const char *name,
 298                   StringList &matches);
 299
 300     //------------------------------------------------------------------
 301     /// Returns a static string representing the current architecture.
 302     ///
 303     /// @return A static string correcponding to the current
 304     ///         architecture.
 305     //------------------------------------------------------------------
 306     const char *
 307     GetArchitectureName () const;
 308
 309     //-----------------------------------------------------------------
 310     /// if MIPS architecture return true.
 311     ///
 312     ///  @return a boolean value.
 313     //-----------------------------------------------------------------
 314     bool
 315     IsMIPS() const;
 316
 317     //------------------------------------------------------------------
 318     /// Returns a string representing current architecture as a target CPU
 319     /// for tools like compiler, disassembler etc.
 320     ///
 321     /// @return A string representing target CPU for the current
 322     ///         architecture.
 323     //------------------------------------------------------------------
 324     std::string
 325     GetClangTargetCPU ();
 326
 327     //------------------------------------------------------------------
 328     /// Clears the object state.
 329     ///
 330     /// Clears the object state back to a default invalid state.
 331     //------------------------------------------------------------------
 332     void
 333     Clear ();
 334
 335     //------------------------------------------------------------------
 336     /// Returns the size in bytes of an address of the current
 337     /// architecture.
 338     ///
 339     /// @return The byte size of an address of the current architecture.
 340     //------------------------------------------------------------------
 341     uint32_t
 342     GetAddressByteSize () const;
 343
 344     //------------------------------------------------------------------
 345     /// Returns a machine family for the current architecture.
 346     ///
 347     /// @return An LLVM arch type.
 348     //------------------------------------------------------------------
 349     llvm::Triple::ArchType
 350     GetMachine () const;
 351
 352     //------------------------------------------------------------------
 353     /// Returns the distribution id of the architecture.
 354     ///
 355     /// This will be something like "ubuntu", "fedora", etc. on Linux.
 356     ///
 357     /// @return A ConstString ref containing the distribution id,
 358     ///         potentially empty.
 359     //------------------------------------------------------------------
 360     const ConstString&
 361     GetDistributionId () const;
 362
 363     //------------------------------------------------------------------
 364     /// Set the distribution id of the architecture.
 365     ///
 366     /// This will be something like "ubuntu", "fedora", etc. on Linux.
 367     /// This should be the same value returned by
 368     /// HostInfo::GetDistributionId ().
 369     ///------------------------------------------------------------------
 370     void
 371     SetDistributionId (const char* distribution_id);
 372
 373     //------------------------------------------------------------------
 374     /// Tests if this ArchSpec is valid.
 375     ///
 376     /// @return True if the current architecture is valid, false
 377     ///         otherwise.
 378     //------------------------------------------------------------------
 379     bool
 380     IsValid () const
 381     {
 382         return m_core >= eCore_arm_generic && m_core < kNumCores;
 383     }
 384
 385     bool
 386     TripleVendorWasSpecified() const
 387     {
 388         return !m_triple.getVendorName().empty();
 389     }
 390
 391     bool
 392     TripleVendorIsUnspecifiedUnknown() const
 393     {
 394         return m_triple.getVendor() == llvm::Triple::UnknownVendor && m_triple.getVendorName().empty();
 395     }
 396
 397     bool
 398     TripleOSWasSpecified() const
 399     {
 400         return !m_triple.getOSName().empty();
 401     }
 402
 403     bool
 404     TripleEnvironmentWasSpecified () const
 405     {
 406         return !m_triple.getEnvironmentName().empty();
 407     }
 408
 409     bool
 410     TripleOSIsUnspecifiedUnknown() const
 411     {
 412         return m_triple.getOS() == llvm::Triple::UnknownOS && m_triple.getOSName().empty();
 413     }
 414
 415     //------------------------------------------------------------------
 416     /// Merges fields from another ArchSpec into this ArchSpec.
 417     ///
 418     /// This will use the supplied ArchSpec to fill in any fields of
 419     /// the triple in this ArchSpec which were unspecified.  This can
 420     /// be used to refine a generic ArchSpec with a more specific one.
 421     /// For example, if this ArchSpec's triple is something like
 422     /// i386-unknown-unknown-unknown, and we have a triple which is
 423     /// x64-pc-windows-msvc, then merging that triple into this one
 424     /// will result in the triple i386-pc-windows-msvc.
 425     ///
 426     //------------------------------------------------------------------
 427     void
 428     MergeFrom(const ArchSpec &other);
 429
 430     //------------------------------------------------------------------
 431     /// Change the architecture object type, CPU type and OS type.
 432     ///
 433     /// @param[in] arch_type The object type of this ArchSpec.
 434     ///
 435     /// @param[in] cpu The required CPU type.
 436     ///
 437     /// @param[in] os The optional OS type
 438     /// The default value of 0 was choosen to from the ELF spec value
 439     /// ELFOSABI_NONE.  ELF is the only one using this parameter.  If another
 440     /// format uses this parameter and 0 does not work, use a value over
 441     /// 255 because in the ELF header this is value is only a byte.
 442     ///
 443     /// @return True if the object, and CPU were successfully set.
 444     ///
 445     /// As a side effect, the vendor value is usually set to unknown.
 446     /// The exections are
 447     ///   aarch64-apple-ios
 448     ///   arm-apple-ios
 449     ///   thumb-apple-ios
 450     ///   x86-apple-
 451     ///   x86_64-apple-
 452     ///
 453     /// As a side effect, the os value is usually set to unknown
 454     /// The exceptions are
 455     ///   *-*-aix
 456     ///   aarch64-apple-ios
 457     ///   arm-apple-ios
 458     ///   thumb-apple-ios
 459     ///   powerpc-apple-darwin
 460     ///   *-*-freebsd
 461     ///   *-*-linux
 462     ///   *-*-netbsd
 463     ///   *-*-openbsd
 464     ///   *-*-solaris
 465     //------------------------------------------------------------------
 466     bool
 467     SetArchitecture (ArchitectureType arch_type,
 468                      uint32_t cpu,
 469                      uint32_t sub,
 470                      uint32_t os = 0);
 471
 472     //------------------------------------------------------------------
 473     /// Returns the byte order for the architecture specification.
 474     ///
 475     /// @return The endian enumeration for the current endianness of
 476     ///     the architecture specification
 477     //------------------------------------------------------------------
 478     lldb::ByteOrder
 479     GetByteOrder () const;
 480
 481     //------------------------------------------------------------------
 482     /// Sets this ArchSpec's byte order.
 483     ///
 484     /// In the common case there is no need to call this method as the
 485     /// byte order can almost always be determined by the architecture.
 486     /// However, many CPU's are bi-endian (ARM, Alpha, PowerPC, etc)
 487     /// and the default/assumed byte order may be incorrect.
 488     //------------------------------------------------------------------
 489     void
 490     SetByteOrder (lldb::ByteOrder byte_order)
 491     {
 492         m_byte_order = byte_order;
 493     }
 494
 495     uint32_t
 496     GetMinimumOpcodeByteSize() const;
 497
 498     uint32_t
 499     GetMaximumOpcodeByteSize() const;
 500
 501     Core
 502     GetCore () const
 503     {
 504         return m_core;
 505     }
 506
 507     uint32_t
 508     GetMachOCPUType () const;
 509
 510     uint32_t
 511     GetMachOCPUSubType () const;
 512
 513     //------------------------------------------------------------------
 514     /// Architecture data byte width accessor
 515     ///
 516     /// @return the size in 8-bit (host) bytes of a minimum addressable
 517     /// unit from the Architecture's data bus
 518     //------------------------------------------------------------------
 519     uint32_t
 520     GetDataByteSize() const;
 521
 522     //------------------------------------------------------------------
 523     /// Architecture code byte width accessor
 524     ///
 525     /// @return the size in 8-bit (host) bytes of a minimum addressable
 526     /// unit from the Architecture's code bus
 527     //------------------------------------------------------------------
 528     uint32_t
 529     GetCodeByteSize() const;
 530
 531     //------------------------------------------------------------------
 532     /// Architecture tripple accessor.
 533     ///
 534     /// @return A triple describing this ArchSpec.
 535     //------------------------------------------------------------------
 536     llvm::Triple &
 537     GetTriple ()
 538     {
 539         return m_triple;
 540     }
 541
 542     //------------------------------------------------------------------
 543     /// Architecture tripple accessor.
 544     ///
 545     /// @return A triple describing this ArchSpec.
 546     //------------------------------------------------------------------
 547     const llvm::Triple &
 548     GetTriple () const
 549     {
 550         return m_triple;
 551     }
 552
 553     void
 554     DumpTriple(Stream &s) const;
 555
 556     //------------------------------------------------------------------
 557     /// Architecture tripple setter.
 558     ///
 559     /// Configures this ArchSpec according to the given triple.  If the
 560     /// triple has unknown components in all of the vendor, OS, and
 561     /// the optional environment field (i.e. "i386-unknown-unknown")
 562     /// then default values are taken from the host.  Architecture and
 563     /// environment components are used to further resolve the CPU type
 564     /// and subtype, endian characteristics, etc.
 565     ///
 566     /// @return A triple describing this ArchSpec.
 567     //------------------------------------------------------------------
 568     bool
 569     SetTriple (const llvm::Triple &triple);
 570
 571     bool
 572     SetTriple (const char *triple_cstr);
 573
 574     bool
 575     SetTriple (const char *triple_cstr,
 576                Platform *platform);
 577
 578     //------------------------------------------------------------------
 579     /// Returns the default endianness of the architecture.
 580     ///
 581     /// @return The endian enumeration for the default endianness of
 582     ///         the architecture.
 583     //------------------------------------------------------------------
 584     lldb::ByteOrder
 585     GetDefaultEndian () const;
 586
 587     //------------------------------------------------------------------
 588     /// Returns true if 'char' is a signed type by defualt in the
 589     /// architecture false otherwise
 590     ///
 591     /// @return True if 'char' is a signed type by default on the
 592     ///         architecture and false otherwise.
 593     //------------------------------------------------------------------
 594     bool
 595     CharIsSignedByDefault () const;
 596
 597     //------------------------------------------------------------------
 598     /// Compare an ArchSpec to another ArchSpec, requiring an exact cpu
 599     /// type match between them.
 600     /// e.g. armv7s is not an exact match with armv7 - this would return false
 601     ///
 602     /// @return true if the two ArchSpecs match.
 603     //------------------------------------------------------------------
 604     bool
 605     IsExactMatch (const ArchSpec& rhs) const;
 606
 607     //------------------------------------------------------------------
 608     /// Compare an ArchSpec to another ArchSpec, requiring a compatible
 609     /// cpu type match between them.
 610     /// e.g. armv7s is compatible with armv7 - this method would return true
 611     ///
 612     /// @return true if the two ArchSpecs are compatible
 613     //------------------------------------------------------------------
 614     bool
 615     IsCompatibleMatch (const ArchSpec& rhs) const;
 616
 617     //------------------------------------------------------------------
 618     /// Get a stop info override callback for the current architecture.
 619     ///
 620     /// Most platform specific code should go in lldb_private::Platform,
 621     /// but there are cases where no matter which platform you are on
 622     /// certain things hold true.
 623     ///
 624     /// This callback is currently intended to handle cases where a
 625     /// program stops at an instruction that won't get executed and it
 626     /// allows the stop reasonm, like "breakpoint hit", to be replaced
 627     /// with a different stop reason like "no stop reason".
 628     ///
 629     /// This is specifically used for ARM in Thumb code when we stop in
 630     /// an IT instruction (if/then/else) where the instruction won't get
 631     /// executed and therefore it wouldn't be correct to show the program
 632     /// stopped at the current PC. The code is generic and applies to all
 633     /// ARM CPUs.
 634     ///
 635     /// @return NULL or a valid stop info override callback for the
 636     ///     current architecture.
 637     //------------------------------------------------------------------
 638     StopInfoOverrideCallbackType
 639     GetStopInfoOverrideCallback () const;
 640
 641     bool
 642     IsFullySpecifiedTriple () const;
 643
 644     void
 645     PiecewiseTripleCompare (const ArchSpec &other,
 646                             bool &arch_different,
 647                             bool &vendor_different,
 648                             bool &os_different,
 649                             bool &os_version_different,
 650                             bool &env_different);
 651
 652     //------------------------------------------------------------------
 653     /// Detect whether this architecture uses thumb code exclusively
 654     ///
 655     /// Some embedded ARM chips (e.g. the ARM Cortex M0-7 line) can
 656     /// only execute the Thumb instructions, never Arm.  We should normally
 657     /// pick up arm/thumbness from their the processor status bits (cpsr/xpsr)
 658     /// or hints on each function - but when doing bare-boards low level
 659     /// debugging (especially common with these embedded processors), we may
 660     /// not have those things easily accessible.
 661     ///
 662     /// @return true if this is an arm ArchSpec which can only execute Thumb
 663     ///         instructions
 664     //------------------------------------------------------------------
 665     bool
 666     IsAlwaysThumbInstructions () const;
 667
 668     uint32_t
 669     GetFlags () const
 670     {
 671         return m_flags;
 672     }
 673
 674     void
 675     SetFlags (uint32_t flags)
 676     {
 677         m_flags = flags;
 678     }
 679
 680 protected:
 681     bool
 682     IsEqualTo (const ArchSpec& rhs, bool exact_match) const;
 683
 684     llvm::Triple m_triple;
 685     Core m_core;
 686     lldb::ByteOrder m_byte_order;
 687
 688     // Additional arch flags which we cannot get from triple and core
 689     // For MIPS these are application specific extensions like
 690     // micromips, mips16 etc.
 691     uint32_t m_flags;
 692
 693     ConstString m_distribution_id;
 694
 695     // Called when m_def or m_entry are changed.  Fills in all remaining
 696     // members with default values.
 697     void
 698     CoreUpdated (bool update_triple);
 699 };
 700
 701 //------------------------------------------------------------------
 702 /// @fn bool operator< (const ArchSpec& lhs, const ArchSpec& rhs)
 703 /// @brief Less than operator.
 704 ///
 705 /// Tests two ArchSpec objects to see if \a lhs is less than \a
 706 /// rhs.
 707 ///
 708 /// @param[in] lhs The Left Hand Side ArchSpec object to compare.
 709 /// @param[in] rhs The Left Hand Side ArchSpec object to compare.
 710 ///
 711 /// @return true if \a lhs is less than \a rhs
 712 //------------------------------------------------------------------
 713 bool operator< (const ArchSpec& lhs, const ArchSpec& rhs);
 714
 715 } // namespace lldb_private
 716
 717 #endif  // #if defined(__cplusplus)
 718 #endif  // #ifndef liblldb_ArchSpec_h_