name string | code string | asm string | file string |
|---|---|---|---|
uhash_close_63 | U_CAPI void U_EXPORT2
uhash_close(UHashtable *hash) {
if (hash == NULL) {
return;
}
if (hash->elements != NULL) {
if (hash->keyDeleter != NULL || hash->valueDeleter != NULL) {
int32_t pos=UHASH_FIRST;
UHashElement *e;
while ((e = (UHashElement*) uhash_next... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b48c3
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1b48b0
cmpq $0x0, 0x20(%rbx)
jne 0x1b4849
cmpq $0x0, 0x28(%rbx)
je 0x1b48a4
movq $-0x1, %r14
movslq 0x34(%rbx), %rax
movslq %r14d, %r14
movq (%rbx), %rdi
leaq (%r14,%r14,2), %rcx
leaq (%rdi,%rcx,8), %rc... | /hunter-packages[P]icu/source/common/uhash.cpp |
icu_63::UnicodeSet::containsAll(icu_63::UnicodeSet const&) const | UBool UnicodeSet::containsAll(const UnicodeSet& c) const {
// The specified set is a subset if all of its pairs are contained in
// this set. It's possible to code this more efficiently in terms of
// direct manipulation of the inversion lists if the need arises.
int32_t n = c.getRangeCount();
for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rsi), %r15d
cmpl $0x2, %r15d
jl 0x1c19f0
shrl %r15d
movq 0x18(%rbx), %r12
movq 0x18(%r14), %r13
xorl %ebp, %ebp
movl (%r12,%rbp,8), %esi
movq %r14, %rdi
callq 0x1c1880
testb $0x1, %al
je 0x1c1a04
cltq... | /hunter-packages[P]icu/source/common/uniset.cpp |
ures_swap_63 | U_CAPI int32_t U_EXPORT2
ures_swap(const UDataSwapper *ds,
const void *inData, int32_t length, void *outData,
UErrorCode *pErrorCode) {
const UDataInfo *pInfo;
const Resource *inBundle;
Resource rootRes;
int32_t headerSize, maxTableLength;
Row rows[STACK_ROW_CAPACITY];
int32... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd08, %rsp # imm = 0xD08
movq %r8, %rbx
movq %rcx, %r13
movl %edx, %r12d
movq %rsi, %rbp
movq %rdi, %r14
callq 0x1b3e50
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x1d2094
cmpl $0x0, (%rbx)
jg 0x1d2094
movzbl 0xc(%rbp), %edx
movl %edx, %ecx
... | /hunter-packages[P]icu/source/common/uresdata.cpp |
uset_addString_63 | U_CAPI void U_EXPORT2
uset_addString(USet* set, const UChar* str, int32_t strLen) {
// UnicodeString handles -1 for strLen
UnicodeString s(strLen<0, str, strLen);
((UnicodeSet*) set)->UnicodeSet::add(s);
} | pushq %rbx
subq $0x60, %rsp
movl %edx, %ecx
movq %rdi, %rbx
movl %edx, %eax
shrl $0x1f, %eax
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x1c8d3a
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c26d0
leaq 0x20(%rsp), %rdi
callq 0x1c95ec
ad... | /hunter-packages[P]icu/source/common/uset.cpp |
uset_containsString_63 | U_CAPI UBool U_EXPORT2
uset_containsString(const USet* set, const UChar* str, int32_t strLen) {
UnicodeString s(strLen==-1, str, strLen);
return ((const UnicodeSet*) set)->UnicodeSet::contains(s);
} | pushq %rbx
subq $0x60, %rsp
movl %edx, %ecx
movq %rdi, %rbx
xorl %eax, %eax
cmpl $-0x1, %edx
sete %al
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x1c8d3a
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c18f4
movl %eax, %ebx
leaq 0x20(%rsp... | /hunter-packages[P]icu/source/common/uset.cpp |
uset_getItem_63 | U_CAPI int32_t U_EXPORT2
uset_getItem(const USet* uset, int32_t itemIndex,
UChar32* start, UChar32* end,
UChar* str, int32_t strCapacity,
UErrorCode* ec) {
if (U_FAILURE(*ec)) return 0;
const UnicodeSet& set = *(const UnicodeSet*)uset;
int32_t rangeCount;
if (item... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x60(%rsp), %rax
xorl %ebx, %ebx
cmpl $0x0, (%rax)
jg 0x1d314e
movl %esi, %ebp
testl %esi, %esi
js 0x1d30f5
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %r12
movq %r8, 0x10(%rsp)
movl %r9d, 0x4(%rsp)
callq 0x1c17f8
movl %ebp, %r14d
mo... | /hunter-packages[P]icu/source/common/uset.cpp |
uset_serializedContains_63 | U_CAPI UBool U_EXPORT2
uset_serializedContains(const USerializedSet* set, UChar32 c) {
const uint16_t* array;
if(set==NULL || (uint32_t)c>0x10ffff) {
return FALSE;
}
array=set->array;
if(c<=0xffff) {
/* find c in the BMP part */
int32_t lo = 0;
int32_t hi = set->bmp... | testq %rdi, %rdi
sete %al
cmpl $0x110000, %esi # imm = 0x110000
setae %cl
orb %al, %cl
je 0x1d3294
xorl %eax, %eax
retq
movq (%rdi), %rcx
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x1d32f0
movzwl (%rcx), %edx
xorl %eax, %eax
cmpl %esi, %edx
ja 0x1d3392
movslq 0x8(%rdi), %rax
movzwl -0x2(%rcx,%rax,2), %edx
... | /hunter-packages[P]icu/source/common/uset.cpp |
uset_openPatternOptions_63 | U_CAPI USet* U_EXPORT2
uset_openPatternOptions(const UChar* pattern, int32_t patternLength,
uint32_t options,
UErrorCode* ec)
{
UnicodeString pat(patternLength==-1, pattern, patternLength);
UnicodeSet* set = new UnicodeSet(pat, options, NULL, *ec);
/* test for NULL */
i... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %ecx
xorl %esi, %esi
cmpl $-0x1, %ecx
sete %sil
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x20(%rsp), %rdi
callq 0x1c8d3a
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x58, %edi
callq 0x1cc4a8
testq %rax, %rax
je 0x1d35a5... | /hunter-packages[P]icu/source/common/uset_props.cpp |
uset_resemblesPattern_63 | U_CAPI UBool U_EXPORT2
uset_resemblesPattern(const UChar *pattern, int32_t patternLength,
int32_t pos) {
UnicodeString pat(pattern, patternLength);
return ((pos+1) < pat.length() &&
pat.charAt(pos) == (UChar)91/*[*/) ||
UnicodeSet::resemblesPattern(pat, pos);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movl %esi, %edx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x1c8cfe
movswl 0x8(%r14), %eax
testw %ax, %ax
jns 0x1d375f
movl 0xc(%rsp), %ecx
jmp 0x1d3764
movl %eax, %ecx
sarl $0x5, %ecx
leal 0x1(%rbx), %edx
cmpl %ecx, %edx
setge %dl
cmpl %ebx, ... | /hunter-packages[P]icu/source/common/uset_props.cpp |
icu_63::UnicodeSetIterator::reset() | void UnicodeSetIterator::reset() {
if (set == NULL) {
// Set up indices to empty iteration
endRange = -1;
stringCount = 0;
} else {
endRange = set->getRangeCount() - 1;
stringCount = set->strings->size();
}
range = 0;
endElement = -1;
nextElement = 0; ... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1d393c
callq 0x1c17f8
leal -0x1(%rax), %ecx
movq 0x18(%rbx), %rdx
movq 0x40(%rdx), %rdx
movl 0x8(%rdx), %edx
movl %ecx, 0x20(%rbx)
movl %edx, 0x34(%rbx)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %rcx, 0x24(%rbx)
movl $0x0, 0x2c... | /hunter-packages[P]icu/source/common/usetiter.cpp |
icu_63::UnicodeSetIterator::nextRange() | UBool UnicodeSetIterator::nextRange() {
string = NULL;
if (nextElement <= endElement) {
codepointEnd = endElement;
codepoint = nextElement;
nextElement = endElement+1;
return TRUE;
}
if (range < endRange) {
loadRange(++range);
codepointEnd = endElement;
... | pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x10(%rdi)
movl 0x28(%rdi), %eax
movl 0x2c(%rdi), %ecx
cmpl %eax, %ecx
jle 0x1d3a4a
movl 0x24(%rbx), %esi
cmpl 0x20(%rbx), %esi
jge 0x1d3a59
incl %esi
movl %esi, 0x24(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl 0x28(%rbx), %eax
movl 0x2c(%rbx), %ecx
movl %eax, 0x... | /hunter-packages[P]icu/source/common/usetiter.cpp |
icu_63::WholeStringBreakIterator::getText() const | CharacterIterator &WholeStringBreakIterator::getText() const {
U_ASSERT(FALSE); // really should not be called
// Returns a null reference.
// Otherwise we would have to define a dummy CharacterIterator,
// and either have it as a field and const_cast it to a non-const reference,
// or have it via ... | xorl %eax, %eax
retq
nop
| /hunter-packages[P]icu/source/common/ustr_titlecase_brkiter.cpp |
icu_63::CaseMap::toTitle(char const*, unsigned int, icu_63::BreakIterator*, char16_t const*, int, char16_t*, int, icu_63::Edits*, UErrorCode&) | int32_t CaseMap::toTitle(
const char *locale, uint32_t options, BreakIterator *iter,
const UChar *src, int32_t srcLength,
UChar *dest, int32_t destCapacity, Edits *edits,
UErrorCode &errorCode) {
LocalPointer<BreakIterator> ownedIter;
iter = ustrcase_getTitleBreakIterator(nullptr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %rcx
movl %esi, %ebp
movq %rdi, %r13
movq 0xb0(%rsp), %r9
leaq 0x8(%rsp), %r8
movq $0x0, (%r8)
xorl %r15d, %r15d
xorl %edi, %edi
movq %r13, %rsi
movl %ebp, %edx
callq 0x1d3d... | /hunter-packages[P]icu/source/common/ustr_titlecase_brkiter.cpp |
ustrcase_internalToTitle_63 | U_CFUNC int32_t U_CALLCONV
ustrcase_internalToTitle(int32_t caseLocale, uint32_t options, BreakIterator *iter,
UChar *dest, int32_t destCapacity,
const UChar *src, int32_t srcLength,
icu::Edits *edits,
UErrorCode &errorC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq 0xb0(%rsp), %rdx
xorl %eax, %eax
cmpl $0x0, (%rdx)
jg 0x1d46b0
movq %rsi, 0x10(%rsp)
notl %esi
testl $0x600, %esi # imm = 0x600
jne 0x1d4202
movl $0x1, (%rdx)
jmp 0x1d46b0
movq %r9, %r14
movl %edi, 0x28(%r... | /hunter-packages[P]icu/source/common/ustrcase.cpp |
icu_63::(anonymous namespace)::appendResult(char16_t*, int, int, int, char16_t const*, int, unsigned int, icu_63::Edits*) | inline int32_t
appendResult(UChar *dest, int32_t destIndex, int32_t destCapacity,
int32_t result, const UChar *s,
int32_t cpLength, uint32_t options, icu::Edits *edits) {
UChar32 c;
int32_t length;
/* decode the result */
if(result<0) {
/* (not) original code point */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movq %r8, (%rsp)
movl %ecx, %r14d
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r12
movq 0x48(%rsp), %rdi
testl %ecx, %ecx
js 0x1d4812
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpl $0x20, %r14d
jb 0x1d4869
cmpl %ebp, %ebx... | /hunter-packages[P]icu/source/common/ustrcase.cpp |
icu_63::GreekUpper::isFollowedByCasedLetter(char16_t const*, int, int) | UBool isFollowedByCasedLetter(const UChar *s, int32_t i, int32_t length) {
while (i < length) {
UChar32 c;
U16_NEXT(s, i, length, c);
int32_t type = ucase_getTypeOrIgnorable(c);
if ((type & UCASE_IGNORABLE) != 0) {
// Case-ignorable, continue with the loop.
} else... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
cmpl %ebx, %esi
jge 0x1d4e76
leal 0x1(%rsi), %ebp
movslq %esi, %rax
movzwl (%r14,%rax,2), %edi
movl %edi, %eax
andl $0xfc00, %eax # imm = 0xFC00
cmpl $0xd800, %eax # imm = 0xD800
setne %al
cmpl %ebx, %ebp
sete %cl
orb %al, %cl
jne 0x1d... | /hunter-packages[P]icu/source/common/ustrcase.cpp |
icu_63::enumNames(icu_63::UCharNames*, int, int, signed char (*)(void*, int, UCharNameChoice, char const*, int), void*, UCharNameChoice) | static UBool
enumNames(UCharNames *names,
UChar32 start, UChar32 limit,
UEnumCharNamesFn *fn, void *context,
UCharNameChoice nameChoice) {
uint16_t startGroupMSB, endGroupMSB, groupCount;
const uint16_t *group, *groupLimit;
startGroupMSB=(uint16_t)(start>>GROUP_SHIFT);
end... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r14d
movq %r8, 0x18(%rsp)
movq %rcx, 0x30(%rsp)
movl %edx, %ebx
movl %esi, %r13d
movl %esi, %r12d
shrl $0x5, %r12d
movq %rdi, 0x20(%rsp)
callq 0x1f27fa
movq %rax, %rbp
movzwl %r12w, %r9d
movzwl (%rax), %r15d
cmpl %r15d, %r9d
... | /hunter-packages[P]icu/source/common/unames.cpp |
u_enumCharNames_63 | U_CAPI void U_EXPORT2
u_enumCharNames(UChar32 start, UChar32 limit,
UEnumCharNamesFn *fn,
void *context,
UCharNameChoice nameChoice,
UErrorCode *pErrorCode) {
AlgorithmicRange *algRange;
uint32_t *p;
uint32_t i;
if(pErrorCode==NULL || U_FA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %r9, %r9
je 0x1f15c5
cmpl $0x0, (%r9)
jg 0x1f15c5
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
cmpl $0x4, %r8d
setl %al
testq %rdx, %rdx
setne %cl
testb %al, %cl
jne 0x1f14e9
movl $0x1, (%r9)
jmp 0x1f15c5
movl %edi, %r12d
movl $0x1100... | /hunter-packages[P]icu/source/common/unames.cpp |
icu_63::enumAlgNames(icu_63::AlgorithmicRange*, int, int, signed char (*)(void*, int, UCharNameChoice, char const*, int), void*, UCharNameChoice) | static UBool
enumAlgNames(AlgorithmicRange *range,
UChar32 start, UChar32 limit,
UEnumCharNamesFn *fn, void *context,
UCharNameChoice nameChoice) {
char buffer[200];
uint16_t length;
if(nameChoice!=U_UNICODE_CHAR_NAME && nameChoice!=U_EXTENDED_CHAR_NAME) {
ret... | testl $0xfffffffd, %r9d # imm = 0xFFFFFFFD
je 0x1f1603
movb $0x1, %al
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl %r9d, %ebx
movq %r8, %r15
movq %rcx, %r14
movl %edx, %r13d
movl %esi, %r12d
movzbl 0x8(%rdi), %eax
cmpl $0x1, %eax
je 0x1f170... | /hunter-packages[P]icu/source/common/unames.cpp |
utrie_unserialize_63 | U_CAPI int32_t U_EXPORT2
utrie_unserialize(UTrie *trie, const void *data, int32_t length, UErrorCode *pErrorCode) {
const UTrieHeader *header;
const uint16_t *p16;
uint32_t options;
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return -1;
}
/* enough data for a trie header? */
i... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x1f498e
cmpl $0x0, (%rcx)
jle 0x1f498f
retq
cmpl $0xf, %edx
jle 0x1f49d1
cmpl $0x54726965, (%rsi) # imm = 0x54726965
jne 0x1f49d1
movl 0x4(%rsi), %r10d
cmpb $0x25, %r10b
jne 0x1f49d1
movl %r10d, %r8d
shrl $0x9, %r8d
andb $0x1, %r8b
movb %r8b, 0x24... | /hunter-packages[P]icu/source/common/utrie.cpp |
ref_geom_edge_tec_zone | REF_FCN REF_STATUS ref_geom_edge_tec_zone(REF_GRID ref_grid, REF_INT id,
FILE *file) {
REF_NODE ref_node = ref_grid_node(ref_grid);
REF_CELL ref_cell = ref_grid_edg(ref_grid);
REF_GEOM ref_geom = ref_grid_geom(ref_grid);
REF_DICT ref_dict;
REF_INT geom, cell, nodes[RE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %r12
movl %esi, %ebp
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %r15
movq 0x98(%rdi), %rbx
leaq 0x20(%rsp), %rdi
callq 0xe1a90
testl %eax, %eax
je 0x45589
movl %eax, %r14d
leaq 0xbcab4(%rip), %rdi # 0x... | /nasa[P]refine/src/ref_geom.c |
ref_geom_ghost | REF_FCN REF_STATUS ref_geom_ghost(REF_GEOM ref_geom, REF_NODE ref_node) {
REF_MPI ref_mpi = ref_node_mpi(ref_node);
REF_INT *a_nnode, *b_nnode;
REF_INT a_nnode_total, b_nnode_total;
REF_GLOB *a_global, *b_global;
REF_INT *a_part, *b_part;
REF_INT *a_ngeom, *b_ngeom;
REF_INT a_ngeom_total, b_ngeom_total;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x50(%rsi), %rax
movslq (%rax), %r12
xorl %ebp, %ebp
cmpq $0x2, %r12
jl 0x48b3a
movq %rsi, %r15
movq %rdi, %r13
movq %rax, 0x10(%rsp)
leaq (,%r12,4), %rbp
movq %rbp, %rdi
callq 0xd230
testq %rax, %rax
je 0x4895f
movq %rax, %rbx
xorl... | /nasa[P]refine/src/ref_geom.c |
ref_geom_bary3 | REF_FCN REF_STATUS ref_geom_bary3(REF_GEOM ref_geom, REF_INT *nodes,
REF_DBL *uv, REF_DBL *bary) {
REF_DBL uv0[2], uv1[2], uv2[2];
REF_INT sens;
REF_DBL total;
REF_INT geom0, geom1, geom2;
RSS(ref_geom_cell_tuv(ref_geom, nodes[0], nodes, REF_GEOM_FACE, uv0, &sens),
"uv0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl (%rsi), %esi
pushq $0x2
popq %rcx
leaq 0x40(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %r12, %rdx
callq 0x3a4b0
testl %eax, %eax
je 0x49979
movl %eax, %ebp
leaq 0xb86aa(%rip),... | /nasa[P]refine/src/ref_geom.c |
ref_grid_parse_coordinate_system | REF_FCN REF_STATUS ref_grid_parse_coordinate_system(
REF_GRID ref_grid, const char *coordinate_system) {
ref_grid_coordinate_system(ref_grid) = REF_GRID_COORDSYS_LAST;
if (0 == strcmp("xByUzL", coordinate_system))
ref_grid_coordinate_system(ref_grid) = REF_GRID_XBYUZL;
if (0 == strcmp("xByRzU", coordinate... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3, 0xc8(%rdi)
leaq 0xb7554(%rip), %rdi # 0x104926
callq 0xd1d0
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal 0x1(,%rcx,2), %ebp
movl %ebp, 0xc8(%rbx)
leaq 0xb7562(%rip), %rdi # 0x104954
movq %r14, %rsi
callq 0xd1d0
testl %eax, %eax
cmove... | /nasa[P]refine/src/ref_grid.c |
ref_node_ghost_dbl | REF_FCN REF_STATUS ref_node_ghost_dbl(REF_NODE ref_node, REF_DBL *vector,
REF_INT ldim) {
REF_MPI ref_mpi = ref_node_mpi(ref_node);
REF_INT *a_size, *b_size;
REF_INT a_total, b_total;
REF_GLOB *a_global, *b_global;
REF_INT part, node;
REF_INT *a_next;
REF_DBL *a_vecto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x50(%rdi), %r13
movslq (%r13), %rbp
xorl %eax, %eax
cmpq $0x2, %rbp
jl 0x87309
movl %edx, %r12d
movq %rdi, %r15
movq %rsi, 0x48(%rsp)
leaq (,%rbp,4), %r14
movq %r14, %rdi
callq 0xd230
testq %rax, %rax
je 0x872bb
movq %rax, %rbx
xor... | /nasa[P]refine/src/ref_node.c |
GA_Set_chunk64 | void GA_Set_chunk64(int g_a, int64_t chunk[])
{
Integer aa, *ptr, ndim;
Integer _ga_work[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
if(!chunk)ptr=(Integer*)0;
else {
COPYC2F(chunk,_ga_work, ndim);
ptr = _ga_work;
}
wnga_set_chunk(aa, ptr);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x80ca7
testq %r14, %r14
je 0x201f4
xorl %ecx, %ecx
testq %rax, %rax
movl $0x0, %edx
cmovgq %rax, %rdx
leaq (%rsp,%rax,8), %rax
addq $-0x8, %rax
movq %rsp, %rsi
cmpq %rcx, %rdx
je 0x201f6
movq (%r14,%rcx,8), %rdi
movq %rdi, (... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Get64 | void NGA_Get64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ndim);
COPYC2F(ld,_ga_work, ndim-1);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movslq %edi, %r14
movq %r14, %rdi
callq 0x84770
xorl %edx, %edx
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
leaq (%rsp,%rax,8), %rsi
addq $0x78, %rsi
cmpq %rdx, %rcx
je 0x21cf7
m... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_NbPut64 | void NGA_NbPut64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[],
ga_nbhdl_t* nbhandle)
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movslq %edi, %r15
movq %r15, %rdi
callq 0x84770
xorl %edx, %edx
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
leaq (%rsp,%rax,8), %rsi
addq $0x78, %rsi
cm... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Strided_put64 | void NGA_Strided_put64(int g_a, int64_t lo[], int64_t hi[], int64_t skip[],
void* buf, int64_t ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_skip[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, nd... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movslq %edi, %r14
movq %r14, %rdi
callq 0x84770
xorl %edx, %edx
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
leaq (%rsp,%rax,8), %rsi
addq $0xb8, %rsi
cm... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Periodic_put | void NGA_Periodic_put(int g_a, int lo[], int hi[], void* buf, int ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ndim);
COPYC2F(ld,_ga_work, ndim-1);
w... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movslq %edi, %r14
movq %r14, %rdi
callq 0x84770
xorl %edx, %edx
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
leaq (%rsp,%rax,8), %rsi
addq $0x88, %rsi
cmpq %rdx, %rcx
je 0x22e02
m... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Periodic_acc | void NGA_Periodic_acc(int g_a, int lo[], int hi[], void* buf,int ld[], void* alpha)
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ndim);
COPYC2F(ld,_ga_work, nd... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movslq %edi, %r15
movq %r15, %rdi
callq 0x84770
xorl %edx, %edx
testq %rax, %rax
movl $0x0, %ecx
cmovgq %rax, %rcx
leaq (%rsp,%rax,8), %rsi
addq $0x88, %rsi
cm... | /GlobalArrays[P]ga/global/src/capi.c |
pnga_sprs_array_dnssprs_multiply | Integer pnga_sprs_array_dnssprs_multiply(Integer g_a, Integer s_b, Integer trans)
{
Integer lcnt;
Integer icnt;
Integer hdl_a = g_a+GA_OFFSET;
Integer hdl_b = s_b+GA_OFFSET;
Integer hdl_c;
int local_sync_begin,local_sync_end;
Integer elemsize;
Integer idim, jdim;
Integer i, j, k, l, m, n, nn;
Intege... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, 0x18(%rsp)
movl $0x3e8, %eax # imm = 0x3E8
movq %rdi, 0x160(%rsp)
leaq (%rdi,%rax), %rbx
movq %rsi, 0x140(%rsp)
addq %rsi, %rax
leaq 0xf87be1(%rip), %r13 # 0xfeee10
movq (%r13), %rcx
imu... | /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_count_sketch | Integer pnga_sprs_array_count_sketch(Integer s_a, Integer size_k,
Integer *g_k, Integer *g_w, Integer trans)
{
Integer i, ii, j, jj, n, hdl, g_a;
Integer nrows;
hdl = s_a + GA_OFFSET;
Integer *klabels;
void *kweights;
Integer idim, jdim;
Integer dims[2];
Integer one = 1;
Integer two = 2;
Integer... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r8, 0xb0(%rsp)
movq %rcx, 0x80(%rsp)
movq %rdx, 0x58(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x3e8(%rdi), %rcx
leaq 0xf85a1a(%rip), %rax # 0xfeee10
movq (%rax), %rax
imulq $0xc8, %rcx, %rcx
cmpq %rsi... | /GlobalArrays[P]ga/global/src/sketch.c |
mh2ad | private Boolean mh2ad(memhandle, adout, location, caller)
Integer memhandle; /* the handle to verify and convert */
AD **adout; /* RETURN: AD corresponding to memhandle */
BlockLocation location; /* where AD must reside */
char *caller; /* name of calling routine */
{
AD ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movl %edx, %ecx
andb $0xf, %cl
movb $0xd, %bpl
shrb %cl, %bpl
movb $0xb, %r13b
shrb %cl, %r13b
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movb $0x7, %r12b
shrb %cl, %r12b
movb $0xe, %bl
shrb %cl, %bl
movq %r15, %rsi
callq 0x78... | /GlobalArrays[P]ga/ma/ma.c |
MA_get_mbase | public Pointer MA_get_mbase(Integer datatype) /* to get base address of */
{
#ifdef STATS
ma_stats.calls[(int)FID_MA_get_mbase]++;
#endif /* STATS */
/* preinitialize if necessary */
ma_preinitialize("MA_get_mbase");
/* verify datatype */
if (!mt_valid(datatype))
{
(void)sprintf(ma_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
incq 0xf77ec4(%rip) # 0xfeee98
leaq 0x539d7(%rip), %rdi # 0xca9b2
callq 0x77037
leaq -0x3e8(%r14), %rax
cmpq $0x11, %rax
jae 0x76ffe
leaq 0x7706c(%rip), %rax # 0xee060
movq -0x1f40(%rax,%r14,8), %rbx
jmp 0x7702e
leaq 0xf780cb(%rip), %r15 # 0xfef0d0
le... | /GlobalArrays[P]ga/ma/ma.c |
void iutest::TestEnv::ParseCommandLine<char>(int*, char**) | static void ParseCommandLine(int* pargc, CharType** argv)
{
if( argv == NULL )
{
return;
}
int argc = *pargc;
for( int i=0; i < argc; )
{
if( ParseCommandLineElem(argv[i]) )
{
--argc;
// 見つかった場合、オプショ... | testq %rsi, %rsi
je 0x1c434
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %ebp
xorl %r15d, %r15d
movl %r15d, %r15d
cmpl %ebp, %r15d
jge 0x1c428
movq (%r14,%r15,8), %rdi
callq 0x1daea
testb %al, %al
je 0x1c423
decl %ebp
movslq %ebp, %rax
movq %r15, %rcx
cmpq %rax, %r... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_env.hpp |
iutest::detail::ParamTestSuiteHolder::~ParamTestSuiteHolder() | ~ParamTestSuiteHolder()
{
// 解放
for( TestSuiteInfoContainer::const_iterator it=m_testsuite_infos.begin(), end=m_testsuite_infos.end(); it != end; ++it )
{
delete *it;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x1cb88
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1cb82
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1cb6f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1d452
nop
| /srz-zumix[P]iutest/include/internal/iutest_params_util.hpp |
iutest::internal::posix::FileSize(_IO_FILE*) | inline iu_uint_max_t FileSize(FILE* fp)
{
if( fp == NULL )
{
return 0;
}
#if IUTEST_HAS_FILE_STAT
StatStruct st;
if (Stat(fp, &st) == 0)
{
return static_cast<iu_uint_max_t>(st.st_size);
}
#endif
return FileSizeBySeekSet(fp);
} | testq %rdi, %rdi
je 0x1da3f
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq %rsp, %rsi
callq 0x1da50
testl %eax, %eax
je 0x1da42
movq %rbx, %rdi
callq 0x1da6a
jmp 0x1da47
xorl %eax, %eax
retq
movq 0x30(%rsp), %rax
addq $0x90, %rsp
popq %rbx
retq
| /srz-zumix[P]iutest/include/internal/iutest_port.hpp |
iutest::detail::iuOptionMessage::ShowHelp() | inline void iuOptionMessage::ShowHelp()
{
detail::iuConsole::color_output(detail::iuConsole::cyan,
"--------------------------------------------------\n"
"Name\n"
" iutest - iris unit test framework\n"
"--------------------------------------------------\n"
"Command Line Op... | leaq 0x892b(%rip), %rsi # 0x27bee
pushq $0x6
popq %rdi
xorl %eax, %eax
jmp 0x18be0
nop
| /srz-zumix[P]iutest/include/internal/iutest_option_message.hpp |
int iutest::detail::CountIf<iutest::TestInfo*, bool (*)(iutest::TestInfo const*)>(std::vector<iutest::TestInfo*, std::allocator<iutest::TestInfo*>> const&, bool (*)(iutest::TestInfo const*)) | int CountIf(const ::std::vector<T>& list, Fn f)
{
int count = 0;
for(typename ::std::vector<T>::const_iterator it = list.begin(), end = list.end(); it != end; ++it)
{
if(f(*it))
{
++count;
}
}
return count;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x201ac
movq (%r14), %rdi
callq *%rbx
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r14
jmp 0x20197
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq... | /srz-zumix[P]iutest/include/internal/../internal/iutest_list.hpp |
iutest::UnitTestImpl::ValidateTestPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static bool ValidateTestPropertyName(const ::std::string& name)
{
const char* ban[] = {
"name", "tests", "failures", "disabled", "skip", "errors", "time", "timestamp", "random_seed"
};
#if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
return TestProperty::ValidateName(name, ban)... | subq $0x48, %rsp
movq %rdi, %rax
leaq 0x12728(%rip), %rsi # 0x344d0
pushq $0x9
popq %rcx
movq %rsp, %rdx
movq %rdx, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
movq %rdx, %rsi
callq 0x22532
addq $0x48, %rsp
retq
| /srz-zumix[P]iutest/include/internal/iutest_core_impl.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::detail::ToHexString<unsigned int>(unsigned int) | inline ::std::string ToHexString(T value)
{
const size_t kN = sizeof(T)*2;
char buf[kN + 1] = {0};
for( size_t i=0; i < kN; ++i )
{
buf[i] = ToHex(static_cast<unsigned int>((value>>((kN-i-1)*4))));
}
buf[kN] = '\0';
return buf;
} | pushq %rbx
subq $0x20, %rsp
andq $0x0, 0x10(%rsp)
movq %rdi, %rbx
pushq $0x1c
popq %rcx
xorl %eax, %eax
cmpq $0x8, %rax
je 0x22512
movl %esi, %edx
shrl %cl, %edx
andl $0xf, %edx
leal 0x30(%rdx), %edi
leal 0x37(%rdx), %r8d
cmpl $0xa, %edx
movzbl %r8b, %edx
movzbl %dil, %edi
cmovael %edx, %edi
movb %dil, 0x10(%rsp,%rax)
... | /srz-zumix[P]iutest/include/internal/iutest_string.hpp |
RenX::LadderDatabase::~LadderDatabase() | RenX::LadderDatabase::~LadderDatabase() {
while (m_head != nullptr) {
m_end = m_head;
m_head = m_head->next;
delete m_end;
}
for (auto itr = g_ladder_databases.begin(); itr != g_ladder_databases.end(); ++itr) {
if (*itr == this) {
g_ladder_databases.erase(itr);
break;
}
}
if (RenX::default_ladder... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38448(%rip), %rax # 0x5cf90
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0x24b98
movq %r14, 0x58(%rbx)
movq 0x130(%r14), %rax
movq %rax, 0x50(%rbx)
movq 0x110(%r14), %rdi
leaq 0x120(%r14), %rax
cmpq %rax, %rdi
je 0x24b85
movq (%... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_LadderDatabase.cpp |
RenX::Plugin::~Plugin() | RenX::Plugin::~Plugin() {
auto& renx_plugins = RenX::getCore()->getPlugins();
for (auto itr = renx_plugins.begin(); itr != renx_plugins.end(); ++itr) {
if (*itr == this) {
RenX::getCore()->getPlugins().erase(itr);
break;
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3629d(%rip), %rax # 0x5cfa0
leaq 0x10(%rax), %rcx
movq %rcx, (%rdi)
addq $0x4f0, %rax # imm = 0x4F0
movq %rax, 0x8(%rdi)
callq 0x1bbc0
movq %rax, %rdi
callq 0x1bc90
movq (%rax), %rcx
movq 0x8(%rax), %rax
cmpq %rax, %rcx
je 0x26d79
leaq 0x8(%rcx), %r... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Plugin.cpp |
RenX::Server::connect() | bool RenX::Server::connect() {
m_lastAttempt = std::chrono::steady_clock::now();
if (m_sock.connect(m_hostname.c_str(), m_port, m_clientHostname.empty() ? nullptr : m_clientHostname.c_str()))
{
m_sock.setBlocking(false);
sendSocket(string_printf("a%.*s\n", m_pass.size(), m_pass.data()));
m_connected = true;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x1bf80
movq %rax, 0x138(%rbx)
leaq 0x260(%rbx), %r14
movq 0x2f0(%rbx), %rcx
movq 0x308(%rbx), %rsi
movzwl 0x2aa(%rbx), %edx
testq %rcx, %rcx
je 0x27433
movq 0x2e8(%rbx), %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x1b8a0
movl... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::sendAdminMessage(std::basic_string_view<char, std::char_traits<char>>) | int RenX::Server::sendAdminMessage(std::string_view message) {
return sendSocket("camsg "s + RenX::escapifyRCON(message) + '\n');
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movl $0x736d6163, (%r12) # imm = 0x736D6163
movw $0x2067, 0x4(%r12) # imm = 0x2067
movq $0x6, -0x8(%r12)
movb $0x0, 0x6(%r12)
leaq 0x20(%rsp), %rdi
callq 0x1bd40
movq 0x40(%rsp),... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::activePlayers(bool) const | std::vector<const RenX::PlayerInfo*> RenX::Server::activePlayers(bool includeBots) const {
std::vector<const RenX::PlayerInfo*> result;
result.reserve(players.size());
// Build list of active players
for (auto& player : players) {
// Filter teamless players and bots (if applicable)
if (player.team != TeamType:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rsi
callq 0x1c0f0
addq $0x10, %r14
movq (%r14), %r12
cmpq %r14, %r12
je 0x31da1
leaq 0x8(%rsp), %r15
cmpl $0x3, 0x108(%r... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::banCheck(RenX::PlayerInfo&) | void RenX::Server::banCheck(RenX::PlayerInfo &player) {
if ((player.exemption_flags & (RenX::ExemptionDatabase::Entry::FLAG_TYPE_BAN | RenX::ExemptionDatabase::Entry::FLAG_TYPE_KICK)) != 0) {
return;
}
uint32_t netmask;
RenX::BanDatabase::Entry* last_to_expire[7]; // TODO: what the fuck is this?
for (size_t in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
testb $0x6, 0xf6(%rsi)
je 0x32354
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, 0x48(%rsp)
movq 0x2ab65(%rip), %rax # ... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::fetchClientList() | bool RenX::Server::fetchClientList() {
m_lastClientListUpdate = std::chrono::steady_clock::now();
// TODO: remove all support for rconVersion < 4
if (m_rconVersion >= 4) {
return sendSocket("cclientvarlist KILLS DEATHS SCORE CREDITS CHARACTER VEHICLE PING ADMIN STEAM IP HWID PLAYERLOG\n"sv) > 0
&& sendSocket("c... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1bf80
movq %rax, 0x148(%rbx)
movl 0x120(%rbx), %ebp
callq 0x1bf80
leaq 0x260(%rbx), %r14
movq %rax, 0x160(%rbx)
cmpl $0x4, %ebp
jb 0x338b7
leaq 0x1b8af(%rip), %rdx # 0x4f14c
movl $0x5f, %esi
movq %r14, %rdi
callq 0x1c850
testl %eax, %eax... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::kill(int) | bool RenX::Server::kill(int id) {
return m_competitive == false && send(string_printf("kill pid%d", id)) > 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0xe9(%rdi)
je 0x33cea
xorl %ebx, %ebx
jmp 0x33d34
movl %esi, %edx
movq %rdi, %rbx
leaq 0x1b6c4(%rip), %rsi # 0x4f3ba
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x1c1c0
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x1b200
testl %eax, %... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::disarmC4(int) | bool RenX::Server::disarmC4(int id) {
return m_competitive == false && send(string_printf("disarmc4 pid%d", id)) > 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0xe9(%rdi)
je 0x33e1e
xorl %ebx, %ebx
jmp 0x33e68
movl %esi, %edx
movq %rdi, %rbx
leaq 0x1b5a8(%rip), %rsi # 0x4f3d2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x1c1c0
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x1b200
testl %eax, %... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::getPrefix() const | std::string_view RenX::Server::getPrefix() const {
static std::string parsed; // TODO: What the hell?
RenX::processTags(parsed = m_IRCPrefix, this);
return parsed;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x29efb(%rip), %al # 0x5e070
testb %al, %al
je 0x341b7
leaq 0x3a8(%rbx), %rsi
leaq 0x29ec9(%rip), %r14 # 0x5e050
movq %r14, %rdi
callq 0x1bc10
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1c660
movq 0x29ea8(%rip), ... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::removeCommand(RenX::GameCommand*) | bool RenX::Server::removeCommand(RenX::GameCommand *command) {
for (auto itr = m_commands.begin(); itr != m_commands.end(); ++itr) {
if (itr->get() == command) {
m_commands.erase(itr);
return true;
}
}
return false;
} | movq %rsi, %rax
movq 0x288(%rdi), %rsi
movq 0x290(%rdi), %rcx
cmpq %rcx, %rsi
je 0x346e8
pushq %rax
addq $0x288, %rdi # imm = 0x288
cmpq %rax, (%rsi)
je 0x346eb
addq $0x8, %rsi
cmpq %rcx, %rsi
jne 0x346d6
xorl %eax, %eax
jmp 0x346f2
xorl %eax, %eax
retq
callq 0x1b3a0
movb $0x1, %al
addq $0x8, %rsp
retq
nop
| /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::Server::setUUIDIfDifferent(RenX::PlayerInfo&, std::basic_string_view<char, std::char_traits<char>>) | bool RenX::Server::setUUIDIfDifferent(RenX::PlayerInfo &player, std::string_view uuid) {
if (player.uuid == uuid) {
return false;
}
setUUID(player, uuid);
return true;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq %rdx, 0x70(%rsi)
jne 0x34848
testq %r14, %r14
je 0x3485d
movq 0x68(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1bca0
testl %eax, %eax
je 0x3485d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, ... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
RenX::PlayerInfo::start_resolve_rdns() | void RenX::PlayerInfo::start_resolve_rdns() {
rdns_pending = true;
auto rdns_string = std::make_shared<std::string>();
m_rdns_ptr = rdns_string;
std::thread(resolve_rdns, ip, std::move(rdns_string)).detach();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb $0x1, 0x168(%rdi)
leaq 0x10(%rsp), %r14
movl $0x30, %edi
callq 0x1bc40
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
movq 0x27fab(%rip), %rcx # 0x5cf28
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x20(%rax), %rd... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Server.cpp |
auto jessilib::split<std::vector, std::basic_string_view<char, std::char_traits<char>>, char const*, char const*, char>(char const*, char const*, char) | constexpr auto split(ItrT begin, EndT end, ElementT in_delim) {
using split_defaults_type = split_defaults<ContainerT, ElementT, ContainerArgsT...>;
using member_type = typename split_defaults_type::member_type;
using container_type = typename split_defaults_type::container_type;
container_type result;
if (begin ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpq %rdx, %rsi
jae 0x37202
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
leaq 0x18(%rsp), %r13
movq %rsi, %r12
movq %rsi, %rax
cmpb %bpl, (%r15)
jne 0x371cb... | /JAJames[P]Jupiter-Bot/src/Jupiter/src/jessilib/src/common/../include/jessilib/split.hpp |
unsigned long jessilib::encode_codepoint_utf8<char, char*>(char*&, char32_t) | constexpr size_t encode_codepoint_utf8(T& out_destination, char32_t in_codepoint) {
if (in_codepoint > 0x10FFFF) {
return 0;
}
if (in_codepoint <= 0x007F) {
// 1-byte sequence (7 bits)
impl_unicode::append_helper(out_destination, static_cast<CharT>(in_codepoint));
return 1;
}
if (in_codepoint <= 0x07FF) ... | cmpl $0x10ffff, %esi # imm = 0x10FFFF
jbe 0x378c2
xorl %eax, %eax
retq
cmpl $0x7f, %esi
ja 0x378d7
movq (%rdi), %rax
movb %sil, (%rax)
movl $0x1, %eax
jmp 0x379a8
cmpl $0x7ff, %esi # imm = 0x7FF
ja 0x3790b
movl %esi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movq (%rdi), %rcx
movb %al, (%rcx)
movq (%rdi),... | /JAJames[P]Jupiter-Bot/src/Jupiter/src/jessilib/src/common/../include/jessilib/unicode_base.hpp |
auto jessilib::word_split_once<std::basic_string_view<char, std::char_traits<char>>, char const*, char const*, char const*, char const*>(char const*, char const*, char const*, char const*) | constexpr auto word_split_once(ItrT begin, EndT end, SpaceItrT in_whitespace_begin, SpaceEndT in_whitespace_end) {
static_assert(sizeof...(OptionalMemberT) <= 1, "Too many member types specified for OptionalMemberT");
using ElementT = std::remove_cvref_t<decltype(*begin)>;
using MemberT = std::tuple_element_t<0, std... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %r8, %rax
subq %rcx, %rax
cmpq $0x1, %rax
jne 0x38802
movsbl (%r12), %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ba70
jmp 0x38896
cmpq %rbx, %r14
jae ... | /JAJames[P]Jupiter-Bot/src/Jupiter/src/jessilib/src/common/../include/jessilib/word_split.hpp |
TagsImp::sanitizeTags(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void TagsImp::sanitizeTags(std::string& fmt)
{
/** Global tags */
RenX::replace_tag(fmt, this->dateTag, this->INTERNAL_DATE_TAG);
RenX::replace_tag(fmt, this->timeTag, this->INTERNAL_TIME_TAG);
/** Server tags */
RenX::replace_tag(fmt, this->rconVersionTag, this->INTERNAL_RCON_VERSION_TAG);
RenX::replace_tag(fmt... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1588(%rdi), %rdx
movq 0x1590(%rdi), %rsi
movq 0x48(%rdi), %r8
movq 0x50(%rdi), %rcx
movq %rbx, %rdi
callq 0x1bcd0
movq 0x15a8(%r14), %rdx
movq 0x15b0(%r14), %rsi
movq 0x68(%r14), %r8
movq 0x70(%r14), %rcx
movq %rbx, %rdi
callq 0x1bcd0
movq 0x15c8(%... | /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.Core/RenX_Tags.cpp |
curl_easy_cleanup | void curl_easy_cleanup(struct Curl_easy *data)
{
SIGPIPE_VARIABLE(pipe_st);
if(!data)
return;
sigpipe_ignore(data, &pipe_st);
Curl_close(data);
sigpipe_restore(&pipe_st);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x89e8
jmp 0x8a0d
movq -0x8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x8a20
movq -0x8(%rbp), %rdi
callq 0x379b0
leaq -0xa8(%rbp), %rdi
callq 0x8ae0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/easy.c |
dupset | static CURLcode dupset(struct Curl_easy *dst, struct Curl_easy *src)
{
CURLcode result = CURLE_OK;
enum dupstring i;
/* Copy src->set into dst->set first, then deal with the strings
afterwards */
dst->set = src->set;
Curl_mime_initpart(&dst->set.mimepost, dst);
/* clear all string pointers first */
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x668, %rdi # imm = 0x668
movq -0x18(%rbp), %rsi
addq $0x668, %rsi # imm = 0x668
movl $0x880, %edx # imm = 0x880
callq 0x76c0
movq -0x10(%rbp), %... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/easy.c |
easy_connection | static CURLcode easy_connection(struct Curl_easy *data,
curl_socket_t *sfd,
struct connectdata **connp)
{
if(data == NULL)
return CURLE_BAD_FUNCTION_ARGUMENT;
/* only allow these to be called on handles with CURLOPT_CONNECT_ONLY */
if(!data->set... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x95e4
movl $0x2b, -0x4(%rbp)
jmp 0x9657
movq -0x10(%rbp), %rax
movq 0xee0(%rax), %rax
shrq $0x25, %rax
andq $0x1, %rax
cmpl $0x0, %eax
jne 0x9617
movq -0x10(%rbp), %rdi
leaq 0x62a... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/easy.c |
curl_easy_upkeep | CURLcode curl_easy_upkeep(struct Curl_easy *data)
{
/* Verify that we got an easy handle we can work with. */
if(!GOOD_EASY_HANDLE(data))
return CURLE_BAD_FUNCTION_ARGUMENT;
if(data->multi_easy) {
/* Use the common function to keep connections alive. */
return Curl_upkeep(&data->multi_easy->conn_cach... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9743
movq -0x10(%rbp), %rax
cmpl $0xc0dedbad, 0x16d0(%rax) # imm = 0xC0DEDBAD
je 0x974c
movl $0x2b, -0x4(%rbp)
jmp 0x9781
movq -0x10(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x977a
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rdi
add... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/easy.c |
Curl_timeleft | timediff_t Curl_timeleft(struct Curl_easy *data,
struct curltime *nowp,
bool duringconnect)
{
int timeout_set = 0;
timediff_t timeout_ms = duringconnect?DEFAULT_CONNECT_TIMEOUT:0;
struct curltime now;
/* if a timeout is set, use the most restrictive one */
i... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0x493e0, %ecx # imm = 0x493E0
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x10... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/connect.c |
trynextip | static CURLcode trynextip(struct connectdata *conn,
int sockindex,
int tempindex)
{
const int other = tempindex ^ 1;
CURLcode result = CURLE_COULDNT_CONNECT;
/* First clean up after the failed socket.
Don't close it yet to ensure that the next IP's socket ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x7, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x270(%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
mo... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/connect.c |
Curl_connalive | bool Curl_connalive(struct connectdata *conn)
{
/* First determine if ssl */
if(conn->ssl[FIRSTSOCKET].use) {
/* use the SSL context */
if(!Curl_ssl_check_cxn(conn))
return false; /* FIN received */
}
/* Minix 3.1 doesn't support any flags on recv; just assume socket is OK */
#ifdef MSG_PEEK
els... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x2b0(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xb126
movq -0x10(%rbp), %rdi
callq 0x273f0
cmpl $0x0, %eax
jne 0xb124
movb $0x0, -0x1(%rbp)
jmp 0xb16a
jmp 0xb166
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x268(%... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/connect.c |
Curl_conncontrol | const char *reason
#endif
)
{
/* close if a connection, or a stream that isn't multiplexed */
bool closeit = (ctrl == CONNCTRL_CONNECTION) ||
((ctrl == CONNCTRL_STREAM) && !(conn->handler->flags & PROTOPT_STREAM));
if((ctrl == CONNCTRL_STREAM) &&
(conn->handler->flags & PROTOPT_STREAM))
DEBUGF(info... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x1, %al
cmpl $0x1, -0xc(%rbp)
movb %al, -0xe(%rbp)
je 0xb368
xorl %eax, %eax
cmpl $0x2, -0xc(%rbp)
movb %al, -0xf(%rbp)
jne 0xb362
movq -0x8(%rbp), %rax
movq 0x3d0(%rax), %rax
movl 0x84(%rax), %eax
andl $0x200, %eax # imm = 0x200
c... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/connect.c |
Curl_expire_clear | void Curl_expire_clear(struct Curl_easy *data)
{
struct Curl_multi *multi = data->multi;
struct curltime *nowp = &data->state.expiretime;
/* this is only interesting while there is still an associated multi struct
remaining! */
if(!multi)
return;
if(nowp->tv_sec || nowp->tv_usec) {
/* Since thi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10a0, %rax # imm = 0x10A0
addq $0x1a0, %rax # imm = 0x1A0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xca6b
jmp 0xcb1c
movq -0x18... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/multi.c |
bundle_create | static CURLcode bundle_create(struct Curl_easy *data,
struct connectbundle **cb_ptr)
{
(void)data;
DEBUGASSERT(*cb_ptr == NULL);
*cb_ptr = malloc(sizeof(struct connectbundle));
if(!*cb_ptr)
return CURLE_OUT_OF_MEMORY;
(*cb_ptr)->num_connections = 0;
(*cb_ptr)->multiuse = B... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x15b22
movl $0x30, %edi
leaq 0x6ad72(%rip), %rax # 0x808a0
callq *(%rax)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15b4d
movl $0x1b, -0x4(%rbp)
jmp 0x15b87
mov... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/conncache.c |
conncache_remove_bundle | static void conncache_remove_bundle(struct conncache *connc,
struct connectbundle *bundle)
{
struct curl_hash_iterator iter;
struct curl_hash_element *he;
if(!connc)
return;
Curl_hash_start_iterate(&connc->hash, &iter);
he = Curl_hash_next_element(&iter);
while(he)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x15e39
jmp 0x15e92
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x48a80
leaq -0x28(%rbp), %rdi
callq 0x48ab0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x15e92
movq -0x30(%rbp), %rax
movq 0x18... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/conncache.c |
ssl_connect_init_proxy | static CURLcode
ssl_connect_init_proxy(struct connectdata *conn, int sockindex)
{
DEBUGASSERT(conn->bits.proxy_ssl_connected[sockindex]);
if(ssl_connection_complete == conn->ssl[sockindex].state &&
!conn->proxy_ssl[sockindex].use) {
struct ssl_backend_data *pbdata;
if(!(Curl_ssl->supports & SSLSUPP_HT... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
jmp 0x26481
movq -0x10(%rbp), %rcx
addq $0x2a0, %rcx # imm = 0x2A0
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rcx
movl $0x2, %eax
cmpl (%rcx), %eax
jne 0x2659b
movq -0x10(%rbp), %rax
addq $0x2d0, %rax ... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/vtls/vtls.c |
verifystatus | static CURLcode verifystatus(struct connectdata *conn,
struct ssl_connect_data *connssl)
{
int i, ocsp_status;
unsigned char *status;
const unsigned char *p;
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
OCSP_RESPONSE *rsp = NULL;
OCSP_BASICRESP *br = NULL;... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/vtls/openssl.c |
file_connect | static CURLcode file_connect(struct connectdata *conn, bool *done)
{
struct Curl_easy *data = conn->data;
char *real_path;
struct FILEPROTO *file = data->req.protop;
int fd;
#ifdef DOS_FILESYSTEM
size_t i;
char *actual_path;
#endif
size_t real_path_len;
CURLcode result = Curl_urldecode(data, data->stat... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x1560(%rax), %rsi
xorl %eax, %eax
movl %eax, ... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/file.c |
file_upload | static CURLcode file_upload(struct connectdata *conn)
{
struct FILEPROTO *file = conn->data->req.protop;
const char *dir = strchr(file->path, DIRSEP);
int fd;
int mode;
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
char *buf = data->state.buffer;
curl_off_t bytecount = 0;
struct_sta... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x7300
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/file.c |
AddFormInfo | static FormInfo * AddFormInfo(char *value,
char *contenttype,
FormInfo *parent_form_info)
{
FormInfo *form_info;
form_info = calloc(1, sizeof(struct FormInfo));
if(form_info) {
if(value)
form_info->value = value;
if(contenttype)
form_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
movl $0x80, %esi
leaq 0x2146b(%rip), %rax # 0x808c0
callq *(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5f496
cmpq $0x0, -0x10(%rbp)
je 0x5f475
movq -0x10(%rbp), %rcx
movq -0... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/formdata.c |
ftp_connect | static CURLcode ftp_connect(struct connectdata *conn,
bool *done) /* see description above */
{
CURLcode result;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
*done = FALSE; /* default to not done yet */
/* We always support persistent connectio... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xb320
mo... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_multi_statemach | static CURLcode ftp_multi_statemach(struct connectdata *conn,
bool *done)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result = Curl_pp_statemach(&ftpc->pp, FALSE, FALSE);
/* Check for the state outside of the Curl_socket_check() return code checks
since at times... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x69210
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %edx
xorl %... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_domore_getsock | static int ftp_domore_getsock(struct connectdata *conn, curl_socket_t *socks,
int numsocks)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(!numsocks)
return GETSOCK_BLANK;
/* When in DO_MORE state, we could be either waiting for us to connect to a
* remote site, or we could... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x60713
movl $0x0, -0x4(%rbp)
jmp 0x607ff
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl 0xbc(... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_statemach_act | static CURLcode ftp_statemach_act(struct connectdata *conn)
{
CURLcode result;
curl_socket_t sock = conn->sock[FIRSTSOCKET];
struct Curl_easy *data = conn->data;
int ftpcode;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
static const char ftpauth[][4] = { "SSL", "TLS" };
s... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x268(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %ra... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_state_type_resp | static CURLcode ftp_state_type_resp(struct connectdata *conn,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
if(ftpcode/100 != 2) {
/* "sasserftpd" and "(u)r(x)bot ftpd" both responds wi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x2, %eax
je 0x627af
movq -0x28(%rbp), %rdi
leaq 0x11399(%... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_state_rest_resp | static CURLcode ftp_state_rest_resp(struct connectdata *conn,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct ftp_conn *ftpc = &conn->proto.ftpc;
switch(instate) {
case FTP_REST:
default:
#ifdef CURL_FTP_HTTPSTYLE_HEA... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x1a, %eax
je 0x629ae
jmp 0x629a4
movl -0x4... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_state_stor_resp | static CURLcode ftp_state_stor_resp(struct connectdata *conn,
int ftpcode, ftpstate instate)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
if(ftpcode >= 400) {
failf(data, "Failed FTP upload: %0d", ftpcode);
state(conn, FTP_STOP);
/* oops, we n... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x190, -0x14(%rbp) # imm = 0x190
jl 0x63699
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x10924(%rip), ... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_state_retr | static CURLcode ftp_state_retr(struct connectdata *conn,
curl_off_t filesize)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct FTP *ftp = data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(data->set.max_filesize && (filesize > dat... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %ra... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_state_ul_setup | static CURLcode ftp_state_ul_setup(struct connectdata *conn,
bool sizechecked)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->req.protop;
struct Curl_easy *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((data->state.resume_from && !sizechecked... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_state_rest | static CURLcode ftp_state_rest(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer != FTPTRANSFER_BODY) && ftpc->file) {
/* if a "head"-like request is being made (on a file) */
/* Determine if s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x6428... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_dophase_done | static CURLcode ftp_dophase_done(struct connectdata *conn,
bool connected)
{
struct FTP *ftp = conn->data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(connected) {
int completed;
CURLcode result = ftp_do_more(conn, &completed);
if(result) {
close_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x28(%rbp)
testb $0x1, -0x11(%rbp)
j... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
AllowServerConnect | static CURLcode AllowServerConnect(struct connectdata *conn, bool *connected)
{
struct Curl_easy *data = conn->data;
time_t timeout_ms;
CURLcode result = CURLE_OK;
*connected = FALSE;
infof(data, "Preparing for accepting server on data port\n");
/* Save the time we start accepting server connect */
Curl... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rdi
leaq 0xe53e(%rip), %rsi # 0x73df2
movb $0x0, %al
callq 0x365c0
movq -0x20(... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
AcceptServerConnect | static CURLcode AcceptServerConnect(struct connectdata *conn)
{
struct Curl_easy *data = conn->data;
curl_socket_t sock = conn->sock[SECONDARYSOCKET];
curl_socket_t s = CURL_SOCKET_BAD;
#ifdef ENABLE_IPV6
struct Curl_sockaddr_storage add;
#else
struct sockaddr_in add;
#endif
curl_socklen_t size = (curl_sock... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x26c(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x80, -0xa4(%rbp)
movl -0x1c(%rbp), %edi
leaq -0xa0(%rbp), %rsi
l... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_sendquote | static
CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
{
struct curl_slist *item;
ssize_t nread;
int ftpcode;
CURLcode result;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
item = quote;
while(item) {
if(item->data) {
char *cmd = item->... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x66114
movq -0x20(%rbp... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_perform | static
CURLcode ftp_perform(struct connectdata *conn,
bool *connected, /* connect status after PASV / PORT */
bool *dophase_done)
{
/* this is FTP and no proxy */
CURLcode result = CURLE_OK;
DEBUGF(infof(conn->data, "DO phase starts\n"));
if(conn->data->set.opt_no_bo... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x6714d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xee0(%rax), %rax
shrq $0x1c, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x67185
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
ftp_block_statemach | static CURLcode ftp_block_statemach(struct connectdata *conn)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
CURLcode result = CURLE_OK;
while(ftpc->state != FTP_STOP) {
result = Curl_pp_statemach(pp, TRUE, TRUE /* disconnecting */);
if(result)
break;
}
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x510, %rax # imm = 0x510
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xbc(%rax)
je 0x67343
movq -0x18(%rbp), %rdi
movl $0x1, %edx
mo... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/ftp.c |
Curl_pp_state_timeout | time_t Curl_pp_state_timeout(struct pingpong *pp, bool disconnecting)
{
struct connectdata *conn = pp->conn;
struct Curl_easy *data = conn->data;
time_t timeout_ms; /* in milliseconds */
long response_time = (data->set.server_response_timeout)?
data->set.server_response_timeout: pp->response_time;
/* if ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x7c0(%rax)
je 0x6912d
movq -0x20(%rbp... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/pingpong.c |
Curl_pp_vsendf | CURLcode Curl_pp_vsendf(struct pingpong *pp,
const char *fmt,
va_list args)
{
ssize_t bytes_written;
size_t write_len;
char *fmt_crlf;
char *s;
CURLcode result;
struct connectdata *conn = pp->conn;
struct Curl_easy *data;
#ifdef HAVE_GSSAPI
enum protectio... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x69512
jmp 0x69514
jmp 0x69516
jmp 0x69518
jmp 0x6951a
cmpq $0x0, -0x50(%rbp)
jne 0x6952d
movl $0x37, -0x4(%rbp)
jmp 0x696ec
movq -0x5... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/pingpong.c |
Curl_pp_flushsend | CURLcode Curl_pp_flushsend(struct pingpong *pp)
{
/* we have a piece of a command still left to send */
struct connectdata *conn = pp->conn;
ssize_t written;
curl_socket_t sock = conn->sock[FIRSTSOCKET];
CURLcode result = Curl_write(conn, sock, pp->sendthis + pp->sendsize -
pp->... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x268(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x10(%rbp), %rax
ad... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/pingpong.c |
hmac_md5 | static CURLcode hmac_md5(const unsigned char *key, unsigned int keylen,
const unsigned char *data, unsigned int datalen,
unsigned char *output)
{
HMAC_context *ctxt = Curl_HMAC_init(Curl_HMAC_MD5, key, keylen);
if(!ctxt)
return CURLE_OUT_OF_MEMORY;
/* Update... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x15428(%rip), %rdi # 0x7f870
callq 0x6bc40
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6a461
movl ... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/curl_ntlm_core.c |
Curl_cert_hostcheck | int Curl_cert_hostcheck(const char *match_pattern, const char *hostname)
{
int res = 0;
if(!match_pattern || !*match_pattern ||
!hostname || !*hostname) /* sanity check */
;
else {
char *matchp = strdup(match_pattern);
if(matchp) {
char *hostp = strdup(hostname);
if(hostp) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6a857
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6a857
cmpq $0x0, -0x10(%rbp)
je 0x6a857
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6a859
jmp 0x6a8ca
leaq 0x16058(%rip), %rax ... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/hostcheck.c |
charclass | static char_class charclass(unsigned char c)
{
if(ISUPPER(c))
return CCLASS_UPPER;
if(ISLOWER(c))
return CCLASS_LOWER;
if(ISDIGIT(c))
return CCLASS_DIGIT;
return CCLASS_OTHER;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %edi
callq 0x23c10
cmpl $0x0, %eax
je 0x6bbf5
movl $0x2, -0x4(%rbp)
jmp 0x6bc2a
movzbl -0x5(%rbp), %edi
callq 0x23c50
cmpl $0x0, %eax
je 0x6bc0c
movl $0x3, -0x4(%rbp)
jmp 0x6bc2a
movzbl -0x5(%rbp), %edi
callq 0x23a90
cmpl... | /havogt[P]cmakels/cmakels/external/cmake/Utilities/cmcurl/lib/curl_fnmatch.c |
printf | int printf( const char * _PDCLIB_restrict format, ... )
{
int rc;
va_list ap;
va_start( ap, format );
rc = vfprintf( stdout, format, ap );
va_end( ap );
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3c68
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)... | /DevSolar[P]pdclib/functions/stdio/printf.c |
memmove | void * memmove( void * s1, const void * s2, size_t n )
{
char * dest = ( char * ) s1;
const char * src = ( const char * ) s2;
if ( dest <= src )
{
while ( n-- )
{
*dest++ = *src++;
}
}
else
{
src += n;
dest += n;
while ( n-- )
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x106d7
jmp 0x1069c
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx... | /DevSolar[P]pdclib/functions/string/memmove.c |
main | int main() {
for (const auto& ns : blns::Blns::getStrings())
{
std::cout << ns << std::endl;
}
return 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x24bc
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x244e
movq 0x2bcc(%rip), %rbx # 0x4fd8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2190
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0x... | /eliabieri[P]blnscpp/examples/example.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.