name string | code string | asm string | file string |
|---|---|---|---|
xmlFAParseCharClassEsc | static void
xmlFAParseCharClassEsc(xmlRegParserCtxtPtr ctxt) {
int cur;
if (CUR == '.') {
if (ctxt->atom == NULL) {
ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_ANYCHAR);
} else if (ctxt->atom->type == XML_REGEXP_RANGES) {
xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
XML_REGEXP_ANYCHAR,... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x9f69e
cmpl $0x2e, %ecx
jne 0x9f6f1
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x9f70e
cmpl $0x3, 0x4(%rsi)
jne 0x9f77a
movl 0x14(%rbx), %edx
andq $0x0, (%rsp)
pushq $0x6
popq %rcx
movq %rbx, %rdi
xorl %r8d, %r... | /frida[P]libxml2/xmlregexp.c |
xmlFAParseCharProp | static void
xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
int cur;
xmlRegAtomType type = (xmlRegAtomType) 0;
xmlChar *blockName = NULL;
cur = CUR;
if (cur == 'L') {
NEXT;
cur = CUR;
if (cur == 'u') {
NEXT;
type = XML_REGEXP_LETTER_UPPERCASE;
} else if (cur == 'l') {
NEXT;
t... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movzbl (%rax), %edx
leal -0x43(%rdx), %ecx
cmpl $0x10, %ecx
ja 0x9fd4b
leaq 0x4d418(%rip), %rdx # 0xed118
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movzbl 0x1(%rax), %ecx
cmpl $0x6f, %ecx
je 0... | /frida[P]libxml2/xmlregexp.c |
xmlSaveToBuffer | xmlSaveCtxtPtr
xmlSaveToBuffer(xmlBufferPtr buffer, const char *encoding, int options)
{
xmlSaveCtxtPtr ret;
ret = xmlNewSaveCtxt(encoding, options);
if (ret == NULL) return(NULL);
ret->buf = xmlOutputBufferCreateBuffer(buffer, ret->handler);
if (ret->buf == NULL) {
xmlCharEncCloseFunc(ret-... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0xa0ae2
testq %rax, %rax
je 0xa0c5f
movq %rax, %rbx
movq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0x35220
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0xa0c61
movq 0x20(%rbx), %rdi
callq 0x35240
movq %rbx, %rdi
callq 0xa0ba1
xorl %ebx, %... | /frida[P]libxml2/xmlsave.c |
xmlDocContentDumpOutput | static int
xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr cur) {
#ifdef LIBXML_HTML_ENABLED
xmlDtdPtr dtd;
int is_xhtml = 0;
#endif
const xmlChar *oldenc = cur->encoding;
const xmlChar *oldctxtenc = ctxt->encoding;
const xmlChar *encoding = ctxt->encoding;
xmlCharEncodingOutputFunc oldes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rsi), %r13
movq 0x18(%rdi), %rbp
movq 0x28(%rdi), %r15
movups 0x88(%rdi), %xmm0
movaps %xmm0, 0x20(%rsp)
callq 0x32ce0
movl 0x8(%rbx), %eax
movl %eax, %ecx
orl $0x4, %ecx
cmpl $0xd, %ecx
jne 0xa... | /frida[P]libxml2/xmlsave.c |
xmlElemDump | void
xmlElemDump(FILE * f, xmlDocPtr doc, xmlNodePtr cur)
{
xmlOutputBufferPtr outbuf;
xmlInitParser();
if (cur == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlElemDump : cur == NULL\n");
#endif
return;
}
#ifdef DEBUG_TREE
if (doc ==... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x32ce0
testq %rbx, %rbx
je 0xa2c26
movq %r15, %rdi
xorl %esi, %esi
callq 0x35050
testq %rax, %rax
je 0xa2c26
movq %rax, %r15
testq %r14, %r14
je 0xa2c2c
cmpl $0xd, 0x8(%r14)
jne 0xa2c2c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rd... | /frida[P]libxml2/xmlsave.c |
xmlDocDumpFormatMemoryEnc | void
xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
int * doc_txt_len, const char * txt_encoding,
int format) {
xmlSaveCtxt ctxt;
int dummy = 0;
xmlOutputBufferPtr out_buff = NULL;
xmlCharEncodingHandlerPtr conv_hdlr = NULL;
if (doc_txt_le... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
testq %rsi, %rsi
je 0xa2da3
movl %r8d, %ebp
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %r12
andq $0x0, (%rsi)
testq %rbx, %rbx
je 0xa2d5d
andl $0x0, (%rbx)
testq %r12, %r12
je 0xa2ebe
testq %r13, %r13
jne 0xa2d75
movq 0x7... | /frida[P]libxml2/xmlsave.c |
xmlSaveFileTo | int
xmlSaveFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding) {
xmlSaveCtxt ctxt;
int ret;
if (buf == NULL) return(-1);
if (cur == NULL) {
xmlOutputBufferClose(buf);
return(-1);
}
memset(&ctxt, 0, sizeof(ctxt));
ctxt.buf = buf;
ctxt.level = 0;
ctxt.format =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
pushq $-0x1
popq %rbp
testq %rdi, %rdi
je 0xa302a
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa3022
movq %rdx, %r15
leaq 0x8(%rsp), %r12
movl $0x98, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x32350
movq %rbx, 0x28(%r12)
andl $0x0, 0x38(... | /frida[P]libxml2/xmlsave.c |
xmlOutputBufferWriteWSNonSig | static void
xmlOutputBufferWriteWSNonSig(xmlSaveCtxtPtr ctxt, int extra)
{
int i;
if ((ctxt == NULL) || (ctxt->buf == NULL))
return;
xmlOutputBufferWrite(ctxt->buf, 1, "\n");
for (i = 0; i < (ctxt->level + extra); i += ctxt->indent_nr) {
xmlOutputBufferWrite(ctxt->buf, ctxt->indent_size ... | testq %rdi, %rdi
je 0xa322a
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0xa3220
movl %esi, %ebx
leaq 0x40c93(%rip), %rdx # 0xe3e78
pushq $0x1
popq %rsi
callq 0x358f0
leaq 0x3c(%r14), %r15
xorl %ebp, %ebp
movl 0x34(%r14), %eax
addl %ebx, %eax
subl ... | /frida[P]libxml2/xmlsave.c |
xmlSchemaFreeType | void
xmlSchemaFreeType(xmlSchemaTypePtr type)
{
if (type == NULL)
return;
if (type->annot != NULL)
xmlSchemaFreeAnnot(type->annot);
if (type->facets != NULL) {
xmlSchemaFacetPtr facet, next;
facet = type->facets;
while (facet != NULL) {
next = facet->next... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa3b58
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xa3ac5
callq 0xa39f9
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
jne 0xa3adc
jmp 0xa3ae1
movq 0x8(%rdi), %r14
callq 0x33f20
movq %r14, %rdi
testq %rdi, %rdi
jne 0xa3ad0
movq 0xd8(%rbx), %rdi
testq %rdi, %r... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaAnnotDump | static void
xmlSchemaAnnotDump(FILE * output, xmlSchemaAnnotPtr annot)
{
xmlChar *content;
if (annot == NULL)
return;
content = xmlNodeGetContent(annot->content);
if (content != NULL) {
fprintf(output, " Annot: %s\n", content);
xmlFree(content);
} else
fprintf(outp... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
callq 0x35340
testq %rax, %rax
je 0xa3e7b
movq %rax, %r14
leaq 0x4aa04(%rip), %rsi # 0xee85f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x35fa8
movq 0x89141(%rip), %rax # 0x12cfb0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaNewParserCtxt | xmlSchemaParserCtxtPtr
xmlSchemaNewParserCtxt(const char *URL)
{
xmlSchemaParserCtxtPtr ret;
if (URL == NULL)
return (NULL);
ret = xmlSchemaParserCtxtCreate();
if (ret == NULL)
return(NULL);
ret->dict = xmlDictCreate();
ret->URL = xmlDictLookup(ret->dict, (const xmlChar *) URL, -1);
... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa40b8
movq %rdi, %r14
callq 0xa40c5
testq %rax, %rax
je 0xa40b8
movq %rax, %rbx
callq 0x326b0
movq %rax, 0x98(%rbx)
pushq $-0x1
popq %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x323f0
movq %rax, 0x50(%rbx)
jmp 0xa40ba
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaNewMemParserCtxt | xmlSchemaParserCtxtPtr
xmlSchemaNewMemParserCtxt(const char *buffer, int size)
{
xmlSchemaParserCtxtPtr ret;
if ((buffer == NULL) || (size <= 0))
return (NULL);
ret = xmlSchemaParserCtxtCreate();
if (ret == NULL)
return(NULL);
ret->buffer = buffer;
ret->size = size;
ret->dict = xml... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0xa4163
movl %esi, %ebp
movq %rdi, %r14
callq 0xa40c5
testq %rax, %rax
je 0xa4163
movq %rax, %rbx
movq %r14, 0x68(%rax)
movl %ebp, 0x70(%rax)
callq 0x326b0
movq %rax, 0x98(%rbx)
jmp 0xa4165
xorl %ebx, %ebx
movq %rbx, ... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaFreeValidCtxt | void
xmlSchemaFreeValidCtxt(xmlSchemaValidCtxtPtr ctxt)
{
if (ctxt == NULL)
return;
if (ctxt->value != NULL)
xmlSchemaFreeValue(ctxt->value);
if (ctxt->pctxt != NULL)
xmlSchemaFreeParserCtxt(ctxt->pctxt);
if (ctxt->idcNodes != NULL) {
int i;
xmlSchemaPSVIIDCNodePtr item;
for (i = 0;... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa4415
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0xa4248
callq 0x33ef0
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0xa4259
callq 0x33e40
cmpq $0x0, 0xe8(%rbx)
je 0xa42a0
xorl %r12d, %r12d
movq 0x88d43(%rip), %r15 # 0x12cfb0
mo... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaCheckFacet | int
xmlSchemaCheckFacet(xmlSchemaFacetPtr facet,
xmlSchemaTypePtr typeDecl,
xmlSchemaParserCtxtPtr pctxt,
const xmlChar * name ATTRIBUTE_UNUSED)
{
int ret = 0, ctxtGiven;
if ((facet == NULL) || (typeDecl == NULL))
return(-1);
/*
* TODO: will the par... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rbp
jne 0xa47eb
movq %rdx, %rbx
movq %rdi, %r15
xorl %r13d, %r13d
movl $0xfffffc18, %eax # imm = 0xFFFFFC18
addl (%rdi), %eax
cmpl $0xb, %eax
ja 0xa... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaFacetTypeToString | static const xmlChar *
xmlSchemaFacetTypeToString(xmlSchemaTypeType type)
{
switch (type) {
case XML_SCHEMA_FACET_PATTERN:
return (BAD_CAST "pattern");
case XML_SCHEMA_FACET_MAXEXCLUSIVE:
return (BAD_CAST "maxExclusive");
case XML_SCHEMA_FACET_MAXINCLUSIVE:
... | addl $0xfffffc18, %edi # imm = 0xFFFFFC18
cmpl $0xb, %edi
ja 0xa50ab
movl %edi, %eax
leaq 0x4929d(%rip), %rcx # 0xee340
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x4dd5a(%rip), %rax # 0xf2e0c
retq
| /frida[P]libxml2/xmlschemas.c |
xmlSchemaParse | xmlSchemaPtr
xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt)
{
xmlSchemaPtr mainSchema = NULL;
xmlSchemaBucketPtr bucket = NULL;
int res;
/*
* This one is used if the schema to be parsed was specified via
* the API; i.e. not automatically by the validated instance document.
*/
xmlSchemaIni... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x20(%rsp)
callq 0x351f0
testq %rbx, %rbx
je 0xa5358
andq $0x0, 0x20(%rbx)
andl $0x0, 0x48(%rbx)
movq %rbx, %rdi
callq 0xa53d3
testq %rax, %rax
je 0xa5321
movq %rax, %r14
movq 0x30(%rbx), %rax
testq %rax, %rax
jne 0xa527c
movq 0x98(%rbx), %rdi
callq 0xa5... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaAddSchemaDoc | static int
xmlSchemaAddSchemaDoc(xmlSchemaParserCtxtPtr pctxt,
int type, /* import or include or redefine */
const xmlChar *schemaLocation,
xmlDocPtr schemaDoc,
const char *schemaBuffer,
int schemaBufferLen,
xmlNodePtr invokingNode,
const xmlChar *sourceTargetNamespace,
const xmlChar *importNamespace,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq 0x98(%rsp), %r15
testq %r15, %r15
je 0xa5507
andq $0x0, (%r15)
movq 0x80(%rsp), %r10
movl %ebp, %eax
leaq 0x48920(%rip), %rcx # 0xede38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
j... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaSetParserErrors | void
xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaValidityErrorFunc err,
xmlSchemaValidityWarningFunc warn, void *ctx)
{
if (ctxt == NULL)
return;
ctxt->error = err;
ctxt->warning = warn;
ctxt->errCtxt = ctx;
if (ctxt->vctxt... | testq %rdi, %rdi
je 0xa840b
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x8(%rdi)
movq 0xb0(%rdi), %rdi
testq %rdi, %rdi
jne 0x324d0
retq
| /frida[P]libxml2/xmlschemas.c |
xmlSchemaItemListCreate | static xmlSchemaItemListPtr
xmlSchemaItemListCreate(void)
{
xmlSchemaItemListPtr ret;
ret = xmlMalloc(sizeof(xmlSchemaItemList));
if (ret == NULL) {
xmlSchemaPErrMemory(NULL,
"allocating an item list structure", NULL);
return (NULL);
}
memset(ret, 0, sizeof(xmlSchemaItemList));
return (r... | pushq %rbx
movq 0x84a9d(%rip), %rax # 0x12cfd0
pushq $0x10
popq %rdi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0xa8548
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xa8558
leaq 0x4aee9(%rip), %rsi # 0xf3438
xorl %edi, %edi
xorl %edx, %edx
callq 0xaa886
movq %rbx, %rax
popq %rbx
retq
| /frida[P]libxml2/xmlschemas.c |
xmlSchemaVStart | static int
xmlSchemaVStart(xmlSchemaValidCtxtPtr vctxt)
{
int ret = 0;
if (xmlSchemaPreRun(vctxt) < 0)
return(-1);
if (vctxt->doc != NULL) {
/*
* Tree validation.
*/
ret = xmlSchemaVDocWalk(vctxt);
#ifdef LIBXML_READER_ENABLED
} else if (vctxt->reader != NULL) {
/*
* XML Reader valida... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
callq 0xa9aa3
testl %eax, %eax
js 0xa8b88
movq 0x30(%r13), %rdi
testq %rdi, %rdi
je 0xa8b90
movq 0x98(%r13), %r15
testq %r15, %r15
jne 0xa899b
callq 0x32870
movq %rax, %r15
testq %rax, %rax
je 0xa8bd2
orl $-0x1, 0xac(%r13... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaSAXHandleStartElementNs | static void
xmlSchemaSAXHandleStartElementNs(void *ctx,
const xmlChar * localname,
const xmlChar * prefix ATTRIBUTE_UNUSED,
const xmlChar * URI,
int nb_namespaces,
const xmlChar ** namespaces,
int nb_attributes,
int nb_defaulted ATTRIBUTE_UNUSED,
const xmlChar ** attributes)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq 0x60(%rsp), %r13
movl 0x50(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xac(%rdi), %eax
movl 0x130(%rdi), %ecx
incl %eax
movl %eax, 0xac(%rdi)
cmpl $-0x1, %ecx
sete %dl
cmpl %ecx, %eax
setl %al
orb %dl, %al
cmpb $0x1, %al
... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaSAXHandleReference | static void
xmlSchemaSAXHandleReference(void *ctx ATTRIBUTE_UNUSED,
const xmlChar * name ATTRIBUTE_UNUSED)
{
xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
if (vctxt->depth < 0)
return;
if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
return;
/* SAX VAL TODO: Wha... | movl 0xac(%rdi), %eax
testl %eax, %eax
js 0xa9567
movl 0x130(%rdi), %ecx
cmpl $-0x1, %ecx
setne %dl
cmpl %ecx, %eax
setge %al
testb %al, %dl
jne 0xa9567
pushq %rbx
callq 0x34700
movq (%rax), %rbx
callq 0x335a0
movq (%rax), %rdi
leaq 0x3f003(%rip), %rsi # 0xe8555
leaq 0x44e2f(%rip), %rdx # 0xee388
movl $0x6b8b, ... | /frida[P]libxml2/xmlschemas.c |
charactersSplit | static void
charactersSplit(void *ctx, const xmlChar *ch, int len)
{
xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
if (ctxt == NULL)
return;
if ((ctxt->user_sax != NULL) && (ctxt->user_sax->characters != NULL))
ctxt->user_sax->characters(ctxt->user_data, ch, len);
if (ctxt->ctxt != NULL... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa98c7
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xa98ac
movq 0x88(%rax), %rax
testq %rax, %rax
je 0xa98ac
movq 0x20(%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq *%rax
movq 0x128(%r15), %rdi
testq %rdi, %rdi
je 0x... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaGetComponentTypeStr | static const xmlChar *
xmlSchemaGetComponentTypeStr(xmlSchemaBasicItemPtr item)
{
switch (item->type) {
case XML_SCHEMA_TYPE_BASIC:
if (WXS_IS_COMPLEX(WXS_TYPE_CAST item))
return(BAD_CAST "complex type definition");
else
return(BAD_CAST "simple type definition");
default:
return(xmlSchemaItemTy... | movl (%rdi), %eax
cmpl $0x1, %eax
jne 0xaa286
cmpl $0x2d, 0xa0(%rdi)
leaq 0x44476(%rip), %rcx # 0xee6f0
leaq 0x499f6(%rip), %rax # 0xf3c77
cmoveq %rcx, %rax
retq
movl %eax, %edi
jmp 0xaa28a
| /frida[P]libxml2/xmlschemas.c |
xmlSchemaTypeDump | static void
xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output)
{
if (type == NULL) {
fprintf(output, "Type: NULL\n");
return;
}
fprintf(output, "Type: ");
if (type->name != NULL)
fprintf(output, "'%s' ", type->name);
else
fprintf(output, "(no name) ");
if (ty... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0xaa398
movq %rdi, %r14
leaq 0x4451a(%rip), %rdi # 0xee888
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x35710
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0xaa3bb
leaq 0x446d3(%ri... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaInternalErr2 | static void LIBXML_ATTR_FORMAT(3,0)
xmlSchemaInternalErr2(xmlSchemaAbstractCtxtPtr actxt,
const char *funcName,
const char *message,
const xmlChar *str1,
const xmlChar *str2)
{
xmlChar *msg = NULL;
if (actxt == NULL)
return;
msg = xmlStrdup(BAD_CAST "Internal error: %s, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xaa97b
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x44174(%rip), %rdi # 0xeea80
callq 0x35fc0
movq %rax, %rdi
movq %r12, %rsi
callq 0x33710
leaq 0x3ea64(%rip), %rsi # 0xe9387
movq %rax, %rdi
callq 0x33710
movq ... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaGetComponentNode | static xmlNodePtr
xmlSchemaGetComponentNode(xmlSchemaBasicItemPtr item)
{
switch (item->type) {
case XML_SCHEMA_TYPE_ELEMENT:
return (((xmlSchemaElementPtr) item)->node);
case XML_SCHEMA_TYPE_ATTRIBUTE:
return (((xmlSchemaAttributePtr) item)->node);
case XML_SCHEMA_TYPE_COMPLEX:
case XML_SCHEMA_TYPE_S... | movl (%rdi), %ecx
xorl %eax, %eax
leal -0x2(%rcx), %edx
cmpl $0x18, %edx
ja 0xaad12
leaq 0x432eb(%rip), %rcx # 0xedfe8
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
pushq $0x18
jmp 0xaad28
pushq $0x20
jmp 0xaad28
pushq $0x48
jmp 0xaad28
cmpl $0x7d0, %ecx # imm = 0x7D0
jne 0xaad2d
pushq $0x28
jmp ... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaPErr | static void LIBXML_ATTR_FORMAT(4,0)
xmlSchemaPErr(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
const char *msg, const xmlChar * str1, const xmlChar * str2)
{
xmlGenericErrorFunc channel = NULL;
xmlStructuredErrorFunc schannel = NULL;
void *data = NULL;
if (ctxt != NULL) {
... | movq %rcx, %r11
movq %rsi, %rax
movq %rdi, %rcx
testq %rdi, %rdi
je 0xab754
incl 0x24(%rcx)
movl %edx, 0x20(%rcx)
movq 0x8(%rcx), %r10
movq 0x10(%rcx), %rsi
movq 0x28(%rcx), %rdi
jmp 0xab75b
xorl %esi, %esi
xorl %edi, %edi
xorl %r10d, %r10d
subq $0x68, %rsp
movq %r9, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r11, 0x48(%rsp... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaItemListAdd | static int
xmlSchemaItemListAdd(xmlSchemaItemListPtr list, void *item)
{
if (list->items == NULL) {
list->items = (void **) xmlMalloc(
20 * sizeof(void *));
if (list->items == NULL) {
xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
return(-1);
}
list->sizeItems = 20;
} else if (l... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xab8b4
movslq 0xc(%rbx), %rsi
cmpl 0x8(%rbx), %esi
jg 0xab8d1
leal (%rsi,%rsi), %ecx
movl %ecx, 0xc(%rbx)
movq 0x81303(%rip), %rcx # 0x12cb90
shlq $0x4, %rsi
movq %rax, %rdi
callq *(%rcx)
movq %rax, (%rbx)
testq ... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaPValAttrNode | static int
xmlSchemaPValAttrNode(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaBasicItemPtr ownerItem,
xmlAttrPtr attr,
xmlSchemaTypePtr type,
const xmlChar **value)
{
const xmlChar *val;
if ((ctxt == NULL) || (type == NULL) || (attr == NULL))
return (-1);
val = xmlSchemaGetNodeContent(ct... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xab9a3
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0xab9d5
testq %r15, %r15
je 0xab9b9
... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaParseAnnotation | static xmlSchemaAnnotPtr
xmlSchemaParseAnnotation(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int needed)
{
xmlSchemaAnnotPtr ret;
xmlNodePtr child = NULL;
xmlAttrPtr attr;
int barked = 0;
/*
* INFO: S4S completed.
*/
/*
* id = ID
* {any attributes with non-schema namespace . ... | testq %rsi, %rsi
je 0xac25c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbp
movq %rdi, %r14
testl %edx, %edx
je 0xac271
movq 0x80d8c(%rip), %rax # 0x12cfd0
pushq $0x10
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0xac25f
andq $0x0, (%rax)
movq %rax, (%rsp)
movq %rbp... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaParseElement | static xmlSchemaBasicItemPtr
xmlSchemaParseElement(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlNodePtr node, int *isElemRef, int topLevel)
{
xmlSchemaElementPtr decl = NULL;
xmlSchemaParticlePtr particle = NULL;
xmlSchemaAnnotPtr annot = NULL;
xmlNodePtr child = NULL;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %r12d
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
testq %rcx, %rcx
je 0xadca9
andl $0x0, (%r15)
leaq 0x37a59(%rip), %rsi # 0xe5709
movq %r14, %rdi
callq 0xab929
movq %rax, %rbp
leaq 0x3b00a(%rip),... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaParseModelGroupDefinition | static xmlSchemaModelGroupDefPtr
xmlSchemaParseModelGroupDefinition(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaModelGroupDefPtr item;
xmlNodePtr child = NULL;
xmlAttrPtr attr;
const xmlChar *name;
if ((ctxt == NULL) || (schema == NULL) || (node == NU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x36740(%rip), %rsi # 0xe5709
movq %rdx, %rdi
callq 0xab929
testq %rax, %rax
je 0xaf007
movq %rax, %r15
pushq $0x16
popq %rdi
callq 0x32a60
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
mo... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaParseNewDoc | static int
xmlSchemaParseNewDoc(xmlSchemaParserCtxtPtr pctxt,
xmlSchemaPtr schema,
xmlSchemaBucketPtr bucket)
{
xmlSchemaParserCtxtPtr newpctxt;
int res = 0;
if (bucket == NULL)
return(0);
if (bucket->parsed) {
PERROR_INT("xmlSchemaParseNewDoc",
"reparsing a schema doc");
return(-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xaf575
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x0, 0x34(%rdx)
je 0xaf582
leaq 0x3ffe1(%rip), %rsi # 0xef542
leaq 0x3ffef(%rip), %rdx # 0xef557
movq %rbx, %rdi
callq 0xa482e
pushq $-0x1
popq %rbp
jmp 0xaf577
xorl %ebp, %ebp
movl %ebp, %ea... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaParseIncludeOrRedefine | static int
xmlSchemaParseIncludeOrRedefine(xmlSchemaParserCtxtPtr pctxt,
xmlSchemaPtr schema,
xmlNodePtr node,
int type)
{
xmlNodePtr child = NULL;
const xmlChar *schemaLocation = NULL;
int res = 0; /* hasRedefinitions = 0 */
int isChameleon = 0, wasChameleon = 0;
xmlSchemaBucketPtr buck... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x34(%rsp)
movq %rdx, %r14
movq %rsi, 0x40(%rsp)
andq $0x0, 0x38(%rsp)
movq %rdi, %rbx
andq $0x0, 0x28(%rsp)
leaq 0x58(%rdx), %r13
leaq 0x3975f(%rip), %rbp # 0xe8ef1
leaq 0x3fff2(%rip), %r15 # 0xef78b
leaq 0x37680(%rip... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaParseModelGroupDefRef | static xmlSchemaTreeItemPtr
xmlSchemaParseModelGroupDefRef(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlNodePtr node)
{
xmlSchemaParticlePtr item;
xmlNodePtr child = NULL;
xmlAttrPtr attr;
const xmlChar *ref = NULL, *refNs = NULL;
int min, max;
if ((ctxt == NULL) || ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
andq $0x0, 0x18(%rsp)
andq $0x0, 0x10(%rsp)
testq %rdx, %rdx
je 0xb0bec
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x38211(%rip), %rsi # 0xe8ccc
movq %rdx, %rdi
callq 0xab929
testq %rax, %rax
je 0xb0bda
movq %rax, %r15
leaq... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaParseAnyAttribute | static xmlSchemaWildcardPtr
xmlSchemaParseAnyAttribute(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema, xmlNodePtr node)
{
xmlSchemaWildcardPtr ret;
xmlNodePtr child = NULL;
xmlAttrPtr attr;
if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
return (NULL);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xb1b6e
movq %rdx, %r14
movq %rdi, %r15
pushq $0x15
popq %rdx
movq %r14, %rcx
callq 0xb36d3
testq %rax, %rax
je 0xb1b6e
movq %rax, %rbx
leaq 0x58(%r14), %r12
leaq 0x37418(%rip), %r13 # 0xe8ef1
leaq 0x35340(%rip), %rbp ... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaItemListAddSize | static int
xmlSchemaItemListAddSize(xmlSchemaItemListPtr list,
int initialSize,
void *item)
{
if (list->items == NULL) {
if (initialSize <= 0)
initialSize = 1;
list->items = (void **) xmlMalloc(
initialSize * sizeof(void *));
if (list->items == NULL) {
xmlSchemaPErrMemory(NULL, "allocating... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xb1d0c
movslq 0xc(%rbx), %rsi
cmpl 0x8(%rbx), %esi
jg 0xb1d34
leal (%rsi,%rsi), %ecx
movl %ecx, 0xc(%rbx)
movq 0x7aeab(%rip), %rcx # 0x12cb90
shlq $0x4, %rsi
movq %rax, %rdi
callq *(%rcx)
movq %rax, (%rbx)
testq ... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaPValAttrNodeQNameValue | static int
xmlSchemaPValAttrNodeQNameValue(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema,
xmlSchemaBasicItemPtr ownerItem,
xmlAttrPtr attr,
const xmlChar *value,
const xmlChar **uri,
const xmlChar **local)
{
const xmlChar *pref;
xmlNsPtr ns;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
andq $0x0, (%r8)
movq %rdi, %r14
andq $0x0, (%r9)
pushq $0x1
popq %rsi
movq %rcx, %rdi
callq 0x32960
testl %eax, %eax
jle 0xb3069
pushq $0x15
popq %rdi
callq 0... | /frida[P]libxml2/xmlschemas.c |
xmlGetBooleanProp | static int
xmlGetBooleanProp(xmlSchemaParserCtxtPtr ctxt,
xmlNodePtr node,
const char *name, int def)
{
const xmlChar *val;
val = xmlSchemaGetProp(ctxt, node, name);
if (val == NULL)
return (def);
/*
* 3.2.2.1 Lexical representation
* An instance of a datatype that... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0xab7b4
testq %rax, %rax
je 0xb31f7
movq %rax, %r14
leaq 0x3c806(%rip), %rsi # 0xef9da
movq %rax, %rdi
callq 0x35170
pushq $0x1
popq %r13
testl %eax, %eax
jne 0xb31fa
leaq 0x3c7f4(%rip), %rs... | /frida[P]libxml2/xmlschemas.c |
xmlGetMinOccurs | static int
xmlGetMinOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
int min, int max, int def, const char *expected)
{
const xmlChar *val, *cur;
int ret = 0;
xmlAttrPtr attr;
attr = xmlSchemaGetPropNode(node, "minOccurs");
if (attr == NULL)
return (def);
val = xmlSchemaGetNodeContent(ct... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %r14
leaq 0x3cc17(%rip), %rsi # 0xeff43
movq %rax, %rdi
callq 0xab929
pushq $0x1
popq %r12
testq %rax, %rax
je 0xb3394
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xab9d5
movq... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaPCustomAttrErr | static void
xmlSchemaPCustomAttrErr(xmlSchemaParserCtxtPtr ctxt,
xmlParserErrors error,
xmlChar **ownerDes,
xmlSchemaBasicItemPtr ownerItem,
xmlAttrPtr attr,
const char *msg)
{
xmlChar *des = NULL;
if (ownerDes == NULL)
xmlSchemaFormatItemForReport(&des, NULL, ownerItem, attr->parent);
else... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x8(%rsp), %r12
andq $0x0, (%r12)
movq 0x28(%rdx), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0xaad2e
movq (%r12), %r8
movq 0x10(%r14), %r9
leaq 0x3caed(%rip), %rcx # 0xf018f
... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaAddWildcard | static xmlSchemaWildcardPtr
xmlSchemaAddWildcard(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
xmlSchemaTypeType type, xmlNodePtr node)
{
xmlSchemaWildcardPtr ret = NULL;
if ((ctxt == NULL) || (schema == NULL))
return (NULL);
ret = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildca... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xb36f1
xorl %ebx, %ebx
jmp 0xb3753
movl %edx, %ebp
movq %rdi, %r14
movq 0x798d3(%rip), %rax # 0x12cfd0
pushq $0x48
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0xb3740
movq %rax... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaParseWildcardNs | static int
xmlSchemaParseWildcardNs(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaPtr schema ATTRIBUTE_UNUSED,
xmlSchemaWildcardPtr wildc,
xmlNodePtr node)
{
const xmlChar *pc, *ns, *dictnsItem;
int ret = 0;
xmlChar *nsItem;
xmlSchemaWildcardNsPtr tmp, lastNs = NULL;
xmlAttrPtr attr;
pc = x... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
leaq 0x3ca47(%rip), %rdx # 0xf01c6
movq %r15, %rsi
callq 0xab7b4
movl $0x0, 0x1c(%rsp)
pushq $0x3
popq %rbx
testq %rax, %rax
je 0xb37de
movq %rax, %r12
leaq 0x3b3cc(%rip), %rsi # 0x... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaCheckReference | static int
xmlSchemaCheckReference(xmlSchemaParserCtxtPtr pctxt,
xmlSchemaPtr schema ATTRIBUTE_UNUSED,
xmlNodePtr node,
xmlAttrPtr attr,
const xmlChar *namespaceName)
{
/* TODO: Pointer comparison instead? */
if (xmlStrEqual(pctxt->targetNamespace, namespaceName))
return (0);
if (xmlStrEqua... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc8(%rdi), %rdi
movq %rcx, %rsi
callq 0x35170
xorl %ebp, %ebp
testl %eax, %eax
jne 0xb3b6e
leaq 0x33345(%rip), %rdi # 0xe6e20
movq %r15, %rsi
callq 0x35170
testl %eax, %... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaAddAttributeUse | static xmlSchemaAttributeUsePtr
xmlSchemaAddAttributeUse(xmlSchemaParserCtxtPtr pctxt,
xmlNodePtr node)
{
xmlSchemaAttributeUsePtr ret = NULL;
if (pctxt == NULL)
return (NULL);
ret = (xmlSchemaAttributeUsePtr) xmlMalloc(sizeof(xmlSchemaAttributeUse));
if (ret == NULL) {
xmlSchemaPE... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x79353(%rip), %rax # 0x12cfd0
pushq $0x48
popq %rdi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0xb3cc4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x40(%rbx... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaAttributeGroupExpandRefs | static int
xmlSchemaAttributeGroupExpandRefs(xmlSchemaParserCtxtPtr pctxt,
xmlSchemaAttributeGroupPtr attrGr)
{
if ((attrGr->attrUses == NULL) ||
(attrGr->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED))
return(0);
attrGr->flags |= XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED;
if (xmlSchemaExpandAttribut... | movq 0x70(%rsi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xb4489
movl 0x48(%rsi), %edx
testb $0x1, %dl
jne 0xb4489
pushq %rax
orl $0x1, %edx
movl %edx, 0x48(%rsi)
leaq 0x50(%rsi), %rdx
xorl %r8d, %r8d
callq 0xb7f16
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
sete %al
negl %eax
addq $0x8, %rsp
retq
| /frida[P]libxml2/xmlschemas.c |
xmlSchemaFixupSimpleTypeStageTwo | static int
xmlSchemaFixupSimpleTypeStageTwo(xmlSchemaParserCtxtPtr pctxt,
xmlSchemaTypePtr type)
{
int res, olderrs = pctxt->nberrors;
if (type->type != XML_SCHEMA_TYPE_SIMPLE)
return(-1);
if (! WXS_IS_TYPE_NOT_FIXED(type))
return(0);
type->flags |= XML_SCHEMAS_TYPE_INTERNAL_RESOLVED;
type... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
pushq $-0x1
popq %rbp
cmpl $0x4, (%rsi)
jne 0xb474c
movq %rsi, %r14
movl 0x58(%rsi), %eax
btl $0x16, %eax
jb 0xb466b
movq %rdi, %rbx
movl 0x24(%rdi), %ecx
orl $0x400000, %eax # imm = 0x400000
movl %eax, 0x58(%r14)
movl $0x4, 0x5c... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaGetType | static xmlSchemaTypePtr
xmlSchemaGetType(xmlSchemaPtr schema, const xmlChar * name,
const xmlChar * nsName)
{
xmlSchemaTypePtr ret = NULL;
if (name == NULL)
return (NULL);
/* First try the built-in types. */
if ((nsName != NULL) && xmlStrEqual(nsName, xmlSchemaNs)) {
ret = xml... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xb7ac5
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xb7a60
leaq 0x2f3e9(%rip), %rsi # 0xe6e20
movq %r14, %rdi
callq 0x35170
testl %eax, %eax
je 0xb7a60
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35d90
testq %rax, %rax
sete %cl
testq %r15, %r... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaGetPrimitiveType | static xmlSchemaTypePtr
xmlSchemaGetPrimitiveType(xmlSchemaTypePtr type)
{
while (type != NULL) {
/*
* Note that anySimpleType is actually not a primitive type
* but we need that here.
*/
if ((type->builtInType == XML_SCHEMAS_ANYSIMPLETYPE) ||
(type->flags & XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE))
retur... | movq %rdi, %rax
testq %rax, %rax
je 0xb87f0
cmpl $0x2e, 0xa0(%rax)
je 0xb87f0
testb $0x40, 0x59(%rax)
jne 0xb87f0
movq 0x70(%rax), %rax
jmp 0xb87d6
retq
| /frida[P]libxml2/xmlschemas.c |
xmlSchemaXPathEvaluate | static int
xmlSchemaXPathEvaluate(xmlSchemaValidCtxtPtr vctxt,
xmlElementType nodeType)
{
xmlSchemaIDCStateObjPtr sto, head = NULL, first;
int res, resolved = 0, depth = vctxt->depth;
if (vctxt->xpathStates == NULL)
return (0);
if (nodeType == XML_ATTRIBUTE_NODE)
depth++;
#ifdef DEBUG_IDC
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xd0(%rdi), %rbx
testq %rbx, %rbx
je 0xbe5ea
movl %esi, %ebp
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $0x2, %esi
sete %r13b
addl 0xac(%rdi), %r13d
xorl %r15d, %r15d
pushq $0x2
popq %r12
movq %rbx, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl ... | /frida[P]libxml2/xmlschemas.c |
xmlSchemaNewStringValue | xmlSchemaValPtr
xmlSchemaNewStringValue(xmlSchemaValType type,
const xmlChar *value)
{
xmlSchemaValPtr val;
if (type != XML_SCHEMAS_STRING)
return(NULL);
val = (xmlSchemaValPtr) xmlMalloc(sizeof(xmlSchemaVal));
if (val == NULL) {
return(NULL);
}
memset(val, 0, sizeof(xmlSchemaVal));
va... | cmpl $0x1, %edi
jne 0xc07c6
pushq %rbx
movq %rsi, %rbx
movq 0x6c82e(%rip), %rax # 0x12cfd0
pushq $0x30
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0xc07c9
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movl $0x1, (%rax)
movq %rbx, 0x10(%rax)
jmp 0xc07cb
xorl %eax, %eax
ret... | /frida[P]libxml2/xmlschemastypes.c |
xmlSchemaNewQNameValue | xmlSchemaValPtr
xmlSchemaNewQNameValue(const xmlChar *namespaceName,
const xmlChar *localName)
{
xmlSchemaValPtr val;
val = xmlSchemaNewValue(XML_SCHEMAS_QNAME);
if (val == NULL)
return (NULL);
val->value.qname.name = (xmlChar *) localName;
val->value.qname.uri = (xmlChar *) namespaceNam... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x6c7ae(%rip), %rax # 0x12cfd0
pushq $0x30
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0xc0848
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movl $0x15, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax... | /frida[P]libxml2/xmlschemastypes.c |
xmlSchemaGetBuiltInListSimpleTypeItemType | xmlSchemaTypePtr
xmlSchemaGetBuiltInListSimpleTypeItemType(xmlSchemaTypePtr type)
{
if ((type == NULL) || (type->type != XML_SCHEMA_TYPE_BASIC))
return (NULL);
switch (type->builtInType) {
case XML_SCHEMAS_NMTOKENS:
return (xmlSchemaTypeNmtokenDef );
case XML_SCHEMAS_IDREFS:
return (xmlSchemaTypeId... | testq %rdi, %rdi
je 0xc091c
cmpl $0x1, (%rdi)
jne 0xc091c
movl 0xa0(%rdi), %eax
cmpl $0x1b, %eax
je 0xc0927
cmpl $0x19, %eax
je 0xc091f
cmpl $0x13, %eax
jne 0xc091c
movq 0x6fb7d(%rip), %rax # 0x130498
retq
xorl %eax, %eax
retq
movq 0x6fb8a(%rip), %rax # 0x1304b0
retq
movq 0x6fb8a(%rip), %rax # 0x1304b8
retq... | /frida[P]libxml2/xmlschemastypes.c |
xmlSchemaDupVal | static xmlSchemaValPtr
xmlSchemaDupVal (xmlSchemaValPtr v)
{
xmlSchemaValPtr ret = xmlSchemaNewValue(v->type);
if (ret == NULL)
return NULL;
memcpy(ret, v, sizeof(xmlSchemaVal));
ret->next = NULL;
return ret;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq 0x69dd4(%rip), %rax # 0x12cfd0
pushq $0x30
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0xc3231
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movl %ebp, (%rax)
movups (%rbx), %xmm0
movups 0x10(%rbx), %... | /frida[P]libxml2/xmlschemastypes.c |
xmlSchemaCompareValuesInternal | static int
xmlSchemaCompareValuesInternal(xmlSchemaValType xtype,
xmlSchemaValPtr x,
const xmlChar *xvalue,
xmlSchemaWhitespaceValueType xws,
xmlSchemaValType ytype,
xmlSchemaValPtr y,
const xmlChar *yvalue,
xmlSchemaWhitespaceValueType yws)
{
sw... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $-0x2
popq %r12
leal -0x1(%rdi), %eax
cmpl $0x2d, %eax
ja 0xc380e
movq %r9, %rbx
movq %rsi, %r14
leaq 0x31cb4(%rip), %rsi # 0xf4f74
movslq (%rsi,%rax,4), %r9
addq %rsi, %r9
pushq $0x1
popq %rbp
movl %r8d, %eax
jmpq *%r9
testq %... | /frida[P]libxml2/xmlschemastypes.c |
xmlSchemaValidateFacet | int
xmlSchemaValidateFacet(xmlSchemaTypePtr base,
xmlSchemaFacetPtr facet,
const xmlChar *value,
xmlSchemaValPtr val)
{
/*
* This tries to ensure API compatibility regarding the old
* xmlSchemaValidateFacet() and the new xmlSchemaValidateFacetInternal() and
* xml... | movq %rcx, %r8
movq %rdx, %rcx
testq %r8, %r8
je 0xc416f
movl (%r8), %edx
movq %rsi, %rdi
xorl %esi, %esi
jmp 0xc4182
testq %rdi, %rdi
je 0xc418a
movl 0xa0(%rdi), %edx
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
jmp 0xc42fe
pushq $-0x1
popq %rax
retq
| /frida[P]libxml2/xmlschemastypes.c |
xmlSchemaDateNormalize | static xmlSchemaValPtr
xmlSchemaDateNormalize (xmlSchemaValPtr dt, double offset)
{
xmlSchemaValPtr dur, ret;
if (dt == NULL)
return NULL;
if (((dt->type != XML_SCHEMAS_TIME) &&
(dt->type != XML_SCHEMAS_DATETIME) &&
(dt->type != XML_SCHEMAS_DATE)) || (dt->value.date.tzo == 0))
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movl (%rdi), %eax
cmpl $0xb, %eax
ja 0xc51db
movl $0xc10, %ecx # imm = 0xC10
btl %eax, %ecx
jae 0xc51db
movzwl 0x28(%r15), %eax
testw $0x1ffe, %ax # imm = 0x1FFE
je 0xc51db
movsd %xmm0, 0x8(%rsp)
mov... | /frida[P]libxml2/xmlschemastypes.c |
xmlSchemaStrip | static xmlChar *
xmlSchemaStrip(const xmlChar *value) {
const xmlChar *start = value, *end, *f;
if (value == NULL) return(NULL);
while ((*start != 0) && (IS_BLANK_CH(*start))) start++;
end = start;
while (*end != 0) end++;
f = end;
end--;
while ((end > start) && (IS_BLANK_CH(*end))) end... | testq %rdi, %rdi
je 0xc58d1
xorl %eax, %eax
movabsq $0x100002600, %rcx # imm = 0x100002600
movzbl (%rdi,%rax), %r8d
cmpq $0x20, %r8
ja 0xc5889
btq %r8, %rcx
jae 0xc5889
incq %rax
jmp 0xc5873
addq %rax, %rdi
xorl %esi, %esi
movq %rdi, %rdx
testb %r8b, %r8b
je 0xc58a1
movb 0x1(%rdx), %r8b
incq %rdx
incl %esi
jmp 0xc... | /frida[P]libxml2/xmlschemastypes.c |
xmlSchemaNormLen | static int
xmlSchemaNormLen(const xmlChar *value) {
const xmlChar *utf;
int ret = 0;
if (value == NULL)
return(-1);
utf = value;
while (IS_BLANK_CH(*utf)) utf++;
while (*utf != 0) {
if (utf[0] & 0x80) {
if ((utf[1] & 0xc0) != 0x80)
return(-1);
if ((utf[0] & 0xe0) == 0xe0) {
if (... | pushq $-0x1
popq %rcx
testq %rdi, %rdi
je 0xc6274
movabsq $0x100002600, %rdx # imm = 0x100002600
movzbl (%rdi), %esi
cmpq $0x20, %rsi
ja 0xc61d1
btq %rsi, %rdx
jae 0xc61d1
incq %rdi
jmp 0xc61bd
xorl %eax, %eax
testb %sil, %sil
je 0xc6276
movzbl %sil, %r8d
js 0xc6207
cmpb $0x20, %sil
ja 0xc6261
btq %r8, %rdx
jae 0x... | /frida[P]libxml2/xmlschemastypes.c |
xmlStrcmp | int
xmlStrcmp(const xmlChar *str1, const xmlChar *str2) {
if (str1 == str2) return(0);
if (str1 == NULL) return(-1);
if (str2 == NULL) return(1);
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
return(strcmp((const char *)str1, (const char *)str2));
#else
do {
int tmp = *str1++ - *str2;
... | cmpq %rsi, %rdi
je 0xc6393
testq %rdi, %rdi
je 0xc6396
testq %rsi, %rsi
je 0xc639a
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %eax
movzbl (%rsi,%rcx), %edx
subl %edx, %eax
jne 0xc6395
incq %rcx
testb %dl, %dl
jne 0xc6380
xorl %eax, %eax
retq
pushq $-0x1
jmp 0xc639c
pushq $0x1
popq %rax
retq
| /frida[P]libxml2/xmlstring.c |
xmlStrncmp | int
xmlStrncmp(const xmlChar *str1, const xmlChar *str2, int len) {
if (len <= 0) return(0);
if (str1 == str2) return(0);
if (str1 == NULL) return(-1);
if (str2 == NULL) return(1);
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
return(strncmp((const char *)str1, (const char *)str2, len));
#else
... | testl %edx, %edx
setle %cl
cmpq %rsi, %rdi
sete %r8b
xorl %eax, %eax
orb %cl, %r8b
je 0xc644f
retq
testq %rdi, %rdi
je 0xc647b
testq %rsi, %rsi
je 0xc647f
decl %edx
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %eax
movzbl (%rsi,%rcx), %r8d
subl %r8d, %eax
jne 0xc644e
xorl %eax, %eax
cmpl %ecx, %edx
je 0xc644e
incq %rcx
testb %r... | /frida[P]libxml2/xmlstring.c |
xmlStrstr | const xmlChar *
xmlStrstr(const xmlChar *str, const xmlChar *val) {
int n;
if (str == NULL) return(NULL);
if (val == NULL) return(NULL);
n = xmlStrlen(val);
if (n == 0) return(str);
while (*str != 0) { /* non input consuming */
if (*str == *val) {
if (!xmlStrncmp(str, val, ... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xc6551
xorl %ebx, %ebx
jmp 0xc6586
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x33fa0
testl %eax, %eax
je 0xc6586
movl %eax, %ebp
movb (%rbx), %al
testb %al, %al
je 0xc654d
cmpb (%r14), %al
jne 0xc6581
movq ... | /frida[P]libxml2/xmlstring.c |
xmlStrPrintf | int XMLCDECL
xmlStrPrintf(xmlChar *buf, int len, const char *msg, ...) {
va_list args;
int ret;
if((buf == NULL) || (msg == NULL)) {
return(-1);
}
va_start(args, msg);
ret = vsnprintf((char *) buf, len, (const char *) msg, args);
va_end(args);
buf[len - 1] = 0; /* be safe ! */
... | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xc6881
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0x... | /frida[P]libxml2/xmlstring.c |
xmlGetUTF8Char | int
xmlGetUTF8Char(const unsigned char *utf, int *len) {
unsigned int c;
if (utf == NULL)
goto error;
if (len == NULL)
goto error;
if (*len < 1)
goto error;
c = utf[0];
if (c & 0x80) {
if (*len < 2)
goto error;
if ((utf[1] & 0xc0) != 0x80)
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rax
je 0xc6a18
testq %rsi, %rsi
jne 0xc6abd
retq
movl (%rsi), %edx
testl %edx, %edx
jle 0xc6abd
movzbl (%rdi), %ecx
testb %cl, %cl
js 0xc6a32
movl $0x1, (%rsi)
movl %ecx, %eax
retq
cmpl $0x1, %edx
je 0xc6abd
movb 0x1(%rdi), %r8b
andb $-0... | /frida[P]libxml2/xmlstring.c |
xmlUTF8Strpos | const xmlChar *
xmlUTF8Strpos(const xmlChar *utf, int pos) {
int ch;
if (utf == NULL) return(NULL);
if (pos < 0)
return(NULL);
while (pos--) {
if ((ch=*utf++) == 0) return(NULL);
if ( ch & 0x80 ) {
/* if not simple ascii, verify proper format */
if ( (ch ... | testq %rdi, %rdi
sete %cl
testl %esi, %esi
sets %dl
orb %cl, %dl
jne 0xc6ca7
movq %rdi, %rax
subl $0x1, %esi
jb 0xc6ca9
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0xc6ca7
incq %rax
testb %cl, %cl
jns 0xc6c78
movl %ecx, %edx
notl %edx
testb $-0x40, %dl
jne 0xc6ca7
testb $0x40, %cl
je 0xc6c78
addl %ecx, %ecx
movb (%rax), %d... | /frida[P]libxml2/xmlstring.c |
xmlUCSIsCatNl | int
xmlUCSIsCatNl(int code) {
return(((code >= 0x16ee) && (code <= 0x16f0)) ||
((code >= 0x2160) && (code <= 0x2183)) ||
(code == 0x3007) ||
((code >= 0x3021) && (code <= 0x3029)) ||
((code >= 0x3038) && (code <= 0x303a)) ||
(code == 0x1034a));
} | leal -0x16ee(%rdi), %ecx
pushq $0x1
popq %rax
cmpl $0x3, %ecx
jb 0xc78b5
leal -0x3038(%rdi), %ecx
cmpl $0x3, %ecx
jb 0xc78b5
leal -0x3021(%rdi), %ecx
cmpl $0x9, %ecx
jb 0xc78b5
cmpl $0x3007, %edi # imm = 0x3007
je 0xc78b5
leal -0x2160(%rdi), %ecx
cmpl $0x24, %ecx
jb 0xc78b5
xorl %eax, %eax
cmpl $0x1034a, %edi... | /frida[P]libxml2/xmlunicode.c |
xmlWriterErrMsg | static void
xmlWriterErrMsg(xmlTextWriterPtr ctxt, xmlParserErrors error,
const char *msg)
{
if (ctxt != NULL) {
__xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
} else {
__xmlRaiseError(NU... | testq %rdi, %rdi
je 0xc7b86
movq 0x38(%rdi), %rcx
jmp 0xc7b88
xorl %ecx, %ecx
subq $0x58, %rsp
movq %rdx, 0x50(%rsp)
leaq 0x1e828(%rip), %rax # 0xe63c0
movq %rax, 0x48(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
andl $0x0, 0x40(%rsp)
andl $0x0, 0x38(%rsp)
andq $0x0, 0x30(%rsp)
movl %esi, (%rsp)
andl $0x0, 0x1... | /frida[P]libxml2/xmlwriter.c |
xmlCmpTextWriterNsStackEntry | static int
xmlCmpTextWriterNsStackEntry(const void *data0, const void *data1)
{
xmlTextWriterNsStackEntry *p0;
xmlTextWriterNsStackEntry *p1;
int rc;
if (data0 == data1)
return 0;
if (data0 == 0)
return -1;
if (data1 == 0)
return 1;
p0 = (xmlTextWriterNsStackEntry... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq %rsi, %rdi
je 0xc7cb8
movq %rdi, %r15
pushq $-0x1
popq %rbp
testq %rdi, %rdi
je 0xc7cb1
movq %rsi, %r14
testq %rsi, %rsi
je 0xc7cb5
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x322b0
testl %eax, %eax
jne 0xc7cb1
movq 0x10(%r15), %rax
cmpq 0x10(%... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteDocCallback | static int
xmlTextWriterWriteDocCallback(void *context, const char *str, int len)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
int rc;
if ((rc = xmlParseChunk(ctxt, str, len, 0)) != 0) {
xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDocCallback... | pushq %rbx
movl %edx, %ebx
xorl %ecx, %ecx
callq 0x34be0
testl %eax, %eax
je 0xc7e30
leaq 0x31650(%rip), %rdi # 0xf9476
movl %eax, %esi
callq 0xcb7a0
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
| /frida[P]libxml2/xmlwriter.c |
xmlTextWriterEndPI | int
xmlTextWriterEndPI(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return 0;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %r15
testq %rdi, %rdi
je 0xc8702
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x33db0
xorl %ebp, %ebp
testq %rax, %rax
je 0xc8705
movq %rax, %rdi
callq 0x32280
testq %rax, %rax
je 0xc8705
movl 0x8(%rax), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0xc8... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterStartComment | int
xmlTextWriterStartComment(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartComment : invalid writer!\n");
return -1;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xc8a1c
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x33db0
xorl %ebp, %ebp
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0xc89c6
movq %rax, %rdi
callq 0x32280
testq %rax, %rax
je 0xc89c6
movq %rax, %r15
movl 0x8(%rax), %eax
testl %eax, %eax
je 0xc89... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterVSprintf | static xmlChar *
xmlTextWriterVSprintf(const char *format, va_list argptr)
{
int size;
int count;
xmlChar *buf;
va_list locarg;
size = BUFSIZ;
buf = (xmlChar *) xmlMalloc(size);
if (buf == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlTextWriterVSprint... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x6438b(%rip), %rax # 0x12cfd0
movl $0x2000, %r12d # imm = 0x2000
movl $0x2000, %edi # imm = 0x2000
callq *(%rax)
testq %rax, %rax
je 0xc8cbf
movq %rax, %rbx
movq %rsp, %r13
mov... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterFullEndElement | int
xmlTextWriterFullEndElement(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return -1;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0xc925b
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x33db0
testq %rax, %rax
je 0xc925b
movq %rax, %rdi
callq 0x32280
testq %rax, %rax
je 0xc925b
movq %rax, %r15
movl 0x8(%rax), %eax
cmpl $0x1, %eax
je ... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteFormatString | int XMLCDECL
xmlTextWriterWriteFormatString(xmlTextWriterPtr writer, const char *format,
...)
{
int rc;
va_list ap;
if ((writer == NULL) || (format == NULL))
return -1;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatString(writer, format, ap);
va_e... | subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xc9515
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0x... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteBinHex | int
xmlTextWriterWriteBinHex(xmlTextWriterPtr writer, const char *data,
int start, int len)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if ((writer == NULL) || (data == NULL) || (start < 0) || (len < 0))
return -1;
sum = 0;
lk = xmlList... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r13d
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
movl %ecx, %eax
orl %r13d, %eax
sets %al
orb %dl, %al
pushq $-0x1
popq %rbp
jne 0xc9881
movq %rdi, %r12
movq %rcx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %rd... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteFormatAttribute | int XMLCDECL
xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
const xmlChar * name, const char *format,
...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatAttribute(writer, name, format, ap);
... | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xc9b83
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0x... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteVFormatAttribute | int
xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc9bf3
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
movq %rcx, %rsi
callq 0xc8c2a
testq %rax, %rax
je 0xc9bf3
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x348b0
movl %eax, %ebx
movq 0x633c6(%rip), %rax # 0x12cfb0
movq %r15, %rdi
cal... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteVFormatAttributeNS | int
xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format, va_list ar... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xc9d16
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq %r8, %rdi
movq %r9, %rsi
callq 0xc8c2a
testq %rax, %rax
je 0xc9d16
movq %rax, %r12
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq ... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteVFormatElement | int
xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
const xmlChar * name, const char *format,
va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc9e4f
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
movq %rcx, %rsi
callq 0xc8c2a
testq %rax, %rax
je 0xc9e4f
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x358a0
movl %eax, %ebx
movq 0x6316a(%rip), %rax # 0x12cfb0
movq %r15, %rdi
cal... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteElement | int
xmlTextWriterWriteElement(xmlTextWriterPtr writer, const xmlChar * name,
const xmlChar * content)
{
int count;
int sum;
sum = 0;
count = xmlTextWriterStartElement(writer, name);
if (count == -1)
return -1;
sum += count;
if (content != NULL) {
count = x... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
callq 0x34120
pushq $-0x1
popq %rbx
cmpl $-0x1, %eax
je 0xc9e9c
movl %eax, %ebp
testq %r15, %r15
je 0xc9e8b
movq %r14, %rdi
movq %r15, %rsi
callq 0x33640
cmpl $-0x1, %eax
je 0xc9e9c
addl %eax, %ebp
movq %r14, %rdi
callq 0x34e90
cmpl ... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterStartDTDElement | int
xmlTextWriterStartDTDElement(xmlTextWriterPtr writer, const xmlChar * name)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL || name == NULL || *name == '\0')
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0) {
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rbx
jne 0xcab8d
movq %rsi, %r15
cmpb $0x0, (%rsi)
je 0xcab8d
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x33db0
testq %rax, %rax
je 0xcab8d
movq %rax, %rdi
callq 0x32280
xorl %ebp, %... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteVFormatDTDInternalEntity | int
xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char *format,
va_list argptr)
{
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xcb1a1
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, %rdi
movq %r8, %rsi
callq 0xc8c2a
testq %rax, %rax
je 0xcb1a1
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x35920
movl %eax, %ebx
movq 0... | /frida[P]libxml2/xmlwriter.c |
xmlTextWriterWriteDTDNotation | int
xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid, const xmlChar * sysid)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL || name == NULL || *name == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rbx
jne 0xcb702
movq %rsi, %r13
cmpb $0x0, (%rsi)
je 0xcb702
movq %rdx, %r12
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x33db0
testq %rax... | /frida[P]libxml2/xmlwriter.c |
libxml_domnode_tim_sort | void TIM_SORT(SORT_TYPE *dst, const size_t size) {
size_t minrun;
TEMP_STORAGE_T _store, *store;
TIM_SORT_RUN_T run_stack[TIM_SORT_STACK_SIZE];
size_t stack_curr = 0;
size_t curr = 0;
/* don't bother sorting an array of size 1 */
if (size <= 1) {
return;
}
if (size < 64) {
BINARY_INSERTION_S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x858, %rsp # imm = 0x858
movq %rdi, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
andq $0x0, 0x40(%rsp)
cmpq $0x2, %rsi
jae 0xcb934
addq $0x858, %rsp # imm = 0x858
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi... | /frida[P]libxml2/timsort.h |
xmlXPathIsInf | int
xmlXPathIsInf(double val) {
#ifdef isinf
return isinf(val) ? (val > 0 ? 1 : -1) : 0;
#else
if (val >= xmlXPathPINF)
return 1;
if (val <= -xmlXPathPINF)
return -1;
return 0;
#endif
} | movq %xmm0, %rax
btrq $0x3f, %rax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
xorl %edx, %edx
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
cmpq %rsi, %rax
leal -0x1(%rcx,%rcx), %eax
cmovnel %edx, %eax
retq
| /frida[P]libxml2/xpath.c |
xmlXPathErr | void
xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
{
if ((error < 0) || (error > MAXERRNO))
error = MAXERRNO;
if (ctxt == NULL) {
__xmlRaiseError(NULL, NULL, NULL,
NULL, NULL, XML_FROM_XPATH,
error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
XML_ERR_ERROR, NULL, 0,
NULL, NULL, NULL, 0... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
cmpl $0x1b, %esi
pushq $0x1b
popq %r14
cmovbl %esi, %r14d
testq %rdi, %rdi
je 0xcbf17
movq %rdi, %rbx
movl %r14d, 0x10(%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xcbf5b
addq $0xe8, %rdi
callq 0x34c50
movq 0x18(%rbx), %rax
movl $0xc, 0xe8(%rax)
leal 0x4b0(%r14), %e... | /frida[P]libxml2/xpath.c |
xmlXPathDebugDumpCompExpr | void
xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
int depth) {
int i;
char shift[100];
if ((output == NULL) || (comp == NULL)) return;
for (i = 0;((i < depth) && (i < 25));i++)
shift[2 * i] = shift[2 * i + 1] = ' ';
shift[2 * i] = shift[2 * i + 1] = ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xcc5fa
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jge 0xcc61d
cmpq $0x18, %rax
ja 0xcc61d
movw... | /frida[P]libxml2/xpath.c |
valuePop | xmlXPathObjectPtr
valuePop(xmlXPathParserContextPtr ctxt)
{
xmlXPathObjectPtr ret;
if ((ctxt == NULL) || (ctxt->valueNr <= 0))
return (NULL);
if (ctxt->valueNr <= ctxt->valueFrame) {
xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
return (NULL);
}
ctxt->valueNr... | testq %rdi, %rdi
je 0xcccd8
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0xcccd8
cmpl 0x50(%rdi), %eax
jle 0xcccdb
leal -0x1(%rax), %ecx
movl %ecx, 0x28(%rdi)
movq 0x30(%rdi), %rdx
cmpl $0x1, %eax
jne 0xccceb
xorl %eax, %eax
jmp 0xcccf0
xorl %eax, %eax
retq
pushq %rax
pushq $0x17
popq %rsi
callq 0x32750
xorl %eax, %eax... | /frida[P]libxml2/xpath.c |
xmlXPathReleaseObject | static void
xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
{
#define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
#define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->nu... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xcd06d
movq %rsi, %rbx
testq %rdi, %rdi
je 0xccee2
movq 0x158(%rdi), %r14
testq %r14, %r14
je 0xccee2
movl (%rbx), %eax
decl %eax
cmpl $0x8, %eax
ja 0xcd088
leaq 0x2c782(%rip), %rcx # 0xf9638
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), ... | /frida[P]libxml2/xpath.c |
xmlXPathCastToString | xmlChar *
xmlXPathCastToString(xmlXPathObjectPtr val) {
xmlChar *ret = NULL;
if (val == NULL)
return(xmlStrdup((const xmlChar *) ""));
switch (val->type) {
case XPATH_UNDEFINED:
#ifdef DEBUG_EXPR
xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
#endif
ret = xmlStrdup((const xmlCh... | testq %rdi, %rdi
je 0xcd214
movl (%rdi), %eax
cmpq $0x9, %rax
ja 0xcd220
leaq 0x2c482(%rip), %rcx # 0xf9684
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
jmp 0x32690
leaq 0x1b3ac(%rip), %rdi # 0xe85c7
jmp 0x35fc0
xorl %eax, %eax
retq
movq 0x20(%rdi), %rdi
jmp 0x35fc0
pushq %rbx
call... | /frida[P]libxml2/xpath.c |
xmlXPathPopExternal | void *
xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
xmlXPathObjectPtr obj;
void * ret;
if ((ctxt == NULL) || (ctxt->value == NULL)) {
xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
return(NULL);
}
if (ctxt->value->type != XPATH_USERS) {
xmlXPathSetTypeError(ctxt);
return(NULL);
}
... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xcd31e
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xcd32d
cmpl $0x8, (%rax)
jne 0xcd341
movq %rbx, %rdi
callq 0x33160
movq 0x28(%rax), %r14
andq $0x0, 0x28(%rax)
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0xcce80
jmp 0xcd356
xorl %r14d, %r14d
pushq $... | /frida[P]libxml2/xpath.c |
xmlXPathCmpNodes | int
xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
int depth1, depth2;
int attr1 = 0, attr2 = 0;
xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
xmlNodePtr cur, root;
if ((node1 == NULL) || (node2 == NULL))
return(-2);
/*
* a couple of optimizations which will avoid computations in... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
jne 0xcd3e8
cmpq %rsi, %rdi
je 0xcd3e6
movl 0x8(%rdi), %r9d
xorl %r10d, %r10d
cmpl $0x2, %r9d
jne 0xcd3e9
movq %rdi, %r8
movq 0x28(%rdi), %rdi
movl $0x1, %r11d
jmp 0xcd3ef
xorl %eax, %eax
retq
xorl %r11d, %r... | /frida[P]libxml2/xpath.c |
xmlXPathErrMemory | static void
xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
{
if (ctxt != NULL) {
xmlResetError(&ctxt->lastError);
if (extra) {
xmlChar buf[200];
xmlStrPrintf(buf, 200,
"Memory allocation failed : %s\n",
extra);... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r15
testq %rdi, %rdi
je 0xcd716
movq %rdi, %rbx
leaq 0xe8(%rdi), %r14
movq %r14, %rdi
callq 0x34c50
testq %r15, %r15
je 0xcd750
leaq 0xf0dc(%rip), %rdx # 0xdc7d6
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movl $0xc8, %esi... | /frida[P]libxml2/xpath.c |
xmlXPathNodeSetAdd | int
xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
int i;
if ((cur == NULL) || (val == NULL)) return(-1);
/* @@ with_ns to check whether namespace nodes should be looked at @@ */
/*
* prevent duplicates
*/
for (i = 0;i < cur->nodeNr;i++)
if (cur->nodeTab[i] == val) retur... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rbx
jne 0xcdb5b
movq %rsi, %r15
movq %rdi, %r14
movslq (%rdi), %rsi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpq %rax, %rcx
je 0xcdab0
movq 0x8(%r14), %rdx
leaq 0x1(%rax), %rdi
... | /frida[P]libxml2/xpath.c |
xmlXPathNodeSetRemove | void
xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
if (cur == NULL) return;
if (val >= cur->nodeNr) return;
if ((cur->nodeTab[val] != NULL) &&
(cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
cur->nodeNr--;
for (;val < cur->nodeNr;val++)
... | testq %rdi, %rdi
je 0xcde9f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl %esi, %eax
jle 0xcde98
movq 0x8(%rbx), %rcx
movslq %esi, %r14
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0xcde76
cmpl $0x12, 0x8(%rdi)
jne 0xcde76
callq 0x34ce0
movl (%rbx), %eax
decl %eax
movl %eax, (%rbx)
cltq
movq 0... | /frida[P]libxml2/xpath.c |
xmlXPathNewNodeSetList | xmlXPathObjectPtr
xmlXPathNewNodeSetList(xmlNodeSetPtr val)
{
xmlXPathObjectPtr ret;
int i;
if (val == NULL)
ret = NULL;
else if (val->nodeTab == NULL)
ret = xmlXPathNewNodeSet(NULL);
else {
ret = xmlXPathNewNodeSet(val->nodeTab[0]);
if (ret) {
for (i = 1... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xce018
movq %rdi, %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xce023
movq (%rax), %rdi
callq 0x350b0
testq %rax, %rax
je 0xce018
movq %rax, %rbx
pushq $0x1
popq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jge 0xce01a
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rax
movq (%... | /frida[P]libxml2/xpath.c |
xmlXPathIntersection | xmlNodeSetPtr
xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
int i, l1;
xmlNodePtr cur;
if (ret == NULL)
return(ret);
if (xmlXPathNodeSetIsEmpty(nodes1))
return(ret);
if (xmlXPathNodeSetIsEmpty(nodes2))
return(ret);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x35a90
movq %rax, %r15
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xce1c1
movl (%r14), %r13d
testl %r13d, %r13d
je 0xce1c1
testq %rbx, %rbx
je 0xce1c1
cmpq $0x0, ... | /frida[P]libxml2/xpath.c |
xmlXPathHasSameNodes | int
xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
int i, l;
xmlNodePtr cur;
if (xmlXPathNodeSetIsEmpty(nodes1) ||
xmlXPathNodeSetIsEmpty(nodes2))
return(0);
l = xmlXPathNodeSetGetLength(nodes1);
for (i = 0; i < l; i++) {
cur = xmlXPathNodeSetItem(nodes1, i);
if (xmlXPathN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xce37c
movq %rdi, %r15
movl (%rdi), %r12d
testl %r12d, %r12d
je 0xce37c
movq %rsi, %r14
testq %rsi, %rsi
je 0xce37c
cmpq $0x0, 0x8(%r15)
je 0xce37c
cmpl $0x0, (%r14)
je 0xce37c
cmpq $0x0, 0x8(%r14)
je 0xce3... | /frida[P]libxml2/xpath.c |
xmlXPathNodeLeadingSorted | xmlNodeSetPtr
xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
int i, l;
xmlNodePtr cur;
xmlNodeSetPtr ret;
if (node == NULL)
return(nodes);
ret = xmlXPathNodeSetCreate(NULL);
if (ret == NULL)
return(ret);
if (xmlXPathNodeSetIsEmpty(nodes) ||
(!xmlXPathNodeSetCo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xce412
movq %rsi, %r14
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x35a90
testq %rax, %rax
je 0xce415
movq %rax, %r15
testq %rbx, %rbx
je 0xce40d
cmpl $0x0, (%rbx)
je 0xce40d
cmpq $0x0, 0x8(%rbx)
je 0xce40d
movq %rbx, %rdi
movq %r1... | /frida[P]libxml2/xpath.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.