name string | code string | asm string | file string | addresses string | bin string |
|---|---|---|---|---|---|
bool llvm::DenseMapBase<llvm::DenseMap<clang::MacroDefinitionRecord const*, unsigned int, llvm::DenseMapInfo<clang::MacroDefinitionRecord const*, void>, llvm::detail::DenseMapPair<clang::MacroDefinitionRecord const*, unsigned int>>, clang::MacroDefinitionRecord const*, unsigned int, llvm::DenseMapInfo<clang::MacroDefin... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0xc42ee0
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r9d
shrl $0x9, %r9d
xorl %eax, %r9d
decl %ecx
andl %ecx, %r9d
movl %r9d, %eax
shll $0x4, %eax
leaq (%rdi,%rax), %r8
movq (%rdi,%rax), %rbx
movb $0x1, %al
cmpq %rbx, %rsi
jne 0xc4... | /llvm/ADT/DenseMap.h | 0xc42ea6 | llvm-project[P]build_O3[P]bin[P]clang-extdef-mapping |
Dumper::printName(dg::dda::RWNode const*) | void printName(const RWNode *node) {
if (node == nullptr) {
printf("nullptr");
return;
}
if (node == UNKNOWN_MEMORY) {
printf("unknown mem");
return;
}
const char *name = nullptr;
std::string nm;
if (!name) {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x240, %rsp # imm = 0x240
testq %rsi, %rsi
je 0x156e0
movq %rsi, %r14
movq 0x89ed(%rip), %rax # 0x1dfe8
cmpq %rsi, (%rax)
je 0x156e9
leaq 0xb8(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq 0x8(%rdi), %rdi
movq... | /mchalupa[P]dg/tools/llvm-dda-dump.cpp | 0x155d8 | mchalupa[P]dg[P]build_O3[P]tools[P]llvm-dda-dump |
void duckdb::AggregateExecutor::UnaryFlatUpdateLoop<duckdb::ApproxQuantileState, duckdb::hugeint_t, duckdb::ApproxQuantileListOperation<duckdb::hugeint_t>>(duckdb::hugeint_t const*, duckdb::AggregateInputData&, duckdb::ApproxQuantileState*, unsigned long, duckdb::ValidityMask&) | static inline void UnaryFlatUpdateLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask) {
AggregateUnaryInput input(aggr_input_data, mask);
auto &base_idx = input.input_idx;
base_idx = 0;... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x68(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0xe5fe30
leaq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, (%rax)
movq 0x58(%r... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp | 0x1cd83e0 | duckdb[P]duckdb[P]build_O0[P]duckdb |
hello::csrf() | void csrf()
{
session().set("name","me");
view::csrf c;
if(request().request_method() == "POST") {
c.my_form.load(context());
if(c.my_form.validate()) {
c.valid=true;
}
}
render("csrf",c);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x5d8, %rsp # imm = 0x5D8
movq %rdi, %rbx
callq 0x139d0
movq %rax, %r14
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9e54(%rip), %rsi # 0x222ac
leaq 0x9e51(%rip), %rdx # 0x222b0
leaq 0x40(%rsp), %rdi
callq 0x16b74
leaq 0x9e48(%rip), %rdx ... | /artyom-beilis[P]cppcms/src/hello_world.cpp | 0x18430 | artyom-beilis[P]cppcms[P]build_O3[P]hello_world |
curlx_sltoui | unsigned int curlx_sltoui(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
#endif
return (uns... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x2b8a
jmp 0x2b8c
jmp 0x2b8e
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nop
| /DarovskikhAndrei[P]curl/lib/warnless.c | 0x2b80 | DarovskikhAndrei[P]curl[P]build_O0[P]tests[P]libtest[P]lib1512 |
yactfr::internal::(anonymous namespace)::readFlSIntLe55At0(unsigned char const*) | std::int64_t readFlSIntLe55At0(const std::uint8_t * const buf) {
std::uint64_t res = 0;
res |= buf[6];
res <<= 8;
res |= buf[5];
res <<= 8;
res |= buf[4];
res <<= 8;
res |= buf[3];
res <<= 8;
res |= buf[2];
res <<= 8;
res |= buf[1];
res <<= 8;
res |= buf[0];
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %eax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x5(%rax), %eax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -... | /eepp[P]yactfr/yactfr/internal/fl-int-reader.hpp | 0x584ea0 | eepp[P]yactfr[P]build_O0[P]yactfr[P]libyactfr.so.0.2.0 |
gdImageCreateFromTgaPtr | BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaPtr(int size, void *data)
{
gdImagePtr im;
gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0);
if (in == NULL) return NULL;
im = gdImageCreateFromTgaCtx(in);
in->gd_free(in);
return im;
} | pushq %r14
pushq %rbx
pushq %rax
xorl %edx, %edx
callq 0xa450
testq %rax, %rax
je 0x1f2db
movq %rax, %rbx
movq %rax, %rdi
callq 0xa1c0
movq %rax, %r14
movq %rbx, %rdi
callq *0x30(%rbx)
movq %r14, %rax
jmp 0x1f2dd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Orc[P]libgd/src/gd_tga.c | 0x1f2b2 | Orc[P]libgd[P]build_O1[P]Bin[P]libgd.so.3.0.8 |
testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlUnitTest(&stream, unit_test);
fprintf(xmlout, "%s", StringStreamToString(&stream)... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x22c96
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9400
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x22dc2
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1ba39
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx... | /lbcb-sci[P]ram/build_O3/_deps/googletest-src/googletest/src/gtest.cc | 0x22bde | lbcb-sci[P]ram[P]build_O3[P]bin[P]ram_test |
xmrig::OclCnRunner::run(unsigned int, unsigned int*) | void xmrig::OclCnRunner::run(uint32_t nonce, uint32_t *hashOutput)
{
static const cl_uint zero = 0;
const size_t w_size = data().thread.worksize();
const size_t g_thd = ((m_intensity + w_size - 1u) / w_size) * w_size;
assert(g_thd % w_size == 0);
for (size_t i = 0; i < BRANCH_MAX; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
movl 0xd8(%rax), %r15d
movl 0x58(%r14), %eax
leaq (%r15,%rax), %r12
decq %r12
xorl %ebp, %ebp
movq %r12, %rax
xorl %edx, %edx
divq %r15
movq %... | /fart-master[P]blur-miner/src/backend/opencl/runners/OclCnRunner.cpp | 0x7018c | fart-master[P]blur-miner[P]build_O2[P]xmrig |
CoreML::Specification::AverageLayerParams::ByteSizeLong() const | size_t AverageLayerParams::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CoreML.Specification.AverageLayerParams)
size_t total_size = 0;
int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = cached_size;
G... | movl $0x0, 0x10(%rdi)
xorl %eax, %eax
retq
| /1duo[P]coremltools/build_O3/mlmodel/format/NeuralNetwork.pb.cc | 0x3a00be | 1duo[P]coremltools[P]build_O1[P]libcaffeconverter.so |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::unordered_multiset<long double, std::hash<long double>, std::equal_to<long double>, std::allocator<long double>>, std::unordered_multiset<long double, std::hash<long double>, std::equal_to<long double>, std::allocator<long double>>>(char const*, char c... | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0xdeb16
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xdeb16
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xor... | /JAJames[P]Jupiter-Bot/src/Jupiter/src/jessilib/src/test/googletest/googletest/include/gtest/gtest.h | 0xde812 | JAJames[P]Jupiter-Bot[P]build_O3[P]bin[P]jessilib_tests |
void ncnn::qsort_descent_inplace<ncnn::Rect>(std::vector<ncnn::Rect, std::allocator<ncnn::Rect>>&, std::vector<float, std::allocator<float>>&, int, int) | static void qsort_descent_inplace(std::vector<T>& datas, std::vector<float>& scores, int left, int right)
{
int i = left;
int j = right;
float p = scores[(left + right) / 2];
while (i <= j)
{
while (scores[i] > p)
i++;
while (scores[j] < p)
j--;
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %ebx, %ecx
movl %edx, %ebp
cmpl %ebx, %edx
jg 0x48176
leal (%rbx,%rdx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %rax
movq (%r14), %rcx
movss (%rcx,%rax,4), %xmm0
movl %e... | /xiangweizeng[P]ncnn/src/layer/proposal.cpp | 0x480b4 | xiangweizeng[P]ncnn[P]build_O1[P]tests[P]test_binaryop |
void pybind11::cpp_function::initialize<void pybind11::detail::vector_if_equal_operator<std::vector<std::vector<long, std::allocator<long>>, std::allocator<std::vector<long, std::allocator<long>>>>, pybind11::class_<std::vector<std::vector<long, std::allocator<long>>, std::allocator<std::vector<long, std::allocator<lon... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
// The unique_ptr makes sure nothing is leaked ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdi, %rbx
movq 0x40(%rsp), %rbp
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x433b2
movq (%r14), %r14
leaq 0x7c(%rip), %rax # 0x7364e
movq %rax, 0x30(%r14)
movq (%r13), %rax
... | /bioinfologics[P]sdg/deps/pybind11/pybind11.h | 0x7359e | bioinfologics[P]sdg[P]build_O1[P]SDGpython[P]SDGpython.so |
var_filter_block2d_bil_first_pass_c | static void var_filter_block2d_bil_first_pass_c(
const uint8_t *a, uint16_t *b, unsigned int src_pixels_per_line,
unsigned int pixel_step, unsigned int output_height,
unsigned int output_width, const uint8_t *filter) {
unsigned int i, j;
for (i = 0; i < output_height; ++i) {
for (j = 0; j < output_... | movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movl %r9d, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jae 0x298755
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0x20(%rsp), %eax
jae 0x29871... | /m-ab-s[P]aom/aom_dsp/variance.c | 0x298670 | m-ab-s[P]aom[P]build_O0[P]aomenc |
boost::unordered::detail::foa::table_locator<boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, std::pair<slang::syntax::SyntaxNode const* const, slang::ast::ConfigRule const*>> boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<slang::syntax::Syn... | locator nosize_unchecked_emplace_at(const arrays_type& arrays_, std::size_t pos0,
std::size_t hash, Args&&... args) {
for (prober pb(pos0);; pb.next(arrays_.groups_size_mask)) {
auto pos = pb.get();
auto pg = arrays_.groups() + pos;
aut... | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rsi
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movq 0x10(%rdx), %r9
shlq $0x4, %rcx
pxor %xmm0, %xmm0
movdqa (%r9,%rcx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ebp
andl $0x7fff, %ebp # imm = 0x7FFF
je 0x3caa0a
addq %rcx, %r9
movq %r9, %rcx
bsfl %ebp, %r9d
imulq $0x... | /MikePopoloski[P]slang/source/../external/boost_unordered.hpp | 0x3ca988 | MikePopoloski[P]slang[P]build_O3[P]bin[P]slang-tidy |
str_len | unsigned int str_len(const char *s)
{
register const char *t;
t = s;
for (;;) {
if (!*t) return t - s; ++t;
if (!*t) return t - s; ++t;
if (!*t) return t - s; ++t;
if (!*t) return t - s; ++t;
}
} | leaq 0x3(%rdi), %rax
cmpb $0x0, -0x3(%rax)
je 0x41b5
cmpb $0x0, -0x2(%rax)
je 0x41bb
cmpb $0x0, -0x1(%rax)
je 0x41c1
cmpb $0x0, (%rax)
je 0x41c4
addq $0x4, %rax
jmp 0x4198
addq $-0x3, %rax
jmp 0x41c4
addq $-0x2, %rax
jmp 0x41c4
decq %rax
subl %edi, %eax
retq
nop
| /madscientist42[P]runit/src/lib/byte/str_len.c | 0x4194 | madscientist42[P]runit[P]build_O2[P]src[P]runsv |
clang::TreeTransform<(anonymous namespace)::TemplateInstantiator>::TransformObjCAtSynchronizedStmt(clang::ObjCAtSynchronizedStmt*) | StmtResult
TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
ObjCAtSynchronizedStmt *S) {
// Transform the object we are locking.
ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
if (Object.isInvalid())
return StmtError();
Object =
... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x32d7d90
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rdi
callq 0x9d0d40
movq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x3255d60
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1d453e0
testb $0x1, %al
jne 0x3321... | /Sema/TreeTransform.h | 0x3321520 | llvm-project[P]build_O0[P]bin[P]c-index-test |
llvm::AMDGPUTargetLowering::getTargetNodeName(unsigned int) const | const char* AMDGPUTargetLowering::getTargetNodeName(unsigned Opcode) const {
switch ((AMDGPUISD::NodeType)Opcode) {
case AMDGPUISD::FIRST_NUMBER: break;
// AMDIL DAG nodes
NODE_NAME_CASE(UMUL);
NODE_NAME_CASE(BRANCH_COND);
// AMDGPU DAG nodes
NODE_NAME_CASE(IF)
NODE_NAME_CASE(ELSE)
NODE_NAME_CASE(LOO... | leal -0x1e6(%rsi), %eax
cmpl $0x62, %eax
ja 0xc35475
leaq 0x2b4db00(%rip), %rcx # 0x3782f64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x329bb30(%rip), %rax # 0x3ed0fa4
retq
addl $0xfffffc26, %esi # imm = 0xFFFFFC26
cmpl $0x36, %esi
ja 0xc358d4
leaq 0x2b4dc65(%rip), %rax # 0x37830f0
movslq (... | /Target/AMDGPU/AMDGPUISelLowering.cpp | 0xc35452 | llvm-project[P]build_O1[P]bin[P]llvm-lto2 |
Catch::operator<<(std::ostream&, Catch::LazyExpression const&) | auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
if( lazyExpr.m_isNegated )
os << "!";
if( lazyExpr ) {
if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
os << "(" << *lazyExpr.m_transientEx... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0x152dc
leaq 0x39a8d(%rip), %rsi # 0x4ed61
movq %rbx, %rdi
callq 0x11550
movq (%r14), %rdi
testq %rdi, %rdi
je 0x15324
cmpb $0x1, 0x8(%r14)
jne 0x1531a
cmpb $0x1, 0x8(%rdi)
jne 0x1531a
leaq 0x36f09(%rip), %rsi # 0x4c201
mo... | /CLIUtils[P]CLI11/build_O2/tests/catch2/catch.hpp | 0x152bc | CLIUtils[P]CLI11[P]build_O2[P]tests[P]link_test_2 |
cs_impl::cni_holder<cs::numeric (*)(cs_impl::any const&), cs::numeric (*)(cs_impl::any const&)>::cni_holder(cs::numeric (* const&)(cs_impl::any const&)) | explicit cni_holder(const T &func) : mCni(func) {} | pushq %rbx
subq $0x20, %rsp
leaq 0xcaf82(%rip), %rax # 0x1561b8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq (%rsi), %rax
testq %rax, %rax
je 0x8b271
movq %rax, (%rsp)
leaq 0x124(%rip), %rax # 0x8b384
movq %rax, 0x18(%rsp)
leaq 0x12a(... | /covscript[P]covscript/include/covscript/core/cni.hpp | 0x8b22a | covscript[P]covscript[P]build_O1[P]cs |
Gia_ManCollectReachable | int Gia_ManCollectReachable( Gia_Man_t * pAig, int nStatesMax, int fMiter, int fDumpFile, int fVerbose )
{
Gia_ManEra_t * p;
Gia_ObjEra_t * pState;
int Hash;
abctime clk = Abc_Clock();
int RetValue = 1;
assert( Gia_ManPiNum(pAig) <= 12 );
assert( Gia_ManRegNum(pAig) > 0 );
p = Gia_ManEr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, 0x24(%rsp)
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r13d
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movl $0x3, %edi
callq 0xc4300
testl %eax, %eax
js 0x5f9695
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x1... | /zfchu[P]abc/src/aig/gia/giaEra.c | 0x5f9635 | zfchu[P]abc[P]build_O1[P]abc |
llvm::HexagonMCChecker::checkRegisterCurDefs() | void HexagonMCChecker::checkRegisterCurDefs() {
for (auto const &I : HexagonMCInstrInfo::bundleInstructions(MCII, MCB)) {
if (HexagonMCInstrInfo::isCVINew(MCII, I) &&
HexagonMCInstrInfo::getDesc(MCII, I).mayLoad()) {
const unsigned RegDef = I.getOperand(0).getReg();
bool HasRegDefUse = false;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0x18(%rdi), %rsi
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0x27cea2
movq 0x20(%r14), %rax
leaq 0x80(%rsp), %rdi
movq %rax, 0x20(%rdi)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1,... | /Target/Hexagon/MCTargetDesc/HexagonMCChecker.cpp | 0x27ad3c | llvm-project[P]build_O1[P]bin[P]llvm-rtdyld |
testing::internal::UnitTestImpl::FilterTests(testing::internal::UnitTestImpl::ReactionToSharding) | int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
// num_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %r12d
movq %rdi, %rbx
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
testl %esi, %esi
jne 0x2117d
leaq 0x175e0(%rip), %rdi # 0x38750
movl $0xffffffff, %esi... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc | 0x21140 | metacall[P]core[P]build_O1[P]detour-test |
llvm::DenseMapBase<llvm::SmallDenseMap<unsigned int, unsigned int, 32u, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>, unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>::clear() | unsigned getNumEntries() const {
return NumEntries;
} | movl (%rdi), %ecx
cmpl $0x1, %ecx
ja 0xef9d63
cmpl $0x0, 0x4(%rdi)
je 0xef9eb8
leal (%rcx,%rcx), %eax
andl $-0x4, %eax
movl $0x20, %edx
andl $0x1, %ecx
jne 0xef9d76
movl 0x10(%rdi), %edx
cmpl %edx, %eax
setae %al
cmpl $0x41, %edx
setb %sil
orb %al, %sil
je 0xefade4
testl %ecx, %ecx
jne 0xef9d95
movq 0x8(%rdi), %rax
jmp... | /llvm/ADT/DenseMap.h | 0xef9d52 | llvm-project[P]build_O3[P]bin[P]llvm-dwp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> generateStringVector<std::vector<helics::GlobalFederateId, std::allocator<helics::GlobalFederateId>>, helics::FilterFederate::query[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>) const::$_1>(std::vector<helics::GlobalFedera... | std::string generateStringVector(const X& data, Proc generator)
{
static_assert(std::is_convertible<decltype(generator(*(data.begin()))), std::string>::value,
"generator output must be convertible to std::string");
std::string ret{"["};
for (auto& ele : data) {
ret.append(helics::g... | subq $0xa8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x90(%rsp)
movb $0x0, 0x8f(%rsp)
leaq 0x8e(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x68470
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x1b509b(%rip), %rsi # 0x6feb89
callq 0x86a10
jmp 0x549af5
leaq 0x8e(%rsp... | /GMLC-TDC[P]HELICS/src/helics/core/queryHelpers.hpp | 0x549aa0 | GMLC-TDC[P]HELICS[P]build_O0[P]bin[P]helics_broker_server |
restincurl::InDataHandler<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::write_callback(char*, unsigned long, unsigned long, void*) | static size_t write_callback(char *ptr, size_t size, size_t nitems, void *userdata) {
assert(userdata);
auto self = reinterpret_cast<InDataHandler *>(userdata);
const auto bytes = size * nitems;
if (bytes > 0) {
std::copy(ptr, ptr + bytes, std::back_insert... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x1d7d5
movq %rdx, %rbx
imulq %rsi, %rbx
testq %rbx, %rbx
je 0x1d7c6
jle 0x1d7c6
movq %rdi, %r14
movq 0x8(%rcx), %r15
leaq 0x1(%rbx), %r12
movsbl (%r14), %esi
movq %r15, %rdi
callq 0x19810
incq %r14
decq %r12
cmpq $0x1, %r12
jg 0x1d7ae
movq %rbx... | /jgaa[P]RESTinCurl/include/restincurl/restincurl.h | 0x1d788 | jgaa[P]RESTinCurl[P]build_O1[P]tests[P]example7 |
helix::make_ob_event(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, helix::order_book*, unsigned int) | event make_ob_event(const std::string& symbol, uint64_t timestamp, order_book* ob, event_mask mask)
{
return event{mask | ev_order_book_update, symbol, timestamp, ob, nullptr};
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
orl $0x1, %r8d
movl %r8d, (%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 0x1300c
movq %r14, 0x28(%r15)
movq %rbx, 0x30(%r15)
movq $0x0, 0x38(%r... | /jvirtanen[P]helix/src/event.cc | 0x16c22 | jvirtanen[P]helix[P]build_O1[P]helix-top |
cmMakefile::DisplayStatus(char const*, float) const | void cmMakefile::DisplayStatus(const char* message, float s) const
{
cmake* cm = this->GetCMakeInstance();
if (cm->GetWorkingMode() == cmake::FIND_PACKAGE_MODE)
{
// don't output any STATUS message in FIND_PACKAGE_MODE, since they will
// directly be fed to the compiler, which will be confused.
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3a6660
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x35cc10
cmpl $0x2, %eax
jne 0x3b9882
jmp 0x3b9894
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %... | /ewmailing[P]CMake/Source/cmMakefile.cxx | 0x3b9850 | ewmailing[P]CMake[P]build_O0[P]bin[P]cmake |
StartLockWheelingWindow(ImGuiWindow*) | static void StartLockWheelingWindow(ImGuiWindow* window)
{
ImGuiContext& g = *GImGui;
if (g.WheelingWindow == window)
return;
g.WheelingWindow = window;
g.WheelingWindowRefMousePos = g.IO.MousePos;
g.WheelingWindowTimer = WINDOWS_MOUSE_WHEEL_SCROLL_LOCK_TIMER;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0x1105c1(%rip), %rax # 0x224c40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1d40(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x114696
jmp 0x1146cf
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1d40(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %ra... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp | 0x114670 | mgerdes[P]Open-Golf[P]build_O0[P]golf |
lest::got::got(lest::location, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | got( location where_, text expr_)
: success( "passed: got exception", where_, expr_) {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x99ec(%rip), %rsi # 0x903b0
leaq 0x99fa(%rip), %rdx # 0x903c5
leaq 0x48(%rsp), %rdi
callq 0xe41a
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r1... | /martinmoene[P]span-lite/test/lest/lest_cpp03.hpp | 0x8699a | martinmoene[P]span-lite[P]build_O1[P]test[P]span-lite-cpp17.t |
filemgr_remove_pending | void filemgr_remove_pending(struct filemgr *old_file,
struct filemgr *new_file,
err_log_callback *log_callback)
{
if (new_file == NULL) {
return;
}
spin_lock(&old_file->lock);
if (atomic_get_uint32_t(&old_file->ref_count) > 0) {
//... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1c216
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1a0(%rdi), %r12
movq %r12, %rdi
callq 0x3330
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x1c222
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x1be74
movb $0x4, %al
xchgb %al, 0x108(%rbx)
mo... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc | 0x1c17b | ForestDB-KVStore[P]forestdb[P]build_O3[P]tests[P]e2e[P]e2etest |
testing::internal::DefaultDeathTestFactory::Create(char const*, testing::internal::RE const*, char const*, int, testing::internal::DeathTest**) | bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
const char* file, int line,
DeathTest** test) {
UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
callq 0x2df24
movq 0x29b00(%rip), %rax # 0x69760
movq 0x1d0(%rax), %r14
movq 0x110(%rax), %rcx
movl 0xd0(%rcx), %eax
leal 0x1(%rax), %edx
movl %edx, 0xd0(... | /CppCodeReviewers[P]How-to-mock-free-function/3rd-party/gmock-1.7.0/gmock-gtest-all.cc | 0x3fc34 | CppCodeReviewers[P]How-to-mock-free-function[P]build_O1[P]How-to-mock-free-function |
llvm::detail::DenseMapPair<clang::CXXMethodDecl const*, llvm::SmallVector<clang::ThunkInfo, 1u>>* llvm::DenseMapBase<llvm::DenseMap<clang::CXXMethodDecl const*, llvm::SmallVector<clang::ThunkInfo, 1u>, llvm::DenseMapInfo<clang::CXXMethodDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXMethodDecl const*, llvm::S... | 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... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4947c0
movq 0x10(%rsp), %rdi
callq 0x3253120
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x2b6fda0
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h | 0x3252fd0 | llvm-project[P]build_O0[P]bin[P]clang-diff |
void duckdb::UnaryExecutor::ExecuteStandard<short, int, duckdb::GenericUnaryWrapper, duckdb::DecimalScaleUpCheckOperator>(duckdb::Vector&, duckdb::Vector&, unsigned long, void*, bool, duckdb::FunctionErrors) | static inline void ExecuteStandard(Vector &input, Vector &result, idx_t count, void *dataptr, bool adds_nulls,
FunctionErrors errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR) {
switch (input.GetVectorType()) {
case VectorType::CONSTANT_VECTOR: {
result.SetVectorType(VectorTyp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
movzbl (%rdi), %eax
testl %eax, %eax
je 0xe3b015
cmpl $0x3, %eax
je 0xe3af28
cmpl $0x2, %eax
jne 0xe3af87
movq %rbx, %rdi
movl $0x2, %esi
callq 0xb6f9c... | /duckdb[P]duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp | 0xe3aea2 | duckdb[P]duckdb[P]build_O3[P]src[P]libduckdb.so |
(anonymous namespace)::PPCBranchCoalescing::moveAndUpdatePHIs(llvm::MachineBasicBlock*, llvm::MachineBasicBlock*) | void PPCBranchCoalescing::moveAndUpdatePHIs(MachineBasicBlock *SourceMBB,
MachineBasicBlock *TargetMBB) {
MachineBasicBlock::iterator MI = SourceMBB->begin();
MachineBasicBlock::iterator ME = SourceMBB->getFirstNonPHI();
if (MI == ME) {
LLVM_DEBUG(dbgs() << "SourceMB... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x3df780
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rdi
callq 0x2f79570
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3e7010
testb $0x1, %al
jne 0x1acbd86
jmp 0x1acbd8f
jmp 0x1acbd88
j... | /Target/PowerPC/PPCBranchCoalescing.cpp | 0x1acbd40 | llvm-project[P]build_O0[P]bin[P]llvm-reduce |
cmExecuteProcessCommandFixText(std::vector<char, std::allocator<char>>&, bool) | void cmExecuteProcessCommandFixText(std::vector<char>& output,
bool strip_trailing_whitespace)
{
// Remove \0 characters and the \r part of \r\n pairs.
unsigned int in_index = 0;
unsigned int out_index = 0;
while (in_index < output.size()) {
char c = output[in_index++];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rdx
movq %rdx, %rdi
subq %r14, %rdi
je 0x196fe5
xorl %ecx, %ecx
movl $0x1, %eax
xorl %r15d, %r15d
movzbl (%r14,%rcx), %r8d
movl %eax, %ecx
testl %r8d, %r8d
je 0x196fa2
cmpl $0xd, %r8d
jne 0x196f91
cmpq %rcx, %rdi
j... | /jdavidberger[P]CMake/Source/cmExecuteProcessCommand.cxx | 0x196f50 | jdavidberger[P]CMake[P]build_O3[P]bin[P]ccmake |
utMatrix4x4_indexOperatorTest_Test::~utMatrix4x4_indexOperatorTest_Test() | TEST_F( utMatrix4x4, indexOperatorTest ) {
aiMatrix4x4 m;
ai_real *a0 = m[ 0 ];
EXPECT_FLOAT_EQ( 1.0, *a0 );
ai_real *a1 = a0+1;
EXPECT_FLOAT_EQ( 0.0, *a1 );
ai_real *a2 = a0 + 2;
EXPECT_FLOAT_EQ( 0.0, *a2 );
ai_real *a3 = a0 + 3;
EXPECT_FLOAT_EQ( 0.0, *a3 );
ai_real *a4 = m[ 1 ... | pushq %rbx
movq %rdi, %rbx
callq 0x239844
movq %rbx, %rdi
popq %rbx
jmp 0x225870
| /wbrbr[P]realtime/external/assimp/test/unit/utMatrix4x4.cpp | 0x285128 | wbrbr[P]realtime[P]build_O2[P]external[P]assimp[P]test[P]unit |
Assimp::X3DImporter::ParseNode_Lighting_DirectionalLight() | void X3DImporter::ParseNode_Lighting_DirectionalLight()
{
std::string def, use;
float ambientIntensity = 0;
aiColor3D color(1, 1, 1);
aiVector3D direction(0, 0, -1);
bool global = false;
float intensity = 1;
bool on = true;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBE... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30ef60
leaq -0x48(%rbp), %rdi
callq 0x30ef60
movl $0x0, -0x4c(%rbp)
leaq -0x58(%rbp), %rdi
movss 0x2352e9(%rip), %xmm2 # 0xb524d8
movaps %xmm2, %xmm0... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Light.cpp | 0x91d1b0 | hbina[P]fatuous[P]build_O0[P]thirdparty[P]assimp[P]test[P]unit |
Int24_To_Int16_Dither | static void Int24_To_Int16_Dither(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
unsigned char *src = (unsigned char*)sourceBuffer;
PaInt16 *dest = (PaInt16*)destinat... | testl %r8d, %r8d
je 0x8fe4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %r15
leal (%rcx,%rcx,2), %eax
cltq
movq %rax, (%rsp)
movslq %esi, %r13
addq $0x2, %r14
addq %r13, %r13
movzwl -0x2(%r14), %eax
shll $0x7, %eax
movzbl (%r14), ... | /mixlr[P]portaudio/src/common/pa_converters.c | 0x8f7a | audacity[P]portaudio[P]build_O3[P]libportaudio.so |
kj::_::BTreeImpl::logInconsistency() const | BTreeImpl::Iterator BTreeImpl::insert(const SearchKey& searchKey) {
// Like search() but ensures that there is room in the leaf node to insert a new row.
// If we split the root node it will generate two new nodes. If we split any other node in the
// path it will generate one new node. `height` doesn't count le... | pushq %rbx
subq $0x20, %rsp
leaq 0x1b0146(%rip), %rax # 0x554550
cmpl $0x3, (%rax)
jge 0x3a446b
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x39d0b3
leaq 0xd78af(%rip), %rdi # 0x47bcd0
leaq 0xd7d01(%rip), %rcx # 0x47c129
leaq 0xd7e2a(%rip), %r8 # 0x47c259
movl $0xf2, %esi
movl $0x2, %edx
movq %rbx, %r9
callq ... | /Cosmic-Sans[P]capnproto/c++/src/kj/table.c++ | 0x3a43fe | Cosmic-Sans[P]capnproto[P]build_O1[P]c++[P]src[P]capnp[P]capnp-heavy-tests |
wally_tx_elements_output_commitment_set | int wally_tx_elements_output_commitment_set(
struct wally_tx_output *output,
const unsigned char *asset,
size_t asset_len,
const unsigned char *value,
size_t value_len,
const unsigned char *nonce,
size_t nonce_len,
const unsigned char *surjectionproof,
size_t surjectionproof_len,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movaps 0x90(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
movq 0xb0(%rsp), %rax
movq 0x20(%rdi), %r12
movq 0x28(%rdi), %r13
movq 0x30(%rdi), %rbx
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r10
movq %r10, 0x30(%rsp)
movq 0x48(%rdi), %rbp
movq 0x50(%... | /cryptogarageinc[P]cfd-go/external/libwally-core/src/transaction.c | 0xdc0a | cryptogarageinc[P]cfd-go[P]build_O3[P]Release[P]ctest_psbt |
helics::fileops::looksLikeConfigJson(std::basic_string_view<char, std::char_traits<char>>) | bool looksLikeConfigJson(std::string_view jsonString)
{
if (jsonString.find("\n#") != std::string_view::npos) {
return false;
}
jsonString = removeSpaceAndComment(jsonString);
if (jsonString.size() < 7) {
// minimum viable config file is 7 characters {"f":4}
return false;
}
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0xa481e(%rip), %rsi # 0x3397d8
xorl %ebx, %ebx
movl $0x2, %ecx
movq %rax, %rdi
xorl %edx, %edx
callq 0x2139c0
cmpq $-0x1, %rax
jne 0x2950a8
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2950ca
movq %rax, 0x8... | /GMLC-TDC[P]HELICS/src/helics/common/JsonProcessingFunctions.cpp | 0x294fa0 | GMLC-TDC[P]HELICS[P]build_O1[P]bin[P]helics_app |
unsigned long llvm::rotl<unsigned long, void>(unsigned long, int) | [[nodiscard]] constexpr T rotl(T V, int R) {
unsigned N = std::numeric_limits<T>::digits;
R = R % N;
if (!R)
return V;
if (R < 0)
return llvm::rotr(V, -R);
return (V << R) | (V >> (N - R));
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl $0x40, (%rsp)
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl (%rsp)
movl %edx, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x121e784
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x121e7ca
cmpl $0x0, 0x4(%rsp)
jge 0x121e7a2
movq 0x8(%rsp), %rdi
xorl %esi, %esi
subl 0x4... | /llvm/ADT/bit.h | 0x121e750 | llvm-project[P]build_O0[P]bin[P]llc |
asio::detail::reactive_socket_send_op<asio::const_buffers_1, asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>, asio::mutable_buffer, asio::mutable_buffer const*, asio::detail::transfer_all_t, asio::ssl::detail::io_op<asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>, ... | inline asio_handler_allocate_is_deprecated
asio_handler_allocate(std::size_t size,
read_until_delim_string_op_v1<AsyncReadStream,
DynamicBuffer_v1, ReadHandler>* this_handler)
{
#if defined(ASIO_NO_DEPRECATED)
asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
return asio_hand... | leaq 0xa8(%rdi), %rsi
movl $0x160, %edi # imm = 0x160
xorl %eax, %eax
jmp 0x711b6
nop
| /DiscordPP[P]echo-bot/lib/discordpp/lib/asio/asio/include/asio/impl/read_until.hpp | 0xa7f44 | DiscordPP[P]echo-bot[P]build_O2[P]echo_bot |
wasm::ModuleRunnerBase<(anonymous namespace)::EvallingModuleRunner>::visitSIMDLoadStoreLane(wasm::SIMDLoadStoreLane*) | Flow visitSIMDLoadStoreLane(SIMDLoadStoreLane* curr) {
NOTE_ENTER("SIMDLoadStoreLane");
Flow ptrFlow = self()->visit(curr->ptr);
if (ptrFlow.breaking()) {
return ptrFlow;
}
NOTE_EVAL1(ptrFlow);
Flow vecFlow = self()->visit(curr->vec);
if (vecFlow.breaking()) {
return vecFlow;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x30(%rdx), %rdx
leaq -0x198(%rbp), %r12
movq %r12, %rdi
callq 0x38a9c
cmpq $0x0, 0x40(%r12)
je 0x432f6
leaq -0x198(%rbp), %rsi
movq %rbx, %rd... | /WebAssembly[P]binaryen/src/wasm-interpreter.h | 0x432aa | WebAssembly[P]binaryen[P]build_O2[P]bin[P]wasm-ctor-eval |
Assimp::LWOImporter::LoadLWO2Clip(unsigned int) | void LWOImporter::LoadLWO2Clip(unsigned int length)
{
AI_LWO_VALIDATE_CHUNK_LENGTH(length,CLIP,10);
mClips.push_back(LWO::Clip());
LWO::Clip& clip = mClips.back();
// first - get the index of the clip
clip.idx = GetU4();
IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
switch (h... | pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp # imm = 0x380
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2f8(%rbp)
cmpl $0xa, -0xc(%rbp)
jae 0x568a8f
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x30ef80
movq %rax, -0x308(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x300(%rbp)... | /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOLoader.cpp | 0x5689b0 | hbina[P]fatuous[P]build_O0[P]thirdparty[P]assimp[P]test[P]unit |
kj::Maybe<kj::HashMap<capnp::(anonymous namespace)::SchemaBindingsPair, capnp::_::RawBrandedSchema*>::Entry&> kj::Table<kj::HashMap<capnp::(anonymous namespace)::SchemaBindingsPair, capnp::_::RawBrandedSchema*>::Entry, kj::HashIndex<kj::HashMap<capnp::(anonymous namespace)::SchemaBindingsPair, capnp::_::RawBrandedSchem... | kj::Maybe<Row&> Table<Row, Indexes...>::find(Params&&... params) {
KJ_IF_SOME(pos, get<index>(indexes).find(rows.asPtr(), kj::fwd<Params>(params)...)) {
return rows[pos];
} else {
return kj::none;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x38(%rsi)
je 0xb2a5e
movq %rdx, %r15
movq (%r14), %rbp
movq (%rdx), %rsi
leaq 0x7ecf2(%rip), %r12 # 0x1316c0
movq %r12, %rdi
callq 0xbfe76
movq %rsp, %r13
movl %eax, (%r13)
movq 0x8(%r15), %rsi
m... | /capnproto[P]capnproto/c++/src/kj/table.h | 0xb29a2 | capnproto[P]capnproto[P]build_O1[P]c++[P]src[P]capnp[P]capnp |
CLI::App::_parse(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | void _parse(std::vector<std::string> &args) {
increment_parsed();
_trigger_pre_parse(args.size());
bool positional_only = false;
while(!args.empty()) {
if(!_parse_single(args, positional_only)) {
break;
}
}
if(parent_ == nullptr) ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x22298
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x5, %rsi
movq %rbx, %rdi
callq 0x222d4
leaq 0xf(%rsp), %r15
movb $0x0, (%r15)
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x25c79
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
ca... | /GFG-CLUB-KIIT[P]TimeLapse/src/../include/CLI11/CLI11.hpp | 0x25c2e | GFG-CLUB-KIIT[P]TimeLapse[P]build_O3[P]elapso |
uv_udp_set_multicast_ttl | int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl) {
/*
* On Solaris and derivatives such as SmartOS, the length of socket options
* is sizeof(int) for IPV6_MULTICAST_HOPS and sizeof(char) for
* IP_MULTICAST_TTL, so hardcode the size of the option in the IPv6 case,
* and use the general uv__setsockopt_maybe_ch... | movl %esi, %ecx
pushq $0x21
popq %rsi
pushq $0x12
popq %rdx
jmp 0xaf5bd
| /czanyou[P]node/core/deps/libuv/src/unix/udp.c | 0xaf613 | czanyou[P]node[P]build_O2[P]lnode |
testing::internal::StreamingListener::SocketWriter::MakeConnection() | void StreamingListener::SocketWriter::MakeConnection() {
GTEST_CHECK_(sockfd_ == -1)
<< "MakeConnection() can't be called when there is already a connection.";
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
hints.ai_socktype = S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x22930
leaq 0x11921(%rip), %rdx # 0x34213
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x1399, %ecx # imm = 0x1399
callq 0x13efe
movq 0x2c6e5(%rip), %rdi # 0x4eff0
leaq 0x128fe(%rip), ... | /greg7mdp[P]parallel-hashmap/build_O2/googletest-src/googletest/src/gtest.cc | 0x228d6 | greg7mdp[P]parallel-hashmap[P]build_O2[P]test_hash_policy_testing |
Saig_ManRetimeMinAreaBackward | Aig_Man_t * Saig_ManRetimeMinAreaBackward( Aig_Man_t * pNew, int fVerbose )
{
Aig_Man_t * pInit, * pFinal;
Vec_Ptr_t * vBadRegs, * vCut;
Vec_Int_t * vInit;
int iBadReg;
// transform the AIG to have no bad registers
vBadRegs = Saig_ManGetRegistersToExclude( pNew );
if ( fVerbose && Vec_PtrSiz... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x73c1d0
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x73cad9
movq -0x30(%rbp), %rdi
callq 0x73a660
cmpl $0x0, %eax
je 0x73cad9
movq -0x30(%rbp), %rdi
callq 0x73a660
movl %eax, %esi
leaq 0x39b605(... | /antmicro[P]abc-lib/src/aig/saig/saigRetMin.c | 0x73ca90 | antmicro[P]abc-lib[P]build_O0[P]abc |
TransactionApi_EstimateFee_CheckRealValue_Test::~TransactionApi_EstimateFee_CheckRealValue_Test() | TEST(TransactionApi, EstimateFee_CheckRealValue) {
AddressFactory factory(NetType::kRegtest);
// Address1
// pubkey: '0359bc91953b251ae501758673b9d6dd78eafa327190741536025d92217a3f567b',
// privkey: 'cQSo3DLRNg4G57hRkbo2d2pY3QSuRM9eact7LroG46XyZbZByxi5'
UtxoData utxo1;
utxo1.block_height = 0;
utxo1.binary... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x1b9bf0
popq %rax
retq
| /p2pderivatives[P]cfd-js/external/cfd/test/test_cfdapi_transaction.cpp | 0x1af970 | p2pderivatives[P]cfd-js[P]build_O0[P]Release[P]cfd_test |
llvm::DenseMapBase<llvm::DenseMap<void const*, std::unique_ptr<clang::ManagedAnalysis, std::default_delete<clang::ManagedAnalysis>>, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, std::unique_ptr<clang::ManagedAnalysis, std::default_delete<clang::ManagedAnalysis>>>>, void const*, std::un... | 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 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x540924e
movl $0x0, 0x14(%rsp)
jmp 0x540926e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x1d85a50
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
add... | /llvm/ADT/DenseMap.h | 0x5409230 | llvm-project[P]build_O0[P]lib[P]libclang-cpp.so.19.1 |
doctest::AssertData::StringContains::~StringContains() | class DOCTEST_INTERFACE StringContains {
private:
Contains content;
bool isContains;
public:
StringContains(const String& str) : content(str), isContains(false) { }
StringContains(Contains cntn) : content(static_cast<Contains&&>(cntn)), isContains(... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /charlesnicholson[P]nanoprintf/tests/doctest.h | 0x25010 | charlesnicholson[P]nanoprintf[P]build_O0[P]npf_conform_fieldwidth_precision |
Cba_ObjLeft | static inline int Cba_ObjFon0( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vObjFon0, i); } | pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x2a93a0
movq %rdi, %rbx
cmpl %esi, 0x7c(%rdi)
jle 0x2a9381
movq 0x80(%rbx), %rax
movl %esi, %ecx
movslq (%rax,%rcx,4), %r14
testq %r14, %r14
jle 0x2a93bf
cmpl $0x0, 0x11c(%rbx)
jle 0x2a9346
leaq 0x118(%rbx), %rdi
leal 0x1(%r14), %esi
xorl %edx, %edx
callq 0x2b0ed0
... | /zfchu[P]abc/src/base/cba/cba.h | 0x2a92e7 | zfchu[P]abc[P]build_O1[P]abc |
Catch::TestCaseInfo::TestCaseInfo(Catch::TestCaseInfo const&) | TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
: name( other.name ),
className( other.className ),
description( other.description ),
tags( other.tags ),
lcaseTags( other.lcaseTags ),
tagsAsString( other.tagsAsString ),
lineInfo( other.lineInfo ),
pr... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x10f370
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq ... | /basiliscos[P]cpp-bredis/t/catch.hpp | 0x1550c0 | basiliscos[P]cpp-bredis[P]build_O0[P]t-13-protol-error |
phmap::priv::btree_node<phmap::priv::set_params<int, phmap::Less<int>, std::allocator<int>, 256, false>>::init_internal(phmap::priv::btree_node<phmap::priv::set_params<int, phmap::Less<int>, std::allocator<int>, 256, false>>*, phmap::priv::btree_node<phmap::priv::set_params<int, phmap::Less<int>, std::allocator<int>, 2... | static btree_node *init_internal(btree_node *n, btree_node *parent) {
init_leaf(n, parent, kNodeValues);
// Set `max_count` to a sentinel value to indicate that this node is
// internal.
n->set_max_count(kInternalNodeMaxCount);
phmap::priv::SanitizerPoisonMemo... | pushq %rbx
movq %rdi, %rbx
testb $0x7, %bl
jne 0xdedc6
movq %rsi, (%rbx)
movl $0x0, 0x8(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xde440
movq %rbx, %rax
popq %rbx
retq
leaq 0xeae3e(%rip), %rdi # 0x1c9c0b
leaq 0xead15(%rip), %rsi # 0x1c9ae9
leaq 0xeae60(%rip), %rcx # 0x1c9c3b
movl $0xf84, %edx ... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/btree.h | 0xdeda4 | greg7mdp[P]parallel-hashmap[P]build_O3[P]test_btree |
QPDFObjectHandle::replaceKeyAndGetNew(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle const&) | QPDFObjectHandle
QPDFObjectHandle::replaceKeyAndGetNew(std::string const& key, QPDFObjectHandle const& value)
{
replaceKey(key, value);
return value;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xfc0dc
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xfc2bc
movq 0xf3cd2(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0xfc2b8
incl 0x8(%rax)
jmp... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc | 0xfc27c | qpdf[P]qpdf[P]build_O3[P]libtests[P]runlength |
rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>& rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::ParseStream<1u, rapidjson::UTF8<char>, rapidjson::Gene... | GenericDocument& ParseStream(InputStream& is) {
GenericReader<SourceEncoding, Encoding, StackAllocator> reader(
stack_.HasAllocator() ? &stack_.GetAllocator() : 0);
ClearStackOnExit scope(*this);
parseResult_ = reader.template Parse<parseFlags>(is, *this);
if (parseResult_) {... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
cmpq $0x0, 0x20(%rdi)
je 0x44c824
movq %r14, %rdi
callq 0x44c8e4
jmp 0x44c826
xorl %eax, %eax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq $0x100, 0x... | /hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/document.h | 0x44c800 | hbina[P]fatuous[P]build_O2[P]thirdparty[P]assimp[P]tools[P]assimp_cmd[P]assimp |
std::enable_if<(unsigned char)50 + (unsigned char)22 >= 64, void>::type (anonymous namespace)::unpack_single_out<(unsigned char)50, (unsigned char)22>(unsigned int const* restrict&, unsigned long*) | unpack_single_out(
const uint32_t *__restrict__ &in, uint64_t *__restrict__ out) {
*out = static_cast<uint64_t>(*in) >> SHR;
++in;
*out |= static_cast<uint64_t>(*in) << (32 - SHR);
++in;
if (DELTA + SHR > 64) {
static const uint8_t NEXT_SHR = DELTA + SHR - 64;
*out |= static_cast<uint64_t>((*in)... | movq (%rdi), %rax
leaq 0x8(%rax), %r8
movl (%rax), %ecx
movl 0x4(%rax), %edx
movq %r8, (%rdi)
movzbl 0x8(%rax), %eax
shrl $0x16, %ecx
shlq $0xa, %rdx
orq %rcx, %rdx
shlq $0x2a, %rax
orq %rdx, %rax
movq %rax, (%rsi)
retq
| /mpetri[P]ans-large-alphabet/third-party/FastPFor/src/bitpacking.cpp | 0x6a6cb | lemire[P]FastPFor[P]build_O2[P]FastPFOR_unittest |
MULTILABEL::read_cached_label(shared_data*, void*, io_buf&) | size_t read_cached_label(shared_data*, void* v, io_buf& cache)
{
labels* ld = (labels*)v;
ld->label_v.clear();
char* c;
size_t total = sizeof(size_t);
if (cache.buf_read(c, (int)total) < total)
return 0;
bufread_label(ld, c, cache);
return total;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1ee0f0
movq $0x8, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movslq %eax, %rdx
leaq 0x8(%rsp), %rsi
callq 0x26cc70
cmpq (%rsp), %rax
jae 0x295e36
movq $0x0, 0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/multilabel.cc | 0x295de0 | LAIRLAB[P]vowpal_wabbit[P]build_O0[P]vowpalwabbit[P]vw |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char [3]>(char const (&) [3]) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x157f2
movq %r15, %rdi
movq %r14, %rsi
callq 0x2256a
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x104b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp | 0x21d72 | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]filter_file_invalid_path_tests |
duckdb::timestamp_t duckdb::Cast::Operation<unsigned int, duckdb::timestamp_t>(unsigned int) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x10b4800
testb %al, %al
je 0x162bd40
movq 0x8(%rsp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a9280
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp | 0x162bd12 | duckdb[P]duckdb[P]build_O2[P]src[P]libduckdb.so |
nlohmann::detail::type_error nlohmann::detail::type_error::create<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned ch... | static type_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
{
std::string w = exception::name("type_error", id_) + exception::diagnostics(context) + what_arg;
return {id_, w.c_str()};
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x8a20
movq -0xe0(%rbp), %rdx
leaq 0x95236(%ri... | /jsonrpcx[P]json-rpc-cxx/vendor/nlohmann/detail/exceptions.hpp | 0x553a0 | jsonrpcx[P]json-rpc-cxx[P]build_O0[P]jsonrpccpp-test |
testing::internal::FilePath::RemoveExtension(char const*) const | FilePath FilePath::RemoveExtension(const char* extension) const {
const std::string dot_extension = std::string(".") + extension;
if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
return FilePath(pathname_.substr(
0, pathname_.length() - dot_extension.length()));
}
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2fd95(%rip), %rsi # 0x6ff8c
leaq 0x2fd8f(%rip), %rdx # 0x6ff8d
leaq 0x8(%rsp), %rdi
callq 0x2500a
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xdb40
lea... | /ampl[P]mp/thirdparty/gmock/gmock-gtest-all.cc | 0x401d2 | ampl[P]mp[P]build_O1[P]bin[P]sp-test |
void InstructionSet::M50740::Executor::perform<(InstructionSet::M50740::Operation)97, (InstructionSet::M50740::AddressingMode)9>() | void Executor::perform() {
// Post cycle cost; this emulation _does not provide accurate timing_.
#define TLength(mode, base) case AddressingMode::mode: subtract_duration(base + t_lengths[index_mode_]); break;
#define Length(mode, base) case AddressingMode::mode: subtract_duration(base); break;
switch(operation) {
... | pushq %rbx
movq %rdi, %rbx
pushq $0x7
popq %rsi
callq 0xa0bea
movl 0x1000(%rbx), %eax
leal 0x1(%rax), %ecx
andl $0x1fff, %ecx # imm = 0x1FFF
movzbl 0x3029(%rbx), %edx
movb 0x1028(%rbx,%rcx), %cl
addb %dl, %cl
movzbl %cl, %ecx
movzbl 0x1028(%rbx,%rcx), %esi
incb %cl
movzbl %cl, %ecx
movzbl 0x1028(%rbx,%rcx), %... | /MaddTheSane[P]CLK/InstructionSets/M50740/Executor.cpp | 0xc2096 | MaddTheSane[P]CLK[P]build_O2[P]clksignal |
ngram_score | int32
ngram_score(ngram_model_t * model, const char *word, ...)
{
va_list history;
const char *hword;
int32 *histid;
int32 n_hist;
int32 n_used;
int32 prob;
va_start(history, word);
n_hist = 0;
while ((hword = va_arg(history, const char *)) != NULL)
++n_hist;
va_end(hist... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
testb %al, %al
je 0x5b4e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%... | /cmusphinx[P]pocketsphinx/src/lm/ngram_model.c | 0x5b10 | cmusphinx[P]pocketsphinx[P]build_O0[P]pocketsphinx_lm_eval |
llvm::SmallVectorImpl<std::pair<clang::Decl const*, llvm::SmallVector<clang::ASTWriter::DeclUpdate, 1u>>>::swap(llvm::SmallVectorImpl<std::pair<clang::Decl const*, llvm::SmallVector<clang::ASTWriter::DeclUpdate, 1u>>>&) | void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
if (this == &RHS) return;
// We can only avoid copying elements if neither vector is small.
if (!this->isSmall() && !RHS.isSmall()) {
std::swap(this->BeginX, RHS.BeginX);
std::swap(this->Size, RHS.Size);
std::swap(this->Capacity, RHS.Capacity);... | cmpq %rsi, %rdi
je 0xa30dc2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0xa30c5d
movq (%rbx), %rcx
leaq 0x10(%rbx), %rdx
cmpq %rdx, %rcx
je 0xa30c5d
movq %rcx, (%r14)
movq %rax, (%rbx)
movl 0x8(%r... | /llvm/ADT/SmallVector.h | 0xa30c04 | llvm-project[P]build_O3[P]bin[P]c-index-test |
parse_paint | static bool parse_paint(const element_t* element, int id, paint_t* paint)
{
const string_t* value = find_attribute(element, id, true);
if(value == NULL)
return false;
const char* it = value->data;
const char* end = it + value->length;
if(skip_string(&it, end, "none")) {
paint->type =... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x5ec0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8ad8
movb $0x0, -0x1(%rbp)
jmp 0x8e02
movq -0x28(%rbp), %rax
movq (%rax), %rax
m... | /sammycage[P]plutosvg/source/plutosvg.c | 0x8aa0 | sammycage[P]plutosvg[P]build_O0[P]examples[P]svg2png |
test_xreq_validate_peer | static void
test_xreq_validate_peer(void)
{
nng_socket s1, s2;
nng_stat *stats;
const nng_stat *reject;
char *addr;
NUTS_ADDR(addr, "inproc");
NUTS_PASS(nng_req0_open_raw(&s1));
NUTS_PASS(nng_req0_open(&s2));
NUTS_PASS(nng_listen(s1, addr, NULL, 0));
NUTS_PASS(nng_dial(s2, addr, NULL, N... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x4e276(%rip), %rdi # 0x5b245
movl $0x40, %esi
leaq 0x6a925(%rip), %rdx # 0x77900
callq 0x2c350
leaq 0x6a919(%rip), %rax # 0x77900
movq %rax, -0x20(%rbp)
jmp 0xcfed
leaq -0x4(%rbp), %rdi
callq 0x29690
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
sete %al
xor... | /nanomsg[P]nng/src/sp/protocol/reqrep0/xreq_test.c | 0xcfc0 | nanomsg[P]nng[P]build_O0[P]src[P]sp[P]protocol[P]reqrep0[P]xreq_test |
testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
const char* const type_param = test_info.type_param();
const char* const value_param = test_info.value_param();
if (type_param != nullptr || value_param != nullptr) {
printf(", where ");
if (type_param != nullptr) {
printf("%s =... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbfe60
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbfe10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9de74
cmpq $0x0, -0x18(%rbp)
je 0x9dedb
leaq 0x7dbf8(%rip), %rdi # 0x11ba73
movb $0x0, %al
callq 0x170a... | /SNSystems[P]pstore/3rd_party/googletest/googletest/src/gtest.cc | 0x9de40 | SNSystems[P]pstore[P]build_O0[P]bin[P]pstore-http-unit-tests |
isoent_remove_child | static void
isoent_remove_child(struct isoent *parent, struct isoent *child)
{
struct isoent *ent;
/* Remove a child entry from children chain. */
ent = parent->children.first;
while (ent->chnext != child)
ent = ent->chnext;
if ((ent->chnext = ent->chnext->chnext) == NULL)
parent->children.last = &(ent->chnex... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x813838
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x81381c
mov... | /jdavidberger[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c | 0x813800 | jdavidberger[P]CMake[P]build_O0[P]bin[P]ccmake |
kwsysProcessSetupOutputPipeFile | static int kwsysProcessSetupOutputPipeFile(int* p, const char* name)
{
int fout;
if (!name) {
return 1;
}
/* Close the existing descriptor. */
kwsysProcessCleanupDescriptor(p);
/* Open a file for the pipe to write. */
if ((fout = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0) {
return 0;... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5265
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x241, %esi # imm = 0x241
movl $0x1b6, %edx # imm = 0x1B6
xorl %eax, %eax
callq 0x2300
testl %eax, %eax
js 0x5258
movl %eax, %r14d
xorl %ebp, %ebp
pushq $0x2
po... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c | 0x5200 | JKorbelRA[P]CMake[P]build_O2[P]Source[P]kwsys[P]cmsysTestProcess |
bool llvm::function_ref<bool (llvm::Value&)>::callback_fn<void clampReturnedValueStates<llvm::AAPotentialConstantValues, llvm::PotentialValuesState<llvm::APInt>, (llvm::Attribute::AttrKind)0, true>(llvm::Attributor&, llvm::AAPotentialConstantValues const&, llvm::PotentialValuesState<llvm::APInt>&, llvm::CallBase const*... | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x1a6bb10
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rcx
movl $0x1, (%rsp)
xorl %ebp, %ebp
movq %rax, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1a7d... | /llvm/ADT/STLFunctionalExtras.h | 0x1a7f19a | llvm-project[P]build_O3[P]bin[P]llvm-isel-fuzzer |
vkt::wsi::(anonymous namespace)::createImageView(vk::DeviceInterface const&, vk::VkDevice_s*, vk::Handle<(vk::HandleType)9>, vk::VkFormat) | vk::Move<vk::VkImageView> createImageView (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkImage image,
vk::VkFormat format)
{
const vk::VkImageViewCreateInfo createInfo =
{
vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
DE_NULL,
0u,
image,
vk::V... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0xf, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movl $0x0, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %ra... | /kaydenl[P]VK-GL-CTS/external/vulkancts/modules/vulkan/wsi/vktWsiDisplayTimingTests.cpp | 0xc499a0 | kaydenl[P]VK-GL-CTS[P]build_O0[P]external[P]vulkancts[P]modules[P]vulkan[P]vk-build-programs |
jsonnet::internal::LiteralString* jsonnet::internal::Allocator::make<jsonnet::internal::LiteralString, jsonnet::internal::LocationRange const&, std::vector<jsonnet::internal::FodderElement, std::allocator<jsonnet::internal::FodderElement>> const&, std::__cxx11::basic_string<char32_t, std::char_traits<char32_t>, std::al... | T *make(Args &&... args)
{
auto r = new T(std::forward<Args>(args)...);
allocated.push_back(r);
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x30(%rsp)
movl $0xe8, %edi
callq 0x5b620
movq %rax, 0x8(%rsp)
movl (%rbp), %ebp
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rbx, %rdi
callq ... | /google[P]jsonnet/core/ast.h | 0xedfa2 | google[P]jsonnet[P]build_O1[P]libjsonnet_test |
void mserialize::detail::BuiltinSerializer<std::unique_ptr<std::vector<std::tuple<int>, std::allocator<std::tuple<int>>>, std::default_delete<std::vector<std::tuple<int>, std::allocator<std::tuple<int>>>>>, void>::serialize<OutputStream>(std::unique_ptr<std::vector<std::tuple<int>, std::allocator<std::tuple<int>>>, std... | static void serialize(const Optional& opt, OutputStream& ostream)
{
if (opt)
{
mserialize::serialize(std::uint8_t{1}, ostream);
mserialize::serialize(*opt, ostream);
}
else
{
mserialize::serialize(std::uint8_t{0}, ostream);
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x0, (%rdi)
je 0x4109a
movq %rdi, %r14
leaq 0x6(%rsp), %rsi
movb $0x1, (%rsi)
movq (%rbx), %rdi
addq $0x10, %rdi
movl $0x1, %edx
callq 0x65f0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3492e
jmp 0x410b3
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
movq (%rbx), %rdi
addq $... | /morganstanley[P]binlog/include/mserialize/detail/Serializer.hpp | 0x41064 | erenon[P]binlog[P]build_O1[P]UnitTest |
aom_highbd_smooth_predictor_8x4_c | static inline void highbd_smooth_predictor(uint16_t *dst, ptrdiff_t stride,
int bw, int bh,
const uint16_t *above,
const uint16_t *left, int bd) {
(void)bd;
const uint16_t below_pred = le... | pushq %rbx
movzwl 0x6(%rcx), %eax
movzwl 0xe(%rdx), %r8d
addq %rsi, %rsi
xorl %r9d, %r9d
leaq 0x2afe53(%rip), %r10 # 0x40e610
movdqa 0x2afe2b(%rip), %xmm0 # 0x40e5f0
movdqa 0x2afe33(%rip), %xmm1 # 0x40e600
pxor %xmm2, %xmm2
movzbl (%r9,%r10), %r11d
movl %r11d, %ebx
negb %bl
movzbl %bl, %ebx
shll $0x8, %ebx
orl %... | /m-ab-s[P]aom/aom_dsp/intrapred.c | 0x15e7a6 | m-ab-s[P]aom[P]build_O1[P]examples[P]scalable_decoder |
google::protobuf::internal::WireFormat::ParseAndMergeField(unsigned int, google::protobuf::FieldDescriptor const*, google::protobuf::Message*, google::protobuf::io::CodedInputStream*) | bool WireFormat::ParseAndMergeField(
uint32_t tag,
const FieldDescriptor* field, // May be nullptr for unknown
Message* message, io::CodedInputStream* input) {
const Reflection* message_reflection = message->GetReflection();
enum { UNKNOWN, NORMAL_FORMAT, PACKED_FORMAT } value_format;
if (field == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %r13d
movq %rdx, %rdi
callq 0x147c82
movq %rdx, %r15
testq %rbx, %rbx
je 0x16eceb
movl %r13d, %ebp
andl $0x7, %ebp
movzbl 0x2(%rbx), %eax
leaq 0x13a84e(%rip), %rcx # 0x2a9530
... | /protocolbuffers[P]protobuf/src/google/protobuf/wire_format.cc | 0x16eca4 | protocolbuffers[P]protobuf[P]build_O1[P]protoc-gen-upb-31.0.0 |
libcmepoll_init_sel_item | extern void
libcmepoll_init_sel_item(struct _select_item *sel_item)
{
sel_item->add_select = (CMAddSelectFunc)libcmepoll_LTX_add_select;
sel_item->remove_select = (CMRemoveSelectFunc)libcmepoll_LTX_remove_select;
sel_item->write_select = (CMAddSelectFunc) libcmepoll_LTX_write_select;
sel_item->add_perio... | movq 0x2b45(%rip), %rax # 0x4f70
movq %rax, (%rdi)
movq 0x2ba3(%rip), %rax # 0x4fd8
movq %rax, 0x8(%rdi)
movq 0x2b68(%rip), %rax # 0x4fa8
movq %rax, 0x10(%rdi)
movq 0x2b7d(%rip), %rax # 0x4fc8
movq %rax, 0x18(%rdi)
movq 0x2b5a(%rip), %rax # 0x4fb0
movq %rax, 0x20(%rdi)
movq 0x2b6f(%rip), %rax ... | /ornladios[P]ADIOS2/thirdparty/EVPath/EVPath/cmepoll.c | 0x2424 | ornladios[P]ADIOS2[P]build_O3[P]thirdparty[P]EVPath[P]EVPath[P]lib[P]adios2-evpath-modules-2_10[P]libadios2_cmepoll.so |
extraBddSpaceFromMatrixNeg | DdNode * extraBddSpaceFromMatrixNeg( DdManager * dd, DdNode * zA )
{
DdNode * bRes;
statLine( dd );
if ( zA == z0 )
return b1;
if ( zA == z1 )
return b0;
if ( (bRes = cuddCacheLookup1(dd, extraBddSpaceFromMatrixNeg, zA)) )
return bRes;
else
{
DdNode * bP0, *... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x970c9f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x971005
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
j... | /FPGeh[P]abc/src/bdd/extrab/extraBddAuto.c | 0x970c70 | FPGeh[P]abc[P]build_O0[P]abc |
non-virtual thunk to cursespp::ListWindow::ProcessMouseEvent(cursespp::IMouseHandler::Event const&) | bool ListWindow::ProcessMouseEvent(const IMouseHandler::Event& event) {
/* CAL TODO: this method assumes each row is a single cell tall. */
bool result = ScrollableWindow::ProcessMouseEvent(event);
auto first = this->scrollPosition.firstVisibleEntryIndex;
if (first == NO_SELECTION) {
return re... | addq $-0x10, %rdi
jmp 0x51810
nop
| /clangen[P]cursespp/src/ListWindow.cpp | 0x6f5b8 | clangen[P]cursespp[P]build_O3[P]libcursespp.so |
mbedtls_pk_parse_keyfile | int mbedtls_pk_parse_keyfile( mbedtls_pk_context *ctx,
const char *path, const char *pwd )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t n;
unsigned char *buf;
PK_VALIDATE_RET( ctx != NULL );
PK_VALIDATE_RET( path != NULL );
if( ( ret = mbedtls_pk_load_file( p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0xf838
movl %eax, %ebp
testl %eax, %eax
jne 0xf9af
movq (%rsp), %r12
movq 0x8(%rsp), %r15
testq %rbx, %rbx
je 0xf981
movq %rbx, %rdi
callq 0x... | /ARMmbed[P]mbed-crypto/library/pkparse.c | 0xf92f | ARMmbed[P]mbed-crypto[P]build_O1[P]programs[P]pkey[P]rsa_sign_pss |
Aig_ObjChild0CopyRepr | static inline Aig_Obj_t * Aig_ObjChild0Copy( Aig_Obj_t * pObj ) { assert( !Aig_IsComplement(pObj) ); return Aig_ObjFanin0(pObj)? Aig_NotCond((Aig_Obj_t *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj)) : NULL; } | testb $0x1, %sil
jne 0x62c5d6
movq 0x8(%rsi), %rsi
movq %rsi, %rax
andq $-0x2, %rax
je 0x62c5d2
andl $0x1, %esi
xorq 0x28(%rax), %rsi
jmp 0x62c5f6
xorl %esi, %esi
jmp 0x62c5f6
pushq %rax
leaq 0x72484(%rip), %rdi # 0x69ea62
leaq 0x723ec(%rip), %rsi # 0x69e9d1
leaq 0x7248e(%rip), %rcx # 0x69ea7a
movl $0x138, ... | /FPGeh[P]abc/src/aig/aig/aig.h | 0x62c5b6 | FPGeh[P]abc[P]build_O2[P]abc |
GET_BLOCK | static void GET_BLOCK(Integer g_x, task_list_t *chunk, void *buf,
char *trans, Integer xilo, Integer xjlo,
Integer *dim_next, Integer *nbhdl) {
Integer i0, i1, j0, j1;
Integer lo[2], hi[2];
if(*trans == 'n' || *trans == 'N') {
*dim_next = chunk->dim[0];
i0= xilo+chunk->lo[0... | pushq %rbx
subq $0x20, %rsp
movq %r9, %rax
movq %r8, %r10
movq %rcx, %r11
movq %rdx, %rcx
movq 0x38(%rsp), %r9
movq 0x30(%rsp), %r8
movzbl (%r11), %edx
orl $0x20, %edx
cmpl $0x6e, %edx
jne 0x3b415
movslq 0x10(%rsi), %rdx
movq %rdx, (%r8)
movslq (%rsi), %rdx
addq %r10, %rdx
movslq 0x8(%rsi), %r11
addq %r10, %r11
movslq ... | /GlobalArrays[P]ga/global/src/matmul.c | 0x3b3cd | GlobalArrays[P]ga[P]build_O1[P]global[P]testing[P]scan_addc.x |
unixCheckReservedLock | static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
int rc = SQLITE_OK;
int reserved = 0;
unixFile *pFile = (unixFile*)id;
SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
assert( pFile );
assert( pFile->eFileLock<=SHARED_LOCK );
sqlite3_mutex_enter(pFile->pInode->pLockMutex);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x4567b
callq *0xd2df5(%rip) # 0x118470
movq 0x10(%r14), %rax
cmpb $0x1, 0x20(%rax)
ja 0x456de
xorl %r15d, %r15d
cmpb $0x0, 0x21(%rax)
movl $0x0, %ebp
jne... | /clangen[P]f8n/src/3rdparty/src/sqlite/sqlite3.c | 0x45658 | clangen[P]cursespp[P]build_O1[P]f8n[P]libf8n.so |
wal_earliest_txn | fdb_txn * wal_earliest_txn(struct filemgr *file, fdb_txn *cur_txn)
{
struct list_elem *le;
struct wal_txn_wrapper *txn_wrapper;
fdb_txn *txn;
fdb_txn *ret = NULL;
uint64_t min_revnum = 0;
spin_lock(&file->wal->lock);
le = list_begin(&file->wal->txn_list);
while(le) {
txn_wrappe... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rdi
addq $0x60, %rdi
callq 0x32a0
movq 0x48(%r14), %rdi
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x19a7a
xorl %ecx, %ecx
xorl %r14d, %r14d
movq 0x10(%rax), %rdx
cmpq %rbx, %rdx
je 0x19a6f
movq 0x20(%rdx), %rsi
cmpq $0x0, (%rsi)
je 0x19a... | /ForestDB-KVStore[P]forestdb/src/wal.cc | 0x19a17 | ForestDB-KVStore[P]forestdb[P]build_O3[P]tests[P]unit[P]btreeblock_test |
SuiteSessionIDTests::TestfromString_SessionStringMissingRightArrow_StringNotPopulated::TestfromString_SessionStringMissingRightArrow_StringNotPopulated() | TEST(fromString_SessionStringMissingRightArrow_StringNotPopulated)
{
std::string sessionString = "FIX.4.2:SENDER<-TARGET";
SessionID object;
object.fromString(sessionString);
CHECK_EQUAL("", object.getBeginString());
CHECK_EQUAL("", object.getSenderCompID());
CHECK_EQUAL("", object.getTargetCompID());
} | pushq %rbx
movq %rdi, %rbx
leaq 0x41aa7(%rip), %rsi # 0x1b82fe
leaq 0x41a32(%rip), %rdx # 0x1b8290
leaq 0x419be(%rip), %rcx # 0x1b8223
movl $0x9d, %r8d
callq 0x19aad6
leaq 0xa85d9(%rip), %rax # 0x21ee50
movq %rax, (%rbx)
popq %rbx
retq
| /marlowa[P]quickfix/src/C++/test/SessionIDTestCase.cpp | 0x17684c | marlowa[P]quickfix[P]build_O2[P]src[P]ut |
sam_bam_cram_readrec | static int sam_bam_cram_readrec(BGZF *bgzfp, void *fpv, void *bv, int *tid, int *beg, int *end)
{
htsFile *fp = fpv;
bam1_t *b = bv;
switch (fp->format.format) {
case bam: return bam_read1(bgzfp, b);
case cram: return cram_get_bam_seq(fp->fp.cram, &b);
default:
// TODO Need headers av... | pushq %rax
movq %rdx, (%rsp)
movl 0x44(%rsi), %eax
cmpl $0x6, %eax
je 0x39043
cmpl $0x4, %eax
jne 0x39051
movq %rdx, %rsi
popq %rax
jmp 0x387b2
movq 0x38(%rsi), %rdi
movq %rsp, %rsi
callq 0x468f4
popq %rcx
retq
callq 0xb729
| /gatoravi[P]bam-parser-tutorial/htslib/sam.c | 0x39028 | gatoravi[P]bam-parser-tutorial[P]build_O1[P]vcf-parser |
tsl::detail_robin_hash::robin_hash<std::pair<unsigned long, ImputedData<int, double>>, tsl::robin_map<unsigned long, ImputedData<int, double>, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long, ImputedData<int, double>>>, false, tsl::rh::power_of_two_growth_policy<2ul>>::Key... | void insert_value_on_rehash(std::size_t ibucket,
distance_type dist_from_ideal_bucket,
truncated_hash_type hash, value_type&& value) {
while (true) {
if (dist_from_ideal_bucket >
m_buckets[ibucket].dist_from_ideal_bucket()) {
if (m_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%r8), %r13
movq 0x20(%r12), %rbp
movq %r15, %rax
shlq $0x8, %rax
movzwl (%rbp,%rax), %ecx
cmpw %cx, %bx
jle 0x61615
addq %rax, %rbp
cmpw $-0x1, %cx
je 0x61620
movq (%r14),... | /david-cortes[P]isotree/src/robinmap/include/tsl/robin_hash.h | 0x615b8 | david-cortes[P]isotree[P]build_O3[P]libisotree.so.0.6.1 |
GlobOpt::ArrayLowerBoundCheckHoistInfo::SetLoop(Loop*, int, bool) | void GlobOpt::ArrayLowerBoundCheckHoistInfo::SetLoop(
::Loop *const loop,
const int indexConstantValue,
const bool isLoopCountBasedBound)
{
Assert(!CompatibleBoundCheckBlock());
Assert(loop);
this->loop = loop;
indexSym = nullptr;
offset = 0;
indexValue = nullptr;
indexConstantB... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
callq 0x38df3c
testq %rax, %rax
je 0x3a7bbd
leaq 0x110274e(%rip), %rax # 0x14aa2bc
incl (%rax)
callq 0x59cc66
leaq 0x10b82cb(%rip), %rdi # 0x145fe48
callq 0x1... | /chakra-core[P]ChakraCore/lib/Backend/GlobOptIntBounds.cpp | 0x3a7b44 | chakra-core[P]ChakraCore[P]build_O1[P]bin[P]ChakraCore[P]libChakraCore.so |
c4::yml::Tree::_relocate(c4::basic_substring<char>) | void Tree::_relocate(substr next_arena)
{
_RYML_CB_ASSERT(m_callbacks, next_arena.not_empty());
_RYML_CB_ASSERT(m_callbacks, next_arena.len >= m_arena.len);
memcpy(next_arena.str, m_arena.str, m_arena_pos);
for(NodeData *C4_RESTRICT n = m_buf, *e = m_buf + m_cap; n != e; ++n)
{
if(in_arena(n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r15
movq %rdx, 0x38(%rsp)
testq %rdx, %rdx
setne %al
movq %rsi, 0x30(%rsp)
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0xb962d
movaps 0x5617f(%rip), %xmm0 # 0x10f700
movaps %xmm0, 0xb0(%rsp)
movaps 0x56160(%rip), %xmm0 ... | /google[P]jsonnet/third_party/rapidyaml/ryml_all.hpp | 0xb9548 | google[P]jsonnet[P]build_O3[P]jsonnetfmt |
draco::PlyPropertyReader<float>::PlyPropertyReader(draco::PlyProperty const*) | explicit PlyPropertyReader(const PlyProperty *property)
: property_(property) {
// Find the suitable function for converting values.
switch (property->data_type()) {
case DT_UINT8:
convert_value_func_ = [=](int val_id) {
return this->ConvertValue<uint8_t>(val_id);
};
... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x36570
movq 0x58(%rsp), %rdi
callq 0x2c490
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x9, %eax
ja 0x2cce3
movq 0x10(%rsp), %rax
leaq 0xe4a57(... | /atteneder[P]draco/src/draco/io/ply_property_reader.h | 0x2cbb0 | atteneder[P]draco[P]build_O0[P]draco_decoder-1.5.6 |
doctest::(anonymous namespace)::operator<<(std::ostream&, doctest::(anonymous namespace)::XmlEncode const&) | std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
xmlEncode.encodeTo( os );
return os;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x9734(%rip), %r12 # 0x15ef8
pushq $0x22
popq %r13
leaq 0x9719(%rip), %r15 # 0x15ee8
movq 0x8(%r14), %rcx
cmpq %rcx, %rbp
jae 0xc9e6
movq (%r14), %rax
movzbl (%rax,%rbp), %esi
cmpl... | /ad65537[P]moptional/include/doctest.h | 0xc7aa | ad65537[P]moptional[P]build_O2[P]tests[P]simple |
insn_find | unsigned short insn_find(insn_map *insns, unsigned int max, unsigned int id, unsigned short **cache)
{
if (id > insns[max - 1].id)
return 0;
if (*cache == NULL)
*cache = make_id2insn(insns, max);
return (*cache)[id];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %esi, %r15d
leal -0x1(%r15), %eax
imulq $0x2e, %rax, %rax
movzwl (%rdi,%rax), %ecx
cmpl %edx, %ecx
jae 0x47636
xorl %eax, %eax
jmp 0x47684
movl %edx, %ebx
movq (%r14), %rax
testq %rax, %rax
jne 0x4767e
movq %rdi, %r12
leaq 0x14ca66(%rip), %rax ... | /sidneyp[P]capstone-tricore/utils.c | 0x47614 | sidneyp[P]capstone-tricore[P]build_O3[P]test |
void Eigen::internal::call_assignment_no_alias<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Transpose<Eigen::CwiseUnaryOp<double (*)(double), Eigen::Matrix<double, -1, -1, 0, -1, -1> const> const... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
{
enum {
NeedToTranspose = ( (int(Dst::RowsAtCompileTime) == 1 && int(Src::ColsAtCompileTime) == 1)
|| (int(Dst::ColsAtCompileTime) == 1 && int(Src::RowsAtCompileTime) == 1)
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x61d60
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h | 0x61d20 | haukri[P]MasterProject[P]build_O0[P]Test[P]Latency_Coding_Lowpass_Example_Results |
Catch::TestSpecParser::isControlChar(char) const | bool TestSpecParser::isControlChar( char c ) const {
switch( m_mode ) {
default:
return false;
case None:
return c == '~';
case Name:
return c == '[';
case EscapedName:
return true;
case Q... | movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x8996b
leaq 0x2d81f(%rip), %rcx # 0xb7160
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x7e, %sil
jmp 0x89967
movb $0x1, %al
retq
cmpb $0x22, %sil
jmp 0x89967
addb $-0x5b, %sil
testb $-0x3, %sil
jmp 0x89967
cmpb $0x5b, %sil
sete %al
retq
xorl %eax, %eax
retq
| /alecthomas[P]entityx/entityx/3rdparty/catch.hpp | 0x89932 | alecthomas[P]entityx[P]build_O2[P]benchmarks_test |
void slang::ast::ASTVisitor<no_old_always_syntax::MainVisitor, true, true, false, false>::visitDefault<slang::ast::StrongWeakAssertionExpr>(slang::ast::StrongWeakAssertionExpr const&) | void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = d... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x16ca80
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h | 0x16ca50 | MikePopoloski[P]slang[P]build_O0[P]bin[P]tidy_unittests |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>> nlohmann::basic_json<std::map, ... | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
}
IteratorType result = end();
switch ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq %rsi, (%rdx)
jne 0x1d6b7
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
callq 0x1da08
... | /coin-au-carre[P]slacking/include/slacking/json.hpp | 0x1d5b2 | coin-au-carre[P]slacking[P]build_O3[P]examples[P]02-basic |
constructor_metadata | value constructor_metadata(constructor ctor)
{
value vi, args, sig;
value *sig_map;
/* Create return array */
vi = constructor_metadata_visibility(ctor);
if (vi == NULL)
{
return NULL;
}
/* Create arguments map */
args = constructor_metadata_args(ctor);
if (args == NULL)
{
value_type_destroy(vi);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r13
movl (%rdi), %edi
callq 0x5120
testq %rax, %rax
je 0x6f59
movq %rax, %rbx
movq 0x10(%r13), %rsi
xorl %edi, %edi
callq 0x57e0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x6f51
movq %rbx, 0x8(%rsp)
cmpq $0x0, 0x10(%r13)
je 0... | /metacall[P]core/source/reflect/source/reflect_constructor.c | 0x6d9c | metacall[P]core[P]build_O2[P]libreflect.so |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.