Mangled.h revision c02400422d5e644a2a486bce5517d46d435a3f02
1//===-- Mangled.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_Mangled_h_ 11#define liblldb_Mangled_h_ 12#if defined(__cplusplus) 13 14 15#include "lldb/lldb-private.h" 16#include "lldb/Core/ConstString.h" 17#include <vector> 18 19namespace lldb_private { 20 21//---------------------------------------------------------------------- 22/// @class Mangled Mangled.h "lldb/Core/Mangled.h" 23/// @brief A class that handles mangled names. 24/// 25/// Designed to handle mangled names. The demangled version of any names 26/// will be computed when the demangled name is accessed through the 27/// Demangled() acccessor. This class can also tokenize the demangled 28/// version of the name for powerful searches. Functions and symbols 29/// could make instances of this class for their mangled names. Uniqued 30/// string pools are used for the mangled, demangled, and token string 31/// values to allow for faster comparisons and for efficient memory use. 32//---------------------------------------------------------------------- 33class Mangled 34{ 35public: 36 37 enum NamePreference 38 { 39 ePreferMangled, 40 ePreferDemangled 41 }; 42 43 //---------------------------------------------------------------------- 44 /// Default constructor. 45 /// 46 /// Initialize with both mangled and demangled names empty. 47 //---------------------------------------------------------------------- 48 Mangled (); 49 50 //---------------------------------------------------------------------- 51 /// Construct with name. 52 /// 53 /// Constructor with an optional string and a boolean indicating if it is 54 /// the mangled version. 55 /// 56 /// @param[in] name 57 /// The already const name to copy into this object. 58 /// 59 /// @param[in] is_mangled 60 /// If \b true then \a name is a mangled name, if \b false then 61 /// \a name is demangled. 62 //---------------------------------------------------------------------- 63 explicit 64 Mangled (const ConstString &name, bool is_mangled); 65 66 //---------------------------------------------------------------------- 67 /// Construct with name. 68 /// 69 /// Constructor with an optional string and auto-detect if \a name is 70 /// mangled or not. 71 /// 72 /// @param[in] name 73 /// The already const name to copy into this object. 74 //---------------------------------------------------------------------- 75 explicit 76 Mangled (const ConstString &name); 77 78 //---------------------------------------------------------------------- 79 /// Destructor 80 /// 81 /// Releases its ref counts on the mangled and demangled strings that 82 /// live in the global string pool. 83 //---------------------------------------------------------------------- 84 ~Mangled (); 85 86 //---------------------------------------------------------------------- 87 /// Convert to pointer operator. 88 /// 89 /// This allows code to check a Mangled object to see if it contains 90 /// a valid mangled name using code such as: 91 /// 92 /// @code 93 /// Mangled mangled(...); 94 /// if (mangled) 95 /// { ... 96 /// @endcode 97 /// 98 /// @return 99 /// A pointer to this object if either the mangled or unmangled 100 /// name is set, NULL otherwise. 101 //---------------------------------------------------------------------- 102 operator 103 void*() const; 104 105 //---------------------------------------------------------------------- 106 /// Logical NOT operator. 107 /// 108 /// This allows code to check a Mangled object to see if it contains 109 /// an empty mangled name using code such as: 110 /// 111 /// @code 112 /// Mangled mangled(...); 113 /// if (!mangled) 114 /// { ... 115 /// @endcode 116 /// 117 /// @return 118 /// Returns \b true if the object has an empty mangled and 119 /// unmangled name, \b false otherwise. 120 //---------------------------------------------------------------------- 121 bool 122 operator!() const; 123 124 //---------------------------------------------------------------------- 125 /// Clear the mangled and demangled values. 126 //---------------------------------------------------------------------- 127 void 128 Clear (); 129 130 //---------------------------------------------------------------------- 131 /// Compare the mangled string values 132 /// 133 /// Compares the Mangled::GetName() string in \a lhs and \a rhs. 134 /// 135 /// @param[in] lhs 136 /// A const reference to the Left Hand Side object to compare. 137 /// 138 /// @param[in] rhs 139 /// A const reference to the Right Hand Side object to compare. 140 /// 141 /// @return 142 /// @li -1 if \a lhs is less than \a rhs 143 /// @li 0 if \a lhs is equal to \a rhs 144 /// @li 1 if \a lhs is greater than \a rhs 145 //---------------------------------------------------------------------- 146 static int 147 Compare (const Mangled& lhs, const Mangled& rhs); 148 149 //---------------------------------------------------------------------- 150 /// Dump a description of this object to a Stream \a s. 151 /// 152 /// Dump a Mangled object to stream \a s. We don't force our 153 /// demangled name to be computed currently (we don't use the accessor). 154 /// 155 /// @param[in] s 156 /// The stream to which to dump the object descripton. 157 //---------------------------------------------------------------------- 158 void 159 Dump (Stream *s) const; 160 161 //---------------------------------------------------------------------- 162 /// Dump a debug description of this object to a Stream \a s. 163 /// 164 /// @param[in] s 165 /// The stream to which to dump the object descripton. 166 //---------------------------------------------------------------------- 167 void 168 DumpDebug (Stream *s) const; 169 170 //---------------------------------------------------------------------- 171 /// Demangled name get accessor. 172 /// 173 /// @return 174 /// A const reference to the demangled name string object. 175 //---------------------------------------------------------------------- 176 const ConstString& 177 GetDemangledName () const; 178 179 void 180 SetDemangledName (const ConstString &name) 181 { 182 m_demangled = name; 183 } 184 185 void 186 SetMangledName (const ConstString &name) 187 { 188 m_mangled = name; 189 } 190 191 //---------------------------------------------------------------------- 192 /// Mangled name get accessor. 193 /// 194 /// @return 195 /// A reference to the mangled name string object. 196 //---------------------------------------------------------------------- 197 ConstString& 198 GetMangledName () 199 { 200 return m_mangled; 201 } 202 203 //---------------------------------------------------------------------- 204 /// Mangled name get accessor. 205 /// 206 /// @return 207 /// A const reference to the mangled name string object. 208 //---------------------------------------------------------------------- 209 const ConstString& 210 GetMangledName () const 211 { 212 return m_mangled; 213 } 214 215 //---------------------------------------------------------------------- 216 /// Best name get accessor. 217 /// 218 /// @param[in] preference 219 /// Which name would you prefer to get? 220 /// 221 /// @return 222 /// A const reference to the the preferred name string object if this 223 /// object has a valid name of that kind, else a const reference to the 224 /// other name is returned. 225 //---------------------------------------------------------------------- 226 const ConstString& 227 GetName (NamePreference preference = ePreferDemangled) const; 228 229 //---------------------------------------------------------------------- 230 /// Check if "name" matches either the mangled or demangled name. 231 /// 232 /// @param[in] name 233 /// A name to match against both strings. 234 /// 235 /// @return 236 /// \b True if \a name matches either name, \b false otherwise. 237 //---------------------------------------------------------------------- 238 bool 239 NameMatches (const ConstString &name) const 240 { 241 if (m_mangled == name) 242 return true; 243 return GetDemangledName () == name; 244 } 245 246 bool 247 NameMatches (const RegularExpression& regex) const; 248 249 //---------------------------------------------------------------------- 250 /// Get the memory cost of this object. 251 /// 252 /// Return the size in bytes that this object takes in memory. This 253 /// returns the size in bytes of this object, not any shared string 254 /// values it may refer to. 255 /// 256 /// @return 257 /// The number of bytes that this object occupies in memory. 258 /// 259 /// @see ConstString::StaticMemorySize () 260 //---------------------------------------------------------------------- 261 size_t 262 MemorySize () const; 263 264 //---------------------------------------------------------------------- 265 /// Set the string value in this object. 266 /// 267 /// If \a is_mangled is \b true, then the mangled named is set to \a 268 /// name, else the demangled name is set to \a name. 269 /// 270 /// @param[in] name 271 /// The already const version of the name for this object. 272 /// 273 /// @param[in] is_mangled 274 /// If \b true then \a name is a mangled name, if \b false then 275 /// \a name is demangled. 276 //---------------------------------------------------------------------- 277 void 278 SetValue (const ConstString &name, bool is_mangled); 279 280 //---------------------------------------------------------------------- 281 /// Set the string value in this object. 282 /// 283 /// This version auto detects if the string is mangled by inspecting the 284 /// string value and looking for common mangling prefixes. 285 /// 286 /// @param[in] name 287 /// The already const version of the name for this object. 288 //---------------------------------------------------------------------- 289 void 290 SetValue (const ConstString &name); 291 292private: 293 //---------------------------------------------------------------------- 294 /// Mangled member variables. 295 //---------------------------------------------------------------------- 296 ConstString m_mangled; ///< The mangled version of the name 297 mutable ConstString m_demangled; ///< Mutable so we can get it on demand with a const version of this object 298}; 299 300 301Stream& operator << (Stream& s, const Mangled& obj); 302 303} // namespace lldb_private 304 305#endif // #if defined(__cplusplus) 306#endif // liblldb_Mangled_h_ 307