name string | code string | asm string | file string |
|---|---|---|---|
llvm::codeview::CVRecord<llvm::codeview::SymbolKind> llvm::codeview::SymbolSerializer::writeOneSymbol<llvm::codeview::ProcSym>(llvm::codeview::ProcSym&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, llvm::codeview::CodeViewContainer) | static CVSymbol writeOneSymbol(SymType &Sym, BumpPtrAllocator &Storage,
CodeViewContainer Container) {
RecordPrefix Prefix{uint16_t(Sym.Kind)};
CVSymbol Result(&Prefix, sizeof(Prefix));
SymbolSerializer Serializer(Storage, Container);
consumeError(Serializer.visitSymbolB... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10038, %rsp # imm = 0x10038
movq %rdi, %rbx
movzwl (%rdi), %eax
leaq 0x44(%rsp), %rcx
movw $0x2, (%rcx)
movw %ax, 0x2(%rcx)
leaq 0x18(%rsp), %r14
movq %rcx, (%r14)
movq $0x4, 0x8(%r14)
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x138f92
leaq 0x38(%rsp), %r12... | /llvm/DebugInfo/CodeView/SymbolSerializer.h |
llvm::Error llvm::codeview::SymbolDeserializer::deserializeAs<llvm::codeview::RegisterSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>, llvm::codeview::RegisterSym&) | static Error deserializeAs(CVSymbol Symbol, T &Record) {
// If we're just deserializing one record, then don't worry about alignment
// as there's nothing that comes after.
SymbolDeserializer S(nullptr, CodeViewContainer::ObjectFile);
if (auto EC = S.visitSymbolBegin(Symbol))
return EC;
if (au... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x1770d8(%rip), %r15 # 0x236560
addq $0x10, %r15
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
xorl %r12d, %r12d
movq %r12, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
movq %r12... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::Error llvm::codeview::SymbolDeserializer::deserializeAs<llvm::codeview::ProcRefSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>, llvm::codeview::ProcRefSym&) | static Error deserializeAs(CVSymbol Symbol, T &Record) {
// If we're just deserializing one record, then don't worry about alignment
// as there's nothing that comes after.
SymbolDeserializer S(nullptr, CodeViewContainer::ObjectFile);
if (auto EC = S.visitSymbolBegin(Symbol))
return EC;
if (au... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x176b3c(%rip), %r15 # 0x236560
addq $0x10, %r15
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
xorl %r12d, %r12d
movq %r12, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
movq %r12... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::Error llvm::codeview::SymbolDeserializer::deserializeAs<llvm::codeview::BlockSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>, llvm::codeview::BlockSym&) | static Error deserializeAs(CVSymbol Symbol, T &Record) {
// If we're just deserializing one record, then don't worry about alignment
// as there's nothing that comes after.
SymbolDeserializer S(nullptr, CodeViewContainer::ObjectFile);
if (auto EC = S.visitSymbolBegin(Symbol))
return EC;
if (au... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x1749c2(%rip), %r15 # 0x236560
addq $0x10, %r15
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
xorl %r12d, %r12d
movq %r12, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
movq %r12... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::codeview::CVRecord<llvm::codeview::SymbolKind> llvm::codeview::SymbolSerializer::writeOneSymbol<llvm::codeview::FrameCookieSym>(llvm::codeview::FrameCookieSym&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, llvm::codeview::CodeViewContainer) | static CVSymbol writeOneSymbol(SymType &Sym, BumpPtrAllocator &Storage,
CodeViewContainer Container) {
RecordPrefix Prefix{uint16_t(Sym.Kind)};
CVSymbol Result(&Prefix, sizeof(Prefix));
SymbolSerializer Serializer(Storage, Container);
consumeError(Serializer.visitSymbolB... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10038, %rsp # imm = 0x10038
movq %rdi, %rbx
movzwl (%rdi), %eax
leaq 0x44(%rsp), %rcx
movw $0x2, (%rcx)
movw %ax, 0x2(%rcx)
leaq 0x18(%rsp), %r14
movq %rcx, (%r14)
movq $0x4, 0x8(%r14)
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x138f92
leaq 0x38(%rsp), %r12... | /llvm/DebugInfo/CodeView/SymbolSerializer.h |
llvm::codeview::CVRecord<llvm::codeview::SymbolKind> llvm::codeview::SymbolSerializer::writeOneSymbol<llvm::codeview::BuildInfoSym>(llvm::codeview::BuildInfoSym&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, llvm::codeview::CodeViewContainer) | static CVSymbol writeOneSymbol(SymType &Sym, BumpPtrAllocator &Storage,
CodeViewContainer Container) {
RecordPrefix Prefix{uint16_t(Sym.Kind)};
CVSymbol Result(&Prefix, sizeof(Prefix));
SymbolSerializer Serializer(Storage, Container);
consumeError(Serializer.visitSymbolB... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10038, %rsp # imm = 0x10038
movq %rdi, %rbx
movzwl (%rdi), %eax
leaq 0x44(%rsp), %rcx
movw $0x2, (%rcx)
movw %ax, 0x2(%rcx)
leaq 0x18(%rsp), %r14
movq %rcx, (%r14)
movq $0x4, 0x8(%r14)
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x138f92
leaq 0x38(%rsp), %r12... | /llvm/DebugInfo/CodeView/SymbolSerializer.h |
llvm::Error llvm::codeview::SymbolDeserializer::deserializeAs<llvm::codeview::BuildInfoSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>, llvm::codeview::BuildInfoSym&) | static Error deserializeAs(CVSymbol Symbol, T &Record) {
// If we're just deserializing one record, then don't worry about alignment
// as there's nothing that comes after.
SymbolDeserializer S(nullptr, CodeViewContainer::ObjectFile);
if (auto EC = S.visitSymbolBegin(Symbol))
return EC;
if (au... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x1727c6(%rip), %r15 # 0x236560
addq $0x10, %r15
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
xorl %r12d, %r12d
movq %r12, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
movq %r12... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
void llvm::yaml::IO::processKey<llvm::CodeViewYAML::detail::SymbolRecordBase, llvm::yaml::EmptyContext>(char const*, llvm::CodeViewYAML::detail::SymbolRecordBase&, bool, llvm::yaml::EmptyContext&) | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
yamlize(*this, Val, Required, Ctx);
this->postflightKey(SaveInfo);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xf(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x78(%rax)
testb %al, %al
je 0xc535a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(... | /llvm/Support/YAMLTraits.h |
llvm::yaml::ScalarTraits<llvm::codeview::GUID, void>::input(llvm::StringRef, void*, llvm::codeview::GUID&) | StringRef ScalarTraits<GUID>::input(StringRef Scalar, void *Ctx, GUID &S) {
if (Scalar.size() != 38)
return "GUID strings are 38 characters long";
if (Scalar.front() != '{' || Scalar.back() != '}')
return "GUID is not enclosed in {}";
Scalar = Scalar.substr(1, Scalar.size() - 2);
SmallVector<StringRef, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpq $0x26, %rsi
jne 0xc5c99
leaq 0x9a608(%rip), %r14 # 0x160110
movl $0x1a, %r15d
cmpb $0x7b, (%rdi)
jne 0xc5ca6
cmpb $0x7d, 0x25(%rdi)
jne 0xc5ca6
movq %rcx, %rbx
incq %rdi
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq $0x24, 0x8(%ra... | /ObjectYAML/CodeViewYAMLTypes.cpp |
llvm::yaml::ScalarTraits<llvm::codeview::TypeIndex, void>::output(llvm::codeview::TypeIndex const&, void*, llvm::raw_ostream&) | [[nodiscard]] inline value_type read(const void *memory, endianness endian) {
value_type ret;
memcpy(&ret,
LLVM_ASSUME_ALIGNED(
memory, (detail::PickAlignment<value_type, alignment>::value)),
sizeof(value_type));
return byte_swap<value_type>(ret, endian);
} | movl (%rdi), %esi
movq %rdx, %rdi
jmp 0x117948
| /llvm/Support/Endian.h |
llvm::CodeViewYAML::detail::LeafRecordImpl<llvm::codeview::PointerRecord>::map(llvm::yaml::IO&) | void LeafRecordImpl<PointerRecord>::map(IO &IO) {
IO.mapRequired("ReferentType", Record.ReferentType);
IO.mapRequired("Attrs", Record.Attrs);
IO.mapOptional("MemberInfo", Record.MemberInfo);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe(%rdi), %rdx
leaq 0x97dfc(%rip), %rsi # 0x160e20
leaq 0xd(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0xba2a2
leaq 0x14(%rbx), %rdx
leaq 0x97dec(%rip), %rsi # 0x160e2d
leaq 0xe(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x... | /ObjectYAML/CodeViewYAMLTypes.cpp |
llvm::CodeViewYAML::detail::LeafRecordImpl<llvm::codeview::FuncIdRecord>::map(llvm::yaml::IO&) | void LeafRecordImpl<FuncIdRecord>::map(IO &IO) {
IO.mapRequired("ParentScope", Record.ParentScope);
IO.mapRequired("FunctionType", Record.FunctionType);
IO.mapRequired("Name", Record.Name);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x12(%rdi), %rdx
leaq 0x976f9(%rip), %rsi # 0x160ed2
leaq 0x5(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0xba2a2
leaq 0x16(%rbx), %rdx
leaq 0x963af(%rip), %rsi # 0x15fba5
leaq 0x6(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0xba2a2... | /ObjectYAML/CodeViewYAMLTypes.cpp |
std::enable_if<has_ScalarBitSetTraits<llvm::codeview::ModifierOptions>::value, void>::type llvm::yaml::yamlize<llvm::codeview::ModifierOptions>(llvm::yaml::IO&, llvm::codeview::ModifierOptions&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_ScalarBitSetTraits<T>::value, void>
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
bool DoClear;
if ( io.beginBitSetScalar(DoClear) ) {
if ( DoClear )
Val = T();
ScalarBitSetTraits<T>::bitset(io, Val);
io.endBitSetScalar();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x7(%rsp), %rsi
callq *0xc0(%rax)
testb %al, %al
je 0xcc7f9
cmpb $0x1, 0x7(%rsp)
jne 0xcc7e2
movw $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc893a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xd0(%rax)
addq $0x8, %rsp
popq %r... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::CodeViewYAML::MemberRecord, std::allocator<llvm::CodeViewYAML::MemberRecord>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::CodeViewYAML::MemberRecord, std::allocator<llvm::CodeViewYAML::MemberRecord>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vect... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x4, %rcx
testb %al, %al
cmovel %ebp, %ecx
testl %ecx, %ecx
je... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<llvm::SmallVector<llvm::codeview::TypeIndex, 5u>>::value, void>::type llvm::yaml::yamlize<llvm::SmallVector<llvm::codeview::TypeIndex, 5u>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::SmallVector<llvm::codeview::TypeIndex, 5u>&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xcd282
movl 0x8(%r15), %ebp
testl %ebp, %ebp
je 0xcd2e7
movl %ebp, %ebp
... | /llvm/Support/YAMLTraits.h |
llvm::CodeViewYAML::detail::LeafRecordImpl<llvm::codeview::ArgListRecord>::toCodeViewRecord(llvm::codeview::AppendingTypeTableBuilder&) const | CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
TS.writeLeafType(Record);
return CVType(TS.records().back());
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x10(%rdi), %rsi
leaq 0x10(%rbx), %rdi
callq 0x133e1a
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x12cd68
movq %rbx, %rdi
callq 0x12cd60
shlq $0x4, %rdx
movq -0x10(%rax,%rdx), %rcx
movq -0x8(%rax,%rdx), %rdx
movq %rcx, %rax
addq $0x10, %... | /ObjectYAML/CodeViewYAMLTypes.cpp |
llvm::Error llvm::codeview::TypeDeserializer::deserializeAs<llvm::codeview::ArgListRecord>(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::ArgListRecord&) | static Error deserializeAs(CVType &CVT, T &Record) {
Record.Kind = static_cast<TypeRecordKind>(CVT.kind());
MappingInfo I(CVT.content());
if (auto EC = I.Mapping.visitTypeBegin(CVT))
return EC;
if (auto EC = I.Mapping.visitKnownRecord(CVT, Record))
return EC;
if (auto EC = I.Mapping.visi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
cmpq $0x4, %rax
jae 0xce14a
xorl %esi, %esi
jmp 0xce14e
movzwl 0x2(%rcx), %esi
movw %si, (%rdx)
addq $-0x4, %rax
addq $0x4, %rcx
leaq 0x168588(%rip), %rsi # 0x2366... | /llvm/DebugInfo/CodeView/TypeDeserializer.h |
llvm::CodeViewYAML::detail::LeafRecordImpl<llvm::codeview::ArrayRecord>::toCodeViewRecord(llvm::codeview::AppendingTypeTableBuilder&) const | CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
TS.writeLeafType(Record);
return CVType(TS.records().back());
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x10(%rdi), %rsi
leaq 0x10(%rbx), %rdi
callq 0x133fa6
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x12cd68
movq %rbx, %rdi
callq 0x12cd60
shlq $0x4, %rdx
movq -0x10(%rax,%rdx), %rcx
movq -0x8(%rax,%rdx), %rdx
movq %rcx, %rax
addq $0x10, %... | /ObjectYAML/CodeViewYAMLTypes.cpp |
llvm::CodeViewYAML::detail::LeafRecordImpl<llvm::codeview::MemberFuncIdRecord>::toCodeViewRecord(llvm::codeview::AppendingTypeTableBuilder&) const | CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
TS.writeLeafType(Record);
return CVType(TS.records().back());
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x10(%rdi), %rsi
leaq 0x10(%rbx), %rdi
callq 0x134d92
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x12cd68
movq %rbx, %rdi
callq 0x12cd60
shlq $0x4, %rdx
movq -0x10(%rax,%rdx), %rcx
movq -0x8(%rax,%rdx), %rdx
movq %rcx, %rax
addq $0x10, %... | /ObjectYAML/CodeViewYAMLTypes.cpp |
llvm::CodeViewYAML::detail::LeafRecordImpl<llvm::codeview::BuildInfoRecord>::~LeafRecordImpl() | explicit LeafRecordImpl(TypeLeafKind K)
: LeafRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x168e49(%rip), %rax # 0x238610
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0xcf7e0
callq 0x26150
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x260c0
| /ObjectYAML/CodeViewYAMLTypes.cpp |
llvm::CodeViewYAML::detail::LeafRecordImpl<llvm::codeview::EndPrecompRecord>::toCodeViewRecord(llvm::codeview::AppendingTypeTableBuilder&) const | CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
TS.writeLeafType(Record);
return CVType(TS.records().back());
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0xc(%rdi), %rsi
leaq 0x10(%rbx), %rdi
callq 0x1359f2
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x12cd68
movq %rbx, %rdi
callq 0x12cd60
shlq $0x4, %rdx
movq -0x10(%rax,%rdx), %rcx
movq -0x8(%rax,%rdx), %rdx
movq %rcx, %rax
addq $0x10, %r... | /ObjectYAML/CodeViewYAMLTypes.cpp |
llvm::yaml::ScalarEnumerationTraits<llvm::COFF::MachineTypes, void>::enumeration(llvm::yaml::IO&, llvm::COFF::MachineTypes&) | void ScalarEnumerationTraits<COFF::MachineTypes>::enumeration(
IO &IO, COFF::MachineTypes &Value) {
ECase(IMAGE_FILE_MACHINE_UNKNOWN);
ECase(IMAGE_FILE_MACHINE_AM33);
ECase(IMAGE_FILE_MACHINE_AMD64);
ECase(IMAGE_FILE_MACHINE_ARM);
ECase(IMAGE_FILE_MACHINE_ARMNT);
ECase(IMAGE_FILE_MACHINE_ARM64);
ECase... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90521(%rip), %rsi # 0x161246
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0d38
movl $0x0, (%rbx)
movq (%r14), %rax
movq %r... | /ObjectYAML/COFFYAML.cpp |
llvm::yaml::ScalarEnumerationTraits<llvm::COFF::SymbolComplexType, void>::enumeration(llvm::yaml::IO&, llvm::COFF::SymbolComplexType&) | void ScalarEnumerationTraits<COFF::SymbolComplexType>::enumeration(
IO &IO, COFF::SymbolComplexType &Value) {
ECase(IMAGE_SYM_DTYPE_NULL);
ECase(IMAGE_SYM_DTYPE_POINTER);
ECase(IMAGE_SYM_DTYPE_FUNCTION);
ECase(IMAGE_SYM_DTYPE_ARRAY);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8fe16(%rip), %rsi # 0x16191d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1b1a
movl $0x0, (%rbx)
movq (%r14), %rax
movq %r... | /ObjectYAML/COFFYAML.cpp |
llvm::yaml::ScalarBitSetTraits<llvm::COFF::Characteristics, void>::bitset(llvm::yaml::IO&, llvm::COFF::Characteristics&) | void ScalarBitSetTraits<COFF::Characteristics>::bitset(
IO &IO, COFF::Characteristics &Value) {
BCase(IMAGE_FILE_RELOCS_STRIPPED);
BCase(IMAGE_FILE_EXECUTABLE_IMAGE);
BCase(IMAGE_FILE_LINE_NUMS_STRIPPED);
BCase(IMAGE_FILE_LOCAL_SYMS_STRIPPED);
BCase(IMAGE_FILE_AGGRESSIVE_WS_TRIM);
BCase(IMAGE_FILE_LARGE... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
movl (%rbx), %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f5f2(%rip), %rsi # 0x1620d3
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2af1
orb $0x1, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
c... | /ObjectYAML/COFFYAML.cpp |
llvm::yaml::MappingTraits<llvm::object::coff_load_config_code_integrity>::mapping(llvm::yaml::IO&, llvm::object::coff_load_config_code_integrity&) | void MappingTraits<object::coff_load_config_code_integrity>::mapping(
IO &IO, object::coff_load_config_code_integrity &S) {
IO.mapOptional("Flags", S.Flags);
IO.mapOptional("Catalog", S.Catalog);
IO.mapOptional("CatalogOffset", S.CatalogOffset);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x89bce(%rip), %rsi # 0x15dbd1
leaq 0x5(%rsp), %r8
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xbaace
leaq 0x2(%rbx), %rdx
leaq 0x8e882(%rip), %rsi # 0x16289f
leaq 0x6(%rsp), %r8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xbaace
addq $0x4, %rbx
leaq 0... | /ObjectYAML/COFFYAML.cpp |
void llvm::yaml::IO::processKey<llvm::COFF::SymbolComplexType, llvm::yaml::EmptyContext>(char const*, llvm::COFF::SymbolComplexType&, bool, llvm::yaml::EmptyContext&) | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
yamlize(*this, Val, Required, Ctx);
this->postflightKey(SaveInfo);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xf(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x78(%rax)
testb %al, %al
je 0xd60ff
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd1ae2
movq (%rbx), %ra... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_ScalarBitSetTraits<llvm::COFF::SectionCharacteristics>::value, void>::type llvm::yaml::yamlize<llvm::COFF::SectionCharacteristics>(llvm::yaml::IO&, llvm::COFF::SectionCharacteristics&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_ScalarBitSetTraits<T>::value, void>
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
bool DoClear;
if ( io.beginBitSetScalar(DoClear) ) {
if ( DoClear )
Val = T();
ScalarBitSetTraits<T>::bitset(io, Val);
io.endBitSetScalar();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x7(%rsp), %rsi
callq *0xc0(%rax)
testb %al, %al
je 0xd69e0
cmpb $0x1, 0x7(%rsp)
jne 0xd69c9
movl $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2da0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xd0(%rax)
addq $0x8, %rsp
popq %r... | /llvm/Support/YAMLTraits.h |
writeVariableSizedInteger(unsigned long, unsigned long, llvm::raw_ostream&, bool) | static Error writeVariableSizedInteger(uint64_t Integer, size_t Size,
raw_ostream &OS, bool IsLittleEndian) {
if (8 == Size)
writeInteger((uint64_t)Integer, OS, IsLittleEndian);
else if (4 == Size)
writeInteger((uint32_t)Integer, OS, IsLittleEndian);
else if (2 == Si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq -0x1(%rdx), %rax
cmpq $0x7, %rax
ja 0xd90c1
leaq 0x89db8(%rip), %rdx # 0x162df0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rax
movb %sil, (%rax)
movl $0x1, %edx
jmp 0xd... | /ObjectYAML/DWARFEmitter.cpp |
emitPubSection(llvm::raw_ostream&, llvm::DWARFYAML::PubSection const&, bool, bool) | static Error emitPubSection(raw_ostream &OS, const DWARFYAML::PubSection &Sect,
bool IsLittleEndian, bool IsGNUPubSec = false) {
writeInitialLength(Sect.Format, Sect.Length, OS, IsLittleEndian);
writeInteger((uint16_t)Sect.Version, OS, IsLittleEndian);
writeInteger((uint32_t)Sect.UnitO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
movzbl (%rdx), %edi
movq 0x8(%rdx), %rsi
movq %r15, %rdx
callq 0xd8f6a
movl 0x10(%r12), %eax
movl %eax, %ecx
rolw $0x8, %cx
testl %ebp, %ebp
cmovnel %e... | /ObjectYAML/DWARFEmitter.cpp |
llvm::SmallVectorImpl<unsigned char>::operator=(llvm::SmallVectorImpl<unsigned char>&&) | SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xde206
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x18(%r14), %rax
cmpq %rax, %rsi
je 0xde188
movq %rbx, %rdi
movq %r14, %rsi
callq 0xde216
jmp 0xde206
movq 0x8(%r14), %r15
movq 0x8(%rbx), %r12
cmpq %r15, %r12
jae 0xde1b9
cmpq %r15, ... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<llvm::SMFixIt, false>::grow(unsigned long) | void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %rsp, %r12
movl $0x30, %ecx
movq %r15, %rsi
movq %r12, %r8
callq 0x10aaae
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde2ca
movq (%r12), %r12
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xde2b6
callq 0... | /llvm/ADT/SmallVector.h |
llvm::yaml::MappingTraits<llvm::DWARFYAML::ARange>::mapping(llvm::yaml::IO&, llvm::DWARFYAML::ARange&) | void MappingTraits<DWARFYAML::ARange>::mapping(IO &IO,
DWARFYAML::ARange &ARange) {
IO.mapOptional("Format", ARange.Format, dwarf::DWARF32);
IO.mapOptional("Length", ARange.Length);
IO.mapRequired("Version", ARange.Version);
IO.mapRequired("CuOffset", ARange.CuOffs... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x7(%rsp), %rcx
movb %bpl, (%rcx)
leaq 0x83671(%rip), %rsi # 0x1633bc
leaq 0x8(%rsp), %r15
movq %rbx, %rdx
xorl %r8d, %r8d
movq %r15, %r9
callq 0xec932
leaq 0x8(%rbx), %rdx
movb %bpl, 0x8(%r15)
leaq 0x8... | /ObjectYAML/DWARFYAML.cpp |
llvm::yaml::MappingTraits<llvm::DWARFYAML::Unit>::mapping(llvm::yaml::IO&, llvm::DWARFYAML::Unit&) | void MappingTraits<DWARFYAML::Unit>::mapping(IO &IO, DWARFYAML::Unit &Unit) {
IO.mapOptional("Format", Unit.Format, dwarf::DWARF32);
IO.mapOptional("Length", Unit.Length);
IO.mapRequired("Version", Unit.Version);
if (Unit.Version >= 5)
IO.mapRequired("UnitType", Unit.Type);
IO.mapOptional("AbbrevTableID",... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x7(%rsp), %rcx
movb %bpl, (%rcx)
leaq 0x8335f(%rip), %rsi # 0x1633bc
leaq 0x8(%rsp), %r15
movq %rbx, %rdx
xorl %r8d, %r8d
movq %r15, %r9
callq 0xec932
leaq 0x8(%rbx), %rdx
movb %bpl, 0x8(%r15)
leaq 0x8... | /ObjectYAML/DWARFYAML.cpp |
llvm::yaml::MappingTraits<llvm::DWARFYAML::LoclistEntry>::mapping(llvm::yaml::IO&, llvm::DWARFYAML::LoclistEntry&) | void MappingTraits<DWARFYAML::LoclistEntry>::mapping(
IO &IO, DWARFYAML::LoclistEntry &LoclistEntry) {
IO.mapRequired("Operator", LoclistEntry.Operator);
IO.mapOptional("Values", LoclistEntry.Values);
IO.mapOptional("DescriptionsLength", LoclistEntry.DescriptionsLength);
IO.mapOptional("Descriptions", Locli... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8042d(%rip), %rsi # 0x160ccb
leaq 0x10(%rsp), %r8
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xf11d0
leaq 0x8(%rbx), %rdx
leaq 0x8c26a(%rip), %rsi # 0x16cb25
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0xe83fe
le... | /ObjectYAML/DWARFYAML.cpp |
void llvm::yaml::IO::processKeyWithDefault<std::vector<llvm::DWARFYAML::StringOffsetsTable, std::allocator<llvm::DWARFYAML::StringOffsetsTable>>, llvm::yaml::EmptyContext>(char const*, std::optional<std::vector<llvm::DWARFYAML::StringOffsetsTable, std::allocator<llvm::DWARFYAML::StringOffsetsTable>>>&, std::optional<st... | void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
const std::optional<T> &DefaultValue,
bool Required, Context &Ctx) {
assert(!DefaultValue && "std::optional<T> shouldn't have a value!");
void *SaveInfo;
bool UseDefault = true;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movb $0x1, 0xf(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r12d
movb 0x18(%r14), %r13b
movq (%rbx), %rax
movq %rbx, %rdi... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::DWARFYAML::ListTable<llvm::DWARFYAML::RnglistEntry>, std::allocator<llvm::DWARFYAML::ListTable<llvm::DWARFYAML::RnglistEntry>>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::DWARFYAML::ListTable<llvm::DWARFYAML::RnglistEntry>, std::allocator<llvm::DWARFYA... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xe3192
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x5, %rax
imull $0xaaaaaaab, %eax, %... | /llvm/Support/YAMLTraits.h |
llvm::yaml::MappingTraits<llvm::DWARFYAML::ListEntries<llvm::DWARFYAML::LoclistEntry>>::validate[abi:cxx11](llvm::yaml::IO&, llvm::DWARFYAML::ListEntries<llvm::DWARFYAML::LoclistEntry>&) | std::string MappingTraits<DWARFYAML::ListEntries<EntryType>>::validate(
IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries) {
if (ListEntries.Entries && ListEntries.Content)
return "Entries and Content can't be used together";
return "";
} | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x18(%rdx)
jne 0xe46e4
cmpb $0x1, 0x38(%rdx)
jne 0xe46e4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x7ee9b(%rip), %rsi # 0x163573
leaq 0x7eebe(%rip), %rdx # 0x16359d
movq %rbx, %rdi
jmp 0xe46f8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xed97c(%rip), %rdx # 0x1d20... | /ObjectYAML/DWARFYAML.cpp |
llvm::yaml::MappingTraits<llvm::DWARFYAML::ListEntries<llvm::DWARFYAML::LoclistEntry>>::mapping(llvm::yaml::IO&, llvm::DWARFYAML::ListEntries<llvm::DWARFYAML::LoclistEntry>&) | void MappingTraits<DWARFYAML::ListEntries<EntryType>>::mapping(
IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries) {
IO.mapOptional("Entries", ListEntries.Entries);
IO.mapOptional("Content", ListEntries.Content);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x78788(%rip), %rsi # 0x15cea0
leaq 0x10(%rsp), %r15
movq %rbx, %rdx
movq %r15, %rcx
callq 0xe475a
addq $0x20, %rbx
movb $0x0, 0x18(%r15)
leaq 0x7a4e6(%rip), %rsi # 0x15ec1e
leaq 0x10(%rsp), %rcx
leaq 0xf(%rsp), %r9
movq %r14... | /ObjectYAML/DWARFYAML.cpp |
std::enable_if<has_SequenceTraits<std::vector<llvm::DWARFYAML::Abbrev, std::allocator<llvm::DWARFYAML::Abbrev>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::DWARFYAML::Abbrev, std::allocator<llvm::DWARFYAML::Abbrev>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::DWARFYAML::Abbrev, std::all... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xe5506
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x4, %rax
imull $0xaaaaaaab, %eax, %... | /llvm/Support/YAMLTraits.h |
llvm::yaml::ScalarEnumerationTraits<llvm::dwarf::Tag, void>::enumeration(llvm::yaml::IO&, llvm::dwarf::Tag&) | static void enumeration(IO &io, dwarf::Tag &value) {
#include "llvm/BinaryFormat/Dwarf.def"
io.enumFallback<Hex16>(value);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
cmpw $0x0, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dd42(%rip), %rsi # 0x16359e
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe586e
movw $0x0, (%rbx)
movq (%r14), %rax
movq %r... | /llvm/ObjectYAML/DWARFYAML.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::DWARFYAML::AttributeAbbrev, std::allocator<llvm::DWARFYAML::AttributeAbbrev>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::DWARFYAML::AttributeAbbrev, std::allocator<llvm::DWARFYAML::AttributeAbbrev>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vect... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x4, %rcx
testb %al, %al
cmovel %ebp, %ecx
testl %ecx, %ecx
je... | /llvm/Support/YAMLTraits.h |
llvm::yaml::ScalarEnumerationTraits<llvm::dwarf::Form, void>::enumeration(llvm::yaml::IO&, llvm::dwarf::Form&) | static void enumeration(IO &io, dwarf::Form &value) {
#include "llvm/BinaryFormat/Dwarf.def"
io.enumFallback<Hex16>(value);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
cmpw $0x1, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c9b6(%rip), %rsi # 0x164034
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7690
movw $0x1, (%rbx)
movq (%r14), %rax
movq %r... | /llvm/ObjectYAML/DWARFYAML.h |
llvm::APInt::trunc(unsigned int) const | APInt APInt::trunc(unsigned width) const {
assert(width <= BitWidth && "Invalid APInt Truncate request");
if (width <= APINT_BITS_PER_WORD)
return APInt(width, getRawData()[0]);
if (width == BitWidth)
return *this;
APInt Result(getMemory(getNumWords(width)), width);
// Copy full words.
unsigned ... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x40, %edx
ja 0xf8ddf
cmpl $0x41, %eax
jb 0xf8dce
movq (%r14), %r14
movq (%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
callq 0xf89ac
jmp 0xf8e45
cmpl %ebp, %eax
jne 0xf8df0
movq %rbx, %rdi
movq %r1... | /Support/APInt.cpp |
llvm::BinaryStreamReader::skip(unsigned long) | Error BinaryStreamReader::skip(uint64_t Amount) {
if (Amount > bytesRemaining())
return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
Offset += Amount;
return Error::success();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x30(%rsi)
jne 0xfa9e6
movq 0x28(%r14), %rax
jmp 0xfa9fd
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xfa9fb
movq (%rdi), %rax
callq *0x28(%rax)
subq 0x20(%r14), %rax
jmp 0xfa9fd
xorl %eax, %eax
movq 0x38(%r14), %rcx
subq %rcx, %r... | /Support/BinaryStreamReader.cpp |
llvm::BinaryStreamWriter::padToAlignment(unsigned int) | Error BinaryStreamWriter::padToAlignment(uint32_t Align) {
uint64_t NewOffset = alignTo(Offset, Align);
const uint64_t ZerosSize = 64;
static constexpr char Zeros[ZerosSize] = {};
while (Offset < NewOffset)
if (auto E = writeArray(
ArrayRef<char>(Zeros, std::min(ZerosSize, NewOffset - Offset))))... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
subq %rcx, %rax
movl %edx, %esi
xorl %edx, %edx
divq %rsi
movq %rax, %r15
addq %rcx, %r15
imulq %rsi, %r15
movl $0x40, %r13d
leaq 0x6c08e(%rip), %r12 # 0x1676c0
mov... | /Support/BinaryStreamWriter.cpp |
llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | movl %edx, %eax
movq %rsi, %r8
movl 0x80(%rdi), %edx
testl %eax, %eax
je 0xfba45
subq $0x18, %rsp
movb 0x94(%rdi), %al
leaq 0x8(%rsp), %rcx
movb %al, 0xc(%rcx)
movl 0x90(%rdi), %eax
movl %eax, 0x8(%rcx)
leaq 0x139acf(%rip), %rax # 0x235500
addq $0x10, %rax
movq %rax, (%rcx)
movq %rdi, %rsi
callq 0x100fb0
addq $0x18,... | /llvm/Support/CommandLine.h |
llvm::cl::parser<unsigned long>::parse(llvm::cl::Option&, llvm::StringRef, llvm::StringRef, unsigned long&) | bool parser<unsigned long>::parse(Option &O, StringRef ArgName, StringRef Arg,
unsigned long &Value) {
if (Arg.getAsInteger(0, Value))
return O.error("'" + Arg + "' value invalid for ulong argument!");
return false;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rsi, %r14
leaq 0x8(%rsp), %rcx
movq %r8, %rdi
movq %r9, %rsi
xorl %edx, %edx
callq 0x10c0c8
movl %eax, %ebx
testb %al, %al
je 0x1005fc
leaq 0x30(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0x674f2(%rip), %rc... | /Support/CommandLine.cpp |
llvm::SmallPtrSetImpl<llvm::cl::SubCommand*>::insert(llvm::cl::SubCommand*) | std::pair<iterator, bool> insert(PtrType Ptr) {
auto p = insert_imp(PtrTraits::getAsVoidPointer(Ptr));
return std::make_pair(makeIterator(p.first), p.second);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10276c
movq 0x8(%r14), %rcx
xorl %esi, %esi
cmpq (%r14), %rcx
sete %sil
movl 0x10(%r14,%rsi,4), %esi
leaq (%rcx,%rsi,8), %rcx
cmpq %rax, %rcx
je 0x1027ff
cmpq $-0x2, (%rax)
jb 0x1027ff
addq $0x8, %rax
cmpq %rcx, %ra... | /llvm/ADT/SmallPtrSet.h |
void llvm::cl::apply<llvm::cl::alias, char [2], llvm::cl::desc, llvm::cl::aliasopt, llvm::cl::MiscFlags>(llvm::cl::alias*, char const (&) [2], llvm::cl::desc const&, llvm::cl::aliasopt const&, llvm::cl::MiscFlags const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x26280
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xfc1bc
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movq (%r14), %rsi
movq %r13, %rdi
callq 0x104974... | /llvm/Support/CommandLine.h |
llvm::SmallVectorImpl<llvm::DebugCounter::Chunk>::assignRemote(llvm::SmallVectorImpl<llvm::DebugCounter::Chunk>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x1079df
callq 0x26150
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r1... | /llvm/ADT/SmallVector.h |
void llvm::cl::apply<llvm::cl::opt<unsigned long, false, llvm::cl::parser<unsigned long>>, char [9], llvm::cl::value_desc, llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::initializer<int>>(llvm::cl::opt<unsigned long, false, llvm::cl::parser<unsigned long>>*, char const (&) [9], llvm::cl::value_desc const&, llvm::cl:... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26280
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xfc1bc
movups (%r13), %xmm0
movups %xmm0, 0x30(%r14)
movl (%r12)... | /llvm/Support/CommandLine.h |
std::pair<llvm::StringMapIterator<std::pair<llvm::yaml::Input::HNode*, llvm::SMRange>>, bool> llvm::StringMap<std::pair<llvm::yaml::Input::HNode*, llvm::SMRange>, llvm::MallocAllocator>::try_emplace_with_hash<>(llvm::StringRef, unsigned int) | std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x10b528
movl %eax, %ebp
movq (%r14), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,8), %rbx
movq (%rbx), %rax
cmpq $-0x8, %rax
je 0x117515
testq %rax, %rax
je 0x117519
jmp 0x117506
movq 0x8(%rbx), ... | /llvm/ADT/StringMap.h |
llvm::raw_ostream::write_uuid(unsigned char const*) | raw_ostream &raw_ostream::write_uuid(const uuid_t UUID) {
for (int Idx = 0; Idx < 16; ++Idx) {
*this << format("%02" PRIX32, UUID[Idx]);
if (Idx == 3 || Idx == 5 || Idx == 7 || Idx == 9)
*this << "-";
}
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
leaq 0x524c8(%rip), %rbp # 0x169e8c
leaq 0x11dbbd(%rip), %r12 # 0x235588
addq $0x10, %r12
movq %rsp, %r15
movq %rbp, 0x8(%rsp)
movq %r12, (%rsp)
movb (%r14,%r13), %al
movb %al, 0x1... | /Support/raw_ostream.cpp |
llvm::raw_ostream::operator<<(llvm::FormattedString const&) | raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
unsigned LeftIndent = 0;
unsigned RightIndent = 0;
const ssize_t Difference = FS.Width - FS.Str.size();
if (Difference > 0) {
switch (FS.Justify) {
case FormattedString::JustifyNone:
break;
case FormattedString::JustifyLeft:
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl 0x10(%rsi), %r14d
subq 0x8(%rsi), %r14
xorl %esi, %esi
testq %r14, %r14
jle 0x118162
movl 0x14(%r15), %eax
cmpl $0x3, %eax
je 0x11818c
cmpl $0x2, %eax
je 0x11815f
cmpl $0x1, %eax
jne 0x118162
jmp 0x118165
movl %r14d, %esi
xorl %r14d, %r14d
movq %rbx,... | /Support/raw_ostream.cpp |
llvm::raw_ostream::write_zeros(unsigned int) | raw_ostream &raw_ostream::write_zeros(unsigned NumZeros) {
return write_padding<'\0'>(*this, NumZeros);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x50, %esi
jae 0x11833a
movl %ebp, %edx
leaq 0x51bf0(%rip), %rsi # 0x169f20
movq %rbx, %rdi
callq 0x117ecc
jmp 0x118361
leaq 0x51bdf(%rip), %r14 # 0x169f20
cmpl $0x4f, %ebp
movl $0x4f, %r15d
cmovbl %ebp, %r15d
movq %rbx... | /Support/raw_ostream.cpp |
getFD(llvm::StringRef, std::error_code&, llvm::sys::fs::CreationDisposition, llvm::sys::fs::FileAccess, llvm::sys::fs::OpenFlags) | static int getFD(StringRef Filename, std::error_code &EC,
sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
sys::fs::OpenFlags Flags) {
assert((Access & sys::fs::FA_Write) &&
"Cannot make a raw_ostream from a read-only descriptor!");
// Handle "-" as stdout. ... | pushq %rbp
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebp
movq %rdx, %rbx
cmpq $0x1, %rsi
jne 0x118516
cmpb $0x2d, (%rdi)
jne 0x118516
callq 0x265f0
movl $0x0, (%rbx)
movq %rax, 0x8(%rbx)
movl %ebp, %edi
callq 0x11dfc6
movl $0x1, %ecx
jmp 0x118579
leaq 0x10(%rsp), %rax
testb $0x1, %r8b
jne 0x11853f
movw $0x105, 0x20(%rax)... | /Support/raw_ostream.cpp |
llvm::raw_fd_ostream::pwrite_impl(char const*, unsigned long, unsigned long) | void raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size,
uint64_t Offset) {
uint64_t Pos = tell();
seek(Offset);
write(Ptr, Size);
seek(Pos);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, %r13
addq 0x20(%r12), %r13
subq 0x10(%r12), %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x118716
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x11... | /Support/raw_ostream.cpp |
llvm::raw_string_ostream::reserveExtraSpace(unsigned long) | void reserveExtraSpace(uint64_t ExtraSize) override {
OS.reserve(tell() + ExtraSize);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x30(%rdi), %r15
callq *0x50(%rax)
addq %rax, %rbx
addq 0x20(%r14), %rbx
subq 0x10(%r14), %rbx
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x265e0
| /llvm/Support/raw_ostream.h |
llvm::xxh3_64bits(llvm::ArrayRef<unsigned char>) | uint64_t llvm::xxh3_64bits(ArrayRef<uint8_t> data) {
auto *in = data.data();
size_t len = data.size();
if (len <= 16)
return XXH3_len_0to16_64b(in, len, kSecret, 0);
if (len <= 128)
return XXH3_len_17to128_64b(in, len, kSecret, 0);
if (len <= XXH3_MIDSIZE_MAX)
return XXH3_len_129to240_64b(in, len,... | cmpq $0x10, %rsi
ja 0x118ce0
cmpq $0x9, %rsi
jb 0x118e85
movabsq $0x6782737bea4239b9, %rcx # imm = 0x6782737BEA4239B9
xorq (%rdi), %rcx
movabsq $-0x50a943c4f669adc6, %rax # imm = 0xAF56BC3B0996523A
xorq -0x8(%rdi,%rsi), %rax
addq %rax, %rsi
mulq %rcx
bswapq %rcx
addq %rcx, %rsi
xorq %rax, %rdx
addq %rsi, %rdx
movq %rdx... | /Support/xxhash.cpp |
llvm::sys::path::reverse_iterator::operator++() | reverse_iterator &reverse_iterator::operator++() {
size_t root_dir_pos = root_dir_start(Path, S);
// Skip separators unless it's the root directory.
size_t end_pos = Position;
while (end_pos > 0 && (end_pos - 1) != root_dir_pos &&
is_separator(Path[end_pos - 1], S))
--end_pos;
// Treat trailing... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
callq 0x11975c
movq (%rbx), %rdi
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x1196b7
movl 0x28(%rbx), %edx
leaq 0x1(%rax), %r14
movq %rcx, %rsi
cmpq %rsi, %r14
je 0x1196bf
cmpl $0x2, %edx
setae %r8b
movb -0x1(%r... | /Support/Path.cpp |
llvm::sys::path::root_path(llvm::StringRef, llvm::sys::path::Style) | StringRef root_path(StringRef path, Style style) {
const_iterator b = begin(path, style), pos = b, e = end(path);
if (b != e) {
bool has_net =
b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
bool has_drive = is_style_windows(style) && b->ends_with(":");
if (has_net || has_d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x119392
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movaps %xmm2, 0x20(%rsp)
mov... | /Support/Path.cpp |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long>(unsigned long&, char*, char*, long) | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
if (!store_and_advance(buffer_ptr, buffer_end, data)) {
// Check for skew which prevents the buffer from being packed, and do
// a partial store into the buffer to fill it. This is only a concern
// with the variadic ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, (%rsp)
leaq 0x8(%rdx), %r13
cmpq %rcx, %r13
jbe 0x11cb8c
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %r15
subq %rdx, %r15
movq %rsp, %rsi
movq %rdx, %rdi
movq %r15, %rdx
callq 0x26080
cmpq $0x0, (%r12)
je 0x11cb91
leaq 0x40... | /llvm/ADT/Hashing.h |
llvm::sys::ExecuteAndWait(llvm::StringRef, llvm::ArrayRef<llvm::StringRef>, std::optional<llvm::ArrayRef<llvm::StringRef>>, llvm::ArrayRef<std::optional<llvm::StringRef>>, unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*, std::optional<llvm::sys::Process... | int sys::ExecuteAndWait(StringRef Program, ArrayRef<StringRef> Args,
std::optional<ArrayRef<StringRef>> Env,
ArrayRef<std::optional<StringRef>> Redirects,
unsigned SecondsToWait, unsigned MemoryLimit,
std::string *ErrMsg, bo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r14
movq %r8, 0x40(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0xb8(%rsp), %r15
leaq 0x4c(%rsp), %rdi
callq 0x11db4c
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x90(%rsp), %xmm0
movups %x... | /Support/Program.cpp |
llvm::ConvertUTF16toUTF8(unsigned short const**, unsigned short const*, unsigned char**, unsigned char*, llvm::ConversionFlags) | ConversionResult ConvertUTF16toUTF8 (
const UTF16** sourceStart, const UTF16* sourceEnd,
UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
ConversionResult result = conversionOK;
const UTF16* source = *sourceStart;
UTF8* target = *targetStart;
while (source < sourceEnd) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r15
movq (%rdx), %r14
xorl %eax, %eax
cmpq %rsi, %r15
jae 0x120b0d
leaq 0x49e99(%rip), %r9 # 0x16a888
leaq 0x49eca(%rip), %r10 # 0x16a8c0
leaq 0x2(%r15), %r11
movzwl (%r15), %ebx
movl %ebx, %ebp
andl $0xfc00, %ebp # imm =... | /Support/ConvertUTF.cpp |
std::vector<unsigned short, std::allocator<unsigned short>>& GetOrCreateOffsetCache<unsigned short>(void*&, llvm::MemoryBuffer*) | static std::vector<T> &GetOrCreateOffsetCache(void *&OffsetCache,
MemoryBuffer *Buffer) {
if (OffsetCache)
return *static_cast<std::vector<T> *>(OffsetCache);
// Lazily fill in the offset cache.
auto *Offsets = new std::vector<T>();
size_t Sz = Buffer->getBuffe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
jne 0x122cb3
movq %rsi, %r15
movq %rdi, %rbx
movl $0x18, %edi
callq 0x26100
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x8(%r15), %r12
movq 0x10(%r15), %r13
subq %r12, ... | /Support/SourceMgr.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [25], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [25], llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x2c0de
movb $0x0, 0x80(%r14)
movq $0x0, 0x90(%r14)
leaq 0x11108b(%rip), %rax # 0x2354e0
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x1149e9(%ri... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [22], llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [22], llvm::cl::OptionHidden const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x26280
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xfc1bc
movl (%r14), %eax
movzwl 0xa(%r12), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
mo... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>, unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>::moveFromOldBuckets(llvm::detail::Den... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x12571d
movq (%r15), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x3, %ecx
negq %rcx
addq %rd... | /llvm/ADT/DenseMap.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [39], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [39], llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26280
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xfc1bc
movq (%r12), %rax
movb (%rax), %cl
movb %cl, 0x80(%r14)
movb $0x1, 0x91(%r14)
movb (%rax), %al... | /llvm/Support/CommandLine.h |
llvm::cl::opt<(anonymous namespace)::PassDebugLevel, false, llvm::cl::parser<(anonymous namespace)::PassDebugLevel>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
movl $0x0, (%rsp)
movq 0xa0(%rdi), %rax
cmpq $0x0, 0x18(%rax)
cmovneq %r8, %r15
cmovneq %r9, %r14
movl 0xb0(%rdi), %eax
testq %rax, %rax
je 0x126665
movq 0xa8(%rbx), %r... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [16], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [16], llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x2c0de
movb $0x0, 0x80(%r14)
movq $0x0, 0x90(%r14)
leaq 0x10ea4b(%rip), %rax # 0x2354e0
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x1123a9(%ri... | /llvm/Support/CommandLine.h |
llvm::FunctionSummary::makeDummyFunctionSummary(std::vector<std::pair<llvm::ValueInfo, llvm::CalleeInfo>, std::allocator<std::pair<llvm::ValueInfo, llvm::CalleeInfo>>>) | static FunctionSummary
makeDummyFunctionSummary(std::vector<FunctionSummary::EdgeTy> Edges) {
return FunctionSummary(
FunctionSummary::GVFlags(
GlobalValue::LinkageTypes::AvailableExternallyLinkage,
GlobalValue::DefaultVisibility,
/*NotEligibleToImport=*/true, /*Live=*/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
xorl %ecx, %ecx
leaq 0x70(%rsp), %r9
movq %rcx, 0x10(%r9)
xorps %xmm0, %xmm0
movaps %xmm0, (%r9)
movups (%rsi), %xmm1
leaq 0x50(%rsp), %rax
movaps %xmm1, (%rax)
movq 0x10(%rsi), %rdx
movq %rdx, 0x10(%rax)
movq %... | /llvm/IR/ModuleSummaryIndex.h |
llvm::cl::parser<llvm::ChangePrinter>::parse(llvm::cl::Option&, llvm::StringRef, llvm::StringRef, llvm::ChangePrinter&) | bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
StringRef ArgVal;
if (Owner.hasArgStr())
ArgVal = Arg;
else
ArgVal = ArgName;
for (size_t i = 0, e = Values.size(); i != e; ++i)
if (Values[i].Name == ArgVal) {
V = Values[i].V.getValue();
return fa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x0, 0x18(%rax)
cmovneq %r8, %r15
cmovneq %r9, %r14
movl 0x18(%rdi), %eax
testq %rax, %rax
je 0x1280af
movq 0x10(%rdi), %r13
shlq $0x4, %rax
leaq (%rax,%rax,2), %... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, char [13], llvm::cl::desc, llvm::cl::MiscFlags, llvm::cl::OptionHidden>(llvm::cl::list<std::__cxx11... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x26280
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xfc1bc
movups (%r12), %xmm0
movups %xmm0, 0x20(%rbx)
movl (%r15), %eax
andl $0x1f, %eax
shll $0x9, %e... | /llvm/Support/CommandLine.h |
llvm::cl::opt<(anonymous namespace)::PassRemarksOpt, true, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
addq $0x90, %rdi
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rsi
callq 0x2b54a
movl %... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<(anonymous namespace)::PassRemarksOpt, true, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, llvm::cl::value_desc, llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::LocationClass<(anonymous namespace)::PassRemarksOpt>, llvm::cl::Value... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x50(%rsp), %r15
movq %rsi, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movups (%rcx), %xmm0
movups %xmm0, 0x20(%rdi)
movzwl 0xa(%rdi), %eax
shll $0x5, %r8d
andl $0x60, %r8d
andl $-0x61, %eax
orl %r8d, %eax
movw %ax, 0xa(%rdi)
cmpq $0x0, 0x80(%rdi)
je 0x128df2... | /llvm/Support/CommandLine.h |
llvm::GCStrategy::~GCStrategy() | virtual ~GCStrategy() = default; | leaq 0x11103d(%rip), %rax # 0x239fc0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
addq $0x18, %rdi
cmpq %rdi, %rax
je 0x128fa5
movq (%rdi), %rsi
incq %rsi
movq %rax, %rdi
jmp 0x260c0
retq
| /llvm/IR/GCStrategy.h |
llvm::Registry<llvm::GCStrategy>::Add<(anonymous namespace)::ErlangGC>::CtorFn() | static std::unique_ptr<T> CtorFn() { return std::make_unique<V>(); } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x30, %edi
callq 0x26100
movq %rax, %r14
movq %rax, %rdi
callq 0x128f52
leaq 0x110ff3(%rip), %rax # 0x239ff8
movq %rax, (%r14)
movw $0x101, 0x2a(%r14) # imm = 0x101
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /llvm/Support/Registry.h |
(anonymous namespace)::ErlangGC::~ErlangGC() | ErlangGC() {
NeededSafePoints = true;
UsesMetadata = true;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x110f97(%rip), %rax # 0x239fc0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x129048
movq (%rax), %rsi
incq %rsi
callq 0x260c0
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x260c0
| /IR/BuiltinGCs.cpp |
void llvm::cl::apply<llvm::cl::opt<llvm::cl::boolOrDefault, false, llvm::cl::parser<llvm::cl::boolOrDefault>>, char [16], llvm::cl::desc, llvm::cl::initializer<llvm::cl::boolOrDefault>, llvm::cl::OptionHidden>(llvm::cl::opt<llvm::cl::boolOrDefault, false, llvm::cl::parser<llvm::cl::boolOrDefault>>*, char const (&) [16]... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x26280
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xfc1bc
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movq (%r14), %rax
movl (%rax), %eax
movl %eax, 0... | /llvm/Support/CommandLine.h |
llvm::dxbc::ProgramSignatureElement const* llvm::SmallVectorTemplateCommon<llvm::dxbc::ProgramSignatureElement, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::dxbc::ProgramSignatureElement, true>>(llvm::SmallVectorTemplateBase<llvm::dxbc::ProgramSignatureElement, true>*, llvm::dxbc::Program... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
addq %rax, %rdx
cmpq %rcx, %rdx
ja 0x129e3e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
movq (%rdi), %rcx
shlq $0x5, %rax
addq %rcx, %rax
cmpq %rbx, %rcx
setbe %sil
cmpq %rbx, %rax
seta %al
testb %al,... | /llvm/ADT/SmallVector.h |
llvm::StringTableBuilder::add(llvm::CachedHashStringRef) | size_t StringTableBuilder::add(CachedHashStringRef S) {
if (K == WinCOFF)
assert(S.size() > COFF::NameSize && "Short string in COFF string table!");
assert(!isFinalized());
auto P = StringIndexMap.insert(std::make_pair(S, 0));
if (P.second) {
size_t Start = alignTo(Size, Alignment);
P.first->second... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rcx
movq %rsi, -0x10(%rcx)
movq %rdx, -0x8(%rcx)
movq $0x0, (%rcx)
leaq 0x18(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12babe
movq (%r15), %rdx
cmpb $0x0, 0x10(%r15)
je 0x12b32e
movq 0x18(%rbx),... | /MC/StringTableBuilder.cpp |
llvm::DenseMapIterator<llvm::CachedHashStringRef, unsigned long, llvm::DenseMapInfo<llvm::CachedHashStringRef, void>, llvm::detail::DenseMapPair<llvm::CachedHashStringRef, unsigned long>, true>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x12b4cc
pushq %rbx
movq %rdi, %rbx
movl 0xc(%rax), %ecx
testl %ecx, %ecx
jne 0x12b49e
movq (%rax), %rdi
movl 0x8(%rax), %esi
movq $-0x1, %rdx
xorl %ecx, %ecx
callq 0x2be4e
testb %al, %al
jne 0x12b4bb
movq (%rbx), %rax
movl 0xc(%rax), %ecx
cmpl $0x1, %ecx
jne 0x12b4cb
movq (%ra... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::CachedHashStringRef, unsigned long, llvm::DenseMapInfo<llvm::CachedHashStringRef, void>, llvm::detail::DenseMapPair<llvm::CachedHashStringRef, unsigned long>, false>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x12b54a
pushq %rbx
movq %rdi, %rbx
movl 0xc(%rax), %ecx
testl %ecx, %ecx
jne 0x12b51c
movq (%rax), %rdi
movl 0x8(%rax), %esi
movq $-0x1, %rdx
xorl %ecx, %ecx
callq 0x2be4e
testb %al, %al
jne 0x12b539
movq (%rbx), %rax
movl 0xc(%rax), %ecx
cmpl $0x1, %ecx
jne 0x12b549
movq (%ra... | /llvm/ADT/DenseMap.h |
llvm::wasm::relocTypeHasAddend(unsigned int) | bool llvm::wasm::relocTypeHasAddend(uint32_t Type) {
switch (Type) {
case R_WASM_MEMORY_ADDR_LEB:
case R_WASM_MEMORY_ADDR_LEB64:
case R_WASM_MEMORY_ADDR_SLEB:
case R_WASM_MEMORY_ADDR_SLEB64:
case R_WASM_MEMORY_ADDR_REL_SLEB:
case R_WASM_MEMORY_ADDR_REL_SLEB64:
case R_WASM_MEMORY_ADDR_I32:
case R_WASM_... | movl %edi, %ecx
cmpl $0x1a, %edi
setb %dl
movl $0x2e3cb38, %eax # imm = 0x2E3CB38
shrl %cl, %eax
andb %dl, %al
retq
nop
| /BinaryFormat/Wasm.cpp |
llvm::Error llvm::codeview::FieldListDeserializer::visitKnownMemberImpl<llvm::codeview::VirtualBaseClassRecord>(llvm::codeview::CVMemberRecord&, llvm::codeview::VirtualBaseClassRecord&) | Error visitKnownMemberImpl(CVMemberRecord &CVR, RecordType &Record) {
if (auto EC = Mapping.Mapping.visitKnownMember(CVR, Record))
return EC;
uint32_t EndOffset = Mapping.Reader.getOffset();
uint32_t RecordLength = EndOffset - Mapping.StartOffset;
Mapping.Reader.setOffset(Mapping.StartOffset);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %rsi
callq 0x13e6fe
cmpq $0x0, (%rbx)
jne 0x12f6d3
movq 0x8(%r15), %rsi
movl 0x38(%rsi), %ecx
movl 0x68(%r15), %eax
subl %eax, %ecx
movq %rax, 0x38(%rsi)
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xfa818
movq %rbx, ... | /llvm/DebugInfo/CodeView/TypeDeserializer.h |
llvm::codeview::DebugStringTableSubsection::commit(llvm::BinaryStreamWriter&) const | Error DebugStringTableSubsection::commit(BinaryStreamWriter &Writer) const {
uint32_t Begin = Writer.getOffset();
uint32_t End = Begin + StringSize;
// Write a null string at the beginning.
if (auto EC = Writer.writeCString(StringRef()))
return EC;
for (auto &Pair : StringToId) {
StringRef S = Pair.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x38(%rdx), %r12d
movl 0x40(%rsi), %ebp
addl %r12d, %ebp
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xfb3b6
cmpq $0x0, (%rbx)
jne 0x132719
movq 0x28(%r15), %rax
movl 0x30(%r15), %... | /DebugInfo/CodeView/DebugStringTableSubsection.cpp |
llvm::ArrayRef<unsigned char> llvm::codeview::SimpleTypeSerializer::serialize<llvm::codeview::PointerRecord>(llvm::codeview::PointerRecord&) | ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {
BinaryStreamWriter Writer(ScratchBuffer, llvm::endianness::little);
TypeRecordMapping Mapping(Writer);
// Write the record prefix first with a dummy length but real kind.
RecordPrefix DummyPrefix(uint16_t(Record.getKind()));
cantFail(Writer.write... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
subq %rsi, %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, %r12
movl $0x1, %ecx
callq 0xfb35c
leaq 0x112fa7(%rip), %rbp # 0x2465d8
addq $0x10, %rbp
leaq... | /DebugInfo/CodeView/SimpleTypeSerializer.cpp |
llvm::ArrayRef<unsigned char> llvm::codeview::SimpleTypeSerializer::serialize<llvm::codeview::ProcedureRecord>(llvm::codeview::ProcedureRecord&) | ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {
BinaryStreamWriter Writer(ScratchBuffer, llvm::endianness::little);
TypeRecordMapping Mapping(Writer);
// Write the record prefix first with a dummy length but real kind.
RecordPrefix DummyPrefix(uint16_t(Record.getKind()));
cantFail(Writer.write... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
subq %rsi, %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, %r12
movl $0x1, %ecx
callq 0xfb35c
leaq 0x112c23(%rip), %rbp # 0x2465d8
addq $0x10, %rbp
leaq... | /DebugInfo/CodeView/SimpleTypeSerializer.cpp |
llvm::ArrayRef<unsigned char> llvm::codeview::SimpleTypeSerializer::serialize<llvm::codeview::UnionRecord>(llvm::codeview::UnionRecord&) | ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {
BinaryStreamWriter Writer(ScratchBuffer, llvm::endianness::little);
TypeRecordMapping Mapping(Writer);
// Write the record prefix first with a dummy length but real kind.
RecordPrefix DummyPrefix(uint16_t(Record.getKind()));
cantFail(Writer.write... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
subq %rsi, %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, %r12
movl $0x1, %ecx
callq 0xfb35c
leaq 0x1122db(%rip), %rbp # 0x2465d8
addq $0x10, %rbp
leaq... | /DebugInfo/CodeView/SimpleTypeSerializer.cpp |
llvm::ArrayRef<unsigned char> llvm::codeview::SimpleTypeSerializer::serialize<llvm::codeview::StringListRecord>(llvm::codeview::StringListRecord&) | ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {
BinaryStreamWriter Writer(ScratchBuffer, llvm::endianness::little);
TypeRecordMapping Mapping(Writer);
// Write the record prefix first with a dummy length but real kind.
RecordPrefix DummyPrefix(uint16_t(Record.getKind()));
cantFail(Writer.write... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
subq %rsi, %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, %r12
movl $0x1, %ecx
callq 0xfb35c
leaq 0x1114ef(%rip), %rbp # 0x2465d8
addq $0x10, %rbp
leaq... | /DebugInfo/CodeView/SimpleTypeSerializer.cpp |
llvm::ArrayRef<unsigned char> llvm::codeview::SimpleTypeSerializer::serialize<llvm::codeview::UdtSourceLineRecord>(llvm::codeview::UdtSourceLineRecord&) | ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {
BinaryStreamWriter Writer(ScratchBuffer, llvm::endianness::little);
TypeRecordMapping Mapping(Writer);
// Write the record prefix first with a dummy length but real kind.
RecordPrefix DummyPrefix(uint16_t(Record.getKind()));
cantFail(Writer.write... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
subq %rsi, %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, %r12
movl $0x1, %ecx
callq 0xfb35c
leaq 0x1111d7(%rip), %rbp # 0x2465d8
addq $0x10, %rbp
leaq... | /DebugInfo/CodeView/SimpleTypeSerializer.cpp |
llvm::ArrayRef<unsigned char> llvm::codeview::SimpleTypeSerializer::serialize<llvm::codeview::MethodOverloadListRecord>(llvm::codeview::MethodOverloadListRecord&) | ArrayRef<uint8_t> SimpleTypeSerializer::serialize(T &Record) {
BinaryStreamWriter Writer(ScratchBuffer, llvm::endianness::little);
TypeRecordMapping Mapping(Writer);
// Write the record prefix first with a dummy length but real kind.
RecordPrefix DummyPrefix(uint16_t(Record.getKind()));
cantFail(Writer.write... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
subq %rsi, %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, %r12
movl $0x1, %ecx
callq 0xfb35c
leaq 0x110ebf(%rip), %rbp # 0x2465d8
addq $0x10, %rbp
leaq... | /DebugInfo/CodeView/SimpleTypeSerializer.cpp |
llvm::codeview::SymbolSerializer::SymbolSerializer(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, llvm::codeview::CodeViewContainer) | SymbolSerializer::SymbolSerializer(BumpPtrAllocator &Allocator,
CodeViewContainer Container)
: Storage(Allocator), Stream(RecordBuffer, llvm::endianness::little),
Writer(Stream), Mapping(Writer, Container) {} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
leaq 0x10d4ad(%rip), %rax # 0x246450
addq $0x10, %rax
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0xff10(%rdi), %rsi
leaq 0x10(%rdi), %rax
leaq 0xffb38(%rip), %rcx # 0x238af8
addq $0x10, %rcx
movq %rcx, 0xff10(%rdi)
movq %rax, 0xff18(%rdi)
movl $0x... | /DebugInfo/CodeView/SymbolSerializer.cpp |
llvm::StringRef (anonymous namespace)::getEnumName<unsigned char, unsigned char>(llvm::codeview::CodeViewRecordIO&, unsigned char, llvm::ArrayRef<llvm::EnumEntry<unsigned char>>) | static StringRef getEnumName(CodeViewRecordIO &IO, T Value,
ArrayRef<EnumEntry<TEnum>> EnumValues) {
if (!IO.isStreaming())
return "";
StringRef Name;
for (const auto &EnumItem : EnumValues) {
if (EnumItem.Value == Value) {
Name = EnumItem.Name;
break;
}
}
... | movq %rdx, %r8
xorl %edx, %edx
cmpq $0x0, 0x38(%rdi)
leaq 0x9760a(%rip), %rax # 0x1d206e
je 0x13aa9b
cmpq $0x0, 0x28(%rdi)
jne 0x13aa9b
cmpq $0x0, 0x30(%rdi)
jne 0x13aa9b
testq %rcx, %rcx
je 0x13aa97
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rax
xorl %edx, %edx
xorl %ecx, %ecx
cmpb %sil, 0x20(%r8,%rcx)
je 0x13aa9c
addq ... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
mapNameAndUniqueName(llvm::codeview::CodeViewRecordIO&, llvm::StringRef&, llvm::StringRef&, bool) | static Error mapNameAndUniqueName(CodeViewRecordIO &IO, StringRef &Name,
StringRef &UniqueName, bool HasUniqueName) {
if (IO.isWriting()) {
// Try to be smart about what we write here. We can't write anything too
// large, so if we're going to go over the limit, replace leng... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
je 0x13c549
cmpq $0x0, 0x38(%r14)
jne 0x13c549
cmpq $0x0, 0x28(%r14)
jne 0x13c549
movq %r14, %rdi
callq 0x13ff26
movl %eax, %r13d
testb... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
llvm::codeview::TypeRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::StringIdRecord&) | Error TypeRecordMapping::visitKnownRecord(CVType &CVR, StringIdRecord &Record) {
error(IO.mapInteger(Record.Id, "Id"));
error(IO.mapStringZ(Record.String, "StringData"));
return Error::success();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x2(%rcx), %rdx
leaq 0x20e28(%rip), %rax # 0x15dc8d
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %r15, %rsi
callq 0x140214
cmpq $0x0, (%rbx)
jne 0x13cea8
... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
llvm::codeview::TypeRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::UdtSourceLineRecord&) | Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
UdtSourceLineRecord &Record) {
error(IO.mapInteger(Record.UDT, "UDT"));
error(IO.mapInteger(Record.SourceFile, "SourceFile"));
error(IO.mapInteger(Record.LineNumber, "LineNumber"));
return Error::success();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x2(%rcx), %rdx
leaq 0xa443d(%rip), %rax # 0x1e1314
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %r15, %rsi
callq 0x140214
cmpq $0x0, (%rbx)
jne 0x13cf44
... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
llvm::codeview::TypeRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::BuildInfoRecord&) | Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
BuildInfoRecord &Record) {
error(IO.mapVectorN<uint16_t>(
Record.ArgIndices,
[](CodeViewRecordIO &IO, TypeIndex &N) {
return IO.mapInteger(N, "Argument");
},
"NumArgs"));
return Error::s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
leaq 0xa5edc(%rip), %rax # 0x1e304e
movq %rax, 0x30(%rsp)
movw $0x103, 0x50(%rsp) # imm = 0x103
movq 0x48(%rsi), %rax
testq %rax, %rax
setne %cl
movq 0x38(%rs... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
llvm::codeview::TypeRecordMapping::visitKnownMember(llvm::codeview::CVMemberRecord&, llvm::codeview::BaseClassRecord&) | Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
BaseClassRecord &Record) {
std::string Attrs = getMemberAttributes(
IO, Record.getAccess(), MethodKind::Vanilla, MethodOptions::None);
error(IO.mapInteger(Record.Attrs.Attrs, "Attrs: " + Attrs));
error(I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x2(%rcx), %r12
movzwl 0x2(%rcx), %edx
andl $0x3, %edx
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x13d8af
leaq 0xa587... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.