Home | History | Annotate | Line # | Download | only in Demangle 
      1 //===--- Demangle.h ---------------------------------------------*- C++ -*-===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 
      9 #ifndef LLVM_DEMANGLE_DEMANGLE_H
     10 #define LLVM_DEMANGLE_DEMANGLE_H
     11 
     12 #include <cstddef>
     13 #include <string>
     14 
     15 namespace llvm {
     16 /// This is a llvm local version of __cxa_demangle. Other than the name and
     17 /// being in the llvm namespace it is identical.
     18 ///
     19 /// The mangled_name is demangled into buf and returned. If the buffer is not
     20 /// large enough, realloc is used to expand it.
     21 ///
     22 /// The *status will be set to a value from the following enumeration
     23 enum : int {
     24   demangle_unknown_error = -4,
     25   demangle_invalid_args = -3,
     26   demangle_invalid_mangled_name = -2,
     27   demangle_memory_alloc_failure = -1,
     28   demangle_success = 0,
     29 };
     30 
     31 char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
     32                       int *status);
     33 
     34 
     35 enum MSDemangleFlags {
     36   MSDF_None = 0,
     37   MSDF_DumpBackrefs = 1 << 0,
     38   MSDF_NoAccessSpecifier = 1 << 1,
     39   MSDF_NoCallingConvention = 1 << 2,
     40   MSDF_NoReturnType = 1 << 3,
     41   MSDF_NoMemberType = 1 << 4,
     42 };
     43 
     44 /// Demangles the Microsoft symbol pointed at by mangled_name and returns it.
     45 /// Returns a pointer to the start of a null-terminated demangled string on
     46 /// success, or nullptr on error.
     47 /// If n_read is non-null and demangling was successful, it receives how many
     48 /// bytes of the input string were consumed.
     49 /// buf can point to a *n_buf bytes large buffer where the demangled name is
     50 /// stored. If the buffer is too small, it is grown with realloc(). If buf is
     51 /// nullptr, then this malloc()s memory for the result.
     52 /// *n_buf stores the size of buf on input if buf is non-nullptr, and it
     53 /// receives the size of the demangled string on output if n_buf is not nullptr.
     54 /// status receives one of the demangle_ enum entries above if it's not nullptr.
     55 /// Flags controls various details of the demangled representation.
     56 char *microsoftDemangle(const char *mangled_name, size_t *n_read,
     57                         char *buf, size_t *n_buf,
     58                         int *status, MSDemangleFlags Flags = MSDF_None);
     59 
     60 // Demangles a Rust v0 mangled symbol. The API follows that of __cxa_demangle.
     61 char *rustDemangle(const char *MangledName, char *Buf, size_t *N, int *Status);
     62 
     63 /// Attempt to demangle a string using different demangling schemes.
     64 /// The function uses heuristics to determine which demangling scheme to use.
     65 /// \param MangledName - reference to string to demangle.
     66 /// \returns - the demangled string, or a copy of the input string if no
     67 /// demangling occurred.
     68 std::string demangle(const std::string &MangledName);
     69 
     70 /// "Partial" demangler. This supports demangling a string into an AST
     71 /// (typically an intermediate stage in itaniumDemangle) and querying certain
     72 /// properties or partially printing the demangled name.
     73 struct ItaniumPartialDemangler {
     74   ItaniumPartialDemangler();
     75 
     76   ItaniumPartialDemangler(ItaniumPartialDemangler &&Other);
     77   ItaniumPartialDemangler &operator=(ItaniumPartialDemangler &&Other);
     78 
     79   /// Demangle into an AST. Subsequent calls to the rest of the member functions
     80   /// implicitly operate on the AST this produces.
     81   /// \return true on error, false otherwise
     82   bool partialDemangle(const char *MangledName);
     83 
     84   /// Just print the entire mangled name into Buf. Buf and N behave like the
     85   /// second and third parameters to itaniumDemangle.
     86   char *finishDemangle(char *Buf, size_t *N) const;
     87 
     88   /// Get the base name of a function. This doesn't include trailing template
     89   /// arguments, ie for "a::b<int>" this function returns "b".
     90   char *getFunctionBaseName(char *Buf, size_t *N) const;
     91 
     92   /// Get the context name for a function. For "a::b::c", this function returns
     93   /// "a::b".
     94   char *getFunctionDeclContextName(char *Buf, size_t *N) const;
     95 
     96   /// Get the entire name of this function.
     97   char *getFunctionName(char *Buf, size_t *N) const;
     98 
     99   /// Get the parameters for this function.
    100   char *getFunctionParameters(char *Buf, size_t *N) const;
    101   char *getFunctionReturnType(char *Buf, size_t *N) const;
    102 
    103   /// If this function has any any cv or reference qualifiers. These imply that
    104   /// the function is a non-static member function.
    105   bool hasFunctionQualifiers() const;
    106 
    107   /// If this symbol describes a constructor or destructor.
    108   bool isCtorOrDtor() const;
    109 
    110   /// If this symbol describes a function.
    111   bool isFunction() const;
    112 
    113   /// If this symbol describes a variable.
    114   bool isData() const;
    115 
    116   /// If this symbol is a <special-name>. These are generally implicitly
    117   /// generated by the implementation, such as vtables and typeinfo names.
    118   bool isSpecialName() const;
    119 
    120   ~ItaniumPartialDemangler();
    121 private:
    122   void *RootNode;
    123   void *Context;
    124 };
    125 } // namespace llvm
    126 
    127 #endif
    128