LLVM  16.0.0git
Namespaces | Functions | Variables
include/llvm/Demangle/README.txt File Reference

Namespaces

 FIXME
 

Functions

Itanium Name Demangler i e convert the string _Z1fv into f ()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
 
Itanium Name Demangler i e convert the string _Z1fv into or (in LLVM) use the opaque ItaniumPartialDemangler to query the demangled AST. Why are there multiple copies of the this library in the source tree? --------------------------------------------------------------------- The canonical sources are in libcxxabi/src/demangle and some of the files are copied to llvm/include/llvm/Demangle. The simple reason for this comes from before the monorepo
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement which is part of the itanium ABI spec *LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be available (i.e., on Windows)
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement which is part of the itanium ABI spec *LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in libcxxabi (ie, the MSVC demangler, ItaniumPartialDemangler)
 

Variables

Itanium Name Demangler Library
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle symbols
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement __cxa_demangle
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement which is part of the itanium ABI spec *LLVM needs a copy for a bunch of places
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement which is part of the itanium ABI spec *LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these differences
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement which is part of the itanium ABI spec *LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these we want to keep the core generic demangling library identical between both copies to simplify development and testing If you re working on the generic library
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement which is part of the itanium ABI spec *LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these we want to keep the core generic demangling library identical between both copies to simplify development and testing If you re working on the generic then do the work first in libcxxabi
 
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement which is part of the itanium ABI spec *LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these we want to keep the core generic demangling library identical between both copies to simplify development and testing If you re working on the generic then do the work first in then run the cp to llvm sh script in src demangle This script takes as an optional argument the path to llvm
 
 FIXME::unit
 
test_demangle cpp
 
test_demangle and llvm unittest Demangle The llvm directory should only get tests for stuff not included in the core library In the future though
 
test_demangle and llvm unittest Demangle The llvm directory should only get tests for stuff not included in the core library In the future we should probably move all the tests to LLVM It is also a really good idea to run libFuzzer after non trivial changes
 

Function Documentation

◆ available()

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle but neither can depend on each other* libcxxabi needs the demangler to implement which is part of the itanium ABI spec* LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be available ( i.  e.,
on  Windows 
)

◆ f()

Itanium Name Demangler i e convert the string _Z1fv into f ( )

Referenced by llvm::BitVector::apply(), canDemoteGlobalVar(), llvm::CastInfo< To, PointerUnion< PTs... > >::doCast(), llvm::ValueFromPointerCast< To, From, Derived >::doCast(), llvm::UniquePtrCast< To, From >::doCast(), llvm::OptionalValueCast< To, From >::doCast(), llvm::ConstStrippingForwardingCast< To, const PointerUnion< PTs... >, CastInfo< To, PointerUnion< PTs... > > >::doCast(), llvm::ForwardToPointerCast< To, From, ForwardTo >::doCast(), llvm::CastInfo< To, From, Enable >::doCast(), llvm::CastInfo< To, From, std::enable_if_t<!is_simple_type< From >::value > >::doCast(), llvm::DefaultDoCastIfPossible< To, PointerUnion< PTs... >, CastInfo< To, PointerUnion< PTs... > > >::doCastIfPossible(), llvm::UniquePtrCast< To, From >::doCastIfPossible(), llvm::ConstStrippingForwardingCast< To, const PointerUnion< PTs... >, CastInfo< To, PointerUnion< PTs... > > >::doCastIfPossible(), llvm::CastInfo< To, From, Enable >::doCastIfPossible(), llvm::CastInfo< To, From, std::enable_if_t<!is_simple_type< From >::value > >::doCastIfPossible(), expandPow(), llvm::ScalarEvolution::getAddExpr(), getInlineImmVal32(), getLit32Encoding(), llvm::MachineFunction::getMachineMemOperand(), llvm::SPIRV::ModuleAnalysisInfo::getOrCreateMBBRegister(), llvm::GetReturnInfo(), llvm::sys::getSwappedBytes(), llvm::detail::IEEEFloat::IEEEFloat(), llvm::AMDGPU::isInlinableLiteral32(), llvm::isMathLibCallNoop(), llvm::CastInfo< To, PointerUnion< PTs... > >::isPossible(), llvm::CastIsPossible< To, From * >::isPossible(), llvm::CastIsPossible< To, Optional< From > >::isPossible(), llvm::ConstStrippingForwardingCast< To, const PointerUnion< PTs... >, CastInfo< To, PointerUnion< PTs... > > >::isPossible(), llvm::ForwardToPointerCast< To, From, ForwardTo >::isPossible(), llvm::CastInfo< To, From, std::enable_if_t<!is_simple_type< From >::value > >::isPossible(), llvm::AMDGPULegalizerInfo::legalizeFDIV32(), llvm::AMDGPULegalizerInfo::legalizeFDIVFastIntrin(), llvm::lintFunction(), LowerFROUND(), optimizeWithFDivFast(), llvm::GCOVFile::print(), llvm::OverlapStats::score(), llvm::MCContext::setDwarfFormat(), llvm::MachineMemOperand::setFlags(), llvm::thread::thread(), llvm::verifyFunction(), llvm::InstCombinerImpl::visitLandingPadInst(), and llvm::X86TargetLowering::X86TargetLowering().

◆ libcxxabi()

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle but neither can depend on each other* libcxxabi needs the demangler to implement which is part of the itanium ABI spec* LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in libcxxabi ( ie  ,
the MSVC  demangler,
ItaniumPartialDemangler   
)

◆ or()

Itanium Name Demangler i e convert the string _Z1fv into or ( in  LLVM)

Variable Documentation

◆ __cxa_demangle

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle but neither can depend on each other* libcxxabi needs the demangler to implement __cxa_demangle

Definition at line 22 of file README.txt.

◆ changes

test_demangle and llvm unittest Demangle The llvm directory should only get tests for stuff not included in the core library In the future we should probably move all the tests to LLVM It is also a really good idea to run libFuzzer after non trivial changes

Definition at line 60 of file README.txt.

◆ cpp

test_demangle cpp

Definition at line 55 of file README.txt.

◆ differences

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle but neither can depend on each other* libcxxabi needs the demangler to implement which is part of the itanium ABI spec* LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these differences

Definition at line 33 of file README.txt.

◆ libcxxabi

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle but neither can depend on each other* libcxxabi needs the demangler to implement which is part of the itanium ABI spec* LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these we want to keep the core generic demangling library identical between both copies to simplify development and testing If you re working on the generic then do the work first in then run the cp to llvm sh script in src demangle This script takes as an optional argument the path to and copies the changes you made to libcxxabi over Note that this script just blindly overwrites all changes to the generic library in so be careful Because the core demangler needs to work in libcxxabi

Definition at line 37 of file README.txt.

◆ Library

Itanium Name Demangler Library
Initial value:
==============================
Introduction
------------
This directory contains the generic itanium name demangler
library. The main purpose of the library is to demangle C++ symbols

Definition at line 2 of file README.txt.

Referenced by llvm::yaml::MappingTraits< const InterfaceFile * >::NormalizedTBD::NormalizedTBD().

◆ library

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle but neither can depend on each other* libcxxabi needs the demangler to implement which is part of the itanium ABI spec* LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these we want to keep the core generic demangling library identical between both copies to simplify development and testing If you re working on the generic library

Definition at line 36 of file README.txt.

◆ llvm

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle but neither can depend on each other* libcxxabi needs the demangler to implement which is part of the itanium ABI spec* LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these we want to keep the core generic demangling library identical between both copies to simplify development and testing If you re working on the generic then do the work first in then run the cp to llvm sh script in src demangle This script takes as an optional argument the path to and copies the changes you made to libcxxabi over Note that this script just blindly overwrites all changes to the generic library in llvm

Definition at line 38 of file README.txt.

◆ places

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle but neither can depend on each other* libcxxabi needs the demangler to implement which is part of the itanium ABI spec* LLVM needs a copy for a bunch of places

Definition at line 25 of file README.txt.

◆ symbols

Itanium Name Demangler i e convert the string _Z1fv into and both [sub] projects need to demangle symbols

◆ though

test_demangle and llvm unittest Demangle The llvm directory should only get tests for stuff not included in the core library In the future though

Definition at line 57 of file README.txt.

is
should just be implemented with a CLZ instruction Since there are other e that share this it would be best to implement this in a target independent as zero is the default value for the binary encoder e add r0 add r5 Register operands should be distinct That is
Definition: README.txt:725
name
static const char * name
Definition: SMEABIPass.cpp:49
contains
return AArch64::GPR64RegClass contains(Reg)
to
Should compile to
Definition: README.txt:449
library
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle but neither can depend on each other *libcxxabi needs the demangler to implement which is part of the itanium ABI spec *LLVM needs a copy for a bunch of and cannot rely on the system s __cxa_demangle because it a might not be and b may not be up to date on the latest language features The copy of the demangler in LLVM has some extra stuff that aren t needed in which depend on the shared generic components Despite these we want to keep the core generic demangling library identical between both copies to simplify development and testing If you re working on the generic library
Definition: README.txt:36
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::demangle
std::string demangle(const std::string &MangledName)
Attempt to demangle a string using different demangling schemes.
Definition: Demangle.cpp:29
symbols
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle symbols
Definition: README.txt:20
main
Here we need to push the arguments because they overwrite each other main()
Definition: README.txt:718
This
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical This
Definition: README.txt:418
of
Add support for conditional and other related patterns Instead of
Definition: README.txt:134