044 《Folly Demangle.h 权威指南：C++ 符号反解的艺术与实践 (Folly Demangle.h: The Definitive Guide to C++ Symbol Demangling)》

                                
                                    

                            
1
                            
namespace my_namespace {
                        

                            
2
                            
    int add(int a, int b) {
                        

                            
3
                            
        return a + b;
                        

                            
4
                            
    }
                        

                            
5
                            
    double add(double a, double b) {
                        

                            
6
                            
        return a + b;
                        

                            
7
                            
    }
                        

                            
8
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
git clone https://github.com/facebook/folly.git
                        

                            
2
                            
cd folly
                        
                                
                            

                                
                                    

                            
1
                            
mkdir build
                        

                            
2
                            
cd build
                        
                                
                            

                                
                                    

                            
1
                            
cmake ..
                        
                                
                            

                                
                                    

                            
1
                            
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local/folly ..
                        
                                
                            

                                
                                    

                            
1
                            
make -j$(nproc)
                        
                                
                            

                                
                                    

                            
1
                            
sudo make install
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        
                                
                            

                                
                                    

                            
1
                            
cmake_minimum_required(VERSION 3.10)
                        

                            
2
                            
project(MyProject)
                        

                            
3
                            

                        

                            
4
                            
find_package(Folly REQUIRED)
                        

                            
5
                            

                        

                            
6
                            
add_executable(my_executable main.cpp)
                        

                            
7
                            
target_link_libraries(my_executable PRIVATE Folly::folly) # 链接 folly 库
                        
                                
                            

                                
                                    

                            
1
                            
cmake -DCMAKE_PREFIX_PATH=/usr/local/folly ..
                        
                                
                            

                                
                                    

                            
1
                            
include_directories(/usr/local/folly/include)
                        

                            
2
                            
link_directories(/usr/local/folly/lib)
                        

                            
3
                            
target_link_libraries(my_executable folly) # 直接链接库名，可能需要指定库路径
                        
                                
                            

                                
                                    

                            
1
                            
namespace folly {
                        

                            
2
                            
std::string demangle(const char* mangledName);
                        

                            
3
                            
} // namespace folly
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
  const char* mangled_var_name = "_ZNSiE"; // 假设这是一个被修饰过的变量名
                        

                            
6
                            
  std::string demangled_var_name = folly::demangle(mangled_var_name);
                        

                            
7
                            
  std::cout << "Mangled name: " << mangled_var_name << std::endl;
                        

                            
8
                            
  std::cout << "Demangled name: " << demangled_var_name << std::endl;
                        

                            
9
                            

                        

                            
10
                            
  const char* mangled_func_name = "_ZN3fooEv"; // 假设这是一个被修饰过的函数名
                        

                            
11
                            
  std::string demangled_func_name = folly::demangle(mangled_func_name);
                        

                            
12
                            
  std::cout << "Mangled name: " << mangled_func_name << std::endl;
                        

                            
13
                            
  std::cout << "Demangled name: " << demangled_func_name << std::endl;
                        

                            
14
                            

                        

                            
15
                            
  return 0;
                        

                            
16
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
namespace folly {
                        

                            
2
                            
std::string demangle(std::string_view mangledName);
                        

                            
3
                            
} // namespace folly
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#include <string>
                        

                            
4
                            
#include <string_view>
                        

                            
5
                            

                        

                            
6
                            
int main() {
                        

                            
7
                            
  std::string mangled_class_name_str = "_ZNSsIcSt11char_traitsIcESaIcEEE"; // 修饰过的类名
                        

                            
8
                            
  std::string_view mangled_class_name_view = mangled_class_name_str; // 创建 string_view
                        

                            
9
                            

                        

                            
10
                            
  std::string demangled_class_name = folly::demangle(mangled_class_name_view);
                        

                            
11
                            
  std::cout << "Mangled name: " << mangled_class_name_view << std::endl;
                        

                            
12
                            
  std::cout << "Demangled name: " << demangled_class_name << std::endl;
                        

                            
13
                            

                        

                            
14
                            
  return 0;
                        

                            
15
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
namespace folly {
                        

                            
2
                            
std::string demangle(const char* mangledName, size_t len);
                        

                            
3
                            
} // namespace folly
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
  char mangled_template_name_array[] = "_Z1fIiEvT_"; // 修饰过的模板函数名，不以 \0 结尾
                        

                            
6
                            
  size_t mangled_len = sizeof(mangled_template_name_array) - 1; // 计算长度，排除 \0 (如果存在)
                        

                            
7
                            

                        

                            
8
                            
  std::string demangled_template_name = folly::demangle(mangled_template_name_array, mangled_len);
                        

                            
9
                            
  std::cout << "Mangled name (array): " << mangled_template_name_array << std::endl; // 注意：这里可能输出不完整，因为不是 \0 结尾
                        

                            
10
                            
  std::cout << "Demangled name: " << demangled_template_name << std::endl;
                        

                            
11
                            

                        

                            
12
                            
  return 0;
                        

                            
13
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
c++filt _Z3fooEi
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
  const char* mangled_global_var = "_ZN10my_namespace2MyClassE"; // 命名空间中的静态成员变量
                        

                            
6
                            
  const char* mangled_local_var = "_ZZ4mainE5local"; // 函数局部静态变量
                        

                            
7
                            

                        

                            
8
                            
  std::cout << "Mangled global variable name: " << mangled_global_var << std::endl;
                        

                            
9
                            
  std::cout << "Demangled global variable name: " << folly::demangle(mangled_global_var) << std::endl;
                        

                            
10
                            

                        

                            
11
                            
  std::cout << "Mangled local static variable name: " << mangled_local_var << std::endl;
                        

                            
12
                            
  std::cout << "Demangled local static variable name: " << folly::demangle(mangled_local_var) << std::endl;
                        

                            
13
                            

                        

                            
14
                            
  return 0;
                        

                            
15
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
Mangled global variable name: _ZN10my_namespace2MyClassE
                        

                            
2
                            
Demangled global variable name: my_namespace::MyClass
                        

                            
3
                            
Mangled local static variable name: _ZZ4mainE5local
                        

                            
4
                            
Demangled local static variable name: `main'::local
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
  const char* mangled_func_simple = "_Z3fooEv"; // 简单函数
                        

                            
6
                            
  const char* mangled_func_param = "_Z3barIiEvT_"; // 模板函数
                        

                            
7
                            
  const char* mangled_func_overload_int = "_Z3bazIiEvT_"; // 重载函数 (int 版本)
                        

                            
8
                            
  const char* mangled_func_overload_double = "_Z3bazIdEvT_"; // 重载函数 (double 版本)
                        

                            
9
                            

                        

                            
10
                            
  std::cout << "Mangled simple function name: " << mangled_func_simple << std::endl;
                        

                            
11
                            
  std::cout << "Demangled simple function name: " << folly::demangle(mangled_func_simple) << std::endl;
                        

                            
12
                            

                        

                            
13
                            
  std::cout << "Mangled template function name: " << mangled_func_param << std::endl;
                        

                            
14
                            
  std::cout << "Demangled template function name: " << folly::demangle(mangled_func_param) << std::endl;
                        

                            
15
                            

                        

                            
16
                            
  std::cout << "Mangled overloaded function name (int): " << mangled_func_overload_int << std::endl;
                        

                            
17
                            
  std::cout << "Demangled overloaded function name (int): " << folly::demangle(mangled_func_overload_int) << std::endl;
                        

                            
18
                            

                        

                            
19
                            
  std::cout << "Mangled overloaded function name (double): " << mangled_func_overload_double << std::endl;
                        

                            
20
                            
  std::cout << "Demangled overloaded function name (double): " << folly::demangle(mangled_func_overload_double) << std::endl;
                        

                            
21
                            

                        

                            
22
                            
  return 0;
                        

                            
23
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
Mangled simple function name: _Z3fooEv
                        

                            
2
                            
Demangled simple function name: foo()
                        

                            
3
                            
Mangled template function name: _Z3barIiEvT_
                        

                            
4
                            
Demangled template function name: bar<int>()
                        

                            
5
                            
Mangled overloaded function name (int): _Z3bazIiEvT_
                        

                            
6
                            
Demangled overloaded function name (int): baz<int>()
                        

                            
7
                            
Mangled overloaded function name (double): _Z3bazIdEvT_
                        

                            
8
                            
Demangled overloaded function name (double): baz<double>()
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
  const char* mangled_class_name = "_ZNSsIcSt11char_traitsIcESaIcEEE"; // std::string 类名
                        

                            
6
                            
  const char* mangled_nested_class_name = "_ZN10my_namespace7OuterClass9InnerClassE"; // 嵌套类名
                        

                            
7
                            
  const char* mangled_namespace_name = "_ZN10my_namespaceE"; // 命名空间名
                        

                            
8
                            

                        

                            
9
                            
  std::cout << "Mangled class name (std::string): " << mangled_class_name << std::endl;
                        

                            
10
                            
  std::cout << "Demangled class name (std::string): " << folly::demangle(mangled_class_name) << std::endl;
                        

                            
11
                            

                        

                            
12
                            
  std::cout << "Mangled nested class name: " << mangled_nested_class_name << std::endl;
                        

                            
13
                            
  std::cout << "Demangled nested class name: " << folly::demangle(mangled_nested_class_name) << std::endl;
                        

                            
14
                            

                        

                            
15
                            
  std::cout << "Mangled namespace name: " << mangled_namespace_name << std::endl;
                        

                            
16
                            
  std::cout << "Demangled namespace name: " << folly::demangle(mangled_namespace_name) << std::endl;
                        

                            
17
                            

                        

                            
18
                            
  return 0;
                        

                            
19
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
Mangled class name (std::string): _ZNSsIcSt11char_traitsIcESaIcEEE
                        

                            
2
                            
Demangled class name (std::string): std::string
                        

                            
3
                            
Mangled nested class name: _ZN10my_namespace7OuterClass9InnerClassE
                        

                            
4
                            
Demangled nested class name: my_namespace::OuterClass::InnerClass
                        

                            
5
                            
Mangled namespace name: _ZN10my_namespaceE
                        

                            
6
                            
Demangled namespace name: my_namespace
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#include <vector>
                        

                            
4
                            

                        

                            
5
                            
template <typename T>
                        

                            
6
                            
class MyTemplateClass {};
                        

                            
7
                            

                        

                            
8
                            
int main() {
                        

                            
9
                            
  const char* mangled_template_class_int = "_ZN17MyTemplateClassIiEE"; // MyTemplateClass<int>
                        

                            
10
                            
  const char* mangled_template_class_vector_int = "_ZN17MyTemplateClassISt6vectorIiSaIiEEEE"; // MyTemplateClass<std::vector<int>>
                        

                            
11
                            
  const char* mangled_template_func = "_Z3tplIiEvT_"; // 模板函数 tpl<int>
                        

                            
12
                            

                        

                            
13
                            
  std::cout << "Mangled template class name (int): " << mangled_template_class_int << std::endl;
                        

                            
14
                            
  std::cout << "Demangled template class name (int): " << folly::demangle(mangled_template_class_int) << std::endl;
                        

                            
15
                            

                        

                            
16
                            
  std::cout << "Mangled template class name (vector<int>): " << mangled_template_class_vector_int << std::endl;
                        

                            
17
                            
  std::cout << "Demangled template class name (vector<int>): " << folly::demangle(mangled_template_class_vector_int) << std::endl;
                        

                            
18
                            

                        

                            
19
                            
  std::cout << "Mangled template function name (int): " << mangled_template_func << std::endl;
                        

                            
20
                            
  std::cout << "Demangled template function name (int): " << folly::demangle(mangled_template_func) << std::endl;
                        

                            
21
                            

                        

                            
22
                            
  return 0;
                        

                            
23
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
Mangled template class name (int): _ZN17MyTemplateClassIiEE
                        

                            
2
                            
Demangled template class name (int): MyTemplateClass
                        

                            
3
                            
Mangled template class name (vector): _ZN17MyTemplateClassISt6vectorIiSaIiEEEE
                        

                            
4
                            
Demangled template class name (vector): MyTemplateClass<:vector> >
                        

                            
5
                            
Mangled template function name (int): _Z3tplIiEvT_
                        

                            
6
                            
Demangled template function name (int): tpl()
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#include <string>
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
  const char* invalid_mangled_name = "invalid_mangled_name"; // 无效的修饰名
                        

                            
7
                            
  std::string demangled_result = folly::demangle(invalid_mangled_name);
                        

                            
8
                            

                        

                            
9
                            
  if (demangled_result.empty()) {
                        

                            
10
                            
    std::cout << "Demangling failed for: " << invalid_mangled_name << std::endl;
                        

                            
11
                            
  } else if (demangled_result == invalid_mangled_name) {
                        

                            
12
                            
    std::cout << "Demangling might have failed or returned the original name for: " << invalid_mangled_name << std::endl;
                        

                            
13
                            
    std::cout << "Demangled result: " << demangled_result << std::endl;
                        

                            
14
                            
  }
                        

                            
15
                            
   else {
                        

                            
16
                            
    std::cout << "Demangled result for: " << invalid_mangled_name << std::endl; // 实际上不会执行到这里，因为是无效的修饰名
                        

                            
17
                            
    std::cout << "Demangled name: " << demangled_result << std::endl;
                        

                            
18
                            
  }
                        

                            
19
                            

                        

                            
20
                            
  const char* valid_mangled_name = "_Z3fooEv"; // 有效的修饰名
                        

                            
21
                            
  demangled_result = folly::demangle(valid_mangled_name);
                        

                            
22
                            
  if (demangled_result.empty()) {
                        

                            
23
                            
    std::cout << "Demangling failed for: " << valid_mangled_name << std::endl; // 实际上不会执行到这里，因为是有效的修饰名
                        

                            
24
                            
  } else {
                        

                            
25
                            
    std::cout << "Demangled result for: " << valid_mangled_name << std::endl;
                        

                            
26
                            
    std::cout << "Demangled name: " << demangled_result << std::endl;
                        

                            
27
                            
  }
                        

                            
28
                            

                        

                            
29
                            
  return 0;
                        

                            
30
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
  const char* mangled_name = "_ZNSs4_Rep17_S_empty_rep_storageE"; // std::string::_Rep::_S_empty_rep_storage 的修饰名
                        

                            
6
                            

                        

                            
7
                            
  // 假设 folly::demangle 接受选项参数 (这只是概念示例，具体API请查阅文档)
                        

                            
8
                            
  std::cout << "默认反解: " << folly::demangle(mangled_name) << std::endl;
                        

                            
9
                            
  // std::cout << "简洁模式反解: " << folly::demangle(mangled_name, folly::DemangleOptions::kSimplified) << std::endl;
                        

                            
10
                            
  // std::cout << "详细模式反解: " << folly::demangle(mangled_name, folly::DemangleOptions::kDetailed) << std::endl;
                        

                            
11
                            

                        

                            
12
                            
  return 0;
                        

                            
13
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
struct Foo {
                        

                            
5
                            
  Foo operator+(const Foo& other) const { return *this; } // 运算符重载
                        

                            
6
                            
  Foo() {} // 构造函数
                        

                            
7
                            
  ~Foo() {} // 析构函数
                        

                            
8
                            
  virtual void virtualFunc() {} // 虚函数
                        

                            
9
                            
  static int staticVar; // 静态成员变量
                        

                            
10
                            
  static void staticFunc() {} // 静态成员函数
                        

                            
11
                            
};
                        

                            
12
                            

                        

                            
13
                            
int Foo::staticVar = 0;
                        

                            
14
                            

                        

                            
15
                            
int main() {
                        

                            
16
                            
  const char* op_plus_mangled = "_ZN3FooplERKS_"; // Foo::operator+(const Foo&) 的修饰名
                        

                            
17
                            
  const char* ctor_mangled = "_ZN3FooC1Ev"; // Foo::Foo() 的修饰名
                        

                            
18
                            
  const char* dtor_mangled = "_ZN3FooD1Ev"; // Foo::~Foo() 的修饰名
                        

                            
19
                            
  const char* vfunc_mangled = "_ZN3Foo11virtualFuncEv"; // Foo::virtualFunc() 的修饰名
                        

                            
20
                            
  const char* static_var_mangled = "_ZN3Foo9staticVarE"; // Foo::staticVar 的修饰名
                        

                            
21
                            
  const char* static_func_mangled = "_ZN3Foo10staticFuncEv"; // Foo::staticFunc() 的修饰名
                        

                            
22
                            

                        

                            
23
                            

                        

                            
24
                            
  std::cout << "运算符重载反解: " << folly::demangle(op_plus_mangled) << std::endl;
                        

                            
25
                            
  std::cout << "构造函数反解: " << folly::demangle(ctor_mangled) << std::endl;
                        

                            
26
                            
  std::cout << "析构函数反解: " << folly::demangle(dtor_mangled) << std::endl;
                        

                            
27
                            
  std::cout << "虚函数反解: " << folly::demangle(vfunc_mangled) << std::endl;
                        

                            
28
                            
  std::cout << "静态变量反解: " << folly::demangle(static_var_mangled) << std::endl;
                        

                            
29
                            
  std::cout << "静态函数反解: " << folly::demangle(static_func_mangled) << std::endl;
                        

                            
30
                            

                        

                            
31
                            
  return 0;
                        

                            
32
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <string>
                        

                            
2
                            
#include <string_view>
                        

                            
3
                            

                        

                            
4
                            
namespace folly {
                        

                            
5
                            

                        

                            
6
                            
class Demangler {
                        

                            
7
                            
public:
                        

                            
8
                            
  virtual ~Demangler() = default;
                        

                            
9
                            

                        

                            
10
                            
  virtual std::string demangle(const char* mangled_name) {
                        

                            
11
                            
    return demangle(std::string_view(mangled_name));
                        

                            
12
                            
  }
                        

                            
13
                            

                        

                            
14
                            
  virtual std::string demangle(std::string_view mangled_name) = 0; // 纯虚函数，需要子类实现
                        

                            
15
                            

                        

                            
16
                            
  // 可选的辅助方法，例如：
                        

                            
17
                            
  // virtual void setOptions(DemangleOptions options) {}
                        

                            
18
                            
  // virtual void handleError(DemangleError error) {}
                        

                            
19
                            
};
                        

                            
20
                            

                        

                            
21
                            
// 默认反解器 (可能存在于 folly/Demangle.h 中)
                        

                            
22
                            
// class DefaultDemangler : public Demangler { ... };
                        

                            
23
                            

                        

                            
24
                            
} // namespace folly
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <string>
                        

                            
3
                            
#include <string_view>
                        

                            
4
                            
#include <iostream>
                        

                            
5
                            

                        

                            
6
                            
namespace my_namespace {
                        

                            
7
                            

                        

                            
8
                            
class MyDemangler : public folly::Demangler {
                        

                            
9
                            
public:
                        

                            
10
                            
  std::string demangle(std::string_view mangled_name) override {
                        

                            
11
                            
    // 在这里实现自定义的反解逻辑
                        

                            
12
                            
    std::string demangled = folly::DefaultDemangler().demangle(mangled_name); // 先使用默认反解器作为基础
                        

                            
13
                            
    // 然后进行自定义的后处理，例如：
                        

                            
14
                            
    if (demangled.find("std::string") != std::string::npos) {
                        

                            
15
                            
      // 将 std::string 替换为 string (简化输出)
                        

                            
16
                            
      size_t pos = demangled.find("std::string");
                        

                            
17
                            
      demangled.replace(pos, std::string("std::string").length(), "string");
                        

                            
18
                            
    }
                        

                            
19
                            
    return demangled;
                        

                            
20
                            
  }
                        

                            
21
                            
};
                        

                            
22
                            

                        

                            
23
                            
} // namespace my_namespace
                        

                            
24
                            

                        

                            
25
                            
int main() {
                        

                            
26
                            
  const char* mangled_name = "_ZNSs4_Rep17_S_empty_rep_storageE"; // std::string::_Rep::_S_empty_rep_storage 的修饰名
                        

                            
27
                            

                        

                            
28
                            
  my_namespace::MyDemangler my_demangler;
                        

                            
29
                            
  std::cout << "自定义反解器输出: " << my_demangler.demangle(mangled_name) << std::endl;
                        

                            
30
                            

                        

                            
31
                            
  return 0;
                        

                            
32
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <string>
                        

                            
3
                            
#include <string_view>
                        

                            
4
                            
#include <unordered_map>
                        

                            
5
                            
#include <mutex>
                        

                            
6
                            

                        

                            
7
                            
namespace utils {
                        

                            
8
                            

                        

                            
9
                            
class DemanglerCache {
                        

                            
10
                            
public:
                        

                            
11
                            
  std::string demangleWithCache(std::string_view mangled_name) {
                        

                            
12
                            
    {
                        

                            
13
                            
      std::shared_lock<std::shared_mutex> lock(cache_mutex_);
                        

                            
14
                            
      auto it = demangle_cache_.find(mangled_name);
                        

                            
15
                            
      if (it != demangle_cache_.end()) {
                        

                            
16
                            
        return it->second;
                        

                            
17
                            
      }
                        

                            
18
                            
    }
                        

                            
19
                            

                        

                            
20
                            
    std::string demangled_name = folly::demangle(mangled_name);
                        

                            
21
                            
    {
                        

                            
22
                            
      std::unique_lock<std::shared_mutex> lock(cache_mutex_);
                        

                            
23
                            
      demangle_cache_[mangled_name] = demangled_name;
                        

                            
24
                            
    }
                        

                            
25
                            
    return demangled_name;
                        

                            
26
                            
  }
                        

                            
27
                            

                        

                            
28
                            
private:
                        

                            
29
                            
  std::unordered_map<std::string, std::string> demangle_cache_;
                        

                            
30
                            
  std::shared_mutex cache_mutex_;
                        

                            
31
                            
};
                        

                            
32
                            

                        

                            
33
                            
static DemanglerCache demangler_cache_instance;
                        

                            
34
                            

                        

                            
35
                            
std::string demangleCached(std::string_view mangled_name) {
                        

                            
36
                            
  return demangler_cache_instance.demangleWithCache(mangled_name);
                        

                            
37
                            
}
                        

                            
38
                            

                        

                            
39
                            
} // namespace utils
                        

                            
40
                            

                        

                            
41
                            
int main() {
                        

                            
42
                            
  const char* mangled_name = "_ZNSs4_Rep17_S_empty_rep_storageE"; // std::string::_Rep::_S_empty_rep_storage 的修饰名
                        

                            
43
                            

                        

                            
44
                            
  for (int i = 0; i < 10; ++i) {
                        

                            
45
                            
    std::cout << "反解结果 (cached): " << utils::demangleCached(mangled_name) << std::endl;
                        

                            
46
                            
  }
                        

                            
47
                            

                        

                            
48
                            
  return 0;
                        

                            
49
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#include <string_view>
                        

                            
4
                            

                        

                            
5
                            
// 假设使用一个简单的自定义日志函数
                        

                            
6
                            
void log_message(const char* level, std::string_view message) {
                        

                            
7
                            
  std::cout << "[" << level << "] " << message << std::endl;
                        

                            
8
                            
}
                        

                            
9
                            

                        

                            
10
                            
// 封装反解和日志输出的宏
                        

                            
11
                            
#define LOG_DEMANGLED(level, message)   log_message(level, folly::demangle(message))
                        

                            
12
                            

                        

                            
13
                            
int main() {
                        

                            
14
                            
  const char* mangled_name = "_ZNSs4_Rep17_S_empty_rep_storageE"; // std::string::_Rep::_S_empty_rep_storage 的修饰名
                        

                            
15
                            

                        

                            
16
                            
  log_message("RAW", mangled_name); // 输出原始修饰名
                        

                            
17
                            
  log_message("DEMANGLED", folly::demangle(mangled_name)); // 输出反解后的名称
                        

                            
18
                            

                        

                            
19
                            
  LOG_DEMANGLED("MACRO_DEMANGLED", mangled_name); // 使用宏输出反解后的名称
                        

                            
20
                            

                        

                            
21
                            
  return 0;
                        

                            
22
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#0  0x00007ffff7a0b428 in _ZNSs4_Rep17_S_empty_rep_storageE () from /lib64/libstdc++.so.6
                        

                            
2
                            
#1  0x00007ffff7a0b6a7 in std::string::_Rep::_M_grab(std::allocator<char> const&, std::allocator<char> const&, int) () from /lib64/libstdc++.so.6
                        

                            
3
                            
#2  0x00007ffff7a0c179 in std::string::reserve(unsigned long) () from /lib64/libstdc++.so.6
                        

                            
4
                            
#3  0x000000000040080d in main () at main.cpp:10
                        
                                
                            

                                
                                    

                            
1
                            
#0  0x00007ffff7a0b428 in std::string::_Rep::_S_empty_rep_storage () from /lib64/libstdc++.so.6
                        

                            
2
                            
#1  0x00007ffff7a0b6a7 in std::string::_Rep::_M_grab(const std::allocator<char>&, const std::allocator<char>&, int) () from /lib64/libstdc++.so.6
                        

                            
3
                            
#2  0x00007ffff7a0c179 in std::string::reserve(unsigned long) () from /lib64/libstdc++.so.6
                        

                            
4
                            
#3  0x000000000040080d in main () at main.cpp:10
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <gtest/gtest.h> // 假设使用 Google Test 框架
                        

                            
3
                            
#include <string>
                        

                            
4
                            

                        

                            
5
                            
namespace my_namespace {
                        

                            
6
                            

                        

                            
7
                            
class MyClass {
                        

                            
8
                            
public:
                        

                            
9
                            
  void myMethod() {}
                        

                            
10
                            
};
                        

                            
11
                            

                        

                            
12
                            
} // namespace my_namespace
                        

                            
13
                            

                        

                            
14
                            
TEST(MyClassTest, MyMethodTest) {
                        

                            
15
                            
  my_namespace::MyClass obj;
                        

                            
16
                            
  // ... 执行一些操作 ...
                        

                            
17
                            

                        

                            
18
                            
  // 假设某个断言失败，可以使用反解后的符号名称来增强断言消息
                        

                            
19
                            
  std::string method_name = folly::demangle("_ZN10my_namespace7MyClass8myMethodEv");
                        

                            
20
                            
  ASSERT_TRUE(true) << "Method " << method_name << " should have been called successfully.";
                        

                            
21
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#ifdef _WIN32
                        

                            
2
                            
// Windows 平台特定的代码
                        

                            
3
                            
#include <windows.h>
                        

                            
4
                            
std::string demangle_impl(const char* mangled_name) {
                        

                            
5
                            
  // 使用 Windows 平台相关的反解 API
                        

                            
6
                            
  // ...
                        

                            
7
                            
}
                        

                            
8
                            
#else
                        

                            
9
                            
// 非 Windows 平台（例如 Linux, macOS）的代码
                        

                            
10
                            
#include <cxxabi.h>
                        

                            
11
                            
std::string demangle_impl(const char* mangled_name) {
                        

                            
12
                            
  // 使用 cxxabi.h 提供的反解 API
                        

                            
13
                            
  // ...
                        

                            
14
                            
}
                        

                            
15
                            
#endif
                        
                                
                            

                                
                                    

                            
1
                            
#ifdef _WIN32
                        

                            
2
                            
// Windows 平台特定的代码
                        

                            
3
                            
#include <windows.h>
                        

                            
4
                            
#endif
                        

                            
5
                            

                        

                            
6
                            
#ifndef __linux__
                        

                            
7
                            
// 非 Linux 平台代码
                        

                            
8
                            
#include <iostream>
                        

                            
9
                            
#endif
                        
                                
                            

                                
                                    

                            
1
                            
#if defined(__linux__)
                        

                            
2
                            
// Linux 平台代码
                        

                            
3
                            
#include <unistd.h>
                        

                            
4
                            
#elif defined(_WIN32)
                        

                            
5
                            
// Windows 平台代码
                        

                            
6
                            
#include <windows.h>
                        

                            
7
                            
#else
                        

                            
8
                            
// 其他平台代码
                        

                            
9
                            
#include <stdio.h>
                        

                            
10
                            
#endif
                        
                                
                            

                                
                                    

                            
1
                            
#define DEBUG_MODE 1
                        

                            
2
                            

                        

                            
3
                            
#if DEBUG_MODE
                        

                            
4
                            
// 调试模式下的代码
                        

                            
5
                            
std::cout << "Debug mode is enabled." << std::endl;
                        

                            
6
                            
#endif
                        

                            
7
                            

                        

                            
8
                            
#undef DEBUG_MODE // 取消 DEBUG_MODE 宏的定义
                        
                                
                            

                                
                                    

                            
1
                            
#ifdef _WIN32
                        

                            
2
                            
#include <windows.h>
                        

                            
3
                            
#include <dbghelp.h> // Windows 调试帮助库
                        

                            
4
                            
#else
                        

                            
5
                            
#include <cxxabi.h> // C++ ABI 反解库 (Linux, macOS 等)
                        

                            
6
                            
#include <dlfcn.h>  // 动态链接库加载 (Linux, macOS 等)
                        

                            
7
                            
#endif
                        
                                
                            

                                
                                    

                            
1
                            
#ifdef _WIN32
                        

                            
2
                            
// Windows 平台使用 SymFromAddr 函数进行符号查找
                        

                            
3
                            
BOOL result = SymFromAddr(GetCurrentProcess(), address, NULL, symbol_info);
                        

                            
4
                            
#else
                        

                            
5
                            
// 非 Windows 平台使用 dladdr 函数进行符号查找
                        

                            
6
                            
Dl_info info;
                        

                            
7
                            
int result = dladdr(address, &info);
                        

                            
8
                            
#endif
                        
                                
                            

                                
                                    

                            
1
                            
#ifdef __GNUC__ // GCC 或 Clang 编译器
                        

                            
2
                            
if (__builtin_expect(condition, 1)) { // 假设 condition 大概率为真
                        

                            
3
                            
  // ...
                        

                            
4
                            
}
                        

                            
5
                            
#else
                        

                            
6
                            
if (condition) {
                        

                            
7
                            
  // ...
                        

                            
8
                            
}
                        

                            
9
                            
#endif
                        
                                
                            

                                
                                    

                            
1
                            
#if __cpp_lib_string_view >= 201606L // C++17 或更高版本支持 std::string_view
                        

                            
2
                            
using string_view_type = std::string_view;
                        

                            
3
                            
#else
                        

                            
4
                            
using string_view_type = folly::StringPiece; // 使用 folly 提供的 StringPiece
                        

                            
5
                            
#endif
                        
                                
                            

                                
                                    

                            
1
                            
git clone https://github.com/facebook/folly.git
                        

                            
2
                            
cd folly
                        
                                
                            

                                
                                    

                            
1
                            
git checkout v2024.01.22.00 # 切换到指定版本
                        
                                
                            

                                
                                    

                            
1
                            
sudo apt-get update
                        

                            
2
                            
sudo apt-get install cmake g++ python libboost-dev libdouble-conversion-dev libgoogle-glog-dev libgflags-dev libevent-dev liblz4-dev libssl-dev zlib1g-dev libzstd-dev libsnappy-dev
                        
                                
                            

                                
                                    

                            
1
                            
brew update
                        

                            
2
                            
brew install cmake boost double-conversion glog gflags libevent lz4 openssl zlib zstd snappy
                        
                                
                            

                                
                                    

                            
1
                            
mkdir build
                        

                            
2
                            
cd build
                        
                                
                            

                                
                                    

                            
1
                            
cmake ..
                        
                                
                            

                                
                                    

                            
1
                            
cmake -DCMAKE_BUILD_TYPE=Release ..
                        
                                
                            

                                
                                    

                            
1
                            
cmake -GNinja ..
                        
                                
                            

                                
                                    

                            
1
                            
make -j$(nproc) # 使用多核并行编译，加快编译速度
                        
                                
                            

                                
                                    

                            
1
                            
ninja -j$(nproc)
                        
                                
                            

                                
                                    

                            
1
                            
sudo make install
                        
                                
                            

                                
                                    

                            
1
                            
sudo ninja install
                        
                                
                            

                                
                                    

                            
1
                            
#ifdef DEBUG
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#define DEBUG_LOG(msg) std::cerr << "[DEBUG] " << msg << std::endl
                        

                            
4
                            
#else
                        

                            
5
                            
#define DEBUG_LOG(msg) // 空宏，发布版本不输出任何信息
                        

                            
6
                            
#endif
                        

                            
7
                            

                        

                            
8
                            
std::string demangle_impl(const char* mangled_name) {
                        

                            
9
                            
  DEBUG_LOG("demangle_impl called with name: " << mangled_name);
                        

                            
10
                            
  // ...
                        

                            
11
                            
  std::string result = /* ... */;
                        

                            
12
                            
  DEBUG_LOG("demangle_impl result: " << result);
                        

                            
13
                            
  return result;
                        

                            
14
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/Demangle.h>
                        

                            
2
                            
#include <string>
                        

                            
3
                            

                        

                            
4
                            
class SymbolHelper {
                        

                            
5
                            
 public:
                        

                            
6
                            
  static std::string demangleSymbol(const std::string& mangledName) {
                        

                            
7
                            
    try {
                        

                            
8
                            
      return folly::demangle(mangledName);
                        

                            
9
                            
    } catch (const std::exception&) {
                        

                            
10
                            
      return mangledName; // 反解失败时返回原始符号名
                        

                            
11
                            
    }
                        

                            
12
                            
  }
                        

                            
13
                            
};