Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
xmlNodeGetSpacePreserve
int xmlNodeGetSpacePreserve(const xmlNode *cur) { xmlChar *space; if ((cur == NULL) || (cur->type != XML_ELEMENT_NODE)) return(-1); while (cur != NULL) { space = xmlGetNsProp(cur, BAD_CAST "space", XML_XML_NAMESPACE); if (space != NULL) { if (xmlStrEqual(space, BAD_CAST "preserve")) { xmlF...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax pushq $-0x1 popq %rbx testq %rdi, %rdi je 0x81cce movq %rdi, %r14 cmpl $0x1, 0x8(%rdi) jne 0x81cce leaq 0x6a71c(%rip), %r15 # 0xec37a leaq 0x5a88a(%rip), %r12 # 0xdc4ef leaq 0x63595(%rip), %r13 # 0xe5201 testq %r14, %r14 je 0x81cce...
/frida[P]libxml2/tree.c
xmlNodeSetName
void xmlNodeSetName(xmlNodePtr cur, const xmlChar *name) { xmlDocPtr doc; xmlDictPtr dict; const xmlChar *freeme = NULL; if (cur == NULL) return; if (name == NULL) return; switch(cur->type) { case XML_TEXT_NODE: case XML_CDATA_SECTION_NODE: case XML_COMMENT_NODE: ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl jne 0x81d0f movq %rsi, %r14 movq %rdi, %rbx movl 0x8(%rdi), %eax cmpl $0x14, %eax ja 0x81d1b movl $0x1c3d18, %ecx # imm = 0x1C3D18 btl %eax, %ecx jae 0x81d1b addq $0x8, %rsp popq %rbx popq %r1...
/frida[P]libxml2/tree.c
xmlNodeGetBase
xmlChar * xmlNodeGetBase(const xmlDoc *doc, const xmlNode *cur) { xmlChar *oldbase = NULL; xmlChar *base, *newbase; if ((cur == NULL) && (doc == NULL)) return(NULL); if ((cur != NULL) && (cur->type == XML_NAMESPACE_DECL)) return(NULL); if (doc == NULL) doc = cur->doc; if ((doc !...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rax orq %rsi, %rax je 0x81e93 movq %rsi, %r15 movq %rdi, %rbx testq %rsi, %rsi je 0x81ea8 cmpl $0x12, 0x8(%r15) jne 0x81ea8 xorl %r12d, %r12d movq %r12, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %r...
/frida[P]libxml2/tree.c
xmlNodeSetContentLen
void xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar *content, int len) { if (cur == NULL) { #ifdef DEBUG_TREE xmlGenericError(xmlGenericErrorContext, "xmlNodeSetContentLen : node == NULL\n"); #endif return; } switch (cur->type) { case XML_DOCUMENT_FRAG_NODE: case XML_ELEMENT_N...
testq %rdi, %rdi je 0x8248a pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl 0x8(%rdi), %eax cmpl $0xc, %eax ja 0x82480 movl %edx, %ebp movq %rsi, %r14 movl $0x11f8, %ecx # imm = 0x11F8 btl %eax, %ecx jae 0x82430 movq 0x50(%rbx), %rsi testq %rsi, %rsi sete %al leaq 0x58(%rbx), %rcx ...
/frida[P]libxml2/tree.c
xmlGetNsList
xmlNsPtr * xmlGetNsList(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlNode *node) { xmlNsPtr cur; xmlNsPtr *ret = NULL; int nbns = 0; int maxns = 10; int i; if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) return(NULL); while (node != NULL) { if (node->type == XML_E...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp testq %rsi, %rsi je 0x82707 xorl %r15d, %r15d cmpl $0x12, 0x8(%rsi) je 0x82707 pushq $0xa popq %r13 xorl %r14d, %r14d testq %rsi, %rsi je 0x8270a cmpl $0x1, 0x8(%rsi) jne 0x826f2 movq %rsi, 0x10(%rsp) leaq 0x60(%rsi), %rbp movq (%rbp), %...
/frida[P]libxml2/tree.c
xmlNsInScope
static int xmlNsInScope(xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePtr node, xmlNodePtr ancestor, const xmlChar * prefix) { xmlNsPtr tst; while ((node != NULL) && (node != ancestor)) { if ((node->type == XML_ENTITY_REF_NODE) || (node->type == XML_ENTITY_NODE) || (node->...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 xorl %ebp, %ebp testq %r14, %r14 je 0x82805 cmpq %rbx, %r14 je 0x82805 movl 0x8(%r14), %eax cmpl $0x1, %eax je 0x827ce leal -0x5(%rax), %ecx cmpl $0x2, %ecx jb 0x82800 cmpl $0x11, %eax je 0x82800 movq 0x28(%r14), %r14...
/frida[P]libxml2/tree.c
xmlReconciliateNs
int xmlReconciliateNs(xmlDocPtr doc, xmlNodePtr tree) { xmlNsPtr *oldNs = NULL; xmlNsPtr *newNs = NULL; int sizeCache = 0; int nbCache = 0; xmlNsPtr n; xmlNodePtr node = tree; xmlAttrPtr attr; int ret = 0, i; if ((node == NULL) || (node->type != XML_ELEMENT_NODE)) return(-1); i...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp pushq $-0x1 popq %rbx testq %rsi, %rsi je 0x82c31 movq %rdi, %rbp testq %rdi, %rdi je 0x82c31 cmpl $0x1, 0x8(%rsi) jne 0x82c31 cmpl $0x9, 0x8(%rbp) jne 0x82c31 cmpq %rbp, 0x40(%rsi) jne 0x82c31 xorl %r14d, %r14d pushq $0x50 popq %rdi xor...
/frida[P]libxml2/tree.c
xmlHasProp
xmlAttrPtr xmlHasProp(const xmlNode *node, const xmlChar *name) { xmlAttrPtr prop; xmlDocPtr doc; if ((node == NULL) || (node->type != XML_ELEMENT_NODE) || (name == NULL)) return(NULL); /* * Check on the properties attached to the node */ prop = node->properties; while (prop !...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax testq %rdi, %rdi je 0x82ceb movq %rsi, %r14 xorl %ebx, %ebx testq %rsi, %rsi je 0x82ced movq %rdi, %r15 cmpl $0x1, 0x8(%rdi) jne 0x82ced leaq 0x58(%r15), %rbx movq (%rbx), %rbx testq %rbx, %rbx je 0x82ca0 movq 0x10(%rbx), %rdi movq %r14, %rsi callq 0x35170 testl %e...
/frida[P]libxml2/tree.c
xmlGetPropNodeInternal
static xmlAttrPtr xmlGetPropNodeInternal(const xmlNode *node, const xmlChar *name, const xmlChar *nsName, int useDTD) { xmlAttrPtr prop; /* Avoid unused variable warning if features are disabled. */ (void) useDTD; if ((node == NULL) || (node->type != XML_ELEMENT_NODE) || (name == NULL)) retu...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp testq %rdi, %rdi je 0x82f5f movq %rsi, %rbx xorl %r14d, %r14d testq %rsi, %rsi je 0x82f62 movq %rdi, %r13 cmpl $0x1, 0x8(%rdi) jne 0x82f62 movl %ecx, %ebp movq %rdx, %r15 movq 0x58(%r13), %r14 testq %r14, %r14 je 0x82da9 testq %r15, %r15...
/frida[P]libxml2/tree.c
xmlUnsetProp
int xmlUnsetProp(xmlNodePtr node, const xmlChar *name) { xmlAttrPtr prop; prop = xmlGetPropNodeInternal(node, name, NULL, 0); if (prop == NULL) return(-1); xmlUnlinkNode((xmlNodePtr) prop); xmlFreeProp(prop); return(0); }
pushq %r14 pushq %rbx pushq %rax xorl %ebx, %ebx xorl %edx, %edx xorl %ecx, %ecx callq 0x82cfc testq %rax, %rax je 0x82fd0 movq %rax, %r14 movq %rax, %rdi callq 0x331e0 movq %r14, %rdi callq 0x359a0 jmp 0x82fd3 pushq $-0x1 popq %rbx movl %ebx, %eax addq $0x8, %rsp popq %rbx popq %r14 retq
/frida[P]libxml2/tree.c
xmlTextConcat
int xmlTextConcat(xmlNodePtr node, const xmlChar *content, int len) { if (node == NULL) return(-1); if ((node->type != XML_TEXT_NODE) && (node->type != XML_CDATA_SECTION_NODE) && (node->type != XML_COMMENT_NODE) && (node->type != XML_PI_NODE)) { #ifdef DEBUG_TREE xmlGenericError(xmlGenericErrorConte...
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x831ab pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movl 0x8(%rdi), %ecx cmpl $0x8, %ecx ja 0x831a7 movl %edx, %ebp movl $0x198, %edx # imm = 0x198 btl %ecx, %edx jae 0x831a7 movq %rsi, %r14 movq 0x50(%rbx), %rsi leaq 0x58(%rbx), %rax cmpq %rax, %rsi je 0x83177 ...
/frida[P]libxml2/tree.c
xmlBufferCreate
xmlBufferPtr xmlBufferCreate(void) { xmlBufferPtr ret; ret = (xmlBufferPtr) xmlMalloc(sizeof(xmlBuffer)); if (ret == NULL) { xmlTreeErrMemory("creating buffer"); return(NULL); } ret->use = 0; ret->size = xmlDefaultBufferSize; ret->alloc = xmlBufferAllocScheme; ret->content = (x...
pushq %rbx movq 0xa9e1c(%rip), %rax # 0x12cfd0 pushq $0x20 popq %rdi callq *(%rax) testq %rax, %rax je 0x831f7 movq %rax, %rbx andl $0x0, 0x8(%rax) callq 0x32100 movl (%rax), %eax movl %eax, 0xc(%rbx) callq 0x35840 movl (%rax), %eax movl %eax, 0x10(%rbx) movq 0xa9950(%rip), %rax # 0x12cb30 movl 0xc(%rbx), %edi ...
/frida[P]libxml2/tree.c
xmlBufferEmpty
void xmlBufferEmpty(xmlBufferPtr buf) { if (buf == NULL) return; if (buf->content == NULL) return; buf->use = 0; if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) { buf->content = BAD_CAST ""; } else if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) { si...
testq %rdi, %rdi je 0x833e6 movq (%rdi), %rax testq %rax, %rax je 0x833e6 andl $0x0, 0x8(%rdi) movl 0x10(%rdi), %ecx cmpl $0x3, %ecx je 0x833ce cmpl $0x2, %ecx jne 0x833e3 leaq 0x651fd(%rip), %rax # 0xe85c7 movq %rax, (%rdi) retq movq 0x18(%rdi), %rcx testq %rcx, %rcx je 0x833e3 subl %ecx, %eax addl %eax, 0xc(%rdi)...
/frida[P]libxml2/tree.c
xmlBufferShrink
int xmlBufferShrink(xmlBufferPtr buf, unsigned int len) { if (buf == NULL) return(-1); if (len == 0) return(0); if (len > buf->use) return(-1); buf->use -= len; if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) || ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL))) { /* * we ...
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x83493 pushq %r15 pushq %r14 pushq %rbx movl %esi, %ebx testl %esi, %esi je 0x8346e movq %rdi, %r14 movl 0x8(%rdi), %ecx subl %ebx, %ecx jb 0x8348e movl %ecx, 0x8(%r14) movl 0x10(%r14), %eax cmpl $0x2, %eax je 0x83425 cmpl $0x3, %eax jne 0x83472 cmpq $0x0, 0x18(%r14) je 0x8347...
/frida[P]libxml2/tree.c
xmlBufferDump
int xmlBufferDump(FILE *file, xmlBufferPtr buf) { size_t ret; if (buf == NULL) { #ifdef DEBUG_BUFFER xmlGenericError(xmlGenericErrorContext, "xmlBufferDump: buf == NULL\n"); #endif return(0); } if (buf->content == NULL) { #ifdef DEBUG_BUFFER xmlGenericError(xmlGenericErrorContext, ...
xorl %eax, %eax testq %rsi, %rsi je 0x835b0 movq %rdi, %rcx movq (%rsi), %rdi testq %rdi, %rdi je 0x835b0 testq %rcx, %rcx jne 0x83591 movq 0xa9a52(%rip), %rax # 0x12cfe0 movq (%rax), %rcx pushq %rax movl 0x8(%rsi), %edx pushq $0x1 popq %rsi callq 0x35710 movq %rax, %rcx movl $0x7fffffff, %eax # imm = 0x7FFFF...
/frida[P]libxml2/tree.c
xmlDOMWrapNewCtxt
xmlDOMWrapCtxtPtr xmlDOMWrapNewCtxt(void) { xmlDOMWrapCtxtPtr ret; ret = xmlMalloc(sizeof(xmlDOMWrapCtxt)); if (ret == NULL) { xmlTreeErrMemory("allocating DOM-wrapper context"); return (NULL); } memset(ret, 0, sizeof(xmlDOMWrapCtxt)); return (ret); }
pushq %rbx movq 0xa9502(%rip), %rax # 0x12cfd0 pushq $0x20 popq %rdi callq *(%rax) movq %rax, %rbx testq %rax, %rax je 0x83ae7 xorps %xmm0, %xmm0 movups %xmm0, 0x10(%rbx) movups %xmm0, (%rbx) jmp 0x83af3 leaq 0x66268(%rip), %rdi # 0xe9d56 callq 0x7c3b1 movq %rbx, %rax popq %rbx retq
/frida[P]libxml2/tree.c
xmlDOMWrapNSNormGatherInScopeNs
static int xmlDOMWrapNSNormGatherInScopeNs(xmlNsMapPtr *map, xmlNodePtr node) { xmlNodePtr cur; xmlNsPtr ns; xmlNsMapItemPtr mi; int shadowed; if ((map == NULL) || (*map != NULL)) return (-1); if ((node == NULL) || (node->type == XML_NAMESPACE_DECL)) return (-1); /* * Get i...
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x843c0 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 testq %rsi, %rsi je 0x843b2 movq %rdi, %r15 cmpq $0x0, (%rdi) jne 0x843b2 cmpl $0x12, 0x8(%r14) je 0x843b2 pushq $-0x1 popq %rbp testq %r14, %r14 je 0x843b0 cmpq 0x40(%r14), %r1...
/frida[P]libxml2/tree.c
xmlDOMWrapAdoptNode
int xmlDOMWrapAdoptNode(xmlDOMWrapCtxtPtr ctxt, xmlDocPtr sourceDoc, xmlNodePtr node, xmlDocPtr destDoc, xmlNodePtr destParent, int options) { if ((node == NULL) || (node->type == XML_NAMESPACE_DECL) || (destDoc == NULL) || ((destParent != NULL) && (destParent->doc != destDoc)...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp pushq $-0x1 popq %r12 testq %rdx, %rdx je 0x85a7a movq %rcx, %r15 movq %rdx, %r14 movl 0x8(%rdx), %eax cmpl $0x12, %eax sete %cl testq %r15, %r15 sete %dl orb %cl, %dl jne 0x85a7a movq %r8, %r13 movq %rdi, %rbx testq %r8, %r8 je 0x84f03 ...
/frida[P]libxml2/tree.c
xmlParseURI
xmlURIPtr xmlParseURI(const char *str) { xmlURIPtr uri; int ret; if (str == NULL) return(NULL); uri = xmlCreateURI(); if (uri != NULL) { ret = xmlParse3986URIReference(uri, str); if (ret) { xmlFreeURI(uri); return(NULL); } } return(uri); }
pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0x85f18 movq %rdi, %r14 callq 0x33a90 testq %rax, %rax je 0x85f18 movq %rax, %rbx movq %rax, %rdi movq %r14, %rsi callq 0x85f68 testl %eax, %eax je 0x85f1a movq %rbx, %rdi callq 0x32e10 xorl %ebx, %ebx movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 retq
/frida[P]libxml2/uri.c
xmlSaveUri
xmlChar * xmlSaveUri(xmlURIPtr uri) { xmlChar *ret = NULL; xmlChar *temp; const char *p; int len; int max; if (uri == NULL) return(NULL); max = 80; ret = (xmlChar *) xmlMallocAtomic(max + 1); if (ret == NULL) { xmlURIErrMemory("saving URI\n"); return(NULL); } len ...
testq %rdi, %rdi je 0x8669b pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %r15 movl $0x50, 0x4(%rsp) movq 0xa64ed(%rip), %rax # 0x12cb30 pushq $0x51 popq %rdi callq *(%rax) testq %rax, %rax je 0x8669e movq %rax, %r14 movq (%r15), %rbx testq %rbx, %rbx movq %r15, 0x8(%...
/frida[P]libxml2/uri.c
xmlParse3986Fragment
static int xmlParse3986Fragment(xmlURIPtr uri, const char **str) { const char *cur; if (str == NULL) return (-1); cur = *str; while ((ISA_PCHAR(cur)) || (*cur == '/') || (*cur == '?') || (*cur == '[') || (*cur == ']') || ((uri != NULL) && (uri->cleanup & 1) && (IS_UNWISE...
testq %rsi, %rsi je 0x8841c pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movq (%rsi), %r15 movabsq $0x380000015, %rax # imm = 0x380000015 movabsq $0x54000000d6007fe9, %rcx # imm = 0x54000000D6007FE9 movabsq $0x3f0000003f, %rdx # imm = 0x3F0000003F movzbl (%r15), %esi leal -0x30(%rsi), %edi ...
/frida[P]libxml2/uri.c
xmlParse3986Authority
static int xmlParse3986Authority(xmlURIPtr uri, const char **str) { const char *cur; int ret; cur = *str; /* * try to parse an userinfo and check for the trailing @ */ ret = xmlParse3986Userinfo(uri, &cur); if ((ret != 0) || (*cur != '@')) cur = *str; else cur++; ...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rsi, %rbx movq %rdi, %r14 movq (%rsi), %r15 movabsq $0x4000000016003fe9, %rax # imm = 0x4000000016003FE9 movabsq $0x3f0000003f, %r12 # imm = 0x3F0000003F movq %r15, %r13 movzbl (%r13), %ecx leal -0x30(%rcx), %edx cmpb $0xa, %dl jb 0x88489...
/frida[P]libxml2/uri.c
xmlCopyNotation
static void * xmlCopyNotation(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) { xmlNotationPtr nota = (xmlNotationPtr) payload; xmlNotationPtr cur; cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation)); if (cur == NULL) { xmlVErrMemory(NULL, "malloc failed"); return(NULL); } if (nota->na...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 movq 0xa229b(%rip), %rax # 0x12cfd0 pushq $0x18 popq %rdi callq *(%rax) movq %rax, %rbx testq %rax, %rax je 0x8ad51 movq (%r14), %rdi testq %rdi, %rdi je 0x8ad61 callq 0x35fc0 jmp 0x8ad63 leaq 0x5467f(%rip), %rsi # 0xdf3d7 xorl %edi, %edi callq 0x8922b jmp 0x8ad9...
/frida[P]libxml2/valid.c
xmlIsID
int xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) { if ((attr == NULL) || (attr->name == NULL)) return(0); if ((attr->ns != NULL) && (attr->ns->prefix != NULL) && (!strcmp((char *) attr->name, "id")) && (!strcmp((char *) attr->ns->prefix, "xml"))) return(1); if (doc == NULL) retu...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp xorl %ebp, %ebp testq %rdx, %rdx je 0x8b281 movq %rdx, %r14 movq 0x10(%rdx), %r12 testq %r12, %r12 je 0x8b281 movq %rsi, %rbx movq %rdi, %r15 movq 0x48(%r14), %r13 pushq $0x1 popq %rax testq %r13, %r13 je 0x8b115 movq 0x18(%r13), %rdi te...
/frida[P]libxml2/valid.c
xmlRemoveID
int xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) { xmlIDTablePtr table; xmlIDPtr id; xmlChar *ID; if (doc == NULL) return(-1); if (attr == NULL) return(-1); table = (xmlIDTablePtr) doc->ids; if (table == NULL) return(-1); ID = xmlNodeListGetString(doc, attr->children, 1); i...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl pushq $-0x1 popq %rbp jne 0x8b3ab movq 0x78(%rdi), %r14 testq %r14, %r14 je 0x8b3ab movq %rsi, %rbx movq 0x18(%rsi), %rsi pushq $0x1 popq %rdx callq 0x344b0 testq %rax, %rax je 0x8b3ab movq %rax, %r15...
/frida[P]libxml2/valid.c
xmlAddRef
xmlRefPtr xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr) { xmlRefPtr ret; xmlRefTablePtr table; xmlListPtr ref_list; if (doc == NULL) { return(NULL); } if (value == NULL) { return(NULL); } if (attr == NULL) { return(NULL...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rcx, %r12 testq %rsi, %rsi sete %al testq %rdx, %rdx sete %cl orb %al, %cl testq %r12, %r12 sete %al orb %cl, %al jne 0x8b5a7 movq %rdx, %r14 movq %rsi, %rbx movq %rdi, %r13 movq 0x80(%rsi), %r15 testq %r15, %r15 jne 0x8b492 movq 0x98(%rbx), %rsi xorl %edi, %...
/frida[P]libxml2/valid.c
xmlIsRef
int xmlIsRef(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) { if (attr == NULL) return(0); if (doc == NULL) { doc = attr->doc; if (doc == NULL) return(0); } if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) { return(0); } else if (doc->type == XML_HTML_DOCUMENT_NO...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax xorl %ebx, %ebx testq %rdx, %rdx je 0x8b681 movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 testq %rdi, %rdi jne 0x8b642 movq 0x40(%r14), %r12 testq %r12, %r12 je 0x8b681 movq 0x50(%r12), %rdi testq %rdi, %rdi jne 0x8b654 cmpq $0x0, 0x58(%r12) je 0x8b681 testq %r15...
/frida[P]libxml2/valid.c
xmlGetRefs
xmlListPtr xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) { xmlRefTablePtr table; if (doc == NULL) { return(NULL); } if (ID == NULL) { return(NULL); } table = (xmlRefTablePtr) doc->refs; if (table == NULL) return(NULL); return (xmlHashLookup(table, ID)); }
testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl jne 0x8b7ae movq 0x80(%rdi), %rdi testq %rdi, %rdi jne 0x32460 xorl %eax, %eax retq
/frida[P]libxml2/valid.c
xmlValidateNameValueInternal
static int xmlValidateNameValueInternal(xmlDocPtr doc, const xmlChar *value) { const xmlChar *cur; int val, len; if (value == NULL) return(0); cur = value; val = xmlStringCurrentChar(NULL, cur, &len); cur += len; if (!xmlIsDocNameStartChar(doc, val)) return(0); val = xmlStringCurrentC...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp testq %rsi, %rsi je 0x8b9f3 movq %rsi, %rbx movq %rdi, %r14 xorl %r15d, %r15d leaq 0xc(%rsp), %r12 xorl %edi, %edi movq %r12, %rdx callq 0x35c40 movslq (%r12), %r12 movq %r14, %rdi movl %eax, %esi callq 0x8ee33 testl %eax, %eax je 0x8b9f6 addq %r12...
/frida[P]libxml2/valid.c
xmlValidatePushCData
int xmlValidatePushCData(xmlValidCtxtPtr ctxt, const xmlChar *data, int len) { int ret = 1; /* printf("CDATA %s %d\n", data, len); */ if (ctxt == NULL) return(0); if (len <= 0) return(ret); if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) { xmlValidStatePtr state = ctxt->vstate; xmlElemen...
pushq %rbx subq $0x10, %rsp xorl %ebx, %ebx testq %rdi, %rdi je 0x8d5f5 pushq $0x1 popq %rax testl %edx, %edx jle 0x8d5f3 cmpl $0x0, 0x50(%rdi) jle 0x8d5f3 movq 0x48(%rdi), %rcx testq %rcx, %rcx je 0x8d5f3 movq (%rcx), %r8 testq %r8, %r8 je 0x8d5f3 movl 0x48(%r8), %r8d testl %r8d, %r8d je 0x8d5f5 cmpl $0x1, %r8d je 0x8...
/frida[P]libxml2/valid.c
xmlValidateOneElement
int xmlValidateOneElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem) { xmlElementPtr elemDecl = NULL; xmlElementContentPtr cont; xmlAttributePtr attr; xmlNodePtr child; int ret = 1, tmp; const xmlChar *name; int extsubset = 0; CHECK_DTD; if (elem ==...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x2748, %rsp # imm = 0x2748 andl $0x0, 0x1c(%rsp) xorl %r12d, %r12d testq %rsi, %rsi je 0x8db18 movq %rdx, %rbx movq %rsi, %r13 movq %rdi, %r14 cmpq $0x0, 0x50(%rsi) je 0x8d75f testq %rbx, %rbx jne 0x8d773 jmp 0x8db18 testq %rbx, %rbx je ...
/frida[P]libxml2/valid.c
xmlValidGetPotentialChildren
int xmlValidGetPotentialChildren(xmlElementContent *ctree, const xmlChar **names, int *len, int max) { int i; if ((ctree == NULL) || (names == NULL) || (len == NULL)) return(-1); if (*len >= max) return(*len); switch (ctree->type) { ca...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movl %ecx, %ebp testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl testq %rdx, %rdx sete %al orb %cl, %al je 0x8eab2 pushq $-0x1 popq %rax jmp 0x8eb64 movq %rdx, %rbx movl (%rdx), %eax cmpl %ebp, %eax jge 0x8eb64 movq %rdi, %r15 movl (%rdi), %eax decl...
/frida[P]libxml2/valid.c
xmlValidGetValidElements
int xmlValidGetValidElements(xmlNode *prev, xmlNode *next, const xmlChar **names, int max) { xmlValidCtxt vctxt; int nb_valid_elements = 0; const xmlChar *elements[256]={0}; int nb_elements = 0, i; const xmlChar *name; xmlNode *ref_node; xmlNode *parent; xmlNode...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x8d8, %rsp # imm = 0x8D8 movl %ecx, %ebx movq %rdx, %r15 movq %rsi, %r14 movq %rdi, %rbp leaq 0xd0(%rsp), %rdi movl $0x800, %edx # imm = 0x800 xorl %esi, %esi callq 0x32350 andl $0x0, 0x8(%rsp) movq %rbp, %rax orq %r14, %rax ...
/frida[P]libxml2/valid.c
xmlIsDocNameStartChar
static int xmlIsDocNameStartChar(xmlDocPtr doc, int c) { if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) { /* * Use the new checks of production [4] [4a] amd [5] of the * Update 5 of XML-1.0 */ if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || (c == '_') || (c == ...
pushq %rbx movl %esi, %ebx testq %rdi, %rdi je 0x8ee48 testb $0x4, 0xac(%rdi) jne 0x8ef14 movl %ebx, %ecx andl $-0x21, %ecx addl $-0x41, %ecx pushq $0x1 popq %rax cmpl $0x1a, %ecx jb 0x8efa9 cmpl $0x3a, %ebx je 0x8efa9 cmpl $0x5f, %ebx je 0x8efa9 movd %ebx, %xmm0 pshufd $0x0, %xmm0, %xmm1 # xmm1 = xmm0[0,0,0,0] mo...
/frida[P]libxml2/valid.c
nodeVPush
static int nodeVPush(xmlValidCtxtPtr ctxt, xmlNodePtr value) { if (ctxt->nodeMax <= 0) { ctxt->nodeMax = 4; ctxt->nodeTab = (xmlNodePtr *) xmlMalloc(ctxt->nodeMax * sizeof(ctxt->nodeTab[0])); if (ctxt->nodeTab == NULL) { xmlVErrMemory(ctx...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movl 0x24(%rdi), %eax testl %eax, %eax jg 0x8f1f5 movl $0x4, 0x24(%rbx) movq 0x9ddec(%rip), %rax # 0x12cfd0 pushq $0x20 popq %rdi callq *(%rax) movq %rax, 0x28(%rbx) testq %rax, %rax je 0x8f255 movl 0x24(%rbx), %eax movl 0x20(%rbx), %ecx cmpl %eax, %e...
/frida[P]libxml2/valid.c
xmlXIncludeNewContext
xmlXIncludeCtxtPtr xmlXIncludeNewContext(xmlDocPtr doc) { xmlXIncludeCtxtPtr ret; #ifdef DEBUG_XINCLUDE xmlGenericError(xmlGenericErrorContext, "New context\n"); #endif if (doc == NULL) return(NULL); ret = (xmlXIncludeCtxtPtr) xmlMalloc(sizeof(xmlXIncludeCtxt)); if (ret == NULL) { xmlXIncludeErrM...
pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0x8f55c movq %rdi, %r14 movq 0x9daa1(%rip), %rax # 0x12cfd0 pushq $0x68 popq %rdi callq *(%rax) testq %rax, %rax je 0x8f560 movq %rax, %rbx xorps %xmm0, %xmm0 movups %xmm0, 0x58(%rax) movups %xmm0, 0x48(%rax) movups %xmm0, 0x38(%rax) movups %xmm0, 0x28(%rax) movu...
/frida[P]libxml2/xinclude.c
xmlXIncludeProcessTreeFlagsData
int xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, int flags, void *data) { xmlXIncludeCtxtPtr ctxt; int ret = 0; if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) || (tree->doc == NULL)) return(-1); ctxt = xmlXIncludeNewContext(tree->doc); if (ctxt == NULL) return...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq $-0x1 popq %rbx testq %rdi, %rdi je 0x8f7b8 movq %rdi, %r15 cmpl $0x12, 0x8(%rdi) je 0x8f7b8 movq 0x40(%r15), %rdi testq %rdi, %rdi je 0x8f7b8 movq %rdx, %r12 movl %esi, %ebp callq 0x32210 testq %rax, %rax je 0x8f7b8 movq %rax, %r14 movq %r12, 0x50(%rax) movq...
/frida[P]libxml2/xinclude.c
xmlXIncludeProcessFlagsData
int xmlXIncludeProcessFlagsData(xmlDocPtr doc, int flags, void *data) { xmlNodePtr tree; if (doc == NULL) return(-1); tree = xmlDocGetRootElement(doc); if (tree == NULL) return(-1); return(xmlXIncludeProcessTreeFlagsData(tree, flags, data)); }
pushq %rbp pushq %rbx pushq %rax testq %rdi, %rdi je 0x8fc5d movq %rdx, %rbx movl %esi, %ebp callq 0x32870 testq %rax, %rax je 0x8fc5d movq %rax, %rdi movl %ebp, %esi movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %rbp jmp 0x321c0 pushq $-0x1 popq %rax addq $0x8, %rsp popq %rbx popq %rbp retq
/frida[P]libxml2/xinclude.c
xmlXIncludeProcessTreeFlags
int xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags) { xmlXIncludeCtxtPtr ctxt; int ret = 0; if ((tree == NULL) || (tree->type == XML_NAMESPACE_DECL) || (tree->doc == NULL)) return(-1); ctxt = xmlXIncludeNewContext(tree->doc); if (ctxt == NULL) return(-1); ctxt->base = xmlNodeG...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax pushq $-0x1 popq %rbx testq %rdi, %rdi je 0x8fcdd movq %rdi, %r15 cmpl $0x12, 0x8(%rdi) je 0x8fcdd movq 0x40(%r15), %rdi testq %rdi, %rdi je 0x8fcdd movl %esi, %ebp callq 0x32210 testq %rax, %rax je 0x8fcdd movq %rax, %r14 movq 0x40(%r15), %rdi movq %r15, %rsi call...
/frida[P]libxml2/xinclude.c
xmlXIncludeErr
static void LIBXML_ATTR_FORMAT(4,0) xmlXIncludeErr(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error, const char *msg, const xmlChar *extra) { if (ctxt != NULL) ctxt->nbErrors++; __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE, error, XML_ERR_ERROR, NULL, 0,...
subq $0x58, %rsp movq %rsi, %rax movq %rdi, %r10 incl 0x38(%rdi) movq %r8, 0x50(%rsp) movq %rcx, 0x48(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x28(%rsp) andl $0x0, 0x40(%rsp) movq %r8, 0x20(%rsp) andl $0x0, 0x38(%rsp) movl %edx, (%rsp) andl $0x0, 0x18(%rsp) andq $0x0, 0x10(%rsp) movl $0x2, 0x8(%rsp) pushq $0xb popq %r9 ...
/frida[P]libxml2/xinclude.c
_xmlLoaderErr
void __xmlLoaderErr(void *ctx, const char *msg, const char *filename) { xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; xmlStructuredErrorFunc schannel = NULL; xmlGenericErrorFunc channel = NULL; void *data = NULL; xmlErrorLevel level = XML_ERR_ERROR; if ((ctxt != NULL) && (ctxt->disableSAX != ...
movq %rdi, %rcx pushq $0x2 popq %r9 testq %rdi, %rdi je 0x91aeb cmpl $0x0, 0x14c(%rcx) je 0x91ac0 cmpl $-0x1, 0x110(%rcx) je 0x91b5c movq (%rcx), %rax testq %rax, %rax je 0x91aeb xorl %r8d, %r8d cmpl $0x0, 0x9c(%rcx) setne %r8b cmpl $0xdeedbeaf, 0xd8(%rax) # imm = 0xDEEDBEAF jne 0x91af4 movq 0xf8(%rax), %rdi jmp 0x91af...
/frida[P]libxml2/xmlIO.c
xmlCleanupOutputCallbacks
void xmlCleanupOutputCallbacks(void) { int i; if (!xmlOutputCallbackInitialized) return; for (i = xmlOutputCallbackNr - 1; i >= 0; i--) { xmlOutputCallbackTable[i].matchcallback = NULL; xmlOutputCallbackTable[i].opencallback = NULL; xmlOutputCallbackTable[i].writecallback =...
cmpb $0x1, 0x9e543(%rip) # 0x130130 jne 0x91c2e movl 0x9e53f(%rip), %eax # 0x130134 movq %rax, %rcx shlq $0x5, %rcx leaq 0x9e53d(%rip), %rdx # 0x130140 addq %rdx, %rcx addq $-0x20, %rcx xorps %xmm0, %xmm0 testl %eax, %eax jle 0x91c20 movaps %xmm0, 0x10(%rcx) movaps %xmm0, (%rcx) decl %eax addq $-0x20, %rcx ...
/frida[P]libxml2/xmlIO.c
xmlIOHTTPOpenW
void * xmlIOHTTPOpenW(const char *post_uri, int compression ATTRIBUTE_UNUSED) { xmlIOHTTPWriteCtxtPtr ctxt = NULL; if (post_uri == NULL) return (NULL); ctxt = xmlMalloc(sizeof(xmlIOHTTPWriteCtxt)); if (ctxt == NULL) { xmlIOErrMemory("creating HTTP output context"); return (NULL); ...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x200, %rsp # imm = 0x200 testq %rdi, %rdi je 0x92017 movl %esi, %r15d movq %rdi, %r14 movq 0x9b11a(%rip), %r12 # 0x12cfd0 pushq $0x18 popq %rdi callq *(%r12) testq %rax, %rax je 0x91fbe movq %rax, %rbx xorps %xmm0, %xmm0 movups %xmm0, (%rax) a...
/frida[P]libxml2/xmlIO.c
xmlAllocOutputBufferInternal
xmlOutputBufferPtr xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder) { xmlOutputBufferPtr ret; ret = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer)); if (ret == NULL) { xmlIOErrMemory("creating output buffer"); return(NULL); } memset(ret, 0, sizeof(xmlOutputBuffer)); ret...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 movq 0x9aee2(%rip), %rax # 0x12cfd0 pushq $0x38 popq %rdi callq *(%rax) testq %rax, %rax je 0x92150 movq %rax, %rbx xorps %xmm0, %xmm0 movups %xmm0, 0x20(%rax) movups %xmm0, 0x10(%rax) movups %xmm0, (%rax) andq $0x0, 0x30(%rax) callq 0x33730 movq %rax, 0x20(%rbx) tes...
/frida[P]libxml2/xmlIO.c
xmlRegisterDefaultInputCallbacks
void xmlRegisterDefaultInputCallbacks(void) { if (xmlInputCallbackInitialized) return; xmlRegisterInputCallbacks(xmlFileMatch, xmlFileOpen, xmlFileRead, xmlFileClose); #ifdef LIBXML_ZLIB_ENABLED xmlRegisterInputCallbacks(xmlGzfileMatch, xmlGzfileOpen, xmlGzfil...
cmpb $0x0, 0x9dcfc(%rip) # 0x12ff40 jne 0x922da pushq %rax movq 0x9ac7e(%rip), %rdi # 0x12ced0 movq 0x9ab17(%rip), %rsi # 0x12cd70 movq 0x9a8e8(%rip), %rdx # 0x12cb48 movq 0x9ac29(%rip), %rcx # 0x12ce90 callq 0x34ca0 leaq 0x68(%rip), %rdi # 0x922db leaq 0x65(%rip), %rsi # 0x922df leaq ...
/frida[P]libxml2/xmlIO.c
xmlGzfileOpen
static void * xmlGzfileOpen (const char *filename) { char *unescaped; void *retval; retval = xmlGzfileOpen_real(filename); if (retval == NULL) { unescaped = xmlURIUnescapeString(filename, 0, NULL); if (unescaped != NULL) { retval = xmlGzfileOpen_real(unescaped); } xmlFree(unescaped); } ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 callq 0x941b0 movq %rax, %rbx testq %rax, %rax jne 0x92320 xorl %ebx, %ebx movq %r14, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x32f10 movq %rax, %r14 testq %rax, %rax je 0x92314 movq %r14, %rdi callq 0x941b0 movq %rax, %rbx movq 0x9ac95(%rip), %rax # 0x12cfb0 movq...
/frida[P]libxml2/xmlIO.c
xmlXzfileOpen
static void * xmlXzfileOpen (const char *filename) { char *unescaped; void *retval; retval = xmlXzfileOpen_real(filename); if (retval == NULL) { unescaped = xmlURIUnescapeString(filename, 0, NULL); if (unescaped != NULL) { retval = xmlXzfileOpen_real(unescaped); } xmlFree(unescaped); } ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 callq 0x94256 movq %rax, %rbx testq %rax, %rax jne 0x923b0 xorl %ebx, %ebx movq %r14, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x32f10 movq %rax, %r14 testq %rax, %rax je 0x923a4 movq %r14, %rdi callq 0x94256 movq %rax, %rbx movq 0x9ac05(%rip), %rax # 0x12cfb0 movq...
/frida[P]libxml2/xmlIO.c
xmlFileOpenW
static void * xmlFileOpenW (const char *filename) { const char *path = NULL; FILE *fd; if (!strcmp(filename, "-")) { fd = stdout; return((void *) fd); } if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "file://localhost/", 17)) #if defined (_WIN32) path = &filename[17]; #else path = &filename[1...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx cmpb $0x2d, (%rdi) jne 0x92465 cmpb $0x0, 0x1(%rbx) je 0x924c6 leaq 0x5a125(%rip), %rsi # 0xec591 pushq $0x11 popq %rdx movq %rbx, %rdi callq 0x32850 testl %eax, %eax je 0x9249a leaq 0x5a121(%rip), %rsi # 0xec5a3 pushq $0x8 popq %rdx movq %rbx, %rdi callq 0x32850...
/frida[P]libxml2/xmlIO.c
xmlFileWrite
static int xmlFileWrite (void * context, const char * buffer, int len) { int items; if ((context == NULL) || (buffer == NULL)) return(-1); items = fwrite(&buffer[0], len, 1, (FILE *) context); if ((items == 0) && (ferror((FILE *) context))) { xmlIOErr(0, "fwrite()"); return(-1); } ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl pushq $-0x1 popq %rbx jne 0x92539 movl %edx, %ebp movq %rdi, %r14 movslq %edx, %rax pushq $0x1 popq %rdx movq %rsi, %rdi movq %rax, %rsi movq %r14, %rcx callq 0x35710 movq %rax, %r15 testl %r15d, %r15...
/frida[P]libxml2/xmlIO.c
xmlAllocParserInputBuffer
xmlParserInputBufferPtr xmlAllocParserInputBuffer(xmlCharEncoding enc) { xmlParserInputBufferPtr ret; ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer)); if (ret == NULL) { xmlIOErrMemory("creating input buffer"); return(NULL); } memset(ret, 0, sizeof(xmlParserInputBuffer)); ...
pushq %rbp pushq %r14 pushq %rbx movl %edi, %ebp movq 0x9a8d4(%rip), %rax # 0x12cfd0 pushq $0x40 popq %rdi callq *(%rax) testq %rax, %rax je 0x9277e movq %rax, %rbx xorps %xmm0, %xmm0 movups %xmm0, 0x30(%rax) movups %xmm0, 0x20(%rax) movups %xmm0, 0x10(%rax) movups %xmm0, (%rax) callq 0x32100 movslq (%rax), %rdi ad...
/frida[P]libxml2/xmlIO.c
xmlFreeParserInputBuffer
void xmlFreeParserInputBuffer(xmlParserInputBufferPtr in) { if (in == NULL) return; if (in->raw) { xmlBufFree(in->raw); in->raw = NULL; } if (in->encoder != NULL) { xmlCharEncCloseFunc(in->encoder); } if (in->closecallback != NULL) { in->closecallback(in->context); } i...
pushq %rbx testq %rdi, %rdi je 0x928af movq %rdi, %rbx movq 0x28(%rdi), %rdi testq %rdi, %rdi je 0x92873 callq 0x35410 andq $0x0, 0x28(%rbx) movq 0x18(%rbx), %rdi testq %rdi, %rdi je 0x92881 callq 0x35240 movq 0x10(%rbx), %rax testq %rax, %rax je 0x9288f movq (%rbx), %rdi callq *%rax movq 0x20(%rbx), %rdi testq %rdi, %...
/frida[P]libxml2/xmlIO.c
_xmlParserInputBufferCreateFilename
xmlParserInputBufferPtr __xmlParserInputBufferCreateFilename(const char *URI, xmlCharEncoding enc) { xmlParserInputBufferPtr ret; int i = 0; void *context = NULL; if (xmlInputCallbackInitialized == 0) xmlRegisterDefaultInputCallbacks(); if (URI == NULL) return(NULL); /* * Try to find on...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %r14 cmpb $0x0, 0x9d4b8(%rip) # 0x12ff40 jne 0x92a8f callq 0x33040 testq %r14, %r14 je 0x92b8b movl 0x9d4a5(%rip), %r13d # 0x12ff44 movq %r13, %rax shlq $0x5, %rax leaq 0x9d4a3(%rip), %rcx # 0x12ff50 leaq ...
/frida[P]libxml2/xmlIO.c
xmlParserInputBufferCreateStatic
xmlParserInputBufferPtr xmlParserInputBufferCreateStatic(const char *mem, int size, xmlCharEncoding enc) { xmlParserInputBufferPtr ret; if (size < 0) return(NULL); if (mem == NULL) return(NULL); ret = (xmlParserInputBufferPtr) xmlMalloc(sizeof(xmlParserInputBuffer)); ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax testl %esi, %esi sets %al testq %rdi, %rdi sete %cl orb %al, %cl jne 0x93258 movl %edx, %ebp movl %esi, %r15d movq %rdi, %r14 movq 0x99de7(%rip), %rax # 0x12cfd0 pushq $0x40 popq %rdi callq *(%rax) testq %rax, %rax je 0x9323e movq %rax, %rbx xorps %xmm0, %xmm0 ...
/frida[P]libxml2/xmlIO.c
xmlParserInputBufferPush
int xmlParserInputBufferPush(xmlParserInputBufferPtr in, int len, const char *buf) { int nbchars = 0; int ret; if (len < 0) return(0); if ((in == NULL) || (in->error)) return(-1); if (in->encoder != NULL) { unsigned int use; /* * Store the data in the incoming r...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax testl %esi, %esi js 0x933ec movq %rdi, %r14 pushq $-0x1 popq %rbx testq %rdi, %rdi je 0x933ee cmpl $0x0, 0x34(%r14) jne 0x933ee movq %rdx, %r15 movl %esi, %ebp cmpq $0x0, 0x18(%r14) je 0x933fb movq 0x28(%r14), %rdi testq %rdi, %rdi jne 0x933aa callq 0x33730 movq %r...
/frida[P]libxml2/xmlIO.c
xmlParserInputBufferRead
int xmlParserInputBufferRead(xmlParserInputBufferPtr in, int len) { if ((in == NULL) || (in->error)) return(-1); if (in->readcallback != NULL) return(xmlParserInputBufferGrow(in, len)); else if (xmlBufGetAllocationScheme(in->buffer) == XML_BUFFER_ALLOC_IMMUTABLE) return(0); else return(-1); }
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x935d2 cmpl $0x0, 0x34(%rdi) je 0x935d3 retq cmpq $0x0, 0x8(%rdi) jne 0x33110 pushq %rax movq 0x20(%rdi), %rdi callq 0x34a60 movl %eax, %ecx xorl %eax, %eax cmpl $0x2, %ecx setne %al negl %eax addq $0x8, %rsp retq
/frida[P]libxml2/xmlIO.c
xmlOutputBufferWriteString
int xmlOutputBufferWriteString(xmlOutputBufferPtr out, const char *str) { int len; if ((out == NULL) || (out->error)) return(-1); if (str == NULL) return(-1); len = strlen(str); if (len > 0) return(xmlOutputBufferWrite(out, len, str)); return(len); }
pushq %r14 pushq %rbx pushq %rax pushq $-0x1 popq %rax testq %rdi, %rdi je 0x93c2a movq %rsi, %rbx testq %rsi, %rsi je 0x93c2a movq %rdi, %r14 cmpl $0x0, 0x34(%rdi) jne 0x93c2a movq %rbx, %rdi callq 0x33720 testl %eax, %eax jle 0x93c2a movq %r14, %rdi movl %eax, %esi movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %r14 ...
/frida[P]libxml2/xmlIO.c
xmlCheckHTTPInput
xmlParserInputPtr xmlCheckHTTPInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr ret) { /* Avoid unused variable warning if features are disabled. */ (void) ctxt; #ifdef LIBXML_HTTP_ENABLED if ((ret != NULL) && (ret->buf != NULL) && (ret->buf->readcallback == xmlIOHTTPRead) && (ret->buf->contex...
pushq %r15 pushq %r14 pushq %rbx testq %rsi, %rsi je 0x93daf movq %rsi, %rbx movq (%rsi), %rax testq %rax, %rax je 0x93db1 movq 0x8(%rax), %rcx cmpq 0x99296(%rip), %rcx # 0x12cf90 jne 0x93db1 movq %rdi, %r14 movq (%rax), %rdi testq %rdi, %rdi je 0x93db1 callq 0x33330 cmpl $0x190, %eax # imm = 0x190 jl 0x...
/frida[P]libxml2/xmlIO.c
xmlNoNetExists
static int xmlNoNetExists(const char *URL) { const char *path; if (URL == NULL) return(0); if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file://localhost/", 17)) #if defined (_WIN32) path = &URL[17]; #else path = &URL[16]; #endif else if (!xmlStrncasecmp(BAD_CAST URL, BAD_CAST "file:///", 8)) { #if d...
testq %rdi, %rdi je 0x93ef7 pushq %rbx movq %rdi, %rbx leaq 0x586c5(%rip), %rsi # 0xec591 pushq $0x11 popq %rdx callq 0x32850 testl %eax, %eax je 0x93efa leaq 0x586c4(%rip), %rsi # 0xec5a3 pushq $0x8 popq %rdx movq %rbx, %rdi callq 0x32850 xorl %ecx, %ecx testl %eax, %eax pushq $0x7 popq %rax cmovneq %rcx, %rax...
/frida[P]libxml2/xmlIO.c
xmlZMemBuffExtend
static int xmlZMemBuffExtend( xmlZMemBuffPtr buff, size_t ext_amt ) { int rc = -1; size_t new_size; size_t cur_used; unsigned char * tmp_ptr = NULL; if ( buff == NULL ) return ( -1 ); else if ( ext_amt == 0 ) return ( 0 ); cur_used = buff->zctrl.next_out - buff->zbuff; new_siz...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1f8, %rsp # imm = 0x1F8 pushq $-0x1 popq %r12 testq %rdi, %rdi je 0x9438f movq %rsi, %rbx xorl %ebp, %ebp testq %rsi, %rsi je 0x94392 movq %rdi, %r14 movq 0x10(%rdi), %r15 movq 0x30(%rdi), %r13 addq (%rdi), %rbx movq 0x98858(%rip), %ra...
/frida[P]libxml2/xmlIO.c
xmlIOHTTPCloseWrite
static int xmlIOHTTPCloseWrite( void * context, const char * http_mthd ) { int close_rc = -1; int http_rtn = 0; int content_lgth = 0; xmlIOHTTPWriteCtxtPtr ctxt = context; char * http_content = NULL; char * content_encoding = NULL; char * content_type = (char *) "text/xml"; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x208, %rsp # imm = 0x208 leaq 0x583bd(%rip), %rax # 0xec77b movq %rax, 0x8(%rsp) testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl je 0x943db pushq $-0x1 popq %rbp jmp 0x945b2 movq %rsi, %r14 movq %rdi, %rbx cmpl $0x0...
/frida[P]libxml2/xmlIO.c
append_reverse_ulong
static void append_reverse_ulong( xmlZMemBuff * buff, unsigned long data ) { int idx; if ( buff == NULL ) return; /* ** This is plagiarized from putLong in gzio.c (zlib source) where ** the number "4" is hardcoded. If zlib is ever patched to ** support 64 bit file sizes, this code would...
testq %rdi, %rdi je 0x945e4 pushq $0x4 popq %rax subl $0x1, %eax jb 0x945e4 movq 0x30(%rdi), %rcx movb %sil, (%rcx) shrq $0x8, %rsi incq 0x30(%rdi) jmp 0x945ce retq nopl (%rax)
/frida[P]libxml2/xmlIO.c
xmlInitMemory
int xmlInitMemory(void) { char *breakpoint; #ifdef DEBUG_MEMORY xmlGenericError(xmlGenericErrorContext, "xmlInitMemory()\n"); #endif /* This is really not good code (see Bug 130419). Suggestions for improvement will be welcome! */ if (xmlMemInitialized) return(-1); xmlMemIni...
pushq %rbx cmpb $0x0, 0x9bbd9(%rip) # 0x130324 je 0x94752 pushq $-0x1 popq %rbx jmp 0x947bd movb $0x1, 0x9bbcb(%rip) # 0x130324 callq 0x33c30 movq %rax, 0x9bbc3(%rip) # 0x130328 leaq 0x58342(%rip), %rdi # 0xecaae callq 0x346e0 testq %rax, %rax je 0x9478e leaq 0x58344(%rip), %rsi # 0xecac1 leaq 0x9bb...
/frida[P]libxml2/xmlmemory.c
xmlMemoryDump
void xmlMemoryDump(void) { #ifdef MEM_LIST FILE *dump; if (debugMaxMemSize == 0) return; dump = fopen(".memdump", "w"); if (dump == NULL) xmlMemoryDumpFile = stderr; else xmlMemoryDumpFile = dump; xmlMemDisplay(xmlMemoryDumpFile); if (dump != NULL) fclose(dump); #endif /* MEM_LIST */ }
retq
/frida[P]libxml2/xmlmemory.c
debugmem_tag_error
static void debugmem_tag_error(void *p) { xmlGenericError(xmlGenericErrorContext, "Memory tag error occurs :%p \n\t bye\n", p); #ifdef MEM_LIST if (stderr) xmlMemDisplay(stderr); #endif }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0x34700 movq (%rax), %r14 callq 0x335a0 movq (%rax), %rdi leaq 0x58002(%rip), %rsi # 0xecad6 movq %rbx, %rdx xorl %eax, %eax movq %r14, %rcx addq $0x8, %rsp popq %rbx popq %r14 jmpq *%rcx
/frida[P]libxml2/xmlmemory.c
xmlMemDisplayLast
void xmlMemDisplayLast(FILE *fp, long nbBytes) { #ifdef MEM_LIST MEMHDR *p; unsigned idx; int nb = 0; #endif FILE *old_fp = fp; if (nbBytes <= 0) return; if (fp == NULL) { fp = fopen(".memorylist", "w"); if (fp == NULL) return; } #ifdef MEM_LIST fprintf(fp," Last ...
pushq %r14 pushq %rbx pushq %rax testq %rsi, %rsi jle 0x94dd1 movq %rdi, %rbx movq %rdi, %r14 testq %rdi, %rdi jne 0x94db7 leaq 0x57ca1(%rip), %rdi # 0xeca44 leaq 0x60dab(%rip), %rsi # 0xf5b55 callq 0x35610 movq %rax, %r14 testq %rax, %rax je 0x94dd1 leaq 0x57c92(%rip), %rdi # 0xeca50 pushq $0x32 popq %rsi ...
/frida[P]libxml2/xmlmemory.c
xmlGcMemGet
int xmlGcMemGet(xmlFreeFunc *freeFunc, xmlMallocFunc *mallocFunc, xmlMallocFunc *mallocAtomicFunc, xmlReallocFunc *reallocFunc, xmlStrdupFunc *strdupFunc) { if (freeFunc != NULL) *freeFunc = xmlFree; if (mallocFunc != NULL) *mallocFunc = xmlMalloc; if (mallocAtomicFunc != NULL) *mallocAtomi...
testq %rdi, %rdi je 0x94fe9 movq 0x97fcd(%rip), %rax # 0x12cfb0 movq (%rax), %rax movq %rax, (%rdi) testq %rsi, %rsi je 0x94ffb movq 0x97fdb(%rip), %rax # 0x12cfd0 movq (%rax), %rax movq %rax, (%rsi) testq %rdx, %rdx je 0x9500d movq 0x97b29(%rip), %rax # 0x12cb30 movq (%rax), %rax movq %rax, (%rdx) testq %r...
/frida[P]libxml2/xmlmemory.c
xmlModuleSymbol
int xmlModuleSymbol(xmlModulePtr module, const char *name, void **symbol) { int rc = -1; if ((NULL == module) || (symbol == NULL) || (name == NULL)) { __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE, XML_MODULE_OPEN, XML_ERR_FATAL, NULL, 0, 0, ...
pushq %r14 pushq %rbx subq $0x58, %rsp testq %rsi, %rsi je 0x951ad testq %rdi, %rdi je 0x951ad movq %rdx, %r14 testq %rdx, %rdx je 0x951ad movq %rsi, %rbx movq 0x8(%rdi), %rdi callq 0x35640 movq %rax, (%r14) callq 0x322d0 testq %rax, %rax je 0x9520c andl $0x0, 0x40(%rsp) andl $0x0, 0x38(%rsp) andq $0x0, 0x30(%rsp) andq...
/frida[P]libxml2/xmlmodule.c
xmlModuleFree
int xmlModuleFree(xmlModulePtr module) { if (NULL == module) { __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_MODULE, XML_MODULE_CLOSE, XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "null module pointer\n"); return -1; } xmlFree(modu...
pushq %r14 pushq %rbx subq $0x58, %rsp testq %rdi, %rdi je 0x9532f movq %rdi, %rbx movq 0x97c91(%rip), %r14 # 0x12cfb0 movq (%rdi), %rdi callq *(%r14) movq %rbx, %rdi callq *(%r14) xorl %eax, %eax jmp 0x95386 leaq 0x57812(%rip), %rax # 0xecb48 movq %rax, 0x48(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x20(%rsp) an...
/frida[P]libxml2/xmlmodule.c
xmlTextReaderFreeNode
static void xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) { xmlDictPtr dict; if ((reader != NULL) && (reader->ctxt != NULL)) dict = reader->ctxt->dict; else dict = NULL; if (cur->type == XML_DTD_NODE) { xmlFreeDtd((xmlDtdPtr) cur); return; } if (cur->type == XML_NAME...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movq 0x20(%rdi), %rax testq %rax, %rax je 0x96050 movq 0x1c8(%rax), %r15 jmp 0x96053 xorl %r15d, %r15d movl 0x8(%rbx), %eax cmpl $0x2, %eax je 0x9607f cmpl $0x12, %eax je 0x96072 cmpl $0xe, %eax jne 0x9608f movq %rbx, %rdi popq %rbx popq %r14 popq %r15 jm...
/frida[P]libxml2/xmlreader.c
xmlTextReaderEntPush
static int xmlTextReaderEntPush(xmlTextReaderPtr reader, xmlNodePtr value) { if (reader->entMax <= 0) { reader->entMax = 10; reader->entTab = (xmlNodePtr *) xmlMalloc(reader->entMax * sizeof(reader->entTab[0])); if (reader->entTab == NULL) { xmlGenericError(...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movl 0xb4(%rdi), %eax testl %eax, %eax jg 0x9625f movl $0xa, 0xb4(%rbx) movq 0x96d8c(%rip), %rax # 0x12cfd0 pushq $0x50 popq %rdi callq *(%rax) movq %rax, 0xb8(%rbx) testq %rax, %rax je 0x962da movl 0xb4(%rbx), %eax movl 0xb0(%rbx), %ecx cmpl %eax, %e...
/frida[P]libxml2/xmlreader.c
xmlTextReaderReadString
xmlChar * xmlTextReaderReadString(xmlTextReaderPtr reader) { xmlNodePtr node; if ((reader == NULL) || (reader->node == NULL)) return(NULL); node = (reader->curnode != NULL) ? reader->curnode : reader->node; switch (node->type) { case XML_TEXT_NODE: if (node->content != NULL) ...
pushq %rbx testq %rdi, %rdi je 0x968ba movq 0x70(%rdi), %rbx testq %rbx, %rbx je 0x968ba movq 0x78(%rdi), %rax testq %rax, %rax cmovneq %rax, %rbx movl 0x8(%rbx), %eax cmpl $0x1, %eax je 0x968a9 cmpl $0x2, %eax je 0x96880 cmpl $0x3, %eax jne 0x968ba movq 0x50(%rbx), %rdi testq %rdi, %rdi je 0x968ba popq %rbx jmp 0x35fc...
/frida[P]libxml2/xmlreader.c
xmlTextReaderStartElementNs
static void xmlTextReaderStartElementNs(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) { xmlP...
pushq %r14 pushq %rbx pushq %rax movq 0x1a8(%rdi), %r14 testq %r14, %r14 je 0x96ce9 movq 0x48(%r14), %rax testq %rax, %rax je 0x96ce1 movq %rdi, %rbx movl 0x28(%rsp), %r10d movl 0x20(%rsp), %r11d subq $0x8, %rsp pushq 0x38(%rsp) pushq %r10 pushq %r11 callq *%rax addq $0x20, %rsp movq 0x50(%rbx), %rax testq %rax, %rax j...
/frida[P]libxml2/xmlreader.c
xmlTextReaderCharacters
static void xmlTextReaderCharacters(void *ctx, const xmlChar *ch, int len) { xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; xmlTextReaderPtr reader = ctxt->_private; #ifdef DEBUG_CALLBACKS printf("xmlTextReaderCharacters()\n"); #endif if ((reader != NULL) && (reader->characters != NULL)) { reader->ch...
movq 0x1a8(%rdi), %rax testq %rax, %rax je 0x96d20 movq 0x58(%rax), %rax testq %rax, %rax je 0x96d20 jmpq *%rax retq
/frida[P]libxml2/xmlreader.c
xmlTextReaderClose
int xmlTextReaderClose(xmlTextReaderPtr reader) { if (reader == NULL) return(-1); reader->node = NULL; reader->curnode = NULL; reader->mode = XML_TEXTREADER_MODE_CLOSED; if (reader->faketext != NULL) { xmlFreeNode(reader->faketext); reader->faketext = NULL; } if (reader->ctx...
pushq %rbp pushq %rbx pushq %rax testq %rdi, %rdi je 0x9704d movq %rdi, %rbx xorps %xmm0, %xmm0 movups %xmm0, 0x70(%rdi) movl $0x4, (%rdi) movq 0x88(%rdi), %rdi testq %rdi, %rdi je 0x96fa2 callq 0x32710 andq $0x0, 0x88(%rbx) movq 0x20(%rbx), %rdi testq %rdi, %rdi je 0x97032 cmpq $0x0, 0xf8(%rdi) je 0x97006 cmpl $0x0, 0...
/frida[P]libxml2/xmlreader.c
xmlTextReaderLookupNamespace
xmlChar * xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, const xmlChar *prefix) { xmlNsPtr ns; if (reader == NULL) return(NULL); if (reader->node == NULL) return(NULL); ns = xmlSearchNs(reader->node->doc, reader->node, prefix); if (ns == NULL) return(NULL); return(xmlStrdup(ns->href)...
pushq %rax testq %rdi, %rdi je 0x974f2 movq %rsi, %rdx movq 0x70(%rdi), %rsi testq %rsi, %rsi je 0x974f2 movq 0x40(%rsi), %rdi callq 0x35940 testq %rax, %rax je 0x974f2 movq 0x10(%rax), %rdi popq %rax jmp 0x35fc0 xorl %eax, %eax popq %rcx retq
/frida[P]libxml2/xmlreader.c
xmlTextReaderMoveToFirstAttribute
int xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader) { if (reader == NULL) return(-1); if (reader->node == NULL) return(-1); if (reader->node->type != XML_ELEMENT_NODE) return(0); if (reader->node->nsDef != NULL) { reader->curnode = (xmlNodePtr) reader->node->nsDef; return(1); } ...
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x97804 movq 0x70(%rdi), %rcx testq %rcx, %rcx je 0x97804 xorl %eax, %eax cmpl $0x1, 0x8(%rcx) jne 0x97804 movq 0x60(%rcx), %rdx testq %rdx, %rdx jne 0x977fd movq 0x58(%rcx), %rdx testq %rdx, %rdx je 0x97804 movq %rdx, 0x78(%rdi) pushq $0x1 popq %rax retq
/frida[P]libxml2/xmlreader.c
xmlTextReaderIsEmptyElement
int xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader) { if ((reader == NULL) || (reader->node == NULL)) return(-1); if (reader->node->type != XML_ELEMENT_NODE) return(0); if (reader->curnode != NULL) return(0); if (reader->node->children != NULL) return(0); if (reader->state == XML_TEXTREADER...
pushq $-0x1 popq %rax testq %rdi, %rdi je 0x97a7d movq 0x70(%rdi), %rcx testq %rcx, %rcx je 0x97a7d xorl %eax, %eax cmpl $0x1, 0x8(%rcx) jne 0x97a7d cmpq $0x0, 0x78(%rdi) je 0x97a7e retq cmpq $0x0, 0x18(%rcx) jne 0x97a7d cmpl $0x2, 0x18(%rdi) je 0x97a7d pushq $0x1 popq %rax cmpq $0x0, 0x8(%rdi) jne 0x97a7d cmpl $0x0, 0...
/frida[P]libxml2/xmlreader.c
xmlTextReaderName
xmlChar * xmlTextReaderName(xmlTextReaderPtr reader) { xmlNodePtr node; xmlChar *ret; if ((reader == NULL) || (reader->node == NULL)) return(NULL); if (reader->curnode != NULL) node = reader->curnode; else node = reader->node; switch (node->type) { case XML_ELEMENT_NODE: case...
pushq %rbx testq %rdi, %rdi je 0x97b37 movq 0x70(%rdi), %rbx testq %rbx, %rbx je 0x97b37 movq 0x78(%rdi), %rax testq %rax, %rax cmovneq %rax, %rbx movl 0x8(%rbx), %ecx xorl %eax, %eax decl %ecx cmpl $0x11, %ecx ja 0x97b39 leaq 0x5509f(%rip), %rdx # 0xecbc4 movslq (%rdx,%rcx,4), %rcx addq %rdx, %rcx jmpq *%rcx movq ...
/frida[P]libxml2/xmlreader.c
xmlTextReaderConstName
const xmlChar * xmlTextReaderConstName(xmlTextReaderPtr reader) { xmlNodePtr node; if ((reader == NULL) || (reader->node == NULL)) return(NULL); if (reader->curnode != NULL) node = reader->curnode; else node = reader->node; switch (node->type) { case XML_ELEMENT_NODE: case XML_AT...
testq %rdi, %rdi je 0x97c61 movq 0x70(%rdi), %rcx testq %rcx, %rcx je 0x97c61 movq 0x78(%rdi), %rax testq %rax, %rax cmovneq %rax, %rcx movl 0x8(%rcx), %edx xorl %eax, %eax decl %edx cmpl $0x11, %edx ja 0x97c9d leaq 0x54fc4(%rip), %rsi # 0xecc0c movslq (%rsi,%rdx,4), %rdx addq %rsi, %rdx jmpq *%rdx movq 0xa0(%rdi),...
/frida[P]libxml2/xmlreader.c
xmlTextReaderConstBaseUri
const xmlChar * xmlTextReaderConstBaseUri(xmlTextReaderPtr reader) { xmlChar *tmp; const xmlChar *ret; if ((reader == NULL) || (reader->node == NULL)) return(NULL); tmp = xmlNodeGetBase(NULL, reader->node); if (tmp == NULL) return(NULL); ret = CONSTSTR(tmp); xmlFree(tmp); retur...
pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0x97eb6 movq %rdi, %rbx movq 0x70(%rdi), %rsi testq %rsi, %rsi je 0x97eb6 xorl %edi, %edi callq 0x34d20 testq %rax, %rax je 0x97eb6 movq %rax, %r14 movq 0xa0(%rbx), %rdi pushq $-0x1 popq %rdx movq %rax, %rsi callq 0x323f0 movq %rax, %rbx movq 0x95104(%rip), %rax ...
/frida[P]libxml2/xmlreader.c
xmlTextReaderConstXmlLang
const xmlChar * xmlTextReaderConstXmlLang(xmlTextReaderPtr reader) { xmlChar *tmp; const xmlChar *ret; if (reader == NULL) return(NULL); if (reader->node == NULL) return(NULL); tmp = xmlNodeGetLang(reader->node); if (tmp == NULL) return(NULL); ret = CONSTSTR(tmp); xmlFree(tmp)...
pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0x9817f movq %rdi, %rbx movq 0x70(%rdi), %rdi testq %rdi, %rdi je 0x9817f callq 0x33ed0 testq %rax, %rax je 0x9817f movq %rax, %r14 movq 0xa0(%rbx), %rdi pushq $-0x1 popq %rdx movq %rax, %rsi callq 0x323f0 movq %rax, %rbx movq 0x94e3b(%rip), %rax # 0x12cfb0 movq ...
/frida[P]libxml2/xmlreader.c
xmlTextReaderValidityErrorRelay
static void XMLCDECL xmlTextReaderValidityErrorRelay(void *ctx, const char *msg, ...) { xmlTextReaderPtr reader = (xmlTextReaderPtr) ctx; char *str; va_list ap; va_start(ap, msg); str = xmlTextReaderBuildMessage(msg, ap); if (!reader->errorFunc) { xmlTextReaderValidityError(ctx, "%s",...
pushq %r14 pushq %rbx subq $0xd8, %rsp movq %rsi, %r10 movq %rdi, %r14 leaq 0x20(%rsp), %rdi movq %rdx, 0x10(%rdi) movq %rcx, 0x18(%rdi) movq %r8, 0x20(%rdi) movq %r9, 0x28(%rdi) testb %al, %al je 0x9863e movaps %xmm0, 0x50(%rsp) movaps %xmm1, 0x60(%rsp) movaps %xmm2, 0x70(%rsp) movaps %xmm3, 0x80(%rsp) movaps %xmm4, 0...
/frida[P]libxml2/xmlreader.c
xmlTextReaderSetSchema
int xmlTextReaderSetSchema(xmlTextReaderPtr reader, xmlSchemaPtr schema) { if (reader == NULL) return(-1); if (schema == NULL) { if (reader->xsdPlug != NULL) { xmlSchemaSAXUnplug(reader->xsdPlug); reader->xsdPlug = NULL; } if (reader->xsdValidCtxt != NULL) { if (! reader->xsdPre...
pushq %rbp pushq %r14 pushq %rbx pushq $-0x1 popq %rbp testq %rdi, %rdi je 0x9893b movq %rsi, %r14 movq %rdi, %rbx testq %rsi, %rsi je 0x988d5 cmpl $0x0, (%rbx) jne 0x9893b movq 0x108(%rbx), %rdi testq %rdi, %rdi je 0x987ec callq 0x32160 andq $0x0, 0x108(%rbx) movq 0xf8(%rbx), %rdi testq %rdi, %rdi je 0x9880e cmpl $0x0...
/frida[P]libxml2/xmlreader.c
xmlTextReaderSchemaValidateInternal
static int xmlTextReaderSchemaValidateInternal(xmlTextReaderPtr reader, const char *xsd, xmlSchemaValidCtxtPtr ctxt, int options ATTRIBUTE_UNUSED) { if (reader == NULL) return(-1); if ((xsd != NULL) && (ctxt != NULL)) return(-1); if (((xsd != NULL) || (ctxt != NULL)) && (...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq $-0x1 popq %r12 testq %rdi, %rdi je 0x98a73 movq %rdx, %r14 movq %rsi, %r15 testq %rsi, %rsi setne %al testq %rdx, %rdx setne %cl testb %cl, %al jne 0x98a73 movq %rdi, %rbx movq %r15, %rax orq %r14, %rax je 0x98a88 cmpl $0x0, (%rbx) je 0x98a81 movl %r12d, %eb...
/frida[P]libxml2/xmlreader.c
xmlReaderForDoc
xmlTextReaderPtr xmlReaderForDoc(const xmlChar * cur, const char *URL, const char *encoding, int options) { int len; if (cur == NULL) return (NULL); len = xmlStrlen(cur); return (xmlReaderForMemory ((const char *) cur, len, URL, encoding, options)); }
testq %rdi, %rdi je 0x99a8c pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movl %ecx, %ebx movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 callq 0x33fa0 movq %r12, %rdi movl %eax, %esi movq %r15, %rdx movq %r14, %rcx movl %ebx, %r8d addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x33520 xorl %eax, ...
/frida[P]libxml2/xmlreader.c
xmlReaderNewMemory
int xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer, int size, const char *URL, const char *encoding, int options) { xmlParserInputBufferPtr input; if (reader == NULL) return (-1); if (buffer == NULL) return (-1); input = xmlParserInputBufferCreateStat...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rcx, %r15 testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl jne 0x99d60 movl %r9d, %ebx movq %r8, %r14 movq %rdi, %r12 movq %rsi, %rdi movl %edx, %esi xorl %edx, %edx callq 0x343a0 testq %rax, %rax je 0x99d60 movq %r12, %rdi movq %rax, %rsi mov...
/frida[P]libxml2/xmlreader.c
xmlReaderNewFd
int xmlReaderNewFd(xmlTextReaderPtr reader, int fd, const char *URL, const char *encoding, int options) { xmlParserInputBufferPtr input; if (fd < 0) return (-1); if (reader == NULL) return (-1); input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE); if (in...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rcx, %r14 testl %esi, %esi sets %al testq %rdi, %rdi sete %cl orb %al, %cl jne 0x99e24 movl %r8d, %ebx movq %rdx, %r15 movq %rdi, %r12 movl %esi, %edi xorl %esi, %esi callq 0x343b0 testq %rax, %rax je 0x99e24 andq $0x0, 0x10(%rax) movq %r12, %rdi movq %rax, %...
/frida[P]libxml2/xmlreader.c
xmlTextReaderFreeNodeList
static void xmlTextReaderFreeNodeList(xmlTextReaderPtr reader, xmlNodePtr cur) { xmlNodePtr next; xmlNodePtr parent; xmlDictPtr dict; size_t depth = 0; if ((reader != NULL) && (reader->ctxt != NULL)) dict = reader->ctxt->dict; else dict = NULL; if (cur == NULL) return; if (cur-...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r15 movq %rdi, %rbx movq 0x20(%rdi), %rax testq %rax, %rax je 0x99fa3 movq 0x1c8(%rax), %rax movq %rax, 0x10(%rsp) jmp 0x99fac movq $0x0, 0x10(%rsp) movl 0x8(%r15), %eax cmpl $0x9, %eax je 0x99fd5 cmpl $0xd, %eax je 0x99fd5 c...
/frida[P]libxml2/xmlreader.c
xmlRegCompactPushString
static int xmlRegCompactPushString(xmlRegExecCtxtPtr exec, xmlRegexpPtr comp, const xmlChar *value, void *data) { int state = exec->index; int i, target; if ((comp == NULL) || (comp->compact == NULL) || (comp->stringMap == NULL)) return(-1); if (valu...
pushq $-0x1 popq %rax testq %rsi, %rsi je 0x9af4e pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdx, %r8 movq %rsi, %r12 movq 0x48(%rsi), %rdx testq %rdx, %rdx je 0x9af40 movq 0x60(%r12), %rsi movq %rsi, 0x30(%rsp) testq %rsi, %rsi je 0x9af40 movl 0x50(%rdi), %esi movl 0x58(%r...
/frida[P]libxml2/xmlregexp.c
xmlRegexpCompile
xmlRegexpPtr xmlRegexpCompile(const xmlChar *regexp) { xmlRegexpPtr ret; xmlRegParserCtxtPtr ctxt; ctxt = xmlRegNewParserCtxt(regexp); if (ctxt == NULL) return(NULL); /* initialize the parser */ ctxt->end = NULL; ctxt->start = ctxt->state = xmlRegNewState(ctxt); xmlRegStatePush(ctxt, ...
pushq %r14 pushq %rbx pushq %rax callq 0x9b945 testq %rax, %rax je 0x9b92a movq %rax, %rbx andq $0x0, 0x20(%rax) movq %rax, %rdi callq 0x9b9b4 movq %rax, 0x28(%rbx) movq %rax, 0x18(%rbx) movq %rbx, %rdi movq %rax, %rsi callq 0x9ba01 pushq $0x1 popq %rsi movq %rbx, %rdi callq 0x9bab0 movq 0x8(%rbx), %rax cmpb $0x0, (%ra...
/frida[P]libxml2/xmlregexp.c
xmlFAParseRegExp
static void xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) { xmlRegStatePtr start, end; /* if not top start should have been generated by an epsilon trans */ start = ctxt->state; ctxt->end = NULL; xmlFAParseBranch(ctxt, NULL); if (top) { #ifdef DEBUG_REGEXP_GRAPH printf("State %d is final...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx movq 0x28(%rdi), %r15 andq $0x0, 0x20(%rdi) xorl %esi, %esi callq 0x9f1c8 testl %ebp, %ebp je 0x9bada movq 0x28(%rbx), %rax movl $0x2, (%rax) movq 0x8(%rbx), %rax movq 0x28(%rbx), %r14 cmpb $0x7c, (%rax) jne 0x9bb1f movb $0x7c, %cl c...
/frida[P]libxml2/xmlregexp.c
xmlRegexpErrCompile
static void xmlRegexpErrCompile(xmlRegParserCtxtPtr ctxt, const char *extra) { const char *regexp = NULL; int idx = 0; if (ctxt != NULL) { regexp = (const char *) ctxt->string; idx = ctxt->cur - ctxt->string; ctxt->error = XML_REGEXP_COMPILE_ERROR; } __xmlRaiseError(NULL, NULL, NULL, NULL...
subq $0x58, %rsp movq (%rdi), %rax movl 0x8(%rdi), %ecx movl $0x5aa, %edx # imm = 0x5AA movl %edx, 0x10(%rdi) subl %eax, %ecx movq %rsi, 0x50(%rsp) leaq 0x51f0f(%rip), %rdi # 0xeda5d movq %rdi, 0x48(%rsp) movl %ecx, 0x38(%rsp) movq %rax, 0x28(%rsp) andl $0x0, 0x40(%rsp) movq %rsi, 0x20(%rsp) andq $0x0, 0...
/frida[P]libxml2/xmlregexp.c
xmlFAEliminateEpsilonTransitions
static void xmlFAEliminateEpsilonTransitions(xmlRegParserCtxtPtr ctxt) { int statenr, transnr; xmlRegStatePtr state; int has_epsilon; if (ctxt->states == NULL) return; /* * Eliminate simple epsilon transition and the associated unreachable * states. */ xmlFAEliminateSimpleEpsilo...
cmpq $0x0, 0x50(%rdi) je 0x9bff6 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx xorl %r15d, %r15d movslq 0x4c(%rbx), %rax cmpq %rax, %r15 jge 0x9bd8f movq 0x50(%rbx), %rax movq (%rax,%r15,8), %r13 testq %r13, %r13 je 0x9bd87 cmpl $0x1, 0x18(%r13) jne 0x9bd87 movl (%r1...
/frida[P]libxml2/xmlregexp.c
xmlRegexpExec
int xmlRegexpExec(xmlRegexpPtr comp, const xmlChar *content) { if ((comp == NULL) || (content == NULL)) return(-1); return(xmlFARegExec(comp, content)); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xa8, %rsp testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl jne 0x9cb81 movq %rdi, %rbx movq %rsi, 0x70(%rsp) andl $0x0, 0x60(%rsp) andl $0x0, 0xa0(%rsp) movabsq $0x100000000, %rax # imm = 0x100000000 movq %rax, 0x10(%rsp) xorp...
/frida[P]libxml2/xmlregexp.c
xmlFAComputesDeterminism
static int xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) { int statenr, transnr; xmlRegStatePtr state; xmlRegTransPtr t1, t2, last; int i; int ret = 1; int deep = 1; #ifdef DEBUG_REGEXP_GRAPH printf("xmlFAComputesDeterminism\n"); xmlRegPrintCtxt(stdout, ctxt); #endif if (ctxt->...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movl 0x68(%rdi), %r12d cmpl $-0x1, %r12d jne 0x9d57c movq %rdi, %r13 movl 0x70(%rdi), %r8d xorl %r9d, %r9d movq %rdi, 0x20(%rsp) movl %r8d, 0x58(%rsp) movslq 0x4c(%r13), %rax cmpq %rax, %r9 jge 0x9ce47 movq 0x50(%r13), %rax movq (%rax,%r...
/frida[P]libxml2/xmlregexp.c
xmlRegFreeAtom
static void xmlRegFreeAtom(xmlRegAtomPtr atom) { int i; if (atom == NULL) return; for (i = 0;i < atom->nbRanges;i++) xmlRegFreeRange(atom->ranges[i]); if (atom->ranges != NULL) xmlFree(atom->ranges); if ((atom->type == XML_REGEXP_STRING) && (atom->valuep != NULL)) xmlFree(atom->valuep); if...
pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0x9d738 movq %rdi, %rbx xorl %r14d, %r14d movslq 0x4c(%rbx), %rax movq 0x50(%rbx), %rdi cmpq %rax, %r14 jge 0x9d6c7 movq (%rdi,%r14,8), %rdi callq 0xa0977 incq %r14 jmp 0x9d6ac testq %rdi, %rdi je 0x9d6d5 movq 0x8f8dd(%rip), %rax # 0x12cfb0 callq *(%rax) movl 0x4...
/frida[P]libxml2/xmlregexp.c
xmlAutomataNewTransition2
xmlAutomataStatePtr xmlAutomataNewTransition2(xmlAutomataPtr am, xmlAutomataStatePtr from, xmlAutomataStatePtr to, const xmlChar *token, const xmlChar *token2, void *data) { xmlRegAtomPtr atom; if ((am == NULL) || (from == NULL) || (token == NULL)) return(NULL); atom = xmlRegNewAtom(am, XML_REGE...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rcx, %rbp testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl testq %rbp, %rbp sete %al orb %cl, %al jne 0x9de99 movq %r9, %r13 movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 movq %r8, %r12 pushq $0x5 popq %rsi callq ...
/frida[P]libxml2/xmlregexp.c
xmlAutomataNewCountTrans2
xmlAutomataStatePtr xmlAutomataNewCountTrans2(xmlAutomataPtr am, xmlAutomataStatePtr from, xmlAutomataStatePtr to, const xmlChar *token, const xmlChar *token2, int min, int max, void *data) { xmlRegAtomPtr atom; int counter; if ((am == NULL) || (from == NULL) || (token == NULL)) return(NULL); ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rcx, %r12 movq %rdx, %rbx testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl testq %r12, %r12 sete %al testl %r9d, %r9d sets %dl orb %al, %dl orb %cl, %dl jne 0x9e204 movl %r9d, %ebp movl 0x60(%rsp), %ecx cmpl %r9d, %...
/frida[P]libxml2/xmlregexp.c
xmlAutomataNewCountTrans
xmlAutomataStatePtr xmlAutomataNewCountTrans(xmlAutomataPtr am, xmlAutomataStatePtr from, xmlAutomataStatePtr to, const xmlChar *token, int min, int max, void *data) { xmlRegAtomPtr atom; int counter; if ((am == NULL) || (from == NULL) || (token == NULL)) return(NULL); if (min < 0) return(NUL...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rcx, %r13 movq %rdx, %rbx testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl testq %r13, %r13 sete %al testl %r8d, %r8d sets %dl orb %al, %dl orb %cl, %dl jne 0x9e6a9 movl %r9d, %r12d movl %r8d, %ebp cmpl %r8d, %r9d setl %a...
/frida[P]libxml2/xmlregexp.c
xmlAutomataNewCounterTrans
xmlAutomataStatePtr xmlAutomataNewCounterTrans(xmlAutomataPtr am, xmlAutomataStatePtr from, xmlAutomataStatePtr to, int counter) { if ((am == NULL) || (from == NULL) || (counter < 0)) return(NULL); xmlFAGenerateCountedTransition(am, from, to, counter); if (to == NULL) return(am->state); return(to); ...
pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx testq %rdi, %rdi sete %al testq %rsi, %rsi sete %dl orb %al, %dl testl %ecx, %ecx sets %al orb %dl, %al je 0x9eb6d xorl %ebx, %ebx jmp 0x9eb81 movq %rdi, %r14 movq %rbx, %rdx callq 0x9eb8c testq %rbx, %rbx jne 0x9eb81 movq 0x28(%r14), %rbx movq %rbx, %rax addq $0x8, %rsp...
/frida[P]libxml2/xmlregexp.c