name string | code string | asm string | file string |
|---|---|---|---|
xmlNewStreamComp | static xmlStreamCompPtr
xmlNewStreamComp(int size) {
xmlStreamCompPtr cur;
if (size < 4)
size = 4;
cur = (xmlStreamCompPtr) xmlMalloc(sizeof(xmlStreamComp));
if (cur == NULL) {
ERROR(NULL, NULL, NULL,
"xmlNewStreamComp: malloc failed\n");
return(NULL);
}
memset(cur, 0, sizeof(xmlS... | pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x5, %edi
pushq $0x4
popq %rbp
cmovgel %edi, %ebp
movq 0xc2144(%rip), %r14 # 0x12cfd0
pushq $0x20
popq %rdi
callq *(%r14)
testq %rax, %rax
je 0x6aecb
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl %ebp, %edi
shlq $0x5, %rdi
callq *(%r14)
... | /frida[P]libxml2/pattern.c |
xmlStreamCompAddStep | static int
xmlStreamCompAddStep(xmlStreamCompPtr comp, const xmlChar *name,
const xmlChar *ns, int nodeType, int flags) {
xmlStreamStepPtr cur;
if (comp->nbStep >= comp->maxStep) {
cur = (xmlStreamStepPtr) xmlRealloc(comp->steps,
comp->maxStep * 2 * sizeof(xmlStreamStep));
if (cur =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x8(%rdi), %eax
movslq 0xc(%rdi), %rsi
cmpl %esi, %eax
jge 0x6aefd
movq 0x10(%r12), %rcx
jmp 0x6af26
movq 0xc1c8c(%rip), %rax # 0x12cb90
movq 0x10(%r12), %rdi
shlq $0x6, %rsi
c... | /frida[P]libxml2/pattern.c |
xmlRelaxNGFreeGrammar | static void
xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar)
{
if (grammar == NULL)
return;
if (grammar->children != NULL) {
xmlRelaxNGFreeGrammar(grammar->children);
}
if (grammar->next != NULL) {
xmlRelaxNGFreeGrammar(grammar->next);
}
if (grammar->refs != NULL) {
... | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6affb
callq 0x6afe9
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x6b009
callq 0x6afe9
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x6b019
xorl %esi, %esi
callq 0x35a40
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x6b029
xorl %esi, %esi
callq 0x35a40
movq 0... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGRegisterTypeLibrary | static int
xmlRelaxNGRegisterTypeLibrary(const xmlChar * namespace, void *data,
xmlRelaxNGTypeHave have,
xmlRelaxNGTypeCheck check,
xmlRelaxNGTypeCompare comp,
xmlRelaxNGFacetCheck facet,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc4cb0(%rip), %rdi # 0x12fee8
movq %rdi, %xmm0
movq %rbx, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xm... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGSchemaTypeHave | static int
xmlRelaxNGSchemaTypeHave(void *data ATTRIBUTE_UNUSED, const xmlChar * type)
{
xmlSchemaTypePtr typ;
if (type == NULL)
return (-1);
typ = xmlSchemaGetPredefinedType(type,
BAD_CAST
"http://www.w3.org/2001/XMLSchema")... | testq %rsi, %rsi
je 0x6b3ba
pushq %rax
leaq 0x7ba81(%rip), %rax # 0xe6e20
movq %rsi, %rdi
movq %rax, %rsi
callq 0x35d90
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
addq $0x8, %rsp
retq
pushq $-0x1
popq %rax
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGSchemaFacetCheck | static int
xmlRelaxNGSchemaFacetCheck(void *data ATTRIBUTE_UNUSED,
const xmlChar * type, const xmlChar * facetname,
const xmlChar * val, const xmlChar * strval,
void *value)
{
xmlSchemaFacetPtr facet;
xmlSchemaTypePtr typ;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
testq %rsi, %rsi
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
pushq $-0x1
popq %rbx
jne 0x6b71d
movq %r9, %r13
movq %r8, %r15
movq %rsi, %r12
movq %rcx, 0x10(%rsp)
leaq 0x7b8b5(%rip), %rsi # 0xe6e20
movq %r12, %rdi
c... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGDefaultTypeHave | static int
xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED,
const xmlChar * type)
{
if (type == NULL)
return (-1);
if (xmlStrEqual(type, BAD_CAST "string"))
return (1);
if (xmlStrEqual(type, BAD_CAST "token"))
return (1);
return (0);
} | testq %rsi, %rsi
je 0x6b757
pushq %rbx
movq %rsi, %rbx
leaq 0x81c72(%rip), %rsi # 0xed3b8
movq %rbx, %rdi
callq 0x35170
testl %eax, %eax
je 0x6b75b
pushq $0x1
popq %rax
jmp 0x6b773
pushq $-0x1
popq %rax
retq
leaq 0x7b771(%rip), %rsi # 0xe6ed3
movq %rbx, %rdi
callq 0x35170
movl %eax, %ecx
xorl %eax, %eax
testl %... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGDefaultTypeCompare | static int
xmlRelaxNGDefaultTypeCompare(void *data ATTRIBUTE_UNUSED,
const xmlChar * type,
const xmlChar * value1,
xmlNodePtr ctxt1 ATTRIBUTE_UNUSED,
void *comp1 ATTRIBUTE_UNUSED,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x81bed(%rip), %rsi # 0xed3b8
movq %r15, %rdi
callq 0x35170
testl %eax, %eax
je 0x6b7ec
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35170
leaq 0x7b6e0(%rip), %... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGFreeTypeLibrary | static void
xmlRelaxNGFreeTypeLibrary(void *payload,
const xmlChar * namespace ATTRIBUTE_UNUSED)
{
xmlRelaxNGTypeLibraryPtr lib = (xmlRelaxNGTypeLibraryPtr) payload;
if (lib == NULL)
return;
if (lib->namespace != NULL)
xmlFree((xmlChar *) lib->namespace);
xmlFre... | pushq %rbx
testq %rdi, %rdi
je 0x6b8da
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6b8cd
movq 0xc16e5(%rip), %rax # 0x12cfb0
callq *(%rax)
movq 0xc16dc(%rip), %rax # 0x12cfb0
movq %rbx, %rdi
popq %rbx
jmpq *(%rax)
popq %rbx
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGNewDocParserCtxt | xmlRelaxNGParserCtxtPtr
xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc)
{
xmlRelaxNGParserCtxtPtr ret;
xmlDocPtr copy;
if (doc == NULL)
return (NULL);
copy = xmlCopyDoc(doc, 1);
if (copy == NULL)
return (NULL);
ret =
(xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParser... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6baea
pushq $0x1
popq %rsi
callq 0x35650
testq %rax, %rax
je 0x6baea
movq %rax, %r14
movq 0xc1522(%rip), %rax # 0x12cfd0
movl $0x100, %edi # imm = 0x100
callq *(%rax)
testq %rax, %rax
je 0x6baf7
movq %rax, %rbx
movl $0x100, %edx # imm = 0x... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGFreeDocument | static void
xmlRelaxNGFreeDocument(xmlRelaxNGDocumentPtr docu)
{
if (docu == NULL)
return;
if (docu->href != NULL)
xmlFree(docu->href);
if (docu->doc != NULL)
xmlFreeDoc(docu->doc);
if (docu->schema != NULL)
xmlRelaxNGFreeInnerSchema(docu->schema);
xmlFree(docu);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6bc2a
movq 0xc1388(%rip), %rax # 0x12cfb0
callq *(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x6bc38
callq 0x35080
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x6bc8d
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x6bc4f
call... | /frida[P]libxml2/relaxng.c |
xmlRngPErr | static void LIBXML_ATTR_FORMAT(4,0)
xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
const char *msg, const xmlChar * str1, const xmlChar * str2)
{
xmlStructuredErrorFunc schannel = NULL;
xmlGenericErrorFunc channel = NULL;
void *data = NULL;
if (ctxt != NULL) {
i... | movq %rsi, %rax
testq %rdi, %rdi
je 0x6bf22
movq %rdi, %r11
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x6bf2b
xorl %esi, %esi
jmp 0x6bf2f
xorl %edi, %edi
xorl %esi, %esi
xorl %r10d, %r10d
jmp 0x6bf36
movq 0x8(%r11), %rsi
movq (%r11), %r10
incl 0x44(%r11)
subq $0x68, %rsp
movq %r9, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGCleanupDoc | static xmlDocPtr
xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
{
xmlNodePtr root;
/*
* Extract the root
*/
root = xmlDocGetRootElement(doc);
if (root == NULL) {
xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x32870
testq %rax, %rax
je 0x6bfb5
movq %r14, %rdi
movq %rax, %rsi
callq 0x6dd19
jmp 0x6bfd8
movq 0x80(%r14), %r8
leaq 0x7ad4b(%rip), %rcx # 0xe6d0e
movq %r14, %rdi
movq %rbx, %rsi
movl $0x3fe, %edx # imm = 0x3FE
xorl... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGParseDocument | static xmlRelaxNGPtr
xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
{
xmlRelaxNGPtr schema = NULL;
const xmlChar *olddefine;
xmlRelaxNGGrammarPtr old;
if ((ctxt == NULL) || (node == NULL))
return (NULL);
schema = xmlRelaxNGNewRelaxNG(ctxt);
if (schema == NULL)
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0xc0fd7(%rip), %rax # 0x12cfd0
pushq $0x50
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0x6c0b6
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGTryCompile | static int
xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
{
int ret = 0;
xmlRelaxNGDefinePtr list;
if ((ctxt == NULL) || (def == NULL))
return (-1);
if ((def->type == XML_RELAXNG_START) ||
(def->type == XML_RELAXNG_ELEMENT)) {
ret = xmlRelaxNGIsComp... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r15
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x6c61f
movl (%rbx), %ecx
movl %ecx, %edx
orl $0x10, %edx
movl $0x0, %eax
cmpl $0x14, %edx
jne 0x6c5dd
movq %rbx, %rdi
callq 0x73aaa
testb $0x40, 0x62(%rbx)
je 0x6c5db
cmpw $-... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGGetParserErrors | int
xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc * err,
xmlRelaxNGValidityWarningFunc * warn, void **ctx)
{
if (ctxt == NULL)
return (-1);
if (err != NULL)
*err = ctxt->error;
if (warn != NULL)
... | testq %rdi, %rdi
je 0x6c68d
testq %rsi, %rsi
je 0x6c673
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
testq %rdx, %rdx
je 0x6c67f
movq 0x10(%rdi), %rax
movq %rax, (%rdx)
xorl %eax, %eax
testq %rcx, %rcx
je 0x6c68c
movq (%rdi), %rdx
movq %rdx, (%rcx)
retq
pushq $-0x1
popq %rax
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGSetParserStructuredErrors | void
xmlRelaxNGSetParserStructuredErrors(xmlRelaxNGParserCtxtPtr ctxt,
xmlStructuredErrorFunc serror,
void *ctx)
{
if (ctxt == NULL)
return;
ctxt->serror = serror;
ctxt->error = NULL;
ctxt->warning = NULL;
ctxt->userData = ctx;
} | testq %rdi, %rdi
je 0x6c6a4
movq %rsi, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rdx, (%rdi)
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGDump | void
xmlRelaxNGDump(FILE * output, xmlRelaxNGPtr schema)
{
if (output == NULL)
return;
if (schema == NULL) {
fprintf(output, "RelaxNG empty or failed to compile\n");
return;
}
fprintf(output, "RelaxNG: ");
if (schema->doc == NULL) {
fprintf(output, "no document\n");
... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6c6f7
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6c6fd
leaq 0x7a697(%rip), %rdi # 0xe6d58
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x35710
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x6c70b
movq 0x88(%rax), %rdx
testq %rdx, %rdx... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGValidatePushElement | int
xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc ATTRIBUTE_UNUSED,
xmlNodePtr elem)
{
int ret = 1;
if ((ctxt == NULL) || (elem == NULL))
return (-1);
#ifdef DEBUG_PROGRESSIVE
xmlGenericError(xmlGenericErrorCont... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
pushq $-0x1
popq %rbx
jne 0x6c956
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0x88(%rdi)
je 0x6c8c7
movq %r15, 0xa8(%r14)
andl $0x0, 0xa0(%r14)
movq 0x10(%r15), %rsi
movq 0x48(%r15), %rax
movq 0x88(%r14), %rdi
testq %rax, %... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGValidateProgressiveCallback | static void
xmlRelaxNGValidateProgressiveCallback(xmlRegExecCtxtPtr exec
ATTRIBUTE_UNUSED,
const xmlChar * token,
void *transdata, void *inputdata)
{
xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rdx
testq %rcx, %rcx
je 0x6cc87
movq %rcx, %rbx
movq 0xa8(%rcx), %r14
movl $0x1, 0xa0(%rcx)
testq %r15, %r15
je 0x6cc29
cmpl $0x4, (%r15)
jne 0x6ccad
cmpl $0x1, 0x8(%r14)
jne 0x6cc41
movq 0x68(%r15), %rdi
testq %rdi... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGValidatePushCData | int
xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
const xmlChar * data, int len ATTRIBUTE_UNUSED)
{
int ret = 1;
if ((ctxt == NULL) || (ctxt->elem == NULL) || (data == NULL))
return (-1);
#ifdef DEBUG_PROGRESSIVE
xmlGenericError(xmlGenericErrorContext, "CDATA... | pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x6ce86
movq %rdi, %r14
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x6ce86
movabsq $0x100002600, %rax # imm = 0x100002600
movzbl (%rsi), %ecx
cmpq $0x20, %rcx
ja 0x6ce70
btq %rcx, %rax
jae 0x6... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGElemPop | static xmlRegExecCtxtPtr
xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt)
{
xmlRegExecCtxtPtr ret;
if (ctxt->elemNr <= 0)
return (NULL);
ctxt->elemNr--;
ret = ctxt->elemTab[ctxt->elemNr];
ctxt->elemTab[ctxt->elemNr] = NULL;
if (ctxt->elemNr > 0)
ctxt->elem = ctxt->elemTab[ctxt->el... | movl 0x90(%rdi), %ecx
testl %ecx, %ecx
jle 0x6cf49
decl %ecx
movl %ecx, 0x90(%rdi)
movq 0x98(%rdi), %rdx
movq (%rdx,%rcx,8), %rax
andq $0x0, (%rdx,%rcx,8)
testl %ecx, %ecx
je 0x6cf4c
movq 0x98(%rdi), %rdx
movq -0x8(%rdx,%rcx,8), %rcx
jmp 0x6cf4e
xorl %eax, %eax
retq
xorl %ecx, %ecx
movq %rcx, 0x88(%rdi)
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGValidateFullElement | int
xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc ATTRIBUTE_UNUSED,
xmlNodePtr elem)
{
int ret;
xmlRelaxNGValidStatePtr state;
if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL))
return (-1);
#ifdef DEB... | pushq %rbp
pushq %r14
pushq %rbx
pushq $-0x1
popq %rbp
testq %rdi, %rdi
je 0x6cfc7
movq %rdx, %r14
testq %rdx, %rdx
je 0x6cfc7
movq %rdi, %rbx
cmpq $0x0, 0xb0(%rdi)
je 0x6cfc7
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x6cfce
testq %rax, %rax
je 0x6cfc7
movq %r14, 0x8(%rax)
movq %rax, 0x60(%rbx)
andl $0x0, 0x44(%rbx)... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGFreeValidState | static void
xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGValidStatePtr state)
{
if (state == NULL)
return;
if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
}
if ((ctxt == NULL) || (ctxt->freeS... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6d5d9
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0x6d57c
movq 0x70(%r15), %r14
testq %r14, %r14
jne 0x6d56a
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x75090
movq %rax, %r14
movq %rax, 0x70(%r15)
testq %rax, %rax
je 0x6d57c
movl (%r... | /frida[P]libxml2/relaxng.c |
xmlRngVErrMemory | static void
xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra)
{
xmlStructuredErrorFunc schannel = NULL;
xmlGenericErrorFunc channel = NULL;
void *data = NULL;
if (ctxt != NULL) {
if (ctxt->serror != NULL)
schannel = ctxt->serror;
else
channel = ctxt->error;
dat... | subq $0x58, %rsp
movq %rsi, %rax
testq %rdi, %rdi
je 0x6d6a5
movq %rdi, %rcx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x6d6ad
xorl %esi, %esi
jmp 0x6d6b1
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x6d6b7
movq 0x8(%rcx), %rsi
movq (%rcx), %rdx
incl 0x20(%rcx)
testq %rax, %rax
je 0x6d6f1
movq %rax, 0x50(%rsp)
... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGSetValidErrors | void
xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc err,
xmlRelaxNGValidityWarningFunc warn, void *ctx)
{
if (ctxt == NULL)
return;
ctxt->error = err;
ctxt->warning = warn;
ctxt->userData = ctx;
ctxt->serror... | testq %rdi, %rdi
je 0x6d938
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, (%rdi)
andq $0x0, 0x18(%rdi)
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGSetValidStructuredErrors | void
xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
xmlStructuredErrorFunc serror, void *ctx)
{
if (ctxt == NULL)
return;
ctxt->serror = serror;
ctxt->error = NULL;
ctxt->warning = NULL;
ctxt->userData = ctx;
} | testq %rdi, %rdi
je 0x6d94c
movq %rsi, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rdx, (%rdi)
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGGetValidErrors | int
xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc * err,
xmlRelaxNGValidityWarningFunc * warn, void **ctx)
{
if (ctxt == NULL)
return (-1);
if (err != NULL)
*err = ctxt->error;
if (warn != NULL)
*wa... | testq %rdi, %rdi
je 0x6d978
testq %rsi, %rsi
je 0x6d95e
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
testq %rdx, %rdx
je 0x6d96a
movq 0x10(%rdi), %rax
movq %rax, (%rdx)
xorl %eax, %eax
testq %rcx, %rcx
je 0x6d977
movq (%rdi), %rdx
movq %rdx, (%rcx)
retq
pushq $-0x1
popq %rax
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGValidateDoc | int
xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
{
int ret;
if ((ctxt == NULL) || (doc == NULL))
return (-1);
ctxt->doc = doc;
ret = xmlRelaxNGValidateDocument(ctxt, doc);
/*
* Remove all left PSVI
*/
xmlRelaxNGCleanPSVI((xmlNodePtr) doc);
/*
*... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x6d990
pushq $-0x1
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x30(%rdi)
movq 0x28(%rdi), %rax
pushq $-0x1
popq %r13
testq %rax, %rax
je 0x6db3e
andl $0x... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGRemoveRedefine | static int
xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
const xmlChar * URL ATTRIBUTE_UNUSED,
xmlNodePtr target, const xmlChar * name)
{
int found = 0;
xmlNodePtr tmp, tmp2;
xmlChar *name2;
#ifdef DEBUG_INCLUDE
if (name == NULL)
xmlGen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
leaq 0x77cb8(%rip), %r15 # 0xe6eaf
testq %r13, %r13
je 0x6f3a0
movq %r13, %rbp
movq 0x30(%r13), %r13
movq 0x48(%rbp), %rax
testq %rbx, %rbx
je 0x6f2aa
testq %rax, %rax
je 0x6f2f6
cmpl $0x1,... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGCheckReference | static void
xmlRelaxNGCheckReference(void *payload, void *data, const xmlChar * name)
{
xmlRelaxNGDefinePtr ref = (xmlRelaxNGDefinePtr) payload;
xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
xmlRelaxNGGrammarPtr grammar;
xmlRelaxNGDefinePtr def, cur;
/*
* Those rules don't app... | pushq %r15
pushq %r14
pushq %rbx
testb $0x1, 0x63(%rdi)
jne 0x70d44
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x70ceb
cmpq $0x0, 0x30(%r15)
je 0x70d0c
movq 0x8(%r15), %rsi
leaq 0x771a2(%rip), %rcx # 0xe7e8b
jmp 0x70cf6
movq 0x8(%r15), %rsi
leaq 0x77164(%rip), %rcx ... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGParsePattern | static xmlRelaxNGDefinePtr
xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
{
xmlRelaxNGDefinePtr def = NULL;
if (node == NULL) {
return (NULL);
}
if (IS_RELAXNG(node, "element")) {
def = xmlRelaxNGParseElement(ctxt, node);
} else if (IS_RELAXNG(node, "attribute... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x48(%rsi)
je 0x7228e
cmpl $0x1, 0x8(%r14)
jne 0x7228e
movq 0x10(%r14), %rdi
leaq 0x78554(%rip), %rsi # 0xe95b7
callq 0x35170
movq 0x48(%r14), %rcx
testl %eax, %eax
je 0x710a1
movq 0x10(%rcx... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGTryUnlink | static xmlRelaxNGDefinePtr
xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
xmlRelaxNGDefinePtr cur,
xmlRelaxNGDefinePtr parent, xmlRelaxNGDefinePtr prev)
{
if (prev != NULL) {
prev->next = cur->next;
} else {
if (parent != NULL) {
... | testq %rdx, %rdx
je 0x72d30
movq %rdx, %rax
movq 0x40(%rdi), %rcx
movq %rcx, 0x40(%rdx)
retq
testq %rsi, %rsi
je 0x72d51
cmpq %rdi, 0x30(%rsi)
je 0x72d58
cmpq %rdi, 0x48(%rsi)
je 0x72d62
cmpq %rdi, 0x50(%rsi)
jne 0x72d6a
movq 0x40(%rdi), %rax
movq %rax, 0x50(%rsi)
jmp 0x72d6a
orl $-0x1, (%rdi)
movq %rdi, %rax
retq
movq... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGGenerateAttributes | static int
xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
xmlRelaxNGDefinePtr def)
{
xmlRelaxNGDefinePtr parent, cur, tmp;
/*
* Don't run that check in case of error. Infinite recursion
* becomes possible.
*/
if (ctxt->nbErrors != 0)
return (-... | cmpl $0x0, 0x44(%rdi)
je 0x72d77
pushq $-0x1
popq %rax
retq
pushq $0x1
popq %rax
movl $0xffc00, %ecx # imm = 0xFFC00
movl $0x1f9, %edx # imm = 0x1F9
movq %rsi, %r8
testq %r8, %r8
je 0x72d76
movq %r8, %rdi
movl (%r8), %r8d
cmpl $0x13, %r8d
ja 0x72dbf
btl %r8d, %ecx
jae 0x72db9
movq 0x30(%rdi), %r8
te... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGGroupContentType | static xmlRelaxNGContentType
xmlRelaxNGGroupContentType(xmlRelaxNGContentType ct1,
xmlRelaxNGContentType ct2)
{
if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
(ct2 == XML_RELAXNG_CONTENT_ERROR))
return (XML_RELAXNG_CONTENT_ERROR);
if (ct1 == XML_RELAXNG_CONTENT_EMPTY)
... | cmpl $-0x1, %edi
sete %cl
cmpl $-0x1, %esi
sete %dl
orb %cl, %dl
je 0x72f89
pushq $-0x1
popq %rax
retq
movl %esi, %eax
testl %edi, %edi
je 0x72fa5
testl %eax, %eax
je 0x72fa6
xorl $0x2, %edi
xorl $0x2, %eax
xorl %ecx, %ecx
orl %edi, %eax
sete %cl
leal (%rcx,%rcx,2), %eax
decl %eax
retq
movl %edi, %eax
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGGetElements | static xmlRelaxNGDefinePtr *
xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
xmlRelaxNGDefinePtr def, int eora)
{
xmlRelaxNGDefinePtr *ret = NULL, parent, cur, tmp;
int len = 0;
int max = 0;
/*
* Don't run that check in case of error. Infinite recursion
* becomes pos... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r13d, %r13d
cmpl $0x0, 0x44(%rdi)
je 0x73010
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movl $0x1b8, %edx ... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGCompareNameClasses | static int
xmlRelaxNGCompareNameClasses(xmlRelaxNGDefinePtr def1,
xmlRelaxNGDefinePtr def2)
{
int ret = 1;
xmlNode node;
xmlNs ns;
xmlRelaxNGValidCtxt ctxt;
memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));
ctxt.flags = FLAGS_IGNORABLE | FLAGS_NOERROR;
if ((def1-... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa8(%rsp), %r15
xorl %ebp, %ebp
movl $0xc0, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x32350
movl $0x9, 0x38(%r15)
movl (%rbx), %eax
addl $-0x2, %eax
cmpl $0x7, %eax
ja 0x732a1
leaq 0x736e7(%ri... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGElementMatch | static int
xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGDefinePtr define, xmlNodePtr elem)
{
int ret = 0, oldflags = 0;
if (define->name != NULL) {
if (!xmlStrEqual(elem->name, define->name)) {
VALID_ERR3(XML_RELAXNG_ERR_ELEMNAME, define->name, elem->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x733e2
movq 0x10(%r15), %rdi
callq 0x35170
testl %eax, %eax
je 0x73428
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x73416
cmpb $0x0, (%rsi)
movq 0x48(%r15), %rax
je 0x7343b
te... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGIsCompilable | static int
xmlRelaxNGIsCompilable(xmlRelaxNGDefinePtr def)
{
int ret = -1;
if (def == NULL) {
return (-1);
}
if ((def->type != XML_RELAXNG_ELEMENT) &&
(def->dflags & IS_COMPILABLE))
return (1);
if ((def->type != XML_RELAXNG_ELEMENT) &&
(def->dflags & IS_NOT_COMPILABL... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x73bc8
movq %rdi, %rbx
movl (%rdi), %edx
movzwl 0x62(%rdi), %ecx
cmpl $0x4, %edx
jne 0x73b1c
testb $-0x40, %cl
jne 0x73b9d
leaq 0x30(%rbx), %r14
pushq $-0x1
popq %rcx
pushq $0x1
popq %rbp
movq (%r14), %r14
testq %r14, %r14... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGCompile | static int
xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
{
int ret = 0;
xmlRelaxNGDefinePtr list;
if ((ctxt == NULL) || (def == NULL))
return (-1);
switch (def->type) {
case XML_RELAXNG_START:
if ((xmlRelaxNGIsCompilable(def) == 1) && (def->depth ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $-0x1
popq %r15
leaq 0x72e4f(%rip), %rax # 0xe6a80
testq %r14, %r14
je 0x7406e
movslq (%r14), %rcx
leal 0x1(%rcx), %edx
cmpl $0x15, %edx
ja 0x7406b
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGDumpDefine | static void
xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define)
{
if (define == NULL)
return;
switch (define->type) {
case XML_RELAXNG_EMPTY:
fprintf(output, "<empty/>\n");
break;
case XML_RELAXNG_NOT_ALLOWED:
fprintf(output, "<notAllowed/>... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x740ce
movq %rsi, %r14
movl (%rsi), %eax
incl %eax
cmpl $0x15, %eax
ja 0x740ce
movq %rdi, %rbx
leaq 0x72a38(%rip), %rcx # 0xe6ad8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x34700
movq (%rax), %rbx
callq 0x335a0
movq (%rax), %rdi
leaq 0x74495(%... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGLogBestError | static void
xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
{
int best;
if ((ctxt == NULL) || (ctxt->states == NULL) ||
(ctxt->states->nbState <= 0))
return;
best = xmlRelaxNGBestState(ctxt);
if ((best >= 0) && (best < ctxt->states->nbState)) {
ctxt->state = ctxt->states->t... | pushq %rbx
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0x746c4
movl (%rcx), %eax
testl %eax, %eax
jle 0x746c4
movq 0x8(%rcx), %rcx
movl $0xf4240, %r9d # imm = 0xF4240
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %esi, %esi
movl $0x186a0, %r8d # imm = 0x186A0
cmpq %rsi, %rax
je 0x746ab
movq (%rcx... | /frida[P]libxml2/relaxng.c |
xmlRelaxNGValidateValueContent | static int
xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGDefinePtr defines)
{
int ret = 0;
while (defines != NULL) {
ret = xmlRelaxNGValidateValue(ctxt, defines);
if (ret != 0)
break;
defines = defines->next;
}
r... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x748a8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7498f
testl %eax, %eax
jne 0x748aa
movq 0x40(%rbx), %rbx
jmp 0x7488e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGValidateValueList | static int
xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGDefinePtr defines)
{
int ret = 0;
while (defines != NULL) {
ret = xmlRelaxNGValidateValue(ctxt, defines);
if (ret != 0)
break;
defines = defines->next;
}
return ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x75030
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7498f
testl %eax, %eax
jne 0x75032
movq 0x40(%rbx), %rbx
jmp 0x75016
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /frida[P]libxml2/relaxng.c |
xmlRelaxNGAddStates | static int
xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGStatesPtr states,
xmlRelaxNGValidStatePtr state)
{
int i;
if (state == NULL || states == NULL) {
return (-1);
}
if (states->nbState >= states->maxState) {
xmlRelaxNGValidStatePt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rbp
jne 0x76771
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x4(%rsi), %r12
cmpl %r12d, (%rsi)
jl 0x766a9
movq 0xb6508(%rip), %rax # 0x12cb90
mov... | /frida[P]libxml2/relaxng.c |
xmlSAX2StartElementNs | void
xmlSAX2StartElementNs(void *ctx,
const xmlChar *localname,
const xmlChar *prefix,
const xmlChar *URI,
int nb_namespaces,
const xmlChar **namespaces,
int nb_attributes,
int nb_defaulted,
const xmlChar **attributes)
{
xmlParserCtxtPtr ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x18(%rsp)
testq %rdi, %rdi
je 0x78e12
movq %r9, %r12
movl %r8d, %r13d
movq %rsi, %r8
movq %rdi, %r15
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x88(%rsp), %ebp
movl 0x80(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x50(%rdi... | /frida[P]libxml2/SAX2.c |
xmlSAX2AttributeNs | static void
xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
const xmlChar * localname,
const xmlChar * prefix,
const xmlChar * value,
const xmlChar * valueend)
{
xmlAttrPtr ret;
xmlNsPtr namespace = NULL;
xmlChar *dup = NULL;
/*
* Note: if prefix == NULL, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x78e55
movq 0x10(%rbx), %rdi
movq 0x50(%rbx), %rsi
movq %r12, %rdx
callq 0x35940
jmp 0x78e57
xorl %eax, %eax
movq 0x250(%rbx), %r14
testq... | /frida[P]libxml2/SAX2.c |
xmlSAX2Reference | void
xmlSAX2Reference(void *ctx, const xmlChar *name)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
xmlNodePtr ret;
if (ctx == NULL) return;
#ifdef DEBUG_SAX
xmlGenericError(xmlGenericErrorContext,
"SAX.xmlSAX2Reference(%s)\n", name);
#endif
if (name[0] == '#')
ret = xmlNewCharRef(ctxt->m... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x793a8
movq %rdi, %rbx
cmpb $0x23, (%rsi)
movq 0x10(%rdi), %rdi
jne 0x7938f
callq 0x32930
jmp 0x79394
callq 0x328b0
movq %rax, %r14
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq 0x34ea0
testq %rax, %rax
je 0x793b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %r... | /frida[P]libxml2/SAX2.c |
xmlSAX2Text | static void
xmlSAX2Text(xmlParserCtxtPtr ctxt, const xmlChar *ch, int len,
xmlElementType type)
{
xmlNodePtr lastChild;
if (ctxt == NULL) return;
#ifdef DEBUG_SAX
xmlGenericError(xmlGenericErrorContext,
"SAX.xmlSAX2Characters(%.30s, %d)\n", ch, len);
#endif
/*
* Handle the data if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x79513
movq %rdi, %rbx
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x79513
movl %edx, %r14d
movq %rsi, %r15
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x79473
cmpl %ecx, 0x8(%r12)
jne 0x79488
cmpl $0x3, %ecx
jne 0x79412
movq 0x10(%r12), %rax
cmpq ... | /frida[P]libxml2/SAX2.c |
xmlNsErrMsg | static void LIBXML_ATTR_FORMAT(3,0)
xmlNsErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
const char *msg, const xmlChar *str1, const xmlChar *str2)
{
if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
(ctxt->instate == XML_PARSER_EOF))
return;
if (ctxt != NULL)
ctxt->errNo = error;
... | movq %rdi, %rax
cmpl $0x0, 0x14c(%rdi)
je 0x79acb
cmpl $-0x1, 0x110(%rax)
je 0x79b2f
subq $0x68, %rsp
movl %esi, 0x88(%rax)
movq %r8, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
andl $0x0, 0x40(%rsp)
movq %r8, 0x28(%rsp)
andl $0x0, 0x38(%rsp)
movq %rcx, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movl %esi, (%rsp)
andl... | /frida[P]libxml2/SAX2.c |
xmlSchematronFree | void
xmlSchematronFree(xmlSchematronPtr schema)
{
if (schema == NULL)
return;
if ((schema->doc != NULL) && (!(schema->preserve)))
xmlFreeDoc(schema->doc);
if (schema->namespaces != NULL)
xmlFree((char **) schema->namespaces);
xmlSchematronFreeRules(schema->rules);
xmlSchem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x79ebb
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x79d9f
cmpl $0x0, 0x8(%rbx)
jne 0x79d9f
callq 0x35080
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x79db1
movq 0xb3201(%rip), %rax # 0x12cfb0
callq *(%rax... | /frida[P]libxml2/schematron.c |
xmlSchematronNewParserCtxt | xmlSchematronParserCtxtPtr
xmlSchematronNewParserCtxt(const char *URL)
{
xmlSchematronParserCtxtPtr ret;
if (URL == NULL)
return (NULL);
ret =
(xmlSchematronParserCtxtPtr)
xmlMalloc(sizeof(xmlSchematronParserCtxt));
if (ret == NULL) {
xmlSchematronPErrMemory(NULL, "allo... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x79f6d
movq %rdi, %r14
movq 0xb30ef(%rip), %rax # 0x12cfd0
movl $0x90, %edi
callq *(%rax)
testq %rax, %rax
je 0x79f41
movq %rax, %rbx
movl $0x90, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x32350
movl $0x1, (%rbx)
callq 0x326b0
movq %rax, 0x30(%rbx)
pushq $-0x1... | /frida[P]libxml2/schematron.c |
xmlSchematronNewDocParserCtxt | xmlSchematronParserCtxtPtr
xmlSchematronNewDocParserCtxt(xmlDocPtr doc)
{
xmlSchematronParserCtxtPtr ret;
if (doc == NULL)
return (NULL);
ret =
(xmlSchematronParserCtxtPtr)
xmlMalloc(sizeof(xmlSchematronParserCtxt));
if (ret == NULL) {
xmlSchematronPErrMemory(NULL, "all... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7a0ea
movq %rdi, %r14
movq 0xb2f41(%rip), %rax # 0x12cfd0
movl $0x90, %edi
callq *(%rax)
testq %rax, %rax
je 0x7a0ee
movq %rax, %rbx
movl $0x90, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x32350
movq %r14, 0x10(%rbx)
callq 0x326b0
movq %rax, 0x30(%rbx)
movl $0... | /frida[P]libxml2/schematron.c |
xmlSchematronRegisterVariables | static int
xmlSchematronRegisterVariables(xmlXPathContextPtr ctxt, xmlSchematronLetPtr let,
xmlDocPtr instance, xmlNodePtr cur)
{
xmlXPathObjectPtr let_eval;
ctxt->doc = instance;
ctxt->node = cur;
while (let != NULL) {
let_eval = xmlXPathCompiledEval(let->comp, c... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
leaq 0x6e3b6(%rip), %rbx # 0xe981d
xorl %r14d, %r14d
leaq 0x6e3d6(%rip), %r13 # 0xe9847
testq %r15, %r15
je 0x7b4c0
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0x34fa0
testq %rax, %rax
j... | /frida[P]libxml2/schematron.c |
xmlSchematronUnregisterVariables | static int
xmlSchematronUnregisterVariables(xmlXPathContextPtr ctxt, xmlSchematronLetPtr let)
{
while (let != NULL) {
if (xmlXPathRegisterVariableNS(ctxt, let->name, NULL, NULL)) {
xmlGenericError(xmlGenericErrorContext,
"Unregistering a let variable failed\n");
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
testq %r14, %r14
je 0x7bbea
movq 0x8(%r14), %rsi
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x34760
testl %eax, %eax
jne 0x7bbcc
movq (%r14), %r14
jmp 0x7bbae
callq 0x34700
movq (%rax), %rbx
callq 0x335a0
movq (%rax), %rdi
leaq ... | /frida[P]libxml2/schematron.c |
xmlSchematronNextNode | static xmlNodePtr
xmlSchematronNextNode(xmlNodePtr cur) {
if (cur->children != NULL) {
/*
* Do not descend on entities declarations
*/
if (cur->children->type != XML_ENTITY_DECL) {
cur = cur->children;
/*
* Skip DTDs
*/
... | movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x7bc0b
movl 0x8(%rax), %ecx
cmpl $0x11, %ecx
je 0x7bc0b
cmpl $0xe, %ecx
jne 0x7bc27
movq %rax, %rdi
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x7bc37
movl 0x8(%rax), %ecx
movq %rax, %rdi
cmpl $0xe, %ecx
je 0x7bc0b
movq %rax, %rdi
cmpl $0x11, %ecx
je 0x7bc0b
retq
cmpl $0x9, 0x8... | /frida[P]libxml2/schematron.c |
xmlNewMutex | xmlMutexPtr
xmlNewMutex(void)
{
xmlMutexPtr tok;
if ((tok = malloc(sizeof(xmlMutex))) == NULL)
return (NULL);
#ifdef HAVE_POSIX_THREADS
if (libxml_is_threaded != 0)
pthread_mutex_init(&tok->lock, NULL);
#elif defined HAVE_WIN32_THREADS
InitializeCriticalSection(&tok->cs);
#endif
ret... | pushq %rbx
pushq $0x28
popq %rdi
callq 0x35f00
movq %rax, %rbx
testq %rax, %rax
je 0x7bec4
cmpl $0x0, 0xb35d4(%rip) # 0x12f48c
je 0x7bec4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x35f10
movq %rbx, %rax
popq %rbx
retq
| /frida[P]libxml2/threads.c |
xmlMutexLock | void
xmlMutexLock(xmlMutexPtr tok)
{
if (tok == NULL)
return;
#ifdef HAVE_POSIX_THREADS
if (libxml_is_threaded != 0)
pthread_mutex_lock(&tok->lock);
#elif defined HAVE_WIN32_THREADS
EnterCriticalSection(&tok->cs);
#endif
} | testq %rdi, %rdi
je 0x7beff
cmpl $0x0, 0xb3593(%rip) # 0x12f48c
jne 0x35f98
retq
| /frida[P]libxml2/threads.c |
xmlFreeRMutex | void
xmlFreeRMutex(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
{
if (tok == NULL)
return;
#ifdef HAVE_POSIX_THREADS
if (libxml_is_threaded != 0) {
pthread_mutex_destroy(&tok->lock);
pthread_cond_destroy(&tok->cv);
}
#elif defined HAVE_WIN32_THREADS
DeleteCriticalSection(&tok->cs);
#endif
... | testq %rdi, %rdi
je 0x7bf7b
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xb352d(%rip) # 0x12f48c
je 0x7bf72
movq %rbx, %rdi
callq 0x35fb0
leaq 0x38(%rbx), %rdi
callq 0x35ed8
movq %rbx, %rdi
popq %rbx
jmp 0x35f20
retq
| /frida[P]libxml2/threads.c |
xmlRMutexUnlock | void
xmlRMutexUnlock(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
{
if (tok == NULL)
return;
#ifdef HAVE_POSIX_THREADS
if (libxml_is_threaded == 0)
return;
pthread_mutex_lock(&tok->lock);
tok->held--;
if (tok->held == 0) {
if (tok->waiters)
pthread_cond_signal(&tok->cv);
... | testq %rdi, %rdi
je 0x7c040
cmpl $0x0, 0xb3479(%rip) # 0x12f48c
je 0x7c040
pushq %rbx
movq %rdi, %rbx
callq 0x35f98
decl 0x28(%rbx)
jne 0x7c037
cmpl $0x0, 0x2c(%rbx)
je 0x7c032
leaq 0x38(%rbx), %rdi
callq 0x35ef0
andq $0x0, 0x30(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x35fb8
retq
| /frida[P]libxml2/threads.c |
_xmlGlobalInitMutexLock | void
__xmlGlobalInitMutexLock(void)
{
/* Make sure the global init lock is initialized and then lock it. */
#ifdef HAVE_POSIX_THREADS
/* The mutex is statically initialized, so we just lock it. */
#ifdef XML_PTHREAD_WEAK
if (pthread_mutex_lock == NULL)
return;
#endif /* XML_PTHREAD_WEAK */
pthre... | cmpq $0x0, 0xb0ef7(%rip) # 0x12cf40
je 0x7c057
leaq 0xb3e9e(%rip), %rdi # 0x12fef0
jmp 0x35f98
retq
| /frida[P]libxml2/threads.c |
_xmlGlobalInitMutexUnlock | void
__xmlGlobalInitMutexUnlock(void)
{
#ifdef HAVE_POSIX_THREADS
#ifdef XML_PTHREAD_WEAK
if (pthread_mutex_unlock == NULL)
return;
#endif /* XML_PTHREAD_WEAK */
pthread_mutex_unlock(&global_init_lock);
#elif defined HAVE_WIN32_THREADS
if (global_init_lock != NULL) {
LeaveCriticalSection(global_ini... | cmpq $0x0, 0xb0f48(%rip) # 0x12cfa8
je 0x7c06e
leaq 0xb3e87(%rip), %rdi # 0x12fef0
jmp 0x35fb8
retq
| /frida[P]libxml2/threads.c |
_xmlGlobalInitMutexDestroy | void
__xmlGlobalInitMutexDestroy(void)
{
#ifdef HAVE_POSIX_THREADS
#elif defined HAVE_WIN32_THREADS
if (global_init_lock != NULL) {
DeleteCriticalSection(global_init_lock);
free(global_init_lock);
global_init_lock = NULL;
}
#endif
} | retq
| /frida[P]libxml2/threads.c |
xmlGetGlobalState | xmlGlobalStatePtr
xmlGetGlobalState(void)
{
#ifdef HAVE_POSIX_THREADS
xmlGlobalState *globalval;
if (libxml_is_threaded == 0)
return (NULL);
pthread_once(&once_control, xmlOnceInit);
if ((globalval = (xmlGlobalState *)
pthread_getspecific(globalkey)) == NULL) {
xmlGlobalState... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0xb3411(%rip) # 0x12f48c
je 0x7c0d0
leaq 0xb3e94(%rip), %rdi # 0x12ff18
leaq 0x72(%rip), %rsi # 0x7c0fd
callq 0x35f08
movl 0xb3e86(%rip), %edi # 0x12ff1c
callq 0x35f80
movq %rax, %rbx
testq %rax, %rax
jne 0x7c0d2
pushq $0x1
popq %rdi
movl $0x3c8, %esi ... | /frida[P]libxml2/threads.c |
xmlOnceInit | static void
xmlOnceInit(void)
{
#ifdef HAVE_POSIX_THREADS
(void) pthread_key_create(&globalkey, xmlFreeGlobalState);
mainthread = pthread_self();
__xmlInitializeDict();
#elif defined(HAVE_WIN32_THREADS)
if (!run_once.done) {
if (InterlockedIncrement(&run_once.control) == 1) {
#if !defined(HAVE_C... | pushq %rax
leaq 0xb3e17(%rip), %rdi # 0x12ff1c
leaq 0x1a9(%rip), %rsi # 0x7c2b5
callq 0x35f48
callq 0x35f50
movq %rax, 0xb3e03(%rip) # 0x12ff20
popq %rax
jmp 0x334d0
| /frida[P]libxml2/threads.c |
xmlValidateNCName | int
xmlValidateNCName(const xmlChar *value, int space) {
const xmlChar *cur = value;
int c,l;
if (value == NULL)
return(-1);
/*
* First quick algorithm for ASCII range
*/
if (space)
while (IS_BLANK_CH(*cur)) cur++;
if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*... | testq %rdi, %rdi
je 0x7c4c6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0x7c4ca
movabsq $0x100002600, %rdx # imm = 0x100002600
movq %rbx, %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x7c4cf
btq %rcx, %rdx
jae 0x7c4cf
incq %rax
jm... | /frida[P]libxml2/tree.c |
xmlValidateQName | int
xmlValidateQName(const xmlChar *value, int space) {
const xmlChar *cur = value;
int c,l;
if (value == NULL)
return(-1);
/*
* First quick algorithm for ASCII range
*/
if (space)
while (IS_BLANK_CH(*cur)) cur++;
if (((*cur >= 'a') && (*cur <= 'z')) || ((*cur >= 'A') && (*cu... | testq %rdi, %rdi
je 0x7c7df
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0x7c7e3
movabsq $0x100002600, %rdx # imm = 0x100002600
movq %rbx, %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x7c7e8
btq %rcx, %rdx
jae 0x7c7e8
incq %rax
jm... | /frida[P]libxml2/tree.c |
xmlValidateNMToken | int
xmlValidateNMToken(const xmlChar *value, int space) {
const xmlChar *cur = value;
int c,l;
if (value == NULL)
return(-1);
/*
* First quick algorithm for ASCII range
*/
if (space)
while (IS_BLANK_CH(*cur)) cur++;
if (((*cur >= 'a') && (*cur <= 'z')) ||
((*cur >= 'A... | testq %rdi, %rdi
je 0x7d044
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0x7d048
movabsq $0x100002600, %rdx # imm = 0x100002600
movq %rbx, %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x7d04d
btq %rcx, %rdx
jae 0x7d04d
incq %rax
jm... | /frida[P]libxml2/tree.c |
xmlFreeNs | void
xmlFreeNs(xmlNsPtr cur) {
if (cur == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlFreeNs : ns == NULL\n");
#endif
return;
}
if (cur->href != NULL) xmlFree((char *) cur->href);
if (cur->prefix != NULL) xmlFree((char *) cur->prefix);
xmlFree(cur);
} | pushq %rbx
testq %rdi, %rdi
je 0x7d51a
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x7d4fb
movq 0xafab7(%rip), %rax # 0x12cfb0
callq *(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x7d50d
movq 0xafaa5(%rip), %rax # 0x12cfb0
callq *(%rax)
movq 0xafa9c(%rip), %rax # 0x12cfb0
movq %rbx, %rdi
p... | /frida[P]libxml2/tree.c |
xmlSetNs | void
xmlSetNs(xmlNodePtr node, xmlNsPtr ns) {
if (node == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlSetNs: node == NULL\n");
#endif
return;
}
if ((node->type == XML_ELEMENT_NODE) ||
(node->type == XML_ATTRIBUTE_NODE))
node->ns = ns;
} | testq %rdi, %rdi
je 0x7d52f
movl 0x8(%rdi), %eax
decl %eax
cmpl $0x1, %eax
ja 0x7d52f
movq %rsi, 0x48(%rdi)
retq
| /frida[P]libxml2/tree.c |
xmlFreeNsList | void
xmlFreeNsList(xmlNsPtr cur) {
xmlNsPtr next;
if (cur == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlFreeNsList : ns == NULL\n");
#endif
return;
}
while (cur != NULL) {
next = cur->next;
xmlFreeNs(cur);
cur = next;
}
} | testq %rdi, %rdi
je 0x7d549
pushq %rbx
testq %rdi, %rdi
je 0x7d548
movq (%rdi), %rbx
callq 0x32360
movq %rbx, %rdi
jmp 0x7d536
popq %rbx
retq
| /frida[P]libxml2/tree.c |
xmlCreateIntSubset | xmlDtdPtr
xmlCreateIntSubset(xmlDocPtr doc, const xmlChar *name,
const xmlChar *ExternalID, const xmlChar *SystemID) {
xmlDtdPtr cur;
if ((doc != NULL) && (xmlGetIntSubset(doc) != NULL)) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlCreateIntSubset(): document... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
testq %rdi, %rdi
je 0x7d680
movq %r14, %rdi
callq 0x34260
testq %rax, %rax
jne 0x7d7ce
movq 0xaf949(%rip), %rax # 0x12cfd0
movl $0x80, %edi
callq *(%rax)
testq %rax, %rax
je 0x7d764
movq %rax, %rbx... | /frida[P]libxml2/tree.c |
xmlFreeDtd | void
xmlFreeDtd(xmlDtdPtr cur) {
xmlDictPtr dict = NULL;
if (cur == NULL) {
return;
}
if (cur->doc != NULL) dict = cur->doc->dict;
if ((__xmlRegisterCallbacks) && (xmlDeregisterNodeDefaultValue))
xmlDeregisterNodeDefaultValue((xmlNodePtr)cur);
if (cur->children != NULL) {
xmlNodePtr next, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x7d86a
movq %rdi, %rbx
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x7d873
movq 0x98(%rax), %r14
jmp 0x7d876
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
movq 0xaf3ab(%rip), %rax # 0x12cc28
cmpl $0x0, (%rax)
je 0x7... | /frida[P]libxml2/tree.c |
xmlUnlinkNode | void
xmlUnlinkNode(xmlNodePtr cur) {
if (cur == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlUnlinkNode : node == NULL\n");
#endif
return;
}
if (cur->type == XML_NAMESPACE_DECL)
return;
if (cur->type == XML_DTD_NODE) {
xmlDocPtr doc;
doc = cur->doc;
if (doc... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7db23
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x12, %eax
je 0x7db23
cmpl $0x11, %eax
je 0x7da00
cmpl $0xe, %eax
jne 0x7dabb
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x7dabb
cmpq %rbx, 0x50(%rax)
jne 0x7d9ec
andq $0x0, 0x50(%rax)
cmpq %rbx, 0x58(%rax)
jne 0x7dab... | /frida[P]libxml2/tree.c |
xmlNewDoc | xmlDocPtr
xmlNewDoc(const xmlChar *version) {
xmlDocPtr cur;
if (version == NULL)
version = (const xmlChar *) "1.0";
/*
* Allocate a new document and fill the fields.
*/
cur = (xmlDocPtr) xmlMalloc(sizeof(xmlDoc));
if (cur == NULL) {
xmlTreeErrMemory("building doc");
return(NULL);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xaf2db(%rip), %rax # 0x12cfd0
movl $0xb0, %edi
callq *(%rax)
testq %rax, %rax
je 0x7dd80
movq %rax, %rbx
testq %r14, %r14
leaq 0x691c1(%rip), %r15 # 0xe6ecf
cmovneq %r14, %r15
movl $0xb0, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x32350
movl $0x9, 0x8(%rb... | /frida[P]libxml2/tree.c |
xmlFreeDoc | void
xmlFreeDoc(xmlDocPtr cur) {
xmlDtdPtr extSubset, intSubset;
xmlDictPtr dict = NULL;
if (cur == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlFreeDoc : document == NULL\n");
#endif
return;
}
if (cur != NULL) dict = cur->dict;
if ((__xmlRegisterCallbacks)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7df4f
movq %rdi, %r14
movq 0x98(%rdi), %rbx
movq 0xaee55(%rip), %rax # 0x12cc28
cmpl $0x0, (%rax)
je 0x7dded
callq 0x332e0
cmpq $0x0, (%rax)
je 0x7dded
callq 0x332e0
movq %r14, %rdi
callq *(%rax)
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0... | /frida[P]libxml2/tree.c |
xmlFreeNodeList | void
xmlFreeNodeList(xmlNodePtr cur) {
xmlNodePtr next;
xmlNodePtr parent;
xmlDictPtr dict = NULL;
size_t depth = 0;
if (cur == NULL) return;
if (cur->type == XML_NAMESPACE_DECL) {
xmlFreeNsList((xmlNsPtr) cur);
return;
}
if (cur->doc != NULL) dict = cur->doc->dict;
while (1) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x7e14f
movq %rdi, %r12
cmpl $0x12, 0x8(%rdi)
jne 0x7df91
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34590
movq 0x40(%r12), %rax
testq %rax, %rax
je 0x7dfa9
movq... | /frida[P]libxml2/tree.c |
xmlNewReference | xmlNodePtr
xmlNewReference(const xmlDoc *doc, const xmlChar *name) {
xmlNodePtr cur;
xmlEntityPtr ent;
if (name == NULL)
return(NULL);
/*
* Allocate a new node and fill the fields.
*/
cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
if (cur == NULL) {
xmlTreeErrMemory("buildin... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x7e76d
movq %rsi, %r15
movq %rdi, %r14
movq 0xae8ce(%rip), %rax # 0x12cfd0
pushq $0x78
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0x7e761
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x60(%... | /frida[P]libxml2/tree.c |
xmlNewProp | xmlAttrPtr
xmlNewProp(xmlNodePtr node, const xmlChar *name, const xmlChar *value) {
if (name == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlNewProp : name == NULL\n");
#endif
return(NULL);
}
return xmlNewPropInternal(node, NULL, name, value, 0);
} | testq %rsi, %rsi
je 0x7edb2
movq %rdx, %rcx
movq %rsi, %rdx
xorl %esi, %esi
xorl %r8d, %r8d
jmp 0x7edb5
xorl %eax, %eax
retq
| /frida[P]libxml2/tree.c |
xmlNewPropInternal | static xmlAttrPtr
xmlNewPropInternal(xmlNodePtr node, xmlNsPtr ns,
const xmlChar * name, const xmlChar * value,
int eatname)
{
xmlAttrPtr cur;
xmlDocPtr doc = NULL;
if ((node != NULL) && (node->type != XML_ELEMENT_NODE)) {
if ((eatname == 1) &&
((node->doc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
je 0x7eddf
cmpl $0x1, 0x8(%r14)
jne 0x7ee62
movq 0xae1ea(%rip), %rax # 0x12cfd0
pushq $0x60
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0x7ee9... | /frida[P]libxml2/tree.c |
xmlNewNsProp | xmlAttrPtr
xmlNewNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name,
const xmlChar *value) {
if (name == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlNewNsProp : name == NULL\n");
#endif
return(NULL);
}
return xmlNewPropInternal(node, ns, name, value, 0... | testq %rdx, %rdx
je 0x7efcb
xorl %r8d, %r8d
jmp 0x7edb5
xorl %eax, %eax
retq
| /frida[P]libxml2/tree.c |
xmlNewDocProp | xmlAttrPtr
xmlNewDocProp(xmlDocPtr doc, const xmlChar *name, const xmlChar *value) {
xmlAttrPtr cur;
if (name == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlNewDocProp : name == NULL\n");
#endif
return(NULL);
}
/*
* Allocate a new property and fill the fields.... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x7f0c9
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0xadfd0(%rip), %rax # 0x12cfd0
pushq $0x60
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0x7f0bd
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x50(%rax)
movu... | /frida[P]libxml2/tree.c |
xmlRemoveProp | int
xmlRemoveProp(xmlAttrPtr cur) {
xmlAttrPtr tmp;
if (cur == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlRemoveProp : cur == NULL\n");
#endif
return(-1);
}
if (cur->parent == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlRemoveProp... | pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x7f1fa
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x7f1fa
pushq %rax
movq 0x58(%rcx), %rdx
cmpq %rdi, %rdx
je 0x7f1dc
testq %rdx, %rdx
je 0x7f1f6
movq %rdx, %rcx
movq 0x30(%rdx), %rdx
cmpq %rdi, %rdx
jne 0x7f1bc
movq 0x30(%rdi), %rax
movq %rax, 0x30(%rcx)
testq %rax, %rax
jne 0... | /frida[P]libxml2/tree.c |
xmlNewDocNodeEatName | xmlNodePtr
xmlNewDocNodeEatName(xmlDocPtr doc, xmlNsPtr ns,
xmlChar *name, const xmlChar *content) {
xmlNodePtr cur;
cur = xmlNewNodeEatName(ns, name);
if (cur != NULL) {
cur->doc = doc;
if (content != NULL) {
cur->children = xmlStringGetNodeList(doc, content);
UPDATE_LAST_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x33d20
movq %rax, %rbx
testq %rax, %rax
je 0x7f4f0
movq %r15, 0x40(%rbx)
testq %r12, %r12
je 0x7f525
movq %r15, %rdi
movq %r12, %rsi
callq 0x33c40
movq %rax, 0x18(%rbx)
testq %ra... | /frida[P]libxml2/tree.c |
xmlNewDocFragment | xmlNodePtr
xmlNewDocFragment(xmlDocPtr doc) {
xmlNodePtr cur;
/*
* Allocate a new DocumentFragment node and fill the fields.
*/
cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
if (cur == NULL) {
xmlTreeErrMemory("building fragment");
return(NULL);
}
memset(cur, 0, sizeof(xmlNode));
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xada36(%rip), %rax # 0x12cfd0
pushq $0x78
popq %rdi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x7f5f8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm... | /frida[P]libxml2/tree.c |
xmlNewCDataBlock | xmlNodePtr
xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len) {
xmlNodePtr cur;
/*
* Allocate a new node and fill the fields.
*/
cur = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
if (cur == NULL) {
xmlTreeErrMemory("building CDATA");
return(NULL);
}
memset(cur, 0, sizeof(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0xad65e(%rip), %rax # 0x12cfd0
pushq $0x78
popq %rdi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x7f9e3
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x60(%rbx)
movups ... | /frida[P]libxml2/tree.c |
copyStringForNewDictIfNeeded | static const xmlChar *_copyStringForNewDictIfNeeded(xmlDictPtr oldDict, xmlDictPtr newDict, const xmlChar *oldValue) {
const xmlChar *newValue = oldValue;
if (oldValue) {
int oldDictOwnsOldValue = oldDict && (xmlDictOwns(oldDict, oldValue) == 1);
if (oldDictOwnsOldValue) {
if (newDic... | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x7fb5a
movq %rdx, %rbx
testq %rdi, %rdi
je 0x7fb5c
movq %rsi, %r14
movq %rbx, %rsi
callq 0x33f90
cmpl $0x1, %eax
jne 0x7fb5c
testq %r14, %r14
je 0x7fb67
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x323f0
xorl %ebx, ... | /frida[P]libxml2/tree.c |
xmlSetListDoc | void
xmlSetListDoc(xmlNodePtr list, xmlDocPtr doc) {
xmlNodePtr cur;
if ((list == NULL) || (list->type == XML_NAMESPACE_DECL))
return;
cur = list;
while (cur != NULL) {
if (cur->doc != doc)
xmlSetTreeDoc(cur, doc);
cur = cur->next;
}
} | testq %rdi, %rdi
je 0x7fb8f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x12, 0x8(%rdi)
jne 0x7fb90
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
testq %r14, %r14
je 0x7fb88
cmpq %rbx, 0x40(%r14)
je 0x7fba9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33070
movq 0x30(%r14), %r14
jmp 0x7fb93
| /frida[P]libxml2/tree.c |
xmlNewChild | xmlNodePtr
xmlNewChild(xmlNodePtr parent, xmlNsPtr ns,
const xmlChar *name, const xmlChar *content) {
xmlNodePtr cur, prev;
if (parent == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlNewChild : parent == NULL\n");
#endif
return(NULL);
}
if (name == NULL)... | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %dil
orb %al, %dil
jne 0x7fc38
movl 0x8(%rbx), %edi
decl %edi
rorl %edi
xorl %eax, %eax
cmpl $0x6, %edi
ja 0x7fc47
leaq 0x69d6a(%rip), %r8 # 0xe9944
movslq (%r8,%rdi,4), %rdi
addq %r8, %rdi
jmpq *%rdi
movq %rbx, %rdi
testq %rsi, %rsi
jne 0x... | /frida[P]libxml2/tree.c |
xmlAddPrevSibling | xmlNodePtr
xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem) {
if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlAddPrevSibling : cur == NULL\n");
#endif
return(NULL);
}
if ((elem == NULL) || (elem->type == XML_NAMESPACE_DECL)... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7fec2
movq %rsi, %rbx
xorl %eax, %eax
testq %rsi, %rsi
je 0x7fec4
movq %rdi, %r14
cmpl $0x12, 0x8(%rdi)
je 0x7fec4
xorl %eax, %eax
cmpq %rbx, %r14
je 0x7fec4
cmpl $0x12, 0x8(%rbx)
je 0x7fec4
movq %rbx, %rdi
callq 0x331e0
movl 0x8(%rbx), %eax
cmpl $0x2, %eax
je 0x7f... | /frida[P]libxml2/tree.c |
xmlAddSibling | xmlNodePtr
xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem) {
xmlNodePtr parent;
if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL)) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlAddSibling : cur == NULL\n");
#endif
return(NULL);
}
if ((elem == NULL) || (elem->type == XM... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7ff7b
movq %rsi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x12, %eax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
je 0x7ff89
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
cmpq %rbx, %rdi
je 0x7ff7e
cmpl $0x12, 0x8(%rbx)
je 0... | /frida[P]libxml2/tree.c |
xmlFirstElementChild | xmlNodePtr
xmlFirstElementChild(xmlNodePtr parent) {
xmlNodePtr cur = NULL;
if (parent == NULL)
return(NULL);
switch (parent->type) {
case XML_ELEMENT_NODE:
case XML_ENTITY_NODE:
case XML_DOCUMENT_NODE:
case XML_DOCUMENT_FRAG_NODE:
case XML_HTML_DOCUMENT_NODE... | testq %rdi, %rdi
je 0x80356
movl 0x8(%rdi), %ecx
xorl %eax, %eax
cmpl $0xd, %ecx
ja 0x80358
movl $0x2a42, %edx # imm = 0x2A42
btl %ecx, %edx
jae 0x80358
addq $0x18, %rdi
movq %rdi, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x80356
cmpl $0x1, 0x8(%rax)
je 0x80358
addq $0x30, %rax
jmp 0x80342
xorl %eax, %eax
r... | /frida[P]libxml2/tree.c |
xmlStaticCopyNode | xmlNodePtr
xmlStaticCopyNode(xmlNodePtr node, xmlDocPtr doc, xmlNodePtr parent,
int extended) {
xmlNodePtr ret;
if (node == NULL) return(NULL);
switch (node->type) {
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_ELEMENT_NODE:
case XML_DOCUMENT_F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x807b1
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x8(%rdi), %eax
addl $-0x2, %eax
cmpl $0x10, %eax
ja 0x807f6
leaq 0x691b8(%rip), %rcx # 0xe9960
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmp... | /frida[P]libxml2/tree.c |
xmlSearchNs | xmlNsPtr
xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace) {
xmlNsPtr cur;
const xmlNode *orig = node;
if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) return(NULL);
if ((nameSpace != NULL) &&
(xmlStrEqual(nameSpace, (const xmlChar *)"xml"))) {
if ((doc == NULL) && (node... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x80c0e
movq %rsi, %rbx
cmpl $0x12, 0x8(%rsi)
jne 0x80c20
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r15
testq %rdx, %rdx
je 0x80c64
movq %rdi, %r12
leaq 0x6b4fe(%rip), %rsi # 0... | /frida[P]libxml2/tree.c |
xmlNewReconciledNs | static xmlNsPtr
xmlNewReconciledNs(xmlDocPtr doc, xmlNodePtr tree, xmlNsPtr ns) {
xmlNsPtr def;
xmlChar prefix[50];
int counter = 1;
if ((tree == NULL) || (tree->type != XML_ELEMENT_NODE)) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"xmlNewReconciledNs : tree == NULL\n");
#end... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x80e0b
movq %rsi, %rbx
cmpl $0x1, 0x8(%rsi)
jne 0x80e0b
movq %rdx, %r14
cmpl $0x12, 0x8(%rdx)
jne 0x80e08
movq %rdi, %r15
movq 0x10(%r14), %rdx
movq %rbx, %rsi
callq 0x347d0
movq %rax, %r12
testq %r... | /frida[P]libxml2/tree.c |
xmlCopyDtd | xmlDtdPtr
xmlCopyDtd(xmlDtdPtr dtd) {
xmlDtdPtr ret;
xmlNodePtr cur, p = NULL, q;
if (dtd == NULL) return(NULL);
ret = xmlNewDtd(NULL, dtd->name, dtd->ExternalID, dtd->SystemID);
if (ret == NULL) return(NULL);
if (dtd->entities != NULL)
ret->entities = (void *) xmlCopyEntitiesTable(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x810de
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x68(%rdi), %rdx
movq 0x70(%rdi), %rcx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x32470
testq %rax, %rax
je 0x810e1
movq %rax, %r14
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x80fc4
callq 0x35670... | /frida[P]libxml2/tree.c |
xmlGetLineNoInternal | static long
xmlGetLineNoInternal(const xmlNode *node, int depth)
{
long result = -1;
if (depth >= 5)
return(-1);
if (!node)
return result;
if ((node->type == XML_ELEMENT_NODE) ||
(node->type == XML_TEXT_NODE) ||
(node->type == XML_COMMENT_NODE) ||
(node->type == XML_PI_NODE))... | pushq %rbx
pushq $-0x1
popq %rax
movl $0x18a, %ecx # imm = 0x18A
testq %rdi, %rdi
je 0x8117e
cmpl $0x4, %esi
jg 0x8117e
movl 0x8(%rdi), %edx
cmpl $0x8, %edx
ja 0x8113f
btl %edx, %ecx
jb 0x8116e
movq 0x38(%rdi), %rdx
testq %rdx, %rdx
je 0x81158
movl 0x8(%rdx), %r8d
cmpl $0x8, %r8d
ja 0x81158
btl %r8d, %ecx
jb... | /frida[P]libxml2/tree.c |
xmlDocGetRootElement | xmlNodePtr
xmlDocGetRootElement(const xmlDoc *doc) {
xmlNodePtr ret;
if (doc == NULL) return(NULL);
ret = doc->children;
while (ret != NULL) {
if (ret->type == XML_ELEMENT_NODE)
return(ret);
ret = ret->next;
}
return(ret);
} | testq %rdi, %rdi
je 0x817bc
movq %rdi, %rax
addq $0x18, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x817bc
cmpl $0x1, 0x8(%rax)
je 0x817be
addq $0x30, %rax
jmp 0x817a8
xorl %eax, %eax
retq
| /frida[P]libxml2/tree.c |
xmlSearchNsByHref | xmlNsPtr
xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node, const xmlChar * href)
{
xmlNsPtr cur;
xmlNodePtr orig = node;
int is_attr;
if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) || (href == NULL))
return (NULL);
if (xmlStrEqual(href, XML_XML_NAMESPACE)) {
/*
* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x81a4b
movq %rdx, %r15
xorl %r14d, %r14d
testq %rdx, %rdx
je 0x81a4e
movq %rsi, %rbx
cmpl $0x12, 0x8(%rsi)
je 0x81a4e
movq %rdi, %r12
leaq 0x5ac1c(%rip), %rsi # 0xdc4ef
movq %r15, %rdi
callq 0x35170
testl %eax, %eax
je 0x81906
testq %r12, %... | /frida[P]libxml2/tree.c |
xmlNodeSetSpacePreserve | void
xmlNodeSetSpacePreserve(xmlNodePtr cur, int val) {
xmlNsPtr ns;
if (cur == NULL) return;
switch(cur->type) {
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_COMMENT_NODE:
case XML_DOCUMENT_NODE:
case XML_DOCUMENT_TYPE_NODE:
case XML_DOCUMENT_FR... | pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x81c11
movq %rdi, %rbx
movl 0x8(%rdi), %eax
addl $-0x3, %eax
cmpl $0x12, %eax
jb 0x81c11
movl %esi, %ebp
movq 0x40(%rbx), %rdi
leaq 0x5a8fd(%rip), %rdx # 0xdc4ef
movq %rbx, %rsi
callq 0x347d0
testq %rax, %rax
je 0x81c11
testl %ebp, %ebp
je 0x81c18
cmpl $0x1, %eb... | /frida[P]libxml2/tree.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.