shims/libdemangle/cxa_demangle.cpp

   1 //===-------------------------- cxa_demangle.cpp --------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // FIXME: (possibly) incomplete list of features that clang mangles that this
  11 // file does not yet support:
  12 //   - C++ modules TS
  13
  14 #define _LIBCPP_NO_EXCEPTIONS
  15
  16 #include "__cxxabi_config.h"
  17
  18 #include "demangle/ItaniumDemangle.h"
  19
  20 #include <cassert>
  21 #include <cctype>
  22 #include <cstdio>
  23 #include <cstdlib>
  24 #include <cstring>
  25 #include <functional>
  26 #include <numeric>
  27 #include <utility>
  28 #include <vector>
  29
  30 using namespace itanium_demangle;
  31
  32 constexpr const char *itanium_demangle::FloatData<float>::spec;
  33 constexpr const char *itanium_demangle::FloatData<double>::spec;
  34 constexpr const char *itanium_demangle::FloatData<long double>::spec;
  35
  36 // <discriminator> := _ <non-negative number>      # when number < 10
  37 //                 := __ <non-negative number> _   # when number >= 10
  38 //  extension      := decimal-digit+               # at the end of string
  39 const char *itanium_demangle::parse_discriminator(const char *first,
  40                                                   const char *last) {
  41   // parse but ignore discriminator
  42   if (first != last) {
  43     if (*first == '_') {
  44       const char *t1 = first + 1;
  45       if (t1 != last) {
  46         if (std::isdigit(*t1))
  47           first = t1 + 1;
  48         else if (*t1 == '_') {
  49           for (++t1; t1 != last && std::isdigit(*t1); ++t1)
  50             ;
  51           if (t1 != last && *t1 == '_')
  52             first = t1 + 1;
  53         }
  54       }
  55     } else if (std::isdigit(*first)) {
  56       const char *t1 = first + 1;
  57       for (; t1 != last && std::isdigit(*t1); ++t1)
  58         ;
  59       if (t1 == last)
  60         first = last;
  61     }
  62   }
  63   return first;
  64 }
  65
  66 #ifndef NDEBUG
  67 namespace {
  68 struct DumpVisitor {
  69   unsigned Depth = 0;
  70   bool PendingNewline = false;
  71
  72   template<typename NodeT> static constexpr bool wantsNewline(const NodeT *) {
  73     return true;
  74   }
  75   static bool wantsNewline(NodeArray A) { return !A.empty(); }
  76   static constexpr bool wantsNewline(...) { return false; }
  77
  78   template<typename ...Ts> static bool anyWantNewline(Ts ...Vs) {
  79     for (bool B : {wantsNewline(Vs)...})
  80       if (B)
  81         return true;
  82     return false;
  83   }
  84
  85   void printStr(const char *S) { fprintf(stderr, "%s", S); }
  86   void print(StringView SV) {
  87     fprintf(stderr, "\"%.*s\"", (int)SV.size(), SV.begin());
  88   }
  89   void print(const Node *N) {
  90     if (N)
  91       N->visit(std::ref(*this));
  92     else
  93       printStr("<null>");
  94   }
  95   void print(NodeOrString NS) {
  96     if (NS.isNode())
  97       print(NS.asNode());
  98     else if (NS.isString())
  99       print(NS.asString());
 100     else
 101       printStr("NodeOrString()");
 102   }
 103   void print(NodeArray A) {
 104     ++Depth;
 105     printStr("{");
 106     bool First = true;
 107     for (const Node *N : A) {
 108       if (First)
 109         print(N);
 110       else
 111         printWithComma(N);
 112       First = false;
 113     }
 114     printStr("}");
 115     --Depth;
 116   }
 117
 118   // Overload used when T is exactly 'bool', not merely convertible to 'bool'.
 119   void print(bool B) { printStr(B ? "true" : "false"); }
 120
 121   template <class T>
 122   typename std::enable_if<std::is_unsigned<T>::value>::type print(T N) {
 123     fprintf(stderr, "%llu", (unsigned long long)N);
 124   }
 125
 126   template <class T>
 127   typename std::enable_if<std::is_signed<T>::value>::type print(T N) {
 128     fprintf(stderr, "%lld", (long long)N);
 129   }
 130
 131   void print(ReferenceKind RK) {
 132     switch (RK) {
 133     case ReferenceKind::LValue:
 134       return printStr("ReferenceKind::LValue");
 135     case ReferenceKind::RValue:
 136       return printStr("ReferenceKind::RValue");
 137     }
 138   }
 139   void print(FunctionRefQual RQ) {
 140     switch (RQ) {
 141     case FunctionRefQual::FrefQualNone:
 142       return printStr("FunctionRefQual::FrefQualNone");
 143     case FunctionRefQual::FrefQualLValue:
 144       return printStr("FunctionRefQual::FrefQualLValue");
 145     case FunctionRefQual::FrefQualRValue:
 146       return printStr("FunctionRefQual::FrefQualRValue");
 147     }
 148   }
 149   void print(Qualifiers Qs) {
 150     if (!Qs) return printStr("QualNone");
 151     struct QualName { Qualifiers Q; const char *Name; } Names[] = {
 152       {QualConst, "QualConst"},
 153       {QualVolatile, "QualVolatile"},
 154       {QualRestrict, "QualRestrict"},
 155     };
 156     for (QualName Name : Names) {
 157       if (Qs & Name.Q) {
 158         printStr(Name.Name);
 159         Qs = Qualifiers(Qs & ~Name.Q);
 160         if (Qs) printStr(" | ");
 161       }
 162     }
 163   }
 164   void print(SpecialSubKind SSK) {
 165     switch (SSK) {
 166     case SpecialSubKind::allocator:
 167       return printStr("SpecialSubKind::allocator");
 168     case SpecialSubKind::basic_string:
 169       return printStr("SpecialSubKind::basic_string");
 170     case SpecialSubKind::string:
 171       return printStr("SpecialSubKind::string");
 172     case SpecialSubKind::istream:
 173       return printStr("SpecialSubKind::istream");
 174     case SpecialSubKind::ostream:
 175       return printStr("SpecialSubKind::ostream");
 176     case SpecialSubKind::iostream:
 177       return printStr("SpecialSubKind::iostream");
 178     }
 179   }
 180
 181   void newLine() {
 182     printStr("\n");
 183     for (unsigned I = 0; I != Depth; ++I)
 184       printStr(" ");
 185     PendingNewline = false;
 186   }
 187
 188   template<typename T> void printWithPendingNewline(T V) {
 189     print(V);
 190     if (wantsNewline(V))
 191       PendingNewline = true;
 192   }
 193
 194   template<typename T> void printWithComma(T V) {
 195     if (PendingNewline || wantsNewline(V)) {
 196       printStr(",");
 197       newLine();
 198     } else {
 199       printStr(", ");
 200     }
 201
 202     printWithPendingNewline(V);
 203   }
 204
 205   struct CtorArgPrinter {
 206     DumpVisitor &Visitor;
 207
 208     template<typename T, typename ...Rest> void operator()(T V, Rest ...Vs) {
 209       if (Visitor.anyWantNewline(V, Vs...))
 210         Visitor.newLine();
 211       Visitor.printWithPendingNewline(V);
 212       int PrintInOrder[] = { (Visitor.printWithComma(Vs), 0)..., 0 };
 213       (void)PrintInOrder;
 214     }
 215   };
 216
 217   template<typename NodeT> void operator()(const NodeT *Node) {
 218     Depth += 2;
 219     fprintf(stderr, "%s(", itanium_demangle::NodeKind<NodeT>::name());
 220     Node->match(CtorArgPrinter{*this});
 221     fprintf(stderr, ")");
 222     Depth -= 2;
 223   }
 224
 225   void operator()(const ForwardTemplateReference *Node) {
 226     Depth += 2;
 227     fprintf(stderr, "ForwardTemplateReference(");
 228     if (Node->Ref && !Node->Printing) {
 229       Node->Printing = true;
 230       CtorArgPrinter{*this}(Node->Ref);
 231       Node->Printing = false;
 232     } else {
 233       CtorArgPrinter{*this}(Node->Index);
 234     }
 235     fprintf(stderr, ")");
 236     Depth -= 2;
 237   }
 238 };
 239 }
 240
 241 void itanium_demangle::Node::dump() const {
 242   DumpVisitor V;
 243   visit(std::ref(V));
 244   V.newLine();
 245 }
 246 #endif
 247
 248 namespace {
 249 class BumpPointerAllocator {
 250   struct BlockMeta {
 251     BlockMeta* Next;
 252     size_t Current;
 253   };
 254
 255   static constexpr size_t AllocSize = 4096;
 256   static constexpr size_t UsableAllocSize = AllocSize - sizeof(BlockMeta);
 257
 258   alignas(long double) char InitialBuffer[AllocSize];
 259   BlockMeta* BlockList = nullptr;
 260
 261   void grow() {
 262     char* NewMeta = static_cast<char *>(std::malloc(AllocSize));
 263     if (NewMeta == nullptr)
 264       std::terminate();
 265     BlockList = new (NewMeta) BlockMeta{BlockList, 0};
 266   }
 267
 268   void* allocateMassive(size_t NBytes) {
 269     NBytes += sizeof(BlockMeta);
 270     BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(std::malloc(NBytes));
 271     if (NewMeta == nullptr)
 272       std::terminate();
 273     BlockList->Next = new (NewMeta) BlockMeta{BlockList->Next, 0};
 274     return static_cast<void*>(NewMeta + 1);
 275   }
 276
 277 public:
 278   BumpPointerAllocator()
 279       : BlockList(new (InitialBuffer) BlockMeta{nullptr, 0}) {}
 280
 281   void* allocate(size_t N) {
 282     N = (N + 15u) & ~15u;
 283     if (N + BlockList->Current >= UsableAllocSize) {
 284       if (N > UsableAllocSize)
 285         return allocateMassive(N);
 286       grow();
 287     }
 288     BlockList->Current += N;
 289     return static_cast<void*>(reinterpret_cast<char*>(BlockList + 1) +
 290                               BlockList->Current - N);
 291   }
 292
 293   void reset() {
 294     while (BlockList) {
 295       BlockMeta* Tmp = BlockList;
 296       BlockList = BlockList->Next;
 297       if (reinterpret_cast<char*>(Tmp) != InitialBuffer)
 298         std::free(Tmp);
 299     }
 300     BlockList = new (InitialBuffer) BlockMeta{nullptr, 0};
 301   }
 302
 303   ~BumpPointerAllocator() { reset(); }
 304 };
 305
 306 class DefaultAllocator {
 307   BumpPointerAllocator Alloc;
 308
 309 public:
 310   void reset() { Alloc.reset(); }
 311
 312   template<typename T, typename ...Args> T *makeNode(Args &&...args) {
 313     return new (Alloc.allocate(sizeof(T)))
 314         T(std::forward<Args>(args)...);
 315   }
 316
 317   void *allocateNodeArray(size_t sz) {
 318     return Alloc.allocate(sizeof(Node *) * sz);
 319   }
 320 };
 321 }  // unnamed namespace
 322
 323 //===----------------------------------------------------------------------===//
 324 // Code beyond this point should not be synchronized with LLVM.
 325 //===----------------------------------------------------------------------===//
 326
 327 using Demangler = itanium_demangle::ManglingParser<DefaultAllocator>;
 328
 329 namespace {
 330 enum : int {
 331   demangle_invalid_args = -3,
 332   demangle_invalid_mangled_name = -2,
 333   demangle_memory_alloc_failure = -1,
 334   demangle_success = 0,
 335 };
 336 }
 337
 338 namespace __cxxabiv1 {
 339 extern "C" _LIBCXXABI_FUNC_VIS char *
 340 __cxa_demangle(const char *MangledName, char *Buf, size_t *N, int *Status) {
 341   if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
 342     if (Status)
 343       *Status = demangle_invalid_args;
 344     return nullptr;
 345   }
 346
 347   int InternalStatus = demangle_success;
 348   Demangler Parser(MangledName, MangledName + std::strlen(MangledName));
 349   OutputStream S;
 350
 351   Node *AST = Parser.parse();
 352
 353   if (AST == nullptr)
 354     InternalStatus = demangle_invalid_mangled_name;
 355   else if (!initializeOutputStream(Buf, N, S, 1024))
 356     InternalStatus = demangle_memory_alloc_failure;
 357   else {
 358     assert(Parser.ForwardTemplateRefs.empty());
 359     AST->print(S);
 360     S += '\0';
 361     if (N != nullptr)
 362       *N = S.getCurrentPosition();
 363     Buf = S.getBuffer();
 364   }
 365
 366   if (Status)
 367     *Status = InternalStatus;
 368   return InternalStatus == demangle_success ? Buf : nullptr;
 369 }
 370 }  // __cxxabiv1