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
19namespace lldb_private {
20
21struct 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//----------------------------------------------------------------------
32class ArchSpec
33{
34public:
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
391protected:
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//------------------------------------------------------------------
417bool operator< (const ArchSpec& lhs, const ArchSpec& rhs);
418
419} // namespace lldb_private
420
421#endif  // #if defined(__cplusplus)
422#endif  // #ifndef liblldb_ArchSpec_h_
423