name string | code string | asm string | file string |
|---|---|---|---|
d68040_move16_ai_al | static void d68040_move16_ai_al(m68k_info *info)
{
int data[] = { info->ir & 7, read_imm_32(info) };
int modes[] = { M68K_AM_REG_DIRECT_ADDR, M68K_AM_ABSOLUTE_DATA_LONG };
LIMIT_CPU_TYPES(info, M68040_PLUS);
build_move16(info, data, modes);
} | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x24(%rdi), %ebp
movl %ebp, %eax
andl $0x7, %eax
movl %eax, 0x8(%rsp)
callq 0x15f89b
addl $0x4, 0x20(%rbx)
movl %eax, 0xc(%rsp)
movabsq $0x1100000002, %rax # imm = 0x1100000002
movq %rax, 0x10(%rsp)
testb $0x10, 0x28(%rbx)
jne 0x162a3a
movq %rbx, %rdi
xorl... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_mull | static void d68020_mull(m68k_info *info)
{
uint extension, insn_signed;
cs_m68k* ext;
cs_m68k_op* op0;
cs_m68k_op* op1;
uint reg_0, reg_1;
LIMIT_CPU_TYPES(info, M68020_PLUS);
extension = read_imm_16(info);
insn_signed = 0;
if (BIT_B((extension)))
insn_signed = 1;
ext = build_init_op(info, insn_signed ?... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x162b84
movl 0x20(%rbx), %eax
movl %eax, %ecx
subl 0x10(%rbx), %ecx
andl 0x2c(%rbx), %ecx
leaq 0x2(%rcx), %rdx
movl $0xaaaa, %ebp # imm = 0xAAAA
cmpq %rdx, 0x8(%rbx)
jb 0x162b03
movq (%rbx), %rdx
movzwl (%rdx,%rcx), %ecx
rolw $0x8, %... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_ori_16 | static unsigned int peek_imm_16(const m68k_info *info) { return m68k_read_safe_16((info), (info)->pc); } | movl 0x20(%rdi), %eax
movl %eax, %edx
subl 0x10(%rdi), %edx
andl 0x2c(%rdi), %edx
leaq 0x2(%rdx), %rsi
movl $0xaaaa, %ecx # imm = 0xAAAA
cmpq %rsi, 0x8(%rdi)
jb 0x162fde
movq (%rdi), %rcx
movzwl (%rcx,%rdx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl $0x2, %eax
movl %eax, 0x20(%rdi)
movl $0x129, %esi ... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_pack_mm | static void d68020_pack_mm(m68k_info *info)
{
LIMIT_CPU_TYPES(info, M68020_PLUS);
build_mm(info, M68K_INS_PACK, 0, read_imm_16(info));
} | testb $0x1c, 0x28(%rdi)
je 0x16309f
movl 0x20(%rdi), %eax
movl %eax, %edx
subl 0x10(%rdi), %edx
andl 0x2c(%rdi), %edx
leaq 0x2(%rdx), %rsi
movl $0xaaaa, %ecx # imm = 0xAAAA
cmpq %rsi, 0x8(%rdi)
jb 0x16308d
movq (%rdi), %rcx
movzwl (%rcx,%rdx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl $0x2, %eax
movl %eax, 0x... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_rol_r_8 | static void d68000_rol_r_8(m68k_info *info)
{
build_r(info, M68K_INS_ROL, 1);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x13c, %esi # imm = 0x13C
callq 0xd721d
movb $0x2, 0x118(%rbx)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x110(%rbx)
movl $0x1, %eax
movl %eax, 0x64(%rbx)
movl 0x24(%rbx), %ecx
movl %ecx, %edx
shrl $0x9, %edx
andl $0x7, %edx
incl %ed... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68010_rtd | static void d68010_rtd(m68k_info *info)
{
set_insn_group(info, M68K_GRP_RET);
LIMIT_CPU_TYPES(info, M68010_PLUS);
build_absolute_jump_with_immediate(info, M68K_INS_RTD, 0, read_imm_16(info));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x17b(%rdi), %eax
leal 0x1(%rax), %ecx
movb %cl, 0x17b(%rdi)
movb $0x3, 0x173(%rdi,%rax)
testb $0x1e, 0x28(%rdi)
je 0x1636e6
movl 0x20(%rbx), %eax
movl %eax, %ecx
subl 0x10(%rbx), %ecx
andl 0x2c(%rbx), %ecx
leaq 0x2(%rcx), %rdx
movl $0xaaaa, %r14d # imm =... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_tst_a_32 | static void d68020_tst_a_32(m68k_info *info)
{
LIMIT_CPU_TYPES(info, M68020_PLUS);
build_ea(info, M68K_INS_TST, 4);
} | pushq %rbx
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x164154
movq 0x18(%rbx), %rdi
movl $0x174, %esi # imm = 0x174
callq 0xd721d
leaq 0x30(%rbx), %rsi
movb $0x1, 0x118(%rbx)
movabsq $0x400000001, %rax # imm = 0x400000001
movq %rax, 0x110(%rbx)
movl 0x24(%rbx), %edx
movq %rbx, %rdi
movl $0x4, %ecx
popq... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_tst_pcix_32 | static void d68020_tst_pcix_32(m68k_info *info)
{
LIMIT_CPU_TYPES(info, M68020_PLUS);
build_ea(info, M68K_INS_TST, 4);
} | pushq %rbx
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x1641fa
movq 0x18(%rbx), %rdi
movl $0x174, %esi # imm = 0x174
callq 0xd721d
leaq 0x30(%rbx), %rsi
movb $0x1, 0x118(%rbx)
movabsq $0x400000001, %rax # imm = 0x400000001
movq %rax, 0x110(%rbx)
movl 0x24(%rbx), %edx
movq %rbx, %rdi
movl $0x4, %ecx
popq... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_unpk_mm | static void d68020_unpk_mm(m68k_info *info)
{
LIMIT_CPU_TYPES(info, M68020_PLUS);
build_mm(info, M68K_INS_UNPK, 0, read_imm_16(info));
} | testb $0x1c, 0x28(%rdi)
je 0x16431b
movl 0x20(%rdi), %eax
movl %eax, %edx
subl 0x10(%rdi), %edx
andl 0x2c(%rdi), %edx
leaq 0x2(%rdx), %rsi
movl $0xaaaa, %ecx # imm = 0xAAAA
cmpq %rsi, 0x8(%rdi)
jb 0x164309
movq (%rdi), %rcx
movzwl (%rcx,%rdx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl $0x2, %eax
movl %eax, 0x... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
build_mm | static void build_mm(m68k_info *info, int opcode, uint8_t size, int imm)
{
cs_m68k_op* op0;
cs_m68k_op* op1;
cs_m68k_op* op2;
cs_m68k* ext = build_init_op(info, opcode, 2, size);
op0 = &ext->operands[0];
op1 = &ext->operands[1];
op2 = &ext->operands[2];
op0->address_mode = M68K_AM_REGI_ADDR_PRE_DEC;
op0->reg... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0xd721d
movb $0x2, 0x118(%r14)
movl $0x1, 0x110(%r14)
movl %ebp, 0x114(%r14)
movl $0x5, %eax
movl %eax, 0x64(%r14)
movl 0x24(%r14), %ecx
movl %ecx, %edx
andl $0x7, %edx
addl $0x9, %edx
movl %edx, 0x30(%r14)
movl... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
build_ea_a | static void build_ea_a(m68k_info *info, int opcode, uint8_t size)
{
cs_m68k_op* op0;
cs_m68k_op* op1;
cs_m68k* ext = build_init_op(info, opcode, 2, size);
op0 = &ext->operands[0];
op1 = &ext->operands[1];
get_ea_mode_op(info, op0, info->ir, size);
op1->address_mode = M68K_AM_REG_DIRECT_ADDR;
op1->reg = M68K_... | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0xd721d
leaq 0x30(%r14), %rsi
movb $0x2, 0x118(%r14)
movl $0x1, 0x110(%r14)
movl %ebx, 0x114(%r14)
movl 0x24(%r14), %edx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x1644cf
movl $0x2, 0x9c(%r14)
movl 0x24(%r14), %eax
shrl $0x9, %eax... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
build_3bit_d | static void build_3bit_d(m68k_info *info, int opcode, int size)
{
cs_m68k_op* op0;
cs_m68k_op* op1;
cs_m68k* ext = build_init_op(info, opcode, 2, size);
op0 = &ext->operands[0];
op1 = &ext->operands[1];
op0->type = M68K_OP_IMM;
op0->address_mode = M68K_AM_IMMEDIATE;
op0->imm = g_3bit_qdata_table[(info->ir >> ... | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0xd721d
movb $0x2, 0x118(%r14)
movl $0x1, %eax
movl %eax, 0x110(%r14)
movl %ebx, 0x114(%r14)
movabsq $0x1200000002, %rcx # imm = 0x1200000002
movq %rcx, 0x60(%r14)
movl 0x24(%r14), %ecx
movl %ecx, %edx
shrl $0x7, %edx
andl ... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
build_movep_re | static void build_movep_re(m68k_info *info, int size)
{
cs_m68k_op* op0;
cs_m68k_op* op1;
cs_m68k* ext = build_init_op(info, M68K_INS_MOVEP, 2, size);
op0 = &ext->operands[0];
op1 = &ext->operands[1];
op0->reg = M68K_REG_D0 + ((info->ir >> 9) & 7);
op1->address_mode = M68K_AM_REGI_ADDR_DISP;
op1->type = M68K... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x11d, %esi # imm = 0x11D
callq 0xd721d
movb $0x2, 0x118(%rbx)
movl $0x1, 0x110(%rbx)
movl %ebp, 0x114(%rbx)
movl 0x24(%rbx), %eax
movl %eax, %ecx
shrl $0x9, %ecx
andl $0x7, %ecx
incl %ecx
movl %ecx, 0x30(%rbx)
movab... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
build_moves | static void build_moves(m68k_info *info, int size)
{
cs_m68k_op* op0;
cs_m68k_op* op1;
cs_m68k* ext = build_init_op(info, M68K_INS_MOVES, 2, size);
uint extension = read_imm_16(info);
op0 = &ext->operands[0];
op1 = &ext->operands[1];
if (BIT_B(extension)) {
op0->reg = (BIT_F(extension) ? M68K_REG_A0 : M68K_R... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x11f, %esi # imm = 0x11F
callq 0xd721d
movb $0x2, 0x118(%rbx)
movl $0x1, 0x110(%rbx)
movl %ebp, 0x114(%rbx)
movl 0x20(%rbx), %eax
movl %eax, %ecx
subl 0x10(%rbx), %ecx
andl 0x2c(%rbx), %ecx
lea... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
M68K_printInst | void M68K_printInst(MCInst* MI, SStream* O, void* PrinterInfo)
{
#ifndef CAPSTONE_DIET
m68k_info *info = (m68k_info *)PrinterInfo;
cs_m68k *ext = &info->extension;
cs_detail *detail = NULL;
int i = 0;
detail = MI->flat_insn->detail;
if (detail) {
int regs_read_count = m68k_min(m68k_sizeof_array(detail->regs_re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x30(%rdx), %rcx
movq 0x310(%rdi), %rax
movq 0xf0(%rax), %r13
testq %r13, %r13
je 0x1657f1
movl 0x148(%r14), %eax
cmpb $0x10, %al
movl $0x10, %r15d
cmovbl %eax, %r15d
movzbl 0x172(%r14... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KInstPrinter.c |
TMS320C64x_init | void TMS320C64x_init(MCRegisterInfo *MRI)
{
MCRegisterInfo_InitMCRegisterInfo(MRI, TMS320C64xRegDesc, 90,
0, 0,
TMS320C64xMCRegisterClasses, 7,
0, 0,
TMS320C64xRegDiffLists,
0,
TMS320C64xSubRegIdxLists, 1,
0);
} | pushq %rax
xorl %eax, %eax
leaq 0x57ca8f(%rip), %r10 # 0x6e2e00
leaq 0x4764b8(%rip), %r11 # 0x5dc830
leaq 0x475bc1(%rip), %rsi # 0x5dbf40
leaq 0x47642a(%rip), %r9 # 0x5dc7b0
movl $0x5a, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq $0x1
pushq %r10
pushq %rax
pushq %r11
pushq $0x0
pushq %rax
pushq $... | /google[P]bloaty/third_party/capstone/arch/TMS320C64x/TMS320C64xDisassembler.c |
DecodeCrosspathX2 | static DecodeStatus DecodeCrosspathX2(MCInst *Inst, unsigned Val,
uint64_t Address, void *Decoder)
{
DecodeStatus ret = MCDisassembler_Success;
MCOperand *op;
if(!Inst->flat_insn->detail)
return MCDisassembler_Success;
switch(Val) {
case 0:
Inst->flat_insn->detail->tms320c64x.funit.crosspath = 0;
brea... | movq 0x310(%rdi), %rax
movq 0xf0(%rax), %rcx
movl $0x3, %eax
testq %rcx, %rcx
je 0x167086
cmpl $0x1, %esi
je 0x16705a
testl %esi, %esi
jne 0x16707a
movl $0x0, 0x16c(%rcx)
retq
movl $0x1, 0x16c(%rcx)
cmpb $0x1, 0x24(%rdi)
jne 0x167086
movl 0x28(%rdi), %ecx
leal -0x19(%rcx), %edx
cmpl $0x1f, %edx
ja 0x167087
addl $0x20, ... | /google[P]bloaty/third_party/capstone/arch/TMS320C64x/TMS320C64xDisassembler.c |
printMemOperand | static void printMemOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNo);
int64_t Val = MCOperand_getImm(Op);
unsigned scaled, base, offset, mode, unit;
cs_tms320c64x *tms320c64x;
char st, nd;
scaled = (Val >> 19) & 1;
base = (Val >> 12) & 0x7f;
offset = (Val >> 5) & 0x7... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r14
movl $0x1, %esi
callq 0xd722b
movq %rax, %rdi
callq 0xd727c
movq %rax, %rbx
movl %ebx, %ebp
shrl $0x13, %ebp
movl %ebx, %r12d
shrl $0xc, %r12d
andl $0x7f, %r12d
movl %ebx, %r15d
shrl $0x5, %r15d
andl $0x7f, %r... | /google[P]bloaty/third_party/capstone/arch/TMS320C64x/TMS320C64xInstPrinter.c |
TMS320C64x_insn_name | const char *TMS320C64x_insn_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
if (id >= TMS320C64X_INS_ENDING)
return NULL;
return insn_name_maps[id].name;
#else
return NULL;
#endif
} | cmpl $0x90, %esi
jbe 0x16852c
xorl %eax, %eax
retq
movl %esi, %eax
shlq $0x4, %rax
leaq 0x402667(%rip), %rcx # 0x56aba0
movq 0x8(%rax,%rcx), %rax
retq
| /google[P]bloaty/third_party/capstone/arch/TMS320C64x/TMS320C64xMapping.c |
TMS320C64x_group_name | const char *TMS320C64x_group_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
unsigned int i;
if (id >= TMS320C64X_GRP_ENDING)
return NULL;
for (i = 0; i < ARR_SIZE(group_name_maps); i++) {
if (group_name_maps[i].id == id)
return group_name_maps[i].name;
}
return group_name_maps[id].name;
#else
... | cmpl $0x84, %esi
jbe 0x16854a
xorl %eax, %eax
retq
xorl %ecx, %ecx
leaq 0x402f5d(%rip), %rax # 0x56b4b0
cmpl %esi, (%rcx,%rax)
je 0x168568
addq $0x10, %rcx
cmpq $0x70, %rcx
jne 0x168553
movl %esi, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq (%rax), %rax
retq
| /google[P]bloaty/third_party/capstone/arch/TMS320C64x/TMS320C64xMapping.c |
indexedX_hdlr | static void indexedX_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
{
uint8_t offset = 0;
read_byte(info, &offset, (*address)++);
add_indexed_operand(info, M680X_REG_X, false, 0, M680X_OFFSET_BITS_8,
(uint16_t)offset, false);
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdi
movzwl (%rdx), %eax
leal 0x1(%rax), %ecx
movw %cx, (%rdx)
movzwl 0xc(%rsi), %ecx
subq %rcx, %rax
cmpl 0x8(%rsi), %eax
jae 0x1698b3
movq (%rdi), %rcx
movzbl (%rcx,%rax), %ebp
jmp 0x1698b5
xorl %ebp, %ebp
movzbl 0x15(%rdi), %eax
leal 0x1(%rax), %ecx
movb %cl, 0x15(%rdi)
le... | /google[P]bloaty/third_party/capstone/arch/M680X/M680XDisassembler.c |
tfm_hdlr | static void tfm_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
{
static const uint8_t inc_dec_r0[] = {
1, -1, 1, 0,
};
static const uint8_t inc_dec_r1[] = {
1, -1, 0, 1,
};
uint8_t regs = 0;
uint8_t index = (MI->Opcode & 0xff) - 0x38;
read_byte(info, ®s, *address);
add_indexed_operand(info, g_tf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movzwl (%rdx), %ecx
movzwl 0xc(%rsi), %edx
subq %rdx, %rcx
cmpl 0x8(%rsi), %ecx
jae 0x169e9b
movq (%r14), %rdx
movb (%rdx,%rcx), %bpl
jmp 0x169e9d
xorl %ebp, %ebp
movl %ebp, %ecx
shrb $0x4, ... | /google[P]bloaty/third_party/capstone/arch/M680X/M680XDisassembler.c |
reg_reg12_hdlr | static void reg_reg12_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
{
static const m680x_reg g_tfr_exg12_reg0_ids[] = {
M680X_REG_A, M680X_REG_B, M680X_REG_CC, M680X_REG_TMP3,
M680X_REG_D, M680X_REG_X, M680X_REG_Y, M680X_REG_S,
};
static const m680x_reg g_tfr_exg12_reg1_ids[] = {
M680X_REG_A, M680X_... | movzwl (%rdx), %eax
leal 0x1(%rax), %ecx
movw %cx, (%rdx)
movzwl 0xc(%rsi), %ecx
subq %rcx, %rax
cmpl 0x8(%rsi), %eax
jae 0x16a3f2
movq (%rsi), %rcx
movb (%rcx,%rax), %al
testb %al, %al
movl $0x14f, %edx # imm = 0x14F
movl $0x99, %ecx
cmovnsl %edx, %ecx
jmp 0x16a3f9
movl $0x14f, %ecx # imm = 0x14F... | /google[P]bloaty/third_party/capstone/arch/M680X/M680XDisassembler.c |
loop_hdlr | static void loop_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
{
static const m680x_reg index_to_reg_id[] = {
M680X_REG_A, M680X_REG_B, M680X_REG_INVALID, M680X_REG_INVALID,
M680X_REG_D, M680X_REG_X, M680X_REG_Y, M680X_REG_S,
};
static const m680x_insn index_to_insn_id[] = {
M680X_INS_DBEQ, M680X_INS_D... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rdx), %edx
leal 0x1(%rdx), %eax
movw %ax, (%r15)
movzwl 0xc(%rsi), %ecx
subq %rcx, %rdx
movl 0x8(%rsi), %ecx
cmpl %ecx, %edx
jae 0x16a4fc
movq (%r14), %rsi
movzbl (%rsi,%rdx), %ebp
movl %ebp, %edx
shrl $0x5, ... | /google[P]bloaty/third_party/capstone/arch/M680X/M680XDisassembler.c |
absl::numbers_internal::FastIntToBuffer(long, char*) | absl::Nonnull<char*> numbers_internal::FastIntToBuffer(
int64_t i, absl::Nonnull<char*> buffer) {
uint64_t u = static_cast<uint64_t>(i);
if (i < 0) {
*buffer++ = '-';
// We need to do the negation in modular (i.e., "unsigned")
// arithmetic; MSVC++ apparently warns for plain "-u", so
// we write... | pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
jns 0x16db05
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
movq %rdi, %rax
shrq $0x20, %rax
je 0x16dbde
movabsq $0x3030303030303030, %r9 # imm = 0x3030303030303030
movabsq $0xfffffffffffff6, %r8 # imm = 0xFFFFFFFFFFFFF6
movabsq $0xf000f000f000f, %r10 # imm = 0xF000F000F000F
... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/numbers.cc |
absl::PowFive(unsigned long, int) | static std::pair<uint64_t, uint64_t> PowFive(uint64_t num, int expfive) {
std::pair<uint64_t, uint64_t> result = {num, 0};
while (expfive >= 13) {
// 5^13 is the highest power of five that will fit in a 32-bit integer.
result = Mul32(result, 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5);
expfive -=... | pushq %rbx
movq %rdi, %rax
xorl %edx, %edx
cmpl $0xd, %esi
jl 0x16f5c2
movl %esi, %ebx
movq %rax, %rdi
movq %rdx, %rsi
movl $0x48c27395, %edx # imm = 0x48C27395
callq 0x16f60c
leal -0xd(%rbx), %esi
cmpl $0x19, %ebx
movl %esi, %ebx
ja 0x16f5a8
andl $0xf, %esi
leaq 0x3236f4(%rip), %rcx # 0x492cc0
movl (%rcx,%rsi... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/numbers.cc |
absl::StripLeadingAsciiWhitespace(std::basic_string_view<char, std::char_traits<char>>) | ABSL_MUST_USE_RESULT inline absl::string_view StripLeadingAsciiWhitespace(
absl::string_view str) {
auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
return str.substr(static_cast<size_t>(it - str.begin()));
} | pushq %rax
movq %rdi, %rcx
sarq $0x2, %rdi
testq %rdi, %rdi
jle 0x16f6ec
movq %rcx, %rax
andq $-0x4, %rax
addq %rsi, %rax
incq %rdi
leaq 0x3(%rsi), %rdx
leaq 0x322336(%rip), %r8 # 0x4919e0
movzbl -0x3(%rdx), %r9d
testb $0x8, (%r8,%r9)
je 0x16f735
movzbl -0x2(%rdx), %r9d
testb $0x8, (%r8,%r9)
je 0x16f73b
movzbl -0x1... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/ascii.h |
absl::StrCat[abi:cxx11](absl::AlphaNum const&, absl::AlphaNum const&, absl::AlphaNum const&, absl::AlphaNum const&) | std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c,
const AlphaNum& d) {
std::string result;
// Use uint64_t to prevent size_t overflow. We assume it is not possible for
// in memory strings to overflow a uint64_t.
constexpr uint64_t kMaxSize = uint64_t{std::numeric_li... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rdx), %rsi
addq (%r14), %rsi
addq (%rcx), %rsi
movq %r8, (%rsp)
addq (%r8), %rsi
xorl %ed... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/str_cat.cc |
absl::StrAppend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, absl::AlphaNum const&, absl::AlphaNum const&, absl::AlphaNum const&, absl::AlphaNum const&) | void StrAppend(absl::Nonnull<std::string*> dest, const AlphaNum& a,
const AlphaNum& b, const AlphaNum& c, const AlphaNum& d) {
ASSERT_NO_OVERLAP(*dest, a);
ASSERT_NO_OVERLAP(*dest, b);
ASSERT_NO_OVERLAP(*dest, c);
ASSERT_NO_OVERLAP(*dest, d);
std::string::size_type old_size = dest->size();
ST... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r9
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x16ff84
movq 0x8(%rbp), %rcx
subq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jbe 0x1700c8
movq (%r12), %rdx
testq %rdx, %rdx
je 0x16ff9f
movq 0x... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/str_cat.cc |
absl::ByString::Find(std::basic_string_view<char, std::char_traits<char>>, unsigned long) const | absl::string_view ByString::Find(absl::string_view text, size_t pos) const {
if (delimiter_.length() == 1) {
// Much faster to call find on a single character than on an
// absl::string_view.
size_t found_pos = text.find(delimiter_[0], pos);
if (found_pos == absl::string_view::npos)
return absl:... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %r15
cmpq $0x1, %r15
jne 0x17018f
movq %r14, %rdx
subq %rcx, %rdx
jbe 0x17018a
movq (%rdi), %rax
movsbl (%rax), %esi
addq %rbx, %rcx
movq %rcx, %rdi
callq 0x6d780
movq %rax, %rdx
testq %rax, %rax
sete %al
subq %rbx, %rdx
c... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/str_split.cc |
absl::substitute_internal::Arg::Arg(absl::Hex) | Arg::Arg(Hex hex) {
char* const end = &scratch_[numbers_internal::kFastToBufferSize];
char* writer = end;
uint64_t value = hex.value;
do {
*--writer = absl::numbers_internal::kHexChar[value & 0xF];
value >>= 4;
} while (value != 0);
char* beg;
if (end - writer < hex.width) {
beg = end - hex.w... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x8, %rax
leaq 0x30(%rdi), %r15
xorl %ecx, %ecx
leaq 0x32230e(%rip), %rdi # 0x492a90
movq %r15, %r14
movq %rsi, %r8
movl %esi, %r9d
andl $0xf, %r9d
movb (%rdi,%r9), %r9b
movb %r9b, -0x1(%r14)
decq %r14
shrq $0x4, %r8
incq %rcx
cmpq $0xf, %rsi
mov... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/substitute.cc |
absl::strings_internal::BigUnsigned<4>::MultiplyByTenToTheNth(int) | void MultiplyByTenToTheNth(int n) {
if (n > kMaxSmallPowerOfTen) {
// For large n, raise to a power of 5, then shift left by the same amount.
// (10**n == 5**n * 2**n.) This requires fewer multiplications overall.
MultiplyByFiveToTheNth(n);
ShiftLeft(n);
} else if (n > 0) {
// We ... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0xa, %esi
jl 0x171d15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x17200e
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x171df2
testl %ebp, %ebp
jle 0x171d33
movl %ebp, %eax
leaq 0x325abe(%rip), %rcx # 0x4977e0
movl (%rcx,%r... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h |
absl::strings_internal::BigUnsigned<4>::SetToZero() | void SetToZero() {
std::fill_n(words_, size_, 0u);
size_ = 0;
} | pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rdx
testq %rdx, %rdx
jle 0x171de9
leaq 0x4(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x6d3c0
movl $0x0, (%rbx)
popq %rbx
retq
nop
| /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h |
absl::strings_internal::BigUnsigned<4>::ShiftLeft(int) | void ShiftLeft(int count) {
if (count > 0) {
const int word_shift = count / 32;
if (word_shift >= max_words) {
SetToZero();
return;
}
size_ = (std::min)(size_ + word_shift, max_words);
count %= 32;
if (count == 0) {
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x171ef6
movl %esi, %ebp
movq %rdi, %rbx
movl (%rdi), %edx
cmpl $0x80, %esi
jb 0x171e2e
testl %edx, %edx
jle 0x171e23
leaq 0x4(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x6d3c0
movl $0x0, (%rbx)
jmp 0x171ef6
movl %ebp, %r14d
shrl $0x5, ... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h |
absl::strings_internal::BigUnsigned<4>::AddWithCarry(int, unsigned int) | void AddWithCarry(int index, uint32_t value) {
if (value) {
while (index < max_words && value > 0) {
words_[index] += value;
// carry if we overflowed in this word:
if (value > words_[index]) {
value = 1;
++index;
} else {
value = 0;
}
... | testl %edx, %edx
je 0x1722d3
cmpl $0x3, %esi
jg 0x1722bd
movslq %esi, %rsi
xorl %eax, %eax
addl %edx, 0x4(%rdi,%rsi,4)
setb %cl
adcl $0x0, %esi
cmpl $0x3, %esi
jg 0x1722bd
movb %cl, %al
movl %eax, %edx
testb %al, %al
jne 0x1722a1
incl %esi
movl (%rdi), %eax
cmpl %eax, %esi
cmovlel %eax, %esi
cmpl $0x4, %esi
movl $0x4, ... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h |
absl::strings_internal::BigUnsigned<4>::MultiplyStep(int, unsigned int const*, int, int) | void BigUnsigned<max_words>::MultiplyStep(int original_size,
const uint32_t* other_words,
int other_size, int step) {
int this_i = std::min(original_size - 1, step);
int other_i = step - this_i;
uint64_t this_word = 0;
uint64_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
decl %esi
cmpl %r8d, %esi
cmovgel %r8d, %esi
movq %rdi, %r14
movl %r8d, %eax
subl %esi, %eax
testl %esi, %esi
sets %dil
cmpl %ecx, %eax
setge %r8b
orb %dil, %r8b
jne 0x172345
movl %esi, %esi
movslq %eax, %rdi
movslq %ecx, %rcx
incq %rdi
xorl %eax, %... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.cc |
absl::strings_internal::BigUnsigned<84>::ReadFloatMantissa(absl::strings_internal::ParsedFloat const&, int) | int BigUnsigned<max_words>::ReadFloatMantissa(const ParsedFloat& fp,
int significant_digits) {
SetToZero();
assert(fp.type == FloatType::kNumber);
if (fp.subrange_begin == nullptr) {
// We already exactly parsed the mantissa, so no more work is necessary.
wor... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rdx
testq %rdx, %rdx
jle 0x172833
leaq 0x4(%r14), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x6d3c0
movl $0x0, (%r14)
cmpl $0x0, 0x10(%rbx)
jne 0x172885
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x17285c
movq 0x20(%rbx), %... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.cc |
absl::strings_internal::BigUnsigned<84>::SetToZero() | void SetToZero() {
std::fill_n(words_, size_, 0u);
size_ = 0;
} | pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rdx
testq %rdx, %rdx
jle 0x1728bf
leaq 0x4(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x6d3c0
movl $0x0, (%rbx)
popq %rbx
retq
nop
| /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h |
absl::strings_internal::BigUnsigned<84>::ToString[abi:cxx11]() const | std::string BigUnsigned<max_words>::ToString() const {
BigUnsigned<max_words> copy = *this;
std::string result;
// Build result in reverse order
while (copy.size() > 0) {
uint32_t next_digit = copy.DivMod<10>();
result.push_back('0' + static_cast<char>(next_digit));
}
if (result.empty()) {
resul... | pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl $0x154, %edx # imm = 0x154
movq %r14, %rdi
callq 0x6d5a0
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
cmpl $0x0, 0xc(%rsp)
jle 0x172c76
movq %r14, %rdi
c... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.cc |
absl::strings_internal::BigUnsigned<84>::AddWithCarry(int, unsigned int) | void AddWithCarry(int index, uint32_t value) {
if (value) {
while (index < max_words && value > 0) {
words_[index] += value;
// carry if we overflowed in this word:
if (value > words_[index]) {
value = 1;
++index;
} else {
value = 0;
}
... | testl %edx, %edx
je 0x172db1
cmpl $0x53, %esi
jg 0x172d9b
movslq %esi, %rsi
xorl %eax, %eax
addl %edx, 0x4(%rdi,%rsi,4)
setb %cl
adcl $0x0, %esi
cmpl $0x53, %esi
jg 0x172d9b
movb %cl, %al
movl %eax, %edx
testb %al, %al
jne 0x172d7f
incl %esi
movl (%rdi), %eax
cmpl %eax, %esi
cmovlel %eax, %esi
cmpl $0x54, %esi
movl $0x... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h |
absl::debugging_internal::MaybeAppend(absl::debugging_internal::State*, char const*) | static bool MaybeAppend(State *state, const char *const str) {
if (state->parse_state.append) {
size_t length = StrLen(str);
MaybeAppendWithLength(state, str, length);
}
return true;
} | cmpl $0x0, 0x28(%rdi)
js 0x173c08
retq
cmpb $0x0, (%rsi)
je 0x173c22
xorl %eax, %eax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%rsi,%rax)
movq %rdx, %rax
jne 0x173c0f
jmp 0x174e40
xorl %edx, %edx
jmp 0x174e40
| /google[P]bloaty/third_party/abseil-cpp/absl/debugging/internal/demangle.cc |
absl::debugging_internal::ParseSubstitution(absl::debugging_internal::State*, bool) | static bool ParseSubstitution(State *state, bool accept_std) {
ComplexityGuard guard(state);
if (guard.IsTooComplex()) return false;
if (ParseTwoCharToken(state, "S_")) {
MaybeAppend(state, "?"); // We don't support substitutions.
return true;
}
ParseState copy = state->parse_state;
if (ParseOneCh... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x14(%rdi), %eax
movl 0x18(%rdi), %ecx
leal 0x1(%rax), %edx
movl %edx, 0x14(%rdi)
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rdi)
cmpl $0x100, %eax # imm = 0x100
setge %al
cmpl $0x20000, %ecx # imm = 0x20000
setge %cl
orb %... | /google[P]bloaty/third_party/abseil-cpp/absl/debugging/internal/demangle.cc |
absl::debugging_internal::Append(absl::debugging_internal::State*, char const*, unsigned long) | static void Append(State *state, const char *const str, const size_t length) {
for (size_t i = 0; i < length; ++i) {
if (state->parse_state.out_cur_idx + 1 <
state->out_end_idx) { // +1 for '\0'
state->out[state->parse_state.out_cur_idx++] = str[i];
} else {
// signal overflow
state... | testq %rdx, %rdx
je 0x174f01
xorl %eax, %eax
movslq 0x20(%rdi), %rcx
leal 0x1(%rcx), %r8d
movl 0x10(%rdi), %r9d
cmpl %r9d, %r8d
jge 0x174efa
movb (%rsi,%rax), %r9b
movq 0x8(%rdi), %r10
movl %r8d, 0x20(%rdi)
movb %r9b, (%r10,%rcx)
incq %rax
cmpq %rax, %rdx
jne 0x174ecf
jmp 0x174f01
incl %r9d
movl %r9d, 0x20(%rdi)
movslq... | /google[P]bloaty/third_party/abseil-cpp/absl/debugging/internal/demangle.cc |
absl::debugging_internal::ParseTemplateTemplateParam(absl::debugging_internal::State*) | static bool ParseTemplateTemplateParam(State *state) {
ComplexityGuard guard(state);
if (guard.IsTooComplex()) return false;
return (ParseTemplateParam(state) ||
// "std" on its own isn't a template.
ParseSubstitution(state, /*accept_std=*/false));
} | pushq %rbx
movq %rdi, %rbx
movl 0x14(%rdi), %eax
movl 0x18(%rdi), %ecx
leal 0x1(%rax), %edx
movl %edx, 0x14(%rdi)
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rdi)
cmpl $0x100, %eax # imm = 0x100
setge %al
cmpl $0x20000, %ecx # imm = 0x20000
setge %cl
orb %al, %cl
je 0x1771c1
xorl %eax, %eax
jmp 0x1771db
m... | /google[P]bloaty/third_party/abseil-cpp/absl/debugging/internal/demangle.cc |
google::protobuf::internal::ArenaImpl::Init() | void ArenaImpl::Init() {
lifecycle_id_ =
lifecycle_id_generator_.fetch_add(1, std::memory_order_relaxed);
hint_.store(nullptr, std::memory_order_relaxed);
threads_.store(nullptr, std::memory_order_relaxed);
if (initial_block_) {
// Thread which calls Init() owns the first block. This allows the
/... | movl $0x1, %eax
lock
xaddq %rax, 0x56b262(%rip) # 0x6e2e10
movq %rax, 0x20(%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, (%rdi)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x177c41
movq 0x40(%rdi), %rcx
movq $0x0, (%rax)
movq %rcx, 0x10(%rax)
movq %fs:0x0, %rdx
leaq -0x10(%rdx), %rdx
leaq 0x18(%rax), %rsi
movq $0x60, 0x8(%rax... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/arena.cc |
google::protobuf::internal::ArenaImpl::~ArenaImpl() | ArenaImpl::~ArenaImpl() {
// Have to do this in a first pass, because some of the destructors might
// refer to memory in other blocks.
CleanupList();
FreeBlocks();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x177caa
cmpq $0x0, 0x18(%r14)
je 0x177ca4
movq %r14, %rdi
callq 0x1782de
movq 0x20(%r14), %r14
jmp 0x177c90
movq %rbx, %rdi
callq 0x177ce4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x177cbc
movq %rax, %rdi
callq 0x7e6b5
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/arena.cc |
google::protobuf::internal::ArenaImpl::AddCleanupFallback(void*, void (*)(void*)) | PROTOBUF_NOINLINE
void ArenaImpl::AddCleanupFallback(void* elem, void (*cleanup)(void*)) {
GetSerialArena()->AddCleanup(elem, cleanup);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x6eb7c
movq 0x38(%rax), %rcx
cmpq 0x40(%rax), %rcx
je 0x1780ce
movq %r14, (%rcx)
movq %rbx, 0x8(%rcx)
addq $0x10, %rcx
movq %rcx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
po... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/arena.cc |
google::protobuf::internal::InitProtobufDefaults() | void InitProtobufDefaults() {
static bool is_inited = InitProtobufDefaultsImpl();
(void)is_inited;
} | pushq %rbx
movb 0x56aa30(%rip), %al # 0x6e2e40
testb %al, %al
je 0x178416
popq %rbx
retq
leaq 0x56aa23(%rip), %rdi # 0x6e2e40
callq 0x6ddc0
testl %eax, %eax
je 0x178414
leaq 0x56aa03(%rip), %rax # 0x6e2e30
movq %rax, 0x56a9ec(%rip) # 0x6e2e20
leaq 0x56a9e5(%rip), %rsi # 0x6e2e20
movq $0x0, 0x56a9e2(%rip... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::RepeatedFieldHelper<2>::Serialize<google::protobuf::io::CodedOutputStream>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::io::CodedOutputStream*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
typedef typename PrimitiveTypeHelper<type>::Type T;
const RepeatedField<T>& array = Get<RepeatedField<T> >(field);
for (int i = 0; i < array.size(); i++) {
WriteTagTo(md.tag, output);
SerializeTo<type>(&array[i], outp... | cmpl $0x0, (%rdi)
jle 0x17a325
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
movl 0x4(%r14), %eax
movl %eax, 0x4(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x17cdf6
movq 0x8(%r15), %rax
movl (%rax,%r13... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::RepeatedFieldHelper<13>::Serialize<google::protobuf::io::CodedOutputStream>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::io::CodedOutputStream*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
typedef typename PrimitiveTypeHelper<type>::Type T;
const RepeatedField<T>& array = Get<RepeatedField<T> >(field);
for (int i = 0; i < array.size(); i++) {
WriteTagTo(md.tag, output);
SerializeTo<type>(&array[i], outp... | cmpl $0x0, (%rdi)
jle 0x17acc2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
xorl %ebp, %ebp
movl 0x4(%r14), %eax
movl %eax, 0x4(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x17cdf6
movq 0x8(%r15), %rdi... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::SingularFieldHelper<15>::Serialize<google::protobuf::io::CodedOutputStream>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::io::CodedOutputStream*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
WriteTagTo(md.tag, output);
SerializeTo<type>(field, output);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
movq %rdx, %rsi
callq 0x17cdf6
movl (%r14), %ebp
movq 0x40(%rbx), %rax
cmpq (%rbx), %rax
jae 0x17ae3f
movl %ebp, (%rax)
addq $0x4, %rax
movq %rax, 0x40(%rbx)
addq $0x10, %rsp
pop... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::PackedFieldHelper<15>::Serialize<google::protobuf::io::CodedOutputStream>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::io::CodedOutputStream*) | inline bool RepeatedField<Element>::empty() const {
return current_size_ == 0;
} | cmpl $0x0, (%rdi)
je 0x17af41
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
movq %rsp, %rdi
movl %eax, (%rdi)
movq %rdx, %rsi
callq 0x17cdf6
movl 0x10(%r14), %eax
leaq 0x4(%rsp), %rdi
movl %eax, (%rdi)
movq %rbx, %rsi
callq 0x17cdf6
cmpl $0x0, (%r14)
jle 0x1... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedFieldHelper<16>::Serialize<google::protobuf::io::CodedOutputStream>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::io::CodedOutputStream*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
typedef typename PrimitiveTypeHelper<type>::Type T;
const RepeatedField<T>& array = Get<RepeatedField<T> >(field);
for (int i = 0; i < array.size(); i++) {
WriteTagTo(md.tag, output);
SerializeTo<type>(&array[i], outp... | cmpl $0x0, (%rdi)
jle 0x17b002
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
movl 0x4(%r14), %eax
movl %eax, 0x4(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x17cdf6
movq 0x8(%r15), %rax
movq (%rax,%r13... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::SingularFieldHelper<3>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
WriteTagTo(md.tag, output);
SerializeTo<type>(field, output);
} | movl 0x4(%rsi), %esi
movq (%rdx), %rax
cmpl $0x7f, %esi
ja 0x17b4ef
movb %sil, (%rax)
incq %rax
jmp 0x17b52e
movl %esi, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %esi, %ecx
shrl $0x7, %ecx
cmpl $0x3fff, %esi # imm = 0x3FFF
ja 0x17b50c
movb %cl, 0x1(%rax)
addq $0x2, %rax
jmp 0x17b52e
addq $0x2, %rax
movl %ecx... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::RepeatedFieldHelper<3>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
typedef typename PrimitiveTypeHelper<type>::Type T;
const RepeatedField<T>& array = Get<RepeatedField<T> >(field);
for (int i = 0; i < array.size(); i++) {
WriteTagTo(md.tag, output);
SerializeTo<type>(&array[i], outp... | cmpl $0x0, (%rdi)
jle 0x17b5d5
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl 0x4(%r14), %edx
movq (%rbx), %rax
cmpl $0x7f, %edx
ja 0x17b56a
movb %dl, (%rax)
incq %rax
jmp 0x17b5a8
movl %edx, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %edx, ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::PackedFieldHelper<3>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | inline bool RepeatedField<Element>::empty() const {
return current_size_ == 0;
} | cmpl $0x0, (%rdi)
je 0x17b6c3
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %edx
movq (%rbx), %rax
cmpl $0x7f, %edx
ja 0x17b5ff
movb %dl, (%rax)
incq %rax
jmp 0x17b63d
movl %edx, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %edx, %ecx
shrl $0x7, %ecx
cmpl $0x3fff, ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::PackedFieldHelper<5>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | inline bool RepeatedField<Element>::empty() const {
return current_size_ == 0;
} | cmpl $0x0, (%rdi)
je 0x17ba93
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %edx
movq (%rbx), %rax
cmpl $0x7f, %edx
ja 0x17b9cf
movb %dl, (%rax)
incq %rax
jmp 0x17ba0d
movl %edx, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %edx, %ecx
shrl $0x7, %ecx
cmpl $0x3fff, ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedFieldHelper<6>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
typedef typename PrimitiveTypeHelper<type>::Type T;
const RepeatedField<T>& array = Get<RepeatedField<T> >(field);
for (int i = 0; i < array.size(); i++) {
WriteTagTo(md.tag, output);
SerializeTo<type>(&array[i], outp... | cmpl $0x0, (%rdi)
jle 0x17bb17
movq (%rdx), %rax
xorl %ecx, %ecx
movl 0x4(%rsi), %r9d
cmpl $0x7f, %r9d
ja 0x17bab0
movb %r9b, (%rax)
incq %rax
jmp 0x17bafa
movl %r9d, %r8d
orb $-0x80, %r8b
movb %r8b, (%rax)
movl %r9d, %r8d
shrl $0x7, %r8d
cmpl $0x3fff, %r9d # imm = 0x3FFF
ja 0x17bad4
movb %r8b, 0x1(%rax)
addq... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::RepeatedFieldHelper<11>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
const internal::RepeatedPtrFieldBase& array =
Get<internal::RepeatedPtrFieldBase>(field);
for (int i = 0; i < AccessorHelper::Size(array); i++) {
WriteTagTo(md.tag, output);
SerializeMessageTo(
static_ca... | cmpl $0x0, 0x8(%rdi)
jle 0x17c31e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl 0x4(%r14), %edx
movq (%rbx), %rax
cmpl $0x7f, %edx
ja 0x17c2a7
movb %dl, (%rax)
incq %rax
jmp 0x17c2e5
movl %edx, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %ed... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::RepeatedFieldHelper<13>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
typedef typename PrimitiveTypeHelper<type>::Type T;
const RepeatedField<T>& array = Get<RepeatedField<T> >(field);
for (int i = 0; i < array.size(); i++) {
WriteTagTo(md.tag, output);
SerializeTo<type>(&array[i], outp... | cmpl $0x0, (%rdi)
jle 0x17c419
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl 0x4(%r14), %edx
movq (%rbx), %rax
cmpl $0x7f, %edx
ja 0x17c3ae
movb %dl, (%rax)
incq %rax
jmp 0x17c3ec
movl %edx, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %edx, ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::PackedFieldHelper<14>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | inline bool RepeatedField<Element>::empty() const {
return current_size_ == 0;
} | cmpl $0x0, (%rdi)
je 0x17c6ef
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %edx
movq (%rbx), %rax
cmpl $0x7f, %edx
ja 0x17c62b
movb %dl, (%rax)
incq %rax
jmp 0x17c669
movl %edx, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %edx, %ecx
shrl $0x7, %ecx
cmpl $0x3fff, ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::PackedFieldHelper<15>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | inline bool RepeatedField<Element>::empty() const {
return current_size_ == 0;
} | cmpl $0x0, (%rdi)
je 0x17c848
movl 0x4(%rsi), %esi
movq (%rdx), %rax
cmpl $0x7f, %esi
ja 0x17c790
movb %sil, (%rax)
incq %rax
jmp 0x17c7cf
movl %esi, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %esi, %ecx
shrl $0x7, %ecx
cmpl $0x3fff, %esi # imm = 0x3FFF
ja 0x17c7ad
movb %cl, 0x1(%rax)
addq $0x2, %rax
jmp 0x17... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::SingularFieldHelper<18>::Serialize<google::protobuf::internal::ArrayOutput>(void const*, google::protobuf::internal::FieldMetadata const&, google::protobuf::internal::ArrayOutput*) | static void Serialize(const void* field, const FieldMetadata& md, O* output) {
WriteTagTo(md.tag, output);
SerializeTo<type>(field, output);
} | pushq %rbx
movq %rdx, %rbx
movl 0x4(%rsi), %ecx
movq (%rdx), %rsi
cmpl $0x7f, %ecx
ja 0x17cbac
movb %cl, (%rsi)
incq %rsi
jmp 0x17cbe7
movl %ecx, %eax
orb $-0x80, %al
movb %al, (%rsi)
movl %ecx, %eax
shrl $0x7, %eax
cmpl $0x3fff, %ecx # imm = 0x3FFF
ja 0x17cbc8
movb %al, 0x1(%rsi)
addq $0x2, %rsi
jmp 0x17cbe7... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
google::protobuf::internal::PrimitiveTypeHelper<13>::Serialize(void const*, google::protobuf::io::CodedOutputStream*) | static void Serialize(const void* ptr, io::CodedOutputStream* output) {
WireFormatLite::WriteUInt32NoTag(Get<uint32>(ptr), output);
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rdi), %ebp
movq 0x40(%rsi), %rax
cmpq (%rsi), %rax
jae 0x17ce5d
cmpl $0x7f, %ebp
ja 0x17ce14
movb %bpl, (%rax)
incq %rax
jmp 0x17ce52
movl %ebp, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %ebp, %ecx
shrl $0x7, %ecx
cmpl $0x3fff, %ebp # imm = 0x3FFF
ja 0x... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
google::protobuf::internal::OutputHelper<google::protobuf::internal::ArrayOutput, 5>::Serialize(void const*, google::protobuf::internal::ArrayOutput*) | static void Serialize(const void* ptr, ArrayOutput* output) {
output->ptr = PrimitiveTypeHelper<type>::SerializeToArray(ptr, output->ptr);
} | movq (%rsi), %rax
movslq (%rdi), %rcx
cmpq $0x7f, %rcx
ja 0x17d3b1
movb %cl, (%rax)
incq %rax
jmp 0x17d3f5
movl %ecx, %edx
movl %ecx, %edi
orb $-0x80, %dil
movb %dil, (%rax)
shrq $0x7, %rcx
cmpl $0x3fff, %edx # imm = 0x3FFF
ja 0x17d3d1
movb %cl, 0x1(%rax)
addq $0x2, %rax
jmp 0x17d3f5
addq $0x2, %rax
movq %rcx... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::SerializeGroupTo<google::protobuf::internal::ArrayOutput>(google::protobuf::MessageLite const*, void const*, google::protobuf::internal::ArrayOutput*) | void SerializeGroupTo(const MessageLite* msg, const void* table_ptr,
O* output) {
const SerializationTable* table =
static_cast<const SerializationTable*>(table_ptr);
if (!table) {
// Proto1
SerializeMessageNoTable(msg, output);
return;
}
const FieldMetadata* field_table ... | pushq %rbx
movq %rdx, %rbx
testq %rsi, %rsi
je 0x17d422
movq 0x8(%rsi), %rax
movl (%rsi), %edx
decl %edx
addq $0x18, %rax
movzbl 0x8(%rbx), %ecx
movq (%rbx), %r8
movq %rax, %rsi
callq 0x178e72
movq %rax, (%rbx)
popq %rbx
retq
movq %rbx, %rsi
popq %rbx
jmp 0x1784be
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
google::protobuf::io::EpsCopyOutputStream::WriteAliasedRaw(void const*, int, unsigned char*) | uint8* EpsCopyOutputStream::WriteAliasedRaw(const void* data, int size,
uint8* ptr) {
if (size < GetSize(ptr)
) {
return WriteRaw(data, size, ptr);
} else {
ptr = Trim(ptr);
if (stream_->WriteAliasedRaw(data, size)) return ptr;
return Error();
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movslq %edx, %r12
movq (%rdi), %rax
subq %rcx, %rax
leaq 0x10(%rax), %rcx
cmpq %r12, %rcx
jle 0x17e853
cmpq %r12, %rax
jl 0x17e890
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6d5a0
addq %r1... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/coded_stream.cc |
google::protobuf::io::CodedOutputStream::CodedOutputStream(google::protobuf::io::ZeroCopyOutputStream*, bool) | CodedOutputStream::CodedOutputStream(ZeroCopyOutputStream* stream,
bool do_eager_refresh)
: impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
start_count_(stream->ByteCount()) {
if (do_eager_refresh) {
void* data;
int size;
if (!stream->Next(&data,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x564411(%rip), %al # 0x6e2e81
andb $0x1, %al
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq %r12, 0x8(%rdi)
movq %rsi, 0x30(%rdi)
movw $0x0, 0x38(%rdi)
movb %al, 0x3a(%rdi)
movq %r12, 0x40(%rd... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/coded_stream.cc |
google::protobuf::io::FileInputStream::CopyingFileInputStream::Read(void*, int) | int FileInputStream::CopyingFileInputStream::Read(void* buffer, int size) {
GOOGLE_CHECK(!is_closed_);
int result;
do {
result = read(file_, buffer, size);
} while (result < 0 && errno == EINTR);
if (result < 0) {
// Read error (not EOF).
errno_ = errno;
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xd(%rdi)
jne 0x17edee
leaq 0x319e79(%rip), %rdx # 0x498c2a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x84, %ecx
callq 0x1885e8
leaq 0x319ef3(%rip), %rsi # 0x498cc2
m... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc |
google::protobuf::io::FileOutputStream::CopyingFileOutputStream::~CopyingFileOutputStream() | FileOutputStream::CopyingFileOutputStream::~CopyingFileOutputStream() {
if (close_on_delete_) {
if (!Close()) {
GOOGLE_LOG(ERROR) << "close() failed: " << strerror(errno_);
}
}
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x3f122a(%rip), %rax # 0x5702c8
movq %rax, (%rdi)
cmpb $0x1, 0xc(%rdi)
jne 0x17f10c
movq %rdi, %rbx
callq 0x17efb6
testb %al, %al
jne 0x17f10c
leaq 0x319b70(%rip), %rdx # 0x498c2a
leaq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0xc5, %ecx
callq 0x1885e8
leaq 0x319bdc(%rip),... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc |
google::protobuf::io::ConcatenatingInputStream::Next(void const**, int*) | bool ConcatenatingInputStream::Next(const void** data, int* size) {
while (stream_count_ > 0) {
if (streams_[0]->Next(data, size)) return true;
// That stream is done. Advance to the next one.
bytes_retired_ += streams_[0]->ByteCount();
++streams_;
--stream_count_;
}
// No more streams.
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
jle 0x17f3e8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movl %eax, %ebp
testb %al, %al
jne 0x17f3ea
movq 0x8(%r15), %rax
movq (%rax... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc |
google::protobuf::io::FileInputStream::~FileInputStream() | class PROTOBUF_EXPORT FileInputStream : public ZeroCopyInputStream {
public:
// Creates a stream that reads from the given Unix file descriptor.
// If a block_size is given, it specifies the number of bytes that
// should be read and returned with each call to Next(). Otherwise,
// a reasonable default is use... | pushq %rbx
movq %rdi, %rbx
leaq 0x3f0ced(%rip), %rax # 0x570210
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x17fcec
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x17eccc
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h |
google::protobuf::io::IstreamInputStream::~IstreamInputStream() | class PROTOBUF_EXPORT IstreamInputStream : public ZeroCopyInputStream {
public:
// Creates a stream that reads from the given C++ istream.
// If a block_size is given, it specifies the number of bytes that
// should be read and returned with each call to Next(). Otherwise,
// a reasonable default is used.
e... | pushq %rbx
movq %rdi, %rbx
leaq 0x3f0d67(%rip), %rax # 0x5702f0
movq %rax, (%rdi)
addq $0x18, %rdi
callq 0x17fcec
movq %rbx, %rdi
popq %rbx
jmp 0x6d670
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h |
google::protobuf::io::ArrayInputStream::Skip(int) | bool ArrayInputStream::Skip(int count) {
GOOGLE_CHECK_GE(count, 0);
last_returned_size_ = 0; // Don't let caller back up.
if (count > size_ - position_) {
position_ = size_;
return false;
} else {
position_ += count;
return true;
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jns 0x17f78d
leaq 0x3197e8(%rip), %rdx # 0x498f38
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x59, %ecx
callq 0x1885e8
leaq 0x3198ea(%rip), %rsi # 0x499058
movq %r14, %rdi
callq 0x188084
leaq 0x7(%rs... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc |
google::protobuf::io::CopyingInputStreamAdaptor::Skip(int) | bool CopyingInputStreamAdaptor::Skip(int count) {
GOOGLE_CHECK_GE(count, 0);
if (failed_) {
// Already failed on a previous read.
return false;
}
// First skip any bytes left over from a previous BackUp().
if (backup_bytes_ >= count) {
// We have more data left over than we're trying to skip. J... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jns 0x180030
leaq 0x318f45(%rip), %rdx # 0x498f38
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x107, %ecx # imm = 0x107
callq 0x1885e8
leaq 0x319047(%rip), %rsi # 0x499058
movq %r15, %rdi
c... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc |
google::protobuf::io::LimitingInputStream::Next(void const**, int*) | bool LimitingInputStream::Next(const void** data, int* size) {
if (limit_ <= 0) return false;
if (!input_->Next(data, size)) return false;
limit_ -= *size;
if (limit_ < 0) {
// We overshot the limit. Reduce *size to hide the rest of the buffer.
*size += limit_;
}
return true;
} | cmpq $0x0, 0x10(%rdi)
jle 0x180429
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x18042c
movslq (%rbx), %rdx
movq 0x10(%r14), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%r14)
movb $0x1, %al
jns 0x18042e
addl %edx, %ecx
movl %ecx, (... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc |
google::protobuf::internal::EpsCopyInputStream::SkipFallback(char const*, int) | const char* EpsCopyInputStream::SkipFallback(const char* ptr, int size) {
return AppendSize(ptr, size, [](const char* p, int s) {});
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %r14
movl 0x8(%rdi), %r15d
subl %eax, %r15d
addl $0x10, %r15d
xorl %ebx, %ebx
cmpl $0x10, 0x1c(%r14)
je 0x1807a2
movslq %r15d, %rcx
addq %rcx, %rax
movq %r14, %rdi
movq %rax, %rsi
movl $0xffffffff, %edx # imm = 0xFFF... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/parse_context.cc |
google::protobuf::internal::WriteLengthDelimited(unsigned int, google::protobuf::StringPiece, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | void WriteLengthDelimited(uint32 num, StringPiece val, std::string* s) {
WriteVarint((num << 3) + 2, s);
WriteVarint(val.size(), s);
s->append(val.data(), val.size());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
leal 0x2(,%rdi,8), %r12d
movl %edi, %eax
shll $0x3, %eax
cmpl $0x80, %eax
jb 0x18096c
movq %r12, %r13
movl %r12d, %eax
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x6d5d0
shrq $0x7, %r13
cmpq $0x3fff, %r12 ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/parse_context.cc |
google::protobuf::internal::VarintParseSlow64(char const*, unsigned int) | std::pair<const char*, uint64> VarintParseSlow64(const char* p, uint32 res32) {
uint64 res = res32;
for (std::uint32_t i = 2; i < 10; i++) {
uint64 byte = static_cast<uint8>(p[i]);
res += (byte - 1) << (7 * i);
if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
return {p + i + 1, res};
}
}
return {n... | movq %rdi, %rax
movl %esi, %edx
addq $0x3, %rax
movl $0xe, %ecx
movq %rdx, %rsi
movzbl -0x1(%rax), %edi
movq %rdi, %rdx
decq %rdx
shlq %cl, %rdx
addq %rsi, %rdx
testb %dil, %dil
jns 0x180a5b
incq %rax
addq $0x7, %rcx
cmpq $0x46, %rcx
jne 0x180a32
xorl %eax, %eax
xorl %edx, %edx
retq
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/parse_context.cc |
google::protobuf::internal::ReadTagFallback(char const*, unsigned int) | std::pair<const char*, uint32> ReadTagFallback(const char* p, uint32 res) {
for (std::uint32_t i = 2; i < 5; i++) {
uint32 byte = static_cast<uint8>(p[i]);
res += (byte - 1) << (7 * i);
if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
return {p + i + 1, res};
}
}
return {nullptr, 0};
} | movl %esi, %edx
movq %rdi, %rax
addq $0x3, %rax
movq $-0x15, %rsi
movl %edx, %edi
movzbl -0x1(%rax), %r8d
movl %r8d, %edx
decl %edx
leal 0x23(%rsi), %ecx
shll %cl, %edx
addl %edi, %edx
testb %r8b, %r8b
jns 0x180a91
incq %rax
addq $0x7, %rsi
jne 0x180a6c
xorl %eax, %eax
xorl %edx, %edx
retq
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/parse_context.cc |
char const* google::protobuf::internal::FixedParser<int>(void*, char const*, google::protobuf::internal::ParseContext*) | const char* FixedParser(void* object, const char* ptr, ParseContext* ctx) {
int size = ReadSize(&ptr);
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
return ctx->ReadPackedFixed(ptr, size,
static_cast<RepeatedField<T>*>(object));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movzbl (%rsi), %edx
testb %dl, %dl
js 0x180d6f
incq %rsi
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x181296
movq %rsi, %rdi
movl %edx, %esi
callq 0x6ef3d
testq %rax, %rax
je 0x180d83
movq %rax, %rsi
jmp 0x180d5d
xorl %eax, %e... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/parse_context.cc |
char const* google::protobuf::internal::FixedParser<unsigned long>(void*, char const*, google::protobuf::internal::ParseContext*) | const char* FixedParser(void* object, const char* ptr, ParseContext* ctx) {
int size = ReadSize(&ptr);
GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
return ctx->ReadPackedFixed(ptr, size,
static_cast<RepeatedField<T>*>(object));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movzbl (%rsi), %edx
testb %dl, %dl
js 0x180db3
incq %rsi
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x181396
movq %rsi, %rdi
movl %edx, %esi
callq 0x6ef3d
testq %rax, %rax
je 0x180dc7
movq %rax, %rsi
jmp 0x180da1
xorl %eax, %e... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/parse_context.cc |
google::protobuf::internal::InternalMetadataWithArenaBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::internal::InternalMetadataWithArenaLite>::mutable_unknown_fields_slow() | PROTOBUF_NOINLINE T* mutable_unknown_fields_slow() {
Arena* my_arena = arena();
Container* container = Arena::Create<Container>(my_arena);
// Two-step assignment works around a bug in clang's static analyzer:
// https://bugs.llvm.org/show_bug.cgi?id=34198.
ptr_ = container;
ptr_ = reinterpret_ca... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testb $0x1, %r14b
jne 0x181161
testq %r14, %r14
je 0x181123
cmpq $0x0, 0x70(%r14)
jne 0x18116b
leaq 0x74(%rip), %rdx # 0x181181
movl $0x28, %esi
movq %r14, %rdi
callq 0x177fd0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
jmp 0x181134
movl $0x28, %... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/metadata_lite.h |
char const* google::protobuf::internal::EpsCopyInputStream::ReadPackedFixed<unsigned long>(char const*, int, google::protobuf::RepeatedField<unsigned long>*) | const char* EpsCopyInputStream::ReadPackedFixed(const char* ptr, int size,
RepeatedField<T>* out) {
int nbytes = buffer_end_ + kSlopBytes - ptr;
while (size > nbytes) {
int num = nbytes / sizeof(T);
int old_entries = out->size();
out->Reserve(old_entries +... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r14
movl 0x8(%rdi), %r12d
subl %r14d, %r12d
addl $0x10, %r12d
cmpl %edx, %r12d
jge 0x181442
movq %rdi, %r13
movl %r12d, %ebp
sarl $0x3, %ebp
movl (%r15), %esi
addl %ebp, %esi
movq %r15, %rdi
callq 0x... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/parse_context.cc |
google::protobuf::internal::RepeatedPtrFieldBase::AddWeak(google::protobuf::MessageLite const*) | MessageLite* RepeatedPtrFieldBase::AddWeak(const MessageLite* prototype) {
if (rep_ != NULL && current_size_ < rep_->allocated_size) {
return reinterpret_cast<MessageLite*>(rep_->elements[current_size_++]);
}
if (!rep_ || rep_->allocated_size == total_size_) {
Reserve(total_size_ + 1);
}
++rep_->alloc... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x181d65
movl 0x8(%rbx), %ecx
movl (%rax), %esi
cmpl %esi, %ecx
jge 0x181d6d
movslq %ecx, %rdx
incl %ecx
movl %ecx, 0x8(%rbx)
movq 0x8(%rax,%rdx,8), %rax
jmp 0x181e23
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %esi
jmp ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.cc |
google::protobuf::RepeatedField<bool>::InternalDeallocate(google::protobuf::RepeatedField<bool>::Rep*, int) | void InternalDeallocate(Rep* rep, int size) {
if (rep != NULL) {
Element* e = &rep->elements[0];
Element* limit = &rep->elements[size];
for (; e < limit; e++) {
e->~Element();
}
if (rep->arena == NULL) {
#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)... | testq %rsi, %rsi
je 0x181fdd
cmpq $0x0, (%rsi)
je 0x181fde
retq
movq %rsi, %rdi
jmp 0x6d670
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<bool>::Swap(google::protobuf::RepeatedField<bool>*) | void RepeatedField<Element>::Swap(RepeatedField* other) {
if (this == other) return;
if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
InternalSwap(other);
} else {
RepeatedField<Element> temp(other->GetArenaNoVirtual());
temp.MergeFrom(*this);
CopyFrom(*other);
other->UnsafeArenaSwap(&... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %rsi, %rdi
je 0x18264b
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rcx
movq 0x8(%rdi), %rax
leaq -0x8(%rax), %rdx
cmpl $0x0, 0x4(%rdi)
cmoveq %rcx, %rdx
addq $0x8, %rsi
movq 0x8(%rbx), %rcx
leaq -0x8(%rcx), %rdi
cmpl $0x0, 0x4(%rbx)
cmoveq %rsi, %rd... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<bool>::erase(bool const*, bool const*) | inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
const_iterator first, const_iterator last) {
size_type first_offset = first - cbegin();
if (first != last) {
Truncate(std::copy(last, cend(), begin() + first_offset) - cbegin());
}
return begin() + first_offset;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rsi, %rdi
subq %rax, %rdi
cmpq %rdx, %rsi
je 0x1827d5
movslq (%r14), %rcx
leaq (%rax,%rcx), %r12
movslq %edi, %rbx
leaq (%rax,%rbx), %r15
subq %rdx, %r12
je 0x1827c6
movq %r15, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<int>::CopyFrom(google::protobuf::RepeatedField<int> const&) | inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
if (&other == this) return;
Clear();
MergeFrom(other);
} | pushq %r14
pushq %rbx
pushq %rax
cmpq %rdi, %rsi
je 0x182a63
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rdi)
movl (%rsi), %esi
testl %esi, %esi
je 0x182a63
movq %r14, %rdi
callq 0x18285a
movl (%rbx), %eax
movq 0x8(%r14), %rdi
addl %eax, (%r14)
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x2, %rdx
addq $0x8, %rsp
p... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<unsigned int>::RepeatedField(google::protobuf::RepeatedField<unsigned int> const&) | inline RepeatedField<Element>::RepeatedField(const RepeatedField& other)
: current_size_(0), total_size_(0), arena_or_elements_(nullptr) {
if (other.current_size_ != 0) {
Reserve(other.size());
AddNAlreadyReserved(other.size());
CopyArray(Mutable(0), &other.Get(0), other.size());
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl (%rsi), %esi
testl %esi, %esi
je 0x1833b7
movq %rdi, %r14
callq 0x1833c0
movl (%rbx), %eax
movq 0x8(%r14), %rdi
addl %eax, (%r14)
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x2, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<unsigned int>::AddNAlreadyReserved(int) | inline Element* RepeatedField<Element>::AddNAlreadyReserved(int n) {
GOOGLE_DCHECK_GE(total_size_ - current_size_, n)
<< total_size_ << ", " << current_size_;
// Warning: sometimes people call this when n == 0 and total_size_ == 0. In
// this case the return pointer points to a zero size array (n == 0). Hen... | movslq (%rdi), %rax
addl %eax, %esi
shlq $0x2, %rax
addq 0x8(%rdi), %rax
movl %esi, (%rdi)
retq
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<unsigned int>::CopyFrom(google::protobuf::RepeatedField<unsigned int> const&) | inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
if (&other == this) return;
Clear();
MergeFrom(other);
} | pushq %r14
pushq %rbx
pushq %rax
cmpq %rdi, %rsi
je 0x1835c9
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rdi)
movl (%rsi), %esi
testl %esi, %esi
je 0x1835c9
movq %r14, %rdi
callq 0x1833c0
movl (%rbx), %eax
movq 0x8(%r14), %rdi
addl %eax, (%r14)
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x2, %rdx
addq $0x8, %rsp
p... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<unsigned int>::Swap(google::protobuf::RepeatedField<unsigned int>*) | void RepeatedField<Element>::Swap(RepeatedField* other) {
if (this == other) return;
if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
InternalSwap(other);
} else {
RepeatedField<Element> temp(other->GetArenaNoVirtual());
temp.MergeFrom(*this);
CopyFrom(*other);
other->UnsafeArenaSwap(&... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %rsi, %rdi
je 0x183ce7
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rcx
movq 0x8(%rdi), %rax
leaq -0x8(%rax), %rdx
cmpl $0x0, 0x4(%rdi)
cmoveq %rcx, %rdx
addq $0x8, %rsi
movq 0x8(%rbx), %rcx
leaq -0x8(%rcx), %rdi
cmpl $0x0, 0x4(%rbx)
cmoveq %rsi, %rd... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<long>::Swap(google::protobuf::RepeatedField<long>*) | void RepeatedField<Element>::Swap(RepeatedField* other) {
if (this == other) return;
if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
InternalSwap(other);
} else {
RepeatedField<Element> temp(other->GetArenaNoVirtual());
temp.MergeFrom(*this);
CopyFrom(*other);
other->UnsafeArenaSwap(&... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %rsi, %rdi
je 0x1847f7
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rcx
movq 0x8(%rdi), %rax
leaq -0x8(%rax), %rdx
cmpl $0x0, 0x4(%rdi)
cmoveq %rcx, %rdx
addq $0x8, %rsi
movq 0x8(%rbx), %rcx
leaq -0x8(%rcx), %rdi
cmpl $0x0, 0x4(%rbx)
cmoveq %rsi, %rd... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<long>::erase(long const*, long const*) | inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
const_iterator first, const_iterator last) {
size_type first_offset = first - cbegin();
if (first != last) {
Truncate(std::copy(last, cend(), begin() + first_offset) - cbegin());
}
return begin() + first_offset;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq %rsi, %rdi
subq %rax, %rdi
cmpq %rdx, %rsi
je 0x1849b2
movslq (%rbx), %rcx
leaq (%rax,%rcx,8), %r15
shrq $0x3, %rdi
movslq %edi, %r12
leaq (%rax,%r12,8), %r14
subq %rdx, %r15
je 0x18499f
movq %r14, %rdi
movq %rdx, %rsi
movq... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<unsigned long>::CopyFrom(google::protobuf::RepeatedField<unsigned long> const&) | inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
if (&other == this) return;
Clear();
MergeFrom(other);
} | pushq %r14
pushq %rbx
pushq %rax
cmpq %rdi, %rsi
je 0x184c43
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rdi)
movl (%rsi), %esi
testl %esi, %esi
je 0x184c43
movq %r14, %rdi
callq 0x184a3a
movl (%rbx), %eax
movq 0x8(%r14), %rdi
addl %eax, (%r14)
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x3, %rdx
addq $0x8, %rsp
p... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<unsigned long>::ExtractSubrange(int, int, unsigned long*) | void RepeatedField<Element>::ExtractSubrange(int start, int num,
Element* elements) {
GOOGLE_DCHECK_GE(start, 0);
GOOGLE_DCHECK_GE(num, 0);
GOOGLE_DCHECK_LE(start + num, this->current_size_);
// Save the values of the removed elements if requested.
if (elements !=... | testq %rcx, %rcx
sete %al
testl %edx, %edx
setle %r8b
orb %al, %r8b
jne 0x18502a
movslq %esi, %rax
movl %edx, %r8d
shlq $0x3, %rax
addq 0x8(%rdi), %rax
xorl %r9d, %r9d
movq (%rax,%r9,8), %r10
movq %r10, (%rcx,%r9,8)
incq %r9
cmpq %r9, %r8
jne 0x18501a
testl %edx, %edx
jle 0x185063
addl %edx, %esi
movslq (%rdi), %rax
cm... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<unsigned long>::Resize(int, unsigned long const&) | inline void RepeatedField<Element>::Resize(int new_size, const Element& value) {
GOOGLE_DCHECK_GE(new_size, 0);
if (new_size > current_size_) {
Reserve(new_size);
std::fill(&elements()[current_size_], &elements()[new_size], value);
}
current_size_ = new_size;
} | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jge 0x1851e3
movq %rdx, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x184a3a
movslq (%r14), %rdx
cmpl %ebx, %edx
je 0x1851e3
movq (%r15), %rax
movq 0x8(%r14), %rsi
movslq %ebx, %rcx
shlq $0x3, %rcx
leaq (,%rdx,8), %rdi
subq %rdi, %rcx
add... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<float>::operator=(google::protobuf::RepeatedField<float>&&) | inline RepeatedField<Element>& RepeatedField<Element>::operator=(
RepeatedField&& other) noexcept {
// We don't just call Swap(&other) here because it would perform 3 copies if
// the two fields are on different arenas.
if (this != &other) {
if (this->GetArenaNoVirtual() != other.GetArenaNoVirtual()) {
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1858c4
movq %rsi, %r14
leaq 0x8(%rbx), %rcx
movq 0x8(%rbx), %rax
leaq -0x8(%rax), %rdx
cmpl $0x0, 0x4(%rbx)
cmoveq %rcx, %rdx
movq (%rdx), %rdx
addq $0x8, %rsi
movq 0x8(%r14), %rcx
leaq -0x8(%rcx), %rdi
cmpl $0x0, 0x4(%r14)
cmoveq %rsi, %rdi
cmpq (%r... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<float>::at(int) | inline Element& RepeatedField<Element>::at(int index) {
GOOGLE_CHECK_GE(index, 0);
GOOGLE_CHECK_LT(index, current_size_);
return elements()[index];
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jns 0x185a1f
leaq 0xb5a11(%rip), %rdx # 0x23b3f3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x4a6, %ecx # imm = 0x4A6
callq 0x1885e8
leaq 0xb5a6f(%rip), %rsi # 0x23b46f
movq %r14, %rdi
c... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.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.