name string | code string | asm string | file string |
|---|---|---|---|
QtMWidgets::TableViewSection::qt_metacall(QMetaObject::Call, int, void**) | int QtMWidgets::TableViewSection::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetPro... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x95380
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xa52... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_tableview.cpp |
QtMWidgets::TableView::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QtMWidgets::TableView::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
auto *_t = static_cast<TableView *>(_o);
(void)_t;
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_ca... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0xa5322
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
testl %eax, %eax
jne... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_tableview.cpp |
QtMWidgets::TableView::qt_metacall(QMetaObject::Call, int, void**) | int QtMWidgets::TableView::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = ScrollArea::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetPropert... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0xa3be0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xa54... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_tableview.cpp |
QtMWidgets::TextLabel::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QtMWidgets::TextLabel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
auto *_t = static_cast<TextLabel *>(_o);
(void)_t;
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_ca... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0xa5604
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x80(%rb... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_textlabel.cpp |
QtMWidgets::TextLabel::qt_metacall(QMetaObject::Call, int, void**) | int QtMWidgets::TextLabel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QFrame::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty ||... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x95560
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xa57... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_textlabel.cpp |
QtMWidgets::TimePicker::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QtMWidgets::TimePicker::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
auto *_t = static_cast<TimePicker *>(_o);
(void)_t;
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0xa5883
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
testl %eax, %eax
jne... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_timepicker.cpp |
QtMWidgets::ToolButton::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QtMWidgets::ToolButton::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<ToolButton *>(_o);
(void)_t;
switch (_id) {
case 0: _t->iconSizeChanged((*reinterpret_cast< std::add_pointer_t<QS... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xa5aa7
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x54(%rbp)
testl %eax, %eax
je 0xa5a7a
jmp 0xa5a70
movl -0x54(%rbp), %ea... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_toolbar.cpp |
QtMWidgets::ToolButton::qt_metacall(QMetaObject::Call, int, void**) | int QtMWidgets::ToolButton::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
} else if (_c... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x95380
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xa5c... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_toolbar.cpp |
QtMWidgets::ToolBar::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QtMWidgets::ToolBar::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<ToolBar *>(_o);
(void)_t;
switch (_id) {
case 0: _t->actionTriggered((*reinterpret_cast< std::add_pointer_t<QAction*... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xa5ea7
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x88(%rbp)
subq $0x7, %rax
ja 0xa5ea0
movq -0x88(%rbp), %rax
leaq 0x6049... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_toolbar.cpp |
QtMWidgets::ToolBar::qt_metacall(QMetaObject::Call, int, void**) | int QtMWidgets::ToolBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 8)
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
} else if (_c ==... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x95380
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xa63... | /igormironchik[P]qtmwidgets/build_O0/src/QtMWidgets_autogen/EWIEGA46WW/moc_toolbar.cpp |
QtMWidgets::ProgressBarPrivate::init() | void
ProgressBarPrivate::init()
{
highlightColor = q->palette().color( QPalette::Highlight );
grooveColor = q->palette().color( QPalette::Dark );
animationColor = q->palette().color( QPalette::Base );
QSizePolicy sp( QSizePolicy::Expanding, QSizePolicy::Fixed );
if( orientation == Qt::Vertical )
sp.tra... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
callq 0x94ee0
movq %rax, %rdi
movl $0xc, %esi
callq 0xaff70
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x24(%rax)
movl 0x8(%rcx), %edx
movl %edx, 0x2c(%rax)
movw 0xc(... | /igormironchik[P]qtmwidgets/src/progressbar.cpp |
QtMWidgets::ProgressBar::ProgressBar(QWidget*) | ProgressBar::ProgressBar( QWidget * parent )
: QWidget( parent )
, d( new ProgressBarPrivate( this ) )
{
d->init();
connect( d->animation, &QVariantAnimation::valueChanged,
this, &ProgressBar::_q_animation );
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x97b20
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x94cd0
movq -0x68(%rbp), %r... | /igormironchik[P]qtmwidgets/src/progressbar.cpp |
QtMWidgets::ProgressBar::reset() | void
ProgressBar::reset()
{
d->value = d->minimum - 1;
if( d->minimum == INT_MIN )
d->value = INT_MIN;
d->animate = true;
d->animation->start();
repaint();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x28, %rdi
callq 0xb00b0
movq -0x10(%rbp), %rdi
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
addq $0x28, %rdi
callq 0xb00b0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rdi
movl %ecx, 0x10(%r... | /igormironchik[P]qtmwidgets/src/progressbar.cpp |
QtMWidgets::ProgressBar::setRange(int, int) | void
ProgressBar::setRange( int minimum, int maximum )
{
if( minimum != d->minimum || maximum != d->maximum )
{
d->minimum = minimum;
d->maximum = qMax( minimum, maximum );
if( d->value < ( d->minimum - 1 ) || d->value > d->maximum )
reset();
else
update();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0x28, %rdi
callq 0xb00b0
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0xaf0b6
movq -0x20(%rbp)... | /igormironchik[P]qtmwidgets/src/progressbar.cpp |
QtMWidgets::ProgressBar::setValue(int) | void
ProgressBar::setValue( int value )
{
if( value == d->minimum - 1 )
{
reset();
return;
}
if( d->value == value
|| ( ( value > d->maximum || value < d->minimum )
&& ( d->maximum != 0 || d->minimum != 0 ) ) )
return;
d->value = value;
emit valueChanged( value );
#ifndef QT_NO_... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x80(%rbp)
addq $0x28, %rdi
callq 0xb00b0
movq %rax, %rcx
movl -0x80(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xaf25d
movq -0... | /igormironchik[P]qtmwidgets/src/progressbar.cpp |
QtMWidgets::ProgressBar::setOrientation(Qt::Orientation) | void
ProgressBar::setOrientation( Qt::Orientation orientation )
{
if( d->orientation == orientation )
return;
d->orientation = orientation;
QSizePolicy sp = sizePolicy();
sp.transpose();
setSizePolicy( sp );
updateGeometry();
update();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
callq 0xb00b0
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xaf47a
jmp 0xaf4cc
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x28, %rdi
cal... | /igormironchik[P]qtmwidgets/src/progressbar.cpp |
xmlBufCreate | xmlBufPtr
xmlBufCreate(void) {
xmlBufPtr ret;
ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
if (ret == NULL) {
xmlBufMemoryError(NULL, "creating buffer");
return(NULL);
}
ret->use = 0;
ret->error = 0;
ret->buffer = NULL;
ret->size = xmlDefaultBufferSize;
UPDATE_COMPAT(ret);
... | pushq %rbx
movq 0xf6f3c(%rip), %rax # 0x12cfd0
pushq $0x40
popq %rdi
callq *(%rax)
testq %rax, %rax
je 0x36104
movq %rax, %rbx
andq $0x0, 0x20(%rax)
andl $0x0, 0x38(%rax)
andq $0x0, 0x30(%rax)
callq 0x32100
movslq (%rax), %rax
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
cmpl %ecx, %eax
cmovbl %eax, %ecx
movq %r... | /frida[P]libxml2/buf.c |
xmlBufDetach | xmlChar *
xmlBufDetach(xmlBufPtr buf) {
xmlChar *ret;
if (buf == NULL)
return(NULL);
if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
return(NULL);
if (buf->buffer != NULL)
return(NULL);
if (buf->error)
return(NULL);
ret = buf->content;
buf->content = NULL;
... | testq %rdi, %rdi
je 0x3624b
cmpl $0x2, 0x10(%rdi)
je 0x3624b
cmpq $0x0, 0x30(%rdi)
jne 0x3624b
cmpl $0x0, 0x38(%rdi)
je 0x3624e
xorl %eax, %eax
retq
movq (%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
retq
| /frida[P]libxml2/buf.c |
xmlBufFree | void
xmlBufFree(xmlBufPtr buf) {
if (buf == NULL) {
#ifdef DEBUG_BUFFER
xmlGenericError(xmlGenericErrorContext,
"xmlBufFree: buf == NULL\n");
#endif
return;
}
if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
(buf->contentIO != NULL)) {
xmlFree(buf->contentIO);
} else if ((buf->cont... | pushq %rbx
testq %rdi, %rdi
je 0x36342
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpl $0x3, %eax
jne 0x36344
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x36357
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x36357
jmp 0x36360
popq %rbx
retq
movq (%rbx), %rdi
testq %rdi, %rdi
sete %cl
cmpl $0x2, %eax
sete %al
orb %cl, %al
jne 0x36... | /frida[P]libxml2/buf.c |
xmlBufShrink | size_t
xmlBufShrink(xmlBufPtr buf, size_t len) {
if ((buf == NULL) || (buf->error != 0)) return(0);
CHECK_COMPAT(buf)
if (len == 0) return(0);
if (len > buf->use) return(0);
buf->use -= len;
if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) ||
((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x364dc
movq %rdi, %r14
cmpl $0x0, 0x38(%rdi)
jne 0x364dc
movq %rsi, %rbx
movq 0x28(%r14), %rax
movl 0xc(%r14), %ecx
cmpq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
setae %dl
cmpq %rcx, %rax
sete %sil
orb %dl, %sil
jne 0x36447
movq %rcx, 0x28(%r14)
movq %rcx, %rax
mo... | /frida[P]libxml2/buf.c |
xmlBufAdd | int
xmlBufAdd(xmlBufPtr buf, const xmlChar *str, int len) {
size_t needSize;
if ((str == NULL) || (buf == NULL) || (buf->error))
return -1;
CHECK_COMPAT(buf)
if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1;
if (len < -1) {
#ifdef DEBUG_BUFFER
xmlGenericError(xmlGenericErrorContext... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
pushq $-0x1
popq %r12
jne 0x36bf1
movq %rdi, %rbx
cmpl $0x0, 0x38(%rdi)
je 0x36bff
movl %r12d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movl 0xc(%rbx... | /frida[P]libxml2/buf.c |
xmlBufSetInputBaseCur | int
xmlBufSetInputBaseCur(xmlBufPtr buf, xmlParserInputPtr input,
size_t base, size_t cur) {
if (input == NULL)
return(-1);
if ((buf == NULL) || (buf->error)) {
input->base = input->cur = input->end = BAD_CAST "";
return(-1);
}
CHECK_COMPAT(buf)
input->b... | testq %rsi, %rsi
je 0x3719e
testq %rdi, %rdi
je 0x37188
cmpl $0x0, 0x38(%rdi)
je 0x371a2
leaq 0xb1438(%rip), %r8 # 0xe85c7
movq %r8, 0x28(%rsi)
movq %r8, 0x20(%rsi)
pushq $-0x1
popq %rax
pushq $0x18
jmp 0x371f3
pushq $-0x1
popq %rax
retq
movl 0xc(%rdi), %eax
cmpq $0x7ffffffe, %rax # imm = 0x7FFFFFFE
ja 0x371... | /frida[P]libxml2/buf.c |
xmlC14NProcessNodeList | static int
xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur)
{
int ret;
if (ctx == NULL) {
xmlC14NErrParam("processing node list");
return (-1);
}
for (ret = 0; cur != NULL && ret >= 0; cur = cur->next) {
ret = xmlC14NProcessNode(ctx, cur);
}
return (ret);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r13
leaq 0xa4c63(%rip), %r12 # 0xdc0f0
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x384c2
testl %r15d, %r15d
js 0x384c2
movq 0x8(%r14), %rax
movl %r13d, %ebp
testq %rax, %rax
je 0x374bd
mov... | /frida[P]libxml2/c14n.c |
xmlC14NFreeCtx | static void
xmlC14NFreeCtx(xmlC14NCtxPtr ctx)
{
if (ctx == NULL) {
xmlC14NErrParam("freeing context");
return;
}
if (ctx->ns_rendered != NULL) {
xmlC14NVisibleNsStackDestroy(ctx->ns_rendered);
}
xmlFree(ctx);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x385aa
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x3856d
movslq 0xc(%r14), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x32350
movq 0xf4a49(%rip), %rax # 0x12cfb0
movq 0x10(%r14), %rdi
callq *(%rax)
movq 0x18(%r14), %rdi
test... | /frida[P]libxml2/c14n.c |
xmlC14NIsNodeInNodeset | static int
xmlC14NIsNodeInNodeset(void *user_data, xmlNodePtr node, xmlNodePtr parent) {
xmlNodeSetPtr nodes = (xmlNodeSetPtr) user_data;
if((nodes != NULL) && (node != NULL)) {
if(node->type != XML_NAMESPACE_DECL) {
return(xmlXPathNodeSetContains(nodes, node));
} else {
xmlNs ns;
memcpy(&ns, ... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x38626
cmpl $0x12, 0x8(%rsi)
jne 0x35e70
subq $0x38, %rsp
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %rdx, %rdx
je 0x3862a
cmpl $0x2, 0x8(%rdx)
j... | /frida[P]libxml2/c14n.c |
xmlC14NPrintNamespaces | static int
xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx)
{
if ((ns == NULL) || (ctx == NULL)) {
xmlC14NErrParam("writing namespaces");
return 0;
}
if (ns->prefix != NULL) {
xmlOutputBufferWriteString(ctx->buf, " xmlns:");
xmlOutputBufferWriteString(ctx->buf, ... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x38cf5
leaq 0xa3879(%rip), %rdi # 0xdc565
callq 0x373a0
xorl %eax, %eax
jmp 0x38d5f
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
movq 0x20(%rsi), %rdi
je 0x38d2c
leaq 0xa386b(%rip), %rsi # 0xdc578... | /frida[P]libxml2/c14n.c |
xmlExcC14NVisibleNsStackFind | static int
xmlExcC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlC14NCtxPtr ctx) {
int i;
const xmlChar *prefix;
const xmlChar *href;
int has_empty_ns;
if(cur == NULL) {
xmlC14NErrParam("searching namespaces stack (exc c14n)");
return (0);
}
/*
* i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x38ddc
movq %rdx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x38df0
movq 0x18(%rsi), %r13
testq %r13, %r13
leaq 0xaf7fc(%rip), %rax # 0xe85c7
cmoveq %rax, %r13
movq 0x10(%rsi), %rbp
testq %rbp, %rbp
cmoveq %rax, %... | /frida[P]libxml2/c14n.c |
xmlFreeCatalogEntry | static void
xmlFreeCatalogEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
xmlCatalogEntryPtr ret = (xmlCatalogEntryPtr) payload;
if (ret == NULL)
return;
/*
* Entries stored in the file hash must be deallocated
* only by the file hash cleaner !
*/
if (ret->dealloc == 1)
ret... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x39117
movq %rdi, %rbx
cmpl $0x1, 0x3c(%rdi)
jne 0x3911d
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0xf644c(%rip) # 0x12f570
je 0x3916c
cmpq $0x0, 0x20(%rbx)
je 0x39143
callq 0x34700
movq (%rax), %r14
callq 0x335a0
movq (%rax), %rdi
movq 0x20(%rbx), %rdx
jmp ... | /frida[P]libxml2/catalog.c |
xmlCatalogListXMLResolve | static xmlChar *
xmlCatalogListXMLResolve(xmlCatalogEntryPtr catal, const xmlChar *pubID,
const xmlChar *sysID) {
xmlChar *ret = NULL;
xmlChar *urnID = NULL;
xmlChar *normid;
if (catal == NULL)
return(NULL);
if ((pubID == NULL) && (sysID == NULL))
return(NULL);
normid =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
testq %rdi, %rdi
je 0x39da5
movq %rdx, %rbp
movq %rsi, %r14
movq %rsi, %rax
orq %rdx, %rax
jne 0x39dac
xorl %ebp, %ebp
jmp 0x3a271
movq %rdi, %rbx
movq %r14, %rdi
callq 0x3c04e
movq %rax, %r15
testq %rax, %rax
j... | /frida[P]libxml2/catalog.c |
xmlCatalogGetSGMLSystem | static const xmlChar *
xmlCatalogGetSGMLSystem(xmlHashTablePtr catal, const xmlChar *sysID) {
xmlCatalogEntryPtr entry;
if (catal == NULL)
return(NULL);
entry = (xmlCatalogEntryPtr) xmlHashLookup(catal, sysID);
if (entry == NULL)
return(NULL);
if (entry->type == SGML_CATA_SYSTEM)
return(entry->... | testq %rdi, %rdi
je 0x3a4c4
pushq %rax
callq 0x32460
testq %rax, %rax
je 0x3a4bd
cmpl $0xd, 0x18(%rax)
jne 0x3a4bd
movq 0x30(%rax), %rax
jmp 0x3a4bf
xorl %eax, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /frida[P]libxml2/catalog.c |
xmlACatalogResolveURI | xmlChar *
xmlACatalogResolveURI(xmlCatalogPtr catal, const xmlChar *URI) {
xmlChar *ret = NULL;
if ((URI == NULL) || (catal == NULL))
return(NULL);
if (xmlDebugCatalogs)
xmlGenericError(xmlGenericErrorContext,
"Resolve URI %s\n", URI);
if (catal->type == XML_XML_CATALOG_TYPE) {
ret = xmlCatalogL... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
je 0x3a713
xorl %r15d, %r15d
jmp 0x3a782
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0xf4e50(%rip) # 0x12f570
je 0x3a741
callq 0x34700
movq (%rax), %r15
callq 0x335a0
movq (%rax), %rdi
leaq 0xa21f9(%rip), %rsi # 0xd... | /frida[P]libxml2/catalog.c |
xmlCatalogListXMLResolveURI | static xmlChar *
xmlCatalogListXMLResolveURI(xmlCatalogEntryPtr catal, const xmlChar *URI) {
xmlChar *ret = NULL;
xmlChar *urnID = NULL;
if (catal == NULL)
return(NULL);
if (URI == NULL)
return(NULL);
if (!xmlStrncmp(URI, BAD_CAST XML_URN_PUBID, sizeof(XML_URN_PUBID) - 1)) {
urnID = xmlC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
testq %rdi, %rdi
je 0x3aa12
movq %rsi, %r14
movq %rdi, %r12
leaq 0xa2447(%rip), %rsi # 0xdcbf9
pushq $0xd
popq %rdx
movq %r14, %rdi
callq 0x340f0
testl %eax, %eax
je 0x3aa29
leaq 0xa2048(%rip), %r13 # 0x... | /frida[P]libxml2/catalog.c |
xmlACatalogRemove | int
xmlACatalogRemove(xmlCatalogPtr catal, const xmlChar *value) {
int res = -1;
if ((catal == NULL) || (value == NULL))
return(-1);
if (catal->type == XML_XML_CATALOG_TYPE) {
res = xmlDelXMLCatalog(catal->xml, value);
} else {
res = xmlHashRemoveEntry(catal->sgml, value, xmlFreeCatalogEntry);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rbp
je 0x3b268
movl %ebp, %eax
jmp 0x3b323
movq %rsi, %rbx
cmpl $0x1, (%rdi)
jne 0x3b30a
movq 0x70(%rdi), %r14
testq %r14, %r14
je 0x3b261
movl 0x18(%r14), %eax... | /frida[P]libxml2/catalog.c |
xmlCatalogIsEmpty | int
xmlCatalogIsEmpty(xmlCatalogPtr catal) {
if (catal == NULL)
return(-1);
if (catal->type == XML_XML_CATALOG_TYPE) {
if (catal->xml == NULL)
return(1);
if ((catal->xml->type != XML_CATA_CATALOG) &&
(catal->xml->type != XML_CATA_BROKEN_CATALOG))
return(-1);
if (catal->xml->children == NULL)... | pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x3b3bc
cmpl $0x1, (%rdi)
jne 0x3b39c
movq 0x70(%rdi), %rcx
testq %rcx, %rcx
je 0x3b3bd
movl 0x18(%rcx), %edx
decl %edx
cmpl $0x1, %edx
ja 0x3b3bc
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
sete %al
retq
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x3b3bd
pushq %rax
callq 0x340d0
movl... | /frida[P]libxml2/catalog.c |
xmlLoadCatalog | int
xmlLoadCatalog(const char *filename)
{
int ret;
xmlCatalogPtr catal;
if (!xmlCatalogInitialized)
xmlInitializeCatalogData();
xmlRMutexLock(xmlCatalogMutex);
if (xmlDefaultCatalog == NULL) {
catal = xmlLoadACatalog(filename);
if (catal == NULL) {
xmlRMutexUnlock(xmlCatalogMutex);
... | pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xf400a(%rip) # 0x12f574
jne 0x3b571
callq 0x3b522
movq 0xf4000(%rip), %rdi # 0x12f578
callq 0x346a0
movq 0xf3ffc(%rip), %rdi # 0x12f580
testq %rdi, %rdi
je 0x3b595
movq %rbx, %rsi
callq 0x3b5c0
movl %eax, %ebx
jmp 0x3b5b0
movq %rbx, %rdi
callq 0x354d0
testq %rax, %rax
... | /frida[P]libxml2/catalog.c |
xmlFreeCatalogHashEntryList | static void
xmlFreeCatalogHashEntryList(void *payload,
const xmlChar *name ATTRIBUTE_UNUSED) {
xmlCatalogEntryPtr catal = (xmlCatalogEntryPtr) payload;
xmlCatalogEntryPtr children, next;
if (catal == NULL)
return;
children = catal->children;
while (children != NULL) {
... | testq %rdi, %rdi
je 0x3b7e2
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3b7cf
movq (%rdi), %r14
andl $0x0, 0x3c(%rdi)
andq $0x0, 0x10(%rdi)
callq 0x39104
movq %r14, %rdi
jmp 0x3b7b4
andl $0x0, 0x3c(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39104
ret... | /frida[P]libxml2/catalog.c |
xmlCatalogAdd | int
xmlCatalogAdd(const xmlChar *type, const xmlChar *orig, const xmlChar *replace) {
int res = -1;
if (!xmlCatalogInitialized)
xmlInitializeCatalogData();
xmlRMutexLock(xmlCatalogMutex);
/*
* Specific case where one want to override the default catalog
* put in place by xmlInitializeCatalo... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x0, 0xf3cbd(%rip) # 0x12f574
jne 0x3b8be
callq 0x3b522
movq 0xf3cb3(%rip), %rdi # 0x12f578
callq 0x346a0
movq 0xf3caf(%rip), %rdi # 0x12f580
testq %rdi, %rdi
je 0x3b8fc
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
cal... | /frida[P]libxml2/catalog.c |
xmlCatalogSetDebug | int
xmlCatalogSetDebug(int level) {
int ret = xmlDebugCatalogs;
if (level <= 0)
xmlDebugCatalogs = 0;
else
xmlDebugCatalogs = level;
return(ret);
} | movl 0xf3ad8(%rip), %eax # 0x12f570
xorl %ecx, %ecx
testl %edi, %edi
cmovgl %edi, %ecx
movl %ecx, 0xf3acb(%rip) # 0x12f570
retq
| /frida[P]libxml2/catalog.c |
xmlCatalogFreeLocal | void
xmlCatalogFreeLocal(void *catalogs) {
xmlCatalogEntryPtr catal;
if (!xmlCatalogInitialized)
xmlInitializeCatalog();
catal = (xmlCatalogEntryPtr) catalogs;
if (catal != NULL)
xmlFreeCatalogEntryList(catal);
} | pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xf3ac3(%rip) # 0x12f574
jne 0x3bab8
callq 0x359f0
testq %rbx, %rbx
je 0x3bac6
movq %rbx, %rdi
popq %rbx
jmp 0x390ef
popq %rbx
retq
| /frida[P]libxml2/catalog.c |
xmlCatalogGetSystem | const xmlChar *
xmlCatalogGetSystem(const xmlChar *sysID) {
xmlChar *ret;
static xmlChar result[1000];
static int msg = 0;
if (!xmlCatalogInitialized)
xmlInitializeCatalog();
if (msg == 0) {
xmlGenericError(xmlGenericErrorContext,
"Use of deprecated xmlCatalogGetSystem() call\n");
msg++;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0xf38f6(%rip) # 0x12f574
jne 0x3bc85
callq 0x359f0
cmpl $0x0, 0xf3cec(%rip) # 0x12f978
jne 0x3bcb0
callq 0x34700
movq (%rax), %r14
callq 0x335a0
movq (%rax), %rdi
leaq 0xa0e2a(%rip), %rsi # 0xdcacf
xorl %eax, %eax
callq *%r14
incl 0xf3cc8(%rip) ... | /frida[P]libxml2/catalog.c |
xmlParseSGMLCatalogName | static const xmlChar *
xmlParseSGMLCatalogName(const xmlChar *cur, xmlChar **name) {
xmlChar buf[XML_MAX_NAMELEN + 5];
int len = 0;
int c;
*name = NULL;
/*
* Handler for more complex cases
*/
c = *cur;
if ((!IS_LETTER(c) && (c != '_') && (c != ':'))) {
return(NULL);
}
w... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
andq $0x0, (%rsi)
movq %rdi, %rbx
movb (%rdi), %al
leal 0x28(%rax), %ecx
cmpb $0x1f, %cl
jb 0x3be2c
leal 0x40(%rax), %ecx
cmpb $0x17, %cl
jb 0x3be2c
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x3be2c
movzbl %al, %ecx
leal -0xf8(... | /frida[P]libxml2/catalog.c |
xmlCatalogNormalizePublic | static xmlChar *
xmlCatalogNormalizePublic(const xmlChar *pubID)
{
int ok = 1;
int white;
const xmlChar *p;
xmlChar *ret;
xmlChar *q;
if (pubID == NULL)
return(NULL);
white = 1;
for (p = pubID;*p != 0 && ok;p++) {
if (!xmlIsBlank_ch(*p))
white = 0;
e... | testq %rdi, %rdi
je 0x3c10e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rax
movabsq $0x100002600, %r14 # imm = 0x100002600
movl %eax, %esi
movl %eax, %edx
movq %rdi, %rcx
testl %esi, %esi
je 0x3c0b3
movb (%rcx), %dil
testb %dil, %dil
je 0x3c0b3
movzbl %dil, %r8d
xorl %edi, %edi
cmpl $0x20, %r... | /frida[P]libxml2/catalog.c |
xmlParseXMLCatalogOneNode | static xmlCatalogEntryPtr
xmlParseXMLCatalogOneNode(xmlNodePtr cur, xmlCatalogEntryType type,
const xmlChar *name, const xmlChar *attrName,
const xmlChar *uriAttrName, xmlCatalogPrefer prefer,
xmlCatalogEntryPtr cgroup) {
int ok = 1;
xmlChar *uriValue;
xmlChar *nameValue = NULL;
xmlChar *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x1c(%rsp)
movq %r8, %r12
movq %rdx, %rbp
movl %esi, 0x18(%rsp)
movq %rdi, %r13
testq %rcx, %rcx
je 0x3c9b6
movq %rcx, %r14
movq %r13, %rdi
movq %rcx, %rsi
callq 0x356d0
testq %rax, %rax
je 0x3c9bd
movq %rax, %rbx
xorl %r15d, ... | /frida[P]libxml2/catalog.c |
xmlDebugDumpString | void
xmlDebugDumpString(FILE * output, const xmlChar * str)
{
int i;
if (output == NULL)
output = stdout;
if (str == NULL) {
fprintf(output, "(NULL)");
return;
}
for (i = 0; i < 40; i++)
if (str[i] == 0)
return;
else if (IS_BLANK_CH(str[i]))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3d075
movq 0xeff6e(%rip), %rax # 0x12cfe0
movq (%rax), %rbx
testq %r14, %r14
je 0x3d0d8
pushq $0x20
popq %rbp
leaq 0xa0937(%rip), %r15 # 0xdd9bb
xorl %r12d, %r12d
cmpq $0x28, %r12
je 0x3d0cd
movzbl (%r1... | /frida[P]libxml2/debugXML.c |
xmlCtxtDumpInitCtxt | static void
xmlCtxtDumpInitCtxt(xmlDebugCtxtPtr ctxt)
{
int i;
ctxt->depth = 0;
ctxt->check = 0;
ctxt->errors = 0;
ctxt->output = stdout;
ctxt->doc = NULL;
ctxt->node = NULL;
ctxt->dict = NULL;
ctxt->nodict = 0;
ctxt->options = 0;
for (i = 0; i < 100; i++)
ctxt->shif... | andl $0x0, 0x70(%rdi)
movq 0xefe90(%rip), %rax # 0x12cfe0
movq (%rax), %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0x78(%rdi)
andq $0x0, 0x88(%rdi)
pushq $0x8
popq %rax
cmpq $0x6c, %rax
je 0x3d17e
movb $0x20, (%rdi,%rax)
incq %rax
jmp 0x3d16f
movb $0x0, 0x6c(%rdi)
retq
| /frida[P]libxml2/debugXML.c |
xmlCtxtDumpAttr | static void
xmlCtxtDumpAttr(xmlDebugCtxtPtr ctxt, xmlAttrPtr attr)
{
xmlCtxtDumpSpaces(ctxt);
if (attr == NULL) {
if (!ctxt->check)
fprintf(ctxt->output, "Attr is NULL");
return;
}
if (!ctxt->check) {
fprintf(ctxt->output, "ATTRIBUTE ");
xmlCtxtDumpString(ctxt, attr... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x400a7
movl 0x90(%rbx), %eax
testq %r14, %r14
je 0x3d211
testl %eax, %eax
jne 0x3d1e4
movq (%rbx), %rcx
leaq 0xa101a(%rip), %rdi # 0xde1c5
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x35710
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x400... | /frida[P]libxml2/debugXML.c |
xmlDebugDumpAttrList | void
xmlDebugDumpAttrList(FILE * output, xmlAttrPtr attr, int depth)
{
xmlDebugCtxt ctxt;
if (output == NULL) return;
xmlCtxtDumpInitCtxt(&ctxt);
ctxt.output = output;
ctxt.depth = depth;
xmlCtxtDumpAttrList(&ctxt, attr);
xmlCtxtDumpCleanCtxt(&ctxt);
} | testq %rdi, %rdi
je 0x3d38b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3d145
movq %r14, (%r15)
movl %ebp, 0x70(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d38c
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15... | /frida[P]libxml2/debugXML.c |
xmlDebugDumpNode | void
xmlDebugDumpNode(FILE * output, xmlNodePtr node, int depth)
{
xmlDebugCtxt ctxt;
if (output == NULL)
output = stdout;
xmlCtxtDumpInitCtxt(&ctxt);
ctxt.output = output;
ctxt.depth = depth;
xmlCtxtDumpNode(&ctxt, node);
xmlCtxtDumpCleanCtxt(&ctxt);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x3df7d
movq 0xef066(%rip), %rax # 0x12cfe0
movq (%rax), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3d145
movq %r14, (%r15)
movl %ebp, 0x70(%r15)
movq %r15, %rdi
movq %rbx, %rsi
c... | /frida[P]libxml2/debugXML.c |
xmlCtxtDumpDocumentHead | static void
xmlCtxtDumpDocumentHead(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
{
if (doc == NULL) return;
xmlCtxtDumpDocHead(ctxt, doc);
if (!ctxt->check) {
if (doc->name != NULL) {
fprintf(ctxt->output, "name=");
xmlCtxtDumpString(ctxt, BAD_CAST doc->name);
fprintf(ctx... | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3e216
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40719
cmpl $0x0, 0x90(%rbx)
jne 0x3e1fe
cmpq $0x0, 0x10(%r14)
je 0x3e143
movq (%rbx), %rcx
leaq 0xa0a9b(%rip), %rdi # 0xdebbc
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
callq 0x35710
movq 0x10(%r14), %rsi
movq %rbx, ... | /frida[P]libxml2/debugXML.c |
xmlDebugDumpDTD | void
xmlDebugDumpDTD(FILE * output, xmlDtdPtr dtd)
{
xmlDebugCtxt ctxt;
if (output == NULL)
output = stdout;
xmlCtxtDumpInitCtxt(&ctxt);
ctxt.options |= DUMP_TEXT_TYPE;
ctxt.output = output;
xmlCtxtDumpDTD(&ctxt, dtd);
xmlCtxtDumpCleanCtxt(&ctxt);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3e2f7
movq 0xeecec(%rip), %rax # 0x12cfe0
movq (%rax), %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x3d145
orb $0x1, 0x9c(%r15)
movq %rbx, (%r15)
testq %r14, %r14
je 0x3e333
movq %rsp, %rdi
movq %r14, %rsi
callq ... | /frida[P]libxml2/debugXML.c |
xmlShellList | int
xmlShellList(xmlShellCtxtPtr ctxt,
char *arg ATTRIBUTE_UNUSED, xmlNodePtr node,
xmlNodePtr node2 ATTRIBUTE_UNUSED)
{
xmlNodePtr cur;
if (!ctxt)
return (0);
if (node == NULL) {
fprintf(ctxt->output, "NULL\n");
return (0);
}
if ((node->type == XML_DOCUMENT_NODE)... | testq %rdi, %rdi
je 0x3e6c0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0x3e675
movl 0x8(%rdx), %eax
cmpl $0x9, %eax
je 0x3e66f
cmpl $0x12, %eax
je 0x3e696
cmpl $0xd, %eax
jne 0x3e68d
movq 0x18(%rdx), %r14
jmp 0x3e6b4
movq 0x28(%rbx), %rcx
leaq 0xb0202(%rip), %rdi # 0xee882
pushq $0x5
popq ... | /frida[P]libxml2/debugXML.c |
xmlShellPwd | int
xmlShellPwd(xmlShellCtxtPtr ctxt ATTRIBUTE_UNUSED, char *buffer,
xmlNodePtr node, xmlNodePtr node2 ATTRIBUTE_UNUSED)
{
xmlChar *path;
if ((node == NULL) || (buffer == NULL))
return (-1);
path = xmlGetNodePath(node);
if (path == NULL)
return (-1);
/*
* This test preve... | pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rbx
jne 0x3ec9c
movq %rsi, %r14
movq %rdx, %rdi
callq 0x35980
testq %rax, %rax
je 0x3ec9c
movq %rax, %r15
leaq 0xa774c(%rip), %rdx # 0xe63c0
xorl %ebx, %ebx
movl $0x1f3, %esi # imm = 0x1F3
... | /frida[P]libxml2/debugXML.c |
xmlCtxtGenericNodeCheck | static void
xmlCtxtGenericNodeCheck(xmlDebugCtxtPtr ctxt, xmlNodePtr node) {
xmlDocPtr doc;
xmlDictPtr dict;
doc = node->doc;
if (node->parent == NULL)
xmlDebugErr(ctxt, XML_CHECK_NO_PARENT,
"Node has no parent\n");
if (node->doc == NULL) {
xmlDebugErr(ctxt, XML_CHECK_... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %r15
cmpq $0x0, 0x28(%rsi)
movq %r15, %rax
jne 0x40222
leaq 0x9dfd5(%rip), %rdx # 0xde1e6
movq %rbx, %rdi
movl $0x1395, %esi # imm = 0x1395
callq 0x40189
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x40264
movq 0x98(%r15), %ra... | /frida[P]libxml2/debugXML.c |
xmlCtxtDumpEntityCallback | static void
xmlCtxtDumpEntityCallback(void *payload, void *data,
const xmlChar *name ATTRIBUTE_UNUSED)
{
xmlEntityPtr cur = (xmlEntityPtr) payload;
xmlDebugCtxtPtr ctxt = (xmlDebugCtxtPtr) data;
if (cur == NULL) {
if (!ctxt->check)
fprintf(ctxt->output, "Entity ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x90(%rsi), %eax
testq %rdi, %rdi
je 0x408a4
testl %eax, %eax
jne 0x408a8
movq %rdi, %r14
movq (%rbx), %rdi
movq 0x10(%r14), %rdx
leaq 0x9ddf0(%rip), %rsi # 0xde65f
xorl %eax, %eax
callq 0x35fa8
movl 0x5c(%r14), %ecx
leal -0x1(%rcx), %eax
cmpl $0x4, %eax
ja 0x40... | /frida[P]libxml2/debugXML.c |
xmlDictCreate | xmlDictPtr
xmlDictCreate(void) {
xmlDictPtr dict;
if (!xmlDictInitialized)
if (!__xmlInitializeDict())
return(NULL);
#ifdef DICT_DEBUG_PATTERNS
fprintf(stderr, "C");
#endif
dict = xmlMalloc(sizeof(xmlDict));
if (dict) {
dict->ref_counter = 1;
dict->limit = 0;
... | pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0xef0f5(%rip) # 0x12fd70
jne 0x40c86
callq 0x334d0
testl %eax, %eax
je 0x40cef
movq 0xec343(%rip), %r14 # 0x12cfd0
pushq $0x40
popq %rdi
callq *(%r14)
testq %rax, %rax
je 0x40cef
movq %rax, %rbx
movl $0x1, (%rax)
andq $0x0, 0x38(%rax)
movq $0x80, 0x10(%rax)
andl $0x0,... | /frida[P]libxml2/dict.c |
xmlDictLookup | const xmlChar *
xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
unsigned long key, okey, nbi = 0;
xmlDictEntryPtr entry;
xmlDictEntryPtr insert;
const xmlChar *ret;
unsigned int l;
if ((dict == NULL) || (name == NULL))
return(NULL);
if (len < 0)
l = strlen((const ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
sete %al
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x41220
movl %edx, %r8d
movq %rdi, %rbx
testl %edx, %edx
jns 0x40eb1
movq 0x8(%rsp), %rdi
callq 0x33720
movq %rax, %r8
movq 0x38(%rbx), %rdx
movl %... | /frida[P]libxml2/dict.c |
xmlDictComputeBigKey | static uint32_t
xmlDictComputeBigKey(const xmlChar* data, int namelen, int seed) {
uint32_t hash;
int i;
if (namelen <= 0 || data == NULL) return(0);
hash = seed;
for (i = 0;i < namelen; i++) {
hash += data[i];
hash += (hash << 10);
hash ^= (hash >> 6);
}
hash += (hash << 3);
... | testl %esi, %esi
setle %cl
testq %rdi, %rdi
sete %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x412f4
movl %esi, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x412e4
movzbl (%rdi,%rcx), %esi
addl %esi, %edx
imull $0x401, %edx, %esi # imm = 0x401
movl %esi, %edx
shrl $0x6, %edx
xorl %esi, %edx
incq %rcx
jmp 0x412c7
leal (%rdx... | /frida[P]libxml2/dict.c |
xmlDictExists | const xmlChar *
xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
unsigned long key, okey;
xmlDictEntryPtr insert;
unsigned int l;
if ((dict == NULL) || (name == NULL))
return(NULL);
if (len < 0)
l = strlen((const char *) name);
else
l = len;
if (((dict->limit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x41760
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r13
testl %edx, %edx
jns 0x415ac
movq %rbx, %rdi
callq 0x33720
movq %rax, %r14
movq 0x38(%r13), %rax
movl %r14d, %e... | /frida[P]libxml2/dict.c |
xmlDictOwns | int
xmlDictOwns(xmlDictPtr dict, const xmlChar *str) {
xmlDictStringsPtr pool;
if ((dict == NULL) || (str == NULL))
return(-1);
pool = dict->strings;
while (pool != NULL) {
if ((str >= &pool->array[0]) && (str <= pool->free))
return(1);
pool = pool->next;
}
if (dict->subdict)
... | pushq $-0x1
popq %rax
testq %rsi, %rsi
je 0x41d63
pushq $0x1
popq %rcx
testq %rdi, %rdi
je 0x41d63
leaq 0x20(%rdi), %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x41d58
leaq 0x28(%rdx), %r8
cmpq %rsi, %r8
ja 0x41d3f
cmpq %rsi, 0x8(%rdx)
jb 0x41d3f
jmp 0x41d64
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x41d36
xorl %eax, ... | /frida[P]libxml2/dict.c |
isolat1ToUTF8 | int
isolat1ToUTF8(unsigned char* out, int *outlen,
const unsigned char* in, int *inlen) {
unsigned char* outstart = out;
const unsigned char* base = in;
unsigned char* outend;
const unsigned char* inend;
const unsigned char* instop;
if ((out == NULL) || (in == NULL) || (outlen == ... | movq %rdx, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rsi, %xmm2
punpcklqdq %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0 # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $... | /frida[P]libxml2/encoding.c |
UTF8Toisolat1 | int
UTF8Toisolat1(unsigned char* out, int *outlen,
const unsigned char* in, int *inlen) {
const unsigned char* processed = in;
const unsigned char* outend;
const unsigned char* outstart = out;
const unsigned char* instart = in;
const unsigned char* inend;
unsigned int c, d;
int... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
testq %rcx, %rcx
sete %al
orb %r8b, %al
je 0x41ecc
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
testq %rdx, %rdx
je 0x41fbf
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rcx), %r9
addq %rdx, %r9
movslq (%rsi), %r10
a... | /frida[P]libxml2/encoding.c |
xmlGetCharEncodingName | const char*
xmlGetCharEncodingName(xmlCharEncoding enc) {
switch (enc) {
case XML_CHAR_ENCODING_ERROR:
return(NULL);
case XML_CHAR_ENCODING_NONE:
return(NULL);
case XML_CHAR_ENCODING_UTF8:
return("UTF-8");
case XML_CHAR_ENCODING_UTF16LE:
return("UTF-16");
... | decl %edi
cmpl $0x14, %edi
ja 0x427bb
movl %edi, %eax
leaq 0x9c609(%rip), %rcx # 0xdedbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
xorl %eax, %eax
retq
| /frida[P]libxml2/encoding.c |
xmlEncodingErr | static void LIBXML_ATTR_FORMAT(2,0)
xmlEncodingErr(xmlParserErrors error, const char *msg, const char *val)
{
__xmlRaiseError(NULL, NULL, NULL, NULL, NULL,
XML_FROM_I18N, error, XML_ERR_FATAL,
NULL, 0, val, NULL, NULL, 0, 0, msg, val);
}
#ifdef LIBXML_ICU_ENABLED
static ucon... | subq $0x58, %rsp
movq %rdx, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsp)
andl $0x0, 0x40(%rsp)
movq %rdx, 0x20(%rsp)
andl $0x0, 0x38(%rsp)
movl %edi, (%rsp)
andl $0x0, 0x18(%rsp)
andq $0x0, 0x10(%rsp)
movl $0x3, 0x8(%rsp)
pushq $0x1b
popq %r9
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %e... | /frida[P]libxml2/encoding.c |
xmlRegisterCharEncodingHandler | void
xmlRegisterCharEncodingHandler(xmlCharEncodingHandlerPtr handler) {
if (handlers == NULL) xmlInitCharEncodingHandlers();
if ((handler == NULL) || (handlers == NULL)) {
xmlEncodingErr(XML_I18N_NO_HANDLER,
"xmlRegisterCharEncodingHandler: NULL handler !\n", NULL);
goto free_handler;
}
... | pushq %rbx
movq %rdi, %rbx
movq 0xed485(%rip), %rax # 0x12fd98
testq %rax, %rax
jne 0x42924
callq 0x32530
movq 0xed474(%rip), %rax # 0x12fd98
testq %rbx, %rbx
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x4294e
leaq 0x9c675(%rip), %rsi # 0xdefb0
movl $0x1771, %edi # imm = 0x1771
xorl %edx, ... | /frida[P]libxml2/encoding.c |
asciiToUTF8 | static int
asciiToUTF8(unsigned char* out, int *outlen,
const unsigned char* in, int *inlen) {
unsigned char* outstart = out;
const unsigned char* base = in;
const unsigned char* processed = in;
unsigned char* outend = out + *outlen;
const unsigned char* inend;
unsigned int c;
... | pushq %rbx
movslq (%rsi), %r8
addq %rdi, %r8
movslq (%rcx), %r9
addq %rdx, %r9
xorl %eax, %eax
leaq (%rdx,%rax), %r10
cmpq %r9, %r10
jae 0x4319c
leaq 0x5(%rax), %r11
movslq (%rsi), %rbx
cmpq %rbx, %r11
jge 0x4319c
leaq (%rdi,%rax), %r11
cmpq %r8, %r11
jae 0x4319c
movb (%r10), %r10b
testb %r10b, %r10b
js 0x431a4
movb %r... | /frida[P]libxml2/encoding.c |
UTF8Toascii | static int
UTF8Toascii(unsigned char* out, int *outlen,
const unsigned char* in, int *inlen) {
const unsigned char* processed = in;
const unsigned char* outend;
const unsigned char* outstart = out;
const unsigned char* instart = in;
const unsigned char* inend;
unsigned int c, d;
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
testq %rcx, %rcx
sete %al
orb %r8b, %al
je 0x431d0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
testq %rdx, %rdx
je 0x432b3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rcx), %r9
addq %rdx, %r9
movslq (%rsi), %r10
a... | /frida[P]libxml2/encoding.c |
xmlCleanupCharEncodingHandlers | void
xmlCleanupCharEncodingHandlers(void) {
xmlCleanupEncodingAliases();
if (handlers == NULL) return;
for (;nbCharEncodingHandler > 0;) {
nbCharEncodingHandler--;
if (handlers[nbCharEncodingHandler] != NULL) {
if (handlers[nbCharEncodingHandler]->name != NULL)
xmlFree(handlers[nbCharEncod... | pushq %rbx
callq 0x35c20
cmpq $0x0, 0xecab4(%rip) # 0x12fd98
je 0x4334e
movl 0xecac4(%rip), %eax # 0x12fdb0
movq 0xe9cbd(%rip), %rbx # 0x12cfb0
testl %eax, %eax
jle 0x43336
decl %eax
movl %eax, 0xecab1(%rip) # 0x12fdb0
movq 0xeca92(%rip), %rcx # 0x12fd98
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
je ... | /frida[P]libxml2/encoding.c |
xmlGetCharEncodingHandler | xmlCharEncodingHandlerPtr
xmlGetCharEncodingHandler(xmlCharEncoding enc) {
xmlCharEncodingHandlerPtr handler;
if (handlers == NULL) xmlInitCharEncodingHandlers();
switch (enc) {
case XML_CHAR_ENCODING_ERROR:
return(NULL);
case XML_CHAR_ENCODING_NONE:
return(NULL);
case XML... | pushq %rbx
movl %edi, %ebx
cmpq $0x0, 0xeca3d(%rip) # 0x12fd98
jne 0x43362
callq 0x32530
incl %ebx
cmpl $0x16, %ebx
ja 0x434e5
leaq 0x9b9ec(%rip), %rax # 0xded60
movslq (%rax,%rbx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x9bab3(%rip), %rdi # 0xdee37
callq 0x33ba0
testq %rax, %rax
jne 0x434e7
leaq 0x9baa8(%... | /frida[P]libxml2/encoding.c |
xmlCharEncFirstLineInput | int
xmlCharEncFirstLineInput(xmlParserInputBufferPtr input, int len)
{
int ret;
size_t written;
size_t toconv;
int c_in;
int c_out;
xmlBufPtr in;
xmlBufPtr out;
if ((input == NULL) || (input->encoder == NULL) ||
(input->buffer == NULL) || (input->raw == NULL))
return (-1... | pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x43961
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
cmpq $0x0, 0x18(%rdi)
je 0x43953
movq 0x20(%r15), %r14
testq %r14, %r14
je 0x43953
movq 0x28(%r15), %rbx
testq %rbx, %rbx
je 0x43953
movl %esi, %ebp
movq %rbx, %rdi
callq ... | /frida[P]libxml2/encoding.c |
xmlCharEncInput | int
xmlCharEncInput(xmlParserInputBufferPtr input, int flush)
{
int ret;
size_t written;
size_t toconv;
int c_in;
int c_out;
xmlBufPtr in;
xmlBufPtr out;
if ((input == NULL) || (input->encoder == NULL) ||
(input->buffer == NULL) || (input->raw == NULL))
return (-1);
... | pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x43ada
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
cmpq $0x0, 0x18(%rdi)
je 0x43acc
movq 0x20(%r15), %r14
testq %r14, %r14
je 0x43acc
movq 0x28(%r15), %rbx
testq %rbx, %rbx
je 0x43acc
movl %esi, %ebp
movq %rbx, %rdi
callq ... | /frida[P]libxml2/encoding.c |
xmlCharEncInFunc | int
xmlCharEncInFunc(xmlCharEncodingHandler * handler, xmlBufferPtr out,
xmlBufferPtr in)
{
int ret;
int written;
int toconv;
if (handler == NULL)
return (-1);
if (out == NULL)
return (-1);
if (in == NULL)
return (-1);
toconv = in->use;
if (toco... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
je 0x43af7
pushq $-0x1
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl 0x8(%rdx), %ecx
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
je 0x43bfc
movq %rsi... | /frida[P]libxml2/encoding.c |
xmlEncOutputChunk | static int
xmlEncOutputChunk(xmlCharEncodingHandler *handler, unsigned char *out,
int *outlen, const unsigned char *in, int *inlen) {
int ret;
if (handler->output != NULL) {
ret = handler->output(out, outlen, in, inlen);
if (ret > 0)
ret = 0;
}
#ifdef LIBXML_ICO... | movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x43f2e
pushq %rax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq *%rax
movl %eax, %ecx
sarl $0x1f, %ecx
andl %ecx, %eax
popq %rcx
retq
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x44343
andl $0x0, (%rdx)
andl $0x0, (%r8)
pushq $-0x4
popq %rax
retq
| /frida[P]libxml2/encoding.c |
xmlGetPredefinedEntity | xmlEntityPtr
xmlGetPredefinedEntity(const xmlChar *name) {
if (name == NULL) return(NULL);
switch (name[0]) {
case 'l':
if (xmlStrEqual(name, BAD_CAST "lt"))
return(&xmlEntityLt);
break;
case 'g':
if (xmlStrEqual(name, BAD_CAST "gt"))
return(&xmlEntityGt);
b... | testq %rdi, %rdi
je 0x44434
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x61, %eax
je 0x4446f
cmpl $0x67, %eax
je 0x44437
cmpl $0x71, %eax
je 0x44453
cmpl $0x6c, %eax
jne 0x444a7
leaq 0x9bd13(%rip), %rsi # 0xe0132
movq %rbx, %rdi
callq 0x35170
testl %eax, %eax
je 0x444a7
leaq 0xeab46(%rip), %rax # 0x12... | /frida[P]libxml2/entities.c |
xmlGetDtdEntity | xmlEntityPtr
xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
xmlEntitiesTablePtr table;
if (doc == NULL)
return(NULL);
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities;
return(xmlGetEntityFromTable(table, name));
}
... | testq %rdi, %rdi
je 0x449a5
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x449a5
movq 0x60(%rax), %rdi
testq %rdi, %rdi
jne 0x32460
xorl %eax, %eax
retq
| /frida[P]libxml2/entities.c |
xmlGetDocEntity | xmlEntityPtr
xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name) {
xmlEntityPtr cur;
xmlEntitiesTablePtr table;
if (doc != NULL) {
if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->intSubset->entities;
cur = xmlGetEntityFromTable(table, ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x44a04
movq %rdi, %r14
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x449d6
movq 0x60(%rax), %rdi
testq %rdi, %rdi
je 0x449d6
movq %rbx, %rsi
callq 0x32460
testq %rax, %rax
jne 0x449fc
cmpl $0x1, 0x4c(%r14)
je 0x44a04
movq 0x58(%r14), %rax
testq %rax, %... | /frida[P]libxml2/entities.c |
xmlEncodeEntitiesInternal | static xmlChar *
xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) {
const xmlChar *cur = input;
xmlChar *buffer = NULL;
xmlChar *out = NULL;
size_t buffer_size = 0;
int html = 0;
if (input == NULL) return(NULL);
if (doc != NULL)
html = (doc->type == XML_HTML_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x44f35
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x44a4a
cmpl $0xd, 0x8(%r14)
sete %al
movl %eax, 0x8(%rsp)
jmp 0x44a52
movl $0x0, 0x8(%rsp)
movq 0xe8577(%rip), %rax # 0x12cfd0
movl $0x3... | /frida[P]libxml2/entities.c |
xmlGenericErrorDefaultFunc | void XMLCDECL
xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
va_list args;
if (xmlGenericErrorContext == NULL)
xmlGenericErrorContext = (void *) stderr;
va_start(args, msg);
vfprintf((FILE *)xmlGenericErrorContext, msg, args);
va_end(args);
} | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x45594
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
mov... | /frida[P]libxml2/error.c |
xmlParserPrintFileContextInternal | static void
xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
xmlGenericErrorFunc channel, void *data ) {
const xmlChar *cur, *base;
unsigned int n, col; /* GCC warns if signed, because compared with sizeof() */
xmlChar content[81]; /* space for 80 chars + line terminator */
xmlChar *ctnt;
... | testq %rdi, %rdi
je 0x457da
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x457cf
movq %rdx, %r14
movq %rsi, %rbx
movq 0x18(%rdi), %rcx
movq %r15, %rax
cmpq %rcx, %rax
jbe 0x45728
movzbl (%rax), %edx
cmpl $0xd, %edx
je 0x45723
cmpl $0xa, %edx
jne 0x45728
decq %ra... | /frida[P]libxml2/error.c |
xmlCopyError | int
xmlCopyError(xmlErrorPtr from, xmlErrorPtr to) {
char *message, *file, *str1, *str2, *str3;
if ((from == NULL) || (to == NULL))
return(-1);
message = (char *) xmlStrdup((xmlChar *) from->message);
file = (char *) xmlStrdup ((xmlChar *) from->file);
str1 = (char *) xmlStrdup ((xmlChar *... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x45e82
pushq $-0x1
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x35fc0
movq %rax, (%rsp)
movq 0x18(%r14), %rdi
callq 0x35fc0
movq %rax, %r12
mov... | /frida[P]libxml2/error.c |
xmlParserWarning | void XMLCDECL
xmlParserWarning(void *ctx, const char *msg, ...)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
xmlParserInputPtr input = NULL;
xmlParserInputPtr cur = NULL;
char * str;
if (ctxt != NULL) {
input = ctxt->input;
if ((input != NULL) && (input->filename == NULL) &&
(ctxt->inpu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r12
movq %rdx, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x68(%rsp)
testb %al, %al
je 0x461ee
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %x... | /frida[P]libxml2/error.c |
xmlCtxtGetLastError | xmlErrorPtr
xmlCtxtGetLastError(void *ctx)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
if (ctxt == NULL)
return (NULL);
if (ctxt->lastError.code == XML_ERR_OK)
return (NULL);
return (&ctxt->lastError);
} | testq %rdi, %rdi
je 0x46bed
leaq 0x258(%rdi), %rcx
xorl %eax, %eax
cmpl $0x0, 0x25c(%rdi)
cmovneq %rcx, %rax
retq
xorl %eax, %eax
retq
| /frida[P]libxml2/error.c |
xmlThrDefOutputBufferCreateFilenameDefault | xmlOutputBufferCreateFilenameFunc
xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func)
{
xmlOutputBufferCreateFilenameFunc old;
xmlMutexLock(xmlThrDefMutex);
old = xmlOutputBufferCreateFilenameValueThrDef;
#ifdef LIBXML_OUTPUT_ENABLED
if (old == NULL) {
old = __xmlOutput... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe8de4(%rip), %rdi # 0x12fdb8
callq 0x35680
movq 0xe8e88(%rip), %r14 # 0x12fe68
testq %r14, %r14
jne 0x46fec
movq 0xe5c2c(%rip), %r14 # 0x12cc18
movq %rbx, 0xe8e75(%rip) # 0x12fe68
movq 0xe8dbe(%rip), %rdi # 0x12fdb8
callq 0x34f00
movq %r14, %ra... | /frida[P]libxml2/globals.c |
xmlThrDefKeepBlanksDefaultValue | int xmlThrDefKeepBlanksDefaultValue(int v) {
int ret;
xmlMutexLock(xmlThrDefMutex);
ret = xmlKeepBlanksDefaultValueThrDef;
xmlKeepBlanksDefaultValueThrDef = v;
xmlMutexUnlock(xmlThrDefMutex);
return ret;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xe8a74(%rip), %rdi # 0x12fdb8
callq 0x35680
movl 0xe8121(%rip), %ebp # 0x12f470
movl %ebx, 0xe811b(%rip) # 0x12f470
movq 0xe8a5c(%rip), %rdi # 0x12fdb8
callq 0x34f00
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /frida[P]libxml2/globals.c |
xmlHashCreateDict | xmlHashTablePtr
xmlHashCreateDict(int size, xmlDictPtr dict) {
xmlHashTablePtr table;
table = xmlHashCreate(size);
if (table != NULL) {
table->dict = dict;
xmlDictReference(dict);
}
return(table);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x33ad0
movq %rax, %r14
testq %rax, %rax
je 0x47689
movq %rbx, 0x10(%r14)
movq %rbx, %rdi
callq 0x335b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /frida[P]libxml2/hash.c |
xmlHashQLookup3 | void *
xmlHashQLookup3(xmlHashTablePtr table,
const xmlChar *prefix, const xmlChar *name,
const xmlChar *prefix2, const xmlChar *name2,
const xmlChar *prefix3, const xmlChar *name3) {
unsigned long key;
xmlHashEntryPtr entry;
if (table == NULL)
return(NULL);
if (name == NULL)
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x47f68
xorl %esi, %esi
jmp 0x4816b
movq %rdx, %r12
movslq 0x18(%rdi), %rcx
testq %rsi, %rsi
movq %rsi, %rax
cmoveq %rdx, %rax
movzbl (%rax), %eax
imulq $0x1e,... | /frida[P]libxml2/hash.c |
xmlHashScanFull | void
xmlHashScanFull(xmlHashTablePtr table, xmlHashScannerFull f, void *data) {
int i, nb;
xmlHashEntryPtr iter;
xmlHashEntryPtr next;
if (table == NULL)
return;
if (f == NULL)
return;
if (table->table) {
for(i = 0; i < table->size; i++) {
if (table->table[i].valid == 0)
continue;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x48331
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x48331
movq %rsi, %r14
xorl %ecx, %ecx
movslq 0x8(%r15), %rax
cmpq %rax, %rcx
jge 0x48331
movq (%r15... | /frida[P]libxml2/hash.c |
htmlCheckAutoClose | static int
htmlCheckAutoClose(const xmlChar * newtag, const xmlChar * oldtag)
{
htmlStartCloseEntry key;
void *res;
key.oldTag = (const char *) oldtag;
key.newTag = (const char *) newtag;
res = bsearch(&key, htmlStartClose,
sizeof(htmlStartClose) / sizeof(htmlStartCloseEntry),
... | subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdi, 0x8(%rax)
leaq 0xe210a(%rip), %rsi # 0x12a870
leaq 0x4fc0(%rip), %r8 # 0x4d72d
pushq $0x10
popq %rcx
movl $0xfb, %edx
movq %rax, %rdi
callq 0x33b60
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movl %ecx, %eax
addq $0x18, %rsp
retq
| /frida[P]libxml2/HTMLparser.c |
UTF8ToHtml | int
UTF8ToHtml(unsigned char* out, int *outlen,
const unsigned char* in, int *inlen) {
const unsigned char* processed = in;
const unsigned char* outend;
const unsigned char* outstart = out;
const unsigned char* instart = in;
const unsigned char* inend;
unsigned int c, d;
int tr... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
testq %rcx, %rcx
sete %al
orb %r8b, %al
je 0x488b4
pushq $-0x1
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdx, %rdx
je 0x48a17
movq %rcx, 0x18(%rsp)
movslq (%rcx), %rbx
addq %rdx, %rbx
movq %... | /frida[P]libxml2/HTMLparser.c |
htmlParseErr | static void LIBXML_ATTR_FORMAT(3,0)
htmlParseErr(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;
... | pushq %rbx
subq $0x60, %rsp
testq %rdi, %rdi
je 0x49086
movq %rdi, %rbx
cmpl $0x0, 0x14c(%rdi)
je 0x49024
cmpl $-0x1, 0x110(%rbx)
je 0x490db
movl %esi, 0x88(%rbx)
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 ... | /frida[P]libxml2/HTMLparser.c |
htmlnamePop | static const xmlChar *
htmlnamePop(htmlParserCtxtPtr ctxt)
{
const xmlChar *ret;
if (ctxt->nameNr <= 0)
return (NULL);
ctxt->nameNr--;
if (ctxt->nameNr < 0)
return (NULL);
if (ctxt->nameNr > 0)
ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
else
ctxt->name = NULL;... | movslq 0x128(%rdi), %rdx
testq %rdx, %rdx
jle 0x49fc0
leal -0x1(%rdx), %eax
movl %eax, 0x128(%rdi)
movq 0x130(%rdi), %rcx
cmpl $0x1, %edx
jne 0x49fad
xorl %edx, %edx
jmp 0x49fb2
movq -0x10(%rcx,%rdx,8), %rdx
movq %rdx, 0x120(%rdi)
movl %eax, %eax
andq $0x0, (%rcx,%rax,8)
retq
| /frida[P]libxml2/HTMLparser.c |
htmlNewSAXParserCtxt | htmlParserCtxtPtr
htmlNewSAXParserCtxt(const htmlSAXHandler *sax, void *userData)
{
xmlParserCtxtPtr ctxt;
ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt));
if (ctxt == NULL) {
htmlErrMemory(NULL, "NewParserCtxt: out of memory\n");
return(NULL);
}
memset(ctxt, 0, sizeof(xmlParser... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0xe1af3(%rip), %r12 # 0x12cfd0
movl $0x2f0, %edi # imm = 0x2F0
callq *(%r12)
testq %rax, %rax
je 0x4b545
movq %rax, %rbx
movl $0x2f0, %edx # imm = 0x2F0
movq %rax, %rdi
xorl %esi, %esi
callq 0x32350
cal... | /frida[P]libxml2/HTMLparser.c |
htmlParseChunk | int
htmlParseChunk(htmlParserCtxtPtr ctxt, const char *chunk, int size,
int terminate) {
if ((ctxt == NULL) || (ctxt->input == NULL)) {
htmlParseErr(ctxt, XML_ERR_INTERNAL_ERROR,
"htmlParseChunk: context error\n", NULL, NULL);
return(XML_ERR_INTERNAL_ERROR);
}
if ((size > 0) && (chunk... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x4b852
movq %rsi, %r14
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x4b852
movl %ecx, %ebp
movl %edx, %r15d
testl %edx, %edx
setle %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x4b870
movq (%rsi), %ra... | /frida[P]libxml2/HTMLparser.c |
htmlCtxtReset | void
htmlCtxtReset(htmlParserCtxtPtr ctxt)
{
xmlParserInputPtr input;
xmlDictPtr dict;
if (ctxt == NULL)
return;
xmlInitParser();
dict = ctxt->dict;
while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
xmlFreeInputStream(input);
}
ctxt->inputNr = 0;
ctxt-... | testq %rdi, %rdi
je 0x4d005
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x32ce0
movq 0x1c8(%rbx), %r14
movq %rbx, %rdi
callq 0x35150
testq %rax, %rax
je 0x4cdd8
movq %rax, %rdi
callq 0x34300
jmp 0x4cdc1
andl $0x0, 0x40(%rbx)
andq $0x0, 0x38(%rbx)
andl $0x0, 0x178(%rbx)
movq 0x180(%rbx), %rax
testq %rax, %rax... | /frida[P]libxml2/HTMLparser.c |
htmlReadDoc | htmlDocPtr
htmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options)
{
htmlParserCtxtPtr ctxt;
if (cur == NULL)
return (NULL);
xmlInitParser();
ctxt = htmlCreateDocParserCtxt(cur, NULL);
if (ctxt == NULL)
return (NULL);
return (htmlDoRead(ctxt, URL, e... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4d168
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x32ce0
movq %r12, %rdi
xorl %esi, %esi
callq 0x4c923
testq %rax, %rax
je 0x4d168
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
addq ... | /frida[P]libxml2/HTMLparser.c |
htmlDoRead | static htmlDocPtr
htmlDoRead(htmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
int options, int reuse)
{
htmlDocPtr ret;
htmlCtxtUseOptions(ctxt, options);
ctxt->html = 1;
if (encoding != NULL) {
xmlCharEncodingHandlerPtr hdlr;
hdlr = xmlFindCharEncodingHandler(encoding... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, %esi
callq 0x34850
movl $0x1, 0x34(%rbx)
testq %r15, %r15
je 0x4d1da
movq %r15, %rdi
callq 0x33ba0
testq %rax, %rax
je 0x4d1da
movq %rbx, %rdi
movq %rax, %rsi
callq 0x344f0
movq 0x38(%rbx), ... | /frida[P]libxml2/HTMLparser.c |
htmlReadMemory | htmlDocPtr
htmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options)
{
htmlParserCtxtPtr ctxt;
xmlInitParser();
ctxt = htmlCreateMemoryParserCtxt(buffer, size);
if (ctxt == NULL)
return (NULL);
return (htmlDoRead(ctxt, URL, encoding, options, 0));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0x32ce0
movq %r12, %rdi
movl %ebp, %esi
callq 0x35af0
testq %rax, %rax
je 0x4d2de
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r... | /frida[P]libxml2/HTMLparser.c |
htmlReadIO | htmlDocPtr
htmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
void *ioctx, const char *URL, const char *encoding, int options)
{
htmlParserCtxtPtr ctxt;
xmlParserInputBufferPtr input;
xmlParserInputPtr stream;
if (ioread == NULL)
return (NULL);
xmlInitParser();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4d44c
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r12
callq 0x32ce0
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x337d0
testq %rax, %rax
je 0x4d425
... | /frida[P]libxml2/HTMLparser.c |
htmlCtxtReadFd | htmlDocPtr
htmlCtxtReadFd(htmlParserCtxtPtr ctxt, int fd,
const char *URL, const char *encoding, int options)
{
xmlParserInputBufferPtr input;
xmlParserInputPtr stream;
if (fd < 0)
return (NULL);
if (ctxt == NULL)
return (NULL);
xmlInitParser();
htmlCtxtReset(ctxt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x4d64f
movl %r8d, %ebx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0x32ce0
movq %r12, %rdi
callq 0x32a10
movl %ebp, %edi
xorl %esi, %esi
callq 0x34... | /frida[P]libxml2/HTMLparser.c |
htmlCompareStartClose | static int
htmlCompareStartClose(const void *vkey, const void *member) {
const htmlStartCloseEntry *key = (const htmlStartCloseEntry *) vkey;
const htmlStartCloseEntry *entry = (const htmlStartCloseEntry *) member;
int ret;
ret = strcmp(key->oldTag, entry->oldTag);
if (ret == 0)
ret = strcm... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x34bb0
testl %eax, %eax
je 0x4d74e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34bb0
| /frida[P]libxml2/HTMLparser.c |
htmlCurrentChar | static int
htmlCurrentChar(xmlParserCtxtPtr ctxt, int *len) {
const unsigned char *cur;
unsigned char c;
unsigned int val;
if (ctxt->instate == XML_PARSER_EOF)
return(0);
if (ctxt->token != 0) {
*len = 0;
return(ctxt->token);
}
if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
xmlC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
cmpl $-0x1, 0x110(%rdi)
je 0x4daae
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x114(%rdi)
je 0x4dab6
andl $0x0, (%r14)
movl 0x114(%rbx), %r15d
jmp 0x4ddbd
xorl %r15d, %r15d
jmp 0x4ddbd
cmpl $0x1, 0x198(%rbx)
je 0x4db1d
movq 0x38(%rbx), %rax
movq 0x... | /frida[P]libxml2/HTMLparser.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.