1 //===-- llvm-undname.cpp - Microsoft ABI name undecorator
2 //------------------===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This utility works like the windows undname utility. It converts mangled
11 // Microsoft symbol names into pretty C/C++ human-readable names.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/Demangle/Demangle.h"
17 #include "llvm/Support/CommandLine.h"
18 #include "llvm/Support/ErrorOr.h"
19 #include "llvm/Support/InitLLVM.h"
20 #include "llvm/Support/MemoryBuffer.h"
21 #include "llvm/Support/Process.h"
22 #include "llvm/Support/WithColor.h"
23 #include "llvm/Support/raw_ostream.h"
24 #include <cstdio>
25 #include <cstring>
26 #include <iostream>
27 #include <string>
28 
29 using namespace llvm;
30 
31 cl::opt<bool> DumpBackReferences("backrefs", cl::Optional,
32                                  cl::desc("dump backreferences"), cl::Hidden,
33                                  cl::init(false));
34 cl::opt<bool> NoAccessSpecifier("no-access-specifier", cl::Optional,
35                                 cl::desc("skip access specifiers"), cl::Hidden,
36                                 cl::init(false));
37 cl::opt<bool> NoCallingConvention("no-calling-convention", cl::Optional,
38                                   cl::desc("skip calling convention"),
39                                   cl::Hidden, cl::init(false));
40 cl::opt<bool> NoReturnType("no-return-type", cl::Optional,
41                            cl::desc("skip return types"), cl::Hidden,
42                            cl::init(false));
43 cl::opt<bool> NoMemberType("no-member-type", cl::Optional,
44                            cl::desc("skip member types"), cl::Hidden,
45                            cl::init(false));
46 cl::opt<std::string> RawFile("raw-file", cl::Optional,
47                              cl::desc("for fuzzer data"), cl::Hidden);
48 cl::opt<bool> WarnTrailing("warn-trailing", cl::Optional,
49                            cl::desc("warn on trailing characters"), cl::Hidden,
50                            cl::init(false));
51 cl::list<std::string> Symbols(cl::Positional, cl::desc("<input symbols>"),
52                               cl::ZeroOrMore);
53 
54 static bool msDemangle(const std::string &S) {
55   int Status;
56   MSDemangleFlags Flags = MSDF_None;
57   if (DumpBackReferences)
58     Flags = MSDemangleFlags(Flags | MSDF_DumpBackrefs);
59   if (NoAccessSpecifier)
60     Flags = MSDemangleFlags(Flags | MSDF_NoAccessSpecifier);
61   if (NoCallingConvention)
62     Flags = MSDemangleFlags(Flags | MSDF_NoCallingConvention);
63   if (NoReturnType)
64     Flags = MSDemangleFlags(Flags | MSDF_NoReturnType);
65   if (NoMemberType)
66     Flags = MSDemangleFlags(Flags | MSDF_NoMemberType);
67 
68   size_t NRead;
69   char *ResultBuf =
70       microsoftDemangle(S.c_str(), &NRead, nullptr, nullptr, &Status, Flags);
71   if (Status == llvm::demangle_success) {
72     outs() << ResultBuf << "\n";
73     outs().flush();
74     if (WarnTrailing && NRead < S.size())
75       WithColor::warning() << "trailing characters: " << S.c_str() + NRead
76                            << "\n";
77   } else {
78     WithColor::error() << "Invalid mangled name\n";
79   }
80   std::free(ResultBuf);
81   return Status == llvm::demangle_success;
82 }
83 
84 int main(int argc, char **argv) {
85   InitLLVM X(argc, argv);
86 
87   cl::ParseCommandLineOptions(argc, argv, "llvm-undname\n");
88 
89   if (!RawFile.empty()) {
90     ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
91         MemoryBuffer::getFileOrSTDIN(RawFile);
92     if (std::error_code EC = FileOrErr.getError()) {
93       WithColor::error() << "Could not open input file \'" << RawFile
94                          << "\': " << EC.message() << '\n';
95       return 1;
96     }
97     return msDemangle(std::string(FileOrErr->get()->getBuffer())) ? 0 : 1;
98   }
99 
100   bool Success = true;
101   if (Symbols.empty()) {
102     while (true) {
103       std::string LineStr;
104       std::getline(std::cin, LineStr);
105       if (std::cin.eof())
106         break;
107 
108       StringRef Line(LineStr);
109       Line = Line.trim();
110       if (Line.empty() || Line.startswith("#") || Line.startswith(";"))
111         continue;
112 
113       // If the user is manually typing in these decorated names, don't echo
114       // them to the terminal a second time.  If they're coming from redirected
115       // input, however, then we should display the input line so that the
116       // mangled and demangled name can be easily correlated in the output.
117       if (!sys::Process::StandardInIsUserInput()) {
118         outs() << Line << "\n";
119         outs().flush();
120       }
121       if (!msDemangle(std::string(Line)))
122         Success = false;
123       outs() << "\n";
124     }
125   } else {
126     for (StringRef S : Symbols) {
127       outs() << S << "\n";
128       outs().flush();
129       if (!msDemangle(std::string(S)))
130         Success = false;
131       outs() << "\n";
132     }
133   }
134 
135   return Success ? 0 : 1;
136 }
137