name string | code string | asm string | file string |
|---|---|---|---|
QtMWidgets::AbstractScrollArea::mouseReleaseEvent(QMouseEvent*) | void
AbstractScrollArea::mouseReleaseEvent( QMouseEvent * e )
{
if( e->button() == Qt::LeftButton )
{
d->leftMouseButtonPressed = false;
if( ( d->horIndicator->needPaint || d->vertIndicator->needPaint ) &&
( d->horIndicator->policy == ScrollIndicatorAsNeeded ||
d->vertIndicator->policy == ScrollI... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, 0x40(%rsi)
jne 0x5e5cb
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movb $0x0, 0x48(%rdi)
movq 0x58(%rdi), %rax
cmpb $0x0, 0x44(%rax)
jne 0x5e5b4
movq 0x60(%rdi), %rcx
cmpb $0x1, 0x44(%rcx)
jne 0x5e5c4
cmpl $0x0, 0x28(%rax)
je 0x5e5cf
movq 0x60(%rdi), %rax
cmpl $0x0,... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::DateTimePickerPrivate::updateDaysIfNeeded() | void
DateTimePickerPrivate::updateDaysIfNeeded()
{
if( movableSection != -1 &&
( movableSection == monthSection || movableSection == yearSection ) )
{
if( daysSection != -1 )
{
QDateTime dummy = value;
QDate date = dummy.date();
int year = dummy.date().year();
int month = dummy.date().m... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x88(%rdi), %eax
cmpl $-0x1, %eax
je 0x6036e
movq %rdi, %rbx
cmpl 0x90(%rdi), %eax
je 0x60220
cmpl 0x94(%rbx), %eax
jne 0x6036e
cmpl $-0x1, 0x8c(%rbx)
je 0x6036e
leaq 0x58(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x4d1f0
movq %r14, %rdi
callq 0x... | /igormironchik[P]qtmwidgets/src/datetimepicker.cpp |
QtMWidgets::NavigationArrowPrivate::init() | void init()
{
baseColor = q->palette().color( QPalette::Highlight );
color = baseColor;
timer = new QTimer( q );
QObject::connect( timer, &QTimer::timeout,
q, &NavigationArrow::_q_timer );
q->setSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
q->setBackgroundRole( QPalette::Base );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4dee0
movq %rax, %rdi
movl $0x4, %esi
movl $0xc, %edx
callq 0x4d550
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0xe(%rax), %rdx
movq %rcx, 0x1c(%rbx)
movq %rdx, 0x22(%rbx)
movl 0x10(%rax), %ecx
m... | /igormironchik[P]qtmwidgets/src/navigationarrow.cpp |
non-virtual thunk to QtMWidgets::TableViewCellLayout::setGeometry(QRect const&) | void
TableViewCellLayout::setGeometry( const QRect & rect )
{
QLayout::setGeometry( rect );
const QMargins m = contentsMargins();
const QRect r = rect.adjusted( m.left(), m.top(), -m.right(), -m.bottom() );
int imageOffset = 0;
const QSize accessorySizeHint = accessoryWidget->sizeHint();
if( image... | addq $-0x10, %rdi
jmp 0x64d3e
nop
| /igormironchik[P]qtmwidgets/src/tableview.cpp |
non-virtual thunk to QtMWidgets::TableViewCellLayout::heightForWidth(int) const | int
TableViewCellLayout::heightForWidth( int w ) const
{
const QSize imageSize = imageLabel->sizeHint();
const QSize accessorySize = accessoryWidget->sizeHint();
const QMargins m = contentsMargins();
const int textWidth = qMax( 10,
w - imageSize.width() - accessorySize.width() );
int height = textLab... | addq $-0x10, %rdi
jmp 0x65342
nop
| /igormironchik[P]qtmwidgets/src/tableview.cpp |
QtMWidgets::TableViewCellLayout::sizeHint() const | QSize
TableViewCellLayout::sizeHint() const
{
const QSize imageSize = imageLabel->sizeHint();
int width = imageSize.width();
int height = imageSize.height();
const QSize textSize = textLabel->sizeHint();
const QSize detailedTextSize = detailedTextLabel->sizeHint();
width += qMax( textSize.width(), d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, (%rsp)
movq %rax, %r13
shrq $0x20, %r13
movq 0x28(%r15), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, %r12
movq %rax, %rbp
shrq $0x20, %rbp
movq 0x30(%... | /igormironchik[P]qtmwidgets/src/tableview.cpp |
QtMWidgets::TableViewSectionPrivate::init() | void
TableViewSectionPrivate::init()
{
q->setSizePolicy( QSizePolicy::Minimum, QSizePolicy::Fixed );
q->setBackgroundRole( QPalette::Base );
q->setAutoFillBackground( true );
layout = new QVBoxLayout( q );
layout->setSpacing( 0 );
layout->setContentsMargins( 0, 0, 0, 0 );
QSizePolicy sp( QSizePolicy... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x10000, %esi # imm = 0x10000
callq 0x4d1e0
movq 0x8(%rbx), %rdi
movl $0x9, %esi
callq 0x4e350
movq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x4e130
movl $0x20, %edi
callq 0x4e080
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi... | /igormironchik[P]qtmwidgets/src/tableview.cpp |
QtMWidgets::MsgBoxTitlePrivate::init() | void
MsgBoxTitlePrivate::init()
{
q->setBackgroundRole( QPalette::Window );
q->setAutoFillBackground( true );
q->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
q->setMinimumHeight( qMax( FingerGeometry::height(),
q->fontMetrics().height() + q->fontMetrics().height() / 3 ) );
prepareTitle(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0xa, %esi
callq 0x4e350
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x4e130
movq (%rbx), %rdi
movl $0x70000, %esi # imm = 0x70000
callq 0x4d1e0
movq (%rbx), %r14
callq 0x63782
movl %eax, %ebp
movq (%rbx), %rax
movq... | /igormironchik[P]qtmwidgets/src/messagebox.cpp |
QtMWidgets::MessageBoxPrivate::init(QString const&, QString const&) | void
MessageBoxPrivate::init( const QString & titl, const QString & txt )
{
q->setModal( true );
QVBoxLayout * layout = new QVBoxLayout( q );
layout->setContentsMargins( 0, 0, 0, 0 );
frame = new QFrame( q );
frame->setFrameStyle( QFrame::Box | QFrame::Plain );
layout->addWidget( frame );
vbox = n... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1, %esi
callq 0x4d840
movl $0x20, %edi
callq 0x4e080
movq %rax, %r12
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x4dc20
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx... | /igormironchik[P]qtmwidgets/src/messagebox.cpp |
QtMWidgets::MsgBoxTitle::paintEvent(QPaintEvent*) | void paintEvent( QPaintEvent * ) override
{
QPainter p( this );
p.setPen( palette().color( QPalette::WindowText ) );
p.drawText( rect().marginsRemoved( QMargins( d->margin, 0,
d->margin, 0 ) ),
d->preparedTitle, QTextOption( Qt::AlignLeft | Qt::AlignVCenter ) );
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4ea40
movq %rbx, %rdi
callq 0x4dee0
movq %rax, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x4d550
movq (%rax), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x4e7e0
movq 0x28(%rbx), %r14
movl 0x20(%r14), %eax
cvt... | /igormironchik[P]qtmwidgets/src/messagebox.cpp |
QtMWidgets::NavigationBar::removeWidget(QWidget*) | void
NavigationBar::removeWidget( QWidget * widget )
{
const int index = d->stack->indexOf( widget );
if( index != -1 )
{
d->removeWidget( widget );
d->backStack.clear();
d->forwardStack.clear();
d->left->hide();
d->right->hide();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x4eb30
cmpl $-0x1, %eax
je 0x6cad5
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x6c4e0
movq 0x28(%rbx), %rdi
addq $0x50, %rdi
callq 0x6d040
movq 0x28(%rbx), %rdi
addq $0x68, %rdi
callq 0x6d040
movq 0x28(%r... | /igormironchik[P]qtmwidgets/src/navigationbar.cpp |
QtMWidgets::PageViewPrivate::movePages() | void
PageViewPrivate::movePages()
{
const int index = control->currentIndex();
if( index != 0 )
{
const QPoint p = viewport->rect().topLeft() -
QPoint( viewport->width(), 0 ) + QPoint( pagesOffset, 0 );
pages.at( index - 1 )->move( p );
}
if( index < control->count() - 1 )
{
const QPoin... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x6af10
movl %eax, %ebp
movslq %eax, %r14
testl %eax, %eax
je 0x6e95c
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rax
movl 0x1c(%rax), %ecx
notl %ecx
addl 0x14(%rax), %ecx
addl 0x4c(%rbx), %ecx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi... | /igormironchik[P]qtmwidgets/src/pageview.cpp |
QtMWidgets::PageView::insertWidget(int, QWidget*) | int
PageView::insertWidget( int index, QWidget * widget )
{
index = qMin( index, d->pages.count() );
if( index < 0 )
index = d->pages.count();
d->pages.insert( index, widget );
d->prepareWidget( widget, frameRect().adjusted( frameWidth(), frameWidth(),
-frameWidth(), -frameWidth() ) );
widget-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq 0x30(%rdi), %rbx
addq $0x20, %rdi
movslq %esi, %rax
cmpq %rax, %rbx
cmovlq %rbx, %rax
testl %eax, %eax
cmovnsl %eax, %ebx
movq %rdx, 0x10(%rsp)
movslq %ebx, %rsi
leaq 0x18(%rsp), %rax
movq %rdx,... | /igormironchik[P]qtmwidgets/src/pageview.cpp |
QtMWidgets::ToolBarLayout::spaceNeeded() const | int
ToolBarLayout::spaceNeeded() const
{
QSize size( 0, 0 );
foreach( QLayoutItem * item, buttons )
{
size += item->sizeHint();
size += QSize( spacing(), spacing() );
}
if( orient == Qt::Horizontal )
return size.width();
else
return size.height();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq 0x40(%rdi), %rcx
testq %rax, %rax
je 0x7013e
lock
incl (%rax)
movq %rax, (%rsp)
testq %rcx, %rcx
je 0x701a1
shlq $0x3, %rcx
xorl %ebx, %ebx
xorl %ebp,... | /igormironchik[P]qtmwidgets/src/toolbar.cpp |
QtMWidgets::SwitchPrivate::SwitchPrivate(QtMWidgets::Switch*) | explicit SwitchPrivate( Switch * parent )
: q( parent )
, state( Switch::AcceptedUncheck )
, radius( 0 )
, textWidth( 0 )
, offset( 0 )
, mouseMoveDelta( 0 )
, leftMouseButtonPressed( false )
{
init();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
movl $0x1, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movl $0x0, 0x40(%rdi)
movw $0xffff, 0x44(%rdi) # imm = 0xFFFF
xorl %eax, %eax
movq %rax, 0x46(%rdi)
movq %rax, 0... | /igormironchik[P]qtmwidgets/src/switch.cpp |
dump | static void dump(const char *timebuf, const char *text,
FILE *stream, const unsigned char *ptr, size_t size,
trace tracetype, curl_infotype infotype)
{
size_t i;
size_t c;
unsigned int width = 0x10;
if(tracetype == TRACE_ASCII)
/* without the hex output, we can fit more o... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x10, -0x44(%rbp)
cmpl $0x2, -0x2c(%rbp)
jne 0x7cc7
movl $0x40, -0x44(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rb... | /lesstif[P]curl/src/tool_cb_dbg.c |
tool_progress_cb | int tool_progress_cb(void *clientp,
double dltotal, double dlnow,
double ultotal, double ulnow)
{
/* The original progress-bar source code was written for curl by Lars Aas,
and this new edition inherits some of his concepts. */
char line[MAX_BARLENGTH+1];
char forma... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
cvttsd2si -0x10(%rbp), %rax
cvttsd2si -0x20(%rbp), %rcx
addq %rcx, %rax
movq -0x18... | /lesstif[P]curl/src/tool_cb_prg.c |
progressbarinit | void progressbarinit(struct ProgressData *bar,
struct Configurable *config)
{
#ifdef __EMX__
/* 20000318 mgs */
int scr_size[2];
#endif
char *colp;
memset(bar, 0, sizeof(struct ProgressData));
/* pass this through to progress function so
* it can display progress towards total file
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x7160
movq -0x10(%rbp), %rax
testb $0x1, 0x50(%rax)
je 0x87ba
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0x11992(%rip)... | /lesstif[P]curl/src/tool_cb_prg.c |
free_config_fields | void free_config_fields(struct Configurable *config)
{
struct getout *urlnode;
if(config->easy) {
curl_easy_cleanup(config->easy);
config->easy = NULL;
}
Curl_safefree(config->random_file);
Curl_safefree(config->egd_file);
Curl_safefree(config->useragent);
Curl_safefree(config->cookie);
Curl_s... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8cbd
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x7260
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x8cbf
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8ce3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
ca... | /lesstif[P]curl/src/tool_cfgable.c |
easysrc_add | CURLcode easysrc_add(struct curl_slist **plist, const char *line)
{
CURLcode ret = CURLE_OK;
struct curl_slist *list =
curl_slist_append(*plist, line);
if(!list) {
easysrc_free();
ret = CURLE_OUT_OF_MEMORY;
}
else
*plist = list;
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x70d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9990
callq 0x99b0
movl $0x1b, -0x14(%rbp)
jmp 0x999b
movq -0x20(%rbp), %rcx
movq... | /lesstif[P]curl/src/tool_easysrc.c |
easysrc_free | static void easysrc_free(void)
{
curl_slist_free_all(easysrc_decl);
easysrc_decl = NULL;
curl_slist_free_all(easysrc_data);
easysrc_data = NULL;
curl_slist_free_all(easysrc_code);
easysrc_code = NULL;
curl_slist_free_all(easysrc_toohard);
easysrc_toohard = NULL;
curl_slist_free_all(easysrc_clean);
e... | pushq %rbp
movq %rsp, %rbp
movq 0x1a945(%rip), %rdi # 0x24300
callq 0x7350
movq $0x0, 0x1a935(%rip) # 0x24300
movq 0x1a936(%rip), %rdi # 0x24308
callq 0x7350
movq $0x0, 0x1a926(%rip) # 0x24308
movq 0x1a927(%rip), %rdi # 0x24310
callq 0x7350
movq $0x0, 0x1a917(%rip) # 0x24310
movq 0x1a918(%rip), %rdi # 0... | /lesstif[P]curl/src/tool_easysrc.c |
easysrc_addf | CURLcode easysrc_addf(struct curl_slist **plist, const char *fmt, ...)
{
CURLcode ret;
char *bufp;
va_list ap;
va_start(ap, fmt);
bufp = curlx_mvaprintf(fmt, ap);
va_end(ap);
if(! bufp) {
ret = CURLE_OUT_OF_MEMORY;
}
else {
ret = easysrc_add(plist, bufp);
curl_free(bufp);
}
return ret;... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x9a6b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)... | /lesstif[P]curl/src/tool_easysrc.c |
formparse | int formparse(struct Configurable *config,
const char *input,
struct curl_httppost **httppost,
struct curl_httppost **last_post,
bool literal_value)
{
/* nextarg MUST be a string in the format 'name=contents' and we'll
build a linked list with the info */
... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq $0x0, -0x138(%rbp)
movq $0x0, -0x250(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x130(%rbp), %rdx
leaq 0x1055... | /lesstif[P]curl/src/tool_formparse.c |
tool_help | void tool_help(void)
{
int i;
for(i = 0; helptext[i]; i++) {
puts(helptext[i]);
#ifdef PRINT_LINES_PAUSE
if(i && ((i % PRINT_LINES_PAUSE) == 0))
tool_pressanykey();
#endif
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x14696(%rip), %rax # 0x230c0
cmpq $0x0, (%rax,%rcx,8)
je 0xea50
movslq -0x4(%rbp), %rcx
leaq 0x14684(%rip), %rax # 0x230c0
movq (%rax,%rcx,8), %rdi
callq 0x7470
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%... | /lesstif[P]curl/src/tool_help.c |
SetHTTPrequest | int SetHTTPrequest(struct Configurable *config, HttpReq req, HttpReq *store)
{
if((*store == HTTPREQ_UNSPEC) ||
(*store == req)) {
*store = req;
return 0;
}
warnf(config, "You can only select one HTTP request!\n");
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xeb47
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xeb59
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%... | /lesstif[P]curl/src/tool_helpers.c |
GetEnv | static char *GetEnv(const char *variable, char do_expand)
{
char *env = NULL;
#ifdef WIN32
char buf1[1024], buf2[1024];
DWORD rc;
/* Don't use getenv(); it doesn't find variable added after program was
* started. Don't accept truncated results (i.e. rc >= sizeof(buf1)). */
rc = GetEnvironmentVariable(v... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7360
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xec79
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xec79
movq -0x18(%rbp), %rdi
callq 0x7560... | /lesstif[P]curl/src/tool_homedir.c |
main | int main(int argc, char *argv[])
{
int res;
struct Configurable config;
memset(&config, 0, sizeof(struct Configurable));
config.errors = stderr; /* default errors to stderr */
main_checkfds();
res = operate(&config, argc, argv);
#ifdef __SYMBIAN32__
if(config.showerror)
tool_pressanykey();
#endif... | pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x3b0(%rbp), %rdi
xorl %esi, %esi
movl $0x398, %edx # imm = 0x398
callq 0x7160
movq 0x1523d(%rip), %rax # 0x23fe0
movq (%rax), %rax
movq %rax, -0x150(%rbp)
callq ... | /lesstif[P]curl/src/tool_main.c |
main_checkfds | static void main_checkfds(void)
{
#ifdef HAVE_PIPE
int fd[2] = { STDIN_FILENO, STDIN_FILENO };
while(fd[0] == STDIN_FILENO ||
fd[0] == STDOUT_FILENO ||
fd[0] == STDERR_FILENO ||
fd[1] == STDIN_FILENO ||
fd[1] == STDOUT_FILENO ||
fd[1] == STDERR_FILENO)
if(pipe(fd) < 0)
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x7160
movb $0x1, %al
cmpl $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0xee39
movb $0x1, %al
cmpl $0x1, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0xee39
movb $0x1, %al
cmpl $0x2, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0xee39
movb ... | /lesstif[P]curl/src/tool_main.c |
AppendNode | static void AppendNode(struct multi_files **first,
struct multi_files **last,
struct multi_files *new)
{
DEBUGASSERT(((*first) && (*last)) || ((!*first) && (!*last)));
if(*last)
(*last)->next = new;
else
*first = new;
*last = new;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xefe2
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xeffd
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xf008
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
mov... | /lesstif[P]curl/src/tool_mfiles.c |
file2string | ParameterError file2string(char **bufp, FILE *file)
{
char buffer[256];
char *ptr;
char *string = NULL;
size_t stringlen = 0;
size_t buflen;
if(file) {
while(fgets(buffer, sizeof(buffer), file)) {
if((ptr = strchr(buffer, '\r')) != NULL)
*ptr = '\0';
if((ptr = strchr(buffer, '\n')) ... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x130(%rbp)
movq $0x0, -0x138(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14be5
jmp 0x14ac6
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x100, %esi # imm = 0x100
callq 0x7490
cmpq $0... | /lesstif[P]curl/src/tool_paramhlp.c |
str2num | ParameterError str2num(long *val, const char *str)
{
if(str) {
char *endptr;
long num = strtol(str, &endptr, 10);
if((endptr != str) && (endptr == str + strlen(str))) {
*val = num;
return PARAM_OK; /* Ok */
}
}
return PARAM_BAD_NUMERIC; /* badness */
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14e69
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x7400
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x14e67
movq -0x20(%rbp), %rax
movq %rax, -0x30(%... | /lesstif[P]curl/src/tool_paramhlp.c |
proto2num | long proto2num(struct Configurable *config, long *val, const char *str)
{
char *buffer;
const char *sep = ",";
char *token;
static struct sprotos {
const char *name;
long bit;
} const protos[] = {
{ "all", CURLPROTO_ALL },
{ "http", CURLPROTO_HTTP },
{ "https", CURLPROTO_HTTPS },
{ "f... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0xa3da(%rip), %rax # 0x1f2b5
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14ef3
movq $0x1, -0x8(%rbp)
jmp 0x150e1
movq -0x20(%rbp), %rdi
callq 0x7560
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(... | /lesstif[P]curl/src/tool_paramhlp.c |
tool_setopt_flags | CURLcode tool_setopt_flags(CURL *curl, struct Configurable *config,
const char *name, CURLoption tag,
const NameValue *nvlist, long lval)
{
CURLcode ret = CURLE_OK;
bool skip = FALSE;
ret = curl_easy_setopt(curl, tag, lval);
if(!lval)
skip = TRUE;
if... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movb $0x0, -0x35(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x7410... | /lesstif[P]curl/src/tool_setopt.c |
tool_go_sleep | void tool_go_sleep(long ms)
{
#if defined(MSDOS)
delay(ms);
#elif defined(WIN32)
Sleep(ms);
#elif defined(HAVE_POLL_FINE)
poll((void *)0, 0, (int)ms);
#else
struct timeval timeout;
timeout.tv_sec = ms / 1000L;
ms = ms % 1000L;
timeout.tv_usec = ms * 1000L;
select(0, NULL, NULL, NULL, &timeout);
#endif
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x7450
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /lesstif[P]curl/src/tool_sleep.c |
tool_tvnow | struct timeval tool_tvnow(void)
{
/*
** gettimeofday() is not granted to be increased monotonically, due to
** clock drifting and external source time synchronization it can jump
** forward or backward in time.
*/
struct timeval now;
(void)gettimeofday(&now, NULL);
return now;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %esi
leaq -0x10(%rbp), %rdi
callq 0x74b0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /lesstif[P]curl/src/tool_util.c |
Curl_raw_toupper | char Curl_raw_toupper(char in)
{
switch (in) {
case 'a':
return 'A';
case 'b':
return 'B';
case 'c':
return 'C';
case 'd':
return 'D';
case 'e':
return 'E';
case 'f':
return 'F';
case 'g':
return 'G';
case 'h':
return 'H';
case 'i':
return 'I';
case 'j':
ret... | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x19, %eax
ja 0x1921f
movq -0x10(%rbp), %rax
leaq 0x6705(%rip), %rcx # 0x1f870
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x41, -0x1(%rbp)
jmp 0x192... | /lesstif[P]curl/lib/rawstr.c |
main | int main(int argc, char** argv) {
if (argc == 2 && 0 == strcmp(argv[1], "pwd")) {
std::cout << Omega_h::filesystem::current_path() << '\n';
} else if (argc == 2 && 0 == strcmp(argv[1], "ls")) {
for (Omega_h::filesystem::directory_iterator
it(Omega_h::filesystem::current_path()),
end;
... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x1336
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xd42(%rip), %rsi # 0x2004
callq 0x10e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1... | /gahansen[P]omega_h/src/osh_filesystem.cpp |
doctest::detail::ContextScopeBase::destroy() | void ContextScopeBase::destroy() {
#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
if(std::uncaught_exceptions() > 0) {
#else
if(std::uncaught_exception()) {
#endif
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, %rbx
callq 0x4430
testl %eax, %eax
jle 0x776e
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x44a0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movl $0x10f8, %ebx # imm = 0x10F8
addq 0x1acbb(%rip), %rbx... | /igormironchik[P]args-parser/tests/auto/stuff/../../../3rdparty/doctest/doctest.h |
doctest::detail::MessageBuilder::MessageBuilder(char const*, int, doctest::assertType::Enum) | MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
m_stream = tlssPush();
m_file = file;
m_line = line;
m_severity = severity;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movb %al, (%rdi)
movb $0x17, 0x17(%rdi)
movb %al, 0x30(%rdi)
callq 0x4f4d
movq %rax, 0x28(%rbx)
movq %r15, 0x18(%rbx)
movl %r14d, 0x20(%rbx)
movl %ebp, 0x24(%rbx)
addq $0x8, %rsp
popq ... | /igormironchik[P]args-parser/tests/auto/stuff/../../../3rdparty/doctest/doctest.h |
doctest::detail::MessageBuilder::~MessageBuilder() | MessageBuilder::~MessageBuilder() {
if (!logged)
tlssPop();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x8024
leaq 0x8(%rsp), %rdi
callq 0x4fbf
cmpb $0x0, 0x1f(%rsp)
jns 0x8024
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8024
callq 0x4470
cmpb $0x0, 0x17(%rbx)
jns 0x8037
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8037
callq 0x4470
addq $0x20, %rsp
popq %r... | /igormironchik[P]args-parser/tests/auto/stuff/../../../3rdparty/doctest/doctest.h |
doctest::detail::MessageBuilder::log() | bool MessageBuilder::log() {
if (!logged) {
m_string = tlssPop();
logged = true;
}
DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
const bool isWarn = m_severity & assertType::is_warn;
// warn is just a message in this context so we don't... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x80b7
movq %rsp, %r14
movq %r14, %rdi
callq 0x4fbf
cmpq %rbx, %r14
je 0x809e
cmpb $0x0, 0x17(%rbx)
jns 0x808c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x808c
callq 0x4470
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movu... | /igormironchik[P]args-parser/tests/auto/stuff/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlReporter::report_query(doctest::QueryData const&) | void report_query(const QueryData& in) override {
test_run_start();
if(opt.list_reporters) {
for(auto& curr : getListeners())
xml.scopedElement("Listener")
.writeAttribute("priority", curr.first.first)
.w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0x48(%rsp)
movq 0x78(%rbx), %rax
cmpb $0x1, 0x86(%rax)
jne 0xc58a
callq 0xae9e
movq 0x16715(%rip), %rbx # 0x22a50
leaq 0x166fe(%rip), %rax # 0x22a40
cm... | /igormironchik[P]args-parser/tests/auto/stuff/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_run_start() | void test_run_start() override {
// remove .exe extension - mainly to have the same output on UNIX and Windows
std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
#ifdef DOCTEST_PLATFORM_WINDOWS
if(binary_name.rfind(".exe") != std::string::npos)
b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdi, %r14
movq 0x78(%rdi), %rdi
cmpb $0x0, 0x1f(%rdi)
jns 0xcd64
movq 0x8(%rdi), %rdi
jmp 0xcd68
addq $0x8, %rdi
callq 0x5ba2
leaq 0x148(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0x4160
leaq 0... | /igormironchik[P]args-parser/tests/auto/stuff/../../../3rdparty/doctest/doctest.h |
void llvm::cl::initializer<char [2]>::apply<llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::... | void apply(Opt &O) const { O.setInitialValue(Init); } | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x2c268
leaq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0x26840
movb $0x1, 0xc8(%rbx)
addq $0xa8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26840
movq (%r14), %rdi
leaq 0x18(%rsp), %ra... | /llvm/Support/CommandLine.h |
llvm::yaml::yaml2coff(llvm::COFFYAML::Object&, llvm::raw_ostream&, llvm::function_ref<void (llvm::Twine const&)>) | bool yaml2coff(llvm::COFFYAML::Object &Doc, raw_ostream &Out,
ErrorHandler ErrHandler) {
COFFParser CP(Doc, ErrHandler);
if (!CP.parse()) {
ErrHandler("failed to parse YAML file");
return false;
}
if (!layoutOptionalHeader(CP)) {
ErrHandler("failed to layout optional header for COFF ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp # imm = 0x3E8
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
leaq 0xe0(%rsp), %rax
movq %rdi, -0x48(%rax)
pxor %xmm0, %xmm0
movdqu %xmm0, -0x40(%rax)
movdqu %xmm0, -0x30(%rax)
movdqu %xmm0, -0x20(%rax)
movq %rax, -0x10(... | /ObjectYAML/COFFEmitter.cpp |
void llvm::SmallVectorImpl<unsigned int>::append<__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, void>(__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsig... | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x2, %r13
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
movq %rax, %rdx
addq %r13, %rdx
cmpq %rcx, %rdx
jbe 0x31f30
leaq 0x10(%rbx), %rsi
movl $0x4, %ecx
movq %rbx, %r... | /llvm/ADT/SmallVector.h |
llvm::mcdxbc::PSVRuntimeInfo::PSVRuntimeInfo() | PSVRuntimeInfo() : DXConStrTabBuilder(StringTableBuilder::DXContainer) {
memset((void *)&BaseData, 0, sizeof(dxbc::PSV::v3::RuntimeInfo));
} | pushq %rbx
movq %rdi, %rbx
movb $0x0, (%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rdi)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0x40(%rdi)
leaq 0x88(%rdi), %rax
movq %rax, 0x78(%rdi)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x80(%rdi)
leaq 0xf8(%rdi), %rcx
movq %rcx, 0xe8(%... | /llvm/MC/DXContainerPSVInfo.h |
llvm::yaml::ScalarEnumerationTraits<llvm::dxbc::PSV::SemanticKind, void>::enumeration(llvm::yaml::IO&, llvm::dxbc::PSV::SemanticKind&) | void ScalarEnumerationTraits<dxbc::PSV::SemanticKind>::enumeration(
IO &IO, dxbc::PSV::SemanticKind &Value) {
for (const auto &E : dxbc::PSV::getSemanticKinds())
IO.enumCase(Value, E.Name.str().c_str(), E.Value);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12cc28
testq %rdx, %rdx
je 0x34dee
movq %rax, %r15
leaq (%rdx,%rdx,4), %rax
leaq (%r15,%rax,8), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %r13
addq $0x8, %r15
movq -0x8(%r15), %rsi
testq %rsi, %r... | /ObjectYAML/DXContainerYAML.cpp |
std::enable_if<has_SequenceTraits<std::vector<unsigned int, std::allocator<unsigned int>>>::value, void>::type llvm::yaml::yamlize<std::vector<unsigned int, std::allocator<unsigned int>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<unsigned int, std::allocator<unsigned int>>&, bool, llvm::yaml::EmptyContext&... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%r15), %rcx
subq (%r15), %rcx
shrq $0x2, %rcx
testb %al, %al
cmovel %ebp, %ecx
tes... | /llvm/Support/YAMLTraits.h |
void llvm::yaml::IO::processKey<llvm::dxbc::SigComponentType, llvm::yaml::EmptyContext>(char const*, llvm::dxbc::SigComponentType&, bool, llvm::yaml::EmptyContext&) | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
yamlize(*this, Val, Required, Ctx);
this->postflightKey(SaveInfo);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xf(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x78(%rax)
testb %al, %al
je 0x3756b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35176
movq (%rbx), %ra... | /llvm/Support/YAMLTraits.h |
llvm::ELFYAML::appendUniqueSuffix[abi:cxx11](llvm::StringRef, llvm::Twine const&) | std::string llvm::ELFYAML::appendUniqueSuffix(StringRef Name,
const Twine &Msg) {
// Do not add a space when a Name is empty.
std::string Ret = Name.empty() ? "" : Name.str() + ' ';
return Ret + (Twine(SuffixStart) + Msg + Twine(SuffixEnd)).str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x399ef
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
testq %rsi, %rsi
je 0x39a11
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2b608
movq 0x8(%r15), %rsi
jmp 0x39a21
leaq 0x18(%rsp), %rax
mov... | /ObjectYAML/ELFEmitter.cpp |
llvm::ELFYAML::shouldAllocateFileSpace(llvm::ArrayRef<llvm::ELFYAML::ProgramHeader>, llvm::ELFYAML::NoBitsSection const&) | bool llvm::ELFYAML::shouldAllocateFileSpace(
ArrayRef<ELFYAML::ProgramHeader> Phdrs, const ELFYAML::NoBitsSection &S) {
for (const ELFYAML::ProgramHeader &PH : Phdrs) {
auto It = llvm::find_if(
PH.Chunks, [&](ELFYAML::Chunk *C) { return C->Name == S.Name; });
if (std::any_of(It, PH.Chunks.end(), [... | testq %rsi, %rsi
je 0x39f43
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq (%rsi,%rsi,4), %rax
shlq $0x5, %rax
addq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rdx), %r14
movq 0x18(%rdx), %r15
movq 0x88(%rdi), %rbp
movq %rdi, 0x20(%rsp)
movq 0x90(%rdi), %r12
movq %r12, %rax
subq... | /ObjectYAML/ELFEmitter.cpp |
llvm::yaml::yaml2elf(llvm::ELFYAML::Object&, llvm::raw_ostream&, llvm::function_ref<void (llvm::Twine const&)>, unsigned long) | bool yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH,
uint64_t MaxSize) {
bool IsLE = Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
bool Is64Bit = Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
if (Is64Bit) {
if (IsLE)
return ELFState<object... | movq %rsi, %rax
movq %rdi, %rsi
movb 0x1(%rdi), %dil
cmpb $0x2, (%rsi)
jne 0x39f74
cmpb $0x1, %dil
jne 0x39f82
movq %rax, %rdi
jmp 0x39f92
cmpb $0x1, %dil
jne 0x39f8a
movq %rax, %rdi
jmp 0x4184a
movq %rax, %rdi
jmp 0x3db74
movq %rax, %rdi
jmp 0x4547a
| /ObjectYAML/ELFEmitter.cpp |
llvm::SetVector<llvm::StringRef, llvm::SmallVector<llvm::StringRef, 8u>, llvm::DenseSet<llvm::StringRef, llvm::DenseMapInfo<llvm::StringRef, void>>, 8u>::insert(llvm::StringRef const&) | bool insert(const value_type &X) {
if constexpr (canBeSmall())
if (isSmall()) {
if (!llvm::is_contained(vector_, X)) {
vector_.push_back(X);
if (vector_.size() > N)
makeBig();
return true;
}
return false;
}
bool result = set_.insert(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x49213
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4994a
cmpb $0x1, 0x10(%r15)
jne 0x49239
addq $0x18, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
... | /llvm/ADT/SetVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>, llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>::moveFromOldBucke... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x49c8b
movq (%r15), %rcx
shlq $0x4, %rax
addq %rcx, %rax
movq $-0x1, (%rcx)
movq $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jne 0x49c73
cmpq %rbx, ... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::ContiguousBlobAccumulator::writeSLEB128(long) | unsigned writeSLEB128(int64_t Val) {
if (!checkLimit(10))
return 0;
return encodeSLEB128(Val, OS);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0xa, %esi
callq 0x4c6c4
testb %al, %al
je 0x4d4ad
leaq 0xa8(%rbx), %r15
movq %r14, %r12
sarq $0x7, %r12
xorl %ebp, %ebp
movl $0x0, %eax
cmpq $0x40, %r14
jb 0x4d472
cmpq $-0x1, %r12
setne %al
testb $0x40, %r14b
sete %bpl
orb %al... | /ObjectYAML/ELFEmitter.cpp |
llvm::Error llvm::handleErrors<llvm::consumeError(llvm::Error)::'lambda'(llvm::ErrorInfoBase const&)>(llvm::Error, llvm::consumeError(llvm::Error)::'lambda'(llvm::ErrorInfoBase const&)&&) | Error handleErrors(Error E, HandlerTs &&... Hs) {
if (!E)
return Error::success();
std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
if (Payload->isA<ErrorList>()) {
ErrorList &List = static_cast<ErrorList &>(*Payload);
Error R;
for (auto &P : List.Payloads)
R = ErrorList::join(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x4d997
movq $0x0, (%rsi)
movq (%r14), %rax
leaq 0x1feb53(%rip), %rsi # 0x24c421
movq %r14, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x4d9a0
movq %rbx, 0x20(%rsp)
movq 0x8(%r14), %... | /llvm/Support/Error.h |
(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)0, true>>::assignSectionAddress(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, true>>&, llvm::ELFYAML::Section*) | void ELFState<ELFT>::assignSectionAddress(Elf_Shdr &SHeader,
ELFYAML::Section *YAMLSec) {
if (YAMLSec && YAMLSec->Address) {
SHeader.sh_addr = *YAMLSec->Address;
LocationCounter = *YAMLSec->Address;
return;
}
// sh_addr represents the address in the memory im... | testq %rdx, %rdx
je 0x4e028
cmpb $0x1, 0x50(%rdx)
jne 0x4e028
movq 0x48(%rdx), %rax
bswapq %rax
movq %rax, 0x10(%rsi)
movq 0x48(%rdx), %rax
movq %rax, 0xf8(%rdi)
retq
movq 0xd8(%rdi), %rax
cmpw $0x1, 0x4(%rax)
je 0x4e03c
testb $0x2, 0xf(%rsi)
jne 0x4e03d
retq
movq 0xf8(%rdi), %rax
movq 0x30(%rsi), %rcx
xorl %r8d, %r8d
... | /ObjectYAML/ELFEmitter.cpp |
(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)1, false>>::writeSectionContent(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, false>>&, llvm::ELFYAML::VerneedSection const&, (anonymous namespace)::ContiguousBlobAccumulator&) | void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
const ELFYAML::VerneedSection &Section,
ContiguousBlobAccumulator &CBA) {
if (Section.Info)
SHeader.sh_info = *Section.Info;
else if (Section.VerneedV)
SHeader.sh_inf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x140(%rdx)
jne 0x50a0f
movq 0x138(%r14), %rax
jmp 0x50a39
cmpb $0x1, 0x130(%r14)
jne 0x50a3c
movq 0x120(%r14), %rcx
subq 0x118(%r14), %rcx
sarq $0x4, %rcx
movabsq $-0... | /ObjectYAML/ELFEmitter.cpp |
(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)1, false>>::initSymtabSectionHeader(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, false>>&, (anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)1, false>>::SymtabType, (anonymous namespace)::ContiguousBl... | void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
SymtabType STType,
ContiguousBlobAccumulator &CBA,
ELFYAML::Section *YAMLSec) {
bool IsStatic = STType == SymtabType::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r12
movq %rcx, 0x20(%rsp)
movl %edx, %r8d
movq 0xd8(%rdi), %rax
xorl %r14d, %r14d
testl %edx, %edx
je 0x51fd9
cmpb $0x1, 0xd8(%rax)
movl $0x0, %r15d
jne 0x5200f
movl $0xc8, %ecx
movl $0xc0, %edx
jmp 0x51ff2
cmpb $0x0, 0xb8(%ra... | /ObjectYAML/ELFEmitter.cpp |
(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)0, false>>::writeSectionContent(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, false>>&, llvm::ELFYAML::HashSection const&, (anonymous namespace)::ContiguousBlobAccumulator&) | void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
const ELFYAML::HashSection &Section,
ContiguousBlobAccumulator &CBA) {
if (!Section.Bucket)
return;
CBA.write<uint32_t>(
Section.NBucket.value_or(llvm::yaml::Hex64... | cmpb $0x1, 0x130(%rsi)
jne 0x537a4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x160(%rsi)
je 0x536c7
movl 0x158(%r14), %esi
jmp 0x536d9
movq 0x120(%r14), %rsi
subq 0x118(%r14), %rsi
shrq $0x2, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x4d250
cmpb ... | /ObjectYAML/ELFEmitter.cpp |
(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)0, false>>::writeSectionContent(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, false>>&, llvm::ELFYAML::LinkerOptionsSection const&, (anonymous namespace)::ContiguousBlobAccumulator&) | void ELFState<ELFT>::writeSectionContent(
Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
ContiguousBlobAccumulator &CBA) {
if (!Section.Options)
return;
for (const ELFYAML::LinkerOption &LO : *Section.Options) {
CBA.write(LO.Key.data(), LO.Key.size());
CBA.write('\0');
CBA... | cmpb $0x1, 0x130(%rsi)
jne 0x53917
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x118(%rsi), %rbp
movq 0x120(%rsi), %rax
movq %rax, (%rsp)
cmpq %rax, %rbp
je 0x53909
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xa8(%rdx), %r15
movq (%rbp), %r12
movq 0x8(%rbp), %r13
movq %rbx, %rdi
movq %r1... | /ObjectYAML/ELFEmitter.cpp |
(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)0, false>>::writeSectionContent(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, false>>&, llvm::ELFYAML::GnuHashSection const&, (anonymous namespace)::ContiguousBlobAccumulator&) | void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
const ELFYAML::GnuHashSection &Section,
ContiguousBlobAccumulator &CBA) {
if (!Section.HashBuckets)
return;
if (!Section.Header)
return;
// We write the header fi... | cmpb $0x1, 0x170(%rsi)
jne 0x53c01
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
cmpb $0x1, 0x130(%rsi)
jne 0x53bf8
movq %rdx, %r15
movq %rdi, %rbx
cmpb $0x1, 0x11c(%r14)
jne 0x53ac7
movl 0x118(%r14), %esi
jmp 0x53ad9
movq 0x160(%r14), %rsi
subq 0x158(%r14), %rsi
shrq $0x2, %rsi
movq %r15, %rdi... | /ObjectYAML/ELFEmitter.cpp |
(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)0, false>>::initSymtabSectionHeader(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)0, false>>&, (anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)0, false>>::SymtabType, (anonymous namespace)::ContiguousBl... | void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
SymtabType STType,
ContiguousBlobAccumulator &CBA,
ELFYAML::Section *YAMLSec) {
bool IsStatic = STType == SymtabType::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r12
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, 0x18(%rsp)
movq 0xd8(%rdi), %rax
xorl %r14d, %r14d
testl %edx, %edx
je 0x54711
cmpb $0x1, 0xd8(%rax)
movl $0x0, %r15d
jne 0x54747
movl $0xc8, %esi
movl $0xc0, %edx
jmp 0x5472a
cmp... | /ObjectYAML/ELFEmitter.cpp |
void llvm::yaml::IO::enumFallback<llvm::yaml::Hex16, llvm::ELFYAML::ELF_EM>(llvm::ELFYAML::ELF_EM&) | void enumFallback(T &Val) {
if (matchEnumFallback()) {
EmptyContext Context;
// FIXME: Force integral conversion to allow strong typedefs to convert.
FBT Res = static_cast<typename FBT::BaseType>(Val);
yamlize(*this, Res, true, Context);
Val = static_cast<T>(static_cast<typename FBT::B... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0xb0(%rax)
testb %al, %al
je 0x587c9
movzwl (%rbx), %eax
leaq 0xe(%rsp), %r15
movw %ax, (%r15)
leaq 0xd(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x7847f
movzwl (%r15), %eax
movl %eax, (%rb... | /llvm/Support/YAMLTraits.h |
llvm::yaml::ScalarBitSetTraits<llvm::ELFYAML::ELF_SHF, void>::bitset(llvm::yaml::IO&, llvm::ELFYAML::ELF_SHF&) | void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
ELFYAML::ELF_SHF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
BCase(SHF_WRITE);
BCase(SHF_ALLOC);
BCase(SHF_EXCLUDE);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1157c2
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rcx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0xf95ad(%rip), %rsi # 0x155bbd
movq %r14, %rdi
callq *0xc8(%rax)
testb %al... | /ObjectYAML/ELFYAML.cpp |
llvm::yaml::MappingTraits<llvm::ELFYAML::BBAddrMapEntry::BBEntry>::mapping(llvm::yaml::IO&, llvm::ELFYAML::BBAddrMapEntry::BBEntry&) | void MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry>::mapping(
IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &E) {
assert(IO.getContext() && "The IO context is not initialized");
IO.mapOptional("ID", E.ID);
IO.mapRequired("AddressOffset", E.AddressOffset);
IO.mapRequired("Size", E.Size);
IO.mapRequired("Metada... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xfa94b(%rip), %rsi # 0x17134c
leaq 0x4(%rsp), %r8
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x35a6c
leaq 0x8(%rbx), %rdx
leaq 0xe6463(%rip), %rsi # 0x15ce7e
leaq 0x5(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x84944
leaq 0x10(%rbx), %rdx
... | /ObjectYAML/ELFYAML.cpp |
llvm::ELFYAML::DynamicSection::~DynamicSection() | DynamicSection() : Section(ChunkKind::Dynamic) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1bc30b(%rip), %rax # 0x235618
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x1, 0x130(%rdi)
jne 0x7933f
movb $0x0, 0x130(%rbx)
movq 0x118(%rbx), %rdi
testq %rdi, %rdi
je 0x7933f
movq 0x128(%rbx), %rsi
subq %rdi, %rsi
callq 0x260c0
movl $0x138, %esi # imm = 0x138
movq %rbx, %r... | /llvm/ObjectYAML/ELFYAML.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::ELFYAML::SectionOrType, std::allocator<llvm::ELFYAML::SectionOrType>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::ELFYAML::SectionOrType, std::allocator<llvm::ELFYAML::SectionOrType>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::ELFYAML... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x4, %rcx
testb %al, %al
cmovel %ebp, %ecx
testl %ecx, %... | /llvm/Support/YAMLTraits.h |
llvm::ELFYAML::SymverSection::getEntries() const | std::vector<std::pair<StringRef, bool>> getEntries() const override {
return {{"Entries", Entries.has_value()}};
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x130(%rsi), %bpl
movl $0x18, %edi
callq 0x26100
movq %rax, (%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq 0xdfda5(%rip), %rdx # 0x15cea0
movq %rdx, (%rax)
movq $0x7, 0x8(%rax)
movb %bpl, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
p... | /llvm/ObjectYAML/ELFYAML.h |
void llvm::yaml::IO::processKeyWithDefault<std::vector<unsigned short, std::allocator<unsigned short>>, llvm::yaml::EmptyContext>(char const*, std::optional<std::vector<unsigned short, std::allocator<unsigned short>>>&, std::optional<std::vector<unsigned short, std::allocator<unsigned short>>> const&, bool, llvm::yaml:... | void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
const std::optional<T> &DefaultValue,
bool Required, Context &Ctx) {
assert(!DefaultValue && "std::optional<T> shouldn't have a value!");
void *SaveInfo;
bool UseDefault = true;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movb $0x1, 0xf(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r12d
movb 0x18(%r14), %r13b
movq (%rbx), %rax
movq %rbx, %rdi... | /llvm/Support/YAMLTraits.h |
llvm::ELFYAML::SymtabShndxSection::~SymtabShndxSection() | SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1b7479(%rip), %rax # 0x2357d0
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x1, 0x130(%rdi)
jne 0x7e389
movb $0x0, 0x130(%rbx)
movq 0x118(%rbx), %rdi
testq %rdi, %rdi
je 0x7e389
movq 0x128(%rbx), %rsi
subq %rdi, %rsi
callq 0x260c0
movl $0x138, %esi # imm = 0x138
movq %rbx, %r... | /llvm/ObjectYAML/ELFYAML.h |
llvm::ELFYAML::LinkerOptionsSection::getEntries() const | std::vector<std::pair<StringRef, bool>> getEntries() const override {
return {{"Options", Options.has_value()}};
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x130(%rsi), %bpl
movl $0x18, %edi
callq 0x26100
movq %rax, (%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq 0xe9147(%rip), %rdx # 0x167e2a
movq %rdx, (%rax)
movq $0x7, 0x8(%rax)
movb %bpl, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
p... | /llvm/ObjectYAML/ELFYAML.h |
llvm::ELFYAML::BBAddrMapSection::getEntries() const | std::vector<std::pair<StringRef, bool>> getEntries() const override {
return {{"Entries", Entries.has_value()}};
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x130(%rsi), %bpl
movl $0x18, %edi
callq 0x26100
movq %rax, (%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq 0xdd23f(%rip), %rdx # 0x15cea0
movq %rdx, (%rax)
movq $0x7, 0x8(%rax)
movb %bpl, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
p... | /llvm/ObjectYAML/ELFYAML.h |
void llvm::yaml::IO::processKeyWithDefault<std::vector<llvm::ELFYAML::BBAddrMapEntry, std::allocator<llvm::ELFYAML::BBAddrMapEntry>>, llvm::yaml::EmptyContext>(char const*, std::optional<std::vector<llvm::ELFYAML::BBAddrMapEntry, std::allocator<llvm::ELFYAML::BBAddrMapEntry>>>&, std::optional<std::vector<llvm::ELFYAML:... | void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
const std::optional<T> &DefaultValue,
bool Required, Context &Ctx) {
assert(!DefaultValue && "std::optional<T> shouldn't have a value!");
void *SaveInfo;
bool UseDefault = true;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movb $0x1, 0xf(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r12d
movb 0x18(%r14), %r13b
movq (%rbx), %rax
movq %rbx, %rdi... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::ELFYAML::PGOAnalysisMapEntry, std::allocator<llvm::ELFYAML::PGOAnalysisMapEntry>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::ELFYAML::PGOAnalysisMapEntry, std::allocator<llvm::ELFYAML::PGOAnalysisMapEntry>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, s... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x80f94
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x4, %rax
imull $0xaaaaaaab, %eax, %... | /llvm/Support/YAMLTraits.h |
llvm::ELFYAML::RawContentSection::~RawContentSection() | RawContentSection() : Section(ChunkKind::RawContent) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1b0e2f(%rip), %rax # 0x2358e8
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x1, 0x140(%rdi)
jne 0x84aeb
movb $0x0, 0x140(%rbx)
movq 0x128(%rbx), %rdi
testq %rdi, %rdi
je 0x84aeb
movq 0x138(%rbx), %rsi
subq %rdi, %rsi
callq 0x260c0
movl $0x148, %esi # imm = 0x148
movq %rbx, %r... | /llvm/ObjectYAML/ELFYAML.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::ELFYAML::BBAddrMapEntry::BBRangeEntry, std::allocator<llvm::ELFYAML::BBAddrMapEntry::BBRangeEntry>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::ELFYAML::BBAddrMapEntry::BBRangeEntry, std::allocator<llvm::ELFYAML::BBAddrMapEntry::BBRangeEntry>>, llvm::ya... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x85014
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xb6db6db7, %eax, %... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<std::unique_ptr<llvm::ELFYAML::Chunk, std::default_delete<llvm::ELFYAML::Chunk>>, std::allocator<std::unique_ptr<llvm::ELFYAML::Chunk, std::default_delete<llvm::ELFYAML::Chunk>>>>>::value, void>::type llvm::yaml::yamlize<std::vector<std::unique_ptr<llvm::ELFYAML::Chunk, std... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%r15), %rcx
subq (%r15), %rcx
shrq $0x3, %rcx
testb %al, %al
cmovel %ebp, %ecx
tes... | /llvm/Support/YAMLTraits.h |
std::pair<llvm::StringRef, llvm::StringRef> const* llvm::SmallVectorTemplateCommon<std::pair<llvm::StringRef, llvm::StringRef>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<std::pair<llvm::StringRef, llvm::StringRef>, true>>(llvm::SmallVectorTemplateBase<std::pair<llvm::StringRef, llvm::StringR... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
addq %rax, %rdx
cmpq %rcx, %rdx
ja 0x994a6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
movq (%rdi), %rcx
shlq $0x5, %rax
addq %rcx, %rax
cmpq %rbx, %rcx
setbe %sil
cmpq %rbx, %rax
seta %al
testb %al, ... | /llvm/ADT/SmallVector.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::OffloadYAML::Binary::StringEntry, std::allocator<llvm::OffloadYAML::Binary::StringEntry>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::OffloadYAML::Binary::StringEntry, std::allocator<llvm::OffloadYAML::Binary::StringEntry>>, llvm::yaml::EmptyContext>(ll... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x5, %rcx
testb %al, %al
cmovel %ebp, %ecx
testl %ecx, %ecx
je... | /llvm/Support/YAMLTraits.h |
writeStringRef(llvm::StringRef const&, llvm::raw_ostream&) | static int writeStringRef(const StringRef &Str, raw_ostream &OS) {
encodeULEB128(Str.size(), OS);
OS << Str;
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movl %r15d, %eax
orb $-0x80, %al
cmpq $0x7f, %r15
movzbl %al, %eax
cmovbel %r15d, %eax
movq 0x20(%rbx), %rcx
cmpq 0x18(%rbx), %rcx
jae 0x9d476
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rbx)
movb %al, (%rcx)
jmp 0x9d481
movzbl %al, %esi
mo... | /ObjectYAML/WasmEmitter.cpp |
llvm::yaml::sectionMapping(llvm::yaml::IO&, llvm::WasmYAML::LinkingSection&) | static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
commonSectionMapping(IO, Section);
IO.mapRequired("Name", Section.Name);
IO.mapRequired("Version", Section.Version);
IO.mapOptional("SymbolTable", Section.SymbolTable);
IO.mapOptional("SegmentInfo", Section.SegmentInfos);
IO.mapOptional... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa082b
leaq 0x30(%rbx), %rdx
leaq 0xbf6b2(%rip), %rsi # 0x15dc4f
leaq 0x2(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x393b0
leaq 0x58(%rbx), %rdx
leaq 0xbf818(%rip), %rsi # 0x15ddd2
leaq 0x3(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx... | /ObjectYAML/WasmYAML.cpp |
llvm::yaml::ScalarEnumerationTraits<llvm::XCOFF::SymbolType, void>::enumeration(llvm::yaml::IO&, llvm::XCOFF::SymbolType&) | void ScalarEnumerationTraits<XCOFF::SymbolType>::enumeration(
IO &IO, XCOFF::SymbolType &Value) {
#define ECase(X) IO.enumCase(Value, #X, XCOFF::X)
ECase(XTY_ER);
ECase(XTY_SD);
ECase(XTY_LD);
ECase(XTY_CM);
#undef ECase
IO.enumFallback<Hex8>(Value);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
cmpb $0x0, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0xb2e17(%rip), %rsi # 0x15f154
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xac34d
movb $0x0, (%rbx)
movq (%r14), %rax
movq %r... | /ObjectYAML/XCOFFYAML.cpp |
std::enable_if<has_ScalarBitSetTraits<llvm::XCOFF::SectionTypeFlags>::value, void>::type llvm::yaml::yamlize<llvm::XCOFF::SectionTypeFlags>(llvm::yaml::IO&, llvm::XCOFF::SectionTypeFlags&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_ScalarBitSetTraits<T>::value, void>
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
bool DoClear;
if ( io.beginBitSetScalar(DoClear) ) {
if ( DoClear )
Val = T();
ScalarBitSetTraits<T>::bitset(io, Val);
io.endBitSetScalar();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x7(%rsp), %rsi
callq *0xc0(%rax)
testb %al, %al
je 0xadf76
cmpb $0x1, 0x7(%rsp)
jne 0xadf5f
movl $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab110
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xd0(%rax)
addq $0x8, %rsp
popq %r... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_ScalarTraits<llvm::CodeViewYAML::HexFormattedString>::value, void>::type llvm::yaml::yamlize<llvm::CodeViewYAML::HexFormattedString>(llvm::yaml::IO&, llvm::CodeViewYAML::HexFormattedString&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_ScalarTraits<T>::value, void> yamlize(IO &io, T &Val, bool,
EmptyContext &Ctx) {
if ( io.outputting() ) {
SmallString<128> Storage;
raw_svector_ostream Buffer(Storage);
ScalarTraits<T>::output(Val, io.getContext(), Buffer);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0xb29f2
leaq 0x60(%rsp), %r12
movq %r12, -0x18(%r12)
xorl %eax, %eax
movq %rax, -0x10(%r12)
movq $0x80, -0x8(%r12)
leaq 0x10(%rsp), %r15
movl $0x2, 0x8(%r15)
movb... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::CodeViewYAML::YAMLCrossModuleImport, std::allocator<llvm::CodeViewYAML::YAMLCrossModuleImport>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::CodeViewYAML::YAMLCrossModuleImport, std::allocator<llvm::CodeViewYAML::YAMLCrossModuleImport>>, llvm::yaml::Empt... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xb4606
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %... | /llvm/Support/YAMLTraits.h |
llvm::yaml::ScalarBitSetTraits<llvm::codeview::CompileSym3Flags, void>::bitset(llvm::yaml::IO&, llvm::codeview::CompileSym3Flags&) | void ScalarBitSetTraits<CompileSym3Flags>::bitset(IO &io,
CompileSym3Flags &Flags) {
auto FlagNames = getCompileSym3FlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<CompileSym3Flags>(E.Value)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13324e
testq %rdx, %rdx
je 0xb5ca4
movq %rax, %r15
leaq (%rdx,%rdx,4), %rax
leaq (%r15,%rax,8), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %r13
addq $0x8, %r15
movq -0x8(%r15), %rsi
testq %rsi, %r... | /ObjectYAML/CodeViewYAMLSymbols.cpp |
llvm::yaml::ScalarEnumerationTraits<llvm::codeview::RegisterId, void>::enumeration(llvm::yaml::IO&, llvm::codeview::RegisterId&) | void ScalarEnumerationTraits<RegisterId>::enumeration(IO &io, RegisterId &Reg) {
const auto *Header = static_cast<COFF::header *>(io.getContext());
assert(Header && "The IO context is not initialized");
std::optional<CPUType> CpuType;
ArrayRef<EnumEntry<uint16_t>> RegNames;
switch (Header->Machine) {
case... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
callq 0x1157c2
movzwl (%rax), %eax
cmpl $0xa640, %eax # imm = 0xA640
jg 0xb624a
cmpl $0x14c, %eax # imm = 0x14C
je 0xb6269
cmpl $0x1c4, %eax # imm = 0x1C4
je 0xb626f
cm... | /ObjectYAML/CodeViewYAMLSymbols.cpp |
llvm::yaml::ScalarEnumerationTraits<llvm::codeview::JumpTableEntrySize, void>::enumeration(llvm::yaml::IO&, llvm::codeview::JumpTableEntrySize&) | void ScalarEnumerationTraits<JumpTableEntrySize>::enumeration(
IO &io, JumpTableEntrySize &FC) {
auto ThunkNames = getJumpTableEntrySizeNames();
for (const auto &E : ThunkNames) {
io.enumCase(FC, E.Name.str().c_str(),
static_cast<JumpTableEntrySize>(E.Value));
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13332b
testq %rdx, %rdx
je 0xb6715
movq %rax, %r15
leaq (%rdx,%rdx,4), %rax
leaq (%r15,%rax,8), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %r13
addq $0x8, %r15
movq -0x8(%r15), %rsi
testq %rsi, %r... | /ObjectYAML/CodeViewYAMLSymbols.cpp |
llvm::CodeViewYAML::detail::SymbolRecordImpl<llvm::codeview::DefRangeSubfieldSym>::map(llvm::yaml::IO&) | void SymbolRecordImpl<DefRangeSubfieldSym>::map(IO &IO) {
IO.mapRequired("Program", Symbol.Program);
IO.mapRequired("OffsetInParent", Symbol.OffsetInParent);
IO.mapRequired("Range", Symbol.Range);
IO.mapRequired("Gaps", Symbol.Gaps);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14(%rdi), %rdx
leaq 0x9b7be(%rip), %rsi # 0x152839
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x35a6c
leaq 0x18(%rbx), %rdx
leaq 0xa8b49(%rip), %rsi # 0x15fbe1
leaq 0x5(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x35254... | /ObjectYAML/CodeViewYAMLSymbols.cpp |
llvm::CodeViewYAML::detail::SymbolRecordImpl<llvm::codeview::DefRangeFramePointerRelSym>::map(llvm::yaml::IO&) | void SymbolRecordImpl<DefRangeFramePointerRelSym>::map(IO &IO) {
IO.mapRequired("Offset", Symbol.Hdr.Offset);
IO.mapRequired("Range", Symbol.Range);
IO.mapRequired("Gaps", Symbol.Gaps);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x12(%rdi), %rdx
leaq 0xa87c5(%rip), %rsi # 0x15f954
leaq 0x5(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0xbab2a
leaq 0x18(%rbx), %rdx
leaq 0xa6ad4(%rip), %rsi # 0x15dc80
leaq 0x6(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0xba71c... | /ObjectYAML/CodeViewYAMLSymbols.cpp |
llvm::CodeViewYAML::detail::SymbolRecordImpl<llvm::codeview::RegRelativeSym>::map(llvm::yaml::IO&) | void SymbolRecordImpl<RegRelativeSym>::map(IO &IO) {
IO.mapRequired("Offset", Symbol.Offset);
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Register", Symbol.Register);
IO.mapRequired("VarName", Symbol.Name);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14(%rdi), %rdx
leaq 0xa7d9d(%rip), %rsi # 0x15f954
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x35a6c
leaq 0x18(%rbx), %rdx
leaq 0xa6010(%rip), %rsi # 0x15dbe4
leaq 0x5(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0xba2a2... | /ObjectYAML/CodeViewYAMLSymbols.cpp |
void mapSymbolRecordImpl<llvm::CodeViewYAML::detail::SymbolRecordImpl<llvm::codeview::CoffGroupSym>>(llvm::yaml::IO&, char const*, llvm::codeview::SymbolKind, llvm::CodeViewYAML::SymbolRecord&) | static void mapSymbolRecordImpl(IO &IO, const char *Class, SymbolKind Kind,
CodeViewYAML::SymbolRecord &Obj) {
if (!IO.outputting())
Obj.Symbol = std::make_shared<ConcreteType>(Kind);
IO.mapRequired(Class, *Obj.Symbol);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0xb8805
movl $0x50, %edi
callq 0x26100
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x17e13a(%rip), %rcx # 0x2368f0
addq $0x10, %rc... | /ObjectYAML/CodeViewYAMLSymbols.cpp |
void mapSymbolRecordImpl<llvm::CodeViewYAML::detail::SymbolRecordImpl<llvm::codeview::DefRangeSubfieldSym>>(llvm::yaml::IO&, char const*, llvm::codeview::SymbolKind, llvm::CodeViewYAML::SymbolRecord&) | static void mapSymbolRecordImpl(IO &IO, const char *Class, SymbolKind Kind,
CodeViewYAML::SymbolRecord &Obj) {
if (!IO.outputting())
Obj.Symbol = std::make_shared<ConcreteType>(Kind);
IO.mapRequired(Class, *Obj.Symbol);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0xb8ea0
movl $0x58, %edi
callq 0x26100
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x17df07(%rip), %rcx # 0x236d50
addq $0x10, %rc... | /ObjectYAML/CodeViewYAMLSymbols.cpp |
std::enable_if<has_ScalarBitSetTraits<llvm::codeview::ProcSymFlags>::value, void>::type llvm::yaml::yamlize<llvm::codeview::ProcSymFlags>(llvm::yaml::IO&, llvm::codeview::ProcSymFlags&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_ScalarBitSetTraits<T>::value, void>
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
bool DoClear;
if ( io.beginBitSetScalar(DoClear) ) {
if ( DoClear )
Val = T();
ScalarBitSetTraits<T>::bitset(io, Val);
io.endBitSetScalar();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x7(%rsp), %rsi
callq *0xc0(%rax)
testb %al, %al
je 0xba569
cmpb $0x1, 0x7(%rsp)
jne 0xba552
movb $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb5f62
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xd0(%rax)
addq $0x8, %rsp
popq %r... | /llvm/Support/YAMLTraits.h |
void llvm::yaml::IO::processKey<llvm::codeview::LocalVariableAddrRange, llvm::yaml::EmptyContext>(char const*, llvm::codeview::LocalVariableAddrRange&, bool, llvm::yaml::EmptyContext&) | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
yamlize(*this, Val, Required, Ctx);
this->postflightKey(SaveInfo);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xf(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x78(%rax)
testb %al, %al
je 0xba76f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xba778
movq (%rbx), %ra... | /llvm/Support/YAMLTraits.h |
llvm::Error llvm::codeview::SymbolDeserializer::visitKnownRecordImpl<llvm::codeview::JumpTableSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::JumpTableSym&) | Error visitKnownRecordImpl(CVSymbol &CVR, T &Record) {
Record.RecordOffset =
Delegate ? Delegate->getRecordOffset(Mapping->Reader) : 0;
if (auto EC = Mapping->Mapping.visitKnownRecord(CVR, Record))
return EC;
return Error::success();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xbd47c
movq 0x18(%r12), %rax
leaq 0x178aad(%rip), %rbp # 0x235ef8
addq $0x10, %rbp
movq %rbp, 0x8(%rsp)
movq 0x28(%rax), %rcx
mo... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::Error llvm::codeview::SymbolDeserializer::visitKnownRecordImpl<llvm::codeview::UsingNamespaceSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::UsingNamespaceSym&) | Error visitKnownRecordImpl(CVSymbol &CVR, T &Record) {
Record.RecordOffset =
Delegate ? Delegate->getRecordOffset(Mapping->Reader) : 0;
if (auto EC = Mapping->Mapping.visitKnownRecord(CVR, Record))
return EC;
return Error::success();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xbdb1c
movq 0x18(%r12), %rax
leaq 0x17840d(%rip), %rbp # 0x235ef8
addq $0x10, %rbp
movq %rbp, 0x8(%rsp)
movq 0x28(%rax), %rcx
mo... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::codeview::CVRecord<llvm::codeview::SymbolKind> llvm::codeview::SymbolSerializer::writeOneSymbol<llvm::codeview::TrampolineSym>(llvm::codeview::TrampolineSym&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, llvm::codeview::CodeViewContainer) | static CVSymbol writeOneSymbol(SymType &Sym, BumpPtrAllocator &Storage,
CodeViewContainer Container) {
RecordPrefix Prefix{uint16_t(Sym.Kind)};
CVSymbol Result(&Prefix, sizeof(Prefix));
SymbolSerializer Serializer(Storage, Container);
consumeError(Serializer.visitSymbolB... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10038, %rsp # imm = 0x10038
movq %rdi, %rbx
movzwl (%rdi), %eax
leaq 0x44(%rsp), %rcx
movw $0x2, (%rcx)
movw %ax, 0x2(%rcx)
leaq 0x18(%rsp), %r14
movq %rcx, (%r14)
movq $0x4, 0x8(%r14)
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x138f92
leaq 0x38(%rsp), %r12... | /llvm/DebugInfo/CodeView/SymbolSerializer.h |
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.