name string | code string | asm string | file string |
|---|---|---|---|
llvm::MDNode::operator delete(void*) | void MDNode::operator delete(void *N) {
Header *H = reinterpret_cast<Header *>(N) - 1;
void *Mem = H->getAllocation();
H->~Header();
::operator delete(Mem);
} | pushq %rbx
movq %rdi, %rbx
addq $-0x10, %rdi
movl -0x10(%rbx), %eax
andl $0x3c, %eax
leal 0xf(,%rax,2), %eax
andl $-0x8, %eax
subq %rax, %rbx
addq $-0x8, %rbx
callq 0x29f882
movq %rbx, %rdi
popq %rbx
jmp 0x89440
nop
| /IR/Metadata.cpp |
llvm::MDNode::storeDistinctInContext() | void MDNode::storeDistinctInContext() {
assert(!Context.hasReplaceableUses() && "Unexpected replaceable uses");
assert(!getNumUnresolved() && "Unexpected unresolved nodes");
Storage = Distinct;
assert(isResolved() && "Expected this to be resolved");
// Reset the hash.
switch (getMetadataID()) {
default:
... | movb 0x1(%rdi), %al
andb $-0x80, %al
incb %al
movb %al, 0x1(%rdi)
movzbl (%rdi), %eax
movabsq $0xffffffdc0, %rcx # imm = 0xFFFFFFDC0
btq %rax, %rcx
jae 0x29f9da
movq 0x8(%rdi), %rax
movq %rax, %rcx
andq $-0x8, %rcx
testb $0x4, %al
je 0x29f9c1
movq (%rcx), %rcx
pushq %rax
movl $0x518, %eax # imm = 0x518
... | /IR/Metadata.cpp |
llvm::Value::eraseMetadata(unsigned int) | bool Value::eraseMetadata(unsigned KindID) {
// Nothing to unset.
if (!HasMetadata)
return false;
MDAttachments &Store = getContext().pImpl->ValueMetadata.find(this)->second;
bool Changed = Store.erase(KindID);
if (Store.empty())
clearMetadata();
return Changed;
} | pushq %rbp
pushq %r14
pushq %rbx
testb $0x20, 0x7(%rdi)
jne 0x2a15da
xorl %ebp, %ebp
jmp 0x2a1613
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2ad308
movl $0xaa0, %edi # imm = 0xAA0
addq (%rax), %rdi
movq %rbx, %rsi
callq 0x2a14ec
movq %rax, %r14
leaq 0x8(%rax), %rdi
movl %ebp, %esi
callq 0x2a11f2
movl %eax, %ebp... | /IR/Metadata.cpp |
llvm::Instruction::setMetadata(unsigned int, llvm::MDNode*) | void Instruction::setMetadata(unsigned KindID, MDNode *Node) {
if (!Node && !hasMetadata())
return;
// Handle 'dbg' as a special case since it is not stored in the hash table.
if (KindID == LLVMContext::MD_dbg) {
DbgLoc = DebugLoc(Node);
return;
}
// Update DIAssignID to Instruction(s) mapping.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x2a16f6
cmpl $0x26, %ebp
je 0x2a1712
testl %ebp, %ebp
jne 0x2a171d
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28b4f2
addq $0x30, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22a134
mo... | /IR/Metadata.cpp |
llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueAsMetadata*>* 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... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, (%rsp)
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x2a2f17
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x2a2f19
incl 0x8... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Value*, llvm::ValueAsMetadata*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, llvm::ValueAsMetadata*>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %edi
callq 0x8ccd8
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0x29d0a4
testq %r14, %r14
je 0x2a2f84
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq ... | /llvm/ADT/DenseMap.h |
llvm::StringMap<llvm::NamedMDNode*, llvm::MallocAllocator>::erase(llvm::StringRef) | bool erase(StringRef Key) {
iterator I = find(Key);
if (I == end())
return false;
erase(I);
return true;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2a6758
movq %rax, %r14
movl 0x8(%rbx), %r15d
shlq $0x3, %r15
addq (%rbx), %r15
cmpq %r15, %rax
je 0x2a5a4f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a6786
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
| /llvm/ADT/StringMap.h |
llvm::Module::getModuleFlagsMetadata(llvm::SmallVectorImpl<llvm::Module::ModuleFlagEntry>&) const | void Module::
getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const {
const NamedMDNode *ModFlags = getModuleFlagsMetadata();
if (!ModFlags) return;
for (const MDNode *Flag : ModFlags->operands()) {
ModFlagBehavior MFB;
MDString *Key = nullptr;
Metadata *Val = nullptr;
if (isValid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
callq 0x2a5bfa
testq %rax, %rax
je 0x2a5beb
movq %rax, %r15
movq %rax, %rdi
callq 0x246294
movl %edx, %ebp
leaq 0x20(%rsp), %r14
movq %r15, (%r14)
xorl %eax, %eax
leaq 0xc(%rsp), %r15
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp)... | /IR/Module.cpp |
llvm::Module::ModuleFlagEntry const* llvm::SmallVectorTemplateCommon<llvm::Module::ModuleFlagEntry, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::Module::ModuleFlagEntry, true>>(llvm::SmallVectorTemplateBase<llvm::Module::ModuleFlagEntry, true>*, llvm::Module::ModuleFlagEntry const&, unsig... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %edx
addq %rax, %rcx
cmpq %rdx, %rcx
ja 0x2a67f1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rdx
imulq $0x18, %rax, %rax
addq %rdx, %... | /llvm/ADT/SmallVector.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [27], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [27], 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 0x8e812
movb $0x0, 0x80(%r14)
andq $0x0, 0x90(%r14)
leaq 0x2bfe0a(%rip), %rax # 0x566cb8
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x2c3dd0(%ri... | /llvm/Support/CommandLine.h |
llvm::cl::opt<llvm::ChangePrinter, false, llvm::cl::parser<llvm::ChangePrinter>>::opt<char [14], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::ValueExpected, llvm::cl::initializer<llvm::ChangePrinter>, llvm::cl::ValuesClass>(char const (&) [14], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::ValueE... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x50(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x8e812
andl $0x0, 0x80(%r14)
andq $0x0, 0x90(%r14)
leaq 0x2e009b(%rip), %rax... | /llvm/Support/CommandLine.h |
llvm::cl::parser<llvm::ChangePrinter>::parse(llvm::cl::Option&, llvm::StringRef, llvm::StringRef, llvm::ChangePrinter&) | bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
StringRef ArgVal;
if (Owner.hasArgStr())
ArgVal = Arg;
else
ArgVal = ArgName;
for (size_t i = 0, e = Values.size(); i != e; ++i)
if (Values[i].Name == ArgVal) {
V = Values[i].V.getValue();
return fa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %rax
cmpq $0x0, 0x18(%rax)
cmovneq %r8, %r15
cmovneq %r9, %r14
movl 0x18(%rdi), %eax
imulq $0x30, %rax, %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x2a84f0
movq... | /llvm/Support/CommandLine.h |
llvm::PointerType::get(llvm::LLVMContext&, unsigned int) | PointerType *PointerType::get(LLVMContext &C, unsigned AddressSpace) {
LLVMContextImpl *CImpl = C.pImpl;
// Since AddressSpace #0 is the common case, we special case it.
PointerType *&Entry = AddressSpace == 0 ? CImpl->AS0PointerType
: CImpl->PointerTypes[AddressSpace];
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movq (%rdi), %r14
testl %esi, %esi
je 0x2a93da
leaq 0xa28(%r14), %rdi
leaq 0x4(%rsp), %rsi
callq 0x2ab3f6
movq %rax, %r15
addq $0x8, %r15
jmp 0x2a93e1
leaq 0xa20(%r14), %r15
movq (%r15), %r12
testq %r12, %r12
jne 0x2a9410
addq $... | /IR/Type.cpp |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Type*, llvm::ElementCount>, llvm::VectorType*, llvm::DenseMapInfo<std::pair<llvm::Type*, llvm::ElementCount>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Type*, llvm::ElementCount>, llvm::VectorType*>>, std::pair<llvm::Type*, llvm::ElementCount>, llvm::VectorType*... | 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
callq 0x29d238
movq %rsp, %r12
cmpq %rbx, %r14
je 0x2ab3e9
movq (%r14), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x2ab39f
cmpq $-0x1000, %rax # imm = 0xF000
jne 0x2ab3ad
cmpl $-0x1, 0x8(%r14)
jne 0... | /llvm/ADT/DenseMap.h |
llvm::ValueHandleBase::ValueIsDeleted(llvm::Value*) | void ValueHandleBase::ValueIsDeleted(Value *V) {
assert(V->HasValueHandle && "Should only be called if ValueHandles present");
// Get the linked list base, which is guaranteed to exist since the
// HasValueHandle flag is set.
LLVMContextImpl *pImpl = V->getContext().pImpl;
ValueHandleBase *Entry = pImpl->Val... | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x20(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x8(%rdi), %rax
movq (%rax), %rax
movl $0xa70, %edi # imm = 0xA70
addq (%rax), %rdi
callq 0x2ae646
movq 0x8(%rax), %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x228d5e
testq %r14, %r14
je 0... | /IR/Value.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::Instruction const*, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::Instruction const*>>, llvm::Instruction const*, llvm::Instruction const*, llvm::DenseMapInfo<llvm::Instruction const*, void... | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + ... | testl %esi, %esi
je 0x2b21b2
pushq %rax
shll $0x2, %esi
pushq $0x3
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
leal 0x1(%rax), %edi
callq 0x8ccd8
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
| /llvm/ADT/DenseMap.h |
(anonymous namespace)::Verifier::visitDbgIntrinsic(llvm::StringRef, llvm::DbgVariableIntrinsic&) | void Verifier::visitDbgIntrinsic(StringRef Kind, DbgVariableIntrinsic &DII) {
auto *MD = DII.getRawLocation();
CheckDI(isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
(isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
"invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movl 0x4(%rcx), %eax
movl %eax, %ecx
shll $0x5, %ecx
movq %r14, %rdx
subq %rcx, %rdx
movq (%rdx), %rcx
movq 0x18(%rcx), %rbx
movq %rbx, 0xc0(%rsp)
movzbl (%rbx), %ecx
cmpl $... | /IR/Verifier.cpp |
(anonymous namespace)::Verifier::visitBinaryOperator(llvm::BinaryOperator&) | void Verifier::visitBinaryOperator(BinaryOperator &B) {
Check(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
"Both operands to a binary operator are not of the same type!", &B);
switch (B.getOpcode()) {
// Check that integer arithmetic operators are only used with
// integral operands.
cas... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %rax
movq -0x20(%rsi), %rcx
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
je 0x2c8e6c
leaq 0x13f145(%rip), %rax # 0x407f8b
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
leaq 0x8(%rsp), %rdx
movq ... | /IR/Verifier.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::MDNode const*, bool, llvm::DenseMapInfo<llvm::MDNode const*, void>, llvm::detail::DenseMapPair<llvm::MDNode const*, bool>>, llvm::MDNode const*, bool, llvm::DenseMapInfo<llvm::MDNode const*, void>, llvm::detail::DenseMapPair<llvm::MDNode const*, bool>>::LookupBucketFor<llvm:... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2cba9a
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r8d
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
movl $0x1, %r10d
xorl %r9d, %r9d
andl %ecx, %r8d
movq %r8, %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r11
movq (%rdi,%rax), %rbx
movb $... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::MDNode const*, bool, llvm::DenseMapInfo<llvm::MDNode const*, void>, llvm::detail::DenseMapPair<llvm::MDNode const*, bool>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::MDNode const*, bool, llvm::DenseMapInfo<llvm::MDNode const*, void>, llvm::detail::DenseMapPair<llvm::MDN... | 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 0x2cba1a
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x2cbaea
xorl %ecx, %ecx
jmp 0x2cbafd
movq %r14,... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<llvm::VFParameter>::operator=(llvm::SmallVectorImpl<llvm::VFParameter>&&) | SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2ccbae
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x10(%r14), %rax
cmpq %rax, %rsi
je 0x2ccb30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ccbbe
jmp 0x2ccbae
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %r12d
cmpl %r15d, %r12d
jae 0x2ccb54
cm... | /llvm/ADT/SmallVector.h |
llvm::Triple::isOSVersionLT(unsigned int, unsigned int, unsigned int) const | bool isOSVersionLT(unsigned Major, unsigned Minor = 0,
unsigned Micro = 0) const {
if (Minor == 0) {
return getOSVersion() < VersionTuple(Major);
}
if (Micro == 0) {
return getOSVersion() < VersionTuple(Major, Minor);
}
return getOSVersion() < VersionTuple(Major, Min... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
testl %edx, %edx
je 0x2ccd29
movl %ecx, %r14d
movl %edx, %ebx
movl %ebp, %eax
shlq $0x20, %rbx
orq %rax, %rbx
btsq $0x3f, %rbx
testl %ecx, %ecx
je 0x2ccd44
callq 0x33501c
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rsp, %rsi
movq %... | /llvm/TargetParser/Triple.h |
llvm::AbstractCallSite::AbstractCallSite(llvm::Use const*) | AbstractCallSite::AbstractCallSite(const Use *U)
: CB(dyn_cast<CallBase>(U->getUser())) {
// First handle unknown users.
if (!CB) {
// If the use is actually in a constant cast expression which itself
// has only one use, we look through the constant cast expression.
// This happens by updating th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movzbl (%r14), %eax
movabsq $0x8000000000041, %r15 # imm = 0x8000000000041
cmpl $0x1d, %eax
jb 0x2cceae
leal -0x22(%rax), %ecx
cmpl $0x33, %ecx
ja 0x2cceae
btq %rcx, %r15
movq %r14, ... | /IR/AbstractCallSite.cpp |
llvm::ConstantFoldInsertValueInstruction(llvm::Constant*, llvm::Constant*, llvm::ArrayRef<unsigned int>) | Constant *llvm::ConstantFoldInsertValueInstruction(Constant *Agg,
Constant *Val,
ArrayRef<unsigned> Idxs) {
// Base case: no indices, so replace the entire value.
if (Idxs.empty())
return Val;
unsigned NumEl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, (%rsp)
testq %rcx, %rcx
je 0x2ce13e
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2ce0a0
movzbl 0x8(%rax), %ecx
cmpl $0x10, %ecx
jne 0x2ce0a0
movl 0xc(%rax... | /IR/ConstantFold.cpp |
llvm::SetVector<llvm::BasicBlock*, llvm::SmallVector<llvm::BasicBlock*, 8u>, llvm::DenseSet<llvm::BasicBlock const*, llvm::DenseMapInfo<llvm::BasicBlock const*, void>>, 8u>::contains(llvm::BasicBlock const* const&) const | bool contains(const key_type &key) const {
if constexpr (canBeSmall())
if (isSmall())
return is_contained(vector_, key);
return set_.find(key) != set_.end();
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x2d0959
movq (%rsi), %rsi
movq %rbx, %rdi
callq 0x2d0a18
movl 0x10(%rbx), %ecx
shlq $0x3, %rcx
addq (%rbx), %rcx
cmpq %rcx, %rax
setne %al
popq %rbx
retq
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x2d0966
| /llvm/ADT/SetVector.h |
llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>>::printEntries(llvm::GenericSSAContext<llvm::Function> const&) const::'lambda'(llvm::raw_ostream&)::operator()(llvm::raw_ostream&) const | Printable printEntries(const ContextT &Ctx) const {
return Printable([this, &Ctx](raw_ostream &Out) {
bool First = true;
for (auto *Entry : Entries) {
if (!First)
Out << ' ';
First = false;
Out << Ctx.print(Entry);
}
});
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rsp)
movl 0x10(%rax), %ebp
shlq $0x3, %rbp
movb $0x1, %al
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
cmpq %r12, %rbp
je 0x2d0cd9
movq (%rsp), %rcx
movq (%rcx... | /llvm/ADT/GenericCycleInfo.h |
llvm::SmallVectorImpl<std::tuple<llvm::BasicBlock const*, llvm::SuccIterator<llvm::Instruction const, llvm::BasicBlock const>, llvm::SuccIterator<llvm::Instruction const, llvm::BasicBlock const>>>::operator=(llvm::SmallVectorImpl<std::tuple<llvm::BasicBlock const*, llvm::SuccIterator<llvm::Instruction const, llvm::Basi... | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &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 (C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2d1d5a
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %r12d
cmpl %r14d, %r12d
jae 0x2d1d3f
cmpl %r14d, 0xc(%rbx)
jae 0x2d1d69
andl $0x0, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d1c4c
jmp 0x2d1d82
testl %r14d, %... | /llvm/ADT/SmallVector.h |
llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GenericCycleInfoCompute<llvm::GenericSSAContext<llvm::Function>>::DFSInfo>* llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::GenericCycleInfoCompute<llvm::GenericSSAContext<llvm::Function>>::DFSInfo, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail:... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, (%rsp)
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x2d397f
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x2d3981
incl 0x8... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::BasicBlock const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseSetPair<llvm::BasicBlock const*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbx
movq %rdi, %rbx
callq 0x2d3b20
movq %rbx, %rdi
movl %eax, %esi
callq 0x2d3b42
testb %al, %al
je 0x2d3b18
movq %rbx, %rdi
popq %rbx
jmp 0x2d3b74
andq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
| /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>>*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::Function>>*>>, llvm::BasicBlock*, llvm::GenericCycle<llvm::G... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2d4274
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r8d
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
movl $0x1, %r10d
xorl %r9d, %r9d
andl %ecx, %r8d
movq %r8, %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r11
movq (%rdi,%rax), %rbx
movb $... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseSetPair<llvm::BasicBlock const*>>, llvm::BasicBlock const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseSet... | 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
callq 0x2d3b74
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
cmpq %rbx, %r14
je 0x2d451e
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x2d4518
mov... | /llvm/ADT/DenseMap.h |
llvm::DominatorTreeBase<llvm::BasicBlock, false>::dominates(llvm::DomTreeNodeBase<llvm::BasicBlock> const*, llvm::DomTreeNodeBase<llvm::BasicBlock> const*) const | bool dominates(const DomTreeNodeBase<NodeT> *A,
const DomTreeNodeBase<NodeT> *B) const {
// A node trivially dominates itself.
if (B == A)
return true;
// An unreachable node is dominated by anything.
if (!isReachableFromEntry(B))
return true;
// And dominates nothing.... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
cmpq %rsi, %rdx
sete %cl
testq %rdx, %rdx
sete %dl
movb $0x1, %al
orb %cl, %dl
jne 0x2d4ddb
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2d4dd9
cmpq %rbx, 0x8(%r14)
je 0x2d4ddb
cmpq %r14, 0x8(%rbx)
je 0x2d4dd9
movl 0x10(%rbx), %eax
cmpl 0x10(%r14), %eax
jae 0x2d4dd9
cmpb $0x1, ... | /llvm/Support/GenericDomTree.h |
llvm::DenseMap<llvm::BasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::BasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::BasicBlock>>>, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::BasicBlock>, std::default_delet... | void shrink_and_clear() {
unsigned OldNumBuckets = NumBuckets;
unsigned OldNumEntries = NumEntries;
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldNumEntries)
NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
if (NewNumBucke... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %r14d
callq 0x2cab4a
testl %ebp, %ebp
je 0x2d5c59
decl %ebp
je 0x2d5c5d
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x2d5c60
xorl %ebp, %ebp
jmp 0x2d5c72
pushq $0x20
popq %rax
movb $0x21, %cl
subb %al, %cl
pushq $0x1
popq %rax
shll %cl, %ea... | /llvm/ADT/DenseMap.h |
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false>>::attachNewSubtree(llvm::DominatorTreeBase<llvm::BasicBlock, false>&, llvm::DomTreeNodeBase<llvm::BasicBlock>*) | void attachNewSubtree(DomTreeT& DT, const TreeNodePtr AttachTo) {
// Attach the first unreachable block to AttachTo.
NodeToInfo[NumToNode[1]].IDom = AttachTo->getBlock();
// Loop over all of the discovered blocks in the function...
for (NodePtr W : llvm::drop_begin(NumToNode)) {
// Don't replace t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %r15
addq $0x210, %rdi # imm = 0x210
movq (%r14), %rsi
addq $0x8, %rsi
callq 0x2d64fc
movq %r15, 0x18(%rax)
movq (%r14), %r13
movl 0x8(%r14), %ebp
leaq 0x18(%rbx), %r15
shlq $0x3, %rbp
pu... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::colorEHFunclets(llvm::Function&) | DenseMap<BasicBlock *, ColorVector> llvm::colorEHFunclets(Function &F) {
SmallVector<std::pair<BasicBlock *, BasicBlock *>, 16> Worklist;
BasicBlock *EntryBlock = &F.getEntryBlock();
DenseMap<BasicBlock *, ColorVector> BlockColors;
// Build up the color map, which maps each block to its set of 'colors'.
// F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x1000000000, %rcx # imm = 0x1000000000
movq %rcx, -0x8(%rax)
movq 0x50(%rsi), %rax
leaq -0x18(%rax), %r14
testq %rax, %rax
cmoveq %rax, ... | /IR/EHPersonalities.cpp |
bool llvm::is_contained<llvm::TinyPtrVector<llvm::BasicBlock*>&, llvm::BasicBlock*>(llvm::TinyPtrVector<llvm::BasicBlock*>&, llvm::BasicBlock* const&) | bool is_contained(R &&Range, const E &Element) {
if constexpr (detail::HasMemberContains<R, E>)
return Range.contains(Element);
else if constexpr (detail::HasMemberFind<R, E>)
return Range.find(Element) != Range.end();
else
return std::find(adl_begin(Range), adl_end(Range), Element) !=
adl_... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq %rdi, %r15
testb $0x4, %al
je 0x2d7dd3
andq $-0x8, %rax
movq (%rax), %r15
movq %rbx, %rdi
callq 0x2c81b4
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2d452c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c81b4
cmpq %rax, %r14
s... | /llvm/ADT/STLExtras.h |
void llvm::Expected<unsigned long>::moveConstruct<unsigned long>(llvm::Expected<unsigned long>&&) | void moveConstruct(Expected<OtherT> &&Other) {
HasError = Other.HasError;
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
Unchecked = true;
Other.Unchecked = false;
#endif
if (!HasError)
new (getStorage()) storage_type(std::move(*Other.getStorage()));
else
new (getErrorStorage()) error_type(std::mo... | movb 0x8(%rsi), %al
andb $0x1, %al
movb 0x8(%rdi), %cl
andb $-0x2, %cl
orb %al, %cl
movb %cl, 0x8(%rdi)
movq (%rsi), %rcx
movq %rcx, (%rdi)
testb %al, %al
je 0x2da99e
andq $0x0, (%rsi)
retq
nop
| /llvm/Support/Error.h |
llvm::MCSymbol::getFragment(bool) const | MCFragment *getFragment(bool SetUsed = true) const {
if (Fragment || !isVariable() || isWeakExternal())
return Fragment;
// If the symbol is a non-weak alias, get information about
// the aliasee. (Don't try to resolve weak aliases.)
Fragment = getVariableValue(SetUsed)->findAssociatedFragment();
... | movq (%rdi), %rax
testq %rax, %rax
je 0x2dc7cb
retq
pushq %rbx
movq %rdi, %rbx
movl $0x7080, %eax # imm = 0x7080
andl 0x8(%rdi), %eax
cmpl $0x2000, %eax # imm = 0x2000
jne 0x2dc7f7
movzbl %sil, %esi
movq %rbx, %rdi
callq 0x2db3f0
movq %rax, %rdi
callq 0x3121d4
movq %rax, (%rbx)
jmp 0x2dc7f9
xorl %ea... | /llvm/MC/MCSymbol.h |
(anonymous namespace)::AsmParser::checkForValidSection() | bool AsmParser::checkForValidSection() {
if (!ParsingMSInlineAsm && !getStreamer().getCurrentFragment()) {
Out.initSections(false, getTargetParser().getSTI());
return Error(getTok().getLoc(),
"expected section directive before assembly directive");
}
return false;
} | cmpb $0x0, 0x36d(%rdi)
je 0x2df36e
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x38(%rax)
cmpq $0x0, 0x118(%rax)
je 0x2df38c
xorl %eax, %eax
jmp 0x2df3e0
movq 0x8(%rbx), %rdi
movq 0xe8(%rbx), %r14
callq 0x2f67c4
movq (%r14), %rcx
movq %r14, %rdi
xorl %esi, %esi
m... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseCppHashLineFilenameComment(llvm::SMLoc, bool) | bool AsmParser::parseCppHashLineFilenameComment(SMLoc L, bool SaveLocInfo) {
Lex(); // Eat the hash token.
// Lexer only ever emits HashDirective if it fully formed if it's
// done the checking already so this is an internal error.
assert(getTok().is(AsmToken::Integer) &&
"Lexing Cpp line comment: Expe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0xb8(%rax)
movq %rbx, %rdi
callq 0x2f5ea0
cmpl $0x41, 0x20(%rax)
jb 0x2e666c
movq 0x18(%rax), %rax
jmp 0x2e6670
addq $0x18, %rax
movq (%rax), %r15
movq (%rbx), %rax
movq ... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseDirectiveIfeqs(llvm::SMLoc, bool) | bool AsmParser::parseDirectiveIfeqs(SMLoc DirectiveLoc, bool ExpectEqual) {
if (Lexer.isNot(AsmToken::String)) {
if (ExpectEqual)
return TokError("expected string parameter for '.ifeqs' directive");
return TokError("expected string parameter for '.ifnes' directive");
}
StringRef String1 = getTok().... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
cmpl $0x3, (%rax)
jne 0x2e698a
movq %rbx, %rdi
callq 0x2f5ea0
movq %rax, %rdi
callq 0x2e843c
movq %rax, %r14
movq %rdx, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb8(%rax)
movq 0... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseAssignment(llvm::StringRef, (anonymous namespace)::AsmParser::AssignmentKind) | bool AsmParser::parseAssignment(StringRef Name, AssignmentKind Kind) {
MCSymbol *Sym;
const MCExpr *Value;
SMLoc ExprLoc = getTok().getLoc();
bool AllowRedef =
Kind == AssignmentKind::Set || Kind == AssignmentKind::Equal;
if (MCParserUtils::parseAssignmentExpression(Name, AllowRedef, *this, Sym,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x2f5ea0
movq %rax, %rdi
callq 0x2f5cd4
movq %rax, %r14
xorl %edx, %edx
testl $0xfffffffd, %ebp # imm = 0xFFFFFFFD
sete %dl
leaq 0x8(%rsp), %r8
movq %rsp, %r9
mo... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseDirectiveComm(bool) | bool AsmParser::parseDirectiveComm(bool IsLocal) {
if (checkForValidSection())
return true;
SMLoc IDLoc = getLexer().getLoc();
StringRef Name;
if (parseIdentifier(Name))
return TokError("expected identifier in directive");
// Handle the identifier as the key symbol.
MCSymbol *Sym = getContext().ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x108(%rax)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2e7784
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq %rax, %rdi
callq 0x2f5cce
movq %rax, %r14
xorps %xmm... | /MC/MCParser/AsmParser.cpp |
void llvm::SmallVectorImpl<llvm::SMLoc>::resizeImpl<false>(unsigned long) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x2ea38b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
jbe 0x2ea38c
movl %ebx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ea3ba
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x3, %rcx
leaq (,%rbx,8), %rdx
cmpq %rc... | /llvm/ADT/SmallVector.h |
parseHexOcta((anonymous namespace)::AsmParser&, unsigned long&, unsigned long&) | static bool parseHexOcta(AsmParser &Asm, uint64_t &hi, uint64_t &lo) {
if (Asm.getTok().isNot(AsmToken::Integer) &&
Asm.getTok().isNot(AsmToken::BigNum))
return Asm.TokError("unknown token in expression");
SMLoc ExprLoc = Asm.getTok().getLoc();
APInt IntValue = Asm.getTok().getAPIntVal();
Asm.Lex();
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2f5ea0
cmpl $0x4, (%rax)
je 0x2eaca9
movq %r15, %rdi
callq 0x2f5ea0
cmpl $0x5, (%rax)
jne 0x2ead49
movq %r15, %rdi
callq 0x2f5ea0
movq %rax, %rdi
callq 0x2f5cd4
movq %rax, %r12
movq %r15, %rdi... | /MC/MCParser/AsmParser.cpp |
bool llvm::function_ref<bool ()>::callback_fn<(anonymous namespace)::AsmParser::parseDirectiveCVLoc()::$_0>(long) | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movq %rbx, %rdi
callq 0x2f5ea0
movq %rax, %rdi
callq 0x2f5cd4
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0xc0(%rax)
testb %al, %al
je 0x2ec... | /llvm/ADT/STLFunctionalExtras.h |
(anonymous namespace)::AsmParser::parseRegisterOrRegisterNumber(long&, llvm::SMLoc) | bool AsmParser::parseRegisterOrRegisterNumber(int64_t &Register,
SMLoc DirectiveLoc) {
MCRegister RegNo;
if (getLexer().isNot(AsmToken::Integer)) {
if (getTargetParser().parseRegister(RegNo, DirectiveLoc, DirectiveLoc))
return true;
Register = getContext(... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x10(%rsp)
andl $0x0, 0xc(%rsp)
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rax), %rax
cmpl $0x4, (%rax)
jne 0x2ec383
movq (%r14), %rax
movq 0x100(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%r... | /MC/MCParser/AsmParser.cpp |
llvm::StringMap<llvm::MCAsmMacro, llvm::MallocAllocator>::erase(llvm::StringRef) | bool erase(StringRef Key) {
iterator I = find(Key);
if (I == end())
return false;
erase(I);
return true;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2e9016
movq %rax, %r14
movl 0x8(%rbx), %r15d
shlq $0x3, %r15
addq (%rbx), %r15
cmpq %r15, %rax
je 0x2ec7b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ec7c4
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
| /llvm/ADT/StringMap.h |
llvm::SmallVectorTemplateBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false>::growAndAssign(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void growAndAssign(size_t NumElts, const T &Elt) {
// Grow manually in case Elt is an internal reference.
size_t NewCapacity;
T *NewElts = mallocForGrow(NumElts, NewCapacity);
std::uninitialized_fill_n(NewElts, NumElts, Elt);
this->destroy_range(this->begin(), this->end());
takeAllocationForGrow... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdx
callq 0x118b2e
movq %rax, %r13
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2edc1c
movq (%r14), %rdi
movl 0x8(%r14), %esi
shlq $0x5, %rsi
addq %rdi, %rs... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::AsmParser::printMacroInstantiations() | void AsmParser::printMacroInstantiations() {
// Print the active macro instantiation stack.
for (MacroInstantiation *M : reverse(ActiveMacros))
printMessage(M->InstantiationLoc, SourceMgr::DK_Note,
"while in macro instantiation");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x170(%rdi), %r15
movq 0x178(%rdi), %r12
leaq 0x1201f2(%rip), %r13 # 0x40df1e
pushq $0x3
popq %rbp
movq %rsp, %r14
cmpq %r15, %r12
je 0x2edd63
movq -0x8(%r12), %rax
addq $-0x8, %r12
movq (%rax), %rsi
movq %r13, (%... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::COFFAsmParser::ParseSectionSwitch(llvm::StringRef, unsigned int, llvm::StringRef, llvm::COFF::COMDATType) | bool COFFAsmParser::ParseSectionSwitch(StringRef Section,
unsigned Characteristics,
StringRef COMDATSymName,
COFF::COMDATType Type) {
if (getLexer().isNot(AsmToken::EndOfStatement))
return TokError... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rax), %rax
cmpl $0x9, (%rax)
jne 0x2ee79e
movq 0x8(%r13), %rdi
movq (%rdi), ... | /MC/MCParser/COFFAsmParser.cpp |
intToken(llvm::StringRef, llvm::APInt&) | static AsmToken intToken(StringRef Ref, APInt &Value) {
if (Value.isIntN(64))
return AsmToken(AsmToken::Integer, Ref, Value);
return AsmToken(AsmToken::BigNum, Ref, Value);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x1ddb60
cmpl $0x41, %eax
leaq 0x18(%rsp), %rax
leaq 0x8(%rsp), %r13
cmovbq %rax, %r13
pushq $0x5
popq %rbp
sbbl $0x0, %ebp
movq %r13, %rdi
movq %r15... | /MC/MCParser/AsmLexer.cpp |
llvm::codeview::TypeRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::TypeServer2Record&) | Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
TypeServer2Record &Record) {
error(IO.mapGuid(Record.Guid, "Guid"));
error(IO.mapInteger(Record.Age, "Age"));
error(IO.mapStringZ(Record.Name, "Name"));
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 0x392a4(%rip), %rax # 0x366e4f
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
movq %r15, %rsi
callq 0x330bcc
cmpq $0x0, (%rbx)
jne 0x32dc18
... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
main | int main(int argc, char* argv[]) {
if(argc != 3) {
std::cerr << "usage: ./inclusive_scan num_workers num_elements\n";
std::exit(EXIT_FAILURE);
}
size_t W = std::atoi(argv[1]);
size_t N = std::atoi(argv[2]);
tf::Executor executor(W);
tf::Taskflow taskflow;
std::vector<int> elements(N), scan_se... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
cmpl $0x3, %edi
jne 0x4d05
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x4490
movslq %eax, %r14
movq 0x10(%rbx), %rdi
callq 0x4490
movl %eax, %ebx
pxor %xmm0, %xmm0
leaq 0xa0(%rsp), %rdx
movdqa %xmm0, (%rdx)
leaq 0x180(%rsp), %rdi
mov... | /taskflow[P]taskflow/examples/inclusive_scan.cpp |
tf::Executor::Executor(unsigned long, std::shared_ptr<tf::WorkerInterface>) | inline Executor::Executor(size_t N, std::shared_ptr<WorkerInterface> wix) :
_workers (N),
_notifier (N),
_buffers (N),
_worker_interface(std::move(wix)) {
if(N == 0) {
TF_THROW("executor must define at least one worker");
}
_spawn(N);
// initialize the default observer if requested
if(has_env... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
leaq 0x10(%rsp), %rdx
movq %rdi, 0x8(%rsp)
callq 0x53d8
movq $0x3fff, 0x40(%r12) ... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Taskflow::~Taskflow() | ~Taskflow() = default; | pushq %rbx
movq %rdi, %rbx
addq $0x68, %rdi
callq 0xebdc
leaq 0x50(%rbx), %rdi
callq 0x8df2
movq 0x30(%rbx), %rdi
addq $0x40, %rbx
cmpq %rbx, %rdi
je 0x52a7
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x4300
popq %rbx
retq
nop
| /taskflow[P]taskflow/taskflow/core/taskflow.hpp |
tf::Executor::~Executor() | inline Executor::~Executor() {
// wait for all topologies to complete
wait_for_all();
// shut down the scheduler
for(size_t i=0; i<_workers.size(); ++i) {
#if __cplusplus >= TF_CPP20
_workers[i]._done.test_and_set(std::memory_order_relaxed);
#else
_workers[i]._done.store(true, std::memory_order_re... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x90(%rdi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x7dec
movb $0x1, 0x10(%rsp)
leaq 0x60(%rbx), %r14
cmpq $0x0, 0xb8(%rbx)
je 0x52fd
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x40a0
cmpq $... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
void tf::throw_re<char const (&) [41]>(char const*, unsigned long, char const (&) [41]) | void throw_re(const char* fname, const size_t line, ArgsT&&... args) {
std::ostringstream oss;
oss << "[" << fname << ":" << line << "] ";
//ostreamize(oss, std::forward<ArgsT>(args)...);
(oss << ... << args);
#ifdef TF_DISABLE_EXCEPTION_HANDLING
std::cerr << oss.str();
std::terminate();
#else
throw std::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x4400
leaq 0xbeab(%rip), %rsi # 0x11346
movl $0x1, %edx
movq %r12, %rdi
callq 0x4350
testq %r15, %r15
jne 0x54cb
movq 0x28(%... | /taskflow[P]taskflow/taskflow/core/error.hpp |
std::shared_ptr<tf::TFProfObserver> tf::Executor::make_observer<tf::TFProfObserver>() | std::shared_ptr<Observer> Executor::make_observer(ArgsT&&... args) {
static_assert(
std::is_base_of_v<ObserverInterface, Observer>,
"Observer must be derived from ObserverInterface"
);
// use a local variable to mimic the constructor
auto ptr = std::make_shared<Observer>(std::forward<ArgsT>(args)...);... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x58, %edi
callq 0x42f0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x12479(%rip), %rax # 0x17a80
movq %rax, (%r14)
leaq 0x10(%r14), %r13
leaq 0x124e3(%rip)... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::UnboundedTaskQueue<tf::Node*>::UnboundedTaskQueue(long) | UnboundedTaskQueue<T>::UnboundedTaskQueue(int64_t LogSize) {
_top.store(0, std::memory_order_relaxed);
_bottom.store(0, std::memory_order_relaxed);
_array.store(new Array{(int64_t{1} << LogSize)}, std::memory_order_relaxed);
_garbage.reserve(32);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x90(%rdi), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rdi)
movq $0x0, 0xa0(%rdi)
movq $0x0, (%rdi)
movq $0x0, 0x80(%rdi)
movl $0x18, %edi
callq 0x42f0
movq %rax, %r15
movl $0x1, %eax
movl %r12d, %ecx
shlq %cl, %rax
movq %rax, ... | /taskflow[P]taskflow/taskflow/core/tsq.hpp |
tf::UnboundedTaskQueue<tf::Node*>::~UnboundedTaskQueue() | UnboundedTaskQueue<T>::~UnboundedTaskQueue() {
for(auto a : _garbage) {
delete a;
}
delete _array.load();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x90(%rdi), %r15
movq 0x98(%rdi), %r12
cmpq %r12, %r15
je 0x5bf1
movq (%r15), %r14
testq %r14, %r14
je 0x5bde
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x5bde
callq 0x43a0
movl $0x18, %esi
movq %r14, %rdi
callq 0x4300
addq $0x8, %r15
jmp 0x5bc3... | /taskflow[P]taskflow/taskflow/core/tsq.hpp |
tf::Executor::_wait_for_task(tf::Worker&, tf::Node*&) | inline bool Executor::_wait_for_task(Worker& w, Node*& t) {
explore_task:
if(_explore_task(w, t) == false) {
return false;
}
// Go exploit the task if we successfully steal one.
if(t) {
return true;
}
// Entering the 2PC guard as all queues should be empty after many stealing attempts.
_no... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x92d8
testb %al, %al
je 0x60a2
leaq 0x40(%r15), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rbx)
setne %bpl
jne 0x6094
lock
addq $0x4000, 0x40(%r15) # imm = 0x4000
mfence
movq 0xd8(%r15), %rax... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Executor::_invoke(tf::Worker&, tf::Node*) | inline void Executor::_invoke(Worker& worker, Node* node) {
#define TF_INVOKE_CONTINUATION() \
if (cache) { \
node = cache; \
goto begin_invoke; \
}
begin_invoke:
Node* cache {nullptr};
// if this is the second invoke due to preemption, dire... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, (%rsp)
leaq 0x10(%rsp), %r14
movq $0x0, 0x8(%rsp)
testb $0x20, 0x3(%rbp)
jne 0x616c
movq 0x30(%rbp), %rax
testq %rax, %rax
je 0x60fc
movl 0x68(%rax), %ecx
btl $0x1d, %ecx
jb 0x6221
movq 0x38(%rb... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
void tf::Executor::_schedule<tf::Node**>(tf::Worker&, tf::Node**, tf::Node**) | void Executor::_schedule(Worker& worker, I first, I last) {
size_t num_nodes = last - first;
if(num_nodes == 0) {
return;
}
// NOTE: We cannot use first/last in the for-loop (e.g., for(; first != last; ++first)).
// This is because when a node v is inserted into the queue, v can run and finish
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, (%rsp)
subq %rdx, %r15
je 0x689e
movq %rsi, %r12
movq %rdi, %r14
sarq $0x3, %r15
cmpq %rdi, 0x18(%rsi)
je 0x681b
cmpq $0x1, %r15
movq %r15, 0x10(%rsp)
movq %r15, %rbp
adcq $0x0, %rbp
xorl %ebx, %ebx
movq (%rsp)... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Executor::_invoke_subflow_task(tf::Worker&, tf::Node*) | inline bool Executor::_invoke_subflow_task(Worker& worker, Node* node) {
auto& h = *std::get_if<Node::Subflow>(&node->_handle);
auto& g = h.subgraph;
if((node->_nstate & NSTATE::PREEMPTED) == 0) {
// set up the subflow
Subflow sf(*this, worker, node, g);
// invoke the subflow callable
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq 0x88(%rdx), %rax
xorl %r13d, %r13d
cmpb $0x3, 0xc0(%rdx)
cmoveq %rax, %r13
leaq 0x20(%r13), %r12
movl (%rdx), %eax
btl $0x1d, %eax
jb 0x6949
movq %rsi, %r14
movq %rdi, %r15
movq %r12, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Executor::_invoke_multi_condition_task(tf::Worker&, tf::Node*, tf::SmallVector<int, 2u>&) | inline void Executor::_invoke_multi_condition_task(
Worker& worker, Node* node, SmallVector<int>& conds
) {
_observer_prologue(worker, node);
TF_EXECUTOR_EXCEPTION_HANDLER(worker, node, {
conds = std::get_if<Node::MultiCondition>(&node->_handle)->work();
});
_observer_epilogue(worker, node);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x110(%rdi), %r13
testq %r13, %r13
je 0x6b2f
movq 0x8(%r13), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq (%r13), %r13
jmp 0x6b14
leaq 0x88(%rbx),... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Executor::_tear_down_async(tf::Worker&, tf::Node*, tf::Node*&) | inline void Executor::_tear_down_async(Worker& worker, Node* node, Node*& cache) {
// from executor
if(auto parent = node->_parent; parent == nullptr) {
_decrement_topology();
}
// from runtime
else {
auto state = parent->_nstate;
if(parent->_join_counter.fetch_sub(1, std::memory_order_acq_rel)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x38(%rdx), %r12
testq %r12, %r12
je 0x6d2b
movl $0x20000000, %eax # imm = 0x20000000
andl (%r12), %eax
lock
decq 0x80(%r12)
jne 0x6d5f
testl %eax, %eax
je 0x6d5f
movq %rcx, %r15
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x6d2... | /taskflow[P]taskflow/taskflow/core/async.hpp |
tf::Executor::_invoke_dependent_async_task(tf::Worker&, tf::Node*) | inline bool Executor::_invoke_dependent_async_task(Worker& worker, Node* node) {
auto& work = std::get_if<Node::DependentAsync>(&node->_handle)->work;
switch(work.index()) {
// void()
case 0:
_observer_prologue(worker, node);
TF_EXECUTOR_EXCEPTION_HANDLER(worker, node, {
std::get_if<0>(&... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x88(%rdx), %r12
movb 0xc0(%rdx), %bpl
xorl %r13d, %r13d
cmpb $0x8, %bpl
cmoveq %r12, %r13
movzbl 0x20(%r13), %eax
cmpl $0x2, %eax
je 0x6e76
cmpl $0x1, %eax
je 0x6e66
testl %eax, %eax
jne 0x6e8c
movq %rdi, ... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Executor::_tear_down_dependent_async(tf::Worker&, tf::Node*, tf::Node*&) | inline void Executor::_tear_down_dependent_async(Worker& worker, Node* node, Node*& cache) {
auto handle = std::get_if<Node::DependentAsync>(&(node->_handle));
// this async task comes from Executor
auto target = ASTATE::UNFINISHED;
while(!handle->state.compare_exchange_weak(target, ASTATE::FINISHED,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
xorl %ebp, %ebp
cmpb $0x8, 0xc0(%rdx)
leaq 0x88(%rdx), %rax
movq %rax, 0x8(%rsp)
cmoveq %rax, %rbp
movl $0x2, %ecx
xorl %eax, %eax
lock
cmpxchgl %ecx, 0x30(%rbp)
jne 0... | /taskflow[P]taskflow/taskflow/core/async.hpp |
tf::Executor::_tear_down_topology(tf::Worker&, tf::Topology*) | inline void Executor::_tear_down_topology(Worker& worker, Topology* tpg) {
auto &f = tpg->_taskflow;
//assert(&tpg == &(f._topologies.front()));
// case 1: we still need to run the topology again
if(!tpg->_exception_ptr && !tpg->cancelled() && !tpg->_pred()) {
//assert(tpg->_join_counter == 0);
std::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r15
cmpq $0x0, 0x70(%rdx)
jne 0x7098
movl 0x68(%r12), %eax
btl $0x1d, %eax
jb 0x7098
cmpq $0x0, 0x30(%r12)
je 0x72e1
leaq 0x20(%r12), %rdi
callq *0x38(%r12)
testb %al, %al
je ... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Executor::_set_up_topology(tf::Worker*, tf::Topology*) | inline void Executor::_set_up_topology(Worker* w, Topology* tpg) {
// ---- under taskflow lock ----
auto& g = tpg->_taskflow._graph;
auto send = _set_up_graph(g.begin(), g.end(), tpg, nullptr);
tpg->_join_counter.store(send - g.begin(), std::memory_order_relaxed);
w ? _schedule(*w, g.begin(), send) : _sc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %r14
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x7606
movq %rax, %rcx
subq 0x50(%r14), %rax
sarq $0x3, %rax
movq %rax, 0x60(%r15)
movq 0... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Topology::_carry_out_promise() | inline void Topology::_carry_out_promise() {
if(_exception_ptr) {
auto e = _exception_ptr;
_exception_ptr = nullptr;
_promise.set_exception(e);
}
else {
_promise.set_value();
}
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
testq %rax, %rax
je 0x75b0
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
callq 0x4050
movq 0x70(%rbx), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x70(%rbx)
testq %rax, %rax
je 0x755c
leaq 0x18(%rsp), %rdi
callq 0x4260
addq $0x8, %rbx
movq 0x10(%rsp), %rax
movq %ra... | /taskflow[P]taskflow/taskflow/core/topology.hpp |
tf::TFProfObserver::Summary::dump_wsum(std::ostream&) const | inline void TFProfObserver::Summary::dump_wsum(std::ostream& os) const {
// task summary
size_t w_w{10}, t_w{10}, l_w{5}, c_w{5}, d_w{9}, avg_w{8}, min_w{8}, max_w{8};
std::for_each(wsum.begin(), wsum.end(), [&](const auto& i){
if(i.count == 0) return;
l_w = (std::max)(l_w, std::to_string(i.level).siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movl $0x5, %eax
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, %rdx
leaq 0x40(%rsp), %r14
movq %rax, (%r14)
leaq 0x58(%rsp), %r12
movq $0x9, (%r12)
movl $0x8, %eax
leaq 0x50(%rsp), %r15
movq %rax, (%r1... | /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::Node* tf::Graph::_emplace_back<int const&, int const&, tf::DefaultTaskParams, std::nullptr_t, std::nullptr_t, int, std::in_place_type_t<tf::Node::Static>, auto tf::make_inclusive_scan_task<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, ... | Node* Graph::_emplace_back(ArgsT&&... args) {
push_back(std::make_unique<Node>(std::forward<ArgsT>(args)...));
return back().get();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x60(%rsp), %rbp
movl $0xd8, %edi
callq 0x42f0
movq %rax, %r14
movl (%r13), %esi
movl (%r12), %edx
movslq (%rbp), %rax
movups 0x68(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
... | /taskflow[P]taskflow/taskflow/core/graph.hpp |
tf::Node::Node<std::in_place_type_t<tf::Node::Static>, auto tf::make_inclusive_scan_task<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, std::m... | Node::Node(
nstate_t nstate,
estate_t estate,
const DefaultTaskParams&,
Topology* topology,
Node* parent,
size_t join_counter,
Args&&... args
) :
_nstate {nstate},
_estate {estate},
_topology {topology},
_parent {parent},
_join_counter {join_counter},
_handle {std... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rsp), %r14
movq 0x20(%rsp), %rax
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
xorl %r15d, %r15d
movq %r15, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %r15, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq %r9, 0x38(%rdi)
movq %r15, 0x40(%rd... | /taskflow[P]taskflow/taskflow/core/graph.hpp |
Catch::restorePreviousSignalHandlers() | static void restorePreviousSignalHandlers() {
// We set signal handlers back to the previous ones. Hopefully
// nobody overwrote them in the meantime, and doesn't expect
// their signal handlers to live past ours given that they
// installed them after ours..
for (std::size_t i =... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x16b962(%rip), %rbx # 0x1972f0
xorl %r14d, %r14d
leaq 0x162498(%rip), %r15 # 0x18de30
movl (%r14,%r15), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21080
addq $0x10, %r14
addq $0x98, %rbx
cmpq $0x60, %r14
jne 0x2b998
leaq 0x16b91a(%rip), %rdi # 0x1972d8
xorl %esi, %esi
p... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::ReporterConfig::fullConfig() const | IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; } | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movq %rcx, (%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x2babd
movq 0x16a4a8(%rip), %rdx # 0x195f58
cmpb $0x0, (%rdx)
je 0x2bab9
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::SectionStats::SectionStats(Catch::SectionInfo const&, Catch::Counts const&, double, bool) | SectionStats::SectionStats( SectionInfo const& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
: sectionInfo( _sectionInfo ),
assertions( _assertions ),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movsd %xmm0, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x162094(%rip), %rax # 0x18dec0
movq %rax, (%rdi)
leaq 0x8(%rdi), %r13
leaq 0x18(%rdi), %rbp
movq %rbp, 0x8(%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rd... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::TestGroupStats::TestGroupStats(Catch::GroupInfo const&, Catch::Totals const&, bool) | TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
Totals const& _totals,
bool _aborting )
: groupInfo( _groupInfo ),
totals( _totals ),
aborting( _aborting )
{} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x161e50(%rip), %rax # 0x18df00
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r12), %rax
movq %rax, 0x8(%r12)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x5080a
movups 0x20(%r1... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::TestGroupStats::TestGroupStats(Catch::GroupInfo const&) | TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
: groupInfo( _groupInfo ),
aborting( false )
{} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x161dd9(%rip), %rax # 0x18df00
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
callq 0x5080a
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x28(%r14)
movl $0x0, 0x38(%r1... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::TestRunStats::TestRunStats(Catch::TestRunInfo const&, Catch::Totals const&, bool) | TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
Totals const& _totals,
bool _aborting )
: runInfo( _runInfo ),
totals( _totals ),
aborting( _aborting )
{} | pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x161d4c(%rip), %rax # 0x18df20
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5080a
movq 0x30(%r14), %rax
movq %rax, 0x58... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::TestRunStats::~TestRunStats() | TestRunStats::~TestRunStats() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x161cd1(%rip), %rax # 0x18df20
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x2c264
callq 0x20ca0
movq %rbx, %rdi
popq %rbx
jmp 0x20ca0
nop
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::listTests(Catch::Config const&) | std::size_t listTests( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
if( config.hasTestFilters() )
Catch::cout() << "Matching test cases:\n";
else {
Catch::cout() << "All available test cases:\n";
}
auto matchedTestCases = filterT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, 0x30(%rsp)
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x169c56(%rip), %rdi # 0x195f60
testb %al, %al
je 0x2c31c
leaq 0xf1c09(%rip), %rsi ... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::filterTests(std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&, Catch::TestSpec const&, Catch::IConfig const&) | std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
std::vector<TestCase> filtered;
filtered.reserve( testCases.size() );
for (auto const& testCase : testCases) {
if ((!testSpec.hasFilters() && !testCase.isHid... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq %rdx, %r15
sarq $0x3, %rax
movabsq $-0x2c8590b21642c859, %rsi # imm = 0xD37A6F4DE9BD37A7
imulq %rax, %rsi
callq... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Matchers::StdString::CasedString::caseSensitivitySuffix[abi:cxx11]() const | std::string CasedString::caseSensitivitySuffix() const {
return m_caseSensitivity == CaseSensitive::No
? " (case insensitive)"
: std::string();
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
cmpl $0x1, (%rsi)
movq %rax, (%rdi)
jne 0x2e69c
leaq 0xefb69(%rip), %rsi # 0x11e1f4
leaq 0xefb75(%rip), %rdx # 0x11e207
movq %rbx, %rdi
callq 0x498d6
jmp 0x2e6a8
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Matchers::StdString::StringMatcherBase::describe[abi:cxx11]() const | std::string StringMatcherBase::describe() const {
std::string description;
description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
m_comparator.caseSensitivitySuffix().size());
description += m_operation;
descriptio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x40(%rsi), %rbp
movq 0x60(%rsi), %r13
cmpl $0x1, 0x30(%rsi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
jne 0x2e7e7... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Matchers::StdString::EqualsMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool EqualsMatcher::match( std::string const& source ) const {
return m_comparator.adjustString( source ) == m_comparator.m_str;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e640
movq 0x8(%r14), %rdx
cmpq 0x40(%rbx), %rdx
jne 0x2e9e8
testq %rdx, %rdx
je 0x2e9ec
movq 0x38(%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0x20dc0
testl %eax, %eax
sete %bl
jmp 0x2e9e... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Matchers::StdString::ContainsMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool ContainsMatcher::match( std::string const& source ) const {
return contains( m_comparator.adjustString( source ), m_comparator.m_str );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e640
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x217d0
movq %rax, %rbx
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2eae9
cal... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Matchers::StdString::StartsWithMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool StartsWithMatcher::match( std::string const& source ) const {
return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e640
movq 0x40(%rbx), %rdx
cmpq %rdx, 0x8(%r14)
jae 0x2ebd8
xorl %ebx, %ebx
jmp 0x2ebf4
testq %rdx, %rdx
je 0x2ebf2
movq 0x38(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x20dc0
testl %e... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Matchers::Matches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
return StdString::RegexMatcher(regex, caseSensitivity);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x5080a
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq $0x0, 0x10(%... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::ScopedMessage::ScopedMessage(Catch::MessageBuilder const&) | ScopedMessage::ScopedMessage( MessageBuilder const& builder )
: m_info( builder.m_info ), m_moved()
{
m_info.message = builder.m_stream.str();
getResultCapture().pushScopedMessage( m_info );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movups 0x18(%rsi), %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
movq 0x28(%rsi), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5080a
movq 0x58(%r15), %rax
mov... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::ScopedMessage::~ScopedMessage() | ScopedMessage::~ScopedMessage() {
if ( !uncaught_exceptions() && !m_moved ){
getResultCapture().popScopedMessage(m_info);
}
} | pushq %rbx
movq %rdi, %rbx
callq 0x200b0
testb %al, %al
jne 0x2f3e6
cmpb $0x0, 0x48(%rbx)
jne 0x2f3e6
callq 0x24136
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x38(%rcx)
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x2f3f9
popq %rbx
jmp 0x20ca0
popq %rbx
retq
movq %rax, %rdi
callq 0x456f9
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Capturer::Capturer(Catch::StringRef, Catch::SourceLineInfo const&, Catch::ResultWas::OfType, Catch::StringRef) | Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
auto trimmed = [&] (size_t start, size_t end) {
while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
++start;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, 0x18(%rsp)
movq %rdi, %r15
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movl %r8d, 0xc(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rdi, 0x10(%rsp)
callq 0x24136
movq %rax, 0x18(%r15)
movq $0x0, 0x2... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::RedirectedStream::RedirectedStream(std::ostream&, std::ostream&) | RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
: m_originalStream( originalStream ),
m_redirectionStream( redirectionStream ),
m_prevBuf( m_originalStream.rdbuf() )
{
m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
} | movq %rsi, %rax
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq (%rsi), %rcx
movq -0x18(%rcx), %rsi
movq 0xe8(%rax,%rsi), %rsi
movq %rsi, 0x10(%rdi)
addq -0x18(%rcx), %rax
movq (%rdx), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rdx,%rcx), %rsi
movq %rax, %rdi
jmp 0x21960
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::RedirectedStdOut::RedirectedStdOut() | RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x34408
movq 0x10(%rbx), %rax
movq 0x1665af(%rip), %rdi # 0x195f60
movq %rdi, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq (%rdi), %rcx
movq -0x18(%rcx), %rdx
movq 0xe8(%rdi,%rdx), %rdx
movq %rdx, 0x28(%rbx)
addq -0x18(%rcx), %rdi
movq (%rax), %rcx
movq -0x18(%rcx), %r... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::XmlReporter::testRunEnded(Catch::TestRunStats const&) | void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
StreamingReporterBase::testRunEnded( testRunStats );
m_xml.scopedElement( "OverallResults" )
.writeAttribute( "successes", testRunStats.totals.assertions.passed )
.writeAttribute( "failures", testRunStats.totals... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x487f2
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xddabb(%rip), %rsi # 0x11ea37
leaq 0xddac2(%rip), %rdx # 0x11ea45
leaq 0x18(%rsp), %rdi
callq 0x498d6
addq $0x170, %rbx #... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::setColour(char const*) | void setColour( const char* _escapeCode ) {
getCurrentContext().getConfig()->stream()
<< '\033' << _escapeCode;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x155e39(%rip) # 0x1972b0
jne 0x414ad
movl $0x30, %edi
callq 0x20d30
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
leaq 0x14c908(%rip), %rcx # 0x18dda0
movq %rcx, (%rax)
leaq 0x14c94e(%rip), %rcx # 0x18ddf0
... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>::setFlag(bool) | auto setFlag( bool flag ) -> ParserResult override {
return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
} | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movl $0x1, 0xc(%rcx)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
leaq 0x14e5e1(%rip), %rdx # 0x190758
movq %rdx, (%rdi)
leaq 0x20(%rdi), %rdx
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
retq
nop
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::getInternal() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x153db6(%rip) # 0x197700
jne 0x43aa5
movl $0x150, %edi # imm = 0x150
callq 0x20d30
movq %rax, %rbx
leaq 0x14c884(%rip), %rax # 0x1901e8
movq %rax, (%rbx)
leaq 0x14c8fa(%rip), %rax # 0x190268
movq %rax, 0x8(%rbx)
leaq 0x14c947(%rip), ... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
non-virtual thunk to Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x14c507(%rip), %rax # 0x1901e8
movq %rax, -0x8(%rdi)
leaq 0x14c57c(%rip), %rax # 0x190268
movq %rax, (%rdi)
leaq 0x14c5ca(%rip), %rax # 0x1902c0
movq %rax, 0x8(%rdi)
leaq 0x14b0cf(%rip), %rax # 0x18edd0
movq %rax, 0x120(%rdi)
addq $0x128, %rdi # imm = 0x128
callq ... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
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.