Folly Code Review · 81/89

folly::demangle — typeid 디망글링

2026년 6월 8일 · Hawk · 4분 읽기

한 줄 요약: typeid(T).name()이 토해내는 mangled name (_ZN3foo3BarE)을 사람 읽기 쉬운 foo::Bar로 바꾼다. crash stacktrace, log, debug 출력의 읽기 가능성을 결정한다.

#동기

C++ name mangling은 컴파일러가 namespace, template, overload, calling convention을 한 식별자에 인코딩하는 방식이다.

1
C++ source           Itanium ABI mangled
2
─────────────────    ──────────────────────────────
3
foo::Bar             N3foo3BarE
4
std::vector<int>     St6vectorIiSaIiEE
5
my_func(int, char)   _Z7my_funciC

mangled name은 ABI 통일을 위해 필수지만 사람이 못 읽는다. typeid(T).name()이 plat-specific mangled name을 반환 (libstdc++/clang) — abi::__cxa_demangle로 복원해야 사람이 읽는다.

folly::demangle이 그 wrapper다.

1
#include <folly/Demangle.h>
2

3
std::cout << folly::demangle(typeid(std::vector<int>));
4
// → "std::vector<int, std::allocator<int> >"
5

6
std::cout << folly::demangle("_ZN3foo3BarE");
7
// → "foo::Bar"

#API

1
namespace folly {
2

3
// 1. typeid(T) 또는 std::type_info에서
4
fbstring demangle(const std::type_info& ti);
5

6
// 2. mangled name string에서
7
fbstring demangle(const char* mangled);
8

9
// 3. 사용자 buffer에 — alloc 회피
10
size_t demangle(const char* mangled, char* out, size_t outSize);
11

12
}

세 가지 형태. 사용자 buffer 변형은 stack-allocated array에 쓸 때 — signal handler처럼 alloc이 위험한 곳에서 쓴다.

#내부 구현

1
// folly/Demangle.cpp 약식
2
fbstring demangle(const char* mangled) {
3
#if FOLLY_HAS_CXXABI_H
4
  int status;
5
  size_t length = 0;
6
  // __cxa_demangle은 malloc된 buffer 반환
7
  char* demangled = abi::__cxa_demangle(mangled, nullptr, &length, &status);
8
  if (status == 0 && demangled) {
9
    fbstring result(demangled);
10
    free(demangled);
11
    return result;
12
  }
13
#endif
14
  return fbstring(mangled);   // demangle 실패 시 mangled 그대로
15
}

핵심은 abi::__cxa_demangle. Itanium C++ ABI 표준 함수 (libstdc++/libc++가 제공). 결과는 malloc된 buffer로 호출자가 free해야 한다.

folly::demangle이 그 alloc/free를 RAII로 묶고 fbstring으로 반환.

#Signal handler-safe variant

1
size_t demangle(const char* mangled, char* out, size_t outSize) {
2
  // __cxa_demangle을 호출하되 user buffer를 passthrough
3
  size_t bufSize = outSize;
4
  int status;
5
  char* demangled = abi::__cxa_demangle(mangled, out, &bufSize, &status);
6
  if (status == 0) {
7
    // demangled가 out이거나 새로 alloc된 buffer
8
    if (demangled != out) {
9
      std::strncpy(out, demangled, outSize);
10
      free(demangled);
11
    }
12
    return std::strlen(out);
13
  }
14
  return 0;
15
}

__cxa_demangle이 buffer가 부족하면 새로 alloc한다 (혹은 reuse) — signal handler에선 malloc 금지라 buffer가 충분한지 미리 검증해야. fbcode의 signal handler가 큰 stack-array를 미리 잡고 호출.

#사용 예 — type info

1
template <class T>
2
void Inspect(const T& v) {
3
  std::cout << "type: " << folly::demangle(typeid(T)) << "\n";
4
  std::cout << "value: " << v << "\n";
5
}
6

7
Inspect(std::vector<std::string>{});
8
// type: std::vector<std::string, std::allocator<std::string> >

generic code에서 어떤 타입이 추론됐는지 확인하기에 편리. CTAD, auto, template 디버깅의 단골.

#사용 예 — exception type

1
try {
2
  // ...
3
} catch (const std::exception& e) {
4
  LOG(ERROR) << "exception of type "
5
             << folly::demangle(typeid(e))
6
             << ": " << e.what();
7
}

exception 타입을 로그에 남길 때. typeid(e).name()은 mangled — demangle 안 거치면 가독성이 떨어진다.

#사용 예 — stacktrace

1
// folly/symbolizer의 stack frame symbolization
2
void DumpFrame(uintptr_t addr) {
3
  Dl_info info;
4
  if (dladdr(reinterpret_cast<void*>(addr), &info) && info.dli_sname) {
5
    std::cerr << folly::demangle(info.dli_sname) << "\n";
6
  }
7
}

dladdr이 반환하는 symbol name도 mangled. demangle 거쳐야 foo::Bar::baz(int) 형태로 본다. folly의 Symbolizer가 이 경로를 자동.

#std와의 비교

항목	표준 (없음)	folly::demangle	absl (없음)
표준 함수	없음 (typeid().name()은 implementation-defined)	wrapper	N/A
Itanium ABI	__cxa_demangle 사용	wrapper	직접 호출 가능
MSVC	__unDName 사용	미지원 (Itanium only)	N/A
signal-safe	N/A	buffer variant	N/A
표준화 가능성	reflection 후보	N/A	N/A

C++ 표준에는 demangle이 없다. std::type_info::name()이 plat-specific이라 표준 raw text조차 없는 상황. C++26 reflection이 들어오면 이 문제가 일부 해소된다.

MSVC는 다른 mangling scheme이라 __unDName이 필요하다. fbcode는 주로 Linux + Itanium ABI라 folly는 Linux/macOS 중심.

#코드 리뷰 포인트

typeid(T).name()을 그대로 log/exception message에 사용 → demangle 거쳐야.
log hot path에서 매번 demangle → demangle은 비싼 연산 (malloc + parse). 한 번 계산 후 캐시.
signal handler에서 folly::demangle(typeid(T)) 호출 → malloc 금지. user buffer variant.
generic logging utility가 type을 자동 보고하면 대량의 demangle 발생. opt-in 또는 캐시.

#자주 보는 안티패턴

1
// 1. hot path log
2
void Process(const auto& v) {
3
  VLOG(2) << "type: " << folly::demangle(typeid(v));   // 매번 demangle
4
  // → 같은 type이면 static 캐시
5
}
6

7
// 2. signal handler에서 fbstring 반환 variant 호출
8
void SignalHandler(int) {
9
  auto s = folly::demangle("_Z...");   // malloc — UB in signal handler
10
}
11

12
// 3. demangle 실패를 가정하지 않음
13
auto name = folly::demangle(mangled);   // 실패 시 mangled 그대로 반환
14
// → 그게 expected 동작. 별도 분기 보통 불필요.

#fbcode 패턴 — type 캐시

1
template <class T>
2
const std::string& TypeName() {
3
  static const std::string kName = folly::demangle(typeid(T)).toStdString();
4
  return kName;
5
}
6

7
void LogType(auto const& v) {
8
  using V = std::decay_t<decltype(v)>;
9
  LOG(INFO) << "type: " << TypeName<V>();
10
}