name string | code string | asm string | file string | addresses string | bin string |
|---|---|---|---|---|---|
mbedtls_asn1_write_ia5_string | int mbedtls_asn1_write_ia5_string( unsigned char **p, unsigned char *start,
const char *text, size_t text_len )
{
int ret;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) text, text_len ) );
MBEDTL... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %cl
cmpq %r12, %rax
setb %al
orb %cl, %al
movl $0xffffff94, %ebx # imm = 0xFFFFFF94
jne 0x272d4
subq %r12, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %r12,... | /project-everest[P]mbedtls/library/asn1write.c | 0x27294 | project-everest[P]mbedtls[P]build_O1[P]tests[P]test_suite_pkparse |
tcu::Matrix<float, 4, 4> tcu::operator-<float, 4, 4>(tcu::Matrix<float, 4, 4> const&, float) | Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) - scalar;
return res;
} | movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x30(%rdi)
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0xae9ae8(%rip), %xmm1 # 0x18f5b4c
movq %rdi, %rdx
xorl %edi, %edi
xorl %r8d, %r8d
movaps %xmm1, %xmm2
cmpq %r8, %rcx
je 0xe0c077
xorps %xmm2, %xmm2
movss %xmm2, (%rd... | /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp | 0xe0c045 | kaydenl[P]VK-GL-CTS[P]build_O3[P]external[P]openglcts[P]modules[P]cts-runner |
pagerPagecount | static int pagerPagecount(Pager *pPager, Pgno *pnPage){
Pgno nPage; /* Value to return via *pnPage */
/* Query the WAL sub-system for the database size. The WalDbsize()
** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
** if the database size is not available. The dat... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movq 0x128(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x3f355
cmpw $0x0, 0x3c(%rcx)
js 0x3f355
movl 0x5c(%rcx), %eax
testl %eax, %eax
je 0x3f387
cmpl 0xbc(%r14), %eax
jbe 0x3f369
movl %eax, 0xbc(%r14)
m... | /qt[P]qtbase/src/3rdparty/sqlite/sqlite3.c | 0x3f322 | qt[P]qtbase[P]build_O1[P]plugins[P]sqldrivers[P]libqsqlite.so |
testing::internal::RE::Init(char const*) | void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex);
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", rege... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x9c30
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x9230
leaq 0xa(%rax), %r12
movq %r12, %rdi
callq 0x9040
movq %rax, %r14
leaq 0x133a4(%rip), %rdx # 0x4c5cf
movq %rax, %rdi
movq %r1... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-port.cc | 0x391ec | walterzhaoJR[P]leveldb[P]build_O2[P]issue320_test |
cmFindPackageCommand::AppendSearchPathGroups() | void cmFindPackageCommand::AppendSearchPathGroups()
{
std::vector<cmFindCommon::PathLabel>* labels;
// Update the All group with new paths
labels = &this->PathGroupLabelMap[PathGroup::All];
labels->insert(std::find(labels->begin(), labels->end(),
PathLabel::CMakeSystem),
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
addq $0xc8, %rdi
leaq 0x2f7f7a(%rip), %rsi # 0x4d4000
callq 0x1e95f4
movq %rax, %r15
movq (%rax), %rdi
movq 0x8(%rax), %rsi
leaq 0x2f7eec(%rip), %r12 # 0x4d3f88
movq %r12, %rdx
callq 0x1f06c1
leaq 0x2f7f7d(%rip), %r14 # 0x4... | /fjeremic[P]CMake/Source/cmFindPackageCommand.cxx | 0x1dc068 | fjeremic[P]CMake[P]build_O3[P]bin[P]cmake |
hwnet::TCPSocket::sendContext::sendContext(std::shared_ptr<hwnet::Buffer> const&, unsigned long) | sendContext(const Buffer::Ptr &buff,size_t len = 0):buff(buff),ptr(buff->BuffPtr()),next(nullptr){
if(len > 0) {
this->len = len;
} else {
this->len = buff->Len();
}
} | pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x16f6a
movq 0xd05c(%rip), %rcx # 0x23fb8
cmpb $0x0, (%rcx)
je 0x16f66
incl 0x8(%rax)
jmp 0x16f6a
lock
incl 0x8(%rax)
movq (%rsi), %rax
movq (%rax), %rcx
movq (%rcx), %rcx
addq 0x10(%rax), %... | /sniperHW[P]hwnet/src/net/TCPSocket.h | 0x16f3e | sniperHW[P]hwnet[P]build_O1[P]bin[P]benmark2 |
testing::internal::StreamingListener::SocketWriter::CloseConnection() | void CloseConnection() override {
GTEST_CHECK_(sockfd_ != -1)
<< "CloseConnection() can be called only when there is a connection.";
close(sockfd_);
sockfd_ = -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0xc110
testb $0x1, %al
jne 0x4638c
jmp 0x4638e
jmp 0x463fe
leaq 0x186ec(%rip), %rdx # 0x5ea81
leaq -0xc(%rbp), %rdi
movq %rdi, -0x38(%... | /metacall[P]core/build_O0/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h | 0x46360 | metacall[P]core[P]build_O0[P]metacall-initialize-test |
llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>::iterator::setNodeStop(unsigned int, unsigned int) | void IntervalMap<KeyT, ValT, N, Traits>::
iterator::setNodeStop(unsigned Level, KeyT Stop) {
// There are no references to the root node, so nothing to update.
if (!Level)
return;
IntervalMapImpl::Path &P = this->path;
// Update nodes pointing to the current node.
while (--Level) {
P.node<Branch>(Leve... | testl %esi, %esi
je 0x722831
movq 0x8(%rdi), %rax
movl %esi, %ecx
shlq $0x4, %rcx
movq %rcx, %rsi
addq $-0x10, %rsi
je 0x722832
movq -0x10(%rax,%rcx), %r8
movl -0x4(%rax,%rcx), %r9d
movl %edx, 0x80(%r8,%r9,4)
movl -0x8(%rax,%rcx), %r8d
decl %r8d
cmpl %r8d, -0x4(%rax,%rcx)
movq %rsi, %rcx
je 0x722807
retq
movq 0x8(%rdi)... | /llvm/ADT/IntervalMap.h | 0x7227f6 | llvm-project[P]build_O2[P]bin[P]lli |
maxn | static int maxn (lua_State *L) {
lua_Number max = 0;
luaL_checktype(L, 1, LUA_TTABLE);
lua_pushnil(L); /* first key */
while (lua_next(L, 1)) {
lua_pop(L, 1); /* remove value */
if (lua_type(L, -1) == LUA_TNUMBER) {
lua_Number v = lua_tonumber(L, -1);
if (v > max) max = v;
}
}
lua_... | pushq %rbx
subq $0x10, %rsp
movl $0x1, %esi
movl $0x5, %edx
movq %rdi, %rbx
callq 0xd38a
movq %rbx, %rdi
callq 0x108c9
movl $0x1, %esi
movq %rbx, %rdi
callq 0x14be9
vxorpd %xmm0, %xmm0, %xmm0
testl %eax, %eax
je 0x3ea92
vmovsd %xmm0, 0x8(%rsp)
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movq %rbx, %rdi
callq 0xf2bf... | /dibyendumajumdar[P]ravi/src/ltablib.c | 0x3ea07 | dibyendumajumdar[P]ravi[P]build_O3[P]ravidebug |
write_setting_fontspec | void write_setting_fontspec(settings_w *handle, const char *name, FontSpec *fs)
{
/*
* read_setting_fontspec had to handle two cases, but when
* writing our settings back out we simply always generate the
* new-style name.
*/
char *suffname = dupcat(name, "Name");
write_setting_s(handle,... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x2f7f2(%rip), %rsi # 0x716cd
movq %rax, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x6a358
movq %rax, %r15
movq (%rbx), %rcx
movq (%r14), %rdi
leaq 0x3b641(%rip), %rsi # 0x7d538
movq %rax, %rdx
xorl %eax, %eax
callq 0xe740
mo... | /codexns[P]putty/unix/storage.c | 0x41ec6 | codexns[P]putty[P]build_O1[P]pscp |
bassign | int bassign (bstring a, const bstring b) {
if (b == NULL || b->data == NULL || b->slen < 0 )
return BSTR_ERR;
if (b->slen != 0) {
if (balloc (a, b->slen) != BSTR_OK) return BSTR_ERR;
bstr__memmove (a->data, b->data, b->slen);
} else {
if (a == NULL || a->data == NULL || a->mlen < a->slen ||
a... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c50c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1c50c
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x1c518
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c5ca
movq -0x18(%rbp), %rax
cm... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c | 0x1c4e0 | X-Ryl669[P]eMQTT5[P]build_O0[P]tests[P]SerializationTests |
RSAParameters::deserialise(ByteString&) | bool RSAParameters::deserialise(ByteString& serialised)
{
ByteString dE = ByteString::chainDeserialise(serialised);
ByteString dLen = ByteString::chainDeserialise(serialised);
if ((dE.size() == 0) ||
(dLen.size() == 0))
{
return false;
}
setE(dE);
setBitLength(dLen.long_val());
return tr... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x27c28
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x27c28
leaq 0x30(%rsp), %rdi
callq 0x2765c
testq %rax, %rax
je 0x30230
leaq 0x8(%rsp), %rdi
callq 0x2765c
testq %rax, %rax
je 0x30230
leaq 0x8(%rbx), %rdi
leaq 0x30(%rsp... | /opendnssec[P]SoftHSMv2/src/lib/crypto/RSAParameters.cpp | 0x301ce | opendnssec[P]SoftHSMv2[P]build_O3[P]src[P]bin[P]util[P]softhsm2-util |
SafeInt<short, safeint_exception_handlers::SafeIntExceptionHandler<SafeIntException>> operator/<short, unsigned short, safeint_exception_handlers::SafeIntExceptionHandler<SafeIntException>>(unsigned short, SafeInt<short, safeint_exception_handlers::SafeIntExceptionHandler<SafeIntException>>) | SAFEINT_CONSTEXPR14 SafeInt< T, E > operator /( U lhs, SafeInt< T, E > rhs ) SAFEINT_CPP_THROW
{
// Corner case - has to be handled seperately
SafeInt< T, E > result;
if( DivisionCornerCaseHelper< T, U, E, (int)DivisionMethod< U, T >::method == (int)DivisionState_UnsignedSigned >::DivisionCornerCase1( lhs, ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movw %di, 0x6(%rsp)
leaq 0xc(%rsp), %r14
andw $0x0, (%r14)
movq %r14, %rdx
callq 0x25c3a
testb %al, %al
jne 0x258c9
leaq 0xa(%rsp), %r15
andw $0x0, (%r15)
leaq 0x8(%rsp), %rsi
movw %bx, (%rsi)
leaq 0x6(%rsp), %rdi
movq %r15, %rdx
callq 0x1e394
leaq 0xe(%... | /dcleblanc[P]SafeInt/Test/../SafeInt.hpp | 0x25874 | dcleblanc[P]SafeInt[P]build_O2[P]Test[P]ClangTest[P]CompileTest_clang |
asl::encodeHex(unsigned char const*, int) | String encodeHex(const byte* data, int n)
{
String h(2*n, 2*n);
for (int i = 0; i < n; i++)
snprintf(&h[2*i], 3, "%02x", data[i]);
return h;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %r13
leaq (,%r13,2), %r15
movl %r15d, %esi
callq 0x59b8
movl %r15d, 0x4(%rbx)
leaq 0x8(%rbx), %r12
cmpl $0x0, (%rbx)
movq %r12, %rax
je 0xbf43
movq 0x8(%rbx), %rax
movb $0x0, (%rax,%... | /aslze[P]asl/src/util.cpp | 0xbf09 | aslze[P]asl-calculator[P]build_O3[P]calcdemo |
Catch::StringMaker<char*, void>::convert[abi:cxx11](char*) | std::string StringMaker<char*>::convert(char* str) {
if (str) {
return ::Catch::Detail::stringify(std::string{ str });
} else {
return{ "{null string}" };
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x21ef4
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x2c49e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21cf2
leaq 0x8(%rsp), %rdi
callq 0x12c18
jmp 0x21f08
leaq 0x59a1b(%rip), %rsi # 0x7b916
leaq 0x8(%rsp), %rdx
movq %rbx, %... | /adamfowleruk[P]groundupdb/groundupdb-tests/catch.hpp | 0x21ebc | adamfowleruk[P]groundupdb[P]build_O2[P]groundupdb-tests[P]groundupdb-tests |
ptls_base64_cell | static void ptls_base64_cell(const uint8_t *data, char *text)
{
int n[4];
n[0] = data[0] >> 2;
n[1] = ((data[0] & 3) << 4) | (data[1] >> 4);
n[2] = ((data[1] & 15) << 2) | (data[2] >> 6);
n[3] = data[2] & 63;
for (int i = 0; i < 4; i++) {
text[i] = ptls_base64_alphabet[n[i]];
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
sarl $0x2, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x3, %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movl %eax, -0x1c(... | /rperper[P]picotls/lib/pembase64.c | 0x35ed0 | rperper[P]picotls[P]build_O0[P]test-minicrypto.t |
ParseInt64_Underscores_Test::~ParseInt64_Underscores_Test() | TEST(ParseInt64, Underscores) {
AssertInt64Equals(123456789, "12_345_6789", Both);
AssertInt64Equals(123456789, "+12_345_6789", SignedAndUnsigned);
AssertInt64Equals(-123456789, "-12345_6789", SignedAndUnsigned);
AssertInt64Equals(19, "1______9", Both);
AssertInt64Equals(0xabcd, "0xa_b_c_d", Both);
AssertIn... | pushq %rbx
movq %rdi, %rbx
callq 0x53582
pushq $0x10
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x2c110
nop
| /wapm-packages[P]wabt/src/test-literal.cc | 0x4951a | wapm-packages[P]wabt[P]build_O2[P]wabt-unittests |
miniros::NodeHandle::getParamCached(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, XmlRpc::XmlRpcValue&) const | bool NodeHandle::getParamCached(const std::string& key, XmlRpc::XmlRpcValue& v) const
{
return getMasterLink()->getCached(resolveName(key), v);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xfdf30
movq (%r14), %r14
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r12, %rsi
movq %r15, %rdx
callq 0x106340
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rd... | /dkargin[P]miniroscpp/src/transport/node_handle.cpp | 0x137a8a | dkargin[P]miniroscpp[P]build_O2[P]lib[P]libroscxx.so |
(anonymous namespace)::HandleVariableMode(cmExecutionStatus&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, (anonymous namespace)::OutType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<ch... | bool HandleVariableMode(cmExecutionStatus& status, const std::string& name,
OutType infoType, const std::string& variable,
const std::string& propertyName)
{
if (!name.empty()) {
status.SetError("given name for VARIABLE scope.");
return false;
}
return Stor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x148eff
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x56ed4e(%rip), %rsi # 0x6b7c14
leaq 0x56ed65(%rip), %rdx # 0x6b7c32
movq %rsp, %r15
movq %r15, %rdi
callq 0x8a3ec
addq $0x8, %r14
... | /JeremieA[P]CMake/Source/cmGetPropertyCommand.cxx | 0x148e9e | JeremieA[P]CMake[P]build_O3[P]bin[P]ccmake |
prometheus::Summary::Observe(double) | void Summary::Observe(const double value) {
std::lock_guard<std::mutex> lock(mutex_);
count_ += 1;
sum_ += value;
quantile_values_.insert(value);
} | pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x7860
testl %eax, %eax
jne 0x28632
incq 0x40(%r14)
movsd 0x48(%r14), %xmm1
movsd (%rsp), %xmm0
addsd %xmm0, %xmm1
movsd %xmm1, 0x48(%r14)
addq $0x50, %r14
movq %r14, %rdi
callq 0x2a224
movq %rbx, %rdi
addq ... | /jupp0r[P]prometheus-cpp/core/src/summary.cc | 0x285e2 | jupp0r[P]prometheus-cpp[P]build_O1[P]bin[P]sample_server_multi |
icu_63::UnifiedCache::removeHardRef(icu_63::SharedObject const*) const | int32_t UnifiedCache::removeHardRef(const SharedObject *value) const {
int refCount = 0;
if (value) {
refCount = umtx_atomic_dec(&value->hardRefCount);
U_ASSERT(refCount >= 0);
if (refCount == 0) {
--fNumValuesInUse;
}
}
return refCount;
} | xorl %eax, %eax
testq %rsi, %rsi
je 0x1bb4a5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rsi)
decl %eax
je 0x1bb4a6
retq
decl 0x18(%rdi)
xorl %eax, %eax
retq
| /hunter-packages[P]icu/source/common/unifiedcache.cpp | 0x1bb490 | hunter-packages[P]icu[P]build_O1[P]source[P]tools[P]genccode[P]genccode |
isl_pw_aff_gist_fn | static __isl_give PW *FN(PW,gist_fn)(__isl_take PW *pw,
__isl_take isl_set *context,
__isl_give isl_set *(*fn_dom)(__isl_take isl_set *set,
__isl_take isl_basic_set *bset),
__isl_give isl_set *intersect_context(__isl_take isl_set *set,
__isl_take isl_set *context))
{
int i;
int is_universe;
isl_basic_se... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rsi, 0x18(%rsp)
callq 0x20fad10
movq %rax, %r14
movq %rax, 0x20(%rsp)
testq %rax, %rax
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x20fac38
cmpl $0x0, 0x10(%r14)
je 0x20faa85... | /External/isl/isl_pw_templ.c | 0x20faa2f | llvm-project[P]build_O2[P]bin[P]clang-linker-wrapper |
fS | static int fS(int Ns, sunrealtype t, N_Vector y, N_Vector ydot, int iS,
N_Vector yS, N_Vector ySdot, void* user_data, N_Vector tmp1,
N_Vector tmp2)
{
UserData data;
sunrealtype p1, p2, p3;
sunrealtype y1, y2, y3;
sunrealtype s1, s2, s3;
sunrealtype sd1, sd2, sd3;
data = (UserDat... | movq 0x8(%rsp), %rax
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm0
movq (%rsi), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm3
movsd 0x10(%rax), %xmm4
movq (%r8), %rdx
movq 0x10(%rdx), %rdx
movsd 0x8(%rdx), %xmm5
movapd %xmm1, %xmm6
mulsd %xmm4, %xmm6
mulsd %xmm5, %xmm6
mulsd (%rdx), %xmm2
subsd... | /opencor[P]sundials/examples/cvodes/serial/cvsRoberts_FSA_dns.c | 0x2dd3 | LLNL[P]sundials[P]build_O1[P]examples[P]cvodes[P]serial[P]cvsRoberts_FSA_dns |
testing::internal::UnitTestImpl::ShuffleTests() | void UnitTestImpl::ShuffleTests() {
// Shuffles the death test suites.
ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
// Shuffles the non-death test suites.
ShuffleRange(random(), last_death_test_suite_ + 1,
static_cast<int>(test_suites_.size()), &test_suite_indices... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x426c0
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movl 0x164(%rcx), %edx
addl $0x1, %edx
addq $0xd0, %rcx
xorl %esi, %esi
callq 0x42da0
movq -0x30(%rbp), %rdi
callq 0x426c0
movq -0x30(%rbp), %rdi
movq %rax,... | /metacall[P]core/build_O0/source/tests/src/google-test-depends/googletest/src/gtest.cc | 0x2ead0 | metacall[P]core[P]build_O0[P]log-test |
ARMCC_ARMCondCodeToString | inline static char *ARMCC_ARMCondCodeToString(ARMCC_CondCodes CC)
{
switch (CC) {
case ARMCC_EQ: return "eq";
case ARMCC_NE: return "ne";
case ARMCC_HS: return "hs";
case ARMCC_LO: return "lo";
case ARMCC_MI: return "mi";
case ARMCC_PL: return "pl";
case ARMCC_VS: return "vs";
case ARMCC_VC: re... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xe, %rax
ja 0x91fc1
movq -0x18(%rbp), %rax
leaq 0xb312d(%rip), %rcx # 0x145010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xcdcde(%rip), %rax # 0x15fbd1
movq %rax, -0x8(%rbp)
jmp 0x91fcc
leaq 0xc... | /radare[P]capstone/arch/ARM/ARMBaseInfo.h | 0x91ec0 | radare[P]capstone[P]build_O0[P]test |
mkvparser::ContentEncoding::ParseCompressionEntry(long long, long long, mkvparser::IMkvReader*, mkvparser::ContentEncoding::ContentCompression*) | long ContentEncoding::ParseCompressionEntry(long long start, long long size,
IMkvReader* pReader,
ContentCompression* compression) {
assert(pReader);
assert(compression);
long long pos = start;
const long long stop = start ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r15
leaq 0x8(%rsp), %r12
movq %rsi, (%r12)
addq %rsi, %r15
movq $0x0, 0x20(%rsp)
leaq 0x18(%rsp), %r13
cmpq %r15, 0x8(%rsp)
jge 0x615d7
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13,... | /m-ab-s[P]aom/third_party/libwebm/mkvparser/mkvparser.cc | 0x61450 | m-ab-s[P]aom[P]build_O1[P]examples[P]photon_noise_table |
print_latex_map_body | static isl_stat print_latex_map_body(__isl_take isl_map *map, void *user)
{
struct isl_union_print_data *data;
data = (struct isl_union_print_data *)user;
if (!data->first)
data->p = isl_printer_print_str(data->p, " \\cup ");
data->first = 0;
data->p = isl_map_print_latex(map, data->p);
isl_map_free(map);
r... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rsi)
jne 0x4873cb
movq (%r14), %rdi
leaq 0x1022fd9(%rip), %rsi # 0x14aa39c
callq 0x48fbf5
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x4838e5
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x4613d0
xorl %eax,... | /External/isl/isl_output.c | 0x4873a9 | llvm-project[P]build_O1[P]bin[P]lldb-server |
attlist1 | static int PTRCALL
attlist1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
const ENCODING *enc) {
UNUSED_P(ptr);
UNUSED_P(end);
UNUSED_P(enc);
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_ATTLIST_NONE;
case XML_TOK_DECL_CLOSE:
setTopLevel(state);
return XML_ROL... | cmpl $0x11, %esi
jg 0x75a65
cmpl $0xf, %esi
je 0x75a9e
cmpl $0x11, %esi
jne 0x75a7b
cmpl $0x0, 0x14(%rdi)
leaq -0x2c0(%rip), %rax # 0x75793
leaq -0x91b(%rip), %rcx # 0x7513f
cmoveq %rax, %rcx
movl $0x21, %edx
jmp 0x75a98
movl $0x16, %edx
leaq 0x33(%rip), %rcx # 0x75aa4
cmpl $0x12, %esi
je 0x75a98
cmpl ... | /stcorp[P]coda/libcoda/expat/xmlrole.c | 0x75a39 | stcorp[P]coda[P]build_O3[P]libcoda.so.16.0.10 |
mbedtls_ripemd160_update_ret | int mbedtls_ripemd160_update_ret( mbedtls_ripemd160_context *ctx,
const unsigned char *input,
size_t ilen )
{
int ret;
size_t fill;
uint32_t left;
if( ilen == 0 )
return( 0 );
left = ctx->total[0] & 0x3F;
fill = 64 - l... | testq %rdx, %rdx
je 0x206af
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %edx, %esi
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x2061e
incl 0x4(%r14)
xorl %ebp, %ebp
testl %eax, %eax
je 0x2063c
movl $0x40,... | /project-everest[P]mbedtls/library/ripemd160.c | 0x205f1 | project-everest[P]mbedtls[P]build_O1[P]tests[P]test_suite_x509parse |
testing::internal::ParseInt32Flag(char const*, char const*, int*) | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == NULL) return false;
// Sets *value to the value of the flag.
return ParseInt32... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x1a3d7
testq %rax, %rax
je 0x1a3a5
movq %rax, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xb28c
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x1ada4(%rip), %rsi # 0x350... | /chunmeng[P]cmake-project-base/build_O1/googletest-src/googletest/src/gtest.cc | 0x1a30e | chunmeng[P]cmake-project-base[P]build_O1[P]test[P]Test |
void evaluations_test<viennamath::ct_binary_expr<viennamath::ct_binary_expr<viennamath::ct_variable<2ul>, viennamath::op_mult<double>, viennamath::ct_variable<1ul>>, viennamath::op_plus<double>, viennamath::ct_constant<5l>>>(viennamath::ct_binary_expr<viennamath::ct_binary_expr<viennamath::ct_variable<2ul>, viennamath:... | void evaluations_test(E const & e, double ref_solution)
{
viennamath::ct_constant<4> ct4;
viennamath::ct_constant<6> ct6;
viennamath::ct_constant<8> ct8;
std::cout << e << " at compile-time (4,6,8): ";
evaluation_compiletime<viennamath::result_of::is_ct_evaluable<E>::value,
E
... | pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq 0x3f6d6(%rip), %rdi # 0x8bfd8
movq %rbx, %rsi
callq 0x4cd7a
leaq 0x2de05(%rip), %rsi # 0x7a716
movl $0x1a, %edx
movq %rax, %rdi
callq 0x3e100
leaq 0x5(%rsp), %rsi
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4ce30
addq $0x10, %rsp
popq %r... | /viennamath[P]viennamath-dev/tests/src/compiletime_evaluation.cpp | 0x4c8ed | viennamath[P]viennamath-dev[P]build_O1[P]tests[P]compiletime_evaluation-test |
testing::internal::FormatDeathTestOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static ::std::string FormatDeathTestOutput(const ::std::string& output) {
::std::string ret;
for (size_t at = 0;;) {
const size_t line_end = output.find('\n', at);
ret += "[ DEATH ] ";
if (line_end == ::std::string::npos) {
ret += output.substr(at);
break;
}
ret += output.substr(a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r15d, %r15d
movq %rsp, %r12
movq %r14, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0x267b0
movq... | /oprecomp[P]flexfloat/build_O1/test/googletest-src/googletest/src/gtest-death-test.cc | 0x2d813 | oprecomp[P]flexfloat[P]build_O1[P]test[P]conversion |
TimeFunctionParallel(TimeResults*, std::function<bool ()>) | static bool TimeFunctionParallel(TimeResults *results,
std::function<bool()> func) {
if (g_threads <= 1) {
return TimeFunction(results, std::move(func));
}
uint32_t iterations_between_time_checks = IterationsBetweenTimeChecks(func);
if (iterations_between_time_checks == 0) ... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rsi, -0x180(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x1, 0x2df29f(%rip) # 0x31e570
jg 0x3f343
movq -0x180(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x198(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x4fb... | /jedisct1[P]boringssl/tool/speed.cc | 0x3f2b0 | jedisct1[P]boringssl[P]build_O0[P]bssl |
c4::yml::Tree::merge_with(c4::yml::Tree const*, unsigned long, unsigned long) | void Tree::merge_with(Tree const *src, size_t src_node, size_t dst_node)
{
_RYML_CB_ASSERT(m_callbacks, src != nullptr);
if(src_node == NONE)
src_node = src->root_id();
if(dst_node == NONE)
dst_node = root_id();
_RYML_CB_ASSERT(m_callbacks, src->has_val(src_node) || src->is_seq(src_node)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jne 0x10d3a6
movups 0x54190(%rip), %xmm0 # 0x16149f
movups %xmm0, 0x3f(%rsp)
movaps 0x54175(%rip), %xmm0 # 0x161490
movaps %xmm0, 0x30(%rsp)
testb $0x... | /google[P]jsonnet/third_party/rapidyaml/ryml_all.hpp | 0x10d2e2 | google[P]jsonnet[P]build_O3[P]libjsonnet++_test |
cmTarget::GetInterfaceFileSetsPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmTarget::GetInterfaceFileSetsPropertyName(const std::string& type)
{
if (type == "HEADERS") {
return "INTERFACE_HEADER_SETS";
}
if (type == "CXX_MODULES") {
return "INTERFACE_CXX_MODULE_SETS";
}
if (type == "CXX_MODULE_HEADER_UNITS") {
return "INTERFACE_CXX_MODULE_HEADER_UNIT_SETS";
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb5848f(%rip), %rsi # 0xd1a935
callq 0x8ace0
testb $0x1, %al
jne 0x1c24b1
jmp 0x1c24fc
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
call... | /JKorbelRA[P]CMake/Source/cmTarget.cxx | 0x1c2480 | JKorbelRA[P]CMake[P]build_O0[P]Tests[P]CMakeLib[P]CMakeLibTests |
feat_compute_utt | static void
feat_compute_utt(feat_t *fcb, mfcc_t **mfc, int32 nfr, int32 win, mfcc_t ***feat)
{
int32 i;
cep_dump_dbg(fcb, mfc, nfr, "Incoming features (after padding)");
/* Create feature vectors */
for (i = win; i < nfr - win; i++) {
fcb->compute_feat(fcb, mfc + i, feat[i - win]);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdi, %r15
movl %edx, 0xc(%rsp)
movl %edx, %eax
subl %ecx, %eax
movq %rcx, 0x10(%rsp)
movslq %ecx, %r13
movslq %eax, %rbp
leaq (%rsi,%r13,8), %r12
xorl %r14d, %r14d
leaq (%r14,%r13), %rax
cmpq %rbp, %rax
jge 0x13fac
m... | /cmusphinx[P]sphinxtrain/src/libs/libsphinxbase/feat/feat.c | 0x13f5e | cmusphinx[P]sphinxtrain[P]build_O2[P]init_gau |
embree::BVHN<4>::prefetch(embree::NodeRefPtr<4>, int) | __forceinline static void prefetch(const NodeRef ref, int types=0)
{
#if defined(__AVX512PF__) // MIC
if (types != BVH_FLAG_QUANTIZED_NODE) {
prefetchL2(((char*)ref.ptr)+0*64);
prefetchL2(((char*)ref.ptr)+1*64);
if ((N >= 8) || (types > BVH_FLAG_ALIGNED_NODE)) {
prefetchL2(((... | movq %rdi, -0x40(%rsp)
movl %esi, -0x44(%rsp)
cmpl $0x100000, -0x44(%rsp) # imm = 0x100000
je 0x372f5f4
movq -0x40(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
prefetcht0 (%rax)
movq -0x40(%rsp), %rax
addq $0x40, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
prefetcht0 (%rax)
cmpl $0x1, -0x44(%rsp)
jle... | /embree[P]embree/kernels/bvh/bvh.h | 0x372f580 | embree[P]embree[P]build_O0[P]libembree4.so.4 |
SQFuncState::CreateTable() | SQObject SQFuncState::CreateTable()
{
SQObjectPtr nt(SQTable::Create(_sharedstate,0));
_table(_strings)->NewSlot(nt,(SQInteger)1);
return nt;
} | subq $0x68, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1d8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10710
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x10760
movq 0x8(%rsp), %rax
movq 0x108(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x105b0... | /KatuH[P]squall/build_O0/_deps/squirrel-src/squirrel/sqfuncstate.cpp | 0x1f890 | KatuH[P]squall[P]build_O0[P]samples[P]coroutine |
QPDF_Integer* qpdf::BaseHandle::as<QPDF_Integer>() const | T*
BaseHandle::as() const
{
if (!obj) {
return nullptr;
}
if (std::holds_alternative<T>(obj->value)) {
return &std::get<T>(obj->value);
}
if (std::holds_alternative<QPDF_Unresolved>(obj->value)) {
return BaseHandle(QPDF::Resolver::resol... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x43960
testb $0x1, %al
jne 0x1cbf8d
movq $0x0, -0x8(%rbp)
jmp 0x1cc0cc
movq -0x50(%rbp), %rdi
callq 0x65f70
movq %rax, %rdi
callq 0x1d7070
testb $0x1, %al
jne 0x1cbfa4
jmp 0x1cbfbe
movq -0x50(%rbp), %... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh | 0x1cbf60 | qpdf[P]qpdf[P]build_O0[P]fuzz[P]pngpredictor_fuzzer |
void Catch::Capturer::captureValues<char [4], double>(unsigned long, char const (&) [4], double const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x4, %r13d
movl $0x4, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp | 0x9a2a4 | embeddedartistry[P]printf[P]build_O3[P]test[P]test_suite |
append_entry_w | static void
append_entry_w(wchar_t **wp, const wchar_t *prefix, int type,
int tag, int flags, const wchar_t *wname, int perm, int id)
{
int i;
if (prefix != NULL) {
wcscpy(*wp, prefix);
*wp += wcslen(*wp);
}
switch (tag) {
case ARCHIVE_ENTRY_ACL_USER_OBJ:
wname = NULL;
id = -1;
if ((type & ARCHIVE_E... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, 0x4(%rsp)
movq %rdi, %rbx
movl 0x48(%rsp), %eax
movl %eax, (%rsp)
movl 0x40(%rsp), %r14d
testq %rsi, %rsi
je 0x2ff8ea
movq (%rbx), %rdi
callq 0x311f0
movq (%rbx), %rbp
movq %rbp, %rdi... | /micst[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c | 0x2ff89d | micst[P]CMake[P]build_O1[P]Tests[P]CMakeLib[P]CMakeLibTests |
fmt::v9::appender fmt::v9::detail::write_codepoint<8ul, char, fmt::v9::appender>(fmt::v9::appender, char, unsigned int) | auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
*out++ = static_cast<Char>('\\');
*out++ = static_cast<Char>(prefix);
Char buf[width];
fill_n(buf, width, static_cast<Char>('0'));
format_uint<4>(buf, cp, width);
return copy_str<Char>(buf, buf + width, out);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
incq %rsi
cmpq %rsi, 0x18(%rdi)
jae 0x200b1
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x5c, (%rax,%rc... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | 0x2008c | njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]26[P]EnergyTransfer[P]test[P]ENDFtk.section.26.EnergyTransfer.test |
core::image::save_tiff_file(std::shared_ptr<core::Image<unsigned char> const>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
save_tiff_file (ByteImage::ConstPtr image, std::string const& filename)
{
if (image == nullptr)
throw std::invalid_argument("Null image given");
TIFF* tif = TIFFOpen(filename.c_str(), "w");
if (!tif)
throw util::FileException(filename, "Unknown TIFF file error");
uint32_t width = ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, (%rdi)
je 0xf1f7
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0xf534(%rip), %rsi # 0x1e643
callq 0x6160
testq %rax, %rax
je 0xf229
movq %rax, %rbx
movq (%r14), %rax
movl 0x8(%rax), %edx
movl 0xc(... | /TouchDeeper[P]imageBasedModeling_l2/core/image_io.cc | 0xf0e4 | TouchDeeper[P]imageBasedModeling_l2[P]build_O3[P]examples[P]task1[P]task1_test_matching |
get_floor_type | int get_floor_type(char c)
{
int val;
val = what_map_char(c);
if (val == INVALID_TYPE) {
val = ERR;
lc_warning("Invalid fill character '%c' in MAZE declaration", c);
}
return val;
} | pushq %rbx
movl %edi, %ebx
callq 0xd1ca
cmpb $0x7f, %al
je 0xd1b2
movzbl %al, %eax
popq %rbx
retq
movsbl %bl, %esi
leaq 0x930d(%rip), %rdi # 0x164c9
xorl %eax, %eax
callq 0xc3d4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0xd1b0
| /DynaMoHack[P]DynaMoHack/libdynamohack/util/lev_main.c | 0xd1a1 | DynaMoHack[P]DynaMoHack[P]build_O1[P]libdynamohack[P]util[P]lev_comp |
detach_set_error | int detach_set_error(DETACH_HANDLE detach, ERROR_HANDLE error_value)
{
int result;
if (detach == NULL)
{
result = MU_FAILURE;
}
else
{
DETACH_INSTANCE* detach_instance = (DETACH_INSTANCE*)detach;
AMQP_VALUE error_amqp_value = amqpvalue_create_error(error_value);
... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x41644
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4164b
movq (%rsi), %rdi
callq 0x4915b
movq %rax, %r14
jmp 0x4164e
movl $0x2566, %ebx # imm = 0x2566
jmp 0x4167c
xorl %r14d, %r14d
testq %r14, %r14
je 0x41677
movq (%rbx), %rdi
movl $0x2, %esi
movq %r14, %rdx
cal... | /Azure[P]azure-iot-c-back-compat/deps/azure-iot-sdk-c/uamqp/src/amqp_definitions.c | 0x41626 | Azure[P]azure-iot-c-back-compat[P]build_O1[P]tests[P]iothub_mqtt_back_compat[P]iothub_mqtt_back_compat_exe |
DSP_showdisplay | void DSP_showdisplay(LispPTR *args)
{
LispPTR base = args[0]; /* pointer to the display bitmap */
LispPTR rasterwidth = args[1]; /* should be a smallp */
if (base == NIL) {
DisplayInitialized = 0;
} else {
DisplayInitialized = 1;
}
} | xorl %eax, %eax
cmpl $0x0, (%rdi)
setne %al
leaq 0x34280(%rip), %rcx # 0x54910
movl %eax, (%rcx)
retq
| /Interlisp[P]maiko/src/dspsubrs.c | 0x20681 | Interlisp[P]maiko[P]build_O3[P]ldeinit |
uv__run_closing_handles | static void uv__run_closing_handles(uv_loop_t* loop) {
uv_handle_t* p;
uv_handle_t* q;
p = loop->closing_handles;
loop->closing_handles = NULL;
while (p) {
q = p->next_closing;
uv__finish_close(p);
p = q;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x168(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xcf7780
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf9940
... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/core.c | 0xcf7730 | JeremieA[P]CMake[P]build_O0[P]bin[P]ccmake |
ncnn::GroupNorm_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int GroupNorm_x86_fma::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
const int dims = bottom_top_blob.dims;
const int channels_per_group = channels / group;
if (dims == 1)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int g = 0; g < group; g++)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, -0x30(%rsp)
movl 0x28(%rsi), %esi
movl 0xd0(%rdi), %ebx
movl 0xd4(%rdi), %eax
cltd
idivl %ebx
movl %eax, %ecx
cltq
movq %rax, -0x28(%rsp)
cmpl $0x2, %esi
movq %rdi, -0x20(%rsp)
je 0x3adc18
cmpl $0x1, %esi
jne 0x3adf4c
vcvtsi2ss %ecx, %xmm0, %x... | /Tencent[P]ncnn/build_O2/src/layer/x86/groupnorm_x86_fma.cpp | 0x3ad8d6 | Tencent[P]ncnn[P]build_O2[P]examples[P]yolov7_pnnx |
ImGui::DestroyContext(ImGuiContext*) | void ImGui::DestroyContext(ImGuiContext* ctx)
{
ImGuiContext* prev_ctx = GetCurrentContext();
if (ctx == NULL) //-V1051
ctx = prev_ctx;
SetCurrentContext(ctx);
Shutdown();
SetCurrentContext((prev_ctx != ctx) ? prev_ctx : NULL);
IM_DELETE(ctx);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe8549(%rip), %r14 # 0x1c9f70
testq %rdi, %rdi
cmoveq %r14, %rbx
movq %rbx, 0xe853b(%rip) # 0x1c9f70
callq 0xe1a59
xorl %eax, %eax
cmpq %rbx, %r14
cmovneq %r14, %rax
movq %rax, 0xe8526(%rip) # 0x1c9f70
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14... | /embree[P]embree/tutorials/common/imgui/imgui.cpp | 0xe1a19 | embree[P]embree[P]build_O3[P]embree_triangle_geometry |
bool Gudhi::persistence_matrix::_generic_add_to_column<Gudhi::persistence_matrix::Intrusive_set_column<Column_mini_matrix<Chain_col_options<false, (Gudhi::persistence_matrix::Column_types)8, false, false, false>>>, Gudhi::persistence_matrix::Intrusive_set_column<Column_mini_matrix<Chain_col_options<false, (Gudhi::persi... | bool _generic_add_to_column(const Entry_range& source,
Column& targetColumn,
F1&& process_target,
F2&& process_source,
F3&& update_target1,
F4&& update_target2,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x7(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsi), %r12
movq 0x18(%rsi), %rcx
leaq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rdi... | /GUDHI[P]gudhi-devel/src/Persistence_matrix/include/gudhi/Persistence_matrix/columns/column_utilities.h | 0x2de35 | GUDHI[P]gudhi-devel[P]build_O2[P]src[P]Persistence_matrix[P]test[P]Persistence_matrix_test_persistence_matrix_column_chain_z5_no_row |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::dec_writer>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x99bd
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x7960
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x99d9... | /scientific-systems[P]fmt/include/fmt/format.h | 0x998e | scientific-systems[P]fmt[P]build_O1[P]bin[P]custom-formatter-test |
mz_zip_writer_create_local_dir_header | static mz_bool mz_zip_writer_create_local_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date)
{
(void)pZip;
memset(pDst, ... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movw %cx, %ax
movw %dx, %cx
movw 0x30(%rbp), %dx
movw 0x28(%rbp), %dx
movw 0x20(%rbp), %dx
movw 0x18(%rbp), %dx
movl 0x10(%rbp), %edx
movq %rdi, -0xb8(%rbp)
movq %rsi, -0xc0(%rbp)
movw %cx, -0xc2(%rbp)
movw %ax, -0xc4(%rbp)
movq %r8, -0xd0(%rbp)
movq... | /ValveSoftware[P]Fossilize/miniz/miniz.c | 0xbae90 | ValveSoftware[P]Fossilize[P]build_O0[P]cli[P]fossilize-prune |
void tinyusdz::MetaVariable::set_value<tinyusdz::value::color3f>(tinyusdz::value::color3f const&) | void set_value(const T &v) {
// TODO: Check T is supported type for Metadatum.
_value = v;
_name = std::string(); // empty
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x1ba70a
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
addq $0x18, %rbx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf410
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x25e7f7
movq 0x10(%rsp), %rsi
incq %rs... | /syoyo[P]tinyusdz/src/prim-types.hh | 0x25e7aa | syoyo[P]tinyusdz[P]build_O1[P]asset_resolution_example |
Float32_To_Int8 | static void Float32_To_Int8(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
signed char *dest = (signed char*)destinationBuffer;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, ... | /audacity[P]portaudio/src/common/pa_converters.c | 0x9070 | audacity[P]portaudio[P]build_O0[P]libportaudio.so |
get_one_and_zeros_padding | static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
size_t i;
unsigned char done = 0, prev_done, bad;
if( NULL == input || NULL == data_len )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
bad = 0xFF;
*data_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0xa0f4
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0xa100
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0xa1d2
movb $-0x1, -0x2b(%rbp)
movq -0x20(%rbp), %... | /Dragonchang[P]https_client/mbedtls/library/cipher.c | 0xa0d0 | Dragonchang[P]https_client[P]build_O0[P]mbedtls[P]tests[P]test_suite_cipher.ccm |
generate_by_descriptor_sh | static int generate_by_descriptor_sh(
struct miniscript_node_t *node,
struct miniscript_node_t *parent,
int32_t derive_child_num,
unsigned char *script,
size_t script_len,
size_t *write_len)
{
int ret;
size_t child_write_len = *write_len;
unsigned char buf[WALLY_SCRIPTPUBKEY_P2SH_LEN... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x8a0d
cmpq $0x17, -0x30(%rb... | /p2pderivatives[P]cfd/external/libwally-core/src/descriptor.c | 0x89c0 | p2pderivatives[P]cfd-go[P]build_O0[P]Release[P]ctest_descriptor |
tinyusdz::Path::has_prefix(tinyusdz::Path const&) const | bool Path::has_prefix(const Path &prefix) const {
if (!is_valid() || !prefix.is_valid()) {
return false;
}
if (prefix.is_prim_property_path()) {
// No hierarchy in Prim's property path, so use ==.
return full_path_name() == prefix.full_path_name();
} else if (prefix.is_prim_path()) {
// '/', pr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpb $0x1, 0xc8(%rdi)
jne 0x1e60b
movq %rsi, %rbx
cmpb $0x1, 0xc8(%rsi)
jne 0x1e60b
movq %rdi, %r14
movq 0x8(%rbx), %rcx
movq 0x28(%rbx), %rax
testq %rcx, %rcx
setne %dl
testq %rax, %rax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1e... | /syoyo[P]tinyusdz/src/prim-types.cc | 0x1e47c | syoyo[P]tinyusdz[P]build_O2[P]save_usda |
duckdb::ValueRelation::ValueRelation(duckdb::shared_ptr<duckdb::ClientContext, true> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, duckdb::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, true>, std::__cxx11::basic_string<char, std::... | ValueRelation::ValueRelation(const shared_ptr<ClientContext> &context, const string &values_list,
vector<string> names_p, string alias_p)
: Relation(context, RelationType::VALUE_LIST_RELATION), names(std::move(names_p)), alias(std::move(alias_p)) {
this->expressions = Parser::ParseValu... | subq $0xd8, %rsp
movq %rcx, 0x30(%rsp)
movq %r8, 0x50(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movq 0xc8(%rsp), %rsi
movl $0xf, %edx
callq 0x27721f0
movq 0x48(%rsp), %rdi
movq 0x1e7e25c(%rip), %rax # ... | /lnkuiper[P]duckdb/src/main/relation/value_relation.cpp | 0x3dc3dc0 | lnkuiper[P]duckdb[P]build_O0[P]src[P]libduckdb.so |
sqlite3_bind_zeroblob64 | SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
int rc;
Vdbe *p = (Vdbe *)pStmt;
sqlite3_mutex_enter(p->db->mutex);
if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
rc = SQLITE_TOOBIG;
}else{
assert( (n & 0x7FFFFFFF)==n );
rc = sqlite3_bind_zeroblob(pStmt, i, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x24a0b
callq *0xe98c5(%rip) # 0x10e2d0
movq (%rbx), %rax
movslq 0x7c(%rax), %rax
movl $0x12, %ebp
cmpq %r14, %rax
jb 0x24a2c
movq %rbx, %rdi
movl ... | /4rterius[P]cgtfs/third_party/sqlite3/src/sqlite3.c | 0x249e9 | 4rterius[P]cgtfs[P]build_O1[P]bench |
diligent_spirv_cross::CompilerGLSL::emit_sampled_image_op(unsigned int, unsigned int, unsigned int, unsigned int) | void CompilerGLSL::emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id)
{
if (options.vulkan_semantics && combined_image_samplers.empty())
{
emit_binary_func_op(result_type, result_id, image_id, samp_id,
type_to_glsl(get<SPIRType>(result_type), r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
cmpb $0x1, 0x1de0(%rdi)
jne 0x537cf5
cmpq $0x0, 0x898(%rbx)
jne 0x537cf5
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5561b8
movq (%rbx),... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Cross/spirv_glsl.cpp | 0x537c84 | DiligentGraphics[P]DiligentCore[P]build_O2[P]Graphics[P]Archiver[P]libArchiver.so |
PAL_iswalpha | int
__cdecl
PAL_iswalpha( char16_t c )
{
PERF_ENTRY(iswalpha);
ENTRY( "PAL_iswalpha (c=%d)\n", c);
if ( PAL_iswupper( c ) || PAL_iswlower( c ) )
{
LOGEXIT( "PAL_iswalpha returns 1.\n" );
PERF_EXIT(iswalpha);
return 1;
}
LOGEXIT( "PAL_iswalpha returns 0.\n" );
PERF_E... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x19202a(%rip), %r14 # 0x25cb9c
cmpb $0x0, (%r14)
je 0xcaba5
movzwl %di, %ebx
movl %ebx, %edi
callq 0xcaad6
testl %eax, %eax
jne 0xcab91
movl %ebx, %edi
callq 0xcab1c
testl %eax, %eax
je 0xcaba1
movl $0x1, %eax
cmpb $0x0, (%r14)
je 0xcaba5
popq %rbx
popq %r14
pop... | /chakra-core[P]ChakraCore/pal/src/cruntime/wchar.cpp | 0xcab64 | chakra-core[P]ChakraCore[P]build_O3[P]bin[P]GCStress[P]GCStress |
edition_unittest::BoolParseTester::Clear() | PROTOBUF_NOINLINE void BoolParseTester::Clear() {
// @@protoc_insertion_point(message_clear_start:edition_unittest.BoolParseTester)
::google::protobuf::internal::TSanWrite(&_impl_);
::uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
_impl_.... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
callq 0xe488c6
leaq 0x30(%rbx), %r14
movq 0x30(%rbx), %r15
testb $0x4, %r15b
je 0xb4f087
movq %r14, %rdi
callq 0x43f580
xorl %ebp, %ebp
testb $0x4, %r15b
sete %bpl
movq %r14, %rdi
movl %ebp, %esi
callq 0x43f4ca
movq %r14, %rdi
movl ... | /protocolbuffers[P]protobuf/build_O3/google/protobuf/edition_unittest.pb.cc | 0xb4f05e | protocolbuffers[P]protobuf[P]build_O3[P]tests |
mpt_stream_seek | extern int64_t mpt_stream_seek(MPT_STRUCT(stream) *stream, int64_t pos, int mode)
{
static const MPT_STRUCT(decode_state) def_dec = MPT_DECODE_INIT;
static const MPT_STRUCT(encode_state) def_enc = MPT_ENCODE_INIT;
MPT_STRUCT(queue) *qu;
off_t add;
int flags, file = -1;
flags = mpt_stream_flags(&stream->_info);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x37a0
movl %eax, %ebp
movl %eax, %ecx
andl $0x3, %ecx
pushq $-0x1
popq %rax
pushq $-0x4
popq %r12
cmpl $0x1, %ecx
je 0x7dd4
testl %ecx, %ecx
jne 0x7e94
cmpq $0x0, 0x50(%r15)
jne 0x7e94
cmp... | /becm[P]mpt-base/mptio/stream/stream_seek.c | 0x7d80 | becm[P]mpt-base[P]build_O2[P]mptio[P]libmptio.so.1.0.0 |
write_data_block | static ssize_t
write_data_block(struct archive_write_disk *a, const char *buff, size_t size)
{
uint64_t start_size = size;
ssize_t bytes_written = 0;
ssize_t block_size = 0, bytes_to_write;
if (size == 0)
return (ARCHIVE_OK);
if (a->filesize == 0 || a->fd < 0) {
archive_set_error(&a->archive, 0,
"Attem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x33a42d
movq %rdi, %rbx
movq 0x210(%rdi), %rax
testq %rax, %rax
je 0x33a2e2
cmpl $0x0, 0x1f4(%rbx)
js 0x33a2e2
movq %rdx, %r14
movq %rsi, %r15
testb $0x10, 0x1f1(%rbx)
jne 0x33a301
xorl %r13d, %r13d
jmp 0x33a327
leaq 0xbf3... | /fjeremic[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c | 0x33a2a2 | fjeremic[P]CMake[P]build_O3[P]bin[P]ccmake |
isl_local_space_free | __isl_null isl_local_space *isl_local_space_free(
__isl_take isl_local_space *ls)
{
if (!ls)
return NULL;
if (--ls->ref > 0)
return NULL;
isl_space_free(ls->dim);
isl_mat_free(ls->div);
free(ls);
return NULL;
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17f07ac
movq $0x0, 0x10(%rsp)
jmp 0x17f07f7
movq 0x8(%rsp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jle 0x17f07c8
movq $0x0, 0x10(%rsp)
jmp 0x17f07f7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1864d10
movq 0x8(%rsp... | /External/isl/isl_local_space.c | 0x17f0790 | llvm-project[P]build_O0[P]bin[P]clangd-fuzzer |
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool>(testing::internal::UnitTestImpl*, bool (testing::internal::UnitTestImpl::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x9411aa
movq 0x8051d(%rip), %rax # 0x9db758
addq %r15, %r14
cmpb $0x1, 0x1f0(%rax)
jne 0x95b268
testb $0x1, %r12b
je 0x95b255
movq (%r14), %rax
movq -0x1(%ra... | /Abc-Arbitrage[P]fixpp/googletest-release-1.8.0/googletest/src/gtest.cc | 0x95b214 | Abc-Arbitrage[P]fixpp[P]build_O1[P]tests[P]run_visitor_test |
FFont::FFont(char const*, char const*, int, int, int, int, int) | FFont::FFont (const char *name, const char *nametemplate, int first, int count, int start, int fdlump, int spacewidth)
{
int i;
FTextureID lump;
char buffer[12];
FTexture **charlumps;
int maxyoffs;
bool doomtemplate = gameinfo.gametype & GAME_DoomChex ? strncmp (nametemplate, "STCFN", 5) == 0 : false;
bool stcfn... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq 0x441936(%rip), %ra... | /alexey-lysiuk[P]gzdoom/src/v_font.cpp | 0x62cea0 | alexey-lysiuk[P]gzdoom[P]build_O0[P]gzdoom |
IntrusiveList<SynConstant>::push_back(SynConstant*) | void push_back(T *node)
{
assert(node);
assert(node->next == 0);
assert(!node->listed);
node->listed = true;
if(!head)
{
head = tail = node;
}
else
{
tail->next = node;
tail = node;
}
} | pushq %rax
testq %rsi, %rsi
je 0x128f9d
cmpq $0x0, 0x30(%rsi)
jne 0x128fbc
cmpb $0x1, 0x38(%rsi)
je 0x128fdb
movb $0x1, 0x38(%rsi)
leaq 0x8(%rdi), %rax
movq 0x8(%rdi), %rcx
addq $0x30, %rcx
xorl %edx, %edx
cmpq $0x0, (%rdi)
setne %dl
cmoveq %rax, %rcx
movq %rsi, (%rcx)
movq %rsi, (%rdi,%rdx,8)
popq %rax
retq
leaq 0xa79... | /WheretIB[P]nullc/NULLC/IntrusiveList.h | 0x128f64 | WheretIB[P]nullc[P]build_O1[P]tests[P]tests |
llvm::detail::UniqueFunctionBase<void, mlir::Operation*, mlir::OpAsmPrinter&, llvm::StringRef>::UniqueFunctionBase<mlir::Op<mlir::LLVM::VPFPToSIOp, mlir::OpTrait::ZeroRegions, mlir::OpTrait::OneResult, mlir::OpTrait::OneTypedResult<mlir::Type>::Impl, mlir::OpTrait::ZeroSuccessors, mlir::OpTrait::NOperands<3u>::Impl, ml... | UniqueFunctionBase(CallableT Callable, CalledAs<CalledAsT>) {
bool IsInlineStorage = true;
void *CallableAddr = getInlineStorage();
if (sizeof(CallableT) > InlineStorageSize ||
alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
IsInlineStorage = false;
// Allocate out-... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
callq 0x1e5e710
movq (%rsp), %rdi
movb $0x1, 0x27(%rsp)
callq 0x1e5e730
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rsp)
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x6f4fb5e(%rip), %rsi # 0x93f... | /llvm/ADT/FunctionExtras.h | 0x24aa9a0 | llvm-project[P]build_O0[P]bin[P]mlir-cpu-runner |
deqp::gls::BuiltinPrecisionTests::Functions::Refract<2>::doExpand(deqp::gls::BuiltinPrecisionTests::ExpandContext&, deqp::gls::BuiltinPrecisionTests::Tuple4<deqp::gls::BuiltinPrecisionTests::ExprP<tcu::Vector<float, 2>>, deqp::gls::BuiltinPrecisionTests::ExprP<tcu::Vector<float, 2>>, deqp::gls::BuiltinPrecisionTests::E... | ExprP<Ret> doExpand (ExpandContext& ctx, const ArgExprs& args) const
{
const ExprP<Arg0>& i = args.a;
const ExprP<Arg1>& n = args.b;
const ExprP<float>& eta = args.c;
const ExprP<float> dotNI = bindExpression("dotNI", ctx, dot(n, i));
const ExprP<float> k1 = bindExpression("k1", ctx, constant(1.0f) - eta... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x286cf9(%rip), %rsi # 0x90c003
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x3b9a18
leaq 0x10(%r15), %r14
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp | 0x6852ea | kaydenl[P]VK-GL-CTS[P]build_O2[P]modules[P]gles3[P]deqp-gles3 |
testing::internal::TestEventRepeater::Release(testing::TestEventListener*) | TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
for (size_t i = 0; i < listeners_.size(); ++i) {
if (listeners_[i] == listener) {
listeners_.erase(listeners_.begin() + i);
return listener;
}
}
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x792f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest.cc | 0x64690 | trinerdi[P]icpc-notebook[P]build_O0[P]test_graph_dinic |
std::pair<google::dense_hashtable_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Hasher, Capital, SetKey<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Capital>, Has... | std::pair<iterator, bool> insert(Arg&& obj) {
resize_delta(1); // adding an object, grow if need be
return insert_noresize(get_key(std::forward<Arg>(obj)), std::forward<Arg>(obj));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %esi
movq %r15, %rdi
callq 0x543fae
leaq 0x30(%r15), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x53db70
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x54... | /sparsehash[P]sparsehash-c11/./sparsehash/internal/densehashtable.h | 0x543f28 | sparsehash[P]sparsehash-c11[P]build_O1[P]tests[P]sparsehash_unittests |
Gudhi::persistence_matrix::RU_pairing<Gudhi::persistence_matrix::Matrix<RU_rep_options_with_row_access<false, (Gudhi::persistence_matrix::Column_types)7, false, true, false, true, true, true>>>::_add_bar(int, unsigned int) | void _add_bar(Dimension dim, Pos_index birth) {
barcode_.emplace_back(birth, Master_matrix::template get_null_value<Pos_index>(), dim);
if constexpr (Master_matrix::hasFixedBarcode || !Master_matrix::Option_list::has_removable_columns) {
indexToBar_.push_back(barcode_.size() - 1);
} else {
index... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %rcx
movl %esi, (%rcx)
leaq 0x10(%rsp), %rsi
movl %edx, (%rsi)
addq $0x38, %rdi
leaq 0xc(%rsp), %r14
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x13fb6
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
shrq $0x2, %rax
imull $0x... | /GUDHI[P]gudhi-devel/src/Persistence_matrix/include/gudhi/Persistence_matrix/ru_pairing.h | 0x3fd9c | GUDHI[P]gudhi-devel[P]build_O3[P]src[P]Persistence_matrix[P]test[P]Persistence_matrix_test_persistence_matrix_matrix_zp_ru_rep_pos_idx_barcode_max_dim |
nhr_response_read_chunks | void nhr_response_read_chunks(nhr_response r, char * str) {
unsigned int chunk_len = 0;
while ((nhr_sscanf(str, "%X", &chunk_len) == 1) || (nhr_sscanf(str, "%x", &chunk_len) == 1)) {
while (isxdigit(*str)) str++;
if (chunk_len == 0) {
if (strncmp(str, k_nhr_double_CRLF, k_nhr_double_CRLF_length) == 0) {
r-... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x7d3b(%rip), %rsi # 0xd35d
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x4230
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x15(%rbp)
je 0x5658
movq -0x10(%rbp),... | /OlehKulykov[P]libnhr/src/nhr_response.c | 0x5600 | OlehKulykov[P]libnhr[P]build_O0[P]tests[P]test_get_static |
DIS::ResupplyOfferPdu::ResupplyOfferPdu() | ResupplyOfferPdu::ResupplyOfferPdu() : LogisticsFamilyPdu(),
_receivingEntityID(),
_supplyingEntityID(),
_numberOfSupplyTypes(0),
_padding1(0),
_padding2(0)
{
setPduType( 6 );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x62960
movq 0x2f098(%rip), %rax # 0xb2af8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x661e0
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0x661e0
xorl %eax, %eax
movb %al, 0x38(%rbx)
andw $0x0, 0x3a(%rbx... | /open-dis[P]open-dis-cpp/src/dis6/ResupplyOfferPdu.cpp | 0x83a48 | open-dis[P]open-dis-cpp[P]build_O2[P]libOpenDIS6.so |
sqlite3ResolveExprNames | SQLITE_PRIVATE int sqlite3ResolveExprNames(
NameContext *pNC, /* Namespace to resolve expressions in. */
Expr *pExpr /* The expression to be analyzed. */
){
int savedHasAgg;
Walker w;
if( pExpr==0 ) return SQLITE_OK;
savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderA... | testq %rsi, %rsi
je 0x73777
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rdi), %ebp
movl %ebp, %eax
andl $0xf7ff6fef, %eax # imm = 0xF7FF6FEF
movl %eax, 0x28(%rdi)
movq (%rdi), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x1cd(%rip), %rax # 0x738ea
movq %rax, 0x... | /hharte[P]mm_manager/third-party/sqlite3.c | 0x736e8 | hharte[P]mm_manager[P]build_O3[P]mm_manager |
main | int main(int argc, char** argv) {
int a = 3;
int b = 10;
int c, *pa, *pb, *pc;
pa = &a;
*pa = *pa * 2;
pb = &b;
c = 3 * (*pb - *pa);
pc = pb;
pa = pb;
pb = pc;
printf("a = %d\nb = %d\n*pa = %d\n*pb = %d\n*pc = %d\n", a, b, *pa, *pb, *pc);
return 0;
} | pushq %rax
leaq 0xec0(%rip), %rdi # 0x2004
pushq $0x6
popq %rsi
pushq $0xa
popq %rcx
movl %ecx, %edx
movl %ecx, %r8d
movl %ecx, %r9d
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
| /adri326[P]ife-exs/src/11/11.1/main.c | 0x113c | adri326[P]ife-exs[P]build_O2[P]11.1 |
RangeReader::write(unsigned char const*, unsigned long) | virtual void write(const uint8_t *p, size_t n)
{
size_t want= (size_t)std::min(uint64_t(n), _endofs-_curpos);
if (want<n)
throw "write beyond limit";
_r->write(p, want);
_curpos += want;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
subq 0x38(%rdi), %rax
cmpq %rdx, %rax
jb 0x1f5a9
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq %rbx, 0x38(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x9120
leaq 0x1319a(%rip), %rcx # 0x3... | /nlitsme[P]eimgfs/build_O1/itslib-src/include/itslib/util/rw/RangeReader.h | 0x1f57c | nlitsme[P]eimgfs[P]build_O1[P]eimgfs |
helics::DependencyInfo::DependencyInfo(helics::GlobalFederateId) | explicit DependencyInfo(GlobalFederateId id): fedID(id), forwarding{id.isBroker()} {} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x142fda
movl %ebx, 0x48(%r14)
cmpl $0x70000000, %ebx # imm = 0x70000000
setge %al
cmpl $0x1, %ebx
sete %cl
orb %al, %cl
andl $0x0, 0x4c(%r14)
movb %cl, 0x50(%r14)
andw $0x0, 0x51(%r14)
movb $0x0, 0x53(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14... | /GMLC-TDC[P]HELICS/src/helics/core/TimeDependencies.hpp | 0x199c8c | GMLC-TDC[P]HELICS[P]build_O2[P]bin[P]helics_player |
LoadTextureFromImage | Texture2D LoadTextureFromImage(Image image)
{
Texture2D texture = { 0 };
if ((image.data != NULL) && (image.width != 0) && (image.height != 0))
{
texture.id = rlLoadTexture(image.data, image.width, image.height, image.format, image.mipmaps);
}
else TRACELOG(LOG_WARNING, "IMAGE: Data is not ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movl $0x0, (%rdi)
movq (%r12), %rdi
testq %rdi, %rdi
setne %al
movl 0x8(%r12), %ebp
testl %ebp, %ebp
setne %cl
andb %al, %cl
movl 0xc(%r12), %r14d
testl %r14d, %r14d
setne %al
andb %cl, %al
cmpb $0x1, %al
jne 0x3fd1f
movl 0x10(... | /reidevries[P]batchglprocess/raylib-3.7.0/src/textures.c | 0x3fcc4 | reidevries[P]batchglprocess[P]build_O3[P]batchglprocess |
bsplib::A2A::~A2A() | A2A::~A2A()
{
if ( m_recv_win != MPI_WIN_NULL )
MPI_Win_free( &m_recv_win );
MPI_Comm_free( &m_comm );
m_comm = MPI_COMM_NULL;
} | pushq %rbx
movq %rdi, %rbx
movq 0x140(%rdi), %rax
cmpq 0xe994(%rip), %rax # 0x16f80
je 0x85fa
leaq 0x140(%rbx), %rdi
callq 0x5080
leaq 0x138(%rbx), %rdi
callq 0x5450
movq 0xe9ab(%rip), %rax # 0x16fb8
movq %rax, 0x138(%rbx)
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
je 0x862f
movq 0x170(%rbx), %rsi
subq %rdi, %rs... | /wijnand-suijlen[P]bsponmpi/src/a2a.cc | 0x85da | wijnand-suijlen[P]bsponmpi[P]build_O1[P]test_hpget_1_msg |
bool clang::interp::GetGlobal<(clang::interp::PrimType)7, clang::interp::Integral<64u, false>>(clang::interp::InterpState&, clang::interp::CodePtr, unsigned int) | bool GetGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
const Pointer &Ptr = S.P.getPtrGlobal(I);
if (!CheckConstant(S, OpPC, Ptr.getFieldDesc()))
return false;
if (Ptr.isExtern())
return false;
// If a global variable is uninitialized, that means the initializer we've
// compiled for it wasn't a ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa8(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x11a1bcc
movq %r15, %rdi
callq 0x114c018
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x118a9c5
testb %al, %al
je 0x11230ca
cmpl $0x0, 0x28(%rsp)
je 0x11230ba
movq %rsp... | /AST/Interp/Interp.h | 0x112303d | llvm-project[P]build_O1[P]bin[P]clang-diff |
clang::analyze_printf::PrintfSpecifier::hasValidFieldWidth() const | bool PrintfSpecifier::hasValidFieldWidth() const {
if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
return true;
// The field width is valid for all conversions except n
switch (CS.getKind()) {
case ConversionSpecifier::nArg:
return false;
default:
return true;
}
} | cmpl $0x0, 0x1c(%rdi)
sete %cl
cmpl $0x17, 0x40(%rdi)
setne %al
orb %cl, %al
retq
nop
| /AST/PrintfFormatString.cpp | 0x12b41c4 | llvm-project[P]build_O1[P]bin[P]arcmt-test |
ImGuiIO::AddInputCharacterUTF16(unsigned short) | void ImGuiIO::AddInputCharacterUTF16(ImWchar16 c)
{
if (c == 0 && InputQueueSurrogate == 0)
return;
if ((c & 0xFC00) == 0xD800) // High surrogate, must save
{
if (InputQueueSurrogate != 0)
InputQueueCharacters.push_back(IM_UNICODE_CODEPOINT_INVALID);
InputQueueSurrogate ... | subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0x0, %eax
jne 0x211a69
movq (%rsp), %rax
movzwl 0x1544(%rax), %eax
cmpl $0x0, %eax
jne 0x211a69
jmp 0x211b2a
movzwl 0xe(%rsp), %eax
andl $0xfc00, %eax # imm = 0xFC00
cm... | /AdamYuan[P]SparseVoxelOctree/dep/MyVK/dep/imgui/imgui.cpp | 0x211a30 | AdamYuan[P]SparseVoxelOctree[P]build_O0[P]SparseVoxelOctree |
bool mlir::op_definition_impl::hasTrait<mlir::OpTrait::ZeroRegions, mlir::OpTrait::OneResult, mlir::OpTrait::OneTypedResult<mlir::Type>::Impl, mlir::OpTrait::ZeroSuccessors, mlir::OpTrait::OneOperand, mlir::OpTrait::OpInvariants, mlir::BytecodeOpInterface::Trait, mlir::ConditionallySpeculatable::Trait, mlir::OpTrait::A... | inline bool hasTrait(TypeID traitID) {
TypeID traitIDs[] = {TypeID::get<Traits>()...};
for (unsigned i = 0, e = sizeof...(Traits); i != e; ++i)
if (traitIDs[i] == traitID)
return true;
return false;
} | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
callq 0x5aa394
movq %rax, (%rsp)
callq 0x5aa422
movq %rax, 0x8(%rsp)
callq 0x5ad2cc
movq %rax, 0x10(%rsp)
callq 0x5aa53e
movq %rax, 0x18(%rsp)
callq 0x5d2e5c
movq %rax, 0x20(%rsp)
callq 0x5a8f04
movq %rax, 0x28(%rsp)
callq 0x5aa5cc
movq %rax, 0x30(%rsp)
callq 0x5aa65a
movq %r... | /mlir/IR/OpDefinition.h | 0xb6c54a | llvm-project[P]build_O3[P]bin[P]mlir-lsp-server |
phmap::priv::raw_hash_set<phmap::priv::FlatHashSetPolicy<phmap::priv::hash_internal::Enum>, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<phmap::priv::hash_internal::Enum>>::initialize_slots(unsigned long) | void initialize_slots(size_t new_capacity) {
assert(new_capacity);
if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value &&
slots_ == nullptr) {
infoz_ = Sample();
}
auto layout = MakeLayout(new_capacity);
char* mem = static_cast<char*>(
... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x38a46
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x31974
movq %rax, %r15
leaq 0x28(%r14), %rdi
addq $0x3, %r15
andq $-0x4, %r15
leaq (%r15,%rdx,4), %rsi
callq 0x38a84
testb $0x3, %al
jne 0x38a65
movq %rax, (%r14)
addq %rax, %r15
movq %r15, 0x8(%r14)
leaq... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h | 0x389e0 | greg7mdp[P]parallel-hashmap[P]build_O3[P]test_parallel_flat_hash_set |
ncnn::vresize_two(short const*, short const*, int, unsigned char*, unsigned char*, short, short, short, short) | static void vresize_two(const short* rows0p, const short* rows1p, int wsize, unsigned char* Dp0, unsigned char* Dp1, short b0, short b1, short b2, short b3)
{
int dx = 0;
#if __ARM_NEON
int16x8_t _b0 = vdupq_n_s16(b0);
int16x8_t _b1 = vdupq_n_s16(b1);
int16x8_t _b2 = vdupq_n_s16(b2);
int16x8_t _b3 =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %r10d
movl 0x38(%rsp), %r11d
movd %r9d, %xmm0
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movd %r11d, %xmm1
pshuflw $0x0, %xmm1, %xmm1 # ... | /Tencent[P]ncnn/src/mat_pixel_resize.cpp | 0x374d4 | Tencent[P]ncnn[P]build_O1[P]examples[P]nanodetplus_pnnx |
void njoy::tools::disco::Integer<2u>::write<int, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(int const&, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&) | static void write( const Representation& value, Iterator& iter ) {
// std::abs does not exist for all integer types (e.g. unsigned)
const Representation absValue = value < 0 ? -value : value;
const auto required = minimumRequiredWidth( absValue )
+ ( value < 0 ? 1 : 0 );
std::o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ebp
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
movl $0x1, %eax
cmpl $0xa, %ecx
jb 0x2d78c
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
movl %ecx, %esi
imulq %rdx, %rsi
shrq... | /njoy[P]ENDFtk/build_O3/_deps/tools-src/src/tools/disco/Integer.hpp | 0x2d74c | njoy[P]ENDFtk[P]build_O3[P]src[P]ENDFtk[P]section[P]2[P]151[P]UnresolvedEnergyDependentFissionWidths[P]LValue[P]test[P]ENDFtk.section.2.151.UnresolvedEnergyDependentFissionWidths.LValue.test |
mbedtls_ssl_get_session | int mbedtls_ssl_get_session( const mbedtls_ssl_context *ssl, mbedtls_ssl_session *dst )
{
if( ssl == NULL ||
dst == NULL ||
ssl->session == NULL ||
ssl->conf->endpoint != MBEDTLS_SSL_IS_CLIENT )
{
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
return( ssl_session_copy( dst,... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x3d7cb
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x3d7cb
movq (%rdi), %rcx
testb $0x1, 0x164(%rcx)
jne 0x3d7cb
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x3cfa5
movl $0xffff8f00, %eax # imm = 0xFFFF8F00
retq
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c | 0x3d79b | aliyun-beta[P]aliyun-openapi-cpp-sdk[P]build_O1[P]libaliyun_api_ram_2014_02_14.so |
llvm::Value::stripAndAccumulateConstantOffsets(llvm::DataLayout const&, llvm::APInt&, bool, bool, llvm::function_ref<bool (llvm::Value&, llvm::APInt&)>) const | const Value *Value::stripAndAccumulateConstantOffsets(
const DataLayout &DL, APInt &Offset, bool AllowNonInbounds,
bool AllowInvariantGroup,
function_ref<bool(Value &, APInt &)> ExternalAnalysis) const {
if (!getType()->isPtrOrPtrVectorTy())
return this;
unsigned BitWidth = Offset.getBitWidth();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r13
movq 0x8(%rdi), %rax
movl $0xfe, %ecx
andl 0x8(%rax), %ecx
cmpl $0x12, %ecx
jne 0x15830a5
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpb $0xf, 0x8(%rax)
jne 0x15833f8
movl %r8d, 0x18(%rsp)
mo... | /IR/Value.cpp | 0x1583074 | llvm-project[P]build_O1[P]bin[P]llvm-opt-fuzzer |
embree::TutorialScene::print_camera_names() | void TutorialScene::print_camera_names ()
{
if (cameras.size() == 0) {
std::cout << "no cameras inside the scene" << std::endl;
return;
}
for (size_t i=0; i<cameras.size(); i++)
std::cout << "camera " << i << ": " << cameras[i]->name << std::endl;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x7be00
cmpq $0x0, %rax
jne 0x7b755
movq 0x47586b(%rip), %rdi # 0x4f0fa0
leaq 0x3d2f6d(%rip), %rsi # 0x44e6a9
callq 0x19c50
movq %rax, %rdi
movq 0x47580d(%rip), %rsi # 0x4f0f58
callq 0x19d30
jmp 0x7b803
movq $0x0, 0x20(%rs... | /embree[P]embree/tutorials/common/tutorial/scene.cpp | 0x7b710 | embree[P]embree[P]build_O0[P]embree_lazy_geometry |
parse(t_program*, t_program*) | void parse(t_program *program, t_program *parent_program) {
// Get scope file path
string path = program->get_path();
// Set current dir global, which is used in the include_file function
g_curdir = directory_name(path);
g_curpath = path;
// Open the file
// skip UTF-8 BOM if there is one
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75180
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x60910
movq -0xd8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x60910
jmp 0x71bf1
leaq -0x50(%rbp), %rd... | /hezhaozhao-git[P]thrift_rpc_code_generate/src/thrift/main.cc | 0x71bb0 | hezhaozhao-git[P]thrift_rpc_code_generate[P]build_O0[P]thrift_code.cpython-310-x86_64-linux-gnu.so |
crnlib::dxt1_endpoint_optimizer::compute_selectors_hc() | void dxt1_endpoint_optimizer::compute_selectors_hc()
{
m_best_solution.m_selectors.resize(m_unique_colors.size());
if (m_best_solution.m_enforce_selector)
{
memset(m_best_solution.m_selectors.get_ptr(), m_best_solution.m_enforced_selector, m_best_solution.m_selectors.size());
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
addq $0x960, %rdi # imm = 0x960
movl 0x40(%rbx), %ebp
movl 0x968(%rbx), %eax
cmpl %ebp, %eax
je 0x70bec
ja 0x70be6
cmpl %ebp, 0x96c(%rbx)
jae 0x70bce
incl %eax
xorl %edx, %edx
cmpl %ebp, %eax
sete %dl
movl %ebp... | /FrozenStormInteractive[P]Crunch2/crnlib/crn_dxt1.cpp | 0x70b84 | FrozenStormInteractive[P]Crunch2[P]build_O1[P]crunch[P]crunch |
ncnn::Convolution_x86_fma::destroy_pipeline(ncnn::Option const&) | int Convolution_x86_fma::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
if (convolution_dilation1)
{
convolution_dilation1->destroy_pipeline(opt);
delete convolution_dilation1;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xf7442
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xf743d
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%rbx)
movq 0x178(%rbx), %rdi
testq %rdi, %rdi
je 0xf747... | /ysh329[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp | 0xf7412 | ysh329[P]ncnn[P]build_O2[P]examples[P]yolov5_pnnx |
InstructionSet::M68k::Preinstruction InstructionSet::M68k::Predecoder<(InstructionSet::M68k::Model)3>::validated<(unsigned char)243, true>(InstructionSet::M68k::AddressingMode, int, InstructionSet::M68k::AddressingMode, int, InstructionSet::M68k::Condition, int) | Preinstruction Predecoder<model>::validated(
AddressingMode op1_mode, int op1_reg,
AddressingMode op2_mode, int op2_reg,
Condition condition,
int additional_extension_words
) {
constexpr auto operation = Predecoder<model>::operation(op);
if constexpr (!validate) {
return Preinstruction(
operation,
op1_mo... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movb %sil, %cl
movl 0x10(%rbp), %esi
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movb $0x75, -0x25(%rbp)
callq 0x251790
movl %eax, -0x2c(%rbp)
movb... | /MaddTheSane[P]CLK/InstructionSets/M68k/Decoder.cpp | 0x251690 | MaddTheSane[P]CLK[P]build_O0[P]clksignal |
bool llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::icmp_pred_with_threshold, llvm::ConstantInt, true>::match_impl<llvm::Constant>(llvm::Constant*) | bool match_impl(ITy *V) {
if (const auto *CV = dyn_cast<ConstantVal>(V))
return this->isValue(CV->getValue());
if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
if (const auto *C = dyn_cast<Constant>(V)) {
if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue()))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %r15b
cmpb $0x11, %r15b
jne 0x3a85f84
leaq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
movl (%r14), %edx
callq 0x3e973c4
movl %eax, %ebp
cmpb $0x11, %r15b
je 0x3a85fdc
movq 0x8(%rbx), %r15
xorl %eax, %eax... | /llvm/IR/PatternMatch.h | 0x3a85f58 | llvm-project[P]build_O1[P]lib[P]liblldb.so.19.1.0 |
deqp::gles2::Functional::eval_selection_ivec3(deqp::gls::ShaderEvalContext&) | void eval_selection_ivec3 (ShaderEvalContext& c) { c.color.xyz() = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(1, 2, 0).asInt(), c.in[2].swizzle(3, 1, 2).asInt()).asFloat(); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movss 0x38(%rdi), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x40(%rdi), %xmm0
movsd 0x44(%rdi), %xmm1
leaq 0x10(%rsp), %rsi
movsd %xmm1, (%rsi)
movss %xmm0, 0x8(%rsi)
leaq 0x34(%rsp), %r14
movq %r14, %rdi
callq 0xd8c12e
movss 0x5c(%rbx), %xmm0
leaq 0x1c(%rsp), ... | /kaydenl[P]VK-GL-CTS/modules/gles2/functional/es2fShaderOperatorTests.cpp | 0xd7b14a | kaydenl[P]VK-GL-CTS[P]build_O2[P]external[P]openglcts[P]modules[P]cts-runner |
_interceptor_pthread_timedjoin_np | INTERCEPTOR(int, pthread_timedjoin_np, void *thread, void **ret,
const struct timespec *abstime) {
int result;
hwasanThreadArgRetval().Join((uptr)thread, [&]() {
result = REAL(pthread_timedjoin_np)(thread, ret, abstime);
return !result;
});
return result;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0xaaaaaaaa, 0x2c(%rsp) # imm = 0xAAAAAAAA
callq 0x4d700
movq %rax, %rdi
movq 0x40(%rsp), %rsi
leaq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0... | /hwasan/hwasan_interceptors.cpp | 0x42580 | llvm-project[P]build_O0[P]lib[P]clang[P]19[P]lib[P]x86_64-unknown-linux-gnu[P]libclang_rt.hwasan.so |
duckdb::ModeState<long, duckdb::ModeStandard<long>>::Scan() const | typename Counts::const_iterator Scan() const {
//! Initialize control variables to first variable of the frequency map
auto highest_frequency = frequency_map->begin();
for (auto i = highest_frequency; i != frequency_map->end(); ++i) {
// Tie break with the lowest insert position
if (i->second.count > highes... | movq 0x18(%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x460daf
movq %rax, %rcx
movq 0x10(%rax), %rdx
cmpq %rdx, 0x10(%rcx)
jbe 0x460d9b
movq %rcx, %rax
jmp 0x460da7
jne 0x460da7
movq 0x18(%rcx), %rdx
cmpq 0x18(%rax), %rdx
jb 0x460d96
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x460d8c
retq
| /duckdb[P]duckdb/extension/core_functions/aggregate/holistic/mode.cpp | 0x460d7c | duckdb[P]duckdb[P]build_O1[P]extension[P]core_functions[P]core_functions.duckdb_extension |
fmt::v5::internal::arg_map<fmt::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::basic_buffer<wchar_t>>, wchar_t>>::find(fmt::v5::basic_string_view<wchar_t>) const | basic_format_arg<Context> find(basic_string_view<char_type> name) const {
// The list is unsorted, so just return the first matching name.
for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
if (it->name == name)
return it->arg;
}
return {};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movl 0x8(%rsi), %eax
testq %rax, %rax
sete %bpl
je 0xae714
movq %rcx, %r14
movq (%rsi), %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %rbx
xorl %r13d, %r13d
movq 0x8(%r12,%r13), %r15
cmpq %r14, %r15
... | /scientific-systems[P]fmt/include/fmt/core.h | 0xae67e | scientific-systems[P]fmt[P]build_O1[P]bin[P]format-test |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.