output stringlengths 44 5.87k | instruction stringlengths 49 12.9k | input stringclasses 1
value |
|---|---|---|
它的源代码可能是：static int
mega_support_ext_cdb(adapter_t *adapter)
{
unsigned char raw_mbox[sizeof(struct mbox_out)];
mbox_t *mbox;
int rval;
mbox = (mbox_t *)raw_mbox;
memset(&mbox->m_out, 0, sizeof(raw_mbox));
/*
* issue command to find out if controller supports extended CDBs.
*/
raw_mbox[0] = 0xA4;
raw_mbox[2] = 0x16;
rval = issue_scb_block(adapter, raw_mbox);
return !rval;
} | 这是一段反汇编代码，它的源代码是什么？<mega_support_ext_cdb>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
lea -0x10(%rbp),%rax
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
mov $0x4,%edx
mov $0x0,%esi
mov %rax,%rdi
callq 2a <mega_support_ext_cdb+0x2a>
movb $0xa4,-0x10(%rbp)
movb $0x16,-0xe(%rbp)
lea -0x10(%rbp),%rdx
mov -0x18(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 45 <mega_support_ext_cdb+0x45>
mov %eax,-0xc(%rbp)
cmpl $0x0,-0xc(%rbp)
sete %al
movzbl %al,%eax
leaveq
retq
| |
它的源代码可能是：static int
mega_support_ext_cdb(adapter_t *adapter)
{
unsigned char raw_mbox[sizeof(struct mbox_out)];
mbox_t *mbox;
int rval;
mbox = (mbox_t *)raw_mbox;
memset(&mbox->m_out, 0, sizeof(raw_mbox));
/*
* issue command to find out if controller supports extended CDBs.
*/
raw_mbox[0] = 0xA4;
raw_mbox[2] = 0x16;
rval = issue_scb_block(adapter, raw_mbox);
return !rval;
} | 这是一段反汇编代码，它的源代码是什么？<mega_support_ext_cdb>:
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
mov $0x4,%edx
mov $0x0,%esi
lea 0xc(%rsp),%rdi
callq 1c <mega_support_ext_cdb+0x1c>
movb $0xa4,0xc(%rsp)
movb $0x16,0xe(%rsp)
lea 0xc(%rsp),%rsi
mov %rbx,%rdi
callq 33 <mega_support_ext_cdb+0x33>
test %eax,%eax
sete %al
movzbl %al,%eax
add $0x10,%rsp
pop %rbx
retq
| |
它的源代码可能是：static int
mega_support_ext_cdb(adapter_t *adapter)
{
unsigned char raw_mbox[sizeof(struct mbox_out)];
mbox_t *mbox;
int rval;
mbox = (mbox_t *)raw_mbox;
memset(&mbox->m_out, 0, sizeof(raw_mbox));
/*
* issue command to find out if controller supports extended CDBs.
*/
raw_mbox[0] = 0xA4;
raw_mbox[2] = 0x16;
rval = issue_scb_block(adapter, raw_mbox);
return !rval;
} | 这是一段反汇编代码，它的源代码是什么？<mega_support_ext_cdb>:
push %rbx
xor %esi,%esi
mov %rdi,%rbx
mov $0x4,%edx
sub $0x10,%rsp
lea 0xc(%rsp),%rdi
callq 19 <mega_support_ext_cdb+0x19>
lea 0xc(%rsp),%rsi
mov %rbx,%rdi
movb $0xa4,0xc(%rsp)
movb $0x16,0xe(%rsp)
callq 30 <mega_support_ext_cdb+0x30>
test %eax,%eax
sete %al
add $0x10,%rsp
movzbl %al,%eax
pop %rbx
retq
| |
它的源代码可能是：static int
mega_support_ext_cdb(adapter_t *adapter)
{
unsigned char raw_mbox[sizeof(struct mbox_out)];
mbox_t *mbox;
int rval;
mbox = (mbox_t *)raw_mbox;
memset(&mbox->m_out, 0, sizeof(raw_mbox));
/*
* issue command to find out if controller supports extended CDBs.
*/
raw_mbox[0] = 0xA4;
raw_mbox[2] = 0x16;
rval = issue_scb_block(adapter, raw_mbox);
return !rval;
} | 这是一段反汇编代码，它的源代码是什么？<mega_support_ext_cdb>:
push %rbx
xor %esi,%esi
mov %rdi,%rbx
mov $0x4,%edx
sub $0x10,%rsp
lea 0xc(%rsp),%rdi
callq 19 <mega_support_ext_cdb+0x19>
lea 0xc(%rsp),%rsi
mov %rbx,%rdi
movb $0xa4,0xc(%rsp)
movb $0x16,0xe(%rsp)
callq 30 <mega_support_ext_cdb+0x30>
test %eax,%eax
sete %al
add $0x10,%rsp
movzbl %al,%eax
pop %rbx
retq
| |
它的源代码可能是：void buf_append(Buffer *b, char *s, int len) {
for (int i = 0; i < len; i++)
buf_write(b, s[i]);
} | 这是一段反汇编代码，它的源代码是什么？<buf_append>:
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movl $0x0,-0x4(%rbp)
jmp 41 <buf_append+0x41>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 3d <buf_append+0x3d>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 1c <buf_append+0x1c>
nop
leaveq
retq
| |
它的源代码可能是：void buf_append(Buffer *b, char *s, int len) {
for (int i = 0; i < len; i++)
buf_write(b, s[i]);
} | 这是一段反汇编代码，它的源代码是什么？<buf_append>:
test %edx,%edx
jle 2f <buf_append+0x2f>
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%rbx
lea -0x1(%rdx),%eax
lea 0x1(%rsi,%rax,1),%r12
movsbl (%rbx),%esi
mov %rbp,%rdi
callq 21 <buf_append+0x21>
add $0x1,%rbx
cmp %r12,%rbx
jne 16 <buf_append+0x16>
pop %rbx
pop %rbp
pop %r12
retq
retq
| |
它的源代码可能是：void buf_append(Buffer *b, char *s, int len) {
for (int i = 0; i < len; i++)
buf_write(b, s[i]);
} | 这是一段反汇编代码，它的源代码是什么？<buf_append>:
test %edx,%edx
jle 40 <buf_append+0x40>
lea -0x1(%rdx),%eax
push %r12
lea 0x1(%rsi,%rax,1),%r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
nopw %cs:0x0(%rax,%rax,1)
00 00 00
movsbl (%rbx),%esi
mov %rbp,%rdi
add $0x1,%rbx
callq 2f <buf_append+0x2f>
cmp %r12,%rbx
jne 20 <buf_append+0x20>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
retq
| |
它的源代码可能是：void buf_append(Buffer *b, char *s, int len) {
for (int i = 0; i < len; i++)
buf_write(b, s[i]);
} | 这是一段反汇编代码，它的源代码是什么？<buf_append>:
test %edx,%edx
jle 40 <buf_append+0x40>
lea -0x1(%rdx),%eax
push %r12
lea 0x1(%rsi,%rax,1),%r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
nopw %cs:0x0(%rax,%rax,1)
00 00 00
movsbl (%rbx),%esi
mov %rbp,%rdi
add $0x1,%rbx
callq 2f <buf_append+0x2f>
cmp %r12,%rbx
jne 20 <buf_append+0x20>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
retq
| |
它的源代码可能是：static __compar_fn_t getKeyComparator(int32_t keyType) {
__compar_fn_t comparator = NULL;
switch (keyType) {
case TSDB_DATA_TYPE_TINYINT:
case TSDB_DATA_TYPE_SMALLINT:
case TSDB_DATA_TYPE_INT:
case TSDB_DATA_TYPE_BIGINT:
case TSDB_DATA_TYPE_BOOL:
comparator = compareIntVal;
break;
case TSDB_DATA_TYPE_FLOAT:
case TSDB_DATA_TYPE_DOUBLE:
comparator = compareDoubleVal;
break;
case TSDB_DATA_TYPE_BINARY:
comparator = compareStrVal;
break;
case TSDB_DATA_TYPE_NCHAR:
comparator = compareWStrVal;
break;
default:
comparator = compareIntVal;
break;
}
return comparator;
} | 这是一段反汇编代码，它的源代码是什么？<getKeyComparator>:
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movq $0x0,-0x8(%rbp)
00
mov -0x14(%rbp),%eax
add $0xffffff80,%eax
cmp $0x8,%eax
ja 5a <getKeyComparator+0x5a>
mov %eax,%eax
mov 0x0(,%rax,8),%rax
00
jmpq *%rax
mov 0x0(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 66 <getKeyComparator+0x66>
mov 0x0(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 66 <getKeyComparator+0x66>
mov 0x0(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 66 <getKeyComparator+0x66>
mov 0x0(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 66 <getKeyComparator+0x66>
mov 0x0(%rip),%rax
mov %rax,-0x8(%rbp)
nop
mov -0x8(%rbp),%rax
pop %rbp
retq
| |
它的源代码可能是：static __compar_fn_t getKeyComparator(int32_t keyType) {
__compar_fn_t comparator = NULL;
switch (keyType) {
case TSDB_DATA_TYPE_TINYINT:
case TSDB_DATA_TYPE_SMALLINT:
case TSDB_DATA_TYPE_INT:
case TSDB_DATA_TYPE_BIGINT:
case TSDB_DATA_TYPE_BOOL:
comparator = compareIntVal;
break;
case TSDB_DATA_TYPE_FLOAT:
case TSDB_DATA_TYPE_DOUBLE:
comparator = compareDoubleVal;
break;
case TSDB_DATA_TYPE_BINARY:
comparator = compareStrVal;
break;
case TSDB_DATA_TYPE_NCHAR:
comparator = compareWStrVal;
break;
default:
comparator = compareIntVal;
break;
}
return comparator;
} | 这是一段反汇编代码，它的源代码是什么？<getKeyComparator>:
add $0xffffff80,%edi
cmp $0x8,%edi
ja 31 <getKeyComparator+0x31>
mov %edi,%edi
jmpq *0x0(,%rdi,8)
mov 0x0(%rip),%rax
retq
mov 0x0(%rip),%rax
retq
mov 0x0(%rip),%rax
retq
mov 0x0(%rip),%rax
retq
mov 0x0(%rip),%rax
retq
| |
它的源代码可能是：static __compar_fn_t getKeyComparator(int32_t keyType) {
__compar_fn_t comparator = NULL;
switch (keyType) {
case TSDB_DATA_TYPE_TINYINT:
case TSDB_DATA_TYPE_SMALLINT:
case TSDB_DATA_TYPE_INT:
case TSDB_DATA_TYPE_BIGINT:
case TSDB_DATA_TYPE_BOOL:
comparator = compareIntVal;
break;
case TSDB_DATA_TYPE_FLOAT:
case TSDB_DATA_TYPE_DOUBLE:
comparator = compareDoubleVal;
break;
case TSDB_DATA_TYPE_BINARY:
comparator = compareStrVal;
break;
case TSDB_DATA_TYPE_NCHAR:
comparator = compareWStrVal;
break;
default:
comparator = compareIntVal;
break;
}
return comparator;
} | 这是一段反汇编代码，它的源代码是什么？<getKeyComparator>:
sub $0x82,%edi
cmp $0x5,%edi
ja 18 <getKeyComparator+0x18>
jmpq *0x0(,%rdi,8)
nopw 0x0(%rax,%rax,1)
mov 0x0(%rip),%rax
retq
mov 0x0(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
00
mov 0x0(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
00
mov 0x0(%rip),%rax
retq
| |
它的源代码可能是：static __compar_fn_t getKeyComparator(int32_t keyType) {
__compar_fn_t comparator = NULL;
switch (keyType) {
case TSDB_DATA_TYPE_TINYINT:
case TSDB_DATA_TYPE_SMALLINT:
case TSDB_DATA_TYPE_INT:
case TSDB_DATA_TYPE_BIGINT:
case TSDB_DATA_TYPE_BOOL:
comparator = compareIntVal;
break;
case TSDB_DATA_TYPE_FLOAT:
case TSDB_DATA_TYPE_DOUBLE:
comparator = compareDoubleVal;
break;
case TSDB_DATA_TYPE_BINARY:
comparator = compareStrVal;
break;
case TSDB_DATA_TYPE_NCHAR:
comparator = compareWStrVal;
break;
default:
comparator = compareIntVal;
break;
}
return comparator;
} | 这是一段反汇编代码，它的源代码是什么？<getKeyComparator>:
sub $0x82,%edi
cmp $0x5,%edi
ja 18 <getKeyComparator+0x18>
jmpq *0x0(,%rdi,8)
nopw 0x0(%rax,%rax,1)
mov 0x0(%rip),%rax
retq
mov 0x0(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
00
mov 0x0(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
00
mov 0x0(%rip),%rax
retq
| |
它的源代码可能是：static int luaB_loadfile (lua_State *L) {
const char *fname = luaL_optstring(L, 1, NULL);
return load_aux(L, luaL_loadfile(L, fname));
} | 这是一段反汇编代码，它的源代码是什么？<luaB_loadfile>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov $0x0,%edx
mov $0x1,%esi
mov %rax,%rdi
callq 22 <luaB_loadfile+0x22>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rdx
mov -0x18(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 39 <luaB_loadfile+0x39>
mov %eax,%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 49 <luaB_loadfile+0x49>
leaveq
retq
| |
它的源代码可能是：static int luaB_loadfile (lua_State *L) {
const char *fname = luaL_optstring(L, 1, NULL);
return load_aux(L, luaL_loadfile(L, fname));
} | 这是一段反汇编代码，它的源代码是什么？<luaB_loadfile>:
push %rbx
mov %rdi,%rbx
mov $0x0,%edx
mov $0x1,%esi
callq 13 <luaB_loadfile+0x13>
mov %rax,%rsi
mov %rbx,%rdi
callq 1e <luaB_loadfile+0x1e>
mov %eax,%esi
mov %rbx,%rdi
callq 28 <luaB_loadfile+0x28>
pop %rbx
retq
| |
它的源代码可能是：static int luaB_loadfile (lua_State *L) {
const char *fname = luaL_optstring(L, 1, NULL);
return load_aux(L, luaL_loadfile(L, fname));
} | 这是一段反汇编代码，它的源代码是什么？<luaB_loadfile>:
push %rbx
xor %edx,%edx
mov $0x1,%esi
mov %rdi,%rbx
callq 10 <luaB_loadfile+0x10>
mov %rbx,%rdi
mov %rax,%rsi
callq 1b <luaB_loadfile+0x1b>
mov %rbx,%rdi
pop %rbx
mov %eax,%esi
jmpq 26 <luaB_loadfile+0x26>
| |
它的源代码可能是：static int luaB_loadfile (lua_State *L) {
const char *fname = luaL_optstring(L, 1, NULL);
return load_aux(L, luaL_loadfile(L, fname));
} | 这是一段反汇编代码，它的源代码是什么？<luaB_loadfile>:
push %rbx
xor %edx,%edx
mov $0x1,%esi
mov %rdi,%rbx
callq 10 <luaB_loadfile+0x10>
mov %rbx,%rdi
mov %rax,%rsi
callq 1b <luaB_loadfile+0x1b>
mov %rbx,%rdi
pop %rbx
mov %eax,%esi
jmpq 26 <luaB_loadfile+0x26>
| |
它的源代码可能是：static void slic_debug_cleanup(void)
{
if (slic_debugfs) {
debugfs_remove(slic_debugfs);
slic_debugfs = NULL;
}
} | 这是一段反汇编代码，它的源代码是什么？<slic_debug_cleanup>:
push %rbp
mov %rsp,%rbp
mov 0x0(%rip),%rax
test %rax,%rax
je 2a <slic_debug_cleanup+0x2a>
mov 0x0(%rip),%rax
mov %rax,%rdi
callq 1f <slic_debug_cleanup+0x1f>
movq $0x0,0x0(%rip)
00 00 00 00
nop
pop %rbp
retq
| |
它的源代码可能是：static void slic_debug_cleanup(void)
{
if (slic_debugfs) {
debugfs_remove(slic_debugfs);
slic_debugfs = NULL;
}
} | 这是一段反汇编代码，它的源代码是什么？<slic_debug_cleanup>:
mov 0x0(%rip),%rdi
test %rdi,%rdi
je 25 <slic_debug_cleanup+0x25>
sub $0x8,%rsp
callq 15 <slic_debug_cleanup+0x15>
movq $0x0,0x0(%rip)
00 00 00 00
add $0x8,%rsp
retq
retq
| |
它的源代码可能是：static void slic_debug_cleanup(void)
{
if (slic_debugfs) {
debugfs_remove(slic_debugfs);
slic_debugfs = NULL;
}
} | 这是一段反汇编代码，它的源代码是什么？<slic_debug_cleanup>:
mov 0x0(%rip),%rdi
test %rdi,%rdi
je 28 <slic_debug_cleanup+0x28>
sub $0x8,%rsp
callq 15 <slic_debug_cleanup+0x15>
movq $0x0,0x0(%rip)
00 00 00 00
add $0x8,%rsp
retq
nopl (%rax)
retq
| |
它的源代码可能是：static void slic_debug_cleanup(void)
{
if (slic_debugfs) {
debugfs_remove(slic_debugfs);
slic_debugfs = NULL;
}
} | 这是一段反汇编代码，它的源代码是什么？<slic_debug_cleanup>:
mov 0x0(%rip),%rdi
test %rdi,%rdi
je 28 <slic_debug_cleanup+0x28>
sub $0x8,%rsp
callq 15 <slic_debug_cleanup+0x15>
movq $0x0,0x0(%rip)
00 00 00 00
add $0x8,%rsp
retq
nopl (%rax)
retq
| |
它的源代码可能是：static void tda8083_wait_diseqc_fifo (struct tda8083_state* state, int timeout)
{
unsigned long start = jiffies;
while (jiffies - start < timeout &&
!(tda8083_readreg(state, 0x02) & 0x80))
{
msleep(50);
};
} | 这是一段反汇编代码，它的源代码是什么？<tda8083_wait_diseqc_fifo>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov 0x0(%rip),%rax
mov %rax,-0x8(%rbp)
jmp 26 <tda8083_wait_diseqc_fifo+0x26>
mov $0x32,%edi
callq 26 <tda8083_wait_diseqc_fifo+0x26>
mov 0x0(%rip),%rax
sub -0x8(%rbp),%rax
mov %rax,%rdx
mov -0x1c(%rbp),%eax
cltq
cmp %rax,%rdx
jae 58 <tda8083_wait_diseqc_fifo+0x58>
mov -0x18(%rbp),%rax
mov $0x2,%esi
mov %rax,%rdi
callq 4f <tda8083_wait_diseqc_fifo+0x4f>
and $0x80,%eax
test %eax,%eax
je 1c <tda8083_wait_diseqc_fifo+0x1c>
nop
leaveq
retq
| |
它的源代码可能是：static void tda8083_wait_diseqc_fifo (struct tda8083_state* state, int timeout)
{
unsigned long start = jiffies;
while (jiffies - start < timeout &&
!(tda8083_readreg(state, 0x02) & 0x80))
{
msleep(50);
};
} | 这是一段反汇编代码，它的源代码是什么？<tda8083_wait_diseqc_fifo>:
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov 0x0(%rip),%r12
movslq %esi,%rbx
test %rbx,%rbx
je 40 <tda8083_wait_diseqc_fifo+0x40>
mov $0x2,%esi
mov %rbp,%rdi
callq 23 <tda8083_wait_diseqc_fifo+0x23>
test $0x80,%al
jne 40 <tda8083_wait_diseqc_fifo+0x40>
mov $0x32,%edi
callq 31 <tda8083_wait_diseqc_fifo+0x31>
mov 0x0(%rip),%rax
sub %r12,%rax
cmp %rbx,%rax
jb 16 <tda8083_wait_diseqc_fifo+0x16>
pop %rbx
pop %rbp
pop %r12
retq
| |
它的源代码可能是：static void tda8083_wait_diseqc_fifo (struct tda8083_state* state, int timeout)
{
unsigned long start = jiffies;
while (jiffies - start < timeout &&
!(tda8083_readreg(state, 0x02) & 0x80))
{
msleep(50);
};
} | 这是一段反汇编代码，它的源代码是什么？<tda8083_wait_diseqc_fifo>:
push %r12
mov 0x0(%rip),%r12
push %rbp
mov %rdi,%rbp
push %rbx
movslq %esi,%rbx
test %rbx,%rbx
jne 39 <tda8083_wait_diseqc_fifo+0x39>
jmp 4a <tda8083_wait_diseqc_fifo+0x4a>
nopl 0x0(%rax,%rax,1)
00
mov $0x32,%edi
callq 2a <tda8083_wait_diseqc_fifo+0x2a>
mov 0x0(%rip),%rax
sub %r12,%rax
cmp %rbx,%rax
jae 4a <tda8083_wait_diseqc_fifo+0x4a>
mov $0x2,%esi
mov %rbp,%rdi
callq 46 <tda8083_wait_diseqc_fifo+0x46>
test $0x80,%al
je 20 <tda8083_wait_diseqc_fifo+0x20>
pop %rbx
pop %rbp
pop %r12
retq
| |
它的源代码可能是：static void tda8083_wait_diseqc_fifo (struct tda8083_state* state, int timeout)
{
unsigned long start = jiffies;
while (jiffies - start < timeout &&
!(tda8083_readreg(state, 0x02) & 0x80))
{
msleep(50);
};
} | 这是一段反汇编代码，它的源代码是什么？<tda8083_wait_diseqc_fifo>:
push %r12
mov 0x0(%rip),%r12
push %rbp
mov %rdi,%rbp
push %rbx
movslq %esi,%rbx
test %rbx,%rbx
jne 39 <tda8083_wait_diseqc_fifo+0x39>
jmp 4a <tda8083_wait_diseqc_fifo+0x4a>
nopl 0x0(%rax,%rax,1)
00
mov $0x32,%edi
callq 2a <tda8083_wait_diseqc_fifo+0x2a>
mov 0x0(%rip),%rax
sub %r12,%rax
cmp %rbx,%rax
jae 4a <tda8083_wait_diseqc_fifo+0x4a>
mov $0x2,%esi
mov %rbp,%rdi
callq 46 <tda8083_wait_diseqc_fifo+0x46>
test $0x80,%al
je 20 <tda8083_wait_diseqc_fifo+0x20>
pop %rbx
pop %rbp
pop %r12
retq
| |
它的源代码可能是：static void d68000_move_32(void)
{
char* str = get_ea_mode_str_32(g_cpu_ir);
sprintf(g_dasm_str, "move.l %s, %s", str, get_ea_mode_str_32(((g_cpu_ir>>9) & 7) | ((g_cpu_ir>>3) & 0x38)));
} | 这是一段反汇编代码，它的源代码是什么？<d68000_move_32>:
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov 0x0(%rip),%eax
mov %eax,%edi
callq 15 <d68000_move_32+0x15>
mov %rax,-0x8(%rbp)
mov 0x0(%rip),%eax
sar $0x9,%eax
and $0x7,%eax
mov %eax,%edx
mov 0x0(%rip),%eax
sar $0x3,%eax
and $0x38,%eax
or %edx,%eax
mov %eax,%edi
callq 3c <d68000_move_32+0x3c>
mov %rax,%rcx
mov 0x0(%rip),%eax
mov -0x8(%rbp),%rdx
mov $0x0,%esi
mov %eax,%edi
callq 55 <d68000_move_32+0x55>
nop
leaveq
retq
| |
它的源代码可能是：static void d68000_move_32(void)
{
char* str = get_ea_mode_str_32(g_cpu_ir);
sprintf(g_dasm_str, "move.l %s, %s", str, get_ea_mode_str_32(((g_cpu_ir>>9) & 7) | ((g_cpu_ir>>3) & 0x38)));
} | 这是一段反汇编代码，它的源代码是什么？<d68000_move_32>:
push %rbx
mov 0x0(%rip),%edi
callq c <d68000_move_32+0xc>
mov %rax,%rbx
mov 0x0(%rip),%eax
mov %eax,%edi
sar $0x9,%edi
and $0x7,%edi
sar $0x3,%eax
and $0x38,%eax
or %eax,%edi
callq 2a <d68000_move_32+0x2a>
mov %rax,%rcx
mov %rbx,%rdx
mov $0x0,%esi
mov 0x0(%rip),%edi
callq 40 <d68000_move_32+0x40>
pop %rbx
retq
| |
它的源代码可能是：static void d68000_move_32(void)
{
char* str = get_ea_mode_str_32(g_cpu_ir);
sprintf(g_dasm_str, "move.l %s, %s", str, get_ea_mode_str_32(((g_cpu_ir>>9) & 7) | ((g_cpu_ir>>3) & 0x38)));
} | 这是一段反汇编代码，它的源代码是什么？<d68000_move_32>:
push %rbx
mov 0x0(%rip),%edi
callq c <d68000_move_32+0xc>
mov %rax,%rbx
mov 0x0(%rip),%eax
mov %eax,%edi
sar $0x3,%eax
sar $0x9,%edi
and $0x38,%eax
and $0x7,%edi
or %eax,%edi
callq 2a <d68000_move_32+0x2a>
mov 0x0(%rip),%edi
mov %rbx,%rdx
pop %rbx
mov %rax,%rcx
mov $0x0,%esi
jmpq 41 <d68000_move_32+0x41>
| |
它的源代码可能是：static void d68000_move_32(void)
{
char* str = get_ea_mode_str_32(g_cpu_ir);
sprintf(g_dasm_str, "move.l %s, %s", str, get_ea_mode_str_32(((g_cpu_ir>>9) & 7) | ((g_cpu_ir>>3) & 0x38)));
} | 这是一段反汇编代码，它的源代码是什么？<d68000_move_32>:
push %rbx
mov 0x0(%rip),%edi
callq c <d68000_move_32+0xc>
mov %rax,%rbx
mov 0x0(%rip),%eax
mov %eax,%edi
sar $0x3,%eax
sar $0x9,%edi
and $0x38,%eax
and $0x7,%edi
or %eax,%edi
callq 2a <d68000_move_32+0x2a>
mov 0x0(%rip),%edi
mov %rbx,%rdx
pop %rbx
mov %rax,%rcx
mov $0x0,%esi
jmpq 41 <d68000_move_32+0x41>
| |
它的源代码可能是：void slowlogInit(void) {
server.slowlog = listCreate();
server.slowlog_entry_id = 0;
listSetFreeMethod(server.slowlog,slowlogFreeEntry);
} | 这是一段反汇编代码，它的源代码是什么？<slowlogInit>:
push %rbp
mov %rsp,%rbp
mov $0x0,%eax
callq e <slowlogInit+0xe>
mov %eax,0x0(%rip)
movq $0x0,0x0(%rip)
00 00 00 00
mov 0x0(%rip),%edx
mov 0x0(%rip),%eax
mov %edx,%esi
mov %eax,%edi
callq 34 <slowlogInit+0x34>
nop
pop %rbp
retq
| |
它的源代码可能是：void slowlogInit(void) {
server.slowlog = listCreate();
server.slowlog_entry_id = 0;
listSetFreeMethod(server.slowlog,slowlogFreeEntry);
} | 这是一段反汇编代码，它的源代码是什么？<slowlogInit>:
sub $0x8,%rsp
mov $0x0,%eax
callq e <slowlogInit+0xe>
mov %eax,0x0(%rip)
movq $0x0,0x0(%rip)
00 00 00 00
mov 0x0(%rip),%esi
mov %eax,%edi
callq 2c <slowlogInit+0x2c>
add $0x8,%rsp
retq
| |
它的源代码可能是：void slowlogInit(void) {
server.slowlog = listCreate();
server.slowlog_entry_id = 0;
listSetFreeMethod(server.slowlog,slowlogFreeEntry);
} | 这是一段反汇编代码，它的源代码是什么？<slowlogInit>:
sub $0x8,%rsp
xor %eax,%eax
callq b <slowlogInit+0xb>
mov 0x0(%rip),%esi
movq $0x0,0x0(%rip)
00 00 00 00
mov %eax,0x0(%rip)
mov %eax,%edi
add $0x8,%rsp
jmpq 2d <slowlogInit+0x2d>
| |
它的源代码可能是：void slowlogInit(void) {
server.slowlog = listCreate();
server.slowlog_entry_id = 0;
listSetFreeMethod(server.slowlog,slowlogFreeEntry);
} | 这是一段反汇编代码，它的源代码是什么？<slowlogInit>:
sub $0x8,%rsp
xor %eax,%eax
callq b <slowlogInit+0xb>
mov 0x0(%rip),%esi
movq $0x0,0x0(%rip)
00 00 00 00
mov %eax,0x0(%rip)
mov %eax,%edi
add $0x8,%rsp
jmpq 2d <slowlogInit+0x2d>
| |
它的源代码可能是：int radeon_ib_ring_tests(struct radeon_device *rdev)
{
unsigned i;
int r;
for (i = 0; i < RADEON_NUM_RINGS; ++i) {
struct radeon_ring *ring = &rdev->ring[i];
if (!ring->ready)
continue;
r = radeon_ib_test(rdev, i, ring);
if (r) {
ring->ready = false;
if (i == RADEON_RING_TYPE_GFX_INDEX) {
/* oh, oh, that's really bad */
DRM_ERROR("radeon: failed testing IB on GFX ring (%d).\n", r);
rdev->accel_working = false;
return r;
} else {
/* still not good, but we can live with it */
DRM_ERROR("radeon: failed testing IB on ring %d (%d).\n", i, r);
}
}
}
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<radeon_ib_ring_tests>:
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmpq ac <radeon_ib_ring_tests+0xac>
mov -0x28(%rbp),%rax
mov 0x8(%rax),%rax
mov -0x4(%rbp),%edx
shl $0x2,%rdx
add %rdx,%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov (%rax),%eax
test %eax,%eax
je a7 <radeon_ib_ring_tests+0xa7>
mov -0x10(%rbp),%rdx
mov -0x4(%rbp),%ecx
mov -0x28(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 4d <radeon_ib_ring_tests+0x4d>
mov %eax,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
je a8 <radeon_ib_ring_tests+0xa8>
mov -0x10(%rbp),%rax
movl $0x0,(%rax)
mov 0x0(%rip),%eax
cmp %eax,-0x4(%rbp)
jne 8e <radeon_ib_ring_tests+0x8e>
mov -0x14(%rbp),%eax
mov %eax,%esi
mov $0x0,%edi
mov $0x0,%eax
callq 7f <radeon_ib_ring_tests+0x7f>
mov -0x28(%rbp),%rax
movl $0x0,(%rax)
mov -0x14(%rbp),%eax
jmp c0 <radeon_ib_ring_tests+0xc0>
mov -0x14(%rbp),%edx
mov -0x4(%rbp),%eax
mov %eax,%esi
mov $0x0,%edi
mov $0x0,%eax
callq a5 <radeon_ib_ring_tests+0xa5>
jmp a8 <radeon_ib_ring_tests+0xa8>
nop
addl $0x1,-0x4(%rbp)
mov 0x0(%rip),%eax
cmp %eax,-0x4(%rbp)
jb 18 <radeon_ib_ring_tests+0x18>
mov $0x0,%eax
leaveq
retq
| |
它的源代码可能是：int radeon_ib_ring_tests(struct radeon_device *rdev)
{
unsigned i;
int r;
for (i = 0; i < RADEON_NUM_RINGS; ++i) {
struct radeon_ring *ring = &rdev->ring[i];
if (!ring->ready)
continue;
r = radeon_ib_test(rdev, i, ring);
if (r) {
ring->ready = false;
if (i == RADEON_RING_TYPE_GFX_INDEX) {
/* oh, oh, that's really bad */
DRM_ERROR("radeon: failed testing IB on GFX ring (%d).\n", r);
rdev->accel_working = false;
return r;
} else {
/* still not good, but we can live with it */
DRM_ERROR("radeon: failed testing IB on ring %d (%d).\n", i, r);
}
}
}
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<radeon_ib_ring_tests>:
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
cmpl $0x0,0x0(%rip)
je a4 <radeon_ib_ring_tests+0xa4>
mov %rdi,%r12
mov $0x0,%ebx
jmp 47 <radeon_ib_ring_tests+0x47>
mov %eax,%esi
mov $0x0,%edi
mov $0x0,%eax
callq 32 <radeon_ib_ring_tests+0x32>
movl $0x0,(%r12)
00
jmp 96 <radeon_ib_ring_tests+0x96>
add $0x1,%ebx
cmp %ebx,0x0(%rip)
jbe 90 <radeon_ib_ring_tests+0x90>
mov %ebx,%eax
mov 0x8(%r12),%rdx
lea (%rdx,%rax,4),%rbp
cmpl $0x0,0x0(%rbp)
je 3c <radeon_ib_ring_tests+0x3c>
mov %rbp,%rdx
mov %ebx,%esi
mov %r12,%rdi
callq 65 <radeon_ib_ring_tests+0x65>
mov %eax,%r13d
test %eax,%eax
je 3c <radeon_ib_ring_tests+0x3c>
movl $0x0,0x0(%rbp)
cmp %ebx,0x0(%rip)
je 21 <radeon_ib_ring_tests+0x21>
mov %eax,%edx
mov %ebx,%esi
mov $0x0,%edi
mov $0x0,%eax
callq 8e <radeon_ib_ring_tests+0x8e>
jmp 3c <radeon_ib_ring_tests+0x3c>
mov $0x0,%r13d
mov %r13d,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x0,%r13d
jmp 96 <radeon_ib_ring_tests+0x96>
| |
它的源代码可能是：int radeon_ib_ring_tests(struct radeon_device *rdev)
{
unsigned i;
int r;
for (i = 0; i < RADEON_NUM_RINGS; ++i) {
struct radeon_ring *ring = &rdev->ring[i];
if (!ring->ready)
continue;
r = radeon_ib_test(rdev, i, ring);
if (r) {
ring->ready = false;
if (i == RADEON_RING_TYPE_GFX_INDEX) {
/* oh, oh, that's really bad */
DRM_ERROR("radeon: failed testing IB on GFX ring (%d).\n", r);
rdev->accel_working = false;
return r;
} else {
/* still not good, but we can live with it */
DRM_ERROR("radeon: failed testing IB on ring %d (%d).\n", i, r);
}
}
}
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<radeon_ib_ring_tests>:
mov 0x0(%rip),%edx
test %edx,%edx
je a9 <radeon_ib_ring_tests+0xa9>
push %r12
mov %rdi,%r12
push %rbp
push %rbx
xor %ebx,%ebx
sub $0x10,%rsp
nopl 0x0(%rax,%rax,1)
mov 0x8(%r12),%rdx
mov %ebx,%eax
lea (%rdx,%rax,4),%rbp
mov 0x0(%rbp),%eax
test %eax,%eax
je 62 <radeon_ib_ring_tests+0x62>
mov %rbp,%rdx
mov %ebx,%esi
mov %r12,%rdi
callq 3f <radeon_ib_ring_tests+0x3f>
mov %eax,%edx
test %eax,%eax
je 62 <radeon_ib_ring_tests+0x62>
movl $0x0,0x0(%rbp)
cmp %ebx,0x0(%rip)
je 80 <radeon_ib_ring_tests+0x80>
mov %ebx,%esi
mov $0x0,%edi
xor %eax,%eax
callq 62 <radeon_ib_ring_tests+0x62>
add $0x1,%ebx
cmp %ebx,0x0(%rip)
ja 20 <radeon_ib_ring_tests+0x20>
add $0x10,%rsp
xor %edx,%edx
pop %rbx
mov %edx,%eax
pop %rbp
pop %r12
retq
nopw 0x0(%rax,%rax,1)
mov %eax,0xc(%rsp)
mov %eax,%esi
mov $0x0,%edi
xor %eax,%eax
callq 92 <radeon_ib_ring_tests+0x92>
mov 0xc(%rsp),%edx
movl $0x0,(%r12)
00
add $0x10,%rsp
pop %rbx
pop %rbp
mov %edx,%eax
pop %r12
retq
xor %edx,%edx
mov %edx,%eax
retq
| |
它的源代码可能是：int radeon_ib_ring_tests(struct radeon_device *rdev)
{
unsigned i;
int r;
for (i = 0; i < RADEON_NUM_RINGS; ++i) {
struct radeon_ring *ring = &rdev->ring[i];
if (!ring->ready)
continue;
r = radeon_ib_test(rdev, i, ring);
if (r) {
ring->ready = false;
if (i == RADEON_RING_TYPE_GFX_INDEX) {
/* oh, oh, that's really bad */
DRM_ERROR("radeon: failed testing IB on GFX ring (%d).\n", r);
rdev->accel_working = false;
return r;
} else {
/* still not good, but we can live with it */
DRM_ERROR("radeon: failed testing IB on ring %d (%d).\n", i, r);
}
}
}
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<radeon_ib_ring_tests>:
mov 0x0(%rip),%ecx
test %ecx,%ecx
je a9 <radeon_ib_ring_tests+0xa9>
push %r12
mov %rdi,%r12
push %rbp
push %rbx
xor %ebx,%ebx
sub $0x10,%rsp
nopl 0x0(%rax,%rax,1)
mov 0x8(%r12),%rdx
mov %ebx,%eax
lea (%rdx,%rax,4),%rbp
mov 0x0(%rbp),%eax
test %eax,%eax
je 68 <radeon_ib_ring_tests+0x68>
mov %rbp,%rdx
mov %ebx,%esi
mov %r12,%rdi
callq 3f <radeon_ib_ring_tests+0x3f>
mov %eax,%edx
test %eax,%eax
je 62 <radeon_ib_ring_tests+0x62>
movl $0x0,0x0(%rbp)
cmp %ebx,0x0(%rip)
je 80 <radeon_ib_ring_tests+0x80>
mov %ebx,%esi
mov $0x0,%edi
xor %eax,%eax
callq 62 <radeon_ib_ring_tests+0x62>
mov 0x0(%rip),%ecx
add $0x1,%ebx
cmp %ecx,%ebx
jb 20 <radeon_ib_ring_tests+0x20>
add $0x10,%rsp
xor %edx,%edx
pop %rbx
mov %edx,%eax
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
mov %eax,0xc(%rsp)
mov %eax,%esi
mov $0x0,%edi
xor %eax,%eax
callq 92 <radeon_ib_ring_tests+0x92>
mov 0xc(%rsp),%edx
movl $0x0,(%r12)
00
add $0x10,%rsp
pop %rbx
pop %rbp
mov %edx,%eax
pop %r12
retq
xor %edx,%edx
mov %edx,%eax
retq
| |
它的源代码可能是：static int
get_direntry(vfs_context_t ctx, vnode_t dvp, struct fd_vn_data *fvd,
int *eofflagp, struct direntry **dpp)
{
int eofflag;
int error;
*eofflagp = 0;
*dpp = NULL;
error = 0;
if (!fvd->fv_bufsiz) {
error = refill_fd_direntries(ctx, dvp, fvd, &eofflag);
if (error) {
return (error);
}
if (eofflag) {
*eofflagp = eofflag;
return (error);
}
}
*dpp = (struct direntry *)(fvd->fv_buf + fvd->fv_bufdone);
return (error);
} | 这是一段反汇编代码，它的源代码是什么？<get_direntry>:
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %rdx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
mov %r8,-0x30(%rbp)
mov -0x28(%rbp),%rax
movl $0x0,(%rax)
mov -0x30(%rbp),%rax
movq $0x0,(%rax)
movl $0x0,-0x4(%rbp)
mov -0x20(%rbp),%rax
mov 0x10(%rax),%eax
test %eax,%eax
jne 79 <get_direntry+0x79>
lea -0x8(%rbp),%rcx
mov -0x20(%rbp),%rdx
mov -0x18(%rbp),%esi
mov -0x14(%rbp),%eax
mov %eax,%edi
callq 56 <get_direntry+0x56>
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
je 64 <get_direntry+0x64>
mov -0x4(%rbp),%eax
jmp 98 <get_direntry+0x98>
mov -0x8(%rbp),%eax
test %eax,%eax
je 79 <get_direntry+0x79>
mov -0x8(%rbp),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
mov -0x4(%rbp),%eax
jmp 98 <get_direntry+0x98>
mov -0x20(%rbp),%rax
mov 0x8(%rax),%rdx
mov -0x20(%rbp),%rax
mov (%rax),%rax
add %rdx,%rax
mov %rax,%rdx
mov -0x30(%rbp),%rax
mov %rdx,(%rax)
mov -0x4(%rbp),%eax
leaveq
retq
| |
它的源代码可能是：static int
get_direntry(vfs_context_t ctx, vnode_t dvp, struct fd_vn_data *fvd,
int *eofflagp, struct direntry **dpp)
{
int eofflag;
int error;
*eofflagp = 0;
*dpp = NULL;
error = 0;
if (!fvd->fv_bufsiz) {
error = refill_fd_direntries(ctx, dvp, fvd, &eofflag);
if (error) {
return (error);
}
if (eofflag) {
*eofflagp = eofflag;
return (error);
}
}
*dpp = (struct direntry *)(fvd->fv_buf + fvd->fv_bufdone);
return (error);
} | 这是一段反汇编代码，它的源代码是什么？<get_direntry>:
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdx,%rbx
mov %r8,%rbp
movl $0x0,(%rcx)
movq $0x0,(%r8)
cmpl $0x0,0x10(%rdx)
je 3a <get_direntry+0x3a>
mov (%rbx),%rax
add 0x8(%rbx),%rax
mov %rax,0x0(%rbp)
mov $0x0,%eax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
retq
mov %rcx,%r12
lea 0xc(%rsp),%rcx
callq 47 <get_direntry+0x47>
test %eax,%eax
jne 31 <get_direntry+0x31>
mov 0xc(%rsp),%edx
test %edx,%edx
je 21 <get_direntry+0x21>
mov %edx,(%r12)
jmp 31 <get_direntry+0x31>
| |
它的源代码可能是：static int
get_direntry(vfs_context_t ctx, vnode_t dvp, struct fd_vn_data *fvd,
int *eofflagp, struct direntry **dpp)
{
int eofflag;
int error;
*eofflagp = 0;
*dpp = NULL;
error = 0;
if (!fvd->fv_bufsiz) {
error = refill_fd_direntries(ctx, dvp, fvd, &eofflag);
if (error) {
return (error);
}
if (eofflag) {
*eofflagp = eofflag;
return (error);
}
}
*dpp = (struct direntry *)(fvd->fv_buf + fvd->fv_bufdone);
return (error);
} | 这是一段反汇编代码，它的源代码是什么？<get_direntry>:
push %rbp
push %rbx
mov %rdx,%rbx
sub $0x28,%rsp
movl $0x0,(%rcx)
mov 0x10(%rdx),%eax
movq $0x0,(%r8)
test %eax,%eax
je 30 <get_direntry+0x30>
mov (%rbx),%rax
add 0x8(%rbx),%rax
mov %rax,(%r8)
xor %eax,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
mov %rcx,%rbp
lea 0x1c(%rsp),%rcx
mov %r8,0x8(%rsp)
callq 42 <get_direntry+0x42>
test %eax,%eax
jne 29 <get_direntry+0x29>
mov 0x1c(%rsp),%edx
mov 0x8(%rsp),%r8
test %edx,%edx
je 1d <get_direntry+0x1d>
mov %edx,0x0(%rbp)
jmp 29 <get_direntry+0x29>
| |
它的源代码可能是：static int
get_direntry(vfs_context_t ctx, vnode_t dvp, struct fd_vn_data *fvd,
int *eofflagp, struct direntry **dpp)
{
int eofflag;
int error;
*eofflagp = 0;
*dpp = NULL;
error = 0;
if (!fvd->fv_bufsiz) {
error = refill_fd_direntries(ctx, dvp, fvd, &eofflag);
if (error) {
return (error);
}
if (eofflag) {
*eofflagp = eofflag;
return (error);
}
}
*dpp = (struct direntry *)(fvd->fv_buf + fvd->fv_bufdone);
return (error);
} | 这是一段反汇编代码，它的源代码是什么？<get_direntry>:
push %rbp
push %rbx
mov %rdx,%rbx
sub $0x28,%rsp
movl $0x0,(%rcx)
mov 0x10(%rdx),%eax
movq $0x0,(%r8)
test %eax,%eax
je 30 <get_direntry+0x30>
mov (%rbx),%rax
add 0x8(%rbx),%rax
mov %rax,(%r8)
xor %eax,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
mov %rcx,%rbp
lea 0x1c(%rsp),%rcx
mov %r8,0x8(%rsp)
callq 42 <get_direntry+0x42>
test %eax,%eax
jne 29 <get_direntry+0x29>
mov 0x1c(%rsp),%edx
mov 0x8(%rsp),%r8
test %edx,%edx
je 1d <get_direntry+0x1d>
mov %edx,0x0(%rbp)
jmp 29 <get_direntry+0x29>
| |
它的源代码可能是：static unsigned int msm_get_mctrl(struct uart_port *port)
{
return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR | TIOCM_RTS;
} | 这是一段反汇编代码，它的源代码是什么？<msm_get_mctrl>:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov 0x0(%rip),%edx
mov 0x0(%rip),%eax
or %eax,%edx
mov 0x0(%rip),%eax
or %eax,%edx
mov 0x0(%rip),%eax
or %edx,%eax
pop %rbp
retq
| |
它的源代码可能是：static unsigned int msm_get_mctrl(struct uart_port *port)
{
return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR | TIOCM_RTS;
} | 这是一段反汇编代码，它的源代码是什么？<msm_get_mctrl>:
mov 0x0(%rip),%eax
or 0x0(%rip),%eax
or 0x0(%rip),%eax
or 0x0(%rip),%eax
retq
| |
它的源代码可能是：static unsigned int msm_get_mctrl(struct uart_port *port)
{
return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR | TIOCM_RTS;
} | 这是一段反汇编代码，它的源代码是什么？<msm_get_mctrl>:
mov 0x0(%rip),%eax
or 0x0(%rip),%eax
or 0x0(%rip),%eax
or 0x0(%rip),%eax
retq
| |
它的源代码可能是：static unsigned int msm_get_mctrl(struct uart_port *port)
{
return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR | TIOCM_RTS;
} | 这是一段反汇编代码，它的源代码是什么？<msm_get_mctrl>:
mov 0x0(%rip),%eax
or 0x0(%rip),%eax
or 0x0(%rip),%eax
or 0x0(%rip),%eax
retq
| |
它的源代码可能是：static int slow_work_wait(void *word)
{
schedule();
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<slow_work_wait>:
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov $0x0,%eax
callq 16 <slow_work_wait+0x16>
mov $0x0,%eax
leaveq
retq
| |
它的源代码可能是：static int slow_work_wait(void *word)
{
schedule();
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<slow_work_wait>:
sub $0x8,%rsp
mov $0x0,%eax
callq e <slow_work_wait+0xe>
mov $0x0,%eax
add $0x8,%rsp
retq
| |
它的源代码可能是：static int slow_work_wait(void *word)
{
schedule();
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<slow_work_wait>:
sub $0x8,%rsp
xor %eax,%eax
callq b <slow_work_wait+0xb>
xor %eax,%eax
add $0x8,%rsp
retq
| |
它的源代码可能是：static int slow_work_wait(void *word)
{
schedule();
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<slow_work_wait>:
sub $0x8,%rsp
xor %eax,%eax
callq b <slow_work_wait+0xb>
xor %eax,%eax
add $0x8,%rsp
retq
| |
它的源代码可能是：void arch_teardown_msi_irq(unsigned int irq)
{
int number_irqs;
uint64_t bitmask;
if ((irq < OCTEON_IRQ_MSI_BIT0) || (irq > OCTEON_IRQ_MSI_BIT63))
panic("arch_teardown_msi_irq: Attempted to teardown illegal "
"MSI interrupt (%d)", irq);
irq -= OCTEON_IRQ_MSI_BIT0;
/*
* Count the number of IRQs we need to free by looking at the
* msi_multiple_irq_bitmask. Each bit set means that the next
* IRQ is also owned by this device.
*/
number_irqs = 0;
while ((irq+number_irqs < 64) &&
(msi_multiple_irq_bitmask & (1ull << (irq + number_irqs))))
number_irqs++;
number_irqs++;
/* Mask with one bit for each IRQ */
bitmask = (1 << number_irqs) - 1;
/* Shift the mask to the correct bit location */
bitmask <<= irq;
if ((msi_free_irq_bitmask & bitmask) != bitmask)
panic("arch_teardown_msi_irq: Attempted to teardown MSI "
"interrupt (%d) not in use", irq);
/* Checks are done, update the in use bitmask */
spin_lock(&msi_free_irq_bitmask_lock);
msi_free_irq_bitmask &= ~bitmask;
msi_multiple_irq_bitmask &= ~bitmask;
spin_unlock(&msi_free_irq_bitmask_lock);
} | 这是一段反汇编代码，它的源代码是什么？<arch_teardown_msi_irq>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov 0x0(%rip),%eax
cmp %eax,-0x14(%rbp)
jb 21 <arch_teardown_msi_irq+0x21>
mov 0x0(%rip),%eax
cmp %eax,-0x14(%rbp)
jbe 30 <arch_teardown_msi_irq+0x30>
mov -0x14(%rbp),%eax
mov %eax,%esi
mov $0x0,%edi
callq 30 <arch_teardown_msi_irq+0x30>
mov 0x0(%rip),%eax
sub %eax,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
jmp 46 <arch_teardown_msi_irq+0x46>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%edx
mov -0x14(%rbp),%eax
add %edx,%eax
cmp $0x3f,%eax
ja 72 <arch_teardown_msi_irq+0x72>
mov 0x0(%rip),%rdx
mov -0x4(%rbp),%ecx
mov -0x14(%rbp),%eax
add %ecx,%eax
mov %eax,%ecx
shr %cl,%rdx
mov %rdx,%rax
and $0x1,%eax
test %rax,%rax
jne 42 <arch_teardown_msi_irq+0x42>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
mov $0x1,%edx
mov %eax,%ecx
shl %cl,%edx
mov %edx,%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%ecx
shll %cl,-0x8(%rbp)
mov 0x0(%rip),%eax
and -0x8(%rbp),%eax
cmp %eax,-0x8(%rbp)
je af <arch_teardown_msi_irq+0xaf>
mov -0x14(%rbp),%eax
mov %eax,%esi
mov $0x0,%edi
callq af <arch_teardown_msi_irq+0xaf>
mov $0x0,%edi
callq b9 <arch_teardown_msi_irq+0xb9>
mov -0x8(%rbp),%eax
not %eax
mov %eax,%edx
mov 0x0(%rip),%eax
and %edx,%eax
mov %eax,0x0(%rip)
mov -0x8(%rbp),%eax
not %eax
mov %eax,%edx
mov 0x0(%rip),%rax
and %rdx,%rax
mov %rax,0x0(%rip)
mov $0x0,%edi
callq f0 <arch_teardown_msi_irq+0xf0>
nop
leaveq
retq
| |
它的源代码可能是：void arch_teardown_msi_irq(unsigned int irq)
{
int number_irqs;
uint64_t bitmask;
if ((irq < OCTEON_IRQ_MSI_BIT0) || (irq > OCTEON_IRQ_MSI_BIT63))
panic("arch_teardown_msi_irq: Attempted to teardown illegal "
"MSI interrupt (%d)", irq);
irq -= OCTEON_IRQ_MSI_BIT0;
/*
* Count the number of IRQs we need to free by looking at the
* msi_multiple_irq_bitmask. Each bit set means that the next
* IRQ is also owned by this device.
*/
number_irqs = 0;
while ((irq+number_irqs < 64) &&
(msi_multiple_irq_bitmask & (1ull << (irq + number_irqs))))
number_irqs++;
number_irqs++;
/* Mask with one bit for each IRQ */
bitmask = (1 << number_irqs) - 1;
/* Shift the mask to the correct bit location */
bitmask <<= irq;
if ((msi_free_irq_bitmask & bitmask) != bitmask)
panic("arch_teardown_msi_irq: Attempted to teardown MSI "
"interrupt (%d) not in use", irq);
/* Checks are done, update the in use bitmask */
spin_lock(&msi_free_irq_bitmask_lock);
msi_free_irq_bitmask &= ~bitmask;
msi_multiple_irq_bitmask &= ~bitmask;
spin_unlock(&msi_free_irq_bitmask_lock);
} | 这是一段反汇编代码，它的源代码是什么？<arch_teardown_msi_irq>:
push %rbx
mov %edi,%ebx
cmp %edi,0x0(%rip)
ja 13 <arch_teardown_msi_irq+0x13>
cmp %edi,0x0(%rip)
jae 1f <arch_teardown_msi_irq+0x1f>
mov %ebx,%esi
mov $0x0,%edi
callq 1f <arch_teardown_msi_irq+0x1f>
mov 0x0(%rip),%edx
mov %ebx,%esi
sub %edx,%esi
cmp $0x3f,%esi
ja 99 <arch_teardown_msi_irq+0x99>
mov 0x0(%rip),%rdi
bt %rsi,%rdi
jae a0 <arch_teardown_msi_irq+0xa0>
sub %ebx,%edx
add $0x40,%edx
mov $0x0,%ecx
add $0x1,%ecx
lea (%rcx,%rsi,1),%eax
cmp %ecx,%edx
je 55 <arch_teardown_msi_irq+0x55>
bt %rax,%rdi
jb 45 <arch_teardown_msi_irq+0x45>
add $0x1,%ecx
mov $0x1,%ebx
shl %cl,%ebx
sub $0x1,%ebx
mov %esi,%ecx
shl %cl,%ebx
mov %ebx,%eax
and 0x0(%rip),%eax
cmp %ebx,%eax
jne a7 <arch_teardown_msi_irq+0xa7>
mov $0x0,%edi
callq 7c <arch_teardown_msi_irq+0x7c>
not %ebx
and %ebx,0x0(%rip)
mov %ebx,%ebx
and %rbx,0x0(%rip)
mov $0x0,%edi
callq 97 <arch_teardown_msi_irq+0x97>
pop %rbx
retq
mov $0x0,%ecx
jmp 55 <arch_teardown_msi_irq+0x55>
mov $0x0,%ecx
jmp 55 <arch_teardown_msi_irq+0x55>
mov $0x0,%edi
callq b1 <arch_teardown_msi_irq+0xb1>
jmp 72 <arch_teardown_msi_irq+0x72>
| |
它的源代码可能是：void arch_teardown_msi_irq(unsigned int irq)
{
int number_irqs;
uint64_t bitmask;
if ((irq < OCTEON_IRQ_MSI_BIT0) || (irq > OCTEON_IRQ_MSI_BIT63))
panic("arch_teardown_msi_irq: Attempted to teardown illegal "
"MSI interrupt (%d)", irq);
irq -= OCTEON_IRQ_MSI_BIT0;
/*
* Count the number of IRQs we need to free by looking at the
* msi_multiple_irq_bitmask. Each bit set means that the next
* IRQ is also owned by this device.
*/
number_irqs = 0;
while ((irq+number_irqs < 64) &&
(msi_multiple_irq_bitmask & (1ull << (irq + number_irqs))))
number_irqs++;
number_irqs++;
/* Mask with one bit for each IRQ */
bitmask = (1 << number_irqs) - 1;
/* Shift the mask to the correct bit location */
bitmask <<= irq;
if ((msi_free_irq_bitmask & bitmask) != bitmask)
panic("arch_teardown_msi_irq: Attempted to teardown MSI "
"interrupt (%d) not in use", irq);
/* Checks are done, update the in use bitmask */
spin_lock(&msi_free_irq_bitmask_lock);
msi_free_irq_bitmask &= ~bitmask;
msi_multiple_irq_bitmask &= ~bitmask;
spin_unlock(&msi_free_irq_bitmask_lock);
} | 这是一段反汇编代码，它的源代码是什么？<arch_teardown_msi_irq>:
mov 0x0(%rip),%edx
push %rbx
mov %edi,%ebx
cmp %edi,%edx
ja b0 <arch_teardown_msi_irq+0xb0>
cmp %edi,0x0(%rip)
jb b0 <arch_teardown_msi_irq+0xb0>
mov %ebx,%esi
sub %edx,%esi
cmp $0x3f,%esi
ja d0 <arch_teardown_msi_irq+0xd0>
mov 0x0(%rip),%rdi
bt %rsi,%rdi
jae d0 <arch_teardown_msi_irq+0xd0>
sub %ebx,%edx
lea 0x1(%rsi),%ecx
add $0x1,%edx
jmp 55 <arch_teardown_msi_irq+0x55>
nopl (%rax)
mov %rdi,%rax
shr %cl,%rax
add $0x1,%ecx
test $0x1,%al
je 5e <arch_teardown_msi_irq+0x5e>
lea (%rdx,%rcx,1),%r8d
cmp $0x40,%ecx
jne 48 <arch_teardown_msi_irq+0x48>
mov $0x1,%ebx
mov %r8d,%ecx
shl %cl,%ebx
sub $0x1,%ebx
mov %esi,%ecx
mov 0x0(%rip),%eax
shl %cl,%ebx
and %ebx,%eax
cmp %ebx,%eax
je 85 <arch_teardown_msi_irq+0x85>
mov $0x0,%edi
callq 85 <arch_teardown_msi_irq+0x85>
mov $0x0,%edi
not %ebx
callq 91 <arch_teardown_msi_irq+0x91>
and %ebx,0x0(%rip)
mov $0x0,%edi
and %rbx,0x0(%rip)
pop %rbx
jmpq a9 <arch_teardown_msi_irq+0xa9>
nopl 0x0(%rax)
mov %ebx,%esi
mov $0x0,%edi
callq bc <arch_teardown_msi_irq+0xbc>
mov 0x0(%rip),%edx
jmpq 1d <arch_teardown_msi_irq+0x1d>
nopw 0x0(%rax,%rax,1)
00 00
mov $0x1,%ebx
jmp 6b <arch_teardown_msi_irq+0x6b>
| |
它的源代码可能是：void arch_teardown_msi_irq(unsigned int irq)
{
int number_irqs;
uint64_t bitmask;
if ((irq < OCTEON_IRQ_MSI_BIT0) || (irq > OCTEON_IRQ_MSI_BIT63))
panic("arch_teardown_msi_irq: Attempted to teardown illegal "
"MSI interrupt (%d)", irq);
irq -= OCTEON_IRQ_MSI_BIT0;
/*
* Count the number of IRQs we need to free by looking at the
* msi_multiple_irq_bitmask. Each bit set means that the next
* IRQ is also owned by this device.
*/
number_irqs = 0;
while ((irq+number_irqs < 64) &&
(msi_multiple_irq_bitmask & (1ull << (irq + number_irqs))))
number_irqs++;
number_irqs++;
/* Mask with one bit for each IRQ */
bitmask = (1 << number_irqs) - 1;
/* Shift the mask to the correct bit location */
bitmask <<= irq;
if ((msi_free_irq_bitmask & bitmask) != bitmask)
panic("arch_teardown_msi_irq: Attempted to teardown MSI "
"interrupt (%d) not in use", irq);
/* Checks are done, update the in use bitmask */
spin_lock(&msi_free_irq_bitmask_lock);
msi_free_irq_bitmask &= ~bitmask;
msi_multiple_irq_bitmask &= ~bitmask;
spin_unlock(&msi_free_irq_bitmask_lock);
} | 这是一段反汇编代码，它的源代码是什么？<arch_teardown_msi_irq>:
mov 0x0(%rip),%edx
push %rbx
mov %edi,%ebx
cmp %edi,%edx
ja b0 <arch_teardown_msi_irq+0xb0>
cmp %edi,0x0(%rip)
jb b0 <arch_teardown_msi_irq+0xb0>
mov %ebx,%esi
sub %edx,%esi
cmp $0x3f,%esi
ja d0 <arch_teardown_msi_irq+0xd0>
mov 0x0(%rip),%rdi
bt %rsi,%rdi
jae d0 <arch_teardown_msi_irq+0xd0>
sub %ebx,%edx
lea 0x1(%rsi),%ecx
add $0x1,%edx
jmp 55 <arch_teardown_msi_irq+0x55>
nopl (%rax)
mov %rdi,%rax
shr %cl,%rax
add $0x1,%ecx
test $0x1,%al
je 5e <arch_teardown_msi_irq+0x5e>
lea (%rdx,%rcx,1),%r8d
cmp $0x40,%ecx
jne 48 <arch_teardown_msi_irq+0x48>
mov $0x1,%ebx
mov %r8d,%ecx
shl %cl,%ebx
sub $0x1,%ebx
mov %esi,%ecx
mov 0x0(%rip),%eax
shl %cl,%ebx
and %ebx,%eax
cmp %ebx,%eax
je 85 <arch_teardown_msi_irq+0x85>
mov $0x0,%edi
callq 85 <arch_teardown_msi_irq+0x85>
mov $0x0,%edi
not %ebx
callq 91 <arch_teardown_msi_irq+0x91>
and %ebx,0x0(%rip)
mov $0x0,%edi
and %rbx,0x0(%rip)
pop %rbx
jmpq a9 <arch_teardown_msi_irq+0xa9>
nopl 0x0(%rax)
mov %ebx,%esi
mov $0x0,%edi
callq bc <arch_teardown_msi_irq+0xbc>
mov 0x0(%rip),%edx
jmpq 1d <arch_teardown_msi_irq+0x1d>
nopw 0x0(%rax,%rax,1)
00 00
mov $0x1,%ebx
jmp 6b <arch_teardown_msi_irq+0x6b>
| |
它的源代码可能是：void Snd_Memset (void* dest, const int val, const size_t count)
{
int *pDest;
int i, iterate;
if (!use_custom_memset)
{
Com_Memset(dest,val,count);
return;
}
iterate = count / sizeof(int);
pDest = (int*)dest;
for(i=0; i<iterate; i++)
{
pDest[i] = val;
}
} | 这是一段反汇编代码，它的源代码是什么？<Snd_Memset>:
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov 0x0(%rip),%eax
test %eax,%eax
jne 34 <Snd_Memset+0x34>
mov -0x28(%rbp),%rdx
mov -0x1c(%rbp),%ecx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 32 <Snd_Memset+0x32>
jmp 75 <Snd_Memset+0x75>
mov -0x28(%rbp),%rax
shr $0x2,%rax
mov %eax,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov %rax,-0x10(%rbp)
movl $0x0,-0x4(%rbp)
jmp 6d <Snd_Memset+0x6d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
00
mov -0x10(%rbp),%rax
add %rax,%rdx
mov -0x1c(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 50 <Snd_Memset+0x50>
leaveq
retq
| |
它的源代码可能是：void Snd_Memset (void* dest, const int val, const size_t count)
{
int *pDest;
int i, iterate;
if (!use_custom_memset)
{
Com_Memset(dest,val,count);
return;
}
iterate = count / sizeof(int);
pDest = (int*)dest;
for(i=0; i<iterate; i++)
{
pDest[i] = val;
}
} | 这是一段反汇编代码，它的源代码是什么？<Snd_Memset>:
cmpl $0x0,0x0(%rip)
je 28 <Snd_Memset+0x28>
shr $0x2,%rdx
test %edx,%edx
jle 36 <Snd_Memset+0x36>
mov %rdi,%rax
lea -0x1(%rdx),%edx
lea 0x4(%rdi,%rdx,4),%rdx
mov %esi,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1c <Snd_Memset+0x1c>
retq
sub $0x8,%rsp
callq 31 <Snd_Memset+0x31>
add $0x8,%rsp
retq
retq
| |
它的源代码可能是：void Snd_Memset (void* dest, const int val, const size_t count)
{
int *pDest;
int i, iterate;
if (!use_custom_memset)
{
Com_Memset(dest,val,count);
return;
}
iterate = count / sizeof(int);
pDest = (int*)dest;
for(i=0; i<iterate; i++)
{
pDest[i] = val;
}
} | 这是一段反汇编代码，它的源代码是什么？<Snd_Memset>:
mov 0x0(%rip),%eax
test %eax,%eax
je 30 <Snd_Memset+0x30>
shr $0x2,%rdx
test %edx,%edx
jle 2b <Snd_Memset+0x2b>
lea -0x1(%rdx),%eax
lea 0x4(%rdi,%rax,4),%rax
nopw 0x0(%rax,%rax,1)
mov %esi,(%rdi)
add $0x4,%rdi
cmp %rax,%rdi
jne 20 <Snd_Memset+0x20>
retq
nopl 0x0(%rax)
jmpq 35 <Snd_Memset+0x35>
| |
它的源代码可能是：void Snd_Memset (void* dest, const int val, const size_t count)
{
int *pDest;
int i, iterate;
if (!use_custom_memset)
{
Com_Memset(dest,val,count);
return;
}
iterate = count / sizeof(int);
pDest = (int*)dest;
for(i=0; i<iterate; i++)
{
pDest[i] = val;
}
} | 这是一段反汇编代码，它的源代码是什么？<Snd_Memset>:
mov 0x0(%rip),%eax
test %eax,%eax
je 78 <Snd_Memset+0x78>
shr $0x2,%rdx
test %edx,%edx
jle 74 <Snd_Memset+0x74>
lea -0x1(%rdx),%eax
cmp $0x2,%eax
jbe 81 <Snd_Memset+0x81>
mov %edx,%ecx
mov %esi,-0xc(%rsp)
movd -0xc(%rsp),%xmm1
mov %rdi,%rax
shr $0x2,%ecx
shl $0x4,%rcx
pshufd $0x0,%xmm1,%xmm0
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
00
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rcx,%rax
jne 40 <Snd_Memset+0x40>
mov %edx,%eax
and $0xfffffffc,%eax
cmp %eax,%edx
je 80 <Snd_Memset+0x80>
movslq %eax,%rcx
mov %esi,(%rdi,%rcx,4)
lea 0x1(%rax),%ecx
cmp %ecx,%edx
jle 74 <Snd_Memset+0x74>
movslq %ecx,%rcx
add $0x2,%eax
mov %esi,(%rdi,%rcx,4)
cmp %eax,%edx
jle 74 <Snd_Memset+0x74>
cltq
mov %esi,(%rdi,%rax,4)
retq
nopl (%rax)
jmpq 7d <Snd_Memset+0x7d>
nopl (%rax)
retq
xor %eax,%eax
jmp 55 <Snd_Memset+0x55>
| |
它的源代码可能是：static void sossi_stop_transfer(void)
{
/* WE */
sossi_set_bits(SOSSI_INIT2_REG, 1 << 4);
/* CS active low */
sossi_set_bits(SOSSI_INIT1_REG, 1 << 30);
} | 这是一段反汇编代码，它的源代码是什么？<sossi_stop_transfer>:
push %rbp
mov %rsp,%rbp
mov 0x0(%rip),%eax
mov $0x10,%esi
mov %eax,%edi
callq 16 <sossi_stop_transfer+0x16>
mov 0x0(%rip),%eax
mov $0x40000000,%esi
mov %eax,%edi
callq 28 <sossi_stop_transfer+0x28>
nop
pop %rbp
retq
| |
它的源代码可能是：static void sossi_stop_transfer(void)
{
/* WE */
sossi_set_bits(SOSSI_INIT2_REG, 1 << 4);
/* CS active low */
sossi_set_bits(SOSSI_INIT1_REG, 1 << 30);
} | 这是一段反汇编代码，它的源代码是什么？<sossi_stop_transfer>:
sub $0x8,%rsp
mov $0x10,%esi
mov 0x0(%rip),%edi
callq 14 <sossi_stop_transfer+0x14>
mov $0x40000000,%esi
mov 0x0(%rip),%edi
callq 24 <sossi_stop_transfer+0x24>
add $0x8,%rsp
retq
| |
它的源代码可能是：static void sossi_stop_transfer(void)
{
/* WE */
sossi_set_bits(SOSSI_INIT2_REG, 1 << 4);
/* CS active low */
sossi_set_bits(SOSSI_INIT1_REG, 1 << 30);
} | 这是一段反汇编代码，它的源代码是什么？<sossi_stop_transfer>:
sub $0x8,%rsp
mov 0x0(%rip),%edi
mov $0x10,%esi
callq 14 <sossi_stop_transfer+0x14>
mov 0x0(%rip),%edi
mov $0x40000000,%esi
add $0x8,%rsp
jmpq 28 <sossi_stop_transfer+0x28>
| |
它的源代码可能是：static void sossi_stop_transfer(void)
{
/* WE */
sossi_set_bits(SOSSI_INIT2_REG, 1 << 4);
/* CS active low */
sossi_set_bits(SOSSI_INIT1_REG, 1 << 30);
} | 这是一段反汇编代码，它的源代码是什么？<sossi_stop_transfer>:
sub $0x8,%rsp
mov 0x0(%rip),%edi
mov $0x10,%esi
callq 14 <sossi_stop_transfer+0x14>
mov 0x0(%rip),%edi
mov $0x40000000,%esi
add $0x8,%rsp
jmpq 28 <sossi_stop_transfer+0x28>
| |
它的源代码可能是：static void bnx2x_8481_link_reset(struct bnx2x_phy *phy,
struct link_params *params)
{
bnx2x_cl45_write(params->bp, phy,
MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x0000);
bnx2x_cl45_write(params->bp, phy,
MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1);
} | 这是一段反汇编代码，它的源代码是什么？<bnx2x_8481_link_reset>:
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
mov 0x0(%rip),%ecx
mov 0x0(%rip),%edx
mov -0x10(%rbp),%rax
mov (%rax),%eax
mov -0x8(%rbp),%rsi
mov $0x0,%r8d
mov %eax,%edi
callq 33 <bnx2x_8481_link_reset+0x33>
mov 0x0(%rip),%ecx
mov 0x0(%rip),%edx
mov -0x10(%rbp),%rax
mov (%rax),%eax
mov -0x8(%rbp),%rsi
mov $0x1,%r8d
mov %eax,%edi
callq 56 <bnx2x_8481_link_reset+0x56>
nop
leaveq
retq
| |
它的源代码可能是：static void bnx2x_8481_link_reset(struct bnx2x_phy *phy,
struct link_params *params)
{
bnx2x_cl45_write(params->bp, phy,
MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x0000);
bnx2x_cl45_write(params->bp, phy,
MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1);
} | 这是一段反汇编代码，它的源代码是什么？<bnx2x_8481_link_reset>:
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov $0x0,%r8d
mov 0x0(%rip),%ecx
mov 0x0(%rip),%edx
mov %rdi,%rsi
mov (%rbx),%edi
callq 28 <bnx2x_8481_link_reset+0x28>
mov $0x1,%r8d
mov 0x0(%rip),%ecx
mov 0x0(%rip),%edx
mov %rbp,%rsi
mov (%rbx),%edi
callq 44 <bnx2x_8481_link_reset+0x44>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| |
它的源代码可能是：static void bnx2x_8481_link_reset(struct bnx2x_phy *phy,
struct link_params *params)
{
bnx2x_cl45_write(params->bp, phy,
MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x0000);
bnx2x_cl45_write(params->bp, phy,
MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1);
} | 这是一段反汇编代码，它的源代码是什么？<bnx2x_8481_link_reset>:
push %rbp
mov %rdi,%rbp
xor %r8d,%r8d
push %rbx
mov %rsi,%rbx
mov %rdi,%rsi
sub $0x8,%rsp
mov (%rbx),%edi
mov 0x0(%rip),%ecx
mov 0x0(%rip),%edx
callq 25 <bnx2x_8481_link_reset+0x25>
mov (%rbx),%edi
mov 0x0(%rip),%ecx
mov %rbp,%rsi
mov 0x0(%rip),%edx
add $0x8,%rsp
mov $0x1,%r8d
pop %rbx
pop %rbp
jmpq 47 <bnx2x_8481_link_reset+0x47>
| |
它的源代码可能是：static void bnx2x_8481_link_reset(struct bnx2x_phy *phy,
struct link_params *params)
{
bnx2x_cl45_write(params->bp, phy,
MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x0000);
bnx2x_cl45_write(params->bp, phy,
MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1);
} | 这是一段反汇编代码，它的源代码是什么？<bnx2x_8481_link_reset>:
push %rbp
mov %rdi,%rbp
xor %r8d,%r8d
push %rbx
mov %rsi,%rbx
mov %rdi,%rsi
sub $0x8,%rsp
mov (%rbx),%edi
mov 0x0(%rip),%ecx
mov 0x0(%rip),%edx
callq 25 <bnx2x_8481_link_reset+0x25>
mov (%rbx),%edi
mov 0x0(%rip),%ecx
mov %rbp,%rsi
mov 0x0(%rip),%edx
add $0x8,%rsp
mov $0x1,%r8d
pop %rbx
pop %rbp
jmpq 47 <bnx2x_8481_link_reset+0x47>
| |
它的源代码可能是：static int dump_sp(struct xfrm_policy *xp, int dir, int count, void *ptr)
{
struct pfkey_sock *pfk = ptr;
struct sk_buff *out_skb;
struct sadb_msg *out_hdr;
int err;
if (!pfkey_can_dump(&pfk->sk))
return -ENOBUFS;
out_skb = pfkey_xfrm_policy2msg_prep(xp);
if (IS_ERR(out_skb))
return PTR_ERR(out_skb);
err = pfkey_xfrm_policy2msg(out_skb, xp, dir);
if (err < 0)
return err;
out_hdr = (struct sadb_msg *) out_skb->data;
out_hdr->sadb_msg_version = pfk->dump.msg_version;
out_hdr->sadb_msg_type = SADB_X_SPDDUMP;
out_hdr->sadb_msg_satype = SADB_SATYPE_UNSPEC;
out_hdr->sadb_msg_errno = 0;
out_hdr->sadb_msg_seq = count + 1;
out_hdr->sadb_msg_pid = pfk->dump.msg_pid;
if (pfk->dump.skb)
pfkey_broadcast(pfk->dump.skb, GFP_ATOMIC, BROADCAST_ONE,
&pfk->sk, sock_net(&pfk->sk));
pfk->dump.skb = out_skb;
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<dump_sp>:
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
add $0x10,%rax
mov %rax,%rdi
callq 2e <dump_sp+0x2e>
test %eax,%eax
jne 3f <dump_sp+0x3f>
mov 0x0(%rip),%eax
neg %eax
jmpq 145 <dump_sp+0x145>
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 4b <dump_sp+0x4b>
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 5b <dump_sp+0x5b>
test %rax,%rax
je 71 <dump_sp+0x71>
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 6c <dump_sp+0x6c>
jmpq 145 <dump_sp+0x145>
mov -0x2c(%rbp),%edx
mov -0x28(%rbp),%rcx
mov -0x10(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 87 <dump_sp+0x87>
mov %eax,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jns 98 <dump_sp+0x98>
mov -0x14(%rbp),%eax
jmpq 145 <dump_sp+0x145>
mov -0x10(%rbp),%rax
mov (%rax),%rax
mov %rax,-0x20(%rbp)
mov -0x8(%rbp),%rax
mov 0xc(%rax),%edx
mov -0x20(%rbp),%rax
mov %edx,0x18(%rax)
mov 0x0(%rip),%edx
mov -0x20(%rbp),%rax
mov %edx,0x14(%rax)
mov 0x0(%rip),%edx
mov -0x20(%rbp),%rax
mov %edx,0x10(%rax)
mov -0x20(%rbp),%rax
movq $0x0,0x8(%rax)
00
mov -0x30(%rbp),%eax
lea 0x1(%rax),%edx
mov -0x20(%rbp),%rax
mov %edx,(%rax)
mov -0x8(%rbp),%rax
mov 0x8(%rax),%edx
mov -0x20(%rbp),%rax
mov %edx,0x4(%rax)
mov -0x8(%rbp),%rax
mov (%rax),%rax
test %rax,%rax
je 135 <dump_sp+0x135>
mov -0x8(%rbp),%rax
add $0x10,%rax
mov %rax,%rdi
callq 10d <dump_sp+0x10d>
mov %eax,%edi
mov -0x8(%rbp),%rax
lea 0x10(%rax),%rcx
mov 0x0(%rip),%edx
mov 0x0(%rip),%esi
mov -0x8(%rbp),%rax
mov (%rax),%rax
mov %edi,%r8d
mov %rax,%rdi
callq 135 <dump_sp+0x135>
mov -0x8(%rbp),%rax
mov -0x10(%rbp),%rdx
mov %rdx,(%rax)
mov $0x0,%eax
leaveq
retq
| |
它的源代码可能是：static int dump_sp(struct xfrm_policy *xp, int dir, int count, void *ptr)
{
struct pfkey_sock *pfk = ptr;
struct sk_buff *out_skb;
struct sadb_msg *out_hdr;
int err;
if (!pfkey_can_dump(&pfk->sk))
return -ENOBUFS;
out_skb = pfkey_xfrm_policy2msg_prep(xp);
if (IS_ERR(out_skb))
return PTR_ERR(out_skb);
err = pfkey_xfrm_policy2msg(out_skb, xp, dir);
if (err < 0)
return err;
out_hdr = (struct sadb_msg *) out_skb->data;
out_hdr->sadb_msg_version = pfk->dump.msg_version;
out_hdr->sadb_msg_type = SADB_X_SPDDUMP;
out_hdr->sadb_msg_satype = SADB_SATYPE_UNSPEC;
out_hdr->sadb_msg_errno = 0;
out_hdr->sadb_msg_seq = count + 1;
out_hdr->sadb_msg_pid = pfk->dump.msg_pid;
if (pfk->dump.skb)
pfkey_broadcast(pfk->dump.skb, GFP_ATOMIC, BROADCAST_ONE,
&pfk->sk, sock_net(&pfk->sk));
pfk->dump.skb = out_skb;
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<dump_sp>:
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%r15d
mov %edx,%r14d
mov %rcx,%rbx
lea 0x10(%rcx),%rbp
mov %rbp,%rdi
callq 26 <dump_sp+0x26>
test %eax,%eax
jne 41 <dump_sp+0x41>
mov 0x0(%rip),%eax
neg %eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %r13,%rdi
callq 49 <dump_sp+0x49>
mov %rax,%r12
mov %rax,%rdi
callq 54 <dump_sp+0x54>
test %rax,%rax
jne d1 <dump_sp+0xd1>
mov %r15d,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 67 <dump_sp+0x67>
test %eax,%eax
js 32 <dump_sp+0x32>
mov (%r12),%rax
mov 0xc(%rbx),%edx
mov %edx,0x18(%rax)
mov 0x0(%rip),%edx
mov %edx,0x14(%rax)
mov 0x0(%rip),%edx
mov %edx,0x10(%rax)
movq $0x0,0x8(%rax)
00
add $0x1,%r14d
mov %r14d,(%rax)
mov 0x8(%rbx),%edx
mov %edx,0x4(%rax)
cmpq $0x0,(%rbx)
je c4 <dump_sp+0xc4>
mov %rbp,%rdi
callq aa <dump_sp+0xaa>
mov %eax,%r8d
mov %rbp,%rcx
mov 0x0(%rip),%edx
mov 0x0(%rip),%esi
mov (%rbx),%rdi
callq c4 <dump_sp+0xc4>
mov %r12,(%rbx)
mov $0x0,%eax
jmpq 32 <dump_sp+0x32>
mov %r12,%rdi
callq d9 <dump_sp+0xd9>
jmpq 32 <dump_sp+0x32>
| |
它的源代码可能是：static int dump_sp(struct xfrm_policy *xp, int dir, int count, void *ptr)
{
struct pfkey_sock *pfk = ptr;
struct sk_buff *out_skb;
struct sadb_msg *out_hdr;
int err;
if (!pfkey_can_dump(&pfk->sk))
return -ENOBUFS;
out_skb = pfkey_xfrm_policy2msg_prep(xp);
if (IS_ERR(out_skb))
return PTR_ERR(out_skb);
err = pfkey_xfrm_policy2msg(out_skb, xp, dir);
if (err < 0)
return err;
out_hdr = (struct sadb_msg *) out_skb->data;
out_hdr->sadb_msg_version = pfk->dump.msg_version;
out_hdr->sadb_msg_type = SADB_X_SPDDUMP;
out_hdr->sadb_msg_satype = SADB_SATYPE_UNSPEC;
out_hdr->sadb_msg_errno = 0;
out_hdr->sadb_msg_seq = count + 1;
out_hdr->sadb_msg_pid = pfk->dump.msg_pid;
if (pfk->dump.skb)
pfkey_broadcast(pfk->dump.skb, GFP_ATOMIC, BROADCAST_ONE,
&pfk->sk, sock_net(&pfk->sk));
pfk->dump.skb = out_skb;
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<dump_sp>:
push %r15
mov %esi,%r15d
push %r14
mov %edx,%r14d
push %r13
mov %rdi,%r13
push %r12
push %rbp
lea 0x10(%rcx),%rbp
push %rbx
mov %rbp,%rdi
mov %rcx,%rbx
sub $0x8,%rsp
callq 26 <dump_sp+0x26>
test %eax,%eax
jne 48 <dump_sp+0x48>
mov 0x0(%rip),%eax
neg %eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %r13,%rdi
callq 50 <dump_sp+0x50>
mov %rax,%rdi
mov %rax,%r12
callq 5b <dump_sp+0x5b>
test %rax,%rax
jne e8 <dump_sp+0xe8>
mov %r15d,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 72 <dump_sp+0x72>
test %eax,%eax
js 32 <dump_sp+0x32>
mov 0xc(%rbx),%edx
mov (%r12),%rax
add $0x1,%r14d
cmpq $0x0,(%rbx)
mov %edx,0x18(%rax)
mov 0x0(%rip),%edx
movq $0x0,0x8(%rax)
00
mov %edx,0x14(%rax)
mov 0x0(%rip),%edx
mov %r14d,(%rax)
mov %edx,0x10(%rax)
mov 0x8(%rbx),%edx
mov %edx,0x4(%rax)
je cf <dump_sp+0xcf>
mov %rbp,%rdi
callq b5 <dump_sp+0xb5>
mov 0x0(%rip),%edx
mov (%rbx),%rdi
mov %rbp,%rcx
mov 0x0(%rip),%esi
mov %eax,%r8d
callq cf <dump_sp+0xcf>
mov %r12,(%rbx)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
add $0x8,%rsp
mov %r12,%rdi
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
jmpq fe <dump_sp+0xfe>
| |
它的源代码可能是：static int dump_sp(struct xfrm_policy *xp, int dir, int count, void *ptr)
{
struct pfkey_sock *pfk = ptr;
struct sk_buff *out_skb;
struct sadb_msg *out_hdr;
int err;
if (!pfkey_can_dump(&pfk->sk))
return -ENOBUFS;
out_skb = pfkey_xfrm_policy2msg_prep(xp);
if (IS_ERR(out_skb))
return PTR_ERR(out_skb);
err = pfkey_xfrm_policy2msg(out_skb, xp, dir);
if (err < 0)
return err;
out_hdr = (struct sadb_msg *) out_skb->data;
out_hdr->sadb_msg_version = pfk->dump.msg_version;
out_hdr->sadb_msg_type = SADB_X_SPDDUMP;
out_hdr->sadb_msg_satype = SADB_SATYPE_UNSPEC;
out_hdr->sadb_msg_errno = 0;
out_hdr->sadb_msg_seq = count + 1;
out_hdr->sadb_msg_pid = pfk->dump.msg_pid;
if (pfk->dump.skb)
pfkey_broadcast(pfk->dump.skb, GFP_ATOMIC, BROADCAST_ONE,
&pfk->sk, sock_net(&pfk->sk));
pfk->dump.skb = out_skb;
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<dump_sp>:
push %r15
mov %esi,%r15d
push %r14
mov %edx,%r14d
push %r13
mov %rdi,%r13
push %r12
push %rbp
lea 0x10(%rcx),%rbp
push %rbx
mov %rbp,%rdi
mov %rcx,%rbx
sub $0x8,%rsp
callq 26 <dump_sp+0x26>
test %eax,%eax
jne 48 <dump_sp+0x48>
mov 0x0(%rip),%eax
neg %eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %r13,%rdi
callq 50 <dump_sp+0x50>
mov %rax,%rdi
mov %rax,%r12
callq 5b <dump_sp+0x5b>
test %rax,%rax
jne e8 <dump_sp+0xe8>
mov %r15d,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 72 <dump_sp+0x72>
test %eax,%eax
js 32 <dump_sp+0x32>
mov 0xc(%rbx),%edx
mov (%r12),%rax
add $0x1,%r14d
cmpq $0x0,(%rbx)
mov %edx,0x18(%rax)
mov 0x0(%rip),%edx
movq $0x0,0x8(%rax)
00
mov %edx,0x14(%rax)
mov 0x0(%rip),%edx
mov %r14d,(%rax)
mov %edx,0x10(%rax)
mov 0x8(%rbx),%edx
mov %edx,0x4(%rax)
je cf <dump_sp+0xcf>
mov %rbp,%rdi
callq b5 <dump_sp+0xb5>
mov 0x0(%rip),%edx
mov (%rbx),%rdi
mov %rbp,%rcx
mov 0x0(%rip),%esi
mov %eax,%r8d
callq cf <dump_sp+0xcf>
mov %r12,(%rbx)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
add $0x8,%rsp
mov %r12,%rdi
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
jmpq fe <dump_sp+0xfe>
| |
它的源代码可能是：static struct i2o_scsi_host *i2o_scsi_get_host(struct i2o_controller *c)
{
return c->driver_data[i2o_scsi_driver.context];
} | 这是一段反汇编代码，它的源代码是什么？<i2o_scsi_get_host>:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov -0x8(%rbp),%rax
mov (%rax),%rax
mov 0x0(%rip),%rdx
shl $0x3,%rdx
add %rdx,%rax
mov (%rax),%rax
pop %rbp
retq
| |
它的源代码可能是：static struct i2o_scsi_host *i2o_scsi_get_host(struct i2o_controller *c)
{
return c->driver_data[i2o_scsi_driver.context];
} | 这是一段反汇编代码，它的源代码是什么？<i2o_scsi_get_host>:
mov (%rdi),%rax
mov 0x0(%rip),%rdx
mov (%rax,%rdx,8),%rax
retq
| |
它的源代码可能是：static struct i2o_scsi_host *i2o_scsi_get_host(struct i2o_controller *c)
{
return c->driver_data[i2o_scsi_driver.context];
} | 这是一段反汇编代码，它的源代码是什么？<i2o_scsi_get_host>:
mov (%rdi),%rax
mov 0x0(%rip),%rdx
mov (%rax,%rdx,8),%rax
retq
| |
它的源代码可能是：static struct i2o_scsi_host *i2o_scsi_get_host(struct i2o_controller *c)
{
return c->driver_data[i2o_scsi_driver.context];
} | 这是一段反汇编代码，它的源代码是什么？<i2o_scsi_get_host>:
mov (%rdi),%rax
mov 0x0(%rip),%rdx
mov (%rax,%rdx,8),%rax
retq
| |
它的源代码可能是：int main()
{
printf("len:%d bytes\n", strlen(code));
(*(void(*)()) code)();
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<main>:
push %rbp
mov %rsp,%rbp
mov 0x0(%rip),%rax
mov %rax,%rdi
callq 13 <main+0x13>
mov %eax,%esi
mov $0x0,%edi
callq 1f <main+0x1f>
mov 0x0(%rip),%rax
mov %rax,%rdx
mov $0x0,%eax
callq *%rdx
mov $0x0,%eax
pop %rbp
retq
| |
它的源代码可能是：int main()
{
printf("len:%d bytes\n", strlen(code));
(*(void(*)()) code)();
return 0;
} | 这是一段反汇编代码，它的源代码是什么？<main>:
sub $0x8,%rsp
mov 0x0(%rip),%rdi
callq 10 <main+0x10>
mov %eax,%esi
mov $0x0,%edi
callq 1c <main+0x1c>
mov $0x0,%eax
callq *0x0(%rip)
mov $0x0,%eax
add $0x8,%rsp
retq
| |
它的源代码可能是：int main()
{
printf("len:%d bytes\n", strlen(code));
(*(void(*)()) code)();
return 0;
} | 这是一段反汇编代码，它的源代码是什么？/data/workspace/github/AnghaBench/exploitdb/shellcodes/superh_sh4/extr_43542_main_O2.o: file format elf64-x86-64
Disassembly of section .text.startup:
0000000000000000 <main>:
sub $0x8,%rsp
mov 0x0(%rip),%rdi
callq 10 <main+0x10>
mov $0x0,%edi
mov %eax,%esi
callq 1c <main+0x1c>
xor %eax,%eax
callq *0x0(%rip)
xor %eax,%eax
add $0x8,%rsp
retq
| |
它的源代码可能是：int main()
{
printf("len:%d bytes\n", strlen(code));
(*(void(*)()) code)();
return 0;
} | 这是一段反汇编代码，它的源代码是什么？/data/workspace/github/AnghaBench/exploitdb/shellcodes/superh_sh4/extr_43542_main_O3.o: file format elf64-x86-64
Disassembly of section .text.startup:
0000000000000000 <main>:
sub $0x8,%rsp
mov 0x0(%rip),%rdi
callq 10 <main+0x10>
mov $0x0,%edi
mov %eax,%esi
callq 1c <main+0x1c>
xor %eax,%eax
callq *0x0(%rip)
xor %eax,%eax
add $0x8,%rsp
retq
| |
它的源代码可能是：static int iwl_request_firmware(struct iwl_drv *drv, bool first)
{
const char *name_pre = drv->cfg->fw_name_pre;
char tag[8];
if (first) {
#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
drv->fw_index = UCODE_EXPERIMENTAL_INDEX;
strcpy(tag, UCODE_EXPERIMENTAL_TAG);
} else if (drv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
#endif
drv->fw_index = drv->cfg->ucode_api_max;
sprintf(tag, "%d", drv->fw_index);
} else {
drv->fw_index--;
sprintf(tag, "%d", drv->fw_index);
}
if (drv->fw_index < drv->cfg->ucode_api_min) {
IWL_ERR(drv, "no suitable firmware found!\n");
return -ENOENT;
}
sprintf(drv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
IWL_DEBUG_INFO(drv, "attempting to load firmware %s'%s'\n",
(drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
? "EXPERIMENTAL " : "",
drv->firmware_name);
return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
drv->trans->dev,
GFP_KERNEL, drv, iwl_req_fw_callback);
} | 这是一段反汇编代码，它的源代码是什么？<iwl_request_firmware>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov 0x18(%rax),%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
cmpl $0x0,-0x1c(%rbp)
je 53 <iwl_request_firmware+0x53>
mov -0x18(%rbp),%rax
mov 0x18(%rax),%rax
mov 0x8(%rax),%edx
mov -0x18(%rbp),%rax
mov %edx,(%rax)
mov -0x18(%rbp),%rax
mov (%rax),%edx
lea -0x10(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
mov $0x0,%eax
callq 51 <iwl_request_firmware+0x51>
jmp 7e <iwl_request_firmware+0x7e>
mov -0x18(%rbp),%rax
mov (%rax),%eax
lea -0x1(%rax),%edx
mov -0x18(%rbp),%rax
mov %edx,(%rax)
mov -0x18(%rbp),%rax
mov (%rax),%edx
lea -0x10(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
mov $0x0,%eax
callq 7e <iwl_request_firmware+0x7e>
mov -0x18(%rbp),%rax
mov (%rax),%edx
mov -0x18(%rbp),%rax
mov 0x18(%rax),%rax
mov 0xc(%rax),%eax
cmp %eax,%edx
jge b1 <iwl_request_firmware+0xb1>
mov -0x18(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq a4 <iwl_request_firmware+0xa4>
mov 0x0(%rip),%eax
neg %eax
jmpq 15b <iwl_request_firmware+0x15b>
mov -0x18(%rbp),%rax
mov 0x10(%rax),%eax
cltq
mov %rax,%rdi
lea -0x10(%rbp),%rdx
mov -0x8(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov %rax,%rdx
mov $0x0,%esi
mov $0x0,%eax
callq e0 <iwl_request_firmware+0xe0>
mov -0x18(%rbp),%rax
mov 0x10(%rax),%edx
mov -0x18(%rbp),%rax
mov (%rax),%ecx
mov 0x0(%rip),%eax
cmp %eax,%ecx
jne fe <iwl_request_firmware+0xfe>
mov $0x0,%esi
jmp 103 <iwl_request_firmware+0x103>
mov $0x0,%esi
mov -0x18(%rbp),%rax
mov %edx,%ecx
mov %rsi,%rdx
mov $0x0,%esi
mov %rax,%rdi
callq 119 <iwl_request_firmware+0x119>
mov 0x0(%rip),%esi
mov 0x0(%rip),%edi
mov -0x18(%rbp),%rax
mov 0x8(%rax),%rax
mov (%rax),%ecx
mov -0x18(%rbp),%rax
mov 0x10(%rax),%edx
mov 0x0(%rip),%eax
mov -0x18(%rbp),%r8
sub $0x8,%rsp
push %rsi
mov %r8,%r9
mov %edi,%r8d
mov $0x1,%esi
mov %eax,%edi
callq 157 <iwl_request_firmware+0x157>
add $0x10,%rsp
leaveq
retq
| |
它的源代码可能是：static int iwl_request_firmware(struct iwl_drv *drv, bool first)
{
const char *name_pre = drv->cfg->fw_name_pre;
char tag[8];
if (first) {
#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
drv->fw_index = UCODE_EXPERIMENTAL_INDEX;
strcpy(tag, UCODE_EXPERIMENTAL_TAG);
} else if (drv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
#endif
drv->fw_index = drv->cfg->ucode_api_max;
sprintf(tag, "%d", drv->fw_index);
} else {
drv->fw_index--;
sprintf(tag, "%d", drv->fw_index);
}
if (drv->fw_index < drv->cfg->ucode_api_min) {
IWL_ERR(drv, "no suitable firmware found!\n");
return -ENOENT;
}
sprintf(drv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
IWL_DEBUG_INFO(drv, "attempting to load firmware %s'%s'\n",
(drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
? "EXPERIMENTAL " : "",
drv->firmware_name);
return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
drv->trans->dev,
GFP_KERNEL, drv, iwl_req_fw_callback);
} | 这是一段反汇编代码，它的源代码是什么？<iwl_request_firmware>:
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov 0x18(%rdi),%rax
mov (%rax),%rbp
test %esi,%esi
je c0 <iwl_request_firmware+0xc0>
mov 0x8(%rax),%edx
mov %edx,(%rdi)
mov $0x0,%esi
lea 0x8(%rsp),%rdi
mov $0x0,%eax
callq 31 <iwl_request_firmware+0x31>
mov 0x18(%rbx),%rax
mov 0xc(%rax),%eax
cmp %eax,(%rbx)
jl e0 <iwl_request_firmware+0xe0>
movslq 0x10(%rbx),%rdi
mov $0x0,%r8d
lea 0x8(%rsp),%rcx
mov %rbp,%rdx
mov $0x0,%esi
mov $0x0,%eax
callq 61 <iwl_request_firmware+0x61>
mov 0x10(%rbx),%ecx
mov (%rbx),%eax
cmp 0x0(%rip),%eax
mov $0x0,%edx
mov $0x0,%eax
cmovne %rax,%rdx
mov $0x0,%esi
mov %rbx,%rdi
callq 87 <iwl_request_firmware+0x87>
mov 0x8(%rbx),%rax
mov 0x10(%rbx),%edx
sub $0x8,%rsp
mov 0x0(%rip),%ecx
push %rcx
mov %rbx,%r9
mov 0x0(%rip),%r8d
mov (%rax),%ecx
mov $0x1,%esi
mov 0x0(%rip),%edi
callq b5 <iwl_request_firmware+0xb5>
add $0x10,%rsp
add $0x18,%rsp
pop %rbx
pop %rbp
retq
mov (%rdi),%eax
lea -0x1(%rax),%edx
mov %edx,(%rdi)
mov $0x0,%esi
lea 0x8(%rsp),%rdi
mov $0x0,%eax
callq db <iwl_request_firmware+0xdb>
jmpq 31 <iwl_request_firmware+0x31>
mov $0x0,%esi
mov %rbx,%rdi
callq ed <iwl_request_firmware+0xed>
mov 0x0(%rip),%eax
neg %eax
jmp b9 <iwl_request_firmware+0xb9>
| |
它的源代码可能是：static int iwl_request_firmware(struct iwl_drv *drv, bool first)
{
const char *name_pre = drv->cfg->fw_name_pre;
char tag[8];
if (first) {
#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
drv->fw_index = UCODE_EXPERIMENTAL_INDEX;
strcpy(tag, UCODE_EXPERIMENTAL_TAG);
} else if (drv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
#endif
drv->fw_index = drv->cfg->ucode_api_max;
sprintf(tag, "%d", drv->fw_index);
} else {
drv->fw_index--;
sprintf(tag, "%d", drv->fw_index);
}
if (drv->fw_index < drv->cfg->ucode_api_min) {
IWL_ERR(drv, "no suitable firmware found!\n");
return -ENOENT;
}
sprintf(drv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
IWL_DEBUG_INFO(drv, "attempting to load firmware %s'%s'\n",
(drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
? "EXPERIMENTAL " : "",
drv->firmware_name);
return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
drv->trans->dev,
GFP_KERNEL, drv, iwl_req_fw_callback);
} | 这是一段反汇编代码，它的源代码是什么？<iwl_request_firmware>:
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x10,%rsp
mov 0x18(%rdi),%rax
mov (%rax),%r12
test %esi,%esi
je c0 <iwl_request_firmware+0xc0>
mov 0x8(%rax),%edx
mov %edx,(%rbx)
lea 0x8(%rsp),%rbp
mov $0x0,%esi
xor %eax,%eax
mov %rbp,%rdi
callq 33 <iwl_request_firmware+0x33>
mov 0x18(%rbx),%rax
mov 0xc(%rax),%eax
cmp %eax,(%rbx)
jl d0 <iwl_request_firmware+0xd0>
movslq 0x10(%rbx),%rdi
mov $0x0,%r8d
mov %rbp,%rcx
mov %r12,%rdx
mov $0x0,%esi
xor %eax,%eax
callq 5e <iwl_request_firmware+0x5e>
mov $0x0,%edx
mov 0x10(%rbx),%ecx
mov %rbx,%rdi
mov 0x0(%rip),%eax
cmp %eax,(%rbx)
mov $0x0,%eax
mov $0x0,%esi
cmovne %rax,%rdx
callq 84 <iwl_request_firmware+0x84>
sub $0x8,%rsp
mov 0x8(%rbx),%rax
mov 0x10(%rbx),%edx
mov 0x0(%rip),%ecx
mov 0x0(%rip),%r8d
mov %rbx,%r9
mov $0x1,%esi
mov 0x0(%rip),%edi
push %rcx
mov (%rax),%ecx
callq b2 <iwl_request_firmware+0xb2>
pop %rdx
pop %rcx
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
retq
nopl (%rax)
mov (%rdi),%eax
lea -0x1(%rax),%edx
jmpq 1d <iwl_request_firmware+0x1d>
nopw 0x0(%rax,%rax,1)
mov %rbx,%rdi
mov $0x0,%esi
callq dd <iwl_request_firmware+0xdd>
mov 0x0(%rip),%eax
add $0x10,%rsp
pop %rbx
pop %rbp
neg %eax
pop %r12
retq
| |
它的源代码可能是：static int iwl_request_firmware(struct iwl_drv *drv, bool first)
{
const char *name_pre = drv->cfg->fw_name_pre;
char tag[8];
if (first) {
#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
drv->fw_index = UCODE_EXPERIMENTAL_INDEX;
strcpy(tag, UCODE_EXPERIMENTAL_TAG);
} else if (drv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
#endif
drv->fw_index = drv->cfg->ucode_api_max;
sprintf(tag, "%d", drv->fw_index);
} else {
drv->fw_index--;
sprintf(tag, "%d", drv->fw_index);
}
if (drv->fw_index < drv->cfg->ucode_api_min) {
IWL_ERR(drv, "no suitable firmware found!\n");
return -ENOENT;
}
sprintf(drv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
IWL_DEBUG_INFO(drv, "attempting to load firmware %s'%s'\n",
(drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
? "EXPERIMENTAL " : "",
drv->firmware_name);
return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
drv->trans->dev,
GFP_KERNEL, drv, iwl_req_fw_callback);
} | 这是一段反汇编代码，它的源代码是什么？<iwl_request_firmware>:
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x10,%rsp
mov 0x18(%rdi),%rax
mov (%rax),%r12
test %esi,%esi
je c0 <iwl_request_firmware+0xc0>
mov 0x8(%rax),%edx
mov %edx,(%rbx)
lea 0x8(%rsp),%rbp
mov $0x0,%esi
xor %eax,%eax
mov %rbp,%rdi
callq 33 <iwl_request_firmware+0x33>
mov 0x18(%rbx),%rax
mov 0xc(%rax),%eax
cmp %eax,(%rbx)
jl d0 <iwl_request_firmware+0xd0>
movslq 0x10(%rbx),%rdi
mov $0x0,%r8d
mov %rbp,%rcx
mov %r12,%rdx
mov $0x0,%esi
xor %eax,%eax
callq 5e <iwl_request_firmware+0x5e>
mov $0x0,%edx
mov 0x10(%rbx),%ecx
mov %rbx,%rdi
mov 0x0(%rip),%eax
cmp %eax,(%rbx)
mov $0x0,%eax
mov $0x0,%esi
cmovne %rax,%rdx
callq 84 <iwl_request_firmware+0x84>
sub $0x8,%rsp
mov 0x8(%rbx),%rax
mov 0x10(%rbx),%edx
mov 0x0(%rip),%ecx
mov 0x0(%rip),%r8d
mov %rbx,%r9
mov $0x1,%esi
mov 0x0(%rip),%edi
push %rcx
mov (%rax),%ecx
callq b2 <iwl_request_firmware+0xb2>
pop %rdx
pop %rcx
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
retq
nopl (%rax)
mov (%rdi),%eax
lea -0x1(%rax),%edx
jmpq 1d <iwl_request_firmware+0x1d>
nopw 0x0(%rax,%rax,1)
mov %rbx,%rdi
mov $0x0,%esi
callq dd <iwl_request_firmware+0xdd>
mov 0x0(%rip),%eax
add $0x10,%rsp
pop %rbx
pop %rbp
neg %eax
pop %r12
retq
| |
它的源代码可能是：int raspicamcontrol_set_metering_mode(MMAL_COMPONENT_T *camera, MMAL_PARAM_EXPOSUREMETERINGMODE_T m_mode )
{
MMAL_PARAMETER_EXPOSUREMETERINGMODE_T meter_mode = {{MMAL_PARAMETER_EXP_METERING_MODE,sizeof(meter_mode)},
m_mode
};
if (!camera)
return 1;
return mmal_status_to_int(mmal_port_parameter_set(camera->control, &meter_mode.hdr));
} | 这是一段反汇编代码，它的源代码是什么？<raspicamcontrol_set_metering_mode>:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movq $0x0,-0x10(%rbp)
00
movq $0x0,-0x8(%rbp)
00
mov 0x0(%rip),%eax
mov %eax,-0x10(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0xc(%rbp)
cmpq $0x0,-0x18(%rbp)
jne 3c <raspicamcontrol_set_metering_mode+0x3c>
mov $0x1,%eax
jmp 57 <raspicamcontrol_set_metering_mode+0x57>
mov -0x18(%rbp),%rax
mov (%rax),%eax
lea -0x10(%rbp),%rdx
mov %rdx,%rsi
mov %eax,%edi
callq 50 <raspicamcontrol_set_metering_mode+0x50>
mov %eax,%edi
callq 57 <raspicamcontrol_set_metering_mode+0x57>
leaveq
retq
| |
它的源代码可能是：int raspicamcontrol_set_metering_mode(MMAL_COMPONENT_T *camera, MMAL_PARAM_EXPOSUREMETERINGMODE_T m_mode )
{
MMAL_PARAMETER_EXPOSUREMETERINGMODE_T meter_mode = {{MMAL_PARAMETER_EXP_METERING_MODE,sizeof(meter_mode)},
m_mode
};
if (!camera)
return 1;
return mmal_status_to_int(mmal_port_parameter_set(camera->control, &meter_mode.hdr));
} | 这是一段反汇编代码，它的源代码是什么？<raspicamcontrol_set_metering_mode>:
sub $0x18,%rsp
movq $0x0,0x8(%rsp)
00 00
mov 0x0(%rip),%eax
mov %eax,(%rsp)
mov %esi,0x4(%rsp)
mov $0x1,%eax
test %rdi,%rdi
je 35 <raspicamcontrol_set_metering_mode+0x35>
mov %rsp,%rsi
mov (%rdi),%edi
callq 2e <raspicamcontrol_set_metering_mode+0x2e>
mov %eax,%edi
callq 35 <raspicamcontrol_set_metering_mode+0x35>
add $0x18,%rsp
retq
| |
它的源代码可能是：int raspicamcontrol_set_metering_mode(MMAL_COMPONENT_T *camera, MMAL_PARAM_EXPOSUREMETERINGMODE_T m_mode )
{
MMAL_PARAMETER_EXPOSUREMETERINGMODE_T meter_mode = {{MMAL_PARAMETER_EXP_METERING_MODE,sizeof(meter_mode)},
m_mode
};
if (!camera)
return 1;
return mmal_status_to_int(mmal_port_parameter_set(camera->control, &meter_mode.hdr));
} | 这是一段反汇编代码，它的源代码是什么？<raspicamcontrol_set_metering_mode>:
sub $0x18,%rsp
mov 0x0(%rip),%eax
movq $0x0,0x8(%rsp)
00 00
mov %eax,(%rsp)
mov $0x1,%eax
mov %esi,0x4(%rsp)
test %rdi,%rdi
je 35 <raspicamcontrol_set_metering_mode+0x35>
mov (%rdi),%edi
mov %rsp,%rsi
callq 2e <raspicamcontrol_set_metering_mode+0x2e>
mov %eax,%edi
callq 35 <raspicamcontrol_set_metering_mode+0x35>
add $0x18,%rsp
retq
| |
它的源代码可能是：int raspicamcontrol_set_metering_mode(MMAL_COMPONENT_T *camera, MMAL_PARAM_EXPOSUREMETERINGMODE_T m_mode )
{
MMAL_PARAMETER_EXPOSUREMETERINGMODE_T meter_mode = {{MMAL_PARAMETER_EXP_METERING_MODE,sizeof(meter_mode)},
m_mode
};
if (!camera)
return 1;
return mmal_status_to_int(mmal_port_parameter_set(camera->control, &meter_mode.hdr));
} | 这是一段反汇编代码，它的源代码是什么？<raspicamcontrol_set_metering_mode>:
sub $0x18,%rsp
mov 0x0(%rip),%eax
movq $0x0,0x8(%rsp)
00 00
mov %eax,(%rsp)
mov $0x1,%eax
mov %esi,0x4(%rsp)
test %rdi,%rdi
je 35 <raspicamcontrol_set_metering_mode+0x35>
mov (%rdi),%edi
mov %rsp,%rsi
callq 2e <raspicamcontrol_set_metering_mode+0x2e>
mov %eax,%edi
callq 35 <raspicamcontrol_set_metering_mode+0x35>
add $0x18,%rsp
retq
| |
它的源代码可能是：static void
hostcache_prune(struct curl_hash *hostcache, long cache_timeout, time_t now)
{
struct hostcache_prune_data user;
user.cache_timeout = cache_timeout;
user.now = now;
Curl_hash_clean_with_criterium(hostcache,
(void *) &user,
hostcache_timestamp_remove);
} | 这是一段反汇编代码，它的源代码是什么？<hostcache_prune>:
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov -0x20(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x24(%rbp),%eax
mov %eax,-0x8(%rbp)
mov 0x0(%rip),%edx
lea -0x10(%rbp),%rcx
mov -0x18(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 3a <hostcache_prune+0x3a>
nop
leaveq
retq
| |
它的源代码可能是：static void
hostcache_prune(struct curl_hash *hostcache, long cache_timeout, time_t now)
{
struct hostcache_prune_data user;
user.cache_timeout = cache_timeout;
user.now = now;
Curl_hash_clean_with_criterium(hostcache,
(void *) &user,
hostcache_timestamp_remove);
} | 这是一段反汇编代码，它的源代码是什么？<hostcache_prune>:
sub $0x18,%rsp
mov %rsi,(%rsp)
mov %edx,0x8(%rsp)
mov 0x0(%rip),%edx
mov %rsp,%rsi
callq 1a <hostcache_prune+0x1a>
add $0x18,%rsp
retq
| |
它的源代码可能是：static void
hostcache_prune(struct curl_hash *hostcache, long cache_timeout, time_t now)
{
struct hostcache_prune_data user;
user.cache_timeout = cache_timeout;
user.now = now;
Curl_hash_clean_with_criterium(hostcache,
(void *) &user,
hostcache_timestamp_remove);
} | 这是一段反汇编代码，它的源代码是什么？<hostcache_prune>:
sub $0x18,%rsp
mov %edx,0x8(%rsp)
mov 0x0(%rip),%edx
mov %rsi,(%rsp)
mov %rsp,%rsi
callq 1a <hostcache_prune+0x1a>
add $0x18,%rsp
retq
| |
它的源代码可能是：static void
hostcache_prune(struct curl_hash *hostcache, long cache_timeout, time_t now)
{
struct hostcache_prune_data user;
user.cache_timeout = cache_timeout;
user.now = now;
Curl_hash_clean_with_criterium(hostcache,
(void *) &user,
hostcache_timestamp_remove);
} | 这是一段反汇编代码，它的源代码是什么？<hostcache_prune>:
sub $0x18,%rsp
mov %edx,0x8(%rsp)
mov 0x0(%rip),%edx
mov %rsi,(%rsp)
mov %rsp,%rsi
callq 1a <hostcache_prune+0x1a>
add $0x18,%rsp
retq
| |
它的源代码可能是：static void single_msr_unreserve(void)
{
release_evntsel_nmi(wd_ops->evntsel);
release_perfctr_nmi(wd_ops->perfctr);
} | 这是一段反汇编代码，它的源代码是什么？<single_msr_unreserve>:
push %rbp
mov %rsp,%rbp
mov 0x0(%rip),%rax
mov 0x4(%rax),%eax
mov %eax,%edi
callq 15 <single_msr_unreserve+0x15>
mov 0x0(%rip),%rax
mov (%rax),%eax
mov %eax,%edi
callq 25 <single_msr_unreserve+0x25>
nop
pop %rbp
retq
| |
它的源代码可能是：static void single_msr_unreserve(void)
{
release_evntsel_nmi(wd_ops->evntsel);
release_perfctr_nmi(wd_ops->perfctr);
} | 这是一段反汇编代码，它的源代码是什么？<single_msr_unreserve>:
sub $0x8,%rsp
mov 0x0(%rip),%rax
mov 0x4(%rax),%edi
callq 13 <single_msr_unreserve+0x13>
mov 0x0(%rip),%rax
mov (%rax),%edi
callq 21 <single_msr_unreserve+0x21>
add $0x8,%rsp
retq
| |
它的源代码可能是：static void single_msr_unreserve(void)
{
release_evntsel_nmi(wd_ops->evntsel);
release_perfctr_nmi(wd_ops->perfctr);
} | 这是一段反汇编代码，它的源代码是什么？<single_msr_unreserve>:
sub $0x8,%rsp
mov 0x0(%rip),%rax
mov 0x4(%rax),%edi
callq 13 <single_msr_unreserve+0x13>
mov 0x0(%rip),%rax
mov (%rax),%edi
add $0x8,%rsp
jmpq 25 <single_msr_unreserve+0x25>
| |
它的源代码可能是：static void single_msr_unreserve(void)
{
release_evntsel_nmi(wd_ops->evntsel);
release_perfctr_nmi(wd_ops->perfctr);
} | 这是一段反汇编代码，它的源代码是什么？<single_msr_unreserve>:
sub $0x8,%rsp
mov 0x0(%rip),%rax
mov 0x4(%rax),%edi
callq 13 <single_msr_unreserve+0x13>
mov 0x0(%rip),%rax
mov (%rax),%edi
add $0x8,%rsp
jmpq 25 <single_msr_unreserve+0x25>
| |
它的源代码可能是：static s32 ixgbe_read_eerd_X540(struct ixgbe_hw *hw, u16 offset, u16 *data)
{
s32 status = 0;
if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM) ==
0)
status = ixgbe_read_eerd_generic(hw, offset, data);
else
status = IXGBE_ERR_SWFW_SYNC;
hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
return status;
} | 这是一段反汇编代码，它的源代码是什么？<ixgbe_read_eerd_X540>:
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%rax
mov 0x0(%rip),%ecx
mov -0x18(%rbp),%rdx
mov %ecx,%esi
mov %rdx,%rdi
callq *%rax
test %rax,%rax
jne 51 <ixgbe_read_eerd_X540+0x51>
mov -0x28(%rbp),%rdx
mov -0x1c(%rbp),%ecx
mov -0x18(%rbp),%rax
mov %ecx,%esi
mov %rax,%rdi
callq 4c <ixgbe_read_eerd_X540+0x4c>
mov %eax,-0x4(%rbp)
jmp 5a <ixgbe_read_eerd_X540+0x5a>
mov 0x0(%rip),%eax
mov %eax,-0x4(%rbp)
mov -0x18(%rbp),%rax
mov 0x8(%rax),%rax
mov 0x0(%rip),%ecx
mov -0x18(%rbp),%rdx
mov %ecx,%esi
mov %rdx,%rdi
callq *%rax
mov -0x4(%rbp),%eax
leaveq
retq
| |
它的源代码可能是：static s32 ixgbe_read_eerd_X540(struct ixgbe_hw *hw, u16 offset, u16 *data)
{
s32 status = 0;
if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM) ==
0)
status = ixgbe_read_eerd_generic(hw, offset, data);
else
status = IXGBE_ERR_SWFW_SYNC;
hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
return status;
} | 这是一段反汇编代码，它的源代码是什么？<ixgbe_read_eerd_X540>:
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%r12d
mov %rdx,%r13
mov 0x0(%rip),%esi
callq *(%rdi)
mov 0x0(%rip),%ebp
test %rax,%rax
je 3f <ixgbe_read_eerd_X540+0x3f>
mov 0x0(%rip),%esi
mov %rbx,%rdi
callq *0x8(%rbx)
mov %ebp,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov %r13,%rdx
mov %r12d,%esi
mov %rbx,%rdi
callq 4d <ixgbe_read_eerd_X540+0x4d>
mov %eax,%ebp
jmp 26 <ixgbe_read_eerd_X540+0x26>
| |
它的源代码可能是：static s32 ixgbe_read_eerd_X540(struct ixgbe_hw *hw, u16 offset, u16 *data)
{
s32 status = 0;
if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM) ==
0)
status = ixgbe_read_eerd_generic(hw, offset, data);
else
status = IXGBE_ERR_SWFW_SYNC;
hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
return status;
} | 这是一段反汇编代码，它的源代码是什么？<ixgbe_read_eerd_X540>:
push %r13
mov %rdx,%r13
push %r12
mov %esi,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
mov 0x0(%rip),%esi
callq *(%rdi)
mov 0x0(%rip),%ebp
test %rax,%rax
je 40 <ixgbe_read_eerd_X540+0x40>
mov %rbx,%rdi
mov 0x0(%rip),%esi
callq *0x8(%rbx)
add $0x8,%rsp
mov %ebp,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nop
mov %r13,%rdx
mov %r12d,%esi
mov %rbx,%rdi
callq 4e <ixgbe_read_eerd_X540+0x4e>
mov %eax,%ebp
jmp 26 <ixgbe_read_eerd_X540+0x26>
| |
它的源代码可能是：static s32 ixgbe_read_eerd_X540(struct ixgbe_hw *hw, u16 offset, u16 *data)
{
s32 status = 0;
if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM) ==
0)
status = ixgbe_read_eerd_generic(hw, offset, data);
else
status = IXGBE_ERR_SWFW_SYNC;
hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
return status;
} | 这是一段反汇编代码，它的源代码是什么？<ixgbe_read_eerd_X540>:
push %r13
mov %rdx,%r13
push %r12
mov %esi,%r12d
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
mov 0x0(%rip),%esi
callq *(%rdi)
mov 0x0(%rip),%ebp
test %rax,%rax
je 40 <ixgbe_read_eerd_X540+0x40>
mov %rbx,%rdi
mov 0x0(%rip),%esi
callq *0x8(%rbx)
add $0x8,%rsp
mov %ebp,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nop
mov %r13,%rdx
mov %r12d,%esi
mov %rbx,%rdi
callq 4e <ixgbe_read_eerd_X540+0x4e>
mov %eax,%ebp
jmp 26 <ixgbe_read_eerd_X540+0x26>
| |
它的源代码可能是：static loff_t null_lseek(struct file * file, loff_t offset, int orig)
{
return file->f_pos = 0;
} | 这是一段反汇编代码，它的源代码是什么？<null_lseek>:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
mov %edx,-0x14(%rbp)
mov -0x8(%rbp),%rax
movq $0x0,(%rax)
mov $0x0,%eax
pop %rbp
retq
| |
它的源代码可能是：static loff_t null_lseek(struct file * file, loff_t offset, int orig)
{
return file->f_pos = 0;
} | 这是一段反汇编代码，它的源代码是什么？<null_lseek>:
movq $0x0,(%rdi)
mov $0x0,%eax
retq
| |
它的源代码可能是：static loff_t null_lseek(struct file * file, loff_t offset, int orig)
{
return file->f_pos = 0;
} | 这是一段反汇编代码，它的源代码是什么？<null_lseek>:
movq $0x0,(%rdi)
xor %eax,%eax
retq
| |
它的源代码可能是：static loff_t null_lseek(struct file * file, loff_t offset, int orig)
{
return file->f_pos = 0;
} | 这是一段反汇编代码，它的源代码是什么？<null_lseek>:
movq $0x0,(%rdi)
xor %eax,%eax
retq
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.