name string | code string | asm string | file string |
|---|---|---|---|
llvm::getArm64ECMangledFunctionName[abi:cxx11](llvm::StringRef) | std::optional<std::string> llvm::getArm64ECMangledFunctionName(StringRef Name) {
bool IsCppFn = Name[0] == '?';
if (IsCppFn && Name.contains("$$h"))
return std::nullopt;
if (!IsCppFn && Name[0] == '#')
return std::nullopt;
StringRef Prefix = "$$h";
size_t InsertIdx = 0;
if (IsCppFn) {
InsertIdx... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movb (%rsi), %al
cmpb $0x3f, %al
jne 0x2a750c6
leaq 0x2619af9(%rip), %rsi # 0x508eba6
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
xorl %ecx, %ecx
callq 0x2b56c06
cmpq $-0x1, %rax
jne 0x2a750d0
jmp 0x2a750e... | /IR/Mangler.cpp |
llvm::ReplaceableMetadataImpl::isReplaceable(llvm::Metadata const&) | bool ReplaceableMetadataImpl::isReplaceable(const Metadata &MD) {
if (auto *N = dyn_cast<MDNode>(&MD))
return !N->isResolved() || N->isAlwaysReplaceable();
return isa<ValueAsMetadata>(&MD) || isa<DIArgList>(&MD);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb1e29e
xorl %edx, %edx
testb %al, %al
cmovneq %rbx, %rdx
je 0x2a75a97
movb 0x1(%rdx), %sil
andb $0x7f, %sil
movb $0x1, %cl
cmpb $0x2, %sil
je 0x2a75a97
cmpl $0x0, -0x8(%rdx)
jne 0x2a75a97
cmpb $0x1e, (%rdx)
sete %cl
testb %al, %al
jne 0x2a75aad
movb (%rbx), %al
leal -0x1(%rax), %ecx
c... | /IR/Metadata.cpp |
llvm::ReplaceableMetadataImpl::getAllDbgVariableRecordUsers() | SmallVector<DbgVariableRecord *>
ReplaceableMetadataImpl::getAllDbgVariableRecordUsers() {
SmallVector<std::pair<OwnerTy, uint64_t> *> DVRUsersWithID;
for (auto Pair : UseMap) {
OwnerTy Owner = Pair.second.first;
if (Owner.isNull())
continue;
if (!Owner.is<DebugValueUser *>())
continue;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x600000000, %rcx # imm = 0x600000000
movq %rcx, -0x8(%rax)
movl 0x10(%rsi), %eax
cmpl $0x1, %eax
ja 0x2a75d79
leaq 0x18(%r14), %rcx
testl %eax, %... | /IR/Metadata.cpp |
llvm::MDString::get(llvm::LLVMContext&, llvm::StringRef) | MDString *MDString::get(LLVMContext &Context, StringRef Str) {
auto &Store = Context.pImpl->MDStringCache;
auto I = Store.try_emplace(Str);
auto &MapEntry = I.first->getValue();
if (!I.second)
return &MapEntry;
MapEntry.Entry = &*I.first;
return &MapEntry;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl $0x180, %r15d # imm = 0x180
addq (%rdi), %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2b55ff4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x2a80014
movq (%rax), %rax
testb $0x1, %dl
je 0x2a76bf3
movq %rax, 0x10(%ra... | /IR/Metadata.cpp |
llvm::DIObjCProperty::cloneImpl() const | TempDIObjCProperty cloneImpl() const {
return getTemporary(getContext(), getName(), getFile(), getLine(),
getGetterName(), getSetterName(), getAttributes(),
getType());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
je 0x2a7879c
movq (%rdi), %rdi
leaq -0x10(%rsi), %r10
movq -0x10(%rsi), %r11
testb $0x2, %r11b
jne 0x2a787b9
leal (%r11,%r11), %ecx
andl $0x78, %ecx
movq %r10, %r... | /llvm/IR/DebugInfoMetadata.h |
llvm::MDNode::makeDistinct() | void MDNode::makeDistinct() {
assert(isTemporary() && "Expected this to be temporary");
assert(!isResolved() && "Expected this to be unresolved");
// Drop RAUW support and store as a distinct node.
dropReplaceableUses();
storeDistinctInContext();
assert(isDistinct() && "Expected this to be distinct");
a... | pushq %rbx
movq %rdi, %rbx
callq 0x2a7916a
movq %rbx, %rdi
popq %rbx
jmp 0x2a791be
| /IR/Metadata.cpp |
llvm::MDNode::getMergedProfMetadata(llvm::MDNode*, llvm::MDNode*, llvm::Instruction const*, llvm::Instruction const*) | MDNode *MDNode::getMergedProfMetadata(MDNode *A, MDNode *B,
const Instruction *AInstr,
const Instruction *BInstr) {
if (!(A && B)) {
return A ? A : B;
}
assert(AInstr->getMetadata(LLVMContext::MD_prof) == A &&
"Caller should... | testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %r8b
testb %r8b, %al
je 0x2a7b9ba
xorl %eax, %eax
cmpb $0x55, (%rdx)
movl $0x0, %r8d
cmoveq %rdx, %r8
sete %r9b
cmpb $0x55, (%rcx)
sete %r10b
cmovneq %rax, %rcx
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x2a7b9c4
movq -0x20(%r8), %r9
xorl %eax, %eax
testq %r9, %r9
je 0x2a7b... | /IR/Metadata.cpp |
llvm::Value::getAllMetadata(llvm::SmallVectorImpl<std::pair<unsigned int, llvm::MDNode*>>&) const | bool hasMetadata() const { return (bool)HasMetadata; } | testb $0x20, 0x7(%rdi)
jne 0x2a7ca2d
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2a9f5fc
movl $0xaa0, %edi # imm = 0xAA0
addq (%rax), %rdi
movq %r14, %rsi
callq 0x2a822bc
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a7c5ba
nop
| /llvm/IR/Value.h |
std::pair<llvm::DenseMapIterator<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned ... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x2a7e5de
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x2a7ef4a
xorl %ecx, %ecx
jmp 0x2a7ef6c
movq %r... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>, 4u, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUs... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x2a7f039
pushq %rbx
movl (%rsi), %edi
movl %edi, %eax
shrl $0x4, %eax
shrl $0x9, %edi
xorl %eax, %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %r10d
xorl %r9d, %r9d
movl %edi, %r11d
leaq (%r11,%r11,2)... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>, 4u, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>>>::... | void shrink_and_clear() {
unsigned OldSize = this->size();
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldSize) {
NewNumBuckets = 1 << (Log2_32_Ceil(OldSize) + 1);
if (NewNumBuckets > InlineBuckets && NewNumBuckets < 64u)
NewNumBuckets = ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
xorl %ebp, %ebp
cmpl $0x2, %eax
jb 0x2a7f677
movl %eax, %ecx
shrl %ecx
decl %ecx
je 0x2a7f659
bsrl %ecx, %edx
xorl $0x1f, %edx
jmp 0x2a7f65e
movl $0x20, %edx
movb $0x21, %cl
subb %dl, %cl
movl $0x1, %esi
shll %cl, %esi
addl $-0x1c, %edx
cmpl $0x3, %edx
... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, llvm::ValueAsMetadata*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueAsMetadata*>>, llvm::Value*, llvm::ValueAsMetadata*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueAsMetadata*... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x2a7ffb9
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DINamespace*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DINamespace>, llvm::detail::DenseSetPair<llvm::DINamespace*>>, llvm::DINamespace*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DINamespace>, llvm::detail::DenseSetPair<llvm::DINamespace*>>::erase(llvm::DINa... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x2a1967e
testb %al, %al
je 0x2a80cfe
movq 0x8(%rsp), %rcx
movq $-0x2000, (%rcx) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0x922957(%rip), %xmm0 # 0x33a3650
movq %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
bool llvm::MDNodeOpsKey::compareOps<llvm::MDTuple>(llvm::MDTuple const*, unsigned int) const | unsigned getHash() const { return Hash; } | movl 0x20(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x2a81120
movl %edx, %ecx
movq %rsi, %rdx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x2a81123
movq (%rdi), %rdi
jmp 0x2a11caa
xorl %eax, %eax
retq
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movq %rax, %rdi
jmp 0x2a11c36
nop
| /IR/LLVMContextImpl.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Value const*, llvm::MDAttachments, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, llvm::MDAttachments>>, llvm::Value const*, llvm::MDAttachments, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Valu... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2a8238a
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r11d
leaq (%r11,%r11,4), %r11
leaq (%rdi,%r11,8), %r11
movq (%r11), %rbx
cmpq %rbx, (%... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value const*, llvm::MDAttachments, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, llvm::MDAttachments>>, llvm::Value const*, llvm::MDAttachments, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value con... | value_type& FindAndConstruct(KeyT &&Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, std::move(Key));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x2a82306
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x2a823f3
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2a823fe
movq (%rbx), %rcx
movq %rcx, (%rax)
xorps ... | /llvm/ADT/DenseMap.h |
llvm::SymbolTableListTraits<llvm::GlobalAlias>::addNodeToList(llvm::GlobalAlias*) | ItemParentClass *getListOwner() {
size_t Offset = reinterpret_cast<size_t>(
&((ItemParentClass *)nullptr->*ItemParentClass::getSublistAccess(
static_cast<ValueSubClass *>(
nullptr))));
ListTy *Anchor = static_cast<... | leaq -0x28(%rdi), %rax
movq %rax, 0x28(%rsi)
testb $0x10, 0x7(%rsi)
je 0x2a8310b
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
jne 0x2aa2b04
retq
| /llvm/IR/SymbolTableListTraits.h |
llvm::Module::createRNG(llvm::StringRef) const | std::unique_ptr<RandomNumberGenerator>
Module::createRNG(const StringRef Name) const {
SmallString<32> Salt(Name);
// This RNG is guaranteed to produce the same random stream only
// when the Module ID and thus the input filename is the same. This
// might be problematic if the input filename extension changes... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq (%rcx,%rdx), %rax
leaq 0x18(%rsp), %r12
movq %r12, -0x18(%r12)
movq $0x0, -0x10(%r12)
movq $0x20, -0x8(%r12)
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x89893e
movq 0xa8(%r15), %rdi
movq 0xb0(%r... | /IR/Module.cpp |
addSDKVersionMD(llvm::VersionTuple const&, llvm::Module&, llvm::StringRef) | static void addSDKVersionMD(const VersionTuple &V, Module &M, StringRef Name) {
SmallVector<unsigned, 3> Entries;
Entries.push_back(V.getMajor());
if (auto Minor = V.getMinor()) {
Entries.push_back(*Minor);
if (auto Subminor = V.getSubminor())
Entries.push_back(*Subminor);
// Ignore the 'build' ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x300000000, %rax # imm = 0x300000000
movq %rax, -0x8(%r13)
movl (%rdi), %esi
movq %rsp, %rdi
callq 0x81fb4c
movq (%r12), %rs... | /IR/Module.cpp |
llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned int, llvm::FunctionType const*>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned int, llvm::FunctionType const*>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, llvm::FunctionType const*>, unsigned int>>, std::pair<unsigned int, llvm::FunctionType cons... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x2a85b21
movq (%r15), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq $-0x1000, 0x8(%rax) ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::ValueInfo, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::ValueInfo, void>, llvm::detail::DenseSetPair<llvm::ValueInfo>>, llvm::ValueInfo, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::ValueInfo, void>, llvm::detail::DenseSetPair<llvm::ValueInfo>>::find(llvm::Value... | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x1fa9cf0
testb %al, %al
je 0x2a88bcd
movq 0x8(%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
jmp 0x2a88bda
movl 0x10(%rbx), %eax
shlq $0x3, %rax
addq (%rbx), %rax
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
getNodeVisualName[abi:cxx11](llvm::ValueInfo const&) | static std::string getNodeVisualName(const ValueInfo &VI) {
return VI.name().empty() ? getNodeVisualName(VI.getGUID()) : VI.name().str();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1fa7c36
testq %rdx, %rdx
je 0x2a88c1b
movq %r14, %rdi
callq 0x1fa7c36
testq %rax, %rax
je 0x2a88c2f
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7fa87c
jmp 0x2a88c42
movq (%r14), %... | /IR/ModuleSummaryIndex.cpp |
llvm::ModulePass::skipModule(llvm::Module&) const | bool ModulePass::skipModule(Module &M) const {
OptPassGate &Gate = M.getContext().getOptPassGate();
return Gate.isEnabled() &&
!Gate.shouldRunPass(this->getPassName(), getDescription(M));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq (%rsi), %rdi
callq 0x2a60918
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl %eax, %ebx
testb %al, %al
je 0x2a8af00
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r... | /IR/Pass.cpp |
(anonymous namespace)::StructuralHashImpl::hashType(llvm::Type*) | void hashType(Type *ValueType) {
hash(ValueType->getTypeID());
if (ValueType->isIntegerTy())
hash(ValueType->getIntegerBitWidth());
} | movabsq $-0x622015f714c7d297, %rax # imm = 0x9DDFEA08EB382D69
movzbl 0x8(%rsi), %ecx
movq (%rdi), %rdx
xorq %rcx, %rdx
imulq %rax, %rdx
xorq %rdx, %rcx
shrq $0x2f, %rdx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rcx
shrq $0x2f, %rcx
xorq %rdx, %rcx
imulq %rax, %rcx
movq %rcx, (%rdi)
movl 0x8(%rsi), %edx
cmpb $0xd, %d... | /IR/StructuralHash.cpp |
llvm::Type::isSizedDerivedType(llvm::SmallPtrSetImpl<llvm::Type*>*) const | bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
if (auto *ATy = dyn_cast<ArrayType>(this))
return ATy->getElementType()->isSized(Visited);
if (auto *VTy = dyn_cast<VectorType>(this))
return VTy->getElementType()->isSized(Visited);
if (auto *TTy = dyn_cast<TargetExtType>(this))
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x8(%rdi), %ebp
cmpl $0x11, %ebp
jne 0x2a9a979
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x97e1b8
cmpl $0x11, %ebp
je 0x2a9a9bf
movl $0xfe, %ebp
andl 0x8(%r14), %ebp
cmpl $0x12, %ebp
jne 0x2a9a998
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x97e... | /IR/Type.cpp |
llvm::APInt::divide(unsigned long const*, unsigned int, unsigned long const*, unsigned int, unsigned long*, unsigned long*) | void APInt::divide(const WordType *LHS, unsigned lhsWords, const WordType *RHS,
unsigned rhsWords, WordType *Quotient, WordType *Remainder) {
assert(lhsWords >= rhsWords && "Fractional result");
// First, compose the values into an array of 32-bit words instead of
// 64-bit words. This is a ne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rdi, %rbx
movq %rcx, 0x38(%rsp)
leal (%rcx,%rcx), %r13d
leal (%rsi,%rsi), %r10d
movl %r10d, %ebp
subl %r13d, %ebp
cmpq $0x1, %r9
movl $0x3, %eax
sbbl $-0x1, %eax
imull %r13d, %eax
leal (%rax,%rbp,2), %eax
... | /Support/APInt.cpp |
llvm::Error llvm::BinaryStreamWriter::writeObject<char>(char const&) | Error writeObject(const T &Obj) {
static_assert(!std::is_pointer<T>::value,
"writeObject should not be used with pointers, to write "
"the pointed-to value dereference the pointer before calling "
"writeObject");
return writeBytes(
ArrayRef<uint8_t>(... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
movq 0x38(%r14), %rdx
movl $0x1, %r8d
callq 0x2b1c78a
cmpq $0x0, (%rbx)
jne 0x2b1cf65
incq 0x38(%r14)
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /llvm/Support/BinaryStreamWriter.h |
llvm::TypeSize::operator unsigned long() const | TypeSize::operator TypeSize::ScalarTy() const {
if (isScalable()) {
reportInvalidSizeRequest(
"Cannot implicitly convert a scalable size to a fixed-width size in "
"`TypeSize::operator ScalarTy()`");
return getKnownMinValue();
}
return getFixedValue();
} | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x2b60e8a
leaq 0x254e2d6(%rip), %rdi # 0x50af15b
callq 0x2b60def
movq (%rbx), %rax
popq %rbx
retq
nop
| /Support/TypeSize.cpp |
llvm::yaml::Scanner::setError(llvm::Twine const&, char const*) | void setError(const Twine &Message, StringRef::iterator Position) {
if (Position >= End)
Position = End - 1;
// propagate the error if possible
if (EC)
*EC = make_error_code(std::errc::invalid_argument);
// Don't print out more errors after the first one we encounter. The rest
// are j... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x150(%rdi), %r12
leaq -0x1(%rax), %r15
cmpq %rdx, %rax
cmovaq %rdx, %r15
testq %r12, %r12
je 0x2b74b02
callq 0x7805a0
movl $0x16, (%r12)
movq %rax, 0x8(%r12)
cmpb $0x0, 0x4b(%rbx)
jne 0x2b74b37
movq ... | /Support/YAMLParser.cpp |
PopDescriptor | static cc_bool PopDescriptor(const KosinskiDecompressCallbacks* const callbacks)
{
const cc_bool result = (descriptor & 1) != 0;
descriptor >>= 1;
if (--descriptor_bits_remaining == 0)
GetDescriptor(callbacks);
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
movl 0x4a5c(%rip), %ebx # 0x6080
movl %ebx, %eax
shrl %eax
movl %eax, 0x4a52(%rip) # 0x6080
decl 0x4a50(%rip) # 0x6084
jne 0x166c
movq %rdi, %r14
incq 0x2a30(%rip) # 0x4070
movq (%rdi), %rdi
callq *0x8(%r14)
movl %eax, %ebp
incq 0x2a20(%rip) # ... | /Clownacy[P]accurate-kosinski/lib/kosinski-decompress.c |
Ptex::v2_2::PtexReader::prune() | void PtexReader::prune()
{
if (_metadata) { delete _metadata; _metadata = 0; }
for (std::vector<Level*>::iterator i = _levels.begin(); i != _levels.end(); ++i) {
if (*i) { delete *i; *i = 0; }
}
_reductions.clear();
_memUsed = _baseMemUsed;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x140(%rdi), %rdi
testq %rdi, %rdi
je 0x103a1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x140(%rbx)
movq 0x1b0(%rbx), %r15
cmpq 0x1b8(%rbx), %r15
je 0x103db
movq (%r15), %r14
testq %r14, %r14
je 0x103d5
movq %r14, %rdi
callq 0x12eea
movl $0x48, %esi
movq %r14, %... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::readConstData() | void PtexReader::readConstData()
{
if (!_constdata) {
// read compressed constant data block
seek(_constdatapos);
int size = _pixelsize * _header.nfaces;
_constdata = new uint8_t[size];
readZipBlock(_constdata, _header.constdatasize, size);
if (_premultiply && _header... | cmpq $0x0, 0x138(%rdi)
je 0x1070d
retq
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xf8(%rdi), %rsi
callq 0x13070
movl 0xa0(%rbx), %ebp
imull 0x130(%rbx), %ebp
movslq %ebp, %r14
movq %r14, %rdi
callq 0xc030
movq %rax, 0x138(%rbx)
movl 0xac(%rbx), %edx
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %ecx
callq 0x1... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::readMetaDataBlock(Ptex::v2_2::PtexReader::MetaData*, long, int, int, unsigned long&) | void PtexReader::readMetaDataBlock(MetaData* metadata, FilePos pos, int zipsize, int memsize, size_t& metaDataMemUsed)
{
seek(pos);
// read from file
bool useNew = memsize > AllocaMax;
char* buff = useNew ? new char[memsize] : (char*)alloca(memsize);
if (readZipBlock(buff, zipsize, memsize)) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movl %r8d, %ebx
movl %ecx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %r13
movq %rdx, %rsi
callq 0x13070
movslq %ebx, %r12
cmpl $0x4001, %ebx # imm = 0x4001
jl 0x10f54
movl %ebx, %edi
callq 0xc030
jmp... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::readLevel(int, Ptex::v2_2::PtexReader::Level*&) | void PtexReader::readLevel(int levelid, Level*& level)
{
// get read lock and make sure we still need to read
AutoMutex locker(readlock);
if (level) {
return;
}
// go ahead and read the level
LevelInfo& l = _levelinfo[levelid];
// keep new level local until finished
Level* newl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0xc380
cmpq $0x0, (%r15)
jne 0x1142f
movl %ebp, 0x4(%rsp)
movslq %ebp, %rbp
movq %rbp, %r13
shlq $0x4, %r13
addq 0x180(%r14), %r13
movl $0x48, %edi
call... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::getPixel(int, int, int, float*, int, int) | void PtexReader::getPixel(int faceid, int u, int v,
float* result, int firstchan, int nchannelsArg)
{
memset(result, 0, sizeof(*result)*nchannelsArg);
// clip nchannels against actual number available
nchannelsArg = PtexUtils::min(nchannelsArg, _header.nchannels-firstchan);
if... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movl %ecx, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
movl %esi, %ebx
movq %rdi, %r13
movslq 0x10(%rbp), %r14
movq %r14, %rdx
shlq $0x2, %rdx
movq %r8, -0x38(%rbp)
movq %r8, %rdi
xorl %esi, %esi
callq 0xc160
movz... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_2::PtexReader::errorData(bool) | FaceData* errorData(bool deleteOnRelease=false)
{
return new ErrorFace(&_errorPixel[0], _pixelsize, deleteOnRelease);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
movl $0x20, %edi
callq 0xc290
movq %rax, %rbx
movq 0x220(%r15), %r14
movslq 0x130(%r15), %r15
movw $0x0, 0x8(%rax)
leaq 0xc422(%rip), %rax # 0x1f7b8
movq %rax, (%rbx)
movl %r15d, 0xc(%rbx)
movq %r15, %rdi
callq 0xc030
movq %rax,... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexReader.h |
Ptex::v2_2::PtexHashMap<Ptex::v2_2::PtexReader::ReductionKey, Ptex::v2_2::PtexReader::FaceData*>::tryInsert(Ptex::v2_2::PtexReader::ReductionKey&, Ptex::v2_2::PtexReader::FaceData*, unsigned long&) | Value tryInsert(Key& key, Value value, size_t& newMemUsed)
{
Entry* entries = lockEntriesAndGrowIfNeeded(newMemUsed);
uint32_t mask = _numEntries-1;
uint32_t hash = key.hash();
Value result = 0;
for (uint32_t i = hash;; ++i) {
Entry& e = entries[i & mask];
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x155d2
movl 0x8(%rbx), %edx
decl %edx
movq (%r15), %rsi
xorl %ecx, %ecx
movl %esi, %r8d
andl %edx, %r8d
shlq $0x4, %r8
leaq (%rax,%r8), %rdi
cmpq $0x0, 0x8(%rax,%r8)
je 0x1346e
movq (%rdi), %r8
cmpq $-0x1, %r8
je 0x1... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_2::PtexReader::MetaData::findKey(char const*, int&, Ptex::v2_2::MetaDataType&) | virtual bool findKey(const char* key, int& index, MetaDataType& type)
{
MetaMap::iterator iter = _map.find(key);
if (iter==_map.end()) {
index = -1;
return false;
}
index = iter->second.index;
type = iter->second.type;
return true;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
callq 0xd7d8
movq %r12, %rdi
movq %r13, %rsi
callq 0x13b66
movq %rax, %r12
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexReader.h |
void Ptex::v2_2::PtexReader::MetaData::getValue<float>(int, Ptex::v2_2::MetaDataType, float const*&, int&) | void getValue(int index, MetaDataType requestedType, const T*& value, int& count)
{
if (index < 0 || index >= int(_entries.size())) {
value = 0;
count = 0;
return;
}
Entry* e = getEntry(index);
if (e && e->type == requestedType) {
... | pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
testl %esi, %esi
js 0x13d16
movq 0x48(%rdi), %rax
subq 0x40(%rdi), %rax
shrq $0x3, %rax
cmpl %esi, %eax
jle 0x13d16
movl %edx, %ebp
callq 0x10e1a
testq %rax, %rax
je 0x13d16
cmpl %ebp, 0x8(%rax)
jne 0x13d16
movq 0x10(%rax), %rcx
movq %rcx, (%r14)
movl 0xc(... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexReader.h |
Ptex::v2_2::PtexHashMap<Ptex::v2_2::PtexReader::ReductionKey, Ptex::v2_2::PtexReader::FaceData*>::deleteContents() | void deleteContents()
{
for (uint32_t i = 0; i < _numEntries; ++i) {
if (_entries[i].value) delete _entries[i].value;
}
delete [] _entries;
for (size_t i = 0; i < _oldEntries.size(); ++i) {
delete [] _oldEntries[i];
}
std::vector<Entry*>().swap... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x14c14
movl $0x8, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
cmpq $0x0, (%rax,%r14)
je 0x14c05
movq (%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x14c05
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
movl 0x8(%rbx), %eax
addq $0x10, %r14
... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_2::PtexUtils::interleave(void const*, int, int, int, void*, int, Ptex::v2_2::DataType, int) | void interleave(const void* src, int sstride, int uw, int vw,
void* dst, int dstride, DataType dt, int nchan)
{
switch (dt) {
case dt_uint8: interleave((const uint8_t*) src, sstride, uw, vw,
(uint8_t*) dst, dstride, nchan); break;
case dt_half:
case ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x40(%rsp), %eax
movl 0x38(%rsp), %r10d
leal -0x1(%r10), %r11d
cmpl $0x2, %r11d
jb 0x15bf4
cmpl $0x3, %r10d
je 0x15c7a
testl %r10d, %r10d
jne 0x15d05
testl %eax, %eax
je 0x15d05
cltq
leaq (%r8,%rax), %r10
imull %esi, %ecx
movslq %ecx, %r11
movslq %e... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexUtils.cpp |
Ptex::v2_2::PtexUtils::deinterleave(void const*, int, int, int, void*, int, Ptex::v2_2::DataType, int) | void deinterleave(const void* src, int sstride, int uw, int vw,
void* dst, int dstride, DataType dt, int nchan)
{
switch (dt) {
case dt_uint8: deinterleave((const uint8_t*) src, sstride, uw, vw,
(uint8_t*) dst, dstride, nchan); break;
case dt_half:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x40(%rsp), %eax
movl 0x38(%rsp), %r10d
leal -0x1(%r10), %r11d
cmpl $0x2, %r11d
jb 0x15d9d
cmpl $0x3, %r10d
je 0x15e23
testl %r10d, %r10d
jne 0x15eae
testl %eax, %eax
je 0x15eae
cltq
leaq (%rdi,%rax), %r10
imull %esi, %ecx
movslq %ecx, %r11
movslq %... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexUtils.cpp |
Ptex::v2_2::PtexUtils::encodeDifference(void*, int, Ptex::v2_2::DataType) | void encodeDifference(void* data, int size, DataType dt)
{
switch (dt) {
case dt_uint8: encodeDifference(static_cast<uint8_t*>(data), size); break;
case dt_uint16: encodeDifference(static_cast<uint16_t*>(data), size); break;
default: break; // skip other types
}
} | cmpl $0x1, %edx
je 0x15ee7
testl %edx, %edx
jne 0x15f1b
testl %esi, %esi
je 0x15f1b
movslq %esi, %rax
xorl %ecx, %ecx
xorl %edx, %edx
movb (%rdi,%rcx), %sil
movl %esi, %r8d
subb %dl, %r8b
movb %r8b, (%rdi,%rcx)
incq %rcx
movl %esi, %edx
cmpq %rcx, %rax
jne 0x15ecd
jmp 0x15f1b
leal 0x1(%rsi), %eax
cmpl $0x3, %eax
jb 0x1... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexUtils.cpp |
Ptex::v2_2::PtexUtils::reduceu(void const*, int, int, int, void*, int, Ptex::v2_2::DataType, int) | void reduceu(const void* src, int sstride, int uw, int vw,
void* dst, int dstride, DataType dt, int nchan)
{
switch (dt) {
case dt_uint8: reduceu(static_cast<const uint8_t*>(src), sstride, uw, vw,
static_cast<uint8_t*>(dst), dstride, nchan); break;
case dt_hal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl 0x70(%rsp), %eax
cmpq $0x3, %rax
ja 0x16608
movq %r8, %rbx
movq %rdi, %r14
movl 0x78(%rsp), %r13d
leaq 0x3359(%rip), %rdi # 0x196a4
movslq (%rdi,%rax,4), %rax
addq %rdi, %rax
jmpq *%rax
imull %esi, %ecx
testl %ecx, %ecx
je 0x16... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexUtils.cpp |
Ptex::v2_2::PtexUtils::blend(void const*, float, void*, bool, int, Ptex::v2_2::DataType, int) | void blend(const void* src, float weight, void* dst, bool flip,
int rowlen, DataType dt, int nchan)
{
switch ((dt<<1) | int(flip)) {
case (dt_uint8<<1): blend(static_cast<const uint8_t*>(src), weight,
static_cast<uint8_t*>(dst), rowlen, nchan); break;
c... | leal (%rdx,%r8,2), %eax
cmpl $0x7, %eax
ja 0x17190
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movaps %xmm0, %xmm1
movq %rdi, %rbx
leaq 0x286d(%rip), %rdx # 0x196d4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
movss %xmm0, 0xc(%rsp)
jmpq *%rax
imull %ecx, %r9d
t... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexUtils.cpp |
void Ptex::v2_2::PtexUtils::(anonymous namespace)::average<unsigned short>(unsigned short const*, int, int, int, unsigned short*, int) | inline void average(const T* src, int sstride, int uw, int vw,
T* dst, int nchan)
{
float* buff = (float*) alloca(nchan*sizeof(float));
memset(buff, 0, nchan*sizeof(float));
sstride /= (int)sizeof(T);
int rowlen = uw*nchan;
int rowskip = sstride - rowl... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movq %r8, %rbx
movl %ecx, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
movl %esi, %r15d
movq %rdi, %r12
movslq %r9d, %rdx
movq %rsp, %r14
leaq 0xf(,%rdx,4), %rax
shlq $0x2, %rdx
andq $-0x10, %rax
subq %rax, %r14
movq %r1... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexUtils.cpp |
void Ptex::v2_2::PtexUtils::(anonymous namespace)::ApplyConst<Ptex::v2_2::PtexHalf, 3>(float, float*, void*, int) | operator float() const { return toFloat(bits); } | movzwl (%rsi), %eax
leaq 0x84c9(%rip), %rcx # 0x20310
movzwl 0x2(%rsi), %edx
movsd (%rdi), %xmm1
movss (%rcx,%rdx,4), %xmm2
movss (%rcx,%rax,4), %xmm3
unpcklps %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movaps %xmm0, %xmm2
unpcklps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexHalf.h |
Ptex::v2_2::PtexHalf::fromFloat(float) | static uint16_t fromFloat(float val)
{
if (val==0) return 0;
union { uint32_t i; float f; } u;
u.f = val;
int e = f2hTable[(u.i>>23)&0x1ff];
if (e) return (uint16_t)(e + (((u.i&0x7fffff) + 0x1000) >> 13));
return fromFloat_except(u.i);
} | xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x18937
jp 0x18937
xorl %eax, %eax
retq
movd %xmm0, %edi
movl %edi, %eax
shrl $0x17, %eax
leaq 0x479c9(%rip), %rcx # 0x60310
movzwl (%rcx,%rax,2), %eax
testw %ax, %ax
je 0x18c64
andl $0x7ff000, %edi # imm = 0x7FF000
addl $0x1000, %edi # imm = 0x1000
shrl... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexHalf.h |
Ptex::v2_2::PtexHalf::fromFloat_except(unsigned int) | uint16_t PtexHalf::fromFloat_except(uint32_t i)
{
uint32_t s = ((i>>16) & 0x8000);
int32_t e = ((i>>13) & 0x3fc00) - 0x1c000;
if (e <= 0) {
// denormalized
union { uint32_t i; float f; } u;
u.i = i;
return (uint16_t)(s|int(fabs(u.f)*1.6777216e7 + .5));
}
if (e == 0x... | movl %edi, %eax
shrl $0x10, %eax
andl $0x8000, %eax # imm = 0x8000
movl %edi, %ecx
shrl $0xd, %ecx
movl %ecx, %edx
andl $0x3fc00, %edx # imm = 0x3FC00
cmpl $0x1c000, %edx # imm = 0x1C000
ja 0x18ca8
andl $0x7fffffff, %edi # imm = 0x7FFFFFFF
movd %edi, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0... | /mmp[P]pbrt-v4-ci-testing/src/ext/ptex/src/ptex/PtexHalf.cpp |
ClassInfo::ClassInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Object* (*)()) | ClassInfo(const std::string className, ObjectConstructorFn ctor)
:m_className(className), m_objectConstructor(ctor)
{
Object::Register(this); //classInfo的构造函数是传入类名和类对应的new函数然后自动注册进map中。
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r15
leaq 0x2927(%rip), %rax # 0x4d58
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2614
movq %r14, 0x... | /tsukinoying[P]cppReflection/Reflex.h |
ClassInfo::~ClassInfo() | virtual ~ClassInfo(){} | pushq %rbx
movq %rdi, %rbx
leaq 0x2763(%rip), %rax # 0x4d58
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x260a
callq 0x20c0
movq %rbx, %rdi
popq %rbx
jmp 0x20c0
nop
| /tsukinoying[P]cppReflection/Reflex.h |
sqlite3_db_status | SQLITE_API int sqlite3_db_status(
sqlite3 *db, /* The database connection whose status is desired */
int op, /* Status verb */
int *pCurrent, /* Write current value here */
int *pHighwater, /* Write high-water mark here */
int resetFlag /* Reset high-water mark if tr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x2af39
movq %rsi, %r12
callq *0xa358a(%rip) # 0xce4c0
movq %r12, %rsi
cmpl $0xc, %esi
ja 0x2b2ea
movl %esi, %eax
leaq 0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeClearObject | SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
SubProgram *pSub, *pNext;
assert( p->db==0 || p->db==db );
releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
for(pSub=p->pProgram; pSub; pSub=pNext){
pNext = pSub->pNext;
vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
sqlite3DbFree(d... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rdi
movzwl 0xbc(%rsi), %esi
addl %esi, %esi
callq 0x49bf2
movq 0x110(%r14), %r15
testq %r15, %r15
je 0x2b47a
movq 0x28(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x49c81
movq %rbx, %rdi... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3_vfs_find | SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
sqlite3_vfs *pVfs = 0;
#if SQLITE_THREADSAFE
sqlite3_mutex *mutex;
#endif
#ifndef SQLITE_OMIT_AUTOINIT
int rc = sqlite3_initialize();
if( rc ) return 0;
#endif
#if SQLITE_THREADSAFE
mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
sqli... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2b5a5
testl %eax, %eax
je 0x2b527
xorl %r15d, %r15d
jmp 0x2b597
movb $0x1, %bpl
cmpl $0x0, 0xa2f03(%rip) # 0xce434
je 0x2b553
movl $0x2, %edi
callq *0xa2f72(%rip) # 0xce4b0
testq %rax, %rax
je 0x2b553
movq %rax, %r14
movq %rax, ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3_str_append | SQLITE_API void sqlite3_str_append(sqlite3_str *p, const char *z, int N){
assert( z!=0 || N==0 );
assert( p->zText!=0 || p->nChar==0 || p->accError );
assert( N>=0 );
assert( p->accError==0 || p->nAlloc==0 );
if( p->nChar+N >= p->nAlloc ){
enlargeAndAppend(p,z,N);
}else if( N ){
assert( p->zText );
... | movl 0x18(%rdi), %eax
leal (%rax,%rdx), %ecx
cmpl 0x10(%rdi), %ecx
jae 0x2da69
testl %edx, %edx
je 0x2da6e
movl %ecx, 0x18(%rdi)
addq 0x8(%rdi), %rax
movslq %edx, %rdx
movq %rax, %rdi
jmp 0xa370
jmp 0x2dc1a
retq
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
unixCurrentTime | static int unixCurrentTime(sqlite3_vfs *NotUsed, double *prNow){
sqlite3_int64 i = 0;
int rc;
UNUSED_PARAMETER(NotUsed);
rc = unixCurrentTimeInt64(0, &i);
*prNow = i/86400000.0;
return rc;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xa700
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r14)
imulq $0x3e8, (%r14), %rax # imm = 0x3E8
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x7, %rdx
addq %rcx, %rdx
addq %rax, %r... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
unixCurrentTimeInt64 | static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){
static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
int rc = SQLITE_OK;
#if defined(NO_GETTOD)
time_t t;
time(&t);
*piNow = ((sqlite3_int64)t)*1000 + unixEpoch;
#elif OS_VXWORKS
struct timespec sNow;
clock_get... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xa700
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r14)
imulq $0x3e8, (%r14), %rax # imm = 0x3E8
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x7, %rdx
addq %rcx, %rdx
addq %rax, %r... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
unixNextSystemCall | static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
int i = -1;
UNUSED_PARAMETER(p);
if( zName ){
for(i=0; i<ArraySize(aSyscall)-1; i++){
if( strcmp(zName, aSyscall[i].zName)==0 ) break;
}
}
for(i++; i<ArraySize(aSyscall); i++){
if( aSyscall[i].pCurrent!=0 ) return aSy... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2f55d
movq %rsi, %rbx
leaq 0x9f37d(%rip), %r15 # 0xce8b0
xorl %r14d, %r14d
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xa610
testl %eax, %eax
je 0x2f558
incq %r14
addq $0x18, %r15
cmpq $0x1c, %r14
jne 0x2f536
movl $0x1c, %r14d
movslq %r14d, %rcx
jmp 0x2f564
movq $... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3_backup_init | SQLITE_API sqlite3_backup *sqlite3_backup_init(
sqlite3* pDestDb, /* Database to write to */
const char *zDestDb, /* Name of database within pDestDb */
sqlite3* pSrcDb, /* Database connection to read from */
const char *zSrcDb /* Name ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rdx), %rdi
testq %rdi, %rdi
je 0x2f5d4
callq *0x9eeec(%rip) # 0xce4c0
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x2f5e3
callq *0x9eedd(%rip) # 0xce4c0
cmpq %r14, %rbx
je 0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
findBtree | static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){
int i = sqlite3FindDbName(pDb, zDb);
if( i==1 ){
Parse sParse;
int rc = 0;
memset(&sParse, 0, sizeof(sParse));
sParse.db = pDb;
if( sqlite3OpenTempDatabase(&sParse) ){
sqlite3ErrorWithMsg(pErrorDb, sParse.rc, "%s",... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3a521
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x2f8e1
leaq 0x8(%rsp), %r15
movl $0x190, %edx # imm = 0x190
movq %r15, %rdi
xorl %esi, %esi... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3BtreeEnter | SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
/* Some basic sanity checking on the Btree. The list of Btrees
** connected by pNext and pPrev should be in sorted order by
** Btree.pBt value. All elements of the list should belong to
** the same connection. Only shared Btrees are on the list. */
assert( p->... | cmpb $0x0, 0x11(%rdi)
je 0x2fee9
incl 0x14(%rdi)
cmpb $0x0, 0x12(%rdi)
je 0x46b8f
retq
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3BtreeUpdateMeta | SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
BtShared *pBt = p->pBt;
unsigned char *pP1;
int rc;
assert( idx>=1 && idx<=15 );
sqlite3BtreeEnter(p);
assert( p->inTrans==TRANS_WRITE );
assert( pBt->pPage1!=0 );
pP1 = pBt->pPage1->aData;
rc = sqlite3PagerWrite(pBt->pPage1->pDb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movq 0x8(%rdi), %r12
cmpb $0x0, 0x11(%rdi)
je 0x307bc
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x307bc
movq %rbx, %rdi
callq 0x46b8f
movq 0x18(%r12), %rax
movq 0x50(%rax), %r13
movq 0x70(%rax),... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3_column_name | SQLITE_API const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
return columnName(
pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
} | pushq %rbp
pushq %r14
pushq %rbx
movzwl 0xbc(%rdi), %eax
cmpl %esi, %eax
jbe 0x3340b
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x333c8
callq *0x9b0f8(%rip) # 0xce4c0
movl %ebp, %eax
imulq $0x38, %rax, %rdi
addq 0x80(%rbx), %rdi
movl $0x1, %esi
callq 0x31895
cmp... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
patternCompare | static int patternCompare(
const u8 *zPattern, /* The glob pattern */
const u8 *zString, /* The string to compare against the glob */
const struct compareInfo *pInfo, /* Information about how to do the compare */
u32 matchOther /* The escape char (LIKE) or '[' (GLOB)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, 0x1c(%rsp)
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
movzbl 0x1(%rdx), %ebx
movzbl (%rdx), %r14d
movq %rdx, 0x20(%rsp)
movb 0x3(%rdx), %al
movb %al, 0x7(%rsp)
movq $0x0, 0x30(%rsp)
movl %r1... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3_exec | SQLITE_API int sqlite3_exec(
sqlite3 *db, /* The database on which the SQL executes */
const char *zSql, /* The SQL to be executed */
sqlite3_callback xCallback, /* Invoke this callback routine */
void *pArg, /* First argument to xCallback() */
char **pzErrMsg ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, 0x40(%rsp)
movq %rdx, 0x30(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
callq 0x36192
testl %eax, %eax
je 0x3601c
testq %r14, %r14
leaq 0x7010f(%rip), %rbx # 0xa5efc
cmovneq %r14, %rbx
mo... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3LockAndPrepare | static int sqlite3LockAndPrepare(
sqlite3 *db, /* Database handle. */
const char *zSql, /* UTF-8 encoded SQL statement. */
int nBytes, /* Length of zSql in bytes. */
u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
Vdbe *pOld, /* VM being rep... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %r8, 0x48(%rsp)
movl %ecx, 0x14(%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %r9, 0x40(%rsp)
movq $0x0, (%r9)
callq 0x36192
testq %r14, %r14
je 0x37038
testl %eax, %eax
je 0x37038
movq 0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3DbFreeNN | SQLITE_PRIVATE void sqlite3DbFreeNN(sqlite3 *db, void *p){
assert( db==0 || sqlite3_mutex_held(db->mutex) );
assert( p!=0 );
if( db ){
if( db->pnBytesFreed ){
measureAllocationSize(db, p);
return;
}
if( isLookaside(db, p) ){
LookasideSlot *pBuf = (LookasideSlot*)p;
#ifdef SQLITE_DEBU... | testq %rdi, %rdi
je 0x3c857
cmpq $0x0, 0x2a0(%rdi)
jne 0x3c85f
cmpq %rsi, 0x188(%rdi)
ja 0x3c857
cmpq %rsi, 0x190(%rdi)
jbe 0x3c857
movq 0x180(%rdi), %rax
movq %rax, (%rsi)
movq %rsi, 0x180(%rdi)
retq
movq %rsi, %rdi
jmp 0x2be2e
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
closePendingFds | static void closePendingFds(unixFile *pFile){
unixInodeInfo *pInode = pFile->pInode;
UnixUnusedFd *p;
UnixUnusedFd *pNext;
assert( unixFileMutexHeld(pFile) );
for(p=pInode->pUnused; p; p=pNext){
pNext = p->pNext;
robust_close(pFile, p->fd, __LINE__);
sqlite3_free(p);
}
pInode->pUnused = 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r15
movq 0x28(%r15), %r14
testq %r14, %r14
je 0x3e4ca
movq %rdi, %rbx
movq 0x8(%r14), %r12
movl (%r14), %esi
movq %rbx, %rdi
movl $0x8271, %edx # imm = 0x8271
callq 0x3e4de
movq %r14, %rdi
callq 0x2be2e
movq %r12, %r14
testq %r12, %r12
j... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
btreeEnterAll | static void SQLITE_NOINLINE btreeEnterAll(sqlite3 *db){
int i;
int skipOk = 1;
Btree *p;
assert( sqlite3_mutex_held(db->mutex) );
for(i=0; i<db->nDb; i++){
p = db->aDb[i].pBt;
if( p && p->sharable ){
sqlite3BtreeEnter(p);
skipOk = 0;
}
}
db->noSharedCache = skipOk;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rdi), %eax
movb $0x1, %cl
testl %eax, %eax
jle 0x3ec68
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rdx
movq (%rdx,%r14), %rdi
testq %rdi, %rdi
je 0x3ec59
cmpb $0x0, 0x11(%rdi)
je 0x3ec59
incl 0x14(%rdi)
cmpb $0x0, 0x12(%rdi)
jne 0x3ec57
callq 0x46b8f
... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
pagerStress | static int pagerStress(void *p, PgHdr *pPg){
Pager *pPager = (Pager *)p;
int rc = SQLITE_OK;
assert( pPg->pPager==pPager );
assert( pPg->flags&PGHDR_DIRTY );
/* The doNotSpill NOSYNC bit is set during times when doing a sync of
** journal (and adding a new header) is not allowed. This occurs
** during ... | xorl %eax, %eax
cmpl $0x0, 0x2c(%rdi)
je 0x400c9
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x18(%rdi), %cl
testb %cl, %cl
je 0x400ee
testb $0x3, %cl
jne 0x4017d
testb $0x8, 0x34(%r14)
jne 0x4017d
incl 0xfc(%rbx)
movq $0x0, 0x20(%r14)
cmpq $0x0, 0x120(%rbx)
je 0x40123
movq %r14, %rdi
cal... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
memjrnlTruncate | static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
MemJournal *p = (MemJournal *)pJfd;
if( ALWAYS(size==0) ){
memjrnlFreeChunks(p);
p->nSize = 0;
p->endpoint.pChunk = 0;
p->endpoint.iOffset = 0;
p->readpoint.pChunk = 0;
p->readpoint.iOffset = 0;
}
return SQLITE_OK;
} | testq %rsi, %rsi
jne 0x413d8
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x413b8
movq (%rdi), %r15
callq 0x2be2e
movq %r15, %rdi
testq %r15, %r15
jne 0x413a8
movl $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq $... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3WalFindFrame | SQLITE_PRIVATE int sqlite3WalFindFrame(
Wal *pWal, /* WAL handle */
Pgno pgno, /* Database page number to read data for */
u32 *piRead /* OUT: Frame number (or zero) */
){
u32 iRead = 0; /* If !=0, WAL frame to return data from */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x58(%rdi), %r13d
testl %r13d, %r13d
je 0x4167b
movq %rdi, %r14
cmpw $0x0, 0x3c(%rdi)
jne 0x41642
cmpb $0x0, 0x46(%r14)
je 0x4167b
movl $0x1000, %ebx # imm = 0x1000
leal (%rbx,%r13), %r12d
addl 0x78(%r14), %ebx
movabsq $0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
walIndexWriteHdr | static void walIndexWriteHdr(Wal *pWal){
volatile WalIndexHdr *aHdr = walIndexHdr(pWal);
const int nCksum = offsetof(WalIndexHdr, aCksum);
assert( pWal->writeLock );
pWal->hdr.isInit = 1;
pWal->hdr.iVersion = WALINDEX_MAX_VERSION;
walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
memcpy(... | pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movq (%rax), %rbx
leaq 0x48(%rdi), %r14
movb $0x1, 0x54(%rdi)
movl $0x2de218, 0x48(%rdi) # imm = 0x2DE218
xorl %eax, %eax
movl $0x40, %ecx
xorl %edx, %edx
addl %eax, %edx
addl 0x8(%rdi,%rcx), %edx
addl 0xc(%rdi,%rcx), %eax
addl %edx, %eax
addq $0x8, %rcx
cmpq $0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
walRestartHdr | static void walRestartHdr(Wal *pWal, u32 salt1){
volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
int i; /* Loop counter */
u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */
pWal->nCkpt++;
pWal->hdr.mxFrame = 0;
sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aS... | pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movq (%rax), %rbx
incl 0x88(%rdi)
xorl %r14d, %r14d
movl %r14d, 0x58(%rdi)
movl 0x68(%rdi), %eax
bswapl %eax
incl %eax
movl %eax, %ecx
shrl $0x18, %ecx
movb %cl, 0x68(%rdi)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x69(%rdi)
movb %ah, 0x6a(%rdi)
movb %al, 0x6b(%r... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
walIndexTryHdr | static int walIndexTryHdr(Wal *pWal, int *pChanged){
u32 aCksum[2]; /* Checksum on the header content */
WalIndexHdr h1, h2; /* Two copies of the header content */
WalIndexHdr volatile *aHdr; /* Header in shared memory */
/* The first page of the wal-index must be mapped at thi... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %r15
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpb $0x2, 0x3f(%rdi)
je 0x426af
movq 0x8(%rbx), %rdi
mo... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
walEncodeFrame | static void walEncodeFrame(
Wal *pWal, /* The write-ahead log */
u32 iPage, /* Database page number for frame */
u32 nTruncate, /* New db size (or 0 for non-commit frames) */
u8 *aData, /* Pointer to page data */
u8 *aFrame ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movl %esi, %eax
movl %esi, %ecx
shrl $0x18, %ecx
movb %cl, (%r8)
movl %esi, %ecx
shrl $0x10, %ecx
movb %cl, 0x1(%r8)
movb %ah, 0x2(%rbx)
movb %al, 0x3(%r8)
movl %edx, %eax
shrl $0x18, %eax
movb %al, 0x4(%r8)
movl %edx, %eax
shrl $0x10... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3PcacheFetchFinish | SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish(
PCache *pCache, /* Obtain the page from this cache */
Pgno pgno, /* Page number obtained */
sqlite3_pcache_page *pPage /* Page obtained by prior PcacheFetch() call */
){
PgHdr *pPgHdr;
assert( pPage!=0 );
pPgHdr = (PgHdr *)pPage-... | movq 0x8(%rdx), %rax
cmpq $0x0, (%rax)
je 0x4350b
incl 0x18(%rdi)
incw 0x36(%rax)
retq
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
accessPayload | static int accessPayload(
BtCursor *pCur, /* Cursor pointing to entry to read from */
u32 offset, /* Begin reading this far into payload */
u32 amt, /* Read this many bytes */
unsigned char *pBuf, /* Write the bytes into this buffer */
int eOp /* zero to read. non-zero ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movl %edx, %ebx
movl %esi, %r13d
movq %rdi, %r15
movq 0x20(%rdi), %r12
movq 0x88(%rdi), %rbp
callq 0x48447
movq 0x38(%r15), %r14
movq %r14, %rcx
subq 0x50(%rbp), %rcx
movq %r12, 0x20(%rsp)
movl ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
getOverflowPage | static int getOverflowPage(
BtShared *pBt, /* The database file */
Pgno ovfl, /* Current overflow page number */
MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */
Pgno *pPgnoNext /* OUT: Next overflow page number */
){
Pgno next = 0;
MemPage *p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
cmpb $0x0, 0x21(%rdi)
je 0x48850
movl 0x860be(%rip), %ecx # 0xce8a0
movl $0xcccccccd, %edi # imm = 0xCCCCCCCD
movl %ebp, %r8d
movl %r8d, %r12d... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
relocatePage | static int relocatePage(
BtShared *pBt, /* Btree */
MemPage *pDbPage, /* Open page to move */
u8 eType, /* Pointer map 'type' entry for pDbPage */
Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
Pgno iFreePage, /* The location to move pDbPage to ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r14d
movl %r8d, 0x4(%rsp)
movl %ecx, %r12d
movl %edx, (%rsp)
movq %rsi, %r13
movl 0x4(%rsi), %eax
movl %eax, 0x1c(%rsp)
movq %rdi, 0x20(%rsp)
movq (%rdi), %rbx
movq 0x70(%rsi), %r15
cmpb $0x0, 0x10(%rbx)
je 0x492eb
movq %r15,... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
setChildPtrmaps | static int setChildPtrmaps(MemPage *pPage){
int i; /* Counter variable */
int nCell; /* Number of cells in page pPage */
int rc; /* Return code */
BtShared *pBt = pPage->pBt;
Pgno pgno = pPage->pgno;
assert( sqlite3_mutex_held(p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x48(%rdi), %r14
movl 0x4(%rdi), %eax
movl %eax, 0x4(%rsp)
cmpb $0x0, (%rdi)
je 0x49621
movl $0x0, (%rsp)
movzwl 0x16(%r15), %ebp
testq %rbp, %rbp
je 0x495f2
xorl %ebx, %ebx
movq %rsp, %r12
movzwl 0x18(%r15), %eax
movq 0x6... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
modifyPagePointer | static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
assert( sqlite3_mutex_held(pPage->pBt->mutex) );
assert( sqlite3PagerIswriteable(pPage->pDbPage) );
if( eType==PTRMAP_OVERFLOW2 ){
/* The pointer is always the first 4 bytes of the page in this case. */
if( get4byte(pPage->aDat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %r15
cmpl $0x4, %ecx
jne 0x497ea
movq 0x50(%r15), %rax
movl (%rax), %ecx
bswapl %ecx
cmpl %r14d, %ecx
jne 0x498a5
bswapl %edx
movl %edx, (%rax)
movl $0x0, 0x4(%rsp)
jmp 0x4994c
movl %ecx, %r12d
movl %edx, 0x8(... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3BitvecClear | SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
if( p==0 ) return;
assert( i>0 );
i--;
while( p->iDivisor ){
u32 bin = i/p->iDivisor;
i = i%p->iDivisor;
p = p->u.apSub[bin];
if (!p) {
return;
}
}
if( p->iSize<=BITVEC_NBIT ){
p->u.aBitmap[i/BITVEC_SZELEM] &... | testq %rdi, %rdi
je 0x49ac8
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
decl %r14d
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
je 0x49a19
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movq 0x10(%rbx,%rax,8), %rbx
movl %edx, %r14d
testq %rbx, %rbx
jne 0x499f9
jmp 0x49ab... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
ptrmapPutOvflPtr | static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
CellInfo info;
if( *pRC ) return;
assert( pCell!=0 );
pPage->xParseCell(pPage, pCell, &info);
if( info.nLocal<info.nPayload ){
Pgno ovfl = get4byte(&pCell[info.nSize-4]);
ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);... | cmpl $0x0, (%rdx)
je 0x49acf
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq %r12, %rdx
callq *0x80(%rdi)
movzwl 0x14(%r12), %eax
cmpl %eax, 0x10(%r12)
jbe 0x49b1d
movzwl 0x16(%rsp), %eax
movl -0x4(%r15,%rax), %esi
bswapl %esi
movq 0... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3BtreeTripAllCursors | SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int writeOnly){
BtCursor *p;
int rc = SQLITE_OK;
assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 );
if( pBtree ){
sqlite3BtreeEnter(pBtree);
for(p=pBtree->pBt->pCursor; p; p=p->pNext){
if( writeOnly && (p->curFl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x49bb8
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
je 0x49b59
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x49b59
movq %rbx, %rdi
callq 0x46b8f
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r12
xorl %ebp... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
freeP4 | static void freeP4(sqlite3 *db, int p4type, void *p4){
assert( db );
switch( p4type ){
case P4_FUNCCTX: {
freeP4FuncCtx(db, (sqlite3_context*)p4);
break;
}
case P4_REAL:
case P4_INT64:
case P4_DYNAMIC:
case P4_DYNBLOB:
case P4_INTARRAY: {
sqlite3DbFree(db, p4);
br... | addl $0x11, %esi
cmpl $0xa, %esi
ja 0x49d33
leaq 0x5ce2b(%rip), %rax # 0xa6b0c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
testq %rdx, %rdx
je 0x49d33
movq %rdx, %rsi
jmp 0x3c824
cmpq $0x0, 0x2a0(%rdi)
jne 0x49d33
movq %rdx, %rdi
jmp 0x49da8
cmpq $0x0, 0x2a0(%rdi)
je 0x49d39
movq %rdx, %rsi
jmp 0x49d75
te... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VtabUnlock | SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){
sqlite3 *db = pVTab->db;
assert( db );
assert( pVTab->nRef>0 );
assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE );
pVTab->nRef--;
if( pVTab->nRef==0 ){
sqlite3_vtab *p = pVTab->pVtab;
if( p ){
p->pModule->xDisconnec... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
decl 0x18(%rdi)
je 0x49dbc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x49dce
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c824
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3OsCurrentTimeInt64 | SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
int rc;
/* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
** method to get the current date and time if that method is available
** (if iVersion is 2 or greater and the function pointer is not NUL... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, (%rdi)
jl 0x49e04
movq 0x88(%rdi), %rax
testq %rax, %rax
je 0x49e04
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq %rsp, %r14
movq %r14, %rsi
callq *0x78(%rdi)
movsd (%r14), %xmm0
mulsd 0x61d96(%rip), %xmm0 # 0xabbb0
cvttsd2si %xmm0, %r... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeTransferError | SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){
sqlite3 *db = p->db;
int rc = p->rc;
if( p->zErrMsg ){
db->bBenignMalloc++;
sqlite3BeginBenignMalloc();
if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
sqlite3En... | pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movl 0x38(%rdi), %ebp
cmpq $0x0, 0x90(%rdi)
je 0x4a42b
movq %rdi, %r14
incb 0x62(%rbx)
movq 0x8652e(%rip), %rax # 0xd08e8
testq %rax, %rax
je 0x4a3c1
callq *%rax
movq 0x150(%rbx), %rdi
testq %rdi, %rdi
jne 0x4a3f3
movl $0x38, %esi
movq %rbx, %rdi
callq 0x330be
test... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeEnter | SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){
int i;
sqlite3 *db;
Db *aDb;
int nDb;
if( DbMaskAllZero(p->lockMask) ) return; /* The common case */
db = p->db;
aDb = db->aDb;
nDb = db->nDb;
for(i=0; i<nDb; i++){
if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
sqlite3BtreeE... | cmpl $0x0, 0xc8(%rdi)
je 0x4a4c9
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0x28(%rax), %r14
testq %r14, %r14
jle 0x4a4be
movq 0x20(%rax), %r15
addq $0x8, %r15
xorl %r12d, %r12d
cmpq $0x1, %r12
je 0x4a4b2
movl 0xc8(%rbx), %eax
btl %r12d, %eax
jae 0x4a4b2
movq (%r15),... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3RollbackAll | SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){
int i;
int inTrans = 0;
int schemaChange;
assert( sqlite3_mutex_held(db->mutex) );
sqlite3BeginBenignMalloc();
/* Obtain all b-tree mutexes before making any calls to BtreeRollback().
** This is important in case the transaction being ro... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x86407(%rip), %rax # 0xd08e8
testq %rax, %rax
je 0x4a4e8
callq *%rax
cmpb $0x0, 0x69(%rbx)
jne 0x4a4f6
movq %rbx, %rdi
callq 0x3ec19
testb $0x1, 0x2c(%rbx)
jne 0x4a501
xorl %r14d, %r14d
jmp 0x4a50c
cmp... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3CloseSavepoints | SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){
while( db->pSavepoint ){
Savepoint *pTmp = db->pSavepoint;
db->pSavepoint = pTmp->pNext;
sqlite3DbFree(db, pTmp);
}
db->nSavepoint = 0;
db->nStatement = 0;
db->isTransactionSavepoint = 0;
} | pushq %rbx
movq %rdi, %rbx
movq 0x278(%rdi), %rsi
testq %rsi, %rsi
je 0x4a644
movq 0x18(%rsi), %rax
movq %rax, 0x278(%rbx)
movq %rbx, %rdi
callq 0x3c824
movq 0x278(%rbx), %rsi
jmp 0x4a623
movq $0x0, 0x284(%rbx)
movb $0x0, 0x67(%rbx)
popq %rbx
retq
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeCommit | static int vdbeCommit(sqlite3 *db, Vdbe *p){
int i;
int nTrans = 0; /* Number of databases with an active write-transaction
** that are candidates for a two-phase commit using a
** master-journal */
int rc = SQLITE_OK;
int needXcommit = 0;
#ifdef SQLITE_OMIT_VIRTUALTABLE
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1e0(%rdi), %r12
movq $0x0, 0x1e0(%rdi)
xorl %r13d, %r13d
movslq 0x1bc(%rbx), %rax
cmpq %rax, %r13
jge 0x4a6ca
movq (%r12,%r13,8), %rax
movq 0x10(%rax), %r15
xorl %ebp, %ebp
testq %r15, %r15
je 0x4a6... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeFrameRestore | SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){
Vdbe *v = pFrame->v;
closeCursorsInFrame(v);
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
v->anExec = pFrame->anExec;
#endif
v->aOp = pFrame->aOp;
v->nOp = pFrame->nOp;
v->aMem = pFrame->aMem;
v->nMem = pFrame->nMem;
v->apCsr = pFrame->apCsr;
v->n... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq 0x4ac70
movq 0x10(%rbx), %rax
movq %rax, 0x68(%r14)
movl 0x58(%rbx), %eax
movl %eax, 0xb8(%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x70(%r14)
movl 0x5c(%rbx), %eax
movl %eax, 0x28(%r14)
movq 0x28(%rbx), %rax
movq %rax, 0x98(%r14)
mov... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeFreeCursor | SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
if( pCx==0 ){
return;
}
assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE );
switch( pCx->eCurType ){
case CURTYPE_SORTER: {
sqlite3VdbeSorterClose(p->db, pCx);
break;
}
case CURTYPE_BTREE: {
if( pCx->isEph... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x4adcd
movq %rsi, %rbx
movzbl (%rsi), %eax
testl %eax, %eax
je 0x4ada9
cmpl $0x2, %eax
je 0x4ad94
cmpl $0x1, %eax
jne 0x4adcd
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x4adcd
movq (%rdi), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4b018
movq 0x40(%r14), %rdi
call... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3BtreeClose | SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){
BtShared *pBt = p->pBt;
BtCursor *pCur;
/* Close all cursors opened via this handle. */
assert( sqlite3_mutex_held(p->db->mutex) );
sqlite3BtreeEnter(p);
pCur = pBt->pCursor;
while( pCur ){
BtCursor *pTmp = pCur;
pCur = pCur->pNext;
if( pTmp->p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
cmpb $0x0, 0x11(%rdi)
je 0x4adf9
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x4adf9
movq %rbx, %rdi
callq 0x46b8f
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x4ae19
movq 0x28(%rdi), %r15
cmpq %rbx, 0x8(%rdi)
jne 0x4ae11
callq 0x4a... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeSorterJoinThread | static int vdbeSorterJoinThread(SortSubtask *pTask){
int rc = SQLITE_OK;
if( pTask->pThread ){
#ifdef SQLITE_DEBUG_SORTER_THREADS
int bDone = pTask->bDone;
#endif
void *pRet = SQLITE_INT_TO_PTR(SQLITE_ERROR);
vdbeSorterBlockDebug(pTask, !bDone, "enter");
(void)sqlite3ThreadJoin(pTask->pThread, &pRet... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x4b27e
movq %rdi, %rbx
movq $0x1, (%rsp)
cmpl $0x0, 0x8(%r14)
je 0x4b282
movq 0x10(%r14), %rax
movq %rax, (%rsp)
jmp 0x4b28d
xorl %eax, %eax
jmp 0x4b2a6
movq (%r14), %rdi
movq %rsp, %rsi
callq 0xa3c0
movq %r14, %rdi
callq 0x2be2e
movl (%rsp), %eax
... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeIncrFree | static void vdbeIncrFree(IncrMerger *pIncr){
if( pIncr ){
#if SQLITE_MAX_WORKER_THREADS>0
if( pIncr->bUseThread ){
vdbeSorterJoinThread(pIncr->pTask);
if( pIncr->aFile[0].pFd ) sqlite3OsCloseFree(pIncr->aFile[0].pFd);
if( pIncr->aFile[1].pFd ) sqlite3OsCloseFree(pIncr->aFile[1].pFd);
}
#endi... | testq %rdi, %rdi
je 0x4b32c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0x4b314
movq (%rbx), %rdi
callq 0x4b256
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x4b2ee
movq (%r14), %rax
testq %rax, %rax
je 0x4b2e6
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, (%r14)
movq %r14, %rdi
callq 0x2be2e
m... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
callFinaliser | static void callFinaliser(sqlite3 *db, int offset){
int i;
if( db->aVTrans ){
VTable **aVTrans = db->aVTrans;
db->aVTrans = 0;
for(i=0; i<db->nVTrans; i++){
VTable *pVTab = aVTrans[i];
sqlite3_vtab *p = pVTab->pVtab;
if( p ){
int (*x)(sqlite3_vtab *);
x = *(int (**)(sql... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x1e0(%rdi), %r14
testq %r14, %r14
je 0x4b3ae
movq %rdi, %rbx
movq $0x0, 0x1e0(%rdi)
cmpl $0x0, 0x1bc(%rdi)
jle 0x4b399
movl %esi, %r12d
xorl %r13d, %r13d
movq (%r14,%r13,8), %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x4b37a
movq (%rdi), %rax
movq (%rax,%... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeError | SQLITE_PRIVATE void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){
va_list ap;
sqlite3DbFree(p->db, p->zErrMsg);
va_start(ap, zFormat);
p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap);
va_end(ap);
} | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4b417
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
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.