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.visitSymbolBegin(Result));
consumeError(Serializer.visitKnownRecord(Result, Sym));
consumeError(Serializer.visitSymbolEnd(Result));
return Result;
}
|
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
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x139082
movq (%r12), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq $0x0, (%r12)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x4d867
movq (%r14), %rdi
testq %rdi, %rdi
je 0xbf063
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xbf073
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xffd0(%rsp), %rsi
leaq 0x30(%rsp), %r14
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x138214
movq (%r14), %rax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movq $0x0, (%r14)
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d867
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbf0bd
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xbf0cd
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x13911a
movq (%rbx), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq $0x0, (%rbx)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x4d867
movq (%r14), %rdi
testq %rdi, %rdi
je 0xbf111
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xbf121
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x187328(%rip), %rax # 0x246450
addq $0x10, %rax
leaq 0xfff0(%rsp), %rcx
movq %rax, -0xffa8(%rcx)
leaq 0x187186(%rip), %rax # 0x2462c8
addq $0x10, %rax
movq %rax, -0x20(%rcx)
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0xbf158
callq 0x26150
leaq 0x1763c1(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0xff90(%rsp)
movq 0xffa0(%rsp), %rdi
testq %rdi, %rdi
je 0xbf17d
callq 0x2e070
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x10038, %rsp # imm = 0x10038
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 (auto EC = S.visitKnownRecord(Symbol, Record))
return EC;
if (auto EC = S.visitSymbolEnd(Symbol))
return EC;
return Error::success();
}
|
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, 0x18(%rsi)
movq %rax, %rdx
callq 0xbb742
cmpq %r12, (%rbx)
jne 0xbf4e0
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0xbc110
cmpq $0x0, (%rbx)
jne 0xbf4e0
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xbb856
movq %r15, 0x8(%rsp)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0xbf4f9
leaq 0x20(%rsp), %rdi
callq 0xbdd6c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 (auto EC = S.visitKnownRecord(Symbol, Record))
return EC;
if (auto EC = S.visitSymbolEnd(Symbol))
return EC;
return Error::success();
}
|
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, 0x18(%rsi)
movq %rax, %rdx
callq 0xbb742
cmpq %r12, (%rbx)
jne 0xbfa7c
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0xbc2b8
cmpq $0x0, (%rbx)
jne 0xbfa7c
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xbb856
movq %r15, 0x8(%rsp)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0xbfa95
leaq 0x20(%rsp), %rdi
callq 0xbdd6c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 (auto EC = S.visitKnownRecord(Symbol, Record))
return EC;
if (auto EC = S.visitSymbolEnd(Symbol))
return EC;
return Error::success();
}
|
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, 0x18(%rsi)
movq %rax, %rdx
callq 0xbb742
cmpq %r12, (%rbx)
jne 0xc1bf6
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0xbcbd4
cmpq $0x0, (%rbx)
jne 0xc1bf6
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xbb856
movq %r15, 0x8(%rsp)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0xc1c0f
leaq 0x20(%rsp), %rdi
callq 0xbdd6c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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.visitSymbolBegin(Result));
consumeError(Serializer.visitKnownRecord(Result, Sym));
consumeError(Serializer.visitSymbolEnd(Result));
return Result;
}
|
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
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x139082
movq (%r12), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq $0x0, (%r12)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x4d867
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc33d9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xc33e9
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xffd0(%rsp), %rsi
leaq 0x30(%rsp), %r14
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1377ea
movq (%r14), %rax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movq $0x0, (%r14)
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d867
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc3433
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xc3443
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x13911a
movq (%rbx), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq $0x0, (%rbx)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x4d867
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc3487
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xc3497
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x182fb2(%rip), %rax # 0x246450
addq $0x10, %rax
leaq 0xfff0(%rsp), %rcx
movq %rax, -0xffa8(%rcx)
leaq 0x182e10(%rip), %rax # 0x2462c8
addq $0x10, %rax
movq %rax, -0x20(%rcx)
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0xc34ce
callq 0x26150
leaq 0x17204b(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0xff90(%rsp)
movq 0xffa0(%rsp), %rdi
testq %rdi, %rdi
je 0xc34f3
callq 0x2e070
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x10038, %rsp # imm = 0x10038
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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.visitSymbolBegin(Result));
consumeError(Serializer.visitKnownRecord(Result, Sym));
consumeError(Serializer.visitSymbolEnd(Result));
return Result;
}
|
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
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x139082
movq (%r12), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq $0x0, (%r12)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x4d867
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc3c43
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xc3c53
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xffd0(%rsp), %rsi
leaq 0x30(%rsp), %r14
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x13664c
movq (%r14), %rax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movq $0x0, (%r14)
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d867
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc3c9d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xc3cad
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x13911a
movq (%rbx), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq $0x0, (%rbx)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x4d867
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc3cf1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xc3d01
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x182748(%rip), %rax # 0x246450
addq $0x10, %rax
leaq 0xfff0(%rsp), %rcx
movq %rax, -0xffa8(%rcx)
leaq 0x1825a6(%rip), %rax # 0x2462c8
addq $0x10, %rax
movq %rax, -0x20(%rcx)
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0xc3d38
callq 0x26150
leaq 0x1717e1(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0xff90(%rsp)
movq 0xffa0(%rsp), %rdi
testq %rdi, %rdi
je 0xc3d5d
callq 0x2e070
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x10038, %rsp # imm = 0x10038
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 (auto EC = S.visitKnownRecord(Symbol, Record))
return EC;
if (auto EC = S.visitSymbolEnd(Symbol))
return EC;
return Error::success();
}
|
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, 0x18(%rsi)
movq %rax, %rdx
callq 0xbb742
cmpq %r12, (%rbx)
jne 0xc3df2
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0xbd5c4
cmpq $0x0, (%rbx)
jne 0xc3df2
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xbb856
movq %r15, 0x8(%rsp)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0xc3e0b
leaq 0x20(%rsp), %rdi
callq 0xbdd6c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x10(%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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, 6> A;
Scalar.split(A, '-', 5);
if (A.size() != 5 || Scalar[8] != '-' || Scalar[13] != '-' ||
Scalar[18] != '-' || Scalar[23] != '-')
return "GUID sections are not properly delineated with dashes";
struct MSGuid {
support::ulittle32_t Data1;
support::ulittle16_t Data2;
support::ulittle16_t Data3;
support::ubig64_t Data4;
};
MSGuid G = {};
uint64_t D41{}, D42{};
if (!to_integer(A[0], G.Data1, 16) || !to_integer(A[1], G.Data2, 16) ||
!to_integer(A[2], G.Data3, 16) || !to_integer(A[3], D41, 16) ||
!to_integer(A[4], D42, 16))
return "GUID contains non hex digits";
G.Data4 = (D41 << 48) | D42;
::memcpy(&S, &G, sizeof(GUID));
return "";
}
|
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(%rax)
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x600000000, %rcx # imm = 0x600000000
movq %rcx, -0x8(%r13)
leaq 0x18(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
movl $0x2d, %edx
movl $0x5, %ecx
movl $0x1, %r8d
callq 0x10bddc
leaq 0x9a5b6(%rip), %r14 # 0x16012b
movl $0x35, %r15d
cmpl $0x5, 0x8(%r12)
jne 0xc5c88
movq 0x8(%rsp), %rax
cmpb $0x2d, 0x8(%rax)
jne 0xc5c88
cmpb $0x2d, 0xd(%rax)
jne 0xc5c88
cmpb $0x2d, 0x12(%rax)
jne 0xc5c88
cmpb $0x2d, 0x17(%rax)
jne 0xc5c88
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %rsp, %rcx
movl $0x10, %edx
callq 0x10c0c8
testb %al, %al
jne 0xc5c7b
movq (%rsp), %r14
movq %r14, %rax
shrq $0x20, %rax
jne 0xc5c7b
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
movq %rsp, %rcx
movl $0x10, %edx
callq 0x10c0c8
testb %al, %al
jne 0xc5c7b
movq (%rsp), %r15
cmpq $0x10000, %r15 # imm = 0x10000
jae 0xc5c7b
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
movq %rsp, %rcx
movl $0x10, %edx
callq 0x10c0c8
testb %al, %al
jne 0xc5c7b
movq (%rsp), %r12
cmpq $0x10000, %r12 # imm = 0x10000
jae 0xc5c7b
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
movq %rsp, %rcx
movl $0x10, %edx
callq 0x10c0c8
testb %al, %al
jne 0xc5c7b
movq %rsp, %rcx
movq (%rcx), %rbp
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x48(%rax), %rsi
movl $0x10, %edx
callq 0x10c0c8
testb %al, %al
je 0xc5cbe
leaq 0x9a4df(%rip), %r14 # 0x160161
movl $0x1c, %r15d
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0xc5ca6
callq 0x26150
jmp 0xc5ca6
leaq 0x9a44c(%rip), %r14 # 0x1600ec
movl $0x23, %r15d
movq %r14, %rax
movq %r15, %rdx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shlq $0x30, %rbp
orq (%rsp), %rbp
bswapq %rbp
movl %r14d, (%rbx)
movw %r15w, 0x4(%rbx)
movw %r12w, 0x6(%rbx)
movq %rbp, 0x8(%rbx)
leaq 0x10c38d(%rip), %r14 # 0x1d206e
xorl %r15d, %r15d
jmp 0xc5c88
|
/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 0x35a6c
addq $0x18, %rbx
leaq 0x10(%rsp), %rcx
movb $0x0, 0x6(%rcx)
leaq 0x97dcc(%rip), %rsi # 0x160e33
leaq 0xf(%rsp), %r9
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0xcc968
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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
addq $0x20, %rbx
leaq 0x9443c(%rip), %rsi # 0x15dc4f
leaq 0x7(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x393b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 %rbx
popq %r14
retq
nop
|
/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::vector<llvm::CodeViewYAML::MemberRecord, std::allocator<llvm::CodeViewYAML::MemberRecord>>&, 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) {
void *SaveInfo;
if ( io.preflightFlowElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightFlowElement(SaveInfo);
}
}
io.endFlowSequence();
}
else {
unsigned incnt = io.beginSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
void *SaveInfo;
if ( io.preflightElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightElement(SaveInfo);
}
}
io.endSequence();
}
}
|
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 0xccbf0
movl %ecx, %ebp
xorl %r15d, %r15d
movq %rsp, %r12
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq *0x20(%rax)
testb %al, %al
je 0xccbe8
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r15, %rcx
ja 0xccbb4
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xccc08
movq (%r14), %rax
movq %r15, %r13
shlq $0x4, %r13
addq %rax, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xcac9a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq (%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
incq %r15
cmpq %rbp, %r15
jne 0xccb7f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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) {
void *SaveInfo;
if ( io.preflightFlowElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightFlowElement(SaveInfo);
}
}
io.endFlowSequence();
}
else {
unsigned incnt = io.beginSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
void *SaveInfo;
if ( io.preflightElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightElement(SaveInfo);
}
}
io.endSequence();
}
}
|
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
xorl %r12d, %r12d
movq %rsp, %r13
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq *0x48(%rax)
testb %al, %al
je 0xcd2df
movl 0x8(%r15), %eax
cmpq %rax, %r12
jb 0xcd2b7
leaq 0x1(%r12), %rsi
movq %r15, %rdi
callq 0xcd300
leaq (,%r12,4), %rsi
addq (%r15), %rsi
movq %rbx, %rdi
movl $0x1, %edx
movq %r14, %rcx
callq 0xba2fd
movq (%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
incq %r12
cmpq %rbp, %r12
jne 0xcd28e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, %rsp
popq %rbx
retq
|
/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.visitTypeEnd(CVT))
return EC;
return Error::success();
}
|
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 # 0x2366e8
addq $0x10, %rsi
leaq 0x30(%rsp), %r13
movq %rsi, -0x20(%r13)
movl $0x1, -0x18(%r13)
movq %rcx, -0x10(%r13)
movq %rax, -0x8(%r13)
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
movq %rdx, 0x8(%rsp)
callq 0xfa7bc
leaq 0x70(%rsp), %r12
leaq 0x17843d(%rip), %rbp # 0x2465d8
addq $0x10, %rbp
movq %rbp, (%r12)
xorl %eax, %eax
movb %al, 0xa(%r12)
movb %al, 0xe(%r12)
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%r15)
movq %r13, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq $0x0, 0x30(%r15)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x139644
cmpq $0x0, (%rbx)
jne 0xce218
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
callq 0x13b454
cmpq $0x0, (%rbx)
jne 0xce218
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x139df0
movq %rbp, 0x70(%rsp)
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0xce22f
callq 0x26150
leaq 0x167cc2(%rip), %rax # 0x235ef8
addq $0x10, %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xce24e
callq 0x2e070
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, %rsp
popq %rbx
retq
|
/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, %rsp
popq %rbx
retq
|
/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, %rsp
popq %rbx
retq
|
/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(IMAGE_FILE_MACHINE_ARM64EC);
ECase(IMAGE_FILE_MACHINE_ARM64X);
ECase(IMAGE_FILE_MACHINE_EBC);
ECase(IMAGE_FILE_MACHINE_I386);
ECase(IMAGE_FILE_MACHINE_IA64);
ECase(IMAGE_FILE_MACHINE_M32R);
ECase(IMAGE_FILE_MACHINE_MIPS16);
ECase(IMAGE_FILE_MACHINE_MIPSFPU);
ECase(IMAGE_FILE_MACHINE_MIPSFPU16);
ECase(IMAGE_FILE_MACHINE_POWERPC);
ECase(IMAGE_FILE_MACHINE_POWERPCFP);
ECase(IMAGE_FILE_MACHINE_R4000);
ECase(IMAGE_FILE_MACHINE_RISCV32);
ECase(IMAGE_FILE_MACHINE_RISCV64);
ECase(IMAGE_FILE_MACHINE_RISCV128);
ECase(IMAGE_FILE_MACHINE_SH3);
ECase(IMAGE_FILE_MACHINE_SH3DSP);
ECase(IMAGE_FILE_MACHINE_SH4);
ECase(IMAGE_FILE_MACHINE_SH5);
ECase(IMAGE_FILE_MACHINE_THUMB);
ECase(IMAGE_FILE_MACHINE_WCEMIPSV2);
}
|
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 %r14, %rdi
callq *0x10(%rax)
cmpl $0x1d3, (%rbx) # imm = 0x1D3
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90508(%rip), %rsi # 0x161261
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0d6c
movl $0x1d3, (%rbx) # imm = 0x1D3
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x8664, (%rbx) # imm = 0x8664
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x904ec(%rip), %rsi # 0x161279
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0da0
movl $0x8664, (%rbx) # imm = 0x8664
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1c0, (%rbx) # imm = 0x1C0
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x904d1(%rip), %rsi # 0x161292
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0dd4
movl $0x1c0, (%rbx) # imm = 0x1C0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1c4, (%rbx) # imm = 0x1C4
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x904b4(%rip), %rsi # 0x1612a9
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0e08
movl $0x1c4, (%rbx) # imm = 0x1C4
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0xaa64, (%rbx) # imm = 0xAA64
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90499(%rip), %rsi # 0x1612c2
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0e3c
movl $0xaa64, (%rbx) # imm = 0xAA64
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0xa641, (%rbx) # imm = 0xA641
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x9047e(%rip), %rsi # 0x1612db
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0e70
movl $0xa641, (%rbx) # imm = 0xA641
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0xa64e, (%rbx) # imm = 0xA64E
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90465(%rip), %rsi # 0x1612f6
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0ea4
movl $0xa64e, (%rbx) # imm = 0xA64E
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0xebc, (%rbx) # imm = 0xEBC
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x9044b(%rip), %rsi # 0x161310
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0ed8
movl $0xebc, (%rbx) # imm = 0xEBC
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x14c, (%rbx) # imm = 0x14C
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x9042e(%rip), %rsi # 0x161327
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0f0c
movl $0x14c, (%rbx) # imm = 0x14C
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x200, (%rbx) # imm = 0x200
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90412(%rip), %rsi # 0x16133f
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0f40
movl $0x200, (%rbx) # imm = 0x200
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x9041, (%rbx) # imm = 0x9041
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x903f6(%rip), %rsi # 0x161357
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0f74
movl $0x9041, (%rbx) # imm = 0x9041
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x266, (%rbx) # imm = 0x266
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x903da(%rip), %rsi # 0x16136f
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0fa8
movl $0x266, (%rbx) # imm = 0x266
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x366, (%rbx) # imm = 0x366
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x903c0(%rip), %rsi # 0x161389
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd0fdc
movl $0x366, (%rbx) # imm = 0x366
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x466, (%rbx) # imm = 0x466
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x903a7(%rip), %rsi # 0x1613a4
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1010
movl $0x466, (%rbx) # imm = 0x466
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1f0, (%rbx) # imm = 0x1F0
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90390(%rip), %rsi # 0x1613c1
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1044
movl $0x1f0, (%rbx) # imm = 0x1F0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1f1, (%rbx) # imm = 0x1F1
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90377(%rip), %rsi # 0x1613dc
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1078
movl $0x1f1, (%rbx) # imm = 0x1F1
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x166, (%rbx) # imm = 0x166
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90360(%rip), %rsi # 0x1613f9
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd10ac
movl $0x166, (%rbx) # imm = 0x166
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x5032, (%rbx) # imm = 0x5032
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90345(%rip), %rsi # 0x161412
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd10e0
movl $0x5032, (%rbx) # imm = 0x5032
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x5064, (%rbx) # imm = 0x5064
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x9032c(%rip), %rsi # 0x16142d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1114
movl $0x5064, (%rbx) # imm = 0x5064
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x5128, (%rbx) # imm = 0x5128
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x90313(%rip), %rsi # 0x161448
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1148
movl $0x5128, (%rbx) # imm = 0x5128
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1a2, (%rbx) # imm = 0x1A2
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x902fb(%rip), %rsi # 0x161464
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd117c
movl $0x1a2, (%rbx) # imm = 0x1A2
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1a3, (%rbx) # imm = 0x1A3
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x902de(%rip), %rsi # 0x16147b
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd11b0
movl $0x1a3, (%rbx) # imm = 0x1A3
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1a6, (%rbx) # imm = 0x1A6
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x902c4(%rip), %rsi # 0x161495
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd11e4
movl $0x1a6, (%rbx) # imm = 0x1A6
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1a8, (%rbx) # imm = 0x1A8
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x902a7(%rip), %rsi # 0x1614ac
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1218
movl $0x1a8, (%rbx) # imm = 0x1A8
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x1c2, (%rbx) # imm = 0x1C2
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x9028a(%rip), %rsi # 0x1614c3
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd124c
movl $0x1c2, (%rbx) # imm = 0x1C2
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x169, (%rbx) # imm = 0x169
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x9026f(%rip), %rsi # 0x1614dc
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1280
movl $0x169, (%rbx) # imm = 0x169
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 %r14, %rdi
callq *0x10(%rax)
cmpl $0x1, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8fdfa(%rip), %rsi # 0x161932
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1b4b
movl $0x1, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x2, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8fde1(%rip), %rsi # 0x16194a
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1b7c
movl $0x2, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpl $0x3, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8fdc9(%rip), %rsi # 0x161963
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xd1bad
movl $0x3, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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_ADDRESS_AWARE);
BCase(IMAGE_FILE_BYTES_REVERSED_LO);
BCase(IMAGE_FILE_32BIT_MACHINE);
BCase(IMAGE_FILE_DEBUG_STRIPPED);
BCase(IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP);
BCase(IMAGE_FILE_NET_RUN_FROM_SWAP);
BCase(IMAGE_FILE_SYSTEM);
BCase(IMAGE_FILE_DLL);
BCase(IMAGE_FILE_UP_SYSTEM_ONLY);
BCase(IMAGE_FILE_BYTES_REVERSED_HI);
}
|
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
callq *0x10(%rax)
movl (%rbx), %ecx
andl $0x2, %ecx
shrl %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f5de(%rip), %rsi # 0x1620ee
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2b20
orb $0x2, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
andl $0x4, %ecx
shrl $0x2, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f5ca(%rip), %rsi # 0x16210a
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2b50
orb $0x4, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
andl $0x8, %ecx
shrl $0x3, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f5b8(%rip), %rsi # 0x162128
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2b80
orb $0x8, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
andl $0x10, %ecx
shrl $0x4, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f5a7(%rip), %rsi # 0x162147
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2bb0
orb $0x10, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
andl $0x20, %ecx
shrl $0x5, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f595(%rip), %rsi # 0x162165
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2be0
orb $0x20, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
testb %cl, %cl
sets %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f585(%rip), %rsi # 0x162184
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2c0f
orb $-0x80, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
shrl $0x8, %ecx
andl $0x1, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f572(%rip), %rsi # 0x1621a1
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2c40
orb $0x1, 0x1(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
shrl $0x9, %ecx
andl $0x1, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f55a(%rip), %rsi # 0x1621ba
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2c71
orb $0x2, 0x1(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
shrl $0xa, %ecx
andl $0x1, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f543(%rip), %rsi # 0x1621d4
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2ca2
orb $0x4, 0x1(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
shrl $0xb, %ecx
andl $0x1, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f535(%rip), %rsi # 0x1621f7
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2cd3
orb $0x8, 0x1(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
shrl $0xc, %ecx
andl $0x1, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f521(%rip), %rsi # 0x162214
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2d04
orb $0x10, 0x1(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
shrl $0xd, %ecx
andl $0x1, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f502(%rip), %rsi # 0x162226
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2d35
orb $0x20, 0x1(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
shrl $0xe, %ecx
andl $0x1, %ecx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f4e0(%rip), %rsi # 0x162235
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2d66
orb $0x40, 0x1(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movl (%rbx), %ecx
testw %cx, %cx
sets %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x8f4c9(%rip), %rsi # 0x16224f
movq %r14, %rdi
callq *0xc8(%rax)
testb %al, %al
je 0xd2d97
orb $-0x80, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 0x8e870(%rip), %rsi # 0x1628a7
leaq 0x7(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xb2810
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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), %rax
movq %rbx, %rdi
callq *0xb8(%rax)
movq 0x10(%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 %rbx
popq %r14
retq
|
/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 == Size)
writeInteger((uint16_t)Integer, OS, IsLittleEndian);
else if (1 == Size)
writeInteger((uint8_t)Integer, OS, IsLittleEndian);
else
return createStringError(errc::not_supported,
"invalid integer write size: %zu", Size);
return Error::success();
}
|
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 0xd9081
movl %esi, %eax
bswapl %eax
testb %r8b, %r8b
cmovnel %esi, %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
jmp 0xd90a3
movl %esi, %eax
rolw $0x8, %ax
testb %r8b, %r8b
cmovel %eax, %esi
leaq 0x8(%rsp), %rax
movw %si, (%rax)
movl $0x2, %edx
movq %rcx, %rdi
movq %rax, %rsi
jmp 0xd90a6
movq %rsi, %rax
bswapq %rax
testb %r8b, %r8b
cmovneq %rsi, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x8, %edx
movq %rcx, %rdi
callq 0x117ecc
movq $0x0, (%rbx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x26580
movq %rax, %r14
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x8(%rsp), %r12
movl $0x0, 0x8(%r12)
movb %al, 0x28(%r12)
movl $0x1, 0x2c(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq %rax, 0x20(%r12)
leaq 0x160963(%rip), %rax # 0x239a70
addq $0x10, %rax
movq %rax, (%r12)
leaq 0x40(%rsp), %rbp
movq %rbp, 0x30(%r12)
movq %r12, %rdi
callq 0x2e336
leaq 0x89ff9(%rip), %rax # 0x163127
leaq 0x60(%rsp), %rsi
movq %rax, 0x8(%rsi)
leaq 0x15f81a(%rip), %rax # 0x238958
addq $0x10, %rax
movq %rax, (%rsi)
movq %r15, 0x10(%rsi)
movq %r12, %rdi
callq 0x117a34
movq %r12, %rdi
callq 0x1188ca
movl $0x40, %edi
callq 0x26100
movq %rax, %r15
movw $0x104, 0x20(%r12) # imm = 0x104
movq %rbp, (%r12)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movl $0x5f, %edx
movq %r14, %rcx
callq 0x1080ba
movq %r15, (%rbx)
movq (%rbp), %rdi
cmpq %r13, %rdi
je 0xd90b2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x260c0
jmp 0xd90b2
|
/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.UnitOffset, OS, IsLittleEndian);
writeInteger((uint32_t)Sect.UnitSize, OS, IsLittleEndian);
for (const auto &Entry : Sect.Entries) {
writeInteger((uint32_t)Entry.DieOffset, OS, IsLittleEndian);
if (IsGNUPubSec)
writeInteger((uint8_t)Entry.Descriptor, OS, IsLittleEndian);
OS.write(Entry.Name.data(), Entry.Name.size());
OS.write('\0');
}
return Error::success();
}
|
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 %eax, %ecx
leaq 0x16(%rsp), %rsi
movw %cx, (%rsi)
movl $0x2, %edx
movq %r15, %rdi
callq 0x117ecc
testl %ebp, %ebp
movl 0x14(%r12), %eax
movl %eax, %ecx
bswapl %ecx
cmovnel %eax, %ecx
leaq 0x20(%rsp), %rsi
movl %ecx, (%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x117ecc
testl %ebp, %ebp
movl 0x18(%r12), %eax
movl %eax, %ecx
bswapl %ecx
cmovnel %eax, %ecx
leaq 0x24(%rsp), %rsi
movl %ecx, (%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x117ecc
movq 0x20(%r12), %r14
movq 0x28(%r12), %r13
cmpq %r13, %r14
je 0xd9623
addq $0x4, %r14
movl -0x4(%r14), %eax
movl %eax, %ecx
bswapl %ecx
testb %bpl, %bpl
cmovnel %eax, %ecx
movl %ecx, 0x10(%rsp)
movl $0x4, %edx
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x117ecc
testb %bl, %bl
je 0xd95f8
movb (%r14), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq %r15, %rdi
leaq 0xf(%rsp), %rsi
callq 0x117ecc
leaq -0x4(%r14), %r12
movq 0x4(%r14), %rsi
movq 0xc(%r14), %rdx
movq %r15, %rdi
callq 0x117ecc
movq %r15, %rdi
xorl %esi, %esi
callq 0x117e56
addq $0x18, %r14
addq $0x18, %r12
cmpq %r13, %r12
jne 0xd95b7
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
// Assign common elements.
iterator NewEnd = this->begin();
if (RHSSize)
NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
// Destroy excess elements and trim the bounds.
this->destroy_range(NewEnd, this->end());
this->set_size(RHSSize);
// Clear the RHS.
RHS.clear();
return *this;
}
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < RHSSize) {
// Destroy current elements.
this->clear();
CurSize = 0;
this->grow(RHSSize);
} else if (CurSize) {
// Otherwise, use assignment for the already-constructed elements.
std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
}
// Move-construct the new elements in place.
this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
this->begin()+CurSize);
// Set end.
this->set_size(RHSSize);
RHS.clear();
return *this;
}
|
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, 0x10(%rbx)
jae 0xde1cb
movq $0x0, 0x8(%rbx)
leaq 0x18(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x10ad78
jmp 0xde1dd
testq %r15, %r15
je 0xde1fa
movq (%rbx), %rdi
movq %r15, %rdx
callq 0x26110
jmp 0xde1fa
testq %r12, %r12
je 0xde1dd
movq (%rbx), %rdi
movq %r12, %rdx
callq 0x26110
jmp 0xde1e0
xorl %r12d, %r12d
movq 0x8(%r14), %rdx
subq %r12, %rdx
je 0xde1fa
movq (%r14), %rsi
addq %r12, %rsi
addq (%rbx), %r12
movq %r12, %rdi
callq 0x26080
movq %r15, 0x8(%rbx)
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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 0x26150
movq %r14, (%rbx)
movl %r12d, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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.CuOffset);
IO.mapOptional("AddressSize", ARange.AddrSize);
IO.mapOptional("SegmentSelectorSize", ARange.SegSize, 0);
IO.mapOptional("Descriptors", ARange.Descriptors);
}
|
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 0x8375e(%rip), %rsi # 0x1634cb
leaq 0x8(%rsp), %rcx
leaq 0x7(%rsp), %r9
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x82f70
leaq 0x18(%rbx), %rdx
leaq 0x7e045(%rip), %rsi # 0x15ddd2
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x35254
leaq 0x20(%rbx), %rdx
leaq 0x83619(%rip), %rsi # 0x1633c3
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl $0x1, %ecx
movq %r15, %r8
callq 0x84944
leaq 0x28(%rbx), %rdx
movb %bpl, 0x1(%r15)
leaq 0x835fe(%rip), %rsi # 0x1633cc
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r9
movq %r14, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xadd70
leaq 0x2a(%rbx), %rdx
movb %bpl, (%r15)
leaq 0x835e4(%rip), %rsi # 0x1633d8
leaq 0x8(%rsp), %rcx
leaq 0x7(%rsp), %r9
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x82a10
addq $0x30, %rbx
leaq 0x835d8(%rip), %rsi # 0x1633ec
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0xeca3a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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", Unit.AbbrevTableID);
IO.mapOptional("AbbrOffset", Unit.AbbrOffset);
IO.mapOptional("AddrSize", Unit.AddrSize);
IO.mapOptional("Entries", Unit.Entries);
}
|
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 0x8344c(%rip), %rsi # 0x1634cb
leaq 0x8(%rsp), %rcx
leaq 0x7(%rsp), %r9
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x82f70
leaq 0x18(%rbx), %rdx
leaq 0x7dd33(%rip), %rsi # 0x15ddd2
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x35254
cmpw $0x5, 0x18(%rbx)
jb 0xe00d5
leaq 0x1c(%rbx), %rdx
leaq 0x83371(%rip), %rsi # 0x163434
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0xed316
leaq 0x20(%rbx), %rdx
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movb %bpl, 0x8(%r15)
leaq 0x83352(%rip), %rsi # 0x16343d
leaq 0x7(%rsp), %r9
movq %r14, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x84afa
leaq 0x30(%rbx), %rdx
movb %bpl, 0x8(%r15)
leaq 0x8333e(%rip), %rsi # 0x16344b
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r9
movq %r14, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x82f70
leaq 0x1a(%rbx), %rdx
movb %bpl, 0x1(%r15)
leaq 0x832d9(%rip), %rsi # 0x16340d
leaq 0x8(%rsp), %rcx
leaq 0x7(%rsp), %r9
movq %r14, %rdi
xorl %r8d, %r8d
callq 0xa0c56
addq $0x40, %rbx
leaq 0x7cd4c(%rip), %rsi # 0x15cea0
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0xed4f0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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", LoclistEntry.Descriptions);
}
|
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
leaq 0x20(%rbx), %rdx
movb $0x0, 0x8(%r15)
leaq 0x82c61(%rip), %rsi # 0x16353c
leaq 0x10(%rsp), %rcx
leaq 0xf(%rsp), %r9
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x82f70
addq $0x30, %rbx
leaq 0x82c54(%rip), %rsi # 0x16354f
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0xf13fa
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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<std::vector<llvm::DWARFYAML::StringOffsetsTable, std::allocator<llvm::DWARFYAML::StringOffsetsTable>>> const&, bool, llvm::yaml::EmptyContext&)
|
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;
const bool sameAsDefault = outputting() && !Val;
if (!outputting() && !Val)
Val = T();
if (Val &&
this->preflightKey(Key, Required, sameAsDefault, UseDefault, SaveInfo)) {
// When reading an std::optional<X> key from a YAML description, we allow
// the special "<none>" value, which can be used to specify that no value
// was requested, i.e. the DefaultValue will be assigned. The DefaultValue
// is usually None.
bool IsNone = false;
if (!outputting())
if (const auto *Node =
dyn_cast<ScalarNode>(((Input *)this)->getCurrentNode()))
// We use rtrim to ignore possible white spaces that might exist when a
// comment is present on the same line.
IsNone = Node->getRawValue().rtrim(' ') == "<none>";
if (IsNone)
Val = DefaultValue;
else
yamlize(*this, *Val, Required, Ctx);
this->postflightKey(SaveInfo);
} else {
if (UseDefault)
Val = DefaultValue;
}
}
|
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
callq *0x10(%rax)
movb 0x18(%r14), %cl
testb %al, %al
jne 0xe2abb
testb $0x1, %cl
jne 0xe2abb
xorps %xmm0, %xmm0
movq %r15, 0x10(%rsp)
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xe2bd4
movq %r15, %rdi
movq 0x10(%rsp), %r15
callq 0x2dca8
movb 0x18(%r14), %cl
testb $0x1, %cl
je 0xe2b26
xorb $0x1, %r13b
andb %r13b, %r12b
movq (%rbx), %rax
movzbl %bpl, %ebp
movzbl %r12b, %ecx
leaq 0xf(%rsp), %r8
leaq 0x28(%rsp), %r9
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movl %ebp, %edx
callq *0x78(%rax)
testb %al, %al
je 0xe2b1f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xe2b40
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq 0x18(%rsp), %rcx
callq 0xe2c3f
movq 0x28(%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
jmp 0xe2b31
testb $0x1, 0xf(%rsp)
je 0xe2b31
movq %r14, %rdi
movq %r15, %rsi
callq 0x89bc0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x116140
testq %rax, %rax
je 0xe2afa
cmpl $0x1, 0x20(%rax)
jne 0xe2afa
movq %r15, %r13
movq 0x48(%rax), %rcx
movq 0x50(%rax), %r12
leaq 0x30(%rsp), %r15
movq %rcx, (%r15)
movq %r12, 0x8(%r15)
movq %r15, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x10bc4a
incq %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
movq %rcx, %rdx
subq %r12, %rdx
addq %rax, %rdx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
cmpq $0x6, %rdx
jne 0xe2afa
movq 0x30(%rsp), %rax
movl $0x6e6f6e3c, %ecx # imm = 0x6E6F6E3C
xorl (%rax), %ecx
movzwl 0x4(%rax), %eax
xorl $0x3e65, %eax # imm = 0x3E65
orl %ecx, %eax
jne 0xe2afa
movq %r13, %rsi
movq %r14, %rdi
callq 0x89bc0
jmp 0xe2b0c
nop
|
/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::DWARFYAML::ListTable<llvm::DWARFYAML::RnglistEntry>>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::DWARFYAML::ListTable<llvm::DWARFYAML::RnglistEntry>, std::allocator<llvm::DWARFYAML::ListTable<llvm::DWARFYAML::RnglistEntry>>>&, 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) {
void *SaveInfo;
if ( io.preflightFlowElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightFlowElement(SaveInfo);
}
}
io.endFlowSequence();
}
else {
unsigned incnt = io.beginSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
void *SaveInfo;
if ( io.preflightElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightElement(SaveInfo);
}
}
io.endSequence();
}
}
|
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, %ebp # imm = 0xAAAAAAAB
testl %ebp, %ebp
je 0xe3222
movl %ebp, %ebp
xorl %r15d, %r15d
movq %rsp, %r12
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq *0x20(%rax)
testb %al, %al
je 0xe321a
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %r15, %rcx
ja 0xe31e5
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xe3d66
movq (%r14), %rax
leaq (%r15,%r15,2), %r13
shlq $0x5, %r13
addq %rax, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xe323a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq (%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
incq %r15
cmpq %rbp, %r15
jne 0xe31a2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 # 0x1d206e
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2b608
movq %rbx, %rax
popq %rbx
retq
|
/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, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x77348
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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::allocator<llvm::DWARFYAML::Abbrev>>&, 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) {
void *SaveInfo;
if ( io.preflightFlowElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightFlowElement(SaveInfo);
}
}
io.endFlowSequence();
}
else {
unsigned incnt = io.beginSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
void *SaveInfo;
if ( io.preflightElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightElement(SaveInfo);
}
}
io.endSequence();
}
}
|
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, %ebp # imm = 0xAAAAAAAB
testl %ebp, %ebp
je 0xe5596
movl %ebp, %ebp
xorl %r15d, %r15d
movq %rsp, %r12
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq *0x20(%rax)
testb %al, %al
je 0xe558e
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %r15, %rcx
ja 0xe5559
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xe55ae
movq (%r14), %rax
leaq (%r15,%r15,2), %r13
shlq $0x4, %r13
addq %rax, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xdfa80
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq (%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
incq %r15
cmpq %rbp, %r15
jne 0xe5516
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 %r14, %rdi
callq *0x10(%rax)
cmpw $0x1, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dd1d(%rip), %rsi # 0x1635aa
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe589f
movw $0x1, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dcfe(%rip), %rsi # 0x1635bc
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe58d0
movw $0x2, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x3, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dcdf(%rip), %rsi # 0x1635ce
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5901
movw $0x3, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x4, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dcc1(%rip), %rsi # 0x1635e1
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5932
movw $0x4, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x5, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dca8(%rip), %rsi # 0x1635f9
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5963
movw $0x5, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x8, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dc8f(%rip), %rsi # 0x163611
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5994
movw $0x8, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xa, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dc7a(%rip), %rsi # 0x16362d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe59c5
movw $0xa, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xb, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dc56(%rip), %rsi # 0x16363a
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe59f6
movw $0xb, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xd, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dc3a(%rip), %rsi # 0x16364f
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5a27
movw $0xd, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xf, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dc17(%rip), %rsi # 0x16365d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5a58
movw $0xf, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x10, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dbfa(%rip), %rsi # 0x163671
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5a89
movw $0x10, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x11, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dbdf(%rip), %rsi # 0x163687
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5aba
movw $0x11, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x12, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dbc2(%rip), %rsi # 0x16369b
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5aeb
movw $0x12, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x13, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dba4(%rip), %rsi # 0x1636ae
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5b1c
movw $0x13, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x15, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7db89(%rip), %rsi # 0x1636c4
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5b4d
movw $0x15, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x16, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7db6f(%rip), %rsi # 0x1636db
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5b7e
movw $0x16, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x17, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7db4d(%rip), %rsi # 0x1636ea
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5baf
movw $0x17, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x18, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7db2e(%rip), %rsi # 0x1636fc
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5be0
movw $0x18, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x19, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7db1b(%rip), %rsi # 0x16371a
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5c11
movw $0x19, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1a, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7daf9(%rip), %rsi # 0x163729
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5c42
movw $0x1a, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1b, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dadc(%rip), %rsi # 0x16373d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5c73
movw $0x1b, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1c, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7dac3(%rip), %rsi # 0x163755
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5ca4
movw $0x1c, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1d, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7daa5(%rip), %rsi # 0x163768
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5cd5
movw $0x1d, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1e, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7da8e(%rip), %rsi # 0x163782
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5d06
movw $0x1e, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1f, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7da6b(%rip), %rsi # 0x163790
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5d37
movw $0x1f, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x20, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7da54(%rip), %rsi # 0x1637aa
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5d68
movw $0x20, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x21, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7da33(%rip), %rsi # 0x1637ba
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5d99
movw $0x21, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x22, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7da17(%rip), %rsi # 0x1637cf
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5dca
movw $0x22, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x23, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d9f7(%rip), %rsi # 0x1637e0
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5dfb
movw $0x23, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x24, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d9e0(%rip), %rsi # 0x1637fa
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5e2c
movw $0x24, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x25, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d9c0(%rip), %rsi # 0x16380b
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5e5d
movw $0x25, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x26, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d9a2(%rip), %rsi # 0x16381e
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5e8e
movw $0x26, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x27, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d983(%rip), %rsi # 0x163830
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5ebf
movw $0x27, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x28, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d962(%rip), %rsi # 0x163840
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5ef0
movw $0x28, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x29, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d943(%rip), %rsi # 0x163852
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5f21
movw $0x29, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2a, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d923(%rip), %rsi # 0x163863
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5f52
movw $0x2a, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2b, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d900(%rip), %rsi # 0x163871
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5f83
movw $0x2b, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2c, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d8df(%rip), %rsi # 0x163881
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5fb4
movw $0x2c, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2d, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d8c3(%rip), %rsi # 0x163896
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe5fe5
movw $0x2d, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2e, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d8a5(%rip), %rsi # 0x1638a9
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6016
movw $0x2e, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2f, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d886(%rip), %rsi # 0x1638bb
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6047
movw $0x2f, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x30, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d874(%rip), %rsi # 0x1638da
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6078
movw $0x30, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x31, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d863(%rip), %rsi # 0x1638fa
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe60a9
movw $0x31, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x32, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d845(%rip), %rsi # 0x16390d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe60da
movw $0x32, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x33, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d825(%rip), %rsi # 0x16391e
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe610b
movw $0x33, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x34, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d808(%rip), %rsi # 0x163932
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe613c
movw $0x34, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x35, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d7e7(%rip), %rsi # 0x163942
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe616d
movw $0x35, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x36, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d7cb(%rip), %rsi # 0x163957
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe619e
movw $0x36, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x37, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d7b1(%rip), %rsi # 0x16396e
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe61cf
movw $0x37, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x38, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d795(%rip), %rsi # 0x163983
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6200
movw $0x38, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x39, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d77a(%rip), %rsi # 0x163999
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6231
movw $0x39, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x3a, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d75a(%rip), %rsi # 0x1639aa
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6262
movw $0x3a, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x3b, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d740(%rip), %rsi # 0x1639c1
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6293
movw $0x3b, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x3c, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d727(%rip), %rsi # 0x1639d9
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe62c4
movw $0x3c, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x3d, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d70a(%rip), %rsi # 0x1639ed
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe62f5
movw $0x3d, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x3f, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d6ee(%rip), %rsi # 0x163a02
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6326
movw $0x3f, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x40, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d6ce(%rip), %rsi # 0x163a13
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6357
movw $0x40, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x41, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d6b0(%rip), %rsi # 0x163a26
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6388
movw $0x41, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x42, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d690(%rip), %rsi # 0x163a37
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe63b9
movw $0x42, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x43, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d67c(%rip), %rsi # 0x163a54
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe63ea
movw $0x43, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x44, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d661(%rip), %rsi # 0x163a6a
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe641b
movw $0x44, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x45, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d644(%rip), %rsi # 0x163a7e
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe644c
movw $0x45, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x46, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d62b(%rip), %rsi # 0x163a96
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe647d
movw $0x46, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x47, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d60e(%rip), %rsi # 0x163aaa
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe64ae
movw $0x47, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x48, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d5f0(%rip), %rsi # 0x163abd
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe64df
movw $0x48, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x49, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d5d0(%rip), %rsi # 0x163ace
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6510
movw $0x49, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x4a, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d5ba(%rip), %rsi # 0x163ae9
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6541
movw $0x4a, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x4b, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d59e(%rip), %rsi # 0x163afe
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6572
movw $0x4b, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4081, %ecx # imm = 0x4081
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d57e(%rip), %rsi # 0x163b14
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe65a8
movw $0x4081, (%rbx) # imm = 0x4081
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4101, %ecx # imm = 0x4101
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d559(%rip), %rsi # 0x163b25
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe65de
movw $0x4101, (%rbx) # imm = 0x4101
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4102, %ecx # imm = 0x4102
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d537(%rip), %rsi # 0x163b39
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6614
movw $0x4102, (%rbx) # imm = 0x4102
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4103, %ecx # imm = 0x4103
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d51a(%rip), %rsi # 0x163b52
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe664a
movw $0x4103, (%rbx) # imm = 0x4103
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4104, %ecx # imm = 0x4104
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d4fa(%rip), %rsi # 0x163b68
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6680
movw $0x4104, (%rbx) # imm = 0x4104
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4105, %ecx # imm = 0x4105
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d4d5(%rip), %rsi # 0x163b79
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe66b6
movw $0x4105, (%rbx) # imm = 0x4105
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4106, %ecx # imm = 0x4106
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d4b0(%rip), %rsi # 0x163b8a
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe66ec
movw $0x4106, (%rbx) # imm = 0x4106
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4107, %ecx # imm = 0x4107
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d49d(%rip), %rsi # 0x163bad
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6722
movw $0x4107, (%rbx) # imm = 0x4107
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4108, %ecx # imm = 0x4108
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d48a(%rip), %rsi # 0x163bd0
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6758
movw $0x4108, (%rbx) # imm = 0x4108
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4109, %ecx # imm = 0x4109
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d475(%rip), %rsi # 0x163bf1
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe678e
movw $0x4109, (%rbx) # imm = 0x4109
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x410a, %ecx # imm = 0x410A
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d454(%rip), %rsi # 0x163c06
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe67c4
movw $0x410a, (%rbx) # imm = 0x410A
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4200, %ecx # imm = 0x4200
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d43d(%rip), %rsi # 0x163c25
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe67fa
movw $0x4200, (%rbx) # imm = 0x4200
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4201, %ecx # imm = 0x4201
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d41d(%rip), %rsi # 0x163c3b
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6830
movw $0x4201, (%rbx) # imm = 0x4201
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4202, %ecx # imm = 0x4202
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d404(%rip), %rsi # 0x163c58
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6866
movw $0x4202, (%rbx) # imm = 0x4202
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4203, %ecx # imm = 0x4203
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d3e8(%rip), %rsi # 0x163c72
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe689c
movw $0x4203, (%rbx) # imm = 0x4203
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4204, %ecx # imm = 0x4204
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d3cd(%rip), %rsi # 0x163c8d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe68d2
movw $0x4204, (%rbx) # imm = 0x4204
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4205, %ecx # imm = 0x4205
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d3b1(%rip), %rsi # 0x163ca7
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6908
movw $0x4205, (%rbx) # imm = 0x4205
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4206, %ecx # imm = 0x4206
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d39b(%rip), %rsi # 0x163cc7
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe693e
movw $0x4206, (%rbx) # imm = 0x4206
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4207, %ecx # imm = 0x4207
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d37a(%rip), %rsi # 0x163cdc
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6974
movw $0x4207, (%rbx) # imm = 0x4207
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4208, %ecx # imm = 0x4208
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d35a(%rip), %rsi # 0x163cf2
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe69aa
movw $0x4208, (%rbx) # imm = 0x4208
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4209, %ecx # imm = 0x4209
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d33e(%rip), %rsi # 0x163d0c
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe69e0
movw $0x4209, (%rbx) # imm = 0x4209
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x420a, %ecx # imm = 0x420A
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d323(%rip), %rsi # 0x163d27
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6a16
movw $0x420a, (%rbx) # imm = 0x420A
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x420b, %ecx # imm = 0x420B
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d302(%rip), %rsi # 0x163d3c
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6a4c
movw $0x420b, (%rbx) # imm = 0x420B
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x420c, %ecx # imm = 0x420C
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d2dc(%rip), %rsi # 0x163d4c
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6a82
movw $0x420c, (%rbx) # imm = 0x420C
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x420d, %ecx # imm = 0x420D
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d2bf(%rip), %rsi # 0x163d65
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6ab8
movw $0x420d, (%rbx) # imm = 0x420D
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x42ff, %ecx # imm = 0x42FF
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d2aa(%rip), %rsi # 0x163d86
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6aee
movw $0x42ff, (%rbx) # imm = 0x42FF
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x4300, %ecx # imm = 0x4300
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d282(%rip), %rsi # 0x163d94
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6b24
movw $0x4300, (%rbx) # imm = 0x4300
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x5101, %ecx # imm = 0x5101
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d265(%rip), %rsi # 0x163dad
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6b5a
movw $0x5101, (%rbx) # imm = 0x5101
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x5102, %ecx # imm = 0x5102
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d247(%rip), %rsi # 0x163dc5
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6b90
movw $0x5102, (%rbx) # imm = 0x5102
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x5103, %ecx # imm = 0x5103
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d22d(%rip), %rsi # 0x163de1
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6bc6
movw $0x5103, (%rbx) # imm = 0x5103
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x5111, %ecx # imm = 0x5111
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d214(%rip), %rsi # 0x163dfe
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6bfc
movw $0x5111, (%rbx) # imm = 0x5111
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x6000, %ecx # imm = 0x6000
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d1f0(%rip), %rsi # 0x163e10
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6c32
movw $0x6000, (%rbx) # imm = 0x6000
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x8004, %ecx # imm = 0x8004
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d1d1(%rip), %rsi # 0x163e27
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6c68
movw $0x8004, (%rbx) # imm = 0x8004
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x8005, %ecx # imm = 0x8005
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d1b0(%rip), %rsi # 0x163e3c
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6c9e
movw $0x8005, (%rbx) # imm = 0x8005
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x8006, %ecx # imm = 0x8006
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d195(%rip), %rsi # 0x163e57
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6cd4
movw $0x8006, (%rbx) # imm = 0x8006
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x8007, %ecx # imm = 0x8007
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d17c(%rip), %rsi # 0x163e74
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6d0a
movw $0x8007, (%rbx) # imm = 0x8007
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x8765, %ecx # imm = 0x8765
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d166(%rip), %rsi # 0x163e94
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6d40
movw $0x8765, (%rbx) # imm = 0x8765
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x8766, %ecx # imm = 0x8766
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d147(%rip), %rsi # 0x163eab
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6d76
movw $0x8766, (%rbx) # imm = 0x8766
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x8767, %ecx # imm = 0x8767
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d128(%rip), %rsi # 0x163ec2
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6dac
movw $0x8767, (%rbx) # imm = 0x8767
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0xa000, %ecx # imm = 0xA000
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d105(%rip), %rsi # 0x163ed5
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6de2
movw $0xa000, (%rbx) # imm = 0xA000
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0xa020, %ecx # imm = 0xA020
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d0e5(%rip), %rsi # 0x163eeb
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6e18
movw $0xa020, (%rbx) # imm = 0xA020
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0xb000, %ecx # imm = 0xB000
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d0ca(%rip), %rsi # 0x163f06
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6e4e
movw $0xb000, (%rbx) # imm = 0xB000
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0xb001, %ecx # imm = 0xB001
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d0ac(%rip), %rsi # 0x163f1e
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6e84
movw $0xb001, (%rbx) # imm = 0xB001
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0xb002, %ecx # imm = 0xB002
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d093(%rip), %rsi # 0x163f3b
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6eba
movw $0xb002, (%rbx) # imm = 0xB002
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0xb003, %ecx # imm = 0xB003
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d081(%rip), %rsi # 0x163f5f
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6ef0
movw $0xb003, (%rbx) # imm = 0xB003
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0xb004, %ecx # imm = 0xB004
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7d065(%rip), %rsi # 0x163f79
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe6f26
movw $0xb004, (%rbx) # imm = 0xB004
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe6f38
|
/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::vector<llvm::DWARFYAML::AttributeAbbrev, std::allocator<llvm::DWARFYAML::AttributeAbbrev>>&, 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) {
void *SaveInfo;
if ( io.preflightFlowElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightFlowElement(SaveInfo);
}
}
io.endFlowSequence();
}
else {
unsigned incnt = io.beginSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
void *SaveInfo;
if ( io.preflightElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightElement(SaveInfo);
}
}
io.endSequence();
}
}
|
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 0xe720e
movl %ecx, %ebp
xorl %r15d, %r15d
movq %rsp, %r12
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq *0x20(%rax)
testb %al, %al
je 0xe7206
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r15, %rcx
ja 0xe71d2
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xe7226
movq (%r14), %rax
movq %r15, %r13
shlq $0x4, %r13
addq %rax, %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xdfc6e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq (%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
incq %r15
cmpq %rbp, %r15
jne 0xe719d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 %r14, %rdi
callq *0x10(%rax)
cmpw $0x3, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c992(%rip), %rsi # 0x164041
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe76c1
movw $0x3, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x4, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c970(%rip), %rsi # 0x164050
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe76f2
movw $0x4, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x5, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c94e(%rip), %rsi # 0x16405f
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7723
movw $0x5, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x6, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c92b(%rip), %rsi # 0x16406d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7754
movw $0x6, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x7, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c908(%rip), %rsi # 0x16407b
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7785
movw $0x7, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x8, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c8e5(%rip), %rsi # 0x164089
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe77b6
movw $0x8, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x9, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c8c3(%rip), %rsi # 0x164098
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe77e7
movw $0x9, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xa, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c8a0(%rip), %rsi # 0x1640a6
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7818
movw $0xa, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xb, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c87e(%rip), %rsi # 0x1640b5
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7849
movw $0xb, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xc, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c85b(%rip), %rsi # 0x1640c3
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe787a
movw $0xc, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xd, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c837(%rip), %rsi # 0x1640d0
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe78ab
movw $0xd, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xe, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c814(%rip), %rsi # 0x1640de
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe78dc
movw $0xe, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0xf, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c7f0(%rip), %rsi # 0x1640eb
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe790d
movw $0xf, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x10, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c7cd(%rip), %rsi # 0x1640f9
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe793e
movw $0x10, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x11, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c7ad(%rip), %rsi # 0x16410a
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe796f
movw $0x11, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x12, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c789(%rip), %rsi # 0x164117
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe79a0
movw $0x12, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x13, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c765(%rip), %rsi # 0x164124
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe79d1
movw $0x13, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x14, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c741(%rip), %rsi # 0x164131
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7a02
movw $0x14, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x15, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c71d(%rip), %rsi # 0x16413e
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7a33
movw $0x15, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x16, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c6fe(%rip), %rsi # 0x164150
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7a64
movw $0x16, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x17, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c6de(%rip), %rsi # 0x164161
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7a95
movw $0x17, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x18, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c6c0(%rip), %rsi # 0x164174
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7ac6
movw $0x18, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x19, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c69f(%rip), %rsi # 0x164184
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7af7
movw $0x19, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x20, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c683(%rip), %rsi # 0x164199
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7b28
movw $0x20, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1a, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c663(%rip), %rsi # 0x1641aa
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7b59
movw $0x1a, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1b, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c63f(%rip), %rsi # 0x1641b7
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7b8a
movw $0x1b, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1c, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c61c(%rip), %rsi # 0x1641c5
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7bbb
movw $0x1c, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1d, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c5fc(%rip), %rsi # 0x1641d6
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7bec
movw $0x1d, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1e, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c5dc(%rip), %rsi # 0x1641e7
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7c1d
movw $0x1e, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x1f, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c5ba(%rip), %rsi # 0x1641f6
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7c4e
movw $0x1f, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x21, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c59b(%rip), %rsi # 0x164208
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7c7f
movw $0x21, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x22, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c581(%rip), %rsi # 0x16421f
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7cb0
movw $0x22, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x23, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c561(%rip), %rsi # 0x164230
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7ce1
movw $0x23, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x24, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c541(%rip), %rsi # 0x164241
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7d12
movw $0x24, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x25, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c521(%rip), %rsi # 0x164252
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7d43
movw $0x25, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x26, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c4fe(%rip), %rsi # 0x164260
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7d74
movw $0x26, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x27, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c4db(%rip), %rsi # 0x16426e
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7da5
movw $0x27, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x28, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c4b8(%rip), %rsi # 0x16427c
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7dd6
movw $0x28, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x29, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c495(%rip), %rsi # 0x16428a
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7e07
movw $0x29, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2a, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c473(%rip), %rsi # 0x164299
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7e38
movw $0x2a, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2b, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c451(%rip), %rsi # 0x1642a8
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7e69
movw $0x2b, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpw $0x2c, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c42f(%rip), %rsi # 0x1642b7
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7e9a
movw $0x2c, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x1f01, %ecx # imm = 0x1F01
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c408(%rip), %rsi # 0x1642c6
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7ed0
movw $0x1f01, (%rbx) # imm = 0x1F01
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x1f02, %ecx # imm = 0x1F02
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c3e9(%rip), %rsi # 0x1642dd
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7f06
movw $0x1f02, (%rbx) # imm = 0x1F02
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x1f20, %ecx # imm = 0x1F20
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c3c9(%rip), %rsi # 0x1642f3
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7f3c
movw $0x1f20, (%rbx) # imm = 0x1F20
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x1f21, %ecx # imm = 0x1F21
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c3a7(%rip), %rsi # 0x164307
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7f72
movw $0x1f21, (%rbx) # imm = 0x1F21
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movzwl (%rbx), %ecx
cmpl $0x2001, %ecx # imm = 0x2001
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x7c386(%rip), %rsi # 0x16431c
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xe7fa8
movw $0x2001, (%rbx) # imm = 0x2001
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe7fba
|
/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 i;
for (i = 0; i != width / APINT_BITS_PER_WORD; i++)
Result.U.pVal[i] = U.pVal[i];
// Truncate and copy any partial word.
unsigned bits = (0 - width) % APINT_BITS_PER_WORD;
if (bits != 0)
Result.U.pVal[i] = U.pVal[i] << bits >> bits;
return Result;
}
|
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 %r14, %rsi
callq 0xf8c46
jmp 0xf8e45
movl %ebp, %edi
addq $0x3f, %rdi
shrq $0x3, %rdi
andl $-0x8, %edi
callq 0x262e0
movl %ebp, 0x8(%rbx)
movq %rax, (%rbx)
movl %ebp, %eax
shrl $0x6, %eax
xorl %ecx, %ecx
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rdx
movq (%rbx), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xf8e0f
negl %ebp
andl $0x3f, %ebp
je 0xf8e45
movq (%r14), %rcx
shll $0x3, %eax
movq (%rcx,%rax), %rdx
movl %ebp, %ecx
shlq %cl, %rdx
shrq %cl, %rdx
movq (%rbx), %rcx
movq %rdx, (%rcx,%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/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, %rax
cmpq %r15, %rax
jae 0xfaa25
movl $0x30, %edi
callq 0x26100
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0xfa61c
jmp 0xfaa2f
addq %r15, %rcx
movq %rcx, 0x38(%r14)
xorl %r14d, %r14d
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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))))
return E;
return Error::success();
}
|
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
movq %r15, %rcx
subq 0x38(%r14), %rcx
jbe 0xfb659
cmpq $0x40, %rcx
cmovaeq %r13, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xfb66e
cmpq $0x0, (%rbx)
je 0xfb632
jmp 0xfb660
movq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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, %rsp
retq
cmpb $0x1, 0x94(%rdi)
jne 0xfba0f
cmpl %edx, 0x90(%rdi)
jne 0xfba0f
retq
nop
|
/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), %rcx # 0x167ab0
movq %rcx, (%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x67310(%rip), %rax # 0x1678e8
movq %rax, 0x10(%r15)
movw $0x302, 0x20(%r15) # imm = 0x302
callq 0x118879
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xfff4c
jmp 0x10060c
movq 0x80(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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, %rax
jne 0x1027f0
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movb %dl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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
movl (%rbx), %eax
andl $0x1f, %eax
shll $0x9, %eax
orw %ax, 0xa(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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 %r14
retq
|
/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::OptionHidden const&, llvm::cl::desc const&, llvm::cl::initializer<int> const&)
|
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), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r14)
movups (%r15), %xmm0
movups %xmm0, 0x20(%r14)
movq (%rbx), %rax
movslq (%rax), %rax
movq %rax, 0x80(%r14)
movb $0x1, 0x98(%r14)
movq %rax, 0x90(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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];
if (Bucket && Bucket != getTombstoneVal())
return std::make_pair(iterator(TheTable + BucketNo, false),
false); // Already exists in map.
if (Bucket == getTombstoneVal())
--NumTombstones;
Bucket =
MapEntryTy::create(Key, getAllocator(), std::forward<ArgsTy>(Args)...);
++NumItems;
assert(NumItems + NumTombstones <= NumBuckets);
BucketNo = RehashTable(BucketNo);
return std::make_pair(iterator(TheTable + BucketNo, false), true);
}
|
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), %rax
addq $0x8, %rbx
testq %rax, %rax
je 0x1174fe
cmpq $-0x8, %rax
je 0x1174fe
xorl %edx, %edx
jmp 0x11758b
decl 0x10(%r14)
leaq 0x21(%r15), %rdi
movl $0x8, %esi
callq 0x109347
movq %rax, %r13
testq %r15, %r15
je 0x117541
movq %r13, %rdi
addq $0x20, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x26080
movb $0x0, 0x20(%r13,%r15)
movq %r15, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13)
movq $0x0, 0x18(%r13)
movq %r13, (%rbx)
incl 0xc(%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x10b746
movl %eax, %ebx
shlq $0x3, %rbx
addq (%r14), %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x117583
cmpq $-0x8, %rax
jne 0x117589
addq $0x8, %rbx
jmp 0x117575
movb $0x1, %dl
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x117a34
movl %r13d, %eax
andl $0xb, %eax
cmpl $0x3, %eax
je 0x117a05
cmpl $0x9, %r13d
je 0x117a05
cmpl $0x5, %r13d
jne 0x117a19
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x50a8d(%rip), %rsi # 0x1684a1
callq 0x4d6ea
incq %r13
cmpq $0x10, %r13
jne 0x1179d2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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:
RightIndent = Difference;
break;
case FormattedString::JustifyRight:
LeftIndent = Difference;
break;
case FormattedString::JustifyCenter:
LeftIndent = Difference / 2;
RightIndent = Difference - LeftIndent;
break;
}
}
indent(LeftIndent);
(*this) << FS.Str;
indent(RightIndent);
return *this;
}
|
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, %rdi
callq 0x118198
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x4d6ea
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x118198
movq %r14, %rsi
shrq %rsi
subl %esi, %r14d
jmp 0x118165
nop
|
/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, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x117ecc
subl %r15d, %ebp
jne 0x118341
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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. Note that when we do this, we consider ourself
// the owner of stdout and may set the "binary" flag globally based on Flags.
if (Filename == "-") {
EC = std::error_code();
// Change stdout's text/binary mode based on the Flags.
sys::ChangeStdoutMode(Flags);
return STDOUT_FILENO;
}
int FD;
if (Access & sys::fs::FA_Read)
EC = sys::fs::openFileForReadWrite(Filename, FD, Disp, Flags);
else
EC = sys::fs::openFileForWrite(Filename, FD, Disp, Flags);
if (EC)
return -1;
return FD;
}
|
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) # imm = 0x105
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
movl %ecx, %edx
movl $0x2, %ecx
jmp 0x11855b
movw $0x105, 0x20(%rax) # imm = 0x105
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
movl %ecx, %edx
movl $0x3, %ecx
movl %ebp, %r8d
movl $0x1b6, %r9d # imm = 0x1B6
callq 0x11c182
movl %eax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
orl 0xc(%rsp), %ecx
movl %ecx, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
|
/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 0x117ecc
movq %r12, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x118716
nop
|
/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, kSecret, 0);
return XXH3_hashLong_64b(in, len, kSecret, sizeof(kSecret));
}
|
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, %rax
shrq $0x25, %rax
xorq %rdx, %rax
jmp 0x118e5a
cmpq $0x80, %rsi
ja 0x118e73
movabsq $-0x61c8864e7a143579, %r8 # imm = 0x9E3779B185EBCA87
movabsq $-0x41b45bdcc6930148, %rcx # imm = 0xBE4BA423396CFEB8
xorq (%rdi), %rcx
imulq %rsi, %r8
movabsq $0x1cad21f72c81017c, %rax # imm = 0x1CAD21F72C81017C
xorq 0x8(%rdi), %rax
mulq %rcx
movq %rdx, %rcx
movabsq $-0x24686f7c16922b22, %rdx # imm = 0xDB979083E96DD4DE
xorq -0x10(%rdi,%rsi), %rdx
xorq %rax, %rcx
movabsq $0x1f67b3b7a4a44072, %rax # imm = 0x1F67B3B7A4A44072
xorq -0x8(%rdi,%rsi), %rax
addq %r8, %rcx
mulq %rdx
movq %rdx, %r9
xorq %rax, %r9
cmpq $0x21, %rsi
jb 0x118e4d
movabsq $0x78e5c0cc4ee679cb, %rdx # imm = 0x78E5C0CC4EE679CB
xorq 0x10(%rdi), %rdx
movabsq $0x2172ffcc7dd05a82, %rax # imm = 0x2172FFCC7DD05A82
xorq 0x18(%rdi), %rax
mulq %rdx
xorq %rax, %rdx
movabsq $-0x71dbbc088bb9f748, %r8 # imm = 0x8E2443F7744608B8
xorq -0x20(%rdi,%rsi), %r8
addq %rdx, %rcx
movabsq $0x4c263a81e69035e0, %rax # imm = 0x4C263A81E69035E0
xorq -0x18(%rdi,%rsi), %rax
mulq %r8
movq %rdx, %r8
xorq %rax, %r8
addq %r9, %r8
cmpq $0x41, %rsi
jb 0x118e4a
movabsq $-0x34ff3c6e44add7c4, %rdx # imm = 0xCB00C391BB52283C
xorq 0x20(%rdi), %rdx
movabsq $-0x5cd1ace4749a2f78, %rax # imm = 0xA32E531B8B65D088
xorq 0x28(%rdi), %rax
mulq %rdx
xorq %rax, %rdx
movabsq $0x4ef90da297486471, %r9 # imm = 0x4EF90DA297486471
xorq -0x30(%rdi,%rsi), %r9
addq %rdx, %rcx
movabsq $-0x27532156b910e6c8, %rax # imm = 0xD8ACDEA946EF1938
xorq -0x28(%rdi,%rsi), %rax
mulq %r9
xorq %rax, %rdx
addq %rdx, %r8
cmpq $0x61, %rsi
jb 0x118e4a
movabsq $0x3f349ce33f76faa8, %rdx # imm = 0x3F349CE33F76FAA8
xorq 0x30(%rdi), %rdx
movabsq $0x1d4f0bc7c7bbdcf9, %rax # imm = 0x1D4F0BC7C7BBDCF9
xorq 0x38(%rdi), %rax
mulq %rdx
xorq %rax, %rdx
movabsq $0x3159b4cd4be0518a, %r9 # imm = 0x3159B4CD4BE0518A
xorq -0x40(%rdi,%rsi), %r9
addq %rdx, %rcx
movabsq $0x647378d9c97e9fc8, %rax # imm = 0x647378D9C97E9FC8
xorq -0x38(%rdi,%rsi), %rax
mulq %r9
xorq %rax, %rdx
addq %rdx, %r8
movq %r8, %r9
addq %r9, %rcx
movq %rcx, %rax
shrq $0x25, %rax
xorq %rcx, %rax
movabsq $0x165667919e3779f9, %rcx # imm = 0x165667919E3779F9
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
xorq %rcx, %rax
retq
cmpq $0xf0, %rsi
jbe 0x118ef5
jmp 0x11907a
cmpq $0x4, %rsi
jb 0x118ee1
movl -0x4(%rdi,%rsi), %eax
movl (%rdi), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movabsq $-0x38c54e8b3a132a5e, %rax # imm = 0xC73AB174C5ECD5A2
xorq %rcx, %rax
movq %rax, %rcx
rolq $0x31, %rcx
movq %rax, %rdx
rolq $0x18, %rdx
xorq %rcx, %rdx
xorq %rax, %rdx
movabsq $-0x604de39ae16720db, %rax # imm = 0x9FB21C651E98DF25
imulq %rax, %rdx
movq %rdx, %rcx
shrq $0x23, %rcx
addq %rsi, %rcx
xorq %rdx, %rcx
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x1c, %rax
jmp 0x118e6f
testq %rsi, %rsi
jne 0x119271
movabsq $0x2d06800538d394c2, %rax # imm = 0x2D06800538D394C2
retq
|
/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 '/' as a '.', unless it is the root dir.
if (Position == Path.size() && !Path.empty() &&
is_separator(Path.back(), S) &&
(root_dir_pos == StringRef::npos || end_pos - 1 > root_dir_pos)) {
--Position;
Component = ".";
return *this;
}
// Find next separator.
size_t start_pos = filename_pos(Path.substr(0, end_pos), S);
Component = Path.slice(start_pos, end_pos);
Position = start_pos;
return *this;
}
|
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(%rdi,%rsi), %r10b
cmpb $0x5c, %r10b
sete %r9b
cmpb $0x2f, %r10b
je 0x1196b2
andb %r8b, %r9b
je 0x1196bc
decq %rsi
jne 0x11968e
xorl %r14d, %r14d
jmp 0x1196bf
movq %rsi, %r14
movq 0x8(%rbx), %rsi
cmpq %rsi, %rcx
setne %dl
testq %rsi, %rsi
sete %r8b
orb %dl, %r8b
jne 0x1196f8
movb -0x1(%rdi,%rcx), %dl
cmpb $0x2f, %dl
je 0x1196e9
cmpb $0x5c, %dl
jne 0x1196f8
cmpl $0x2, 0x28(%rbx)
jb 0x1196f8
cmpq $-0x1, %rax
je 0x119740
leaq -0x1(%r14), %rdx
cmpq %rax, %rdx
ja 0x119740
cmpq %r14, %rsi
cmovaeq %r14, %rsi
movl 0x28(%rbx), %edx
callq 0x119832
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
movq %rax, %rdx
cmovbq %rcx, %rdx
cmpq %r14, %rdx
cmovaq %rax, %r14
cmpq %rcx, %r14
cmovaeq %rcx, %r14
subq %rdx, %r14
addq (%rbx), %rdx
movq %rdx, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
decq %rcx
movq %rcx, 0x20(%rbx)
leaq 0x5099f(%rip), %rax # 0x16a0ed
movq %rax, 0x10(%rbx)
movq $0x1, 0x18(%rbx)
jmp 0x119735
|
/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_drive) {
if ((++pos != e) && is_separator((*pos)[0], style)) {
// {C:/,//net/}, so get the first two components.
return path.substr(0, b->size() + pos->size());
}
// just {C:,//net}, return the first component.
return *b;
}
// POSIX style root directory.
if (is_separator((*b)[0], style)) {
return *b;
}
}
return StringRef();
}
|
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)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpq %rbx, (%r14)
jne 0x11997b
cmpq %r15, 0x50(%rsp)
jne 0x11997b
xorl %r14d, %r14d
xorl %ebx, %ebx
jmp 0x119a3f
movq 0x48(%rsp), %r14
cmpq $0x3, %r14
jb 0x1199ac
movq 0x40(%rsp), %rax
movb (%rax), %cl
cmpb $0x2f, %cl
je 0x1199a4
cmpl $0x2, %ebp
setb %dl
cmpb $0x5c, %cl
setne %sil
orb %dl, %sil
jne 0x1199ac
cmpb %cl, 0x1(%rax)
sete %al
jmp 0x1199ae
xorl %eax, %eax
cmpl $0x2, %ebp
setb %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x1199ce
movq 0x40(%rsp), %rcx
cmpb $0x3a, -0x1(%rcx,%r14)
sete %cl
jmp 0x1199d0
xorl %ecx, %ecx
orb %cl, %al
cmpb $0x1, %al
jne 0x119a11
movq %rsp, %r12
movq %r12, %rdi
callq 0x1194d2
cmpq %rbx, (%r12)
jne 0x1199ee
cmpq %r15, 0x20(%rsp)
je 0x119a0a
cmpl $0x2, %ebp
setae %al
movq 0x10(%rsp), %rcx
movb (%rcx), %dl
cmpb $0x5c, %dl
sete %cl
cmpb $0x2f, %dl
je 0x119a33
andb %cl, %al
jne 0x119a33
movq 0x40(%rsp), %rbx
jmp 0x119a3f
cmpl $0x2, %ebp
setae %al
movq 0x40(%rsp), %rbx
movb (%rbx), %dl
cmpb $0x5c, %dl
sete %cl
cmpb $0x2f, %dl
je 0x119a3f
andb %cl, %al
je 0x119971
jmp 0x119a3f
addq 0x18(%rsp), %r14
cmpq %r14, %r15
cmovbq %r15, %r14
movq %rbx, %rax
movq %r14, %rdx
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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 combine because that formation can have varying
// argument types.
size_t partial_store_size = buffer_end - buffer_ptr;
memcpy(buffer_ptr, &data, partial_store_size);
// If the store fails, our buffer is full and ready to hash. We have to
// either initialize the hash state (on the first full buffer) or mix
// this buffer into the existing hash state. Length tracks the *hashed*
// length, not the buffered length.
if (length == 0) {
state = state.create(buffer, seed);
length = 64;
} else {
// Mix this chunk into the current state and bump length up by 64.
state.mix(buffer);
length += 64;
}
// Reset the buffer_ptr to the head of the buffer for the next chunk of
// data.
buffer_ptr = buffer;
// Try again to store into the buffer -- this cannot fail as we only
// store types smaller than the buffer.
if (!store_and_advance(buffer_ptr, buffer_end, data,
partial_store_size))
llvm_unreachable("buffer smaller than stored type");
}
return buffer_ptr;
}
|
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(%rbx), %rdi
movq %rbx, %rsi
callq 0xf9dd4
movq (%r12), %rax
addq $0x40, %rax
jmp 0x11cbcd
movq %r8, (%rdx)
jmp 0x11cbf3
movq 0x78(%rbx), %rdx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0xf9d2c
movq 0x30(%r13), %rax
movq %rax, 0x70(%rbx)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x60(%rbx)
movups %xmm1, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movl $0x40, %eax
movq %rax, (%r12)
movl $0x8, %edx
subq %r15, %rdx
leaq (%rbx,%rdx), %r13
cmpq %r14, %r13
ja 0x11cbf0
leaq (%rsp,%r15), %rsi
movq %rbx, %rdi
callq 0x26080
jmp 0x11cbf3
movq %rbx, %r13
movq %r13, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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::ProcessStatistics>*, llvm::BitVector*)
|
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, bool *ExecutionFailed,
std::optional<ProcessStatistics> *ProcStat,
BitVector *AffinityMask) {
assert(Redirects.empty() || Redirects.size() == 3);
ProcessInfo PI;
if (Execute(PI, Program, Args, Env, Redirects, MemoryLimit, ErrMsg,
AffinityMask, /*DetachProcess=*/false)) {
if (ExecutionFailed)
*ExecutionFailed = false;
ProcessInfo Result = Wait(
PI, SecondsToWait == 0 ? std::nullopt : std::optional(SecondsToWait),
ErrMsg, ProcStat);
return Result.ReturnCode;
}
if (ExecutionFailed)
*ExecutionFailed = true;
return -1;
}
|
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 %xmm0, (%rsp)
movq %r15, 0x28(%rsp)
movl 0xb0(%rsp), %eax
movl %eax, 0x20(%rsp)
movq %r14, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
leaq 0x4c(%rsp), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r12, %r8
movq 0x40(%rsp), %r9
callq 0x11cdcc
testb %al, %al
je 0x11cda8
movq 0xc8(%rsp), %rcx
movl 0xa8(%rsp), %eax
movq 0xc0(%rsp), %rdx
testq %rdx, %rdx
je 0x11cd7f
movb $0x0, (%rdx)
xorl %edx, %edx
testl %eax, %eax
setne %dl
shlq $0x20, %rdx
movl %eax, %esi
orq %rdx, %rsi
leaq 0x4c(%rsp), %rdi
movq 0xb8(%rsp), %rdx
xorl %r8d, %r8d
callq 0x11d78f
movl %edx, %eax
jmp 0x11cdbd
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq 0xc0(%rsp), %rcx
testq %rcx, %rcx
je 0x11cdbd
movb $0x1, (%rcx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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) {
UTF32 ch;
unsigned short bytesToWrite = 0;
const UTF32 byteMask = 0xBF;
const UTF32 byteMark = 0x80;
const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
ch = *source++;
/* If we have a surrogate pair, convert to UTF32 first. */
if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
/* If the 16 bits following the high surrogate are in the source buffer... */
if (source < sourceEnd) {
UTF32 ch2 = *source;
/* If it's a low surrogate, convert to UTF32. */
if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
+ (ch2 - UNI_SUR_LOW_START) + halfBase;
++source;
} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
--source; /* return to the illegal value itself */
result = sourceIllegal;
break;
}
} else { /* We don't have the 16 bits following the high surrogate. */
--source; /* return to the high surrogate */
result = sourceExhausted;
break;
}
} else if (flags == strictConversion) {
/* UTF-16 surrogate values are illegal in UTF-32 */
if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
--source; /* return to the illegal value itself */
result = sourceIllegal;
break;
}
}
/* Figure out how many bytes the result will require */
if (ch < (UTF32)0x80) { bytesToWrite = 1;
} else if (ch < (UTF32)0x800) { bytesToWrite = 2;
} else if (ch < (UTF32)0x10000) { bytesToWrite = 3;
} else if (ch < (UTF32)0x110000) { bytesToWrite = 4;
} else { bytesToWrite = 3;
ch = UNI_REPLACEMENT_CHAR;
}
target += bytesToWrite;
if (target > targetEnd) {
source = oldSource; /* Back up source pointer! */
target -= bytesToWrite; result = targetExhausted; break;
}
switch (bytesToWrite) { /* note: everything falls through. */
case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]);
}
target += bytesToWrite;
}
*sourceStart = source;
*targetStart = target;
return result;
}
|
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 = 0xFC00
cmpl $0xd800, %ebp # imm = 0xD800
jne 0x120a3e
cmpq %rsi, %r11
jae 0x120b08
movzwl (%r11), %r12d
movl %r12d, %ebp
andl $0xfc00, %ebp # imm = 0xFC00
cmpl $0xdc00, %ebp # imm = 0xDC00
jne 0x120a53
shll $0xa, %ebx
addl %r12d, %ebx
addl $0xfca02400, %ebx # imm = 0xFCA02400
leaq 0x4(%r15), %r11
jmp 0x120a5c
testl %r8d, %r8d
jne 0x120a5c
movzwl %bp, %ebp
cmpl $0xdc00, %ebp # imm = 0xDC00
jne 0x120a5c
jmp 0x120b01
testl %r8d, %r8d
je 0x120b01
movw $0x1, %bp
cmpl $0x80, %ebx
jb 0x120a82
movw $0x2, %bp
cmpl $0x800, %ebx # imm = 0x800
jb 0x120a82
cmpl $0x10000, %ebx # imm = 0x10000
movw $0x4, %bp
sbbw $0x0, %bp
movzwl %bp, %r12d
leaq (%r14,%r12), %r13
cmpq %rcx, %r13
ja 0x120afa
leal -0x1(%r12), %r14d
movslq (%r9,%r14,4), %r14
addq %r9, %r14
jmpq *%r14
movl %ebx, %ebp
andb $0x3f, %bpl
orb $-0x80, %bpl
movb %bpl, -0x1(%r13)
decq %r13
shrl $0x6, %ebx
movl %ebx, %ebp
andb $0x3f, %bpl
orb $-0x80, %bpl
movb %bpl, -0x1(%r13)
decq %r13
shrl $0x6, %ebx
movl %ebx, %ebp
andb $0x3f, %bpl
orb $-0x80, %bpl
movb %bpl, -0x1(%r13)
decq %r13
shrl $0x6, %ebx
orb (%r12,%r10), %bl
movb %bl, -0x1(%r13)
leaq (%r12,%r13), %r14
decq %r14
movq %r11, %r15
cmpq %rsi, %r11
jb 0x1209f6
movq %r11, %r15
jmp 0x120b0d
movl $0x2, %eax
jmp 0x120b0d
movl $0x3, %eax
jmp 0x120b0d
movl $0x1, %eax
movq %r15, (%rdi)
movq %r14, (%rdx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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->getBufferSize();
assert(Sz <= std::numeric_limits<T>::max());
StringRef S = Buffer->getBuffer();
for (size_t N = 0; N < Sz; ++N) {
if (S[N] == '\n')
Offsets->push_back(static_cast<T>(N));
}
OffsetCache = Offsets;
return *Offsets;
}
|
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, %r13
je 0x122cb0
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %ebp, %ebp
leaq 0x6(%rsp), %r15
cmpb $0xa, (%r12,%rbp)
jne 0x122ca8
movw %bp, 0x6(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x122c9d
movw %bp, (%rsi)
addq $0x2, %rsi
movq %rsi, 0x8(%r14)
jmp 0x122ca8
movq %r14, %rdi
movq %r15, %rdx
callq 0x122cc6
incq %rbp
cmpq %rbp, %r13
jne 0x122c7a
movq %r14, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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(%rip), %rax # 0x238e50
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x114783(%rip), %rax # 0x238bf8
addq $0x10, %rax
movq %rax, 0x98(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
leaq -0xf8110(%rip), %rax # 0x2c382
movq %rax, 0xb8(%r14)
leaq -0xf811c(%rip), %rax # 0x2c384
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x12511c
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfba70
|
/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
movw %cx, 0xa(%r12)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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::DenseMapPair<unsigned int, unsigned int>*, llvm::detail::DenseMapPair<unsigned int, unsigned int>*)
|
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::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
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 %rdx, %rcx
addq $0x4, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
xorl %edx, %edx
movdqa 0x37d99(%rip), %xmm1 # 0x15d3e0
movdqa 0x2df71(%rip), %xmm2 # 0x1535c0
movdqa 0x2df79(%rip), %xmm3 # 0x1535d0
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x1256a9
movl $0xffffffff, (%rax,%rdx,8) # imm = 0xFFFFFFFF
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x1256c0
movl $0xffffffff, 0x8(%rax,%rdx,8) # imm = 0xFFFFFFFF
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x1256fd
movl $0xffffffff, 0x10(%rax,%rdx,8) # imm = 0xFFFFFFFF
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x125710
movl $0xffffffff, 0x18(%rax,%rdx,8) # imm = 0xFFFFFFFF
addq $0x4, %rdx
cmpq %rdx, %rcx
jne 0x12565f
cmpq %rbx, %r14
je 0x125756
movq %rsp, %r12
cmpl $-0x3, (%r14)
ja 0x12574d
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x12536c
movq (%rsp), %rax
movl (%r14), %ecx
movl %ecx, (%rax)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
incl 0x8(%r15)
addq $0x8, %r14
cmpq %rbx, %r14
jne 0x125725
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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
movb %al, 0x90(%r14)
movl (%r15), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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->setPosition(pos);
Callback(Val);
return false;
}
|
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), %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %rbp
xorl %r13d, %r13d
cmpq %r14, 0x8(%r12,%r13)
jne 0x12665c
testq %r14, %r14
je 0x1266c0
movq (%r12,%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x264f0
testl %eax, %eax
je 0x1266c0
addq $0x30, %r13
cmpq %r13, %rbp
jne 0x12663d
leaq 0x8(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0xabbe1(%rip), %rcx # 0x1d2258
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
leaq 0x30(%rsp), %r14
movq %rax, (%r14)
leaq 0x465a6(%rip), %rax # 0x16cc37
movq %rax, 0x10(%r14)
movw $0x302, 0x20(%r14) # imm = 0x302
callq 0x118879
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xfff4c
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0x1266c9
jmp 0x1266f4
movl 0x28(%r12,%r13), %r15d
movl %r15d, (%rsp)
movl %r15d, 0x80(%rbx)
movl 0x4(%rsp), %eax
movw %ax, 0xc(%rbx)
cmpq $0x0, 0x248(%rbx)
je 0x126703
leaq 0x238(%rbx), %rdi
movq %rsp, %rsi
callq *0x250(%rbx)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x26800
|
/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(%rip), %rax # 0x238e50
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x112143(%rip), %rax # 0x238bf8
addq $0x10, %rax
movq %rax, 0x98(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
leaq -0xfa750(%rip), %rax # 0x2c382
movq %rax, 0xb8(%r14)
leaq -0xfa75c(%rip), %rax # 0x2c384
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x126d5a
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfba70
|
/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=*/true, /*IsLocal=*/false,
/*CanAutoHide=*/false, GlobalValueSummary::ImportKind::Definition),
/*NumInsts=*/0, FunctionSummary::FFlags{}, /*EntryCount=*/0,
std::vector<ValueInfo>(), std::move(Edges),
std::vector<GlobalValue::GUID>(),
std::vector<FunctionSummary::VFuncId>(),
std::vector<FunctionSummary::VFuncId>(),
std::vector<FunctionSummary::ConstVCall>(),
std::vector<FunctionSummary::ConstVCall>(),
std::vector<FunctionSummary::ParamAccess>(),
std::vector<CallsiteInfo>(), std::vector<AllocInfo>());
}
|
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 %rcx, 0x10(%rsi)
movups %xmm0, (%rsi)
leaq 0x30(%rsp), %r10
movq %rcx, 0x10(%r10)
movaps %xmm0, (%r10)
leaq 0x10(%rsp), %r11
movaps %xmm0, (%r11)
movq %rcx, 0x10(%r11)
leaq 0x90(%rsp), %rbx
movaps %xmm0, (%rbx)
movq %rcx, 0x10(%rbx)
leaq 0x130(%rsp), %r14
movaps %xmm0, (%r14)
movq %rcx, 0x10(%r14)
leaq 0x110(%rsp), %r15
movaps %xmm0, (%r15)
movq %rcx, 0x10(%r15)
leaq 0xf0(%rsp), %r12
movaps %xmm0, (%r12)
movq %rcx, 0x10(%r12)
leaq 0xd0(%rsp), %r13
movaps %xmm0, (%r13)
movq %rcx, 0x10(%r13)
leaq 0xb0(%rsp), %rbp
movq %rcx, 0x10(%rbp)
movaps %xmm0, (%rbp)
subq $0x8, %rsp
movq %rdi, 0x10(%rsp)
movl $0xc1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rbp
pushq %r13
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
pushq %rax
callq 0x1249b8
addq $0x50, %rsp
movq %rbp, %rdi
callq 0x12487c
movq %r13, %rdi
callq 0x1248a4
movq %r12, %rdi
callq 0x124802
movq %r15, %rdi
callq 0x1248cc
movq %r14, %rdi
callq 0x1248cc
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x126ce4
movq 0xa0(%rsp), %rsi
subq %rdi, %rsi
callq 0x260c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x126cfb
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x260c0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x126d12
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x260c0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x126d29
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x260c0
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x126d43
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x260c0
movq 0x8(%rsp), %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 false;
}
return O.error("Cannot find option named '" + ArgVal + "'!");
}
|
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), %r12
xorl %ebp, %ebp
cmpq %r14, 0x8(%r13,%rbp)
jne 0x1280a6
testq %r14, %r14
je 0x1280ff
movq (%r13,%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x264f0
testl %eax, %eax
je 0x1280ff
addq $0x30, %rbp
cmpq %rbp, %r12
jne 0x128086
leaq 0x8(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0xaa197(%rip), %rcx # 0x1d2258
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
leaq 0x30(%rsp), %r14
movq %rax, (%r14)
leaq 0x44b5c(%rip), %rax # 0x16cc37
movq %rax, 0x10(%r14)
movw $0x302, 0x20(%r14) # imm = 0x302
callq 0x118879
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xfff4c
jmp 0x128110
movl 0x28(%r13,%rbp), %eax
movq 0x90(%rsp), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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::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 const (&) [13], llvm::cl::desc const&, llvm::cl::MiscFlags const&, llvm::cl::OptionHidden 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, %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, %eax
orw 0xa(%rbx), %ax
movw %ax, 0xa(%rbx)
movl (%r14), %ecx
shll $0x5, %ecx
andl $0x60, %ecx
andl $-0x61, %eax
orl %ecx, %eax
movw %ax, 0xa(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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->setPosition(pos);
Callback(Val);
return false;
}
|
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 %eax, %ebp
testb %al, %al
jne 0x128ba2
cmpq $0x0, 0x18(%rsp)
je 0x128b81
movl %r14d, 0xc(%rsp)
movq 0x80(%rbx), %r14
movl $0x20, %edi
callq 0x26100
movq %rax, %r15
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0x111463(%rip), %rax # 0x239f68
addq $0x10, %rax
movq %rax, (%r15)
leaq 0x10(%r15), %r12
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x1415ba
movq %r12, (%r14)
movq 0x8(%r14), %rdi
movq %r15, 0x8(%r14)
testq %rdi, %rdi
je 0x128b3c
callq 0x2e070
movq (%r14), %r12
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x30(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x141642
testb %al, %al
je 0x128bd2
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x128b7c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x260c0
movl 0xc(%rsp), %r14d
movw %r14w, 0xc(%rbx)
cmpq $0x0, 0xa8(%rbx)
je 0x128bcd
leaq 0x98(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq *0xb0(%rbx)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x128bb9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x260c0
movl %ebp, %eax
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x26800
leaq 0xb582b(%rip), %rax # 0x1de404
leaq 0xc8(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, %bp # imm = 0x103
movw %bp, 0x20(%rsi)
movw $0x104, %r12w # imm = 0x104
leaq 0xa0(%rsp), %rdx
movw %r12w, 0x20(%rdx)
leaq 0x10(%rsp), %rax
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rbx
movq %rbx, %rdi
callq 0x931ba
leaq 0xb5804(%rip), %rax # 0x1de421
leaq 0x78(%rsp), %rdx
movq %rax, (%rdx)
movw %bp, 0x20(%rdx)
leaq 0x118(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x931ba
leaq 0x50(%rsp), %rdx
movw %r12w, 0x20(%rdx)
movq %r15, (%rdx)
leaq 0x140(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x931ba
movq %rbx, %rdi
xorl %esi, %esi
callq 0x108702
|
/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::ValueExpected>(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 const&, llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::LocationClass<(anonymous namespace)::PassRemarksOpt> const&, llvm::cl::ValueExpected const&)
|
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
leaq 0x3f207(%rip), %rax # 0x167fcd
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movw $0x103, 0x20(%r14) # imm = 0x103
callq 0x118879
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xfff4c
movzwl 0xa(%rbx), %eax
jmp 0x128dfc
movq (%r9), %rcx
movq %rcx, 0x80(%rbx)
movl (%r15), %ecx
andl $0x3, %ecx
andl $-0x19, %eax
leal (%rax,%rcx,8), %eax
movw %ax, 0xa(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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], llvm::cl::desc const&, llvm::cl::initializer<llvm::cl::boolOrDefault> const&, llvm::cl::OptionHidden 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), %rax
movl (%rax), %eax
movl %eax, 0x80(%r13)
movb $0x1, 0x94(%r13)
movl %eax, 0x90(%r13)
movl (%rbx), %eax
movzwl 0xa(%r13), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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::ProgramSignatureElement const&, unsigned long)
|
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::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
}
|
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, %sil
jne 0x129e70
leaq 0x10(%r14), %rsi
movl $0x20, %ecx
movq %r14, %rdi
callq 0x10abf4
jmp 0x129e33
subq %rcx, %rbx
leaq 0x10(%r14), %rsi
movl $0x20, %ecx
movq %r14, %rdi
callq 0x10abf4
addq (%r14), %rbx
jmp 0x129e33
|
/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 = Start;
Size = Start + S.size() + (K != RAW);
}
return 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), %rsi
movb 0x24(%rbx), %cl
movl $0x1, %eax
shlq %cl, %rax
leaq (%rsi,%rax), %rcx
decq %rcx
negq %rax
andq %rcx, %rax
movq %rax, 0x10(%rdx)
movl %r14d, %ecx
xorl %edx, %edx
cmpl $0x6, 0x20(%rbx)
setne %dl
addq %rcx, %rdx
addq %rax, %rdx
movq %rdx, 0x18(%rbx)
jmp 0x12b332
movq 0x10(%rdx), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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 (%rax), %rdi
movl 0x8(%rax), %esi
movq $-0x2, %rdx
xorl %ecx, %ecx
callq 0x2be4e
testb %al, %al
je 0x12b4cb
movq (%rbx), %rax
addq $0x18, %rax
movq %rax, (%rbx)
cmpq 0x8(%rbx), %rax
jne 0x12b479
popq %rbx
retq
nop
|
/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 (%rax), %rdi
movl 0x8(%rax), %esi
movq $-0x2, %rdx
xorl %ecx, %ecx
callq 0x2be4e
testb %al, %al
je 0x12b549
movq (%rbx), %rax
addq $0x18, %rax
movq %rax, (%rbx)
cmpq 0x8(%rbx), %rax
jne 0x12b4f7
popq %rbx
retq
nop
|
/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_MEMORY_ADDR_I64:
case R_WASM_MEMORY_ADDR_TLS_SLEB:
case R_WASM_MEMORY_ADDR_TLS_SLEB64:
case R_WASM_FUNCTION_OFFSET_I32:
case R_WASM_FUNCTION_OFFSET_I64:
case R_WASM_SECTION_OFFSET_I32:
case R_WASM_MEMORY_ADDR_LOCREL_I32:
return true;
default:
return false;
}
}
|
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);
if (auto EC = Mapping.Reader.readBytes(CVR.Data, RecordLength))
return EC;
assert(Mapping.Reader.getOffset() == EndOffset);
return Error::success();
}
|
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, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/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.getKey();
uint32_t Offset = Begin + Pair.getValue();
Writer.setOffset(Offset);
if (auto EC = Writer.writeCString(S))
return EC;
assert(Writer.getOffset() <= End);
}
Writer.setOffset(End);
assert((End - Begin) == StringSize);
return Error::success();
}
|
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), %ecx
movq %rax, %r15
testq %rcx, %rcx
je 0x1326c7
movq %rax, %r15
movq (%r15), %rdx
testq %rdx, %rdx
je 0x1326c1
cmpq $-0x8, %rdx
jne 0x1326c7
addq $0x8, %r15
jmp 0x1326b3
leaq (%rax,%rcx,8), %r13
cmpq %r13, %r15
je 0x13270c
movq (%r15), %rax
leaq 0x10(%rax), %rdx
movq (%rax), %rcx
movl 0x8(%rax), %eax
addl %r12d, %eax
movq %rax, 0x38(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfb3b6
cmpq $0x0, (%rbx)
jne 0x132719
addq $0x8, %r15
movq (%r15), %rax
testq %rax, %rax
je 0x1326f5
cmpq $-0x8, %rax
je 0x1326f5
cmpq %r13, %r15
jne 0x1326d3
movl %ebp, %eax
movq %rax, 0x38(%r14)
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.writeObject(DummyPrefix));
RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(ScratchBuffer.data());
CVType CVT(Prefix, sizeof(RecordPrefix));
cantFail(Mapping.visitTypeBegin(CVT));
cantFail(Mapping.visitKnownRecord(CVT, Record));
cantFail(Mapping.visitTypeEnd(CVT));
addPadding(Writer);
// Update the size and kind after serialization.
Prefix->RecordKind = CVT.kind();
Prefix->RecordLen = Writer.getOffset() - sizeof(uint16_t);
return {ScratchBuffer.data(), static_cast<size_t>(Writer.getOffset())};
}
|
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 0xb0(%rsp), %r15
movq %rbp, -0x20(%r15)
xorl %r14d, %r14d
movb %r14b, -0x16(%r15)
movb %r14b, -0x12(%r15)
movq %r15, -0x10(%r15)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%r15)
movq $0x0, 0x18(%r15)
movq %r12, %rsi
movq %r12, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movzwl (%r13), %eax
leaq 0x1c(%rsp), %rdx
movw $0x2, (%rdx)
movw %ax, 0x2(%rdx)
leaq 0x48(%rsp), %rdi
movl $0x4, %ecx
callq 0xfb382
movq %rbx, 0x10(%rsp)
movq (%rbx), %rbx
leaq 0x38(%rsp), %r12
movq %rbx, (%r12)
movq $0x4, 0x8(%r12)
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x139644
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq 0x13b8f4
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x139df0
leaq 0x50(%rsp), %rdi
callq 0x13377d
cmpq $0x4, 0x8(%r12)
jb 0x13370a
movq 0x38(%rsp), %rax
movzwl 0x2(%rax), %r14d
movw %r14w, 0x2(%rbx)
movl 0x88(%rsp), %eax
addl $-0x2, %eax
movw %ax, (%rbx)
movq 0x10(%rsp), %rax
movq (%rax), %rbx
movq 0x88(%rsp), %r14
movq %rbp, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0x133746
callq 0x26150
leaq 0x101dd3(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x133765
callq 0x2e070
movq %rbx, %rax
movq %r14, %rdx
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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.writeObject(DummyPrefix));
RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(ScratchBuffer.data());
CVType CVT(Prefix, sizeof(RecordPrefix));
cantFail(Mapping.visitTypeBegin(CVT));
cantFail(Mapping.visitKnownRecord(CVT, Record));
cantFail(Mapping.visitTypeEnd(CVT));
addPadding(Writer);
// Update the size and kind after serialization.
Prefix->RecordKind = CVT.kind();
Prefix->RecordLen = Writer.getOffset() - sizeof(uint16_t);
return {ScratchBuffer.data(), static_cast<size_t>(Writer.getOffset())};
}
|
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 0xb0(%rsp), %r15
movq %rbp, -0x20(%r15)
xorl %r14d, %r14d
movb %r14b, -0x16(%r15)
movb %r14b, -0x12(%r15)
movq %r15, -0x10(%r15)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%r15)
movq $0x0, 0x18(%r15)
movq %r12, %rsi
movq %r12, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movzwl (%r13), %eax
leaq 0x1c(%rsp), %rdx
movw $0x2, (%rdx)
movw %ax, 0x2(%rdx)
leaq 0x48(%rsp), %rdi
movl $0x4, %ecx
callq 0xfb382
movq %rbx, 0x10(%rsp)
movq (%rbx), %rbx
leaq 0x38(%rsp), %r12
movq %rbx, (%r12)
movq $0x4, 0x8(%r12)
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x139644
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq 0x13a86a
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x139df0
leaq 0x50(%rsp), %rdi
callq 0x13377d
cmpq $0x4, 0x8(%r12)
jb 0x133a8e
movq 0x38(%rsp), %rax
movzwl 0x2(%rax), %r14d
movw %r14w, 0x2(%rbx)
movl 0x88(%rsp), %eax
addl $-0x2, %eax
movw %ax, (%rbx)
movq 0x10(%rsp), %rax
movq (%rax), %rbx
movq 0x88(%rsp), %r14
movq %rbp, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0x133aca
callq 0x26150
leaq 0x101a4f(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x133ae9
callq 0x2e070
movq %rbx, %rax
movq %r14, %rdx
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.writeObject(DummyPrefix));
RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(ScratchBuffer.data());
CVType CVT(Prefix, sizeof(RecordPrefix));
cantFail(Mapping.visitTypeBegin(CVT));
cantFail(Mapping.visitKnownRecord(CVT, Record));
cantFail(Mapping.visitTypeEnd(CVT));
addPadding(Writer);
// Update the size and kind after serialization.
Prefix->RecordKind = CVT.kind();
Prefix->RecordLen = Writer.getOffset() - sizeof(uint16_t);
return {ScratchBuffer.data(), static_cast<size_t>(Writer.getOffset())};
}
|
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 0xb0(%rsp), %r15
movq %rbp, -0x20(%r15)
xorl %r14d, %r14d
movb %r14b, -0x16(%r15)
movb %r14b, -0x12(%r15)
movq %r15, -0x10(%r15)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%r15)
movq $0x0, 0x18(%r15)
movq %r12, %rsi
movq %r12, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movzwl (%r13), %eax
leaq 0x1c(%rsp), %rdx
movw $0x2, (%rdx)
movw %ax, 0x2(%rdx)
leaq 0x48(%rsp), %rdi
movl $0x4, %ecx
callq 0xfb382
movq %rbx, 0x10(%rsp)
movq (%rbx), %rbx
leaq 0x38(%rsp), %r12
movq %rbx, (%r12)
movq $0x4, 0x8(%r12)
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x139644
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq 0x13c692
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x139df0
leaq 0x50(%rsp), %rdi
callq 0x13377d
cmpq $0x4, 0x8(%r12)
jb 0x1343d6
movq 0x38(%rsp), %rax
movzwl 0x2(%rax), %r14d
movw %r14w, 0x2(%rbx)
movl 0x88(%rsp), %eax
addl $-0x2, %eax
movw %ax, (%rbx)
movq 0x10(%rsp), %rax
movq (%rax), %rbx
movq 0x88(%rsp), %r14
movq %rbp, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0x134412
callq 0x26150
leaq 0x101107(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x134431
callq 0x2e070
movq %rbx, %rax
movq %r14, %rdx
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.writeObject(DummyPrefix));
RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(ScratchBuffer.data());
CVType CVT(Prefix, sizeof(RecordPrefix));
cantFail(Mapping.visitTypeBegin(CVT));
cantFail(Mapping.visitKnownRecord(CVT, Record));
cantFail(Mapping.visitTypeEnd(CVT));
addPadding(Writer);
// Update the size and kind after serialization.
Prefix->RecordKind = CVT.kind();
Prefix->RecordLen = Writer.getOffset() - sizeof(uint16_t);
return {ScratchBuffer.data(), static_cast<size_t>(Writer.getOffset())};
}
|
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 0xb0(%rsp), %r15
movq %rbp, -0x20(%r15)
xorl %r14d, %r14d
movb %r14b, -0x16(%r15)
movb %r14b, -0x12(%r15)
movq %r15, -0x10(%r15)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%r15)
movq $0x0, 0x18(%r15)
movq %r12, %rsi
movq %r12, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movzwl (%r13), %eax
leaq 0x1c(%rsp), %rdx
movw $0x2, (%rdx)
movw %ax, 0x2(%rdx)
leaq 0x48(%rsp), %rdi
movl $0x4, %ecx
callq 0xfb382
movq %rbx, 0x10(%rsp)
movq (%rbx), %rbx
leaq 0x38(%rsp), %r12
movq %rbx, (%r12)
movq $0x4, 0x8(%r12)
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x139644
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq 0x13b6a4
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x139df0
leaq 0x50(%rsp), %rdi
callq 0x13377d
cmpq $0x4, 0x8(%r12)
jb 0x1351c2
movq 0x38(%rsp), %rax
movzwl 0x2(%rax), %r14d
movw %r14w, 0x2(%rbx)
movl 0x88(%rsp), %eax
addl $-0x2, %eax
movw %ax, (%rbx)
movq 0x10(%rsp), %rax
movq (%rax), %rbx
movq 0x88(%rsp), %r14
movq %rbp, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0x1351fe
callq 0x26150
leaq 0x10031b(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x13521d
callq 0x2e070
movq %rbx, %rax
movq %r14, %rdx
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.writeObject(DummyPrefix));
RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(ScratchBuffer.data());
CVType CVT(Prefix, sizeof(RecordPrefix));
cantFail(Mapping.visitTypeBegin(CVT));
cantFail(Mapping.visitKnownRecord(CVT, Record));
cantFail(Mapping.visitTypeEnd(CVT));
addPadding(Writer);
// Update the size and kind after serialization.
Prefix->RecordKind = CVT.kind();
Prefix->RecordLen = Writer.getOffset() - sizeof(uint16_t);
return {ScratchBuffer.data(), static_cast<size_t>(Writer.getOffset())};
}
|
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 0xb0(%rsp), %r15
movq %rbp, -0x20(%r15)
xorl %r14d, %r14d
movb %r14b, -0x16(%r15)
movb %r14b, -0x12(%r15)
movq %r15, -0x10(%r15)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%r15)
movq $0x0, 0x18(%r15)
movq %r12, %rsi
movq %r12, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movzwl (%r13), %eax
leaq 0x1c(%rsp), %rdx
movw $0x2, (%rdx)
movw %ax, 0x2(%rdx)
leaq 0x48(%rsp), %rdi
movl $0x4, %ecx
callq 0xfb382
movq %rbx, 0x10(%rsp)
movq (%rbx), %rbx
leaq 0x38(%rsp), %r12
movq %rbx, (%r12)
movq $0x4, 0x8(%r12)
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x139644
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq 0x13ceb6
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x139df0
leaq 0x50(%rsp), %rdi
callq 0x13377d
cmpq $0x4, 0x8(%r12)
jb 0x1354da
movq 0x38(%rsp), %rax
movzwl 0x2(%rax), %r14d
movw %r14w, 0x2(%rbx)
movl 0x88(%rsp), %eax
addl $-0x2, %eax
movw %ax, (%rbx)
movq 0x10(%rsp), %rax
movq (%rax), %rbx
movq 0x88(%rsp), %r14
movq %rbp, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0x135516
callq 0x26150
leaq 0x100003(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x135535
callq 0x2e070
movq %rbx, %rax
movq %r14, %rdx
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.writeObject(DummyPrefix));
RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(ScratchBuffer.data());
CVType CVT(Prefix, sizeof(RecordPrefix));
cantFail(Mapping.visitTypeBegin(CVT));
cantFail(Mapping.visitKnownRecord(CVT, Record));
cantFail(Mapping.visitTypeEnd(CVT));
addPadding(Writer);
// Update the size and kind after serialization.
Prefix->RecordKind = CVT.kind();
Prefix->RecordLen = Writer.getOffset() - sizeof(uint16_t);
return {ScratchBuffer.data(), static_cast<size_t>(Writer.getOffset())};
}
|
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 0xb0(%rsp), %r15
movq %rbp, -0x20(%r15)
xorl %r14d, %r14d
movb %r14b, -0x16(%r15)
movb %r14b, -0x12(%r15)
movq %r15, -0x10(%r15)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, -0x8(%r15)
movq $0x0, 0x18(%r15)
movq %r12, %rsi
movq %r12, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movzwl (%r13), %eax
leaq 0x1c(%rsp), %rdx
movw $0x2, (%rdx)
movw %ax, 0x2(%rdx)
leaq 0x48(%rsp), %rdi
movl $0x4, %ecx
callq 0xfb382
movq %rbx, 0x10(%rsp)
movq (%rbx), %rbx
leaq 0x38(%rsp), %r12
movq %rbx, (%r12)
movq $0x4, 0x8(%r12)
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x139644
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
callq 0x13d376
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x139df0
leaq 0x50(%rsp), %rdi
callq 0x13377d
cmpq $0x4, 0x8(%r12)
jb 0x1357f2
movq 0x38(%rsp), %rax
movzwl 0x2(%rax), %r14d
movw %r14w, 0x2(%rbx)
movl 0x88(%rsp), %eax
addl $-0x2, %eax
movw %ax, (%rbx)
movq 0x10(%rsp), %rax
movq (%rax), %rbx
movq 0x88(%rsp), %r14
movq %rbp, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0x13582e
callq 0x26150
leaq 0xffceb(%rip), %rax # 0x235520
addq $0x10, %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x13584d
callq 0x2e070
movq %rbx, %rax
movq %r14, %rdx
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 $0xff00, %ecx # imm = 0xFF00
movq %rcx, 0xff20(%rdi)
leaq 0xfd703(%rip), %rdx # 0x2366e8
addq $0x10, %rdx
movq %rdx, 0xff28(%rdi)
movl $0x1, 0xff30(%rdi)
movq %rax, 0xff38(%rdi)
movq %rcx, 0xff40(%rdi)
leaq 0xff48(%rdi), %r15
movq %r15, %rdi
callq 0xfb336
leaq 0x10d2aa(%rip), %rax # 0x2462c8
addq $0x10, %rax
movq %rax, 0xff88(%r14)
xorl %eax, %eax
movb %al, 0xff92(%r14)
leaq 0xffa8(%r14), %rcx
movq %rcx, 0xff98(%r14)
movabsq $0x200000000, %rcx # imm = 0x200000000
movq %rcx, 0xffa0(%r14)
movq $0x0, 0xffc0(%r14)
movq %r15, 0xffc8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xffd0(%r14)
movl %ebx, 0xffe0(%r14)
movb %al, 0xffea(%r14)
popq %rbx
popq %r14
popq %r15
retq
|
/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;
}
}
return Name;
}
|
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 $0x28, %rcx
cmpq %rcx, %rax
jne 0x13aa85
jmp 0x13aa99
xorl %edx, %edx
xorl %eax, %eax
retq
movq (%r8,%rcx), %rax
movq 0x8(%r8,%rcx), %rdx
retq
|
/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 lengthy names with
// a stringified hash value.
size_t BytesLeft = IO.maxFieldLength();
if (HasUniqueName) {
size_t BytesNeeded = Name.size() + UniqueName.size() + 2;
if (BytesNeeded > BytesLeft) {
// The minimum space required for emitting hashes of both names.
assert(BytesLeft >= 70);
// Replace the entire unique name with a hash of the unique name.
SmallString<32> Hash;
computeHashString(UniqueName, Hash);
std::string UniqueB = Twine("??@" + Hash + "@").str();
assert(UniqueB.size() == 36);
// Truncate the name if necessary and append a hash of the name.
// The name length, hash included, is limited to 4096 bytes.
const size_t MaxTakeN = 4096;
size_t TakeN = std::min(MaxTakeN, BytesLeft - UniqueB.size() - 2) - 32;
computeHashString(Name, Hash);
std::string NameB = (Name.take_front(TakeN) + Hash).str();
StringRef N = NameB;
StringRef U = UniqueB;
error(IO.mapStringZ(N));
error(IO.mapStringZ(U));
} else {
error(IO.mapStringZ(Name));
error(IO.mapStringZ(UniqueName));
}
} else {
// Cap the length of the string at however many bytes we have available,
// plus one for the required null terminator.
auto N = StringRef(Name).take_front(BytesLeft - 1);
error(IO.mapStringZ(N));
}
} else {
// Reading & Streaming mode come after writing mode is executed for each
// record. Truncating large names are done during writing, so its not
// necessary to do it while reading or streaming.
error(IO.mapStringZ(Name, "Name"));
if (HasUniqueName)
error(IO.mapStringZ(UniqueName, "LinkageName"));
}
return Error::success();
}
|
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 %bpl, %bpl
je 0x13c592
movq 0x8(%r15), %rax
movq 0x8(%r12), %rsi
addq %rsi, %rax
addq $0x2, %rax
cmpq %r13, %rax
jbe 0x13c5c3
leaq 0x18(%rsp), %rax
movq %rax, -0x18(%rax)
movq $0x0, -0x10(%rax)
movq $0x20, -0x8(%rax)
movq (%r12), %rdi
movq %rsp, %r12
movq %r12, %rdx
callq 0x13ea9a
movups (%r12), %xmm0
leaq 0x58(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0xa6db4(%rip), %rcx # 0x1e31cb
movq %rcx, (%rax)
movups %xmm0, 0x10(%rax)
leaq 0x90(%rsp), %rbp
movq %rax, (%rbp)
leaq 0xa1498(%rip), %rax # 0x1dd8c9
movq %rax, 0x10(%rbp)
movw $0x302, 0x20(%rbp) # imm = 0x302
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10d126
subq 0x8(%r12), %r13
addq $-0x2, %r13
movl $0x1000, %eax # imm = 0x1000
cmpq %rax, %r13
cmovaeq %rax, %r13
addq $-0x20, %r13
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rsp, %r12
movq %r12, %rdx
callq 0x13ea9a
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %r13, %rcx
cmovbq %rcx, %r13
movups (%r12), %xmm0
movq %rax, (%rbp)
movq %r13, 0x8(%rbp)
movups %xmm0, 0x10(%rbp)
movw $0x505, 0x20(%rbp) # imm = 0x505
leaq 0x58(%rsp), %r15
leaq 0x90(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x10d126
movups (%r15), %xmm0
leaq 0xb8(%rsp), %rdx
movups %xmm0, (%rdx)
leaq 0x38(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, 0x80(%rsp)
movw $0x101, 0x20(%r12) # imm = 0x101
leaq 0x90(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x140cfc
cmpq $0x0, (%rbx)
je 0x13c616
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13c512
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x260c0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13c52d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x260c0
movq (%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13c604
callq 0x26150
jmp 0x13c604
leaq 0x216ff(%rip), %rax # 0x15dc4f
movq %rsp, %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x140cfc
cmpq $0x0, (%rbx)
jne 0x13c604
testb %bpl, %bpl
je 0x13c5fd
leaq 0xa6c4b(%rip), %rax # 0x1e31cf
movq %rsp, %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
jmp 0x13c5e9
movq (%r15), %rax
movq 0x8(%r15), %rcx
decq %r13
cmpq %r13, %rcx
cmovbq %rcx, %r13
leaq 0x90(%rsp), %rdx
movq %rax, (%rdx)
movq %r13, 0x8(%rdx)
movq %rsp, %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x13c5f2
movq %rsp, %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x140cfc
cmpq $0x0, (%rbx)
jne 0x13c604
movq %rsp, %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x140cfc
cmpq $0x0, (%rbx)
jne 0x13c604
movq $0x0, (%rbx)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x90(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
leaq 0x80(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x140cfc
movq (%rbx), %r14
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13c655
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x260c0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13c670
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x260c0
movq (%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13c683
callq 0x26150
testq %r14, %r14
jne 0x13c604
jmp 0x13c5fd
nop
|
/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
addq $0x8, %r14
leaq 0xa62b0(%rip), %rax # 0x1e313c
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x140cfc
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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
leaq 0x6(%r14), %rdx
leaq 0x23fe0(%rip), %rax # 0x160ede
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140214
cmpq $0x0, (%rbx)
jne 0x13cf44
addq $0xc, %r14
leaq 0x23fc1(%rip), %rax # 0x160ee9
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x135cba
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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::success();
}
|
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(%rsi), %rsi
movq 0x40(%r12), %r13
testq %rsi, %rsi
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x13d245
testq %r13, %r13
jne 0x13d2eb
movzwl 0x10(%r15), %r13d
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x138c62
movq 0x48(%r12), %rdi
movq (%rdi), %rax
movq %r13, %rsi
movl $0x2, %edx
callq *0x8(%rax)
cmpq $0x0, 0x48(%r12)
je 0x13d1ee
cmpq $0x0, 0x38(%r12)
jne 0x13d1ee
cmpq $0x0, 0x40(%r12)
jne 0x13d1ee
addq $0x2, 0x50(%r12)
movl 0x10(%r15), %r13d
testq %r13, %r13
je 0x13d35d
movq 0x8(%r15), %r15
shlq $0x2, %r13
leaq 0x99522(%rip), %rbp # 0x1d672c
leaq 0x8(%rsp), %r12
movq %rbp, 0x8(%rsp)
movw $0x103, 0x28(%rsp) # imm = 0x103
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x140214
cmpq $0x0, (%rbx)
jne 0x13d364
addq $0x4, %r15
addq $-0x4, %r13
jne 0x13d20f
jmp 0x13d35d
testq %r13, %r13
setne %cl
orq %rsi, %rax
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x13d2eb
movl 0x10(%r15), %ebp
movq 0x18(%r13), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %ebp, %ecx
rolw $0x8, %cx
cmpl $0x1, %eax
cmovel %ebp, %ecx
leaq 0x8(%rsp), %rdx
movw %cx, (%rdx)
movl $0x2, %ecx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfb382
cmpq $0x0, (%rbx)
jne 0x13d364
movl 0x10(%r15), %r13d
testq %r13, %r13
je 0x13d35d
movq 0x8(%r15), %r15
shlq $0x2, %r13
leaq 0x99479(%rip), %rbp # 0x1d672c
leaq 0x8(%rsp), %r12
movq %rbp, 0x8(%rsp)
movw $0x103, 0x28(%rsp) # imm = 0x103
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x140214
cmpq $0x0, (%rbx)
jne 0x13d364
addq $0x4, %r15
addq $-0x4, %r13
jne 0x13d2b8
jmp 0x13d35d
leaq 0x2(%rsp), %rdx
movq %rbx, %rdi
callq 0xc53c6
cmpq $0x0, (%rbx)
jne 0x13d364
cmpw $0x0, 0x2(%rsp)
je 0x13d35d
addq $0x8, %r15
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
leaq 0x8(%rsp), %r13
movl $0x0, 0x4(%rsp)
leaq 0x99407(%rip), %rax # 0x1d672c
movq %rax, 0x8(%rsp)
movw $0x103, 0x28(%rsp) # imm = 0x103
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x140214
cmpq $0x0, (%rbx)
jne 0x13d364
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x13fc98
incl %ebp
cmpw 0x2(%rsp), %bp
jb 0x13d316
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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(IO.mapInteger(Record.Type, "BaseType"));
error(IO.mapEncodedInteger(Record.Offset, "BaseOffset"));
return Error::success();
}
|
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 0xa587b(%rip), %rsi # 0x1e3061
movq %rsp, %rbp
movq %rbp, %rdi
movq %r13, %rdx
callq 0x2b156
leaq 0x40(%rsp), %rcx
movw $0x104, 0x20(%rcx) # imm = 0x104
movq %rbp, (%rcx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x135d98
movq (%rbp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x13d82b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x260c0
cmpq $0x0, (%rbx)
jne 0x13d882
leaq 0x4(%r14), %rdx
leaq 0x23746(%rip), %rax # 0x160f82
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %rbx, %rdi
movq %r15, %rsi
callq 0x140214
cmpq $0x0, (%rbx)
jne 0x13d882
addq $0x8, %r14
leaq 0x224f2(%rip), %rax # 0x15fd58
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x140ab8
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13d89d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x260c0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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.