name string | code string | asm string | file string |
|---|---|---|---|
DecodeCopMemInstruction | static DecodeStatus DecodeCopMemInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned CRd = fieldFromInstruction_4(Insn, 12, 4);
unsigned coproc = fieldFromInstruction_4(Insn, 8, 4);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0xd43b8
cmpl $0x93c, %eax # imm = 0x93C
jg 0xe35df
leal -0x8a(%rax), %ecx
cmpl $0x8, %ecx
jb 0xe35f4
addl $0xfffffe73, %eax # imm = 0xFFFFFE73
cmpl $0x8, %eax
jb 0xe35f4
jmp 0xe360a
leal -... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
DecodeVCVTD | static DecodeStatus DecodeVCVTD(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Vm, imm, cmode, op;
unsigned Vd = (fieldFromInstruction_4(Insn, 12, 4) << 0);
Vd |= (fieldFromInstruction_4(Insn, 22, 1) << 4);
Vm = (fieldFromInstruction_4(Insn... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
shrl $0x5, %r14d
andl $0x1, %r14d
movl %esi, %eax
andl $0x380f00, %eax # imm = 0x380F00
cmpl $0xf00, %eax # imm = 0xF00
jne 0xe3beb
testl %r14d, %r14d
jne 0xe3bf1
movq %rbx, %rdi
movl $0x55d, %esi ... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
DecodeT2STRDPreInstruction | static DecodeStatus DecodeT2STRDPreInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rt2 = fieldFromInstruction_4(Insn, 8, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %esi, %r13d
shrl $0xc, %r13d
andl $0xf, %r13d
movl %esi, %r15d
shrl $0x8, %r15d
andl $0xf, %r15d
movl %esi, %r14d
shrl $0x10, %r14d
andl $0xf, %r14d
movl %esi, %eax
andl $0x1200000, %eax # imm = 0x1200000
xorl %ecx,... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
printAdrpLabel | static void printAdrpLabel(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNum);
if (MCOperand_isImm(Op)) {
// ADRP sign extends a 21-bit offset, shifts it left by 12
// and adds it to the value of the PC with its bottom 12 bits cleared
uint64_t imm = (MCOperand_getImm(Op) * 0... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %esi
callq 0xd43bf
movq %rax, %r14
movq %rax, %rdi
callq 0xd43f8
testb %al, %al
je 0x11be65
movq %r14, %rdi
callq 0xd4410
shlq $0xc, %rax
movq $-0x1000, %r14 # imm = 0xF000
andq 0x318(%rbx), %r14
addq %rax, %r14
m... | /google[P]bloaty/third_party/capstone/arch/AArch64/AArch64InstPrinter.c |
DecodeLO32DSPRegisterClass | static DecodeStatus DecodeLO32DSPRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo >= 4)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_LO32DSPRegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x3, %esi
ja 0x121afa
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x1b, %esi
callq 0xd88fb
movq (%rax), %rax
movl %ebp, %ecx
movzwl (%rax,%rcx,2), %esi
movq %rbx, %rdi
callq 0xd443b
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /google[P]bloaty/third_party/capstone/arch/Mips/MipsDisassembler.c |
DecodeGPR64RegisterClass | static DecodeStatus DecodeGPR64RegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 31)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_GPR64RegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0x121b33
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x23, %esi
callq 0xd88fb
movq (%rax), %rax
movl %ebp, %ecx
movzwl (%rax,%rcx,2), %esi
movq %rbx, %rdi
callq 0xd443b
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /google[P]bloaty/third_party/capstone/arch/Mips/MipsDisassembler.c |
DecodeFGR64RegisterClass | static DecodeStatus DecodeFGR64RegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 31)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_FGR64RegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0x121c1e
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x22, %esi
callq 0xd88fb
movq (%rax), %rax
movl %ebp, %ecx
movzwl (%rax,%rcx,2), %esi
movq %rbx, %rdi
callq 0xd443b
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /google[P]bloaty/third_party/capstone/arch/Mips/MipsDisassembler.c |
DecodeDaddiGroupBranch_4 | static DecodeStatus DecodeDaddiGroupBranch_4(MCInst *MI, uint32_t insn,
uint64_t Address, const MCRegisterInfo *Decoder)
{
// If we are called then we can assume that MIPS32r6/MIPS64r6 is enabled
// (otherwise we would have matched the ADDI instruction from the earlier
// ISA's instead).
//
// We have:
// 0b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
shrl $0x15, %r15d
andl $0x1f, %r15d
movl %esi, %r12d
shrl $0x10, %r12d
andl $0x1f, %r12d
movl $0x122, %esi # imm = 0x122
cmpl %r12d, %r15d
jae 0x122635
movl $0x113, %esi # imm = ... | /google[P]bloaty/third_party/capstone/arch/Mips/MipsDisassembler.c |
SystemZ_getInstruction | bool SystemZ_getInstruction(csh ud, const uint8_t *code, size_t code_len, MCInst *MI,
uint16_t *size, uint64_t address, void *info)
{
uint64_t Inst;
const uint8_t *Table;
uint16_t I;
// The top 2 bits of the first byte specify the size.
if (*code < 0x40) {
*size = 2;
Table = DecoderTable16;
} else if (*co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rcx, %r14
movq %rsi, %r12
movb (%rsi), %al
xorl %ecx, %ecx
cmpb $-0x40, %al
setae %cl
leaq 0x2f633f(%rip), %rsi # 0x44fc90
leaq 0x2f8498(%rip), %rdi # 0x451df0
cmovbq %rsi, %rdi
cmpb $0x40, %al
leal 0x4(%... | /google[P]bloaty/third_party/capstone/arch/SystemZ/SystemZDisassembler.c |
printBDLAddrOperand | static void printBDLAddrOperand(MCInst *MI, int OpNum, SStream *O)
{
unsigned Base = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
uint64_t Disp = (uint64_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1));
uint64_t Length = (uint64_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum + 2));
if (Disp > HEX_THRESHOLD... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
callq 0xd43bf
movq %rax, %rdi
callq 0xd4408
movl %eax, %r15d
leal 0x1(%r13), %esi
movq %rbx, %rdi
callq 0xd43bf
movq %rax, %rdi
callq 0xd4410
movq %rax, %r14
addl $0x2, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x... | /google[P]bloaty/third_party/capstone/arch/SystemZ/SystemZInstPrinter.c |
DecodeL4RSrcDstSrcDstInstruction | static DecodeStatus DecodeL4RSrcDstSrcDstInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
const void *Decoder)
{
unsigned Op1, Op2, Op3;
unsigned Op4 = fieldFromInstruction_4(Insn, 16, 4);
DecodeStatus S =
Decode3OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2, &Op3);
if (S == MCDisassem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %ebp
shrl $0x10, %ebp
movl %esi, %eax
shrl $0x6, %eax
andl $0x1f, %eax
cmpl $0x1a, %eax
ja 0x16206f
movl %eax, %edx
imulq $0x55555556, %rdx, %rcx # imm = 0x55555556
shrq $0x20, %rcx
leal (%rcx,%rcx,2)... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreDisassembler.c |
DecodeLR2RInstruction | static DecodeStatus DecodeLR2RInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
const void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(fieldFromInstruction_4(Insn, 0, 16), &Op1, &Op2);
if (S != MCDisassembler_Success)
return DecodeL2OpInstructionFail(Inst, Insn, Address, Decoder... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movzwl %bp, %edi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1625e8
cmpl $0x3, %eax
jne 0x1623a1
movl 0x8(%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1617b3
movl 0xc(%rsp), %esi
movq %r14, %rdi
movq %rbx, %rd... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreDisassembler.c |
DecodeL2OpInstructionFail | static DecodeStatus DecodeL2OpInstructionFail(MCInst *Inst, unsigned Insn, uint64_t Address,
const void *Decoder)
{
// Try and decode as a L3R / L2RUS instruction.
unsigned Opcode = fieldFromInstruction_4(Insn, 16, 4) |
fieldFromInstruction_4(Insn, 27, 5) << 4;
switch (Opcode) {
case 0x0c:
MCInst_setOpcode(... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %ecx
shrl $0x10, %ecx
andl $0xf, %ecx
movl %esi, %eax
shrl $0x17, %eax
andl $-0x10, %eax
orl %ecx, %eax
cmpl $0x10b, %eax # imm = 0x10B
jg 0x1627fd
cmpl $0x5b, %eax
jg 0x16283d
cmpl $0x2b, %eax
jle 0x1628ab
cmpl $0x2c... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreDisassembler.c |
XCore_printInst | void XCore_printInst(MCInst *MI, SStream *O, void *Info)
{
printInstruction(MI, O, Info);
set_mem_access(MI, false, 0);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd43b8
movl %eax, %eax
leaq 0x32f964(%rip), %rcx # 0x492650
movl (%rcx,%rax,4), %r12d
movl %r12d, %eax
andl $0x7ff, %eax # imm = 0x7FF
leaq 0x32fd31(%rip), %rcx # 0x492a30
leaq (%rax,%rcx), %r15
decq %r15
movq... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreInstPrinter.c |
set_mem_access | static void set_mem_access(MCInst *MI, bool status, int reg)
{
if (MI->csh->detail != CS_OPT_ON)
return;
MI->csh->doing_mem = status;
if (status) {
if (reg != 0xffff && reg != -0xffff) {
MI->flat_insn->detail->xcore.operands[MI->flat_insn->detail->xcore.op_count].type = XCORE_OP_MEM;
if (reg) {
MI->fl... | movq 0x320(%rdi), %rax
cmpl $0x3, 0x60(%rax)
jne 0x163407
movb %sil, 0x6c(%rax)
testb %sil, %sil
je 0x1633d9
cmpl $0xffff0001, %edx # imm = 0xFFFF0001
je 0x163349
cmpl $0xffff, %edx # imm = 0xFFFF
jne 0x163408
movq 0x310(%rdi), %rax
movq 0xf0(%rax), %rax
decb 0x58(%rax)
movq 0x310(%rdi), %rax
movq 0xf0(... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreInstPrinter.c |
printOperand | static void printOperand(MCInst *MI, int OpNum, SStream *O)
{
if (OpNum >= MI->size)
return;
_printOperand(MI, MCInst_getOperand(MI, OpNum), O);
} | movzbl 0x4(%rdi), %eax
cmpl %esi, %eax
jle 0x1635d9
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0xd43bf
movq %rax, %r15
movq %rax, %rdi
callq 0xd43f0
testb %al, %al
je 0x16353a
movq %r15, %rdi
callq 0xd4408
movl %eax, %r15d
leal -0x1(%r15), %eax
leaq 0x32fad5(%rip), %rcx # 0x492fb0
movzbl ... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreInstPrinter.c |
XCore_reg_name | const char *XCore_reg_name(csh handle, unsigned int reg)
{
#ifndef CAPSTONE_DIET
if (reg >= ARR_SIZE(reg_name_maps))
return NULL;
return reg_name_maps[reg].name;
#else
return NULL;
#endif
} | cmpl $0x19, %esi
jbe 0x1635e8
xorl %eax, %eax
retq
movl %esi, %eax
shlq $0x4, %rax
leaq 0x413a2b(%rip), %rcx # 0x577020
movq 0x8(%rax,%rcx), %rax
retq
| /google[P]bloaty/third_party/capstone/arch/XCore/XCoreMapping.c |
XCore_reg_id | xcore_reg XCore_reg_id(char *name)
{
int i;
for(i = 1; i < ARR_SIZE(reg_name_maps); i++) {
if (!strcmp(name, reg_name_maps[i].name))
return reg_name_maps[i].id;
}
// not found
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x18, %r14d
leaq 0x413a10(%rip), %r15 # 0x577020
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x6da80
testl %eax, %eax
je 0x163631
addq $0x10, %r14
cmpq $0x1a8, %r14 # imm = 0x1A8
jne 0x163610
xorl %eax, %eax
jmp 0x163636
movl -0x8(%r14,%r15), %eax
po... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreMapping.c |
XCore_insn_name | const char *XCore_insn_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
unsigned int i;
if (id >= XCORE_INS_ENDING)
return NULL;
// handle special alias first
for (i = 0; i < ARR_SIZE(alias_insn_names); i++) {
if (alias_insn_names[i].id == id)
return alias_insn_names[i].name;
}
return insn_name... | leal -0x79(%rsi), %eax
cmpl $-0x78, %eax
jae 0x163728
xorl %eax, %eax
retq
movl %esi, %eax
shlq $0x4, %rax
leaq 0x413a8b(%rip), %rcx # 0x5771c0
movq 0x8(%rax,%rcx), %rax
retq
| /google[P]bloaty/third_party/capstone/arch/XCore/XCoreMapping.c |
peek_imm_32 | static unsigned int peek_imm_32(const m68k_info *info) { return m68k_read_safe_32((info), (info)->pc); } | movl 0x20(%rdi), %ecx
subl 0x10(%rdi), %ecx
andl 0x2c(%rdi), %ecx
leaq 0x4(%rcx), %rdx
movl $0xaaaaaaaa, %eax # imm = 0xAAAAAAAA
cmpq %rdx, 0x8(%rdi)
jb 0x163b4d
movq (%rdi), %rax
movl (%rax,%rcx), %eax
bswapl %eax
retq
| /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_abcd_rr | static void d68000_abcd_rr(m68k_info *info)
{
build_rr(info, M68K_INS_ABCD, 1, 0);
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x1, %ebp
movl $0x1, %esi
callq 0xd43b1
movb $0x2, 0x118(%rbx)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x110(%rbx)
movl %ebp, 0x64(%rbx)
movl 0x24(%rbx), %eax
movl %eax, %ecx
andl $0x7, %ecx
incl %ecx
movl %ecx, 0x30(%rb... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_addi_8 | static unsigned int peek_imm_8(const m68k_info *info) { return (m68k_read_safe_16((info), (info)->pc)&0xff); } | movl 0x20(%rdi), %eax
movl %eax, %edx
subl 0x10(%rdi), %edx
andl 0x2c(%rdi), %edx
leaq 0x2(%rdx), %rsi
movl $0xaa, %ecx
cmpq %rsi, 0x8(%rdi)
jb 0x163ddc
movq (%rdi), %rcx
movzbl 0x1(%rcx,%rdx), %ecx
addl $0x2, %eax
movl %eax, 0x20(%rdi)
movl $0x4, %esi
movl $0x1, %edx
jmp 0x168c5f
| /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_addx_rr_16 | static void d68000_addx_rr_16(m68k_info *info)
{
build_rr(info, M68K_INS_ADDX, 2, 0);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x6, %esi
callq 0xd43b1
movb $0x2, 0x118(%rbx)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, 0x110(%rbx)
movl $0x1, %eax
movl %eax, 0x64(%rbx)
movl 0x24(%rbx), %ecx
movl %ecx, %edx
andl $0x7, %edx
incl %edx
movl %edx, 0x30(%rbx)
movl %eax, 0x9c(%rb... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_addx_mm_8 | static void d68000_addx_mm_8(m68k_info *info)
{
build_mm(info, M68K_INS_ADDX, 1, 0);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x6, %esi
callq 0xd43b1
movb $0x2, 0x118(%rbx)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x110(%rbx)
movl $0x5, %eax
movl %eax, 0x64(%rbx)
movl 0x24(%rbx), %ecx
movl %ecx, %edx
andl $0x7, %edx
addl $0x9, %edx
movl %edx, 0x30(%rbx)
movl %eax, 0x... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_asr_r_16 | static void d68000_asr_r_16(m68k_info *info)
{
build_r(info, M68K_INS_ASR, 2);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0xa, %esi
callq 0xd43b1
movb $0x2, 0x118(%rbx)
movabsq $0x200000001, %rax # imm = 0x200000001
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 %edx
movl %edx, 0x30(%rbx)
mov... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_bra_8 | static void d68000_bra_8(m68k_info *info)
{
build_relative_branch(info, M68K_INS_BRA, 1, make_int_8(info->ir));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x24(%rdi), %eax
movzbl %al, %eax
movsbl %al, %ebp
andl $0xffffff00, %ebp # imm = 0xFFFFFF00
orl %eax, %ebp
movq 0x18(%rdi), %rdi
movl $0x1b, %esi
callq 0xd43b1
movb $0x1, %al
movb %al, 0x118(%rbx)
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx,... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_bra_32 | static void d68020_bra_32(m68k_info *info)
{
LIMIT_CPU_TYPES(info, M68020_PLUS);
build_relative_branch(info, M68K_INS_BRA, 4, read_imm_32(info));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x1649fa
movq %rbx, %rdi
callq 0x163b2d
movl %eax, %ebp
addl $0x4, 0x20(%rbx)
movq 0x18(%rbx), %rdi
movl $0x1b, %esi
callq 0xd43b1
movb $0x1, %al
movb %al, 0x118(%rbx)
movabsq $0x400000001, %rcx # imm = 0x400000001
movq %rcx, 0x110(%rbx)
m... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_bsr_32 | static void d68020_bsr_32(m68k_info *info)
{
LIMIT_CPU_TYPES(info, M68020_PLUS);
build_relative_branch(info, M68K_INS_BSR, 4, peek_imm_32(info));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x164c14
movq %rbx, %rdi
callq 0x163b2d
movl %eax, %ebp
movq 0x18(%rbx), %rdi
movl $0x1c, %esi
callq 0xd43b1
movb $0x1, %al
movb %al, 0x118(%rbx)
movabsq $0x400000001, %rcx # imm = 0x400000001
movq %rcx, 0x110(%rbx)
movabsq $0x1300000008, ... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_cpbcc_16 | static void d68020_cpbcc_16(m68k_info *info)
{
cs_m68k_op* op0;
cs_m68k* ext;
LIMIT_CPU_TYPES(info, M68020_PLUS);
// these are all in row with the extension so just doing a add here is fine
info->inst->Opcode += (info->ir & 0x2f);
ext = build_init_op(info, M68K_INS_FBF, 1, 2);
op0 = &ext->operands[0];
make_c... | pushq %rbx
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
movl 0x24(%rdi), %edx
je 0x165299
andl $0x2f, %edx
movq 0x18(%rbx), %rdi
addl %edx, 0x8(%rdi)
movl $0x5f, %esi
callq 0xd43b1
movb $0x1, 0x118(%rbx)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, 0x110(%rbx)
movl 0x20(%rbx), %eax
movl %eax, %edx
subl 0x1... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_cpdbcc | static void d68020_cpdbcc(m68k_info *info)
{
cs_m68k* ext;
cs_m68k_op* op0;
cs_m68k_op* op1;
uint ext1, ext2;
LIMIT_CPU_TYPES(info, M68020_PLUS);
ext1 = read_imm_16(info);
ext2 = read_imm_16(info);
// these are all in row with the extension so just doing a add here is fine
info->inst->Opcode += (ext1 & 0x2f... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x165457
movl 0x20(%rbx), %eax
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
movl %eax, %ecx
subl %edi, %ecx
movl 0x2c(%rbx), %edx
movl %edx, %r8d
andl %ecx, %r8d
leaq 0x2(%r8), %r9
movl $0x2a, %ecx
cmpq %r9, %rsi
jb 0x165391
movq (%rbx), %rcx
mov... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_cprestore | static void d68020_cprestore(m68k_info *info)
{
cs_m68k* ext;
LIMIT_CPU_TYPES(info, M68020_PLUS);
ext = build_init_op(info, M68K_INS_FRESTORE, 1, 0);
get_ea_mode_op(info, &ext->operands[0], info->ir, 1);
} | pushq %rbx
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x165a17
movq 0x18(%rbx), %rdi
movl $0xbd, %esi
callq 0xd43b1
leaq 0x30(%rbx), %rsi
movb $0x1, 0x118(%rbx)
movq $0x1, 0x110(%rbx)
movl 0x24(%rbx), %edx
movq %rbx, %rdi
movl $0x1, %ecx
popq %rbx
jmp 0x168746
movl 0x24(%rbx), %edx
movq %rbx, %rdi
xorl %esi, %esi
popq ... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_cpscc | static void d68020_cpscc(m68k_info *info)
{
cs_m68k* ext;
LIMIT_CPU_TYPES(info, M68020_PLUS);
ext = build_init_op(info, M68K_INS_FSF, 1, 1);
// these are all in row with the extension so just doing a add here is fine
info->inst->Opcode += (read_imm_16(info) & 0x2f);
get_ea_mode_op(info, &ext->operands[0], info... | pushq %rbx
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x165ae9
movq 0x18(%rbx), %rdi
movl $0xc8, %esi
callq 0xd43b1
leaq 0x30(%rbx), %rsi
movb $0x1, 0x118(%rbx)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x110(%rbx)
movl 0x20(%rbx), %eax
movl %eax, %edx
subl 0x10(%rbx), %edx
andl 0x2c(%rbx), %edx
le... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_cptrapcc_16 | static void d68020_cptrapcc_16(m68k_info *info)
{
uint extension1, extension2;
cs_m68k_op* op0;
cs_m68k* ext;
LIMIT_CPU_TYPES(info, M68020_PLUS);
extension1 = read_imm_16(info);
extension2 = read_imm_16(info);
ext = build_init_op(info, M68K_INS_FTRAPF, 1, 2);
// these are all in row with the extension so ju... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testb $0x1c, 0x28(%rdi)
je 0x165c25
movl 0x20(%rbx), %eax
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
movl %eax, %r8d
subl %esi, %r8d
movl 0x2c(%rbx), %ecx
movl %ecx, %edi
andl %r8d, %edi
leaq 0x2(%rdi), %r8
movl $0x2a, %ebp
cmpq %r8, %rdx
jb 0x165bb3
movq (%rbx), %r8
mov... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_dbcc | 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 0x165d33
movq (%rdi), %rcx
movzwl (%rcx,%rdx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl $0x2, %eax
movl %eax, 0x20(%rdi)
movswl %cx, %edx
andl $0xff... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68020_divl | static void d68020_divl(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 0x165e81
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 0x165df5
movq (%rbx), %rdx
movzwl (%rdx,%rcx), %ecx
rolw $0x8, %... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_lsr_r_32 | static void d68000_lsr_r_32(m68k_info *info)
{
build_r(info, M68K_INS_LSR, 4);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x118, %esi # imm = 0x118
callq 0xd43b1
movb $0x2, 0x118(%rbx)
movabsq $0x400000001, %rax # imm = 0x400000001
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 |
d68000_move_to_usp | static void d68000_move_to_usp(m68k_info *info)
{
cs_m68k_op* op0;
cs_m68k_op* op1;
cs_m68k* ext = build_init_op(info, M68K_INS_MOVE, 2, 0);
op0 = &ext->operands[0];
op1 = &ext->operands[1];
op0->address_mode = M68K_AM_NONE;
op0->reg = M68K_REG_A0 + (info->ir & 7);
op1->address_mode = M68K_AM_NONE;
op1->reg... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x119, %esi # imm = 0x119
callq 0xd43b1
movb $0x2, 0x118(%rbx)
movq $0x1, 0x110(%rbx)
movabsq $0x1e00000000, %rax # imm = 0x1E00000000
movq %rax, 0x64(%rbx)
movl 0x24(%rbx), %eax
andl $0x7, %eax
addl $0x9, %eax
movl %eax, 0x30(%rbx)
movl $0x0, 0x9c(%... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_ror_r_32 | static void d68000_ror_r_32(m68k_info *info)
{
build_r(info, M68K_INS_ROR, 4);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x13d, %esi # imm = 0x13D
callq 0xd43b1
movb $0x2, 0x118(%rbx)
movabsq $0x400000001, %rax # imm = 0x400000001
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 |
printMemOperand2 | static void printMemOperand2(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNo);
int64_t Val = MCOperand_getImm(Op);
uint16_t offset;
unsigned basereg;
cs_tms320c64x *tms320c64x;
basereg = Val & 0x7f;
offset = (Val >> 7) & 0x7fff;
SStream_concat(O, "*+%s[0x%x]", getRegisterNam... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %esi
callq 0xd43bf
movq %rax, %rdi
callq 0xd4410
movq %rax, %rbx
movl %ebx, %r12d
andl $0x7f, %r12d
shrl $0x7, %ebx
andl $0x7fff, %ebx # imm = 0x7FFF
leal -0x1(%r12), %eax
leaq 0x32bd5f(%rip), %rcx # 0x498310
... | /google[P]bloaty/third_party/capstone/arch/TMS320C64x/TMS320C64xInstPrinter.c |
TMS320C64x_reg_name | const char *TMS320C64x_reg_name(csh handle, unsigned int reg)
{
#ifndef CAPSTONE_DIET
if (reg >= ARR_SIZE(reg_name_maps))
return NULL;
return reg_name_maps[reg].name;
#else
return NULL;
#endif
} | cmpl $0x59, %esi
jbe 0x16c640
xorl %eax, %eax
retq
movl %esi, %eax
shlq $0x4, %rax
leaq 0x40c063(%rip), %rcx # 0x5786b0
movq 0x8(%rax,%rcx), %rax
retq
| /google[P]bloaty/third_party/capstone/arch/TMS320C64x/TMS320C64xMapping.c |
TMS320C64x_get_insn_id | void TMS320C64x_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id)
{
unsigned short i;
i = insn_find(insns, ARR_SIZE(insns), id, &h->insn_cache);
if (i != 0) {
insn->id = insns[i].mapid;
if (h->detail) {
#ifndef CAPSTONE_DIET
memcpy(insn->detail->regs_read, insns[i].regs_use, sizeof(insns[i].regs_use... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x70(%rdi), %rcx
leaq 0x47e806(%rip), %r14 # 0x5eaeb0
movq %r14, %rdi
movl $0x103, %esi # imm = 0x103
callq 0xd4728
testw %ax, %ax
je 0x16c76f
movzwl %ax, %eax
imulq $0x4e, %rax, %rax
movzwl 0x2(%rax,%r14), %ecx
movl %ecx, (%rbx)
cmpl $... | /google[P]bloaty/third_party/capstone/arch/TMS320C64x/TMS320C64xMapping.c |
M680X_get_insn_id | void M680X_get_insn_id(cs_struct *handle, cs_insn *insn, unsigned int id)
{
const m680x_info *const info = (const m680x_info *)handle->printer_info;
const cpu_tables *cpu = info->cpu;
uint8_t insn_prefix = (id >> 8) & 0xff;
int index;
int i;
insn->id = M680X_INS_ILLGL;
for (i = 0; i < ARR_SIZE(cpu->pageX_prefi... | pushq %rbx
movq 0x10(%rdi), %rax
movq 0xf0(%rax), %rcx
movl %edx, %edi
shrl $0x8, %edi
movl $0x9f, (%rsi)
movq $-0x3, %r9
movq 0x60(%rcx,%r9,8), %r8
testq %r8, %r8
je 0x16c80e
movq 0x48(%rcx,%r9,8), %rax
testq %rax, %rax
je 0x16c80e
cmpb %dil, 0x2b(%rcx,%r9)
je 0x16c8b3
incq %r9
jne 0x16c7ea
testl $0xff00, %edx ... | /google[P]bloaty/third_party/capstone/arch/M680X/M680XDisassembler.c |
M680X_reg_access | void M680X_reg_access(const cs_insn *insn,
cs_regs regs_read, uint8_t *regs_read_count,
cs_regs regs_write, uint8_t *regs_write_count)
{
if (insn->detail == NULL) {
*regs_read_count = 0;
*regs_write_count = 0;
}
else {
*regs_read_count = insn->detail->regs_read_count;
*regs_write_count = insn->detail->regs... | pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq 0xf0(%rdi), %rax
testq %rax, %rax
je 0x16d6cf
movq %rcx, %r14
movq %rdi, %r15
movb 0x20(%rax), %al
movb %al, (%rdx)
movq 0xf0(%rdi), %rax
movb 0x4a(%rax), %al
movb %al, (%rbx)
movq 0xf0(%rdi), %rax
movzbl (%rdx), %edx
addl %edx, %edx
movq %rsi, %rdi
movq %rax, %rsi
c... | /google[P]bloaty/third_party/capstone/arch/M680X/M680XDisassembler.c |
relative8_hdlr | static void relative8_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
{
int16_t offset = 0;
read_byte_sign_extended(info, &offset, (*address)++);
add_rel_operand(info, offset, *address + offset);
add_insn_group(MI->flat_insn->detail, M680X_GRP_BRAREL);
if ((info->insn != M680X_INS_BRA) &&
(info->insn != ... | movzwl (%rdx), %ecx
leal 0x1(%rcx), %eax
movw %ax, (%rdx)
movzwl 0xc(%rsi), %edx
subq %rdx, %rcx
cmpl 0x8(%rsi), %ecx
jae 0x16d8bb
movq (%rsi), %rdx
movzbl (%rdx,%rcx), %ecx
movl %ecx, %edx
orl $0xffffff00, %edx # imm = 0xFFFFFF00
testb %cl, %cl
movzbl %cl, %ecx
cmovsl %edx, %ecx
jmp 0x16d8bd
xorl %ecx, %ecx
movs... | /google[P]bloaty/third_party/capstone/arch/M680X/M680XDisassembler.c |
relative16_hdlr | static void relative16_hdlr(MCInst *MI, m680x_info *info, uint16_t *address)
{
uint16_t offset = 0;
read_word(info, &offset, *address);
*address += 2;
add_rel_operand(info, (int16_t)offset, *address + offset);
add_insn_group(MI->flat_insn->detail, M680X_GRP_BRAREL);
if ((info->insn != M680X_INS_LBRA) &&
(info... | movzwl (%rdx), %eax
movzwl 0xc(%rsi), %ecx
movq %rax, %r8
subq %rcx, %r8
leaq 0x1(%r8), %rcx
cmpl 0x8(%rsi), %ecx
jae 0x16d95a
movq (%rsi), %r9
movzbl (%r9,%r8), %r8d
shll $0x8, %r8d
movzbl (%r9,%rcx), %ecx
orl %r8d, %ecx
jmp 0x16d95c
xorl %ecx, %ecx
leal 0x2(%rax), %r8d
movw %r8w, (%rdx)
addl %ecx, %eax
addl $0x2, %ea... | /google[P]bloaty/third_party/capstone/arch/M680X/M680XDisassembler.c |
absl::WebSafeBase64Escape[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>) | std::string WebSafeBase64Escape(absl::string_view src) {
std::string dest;
strings_internal::Base64EscapeInternal(
reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest,
false, strings_internal::kWebSafeBase64Chars);
return dest;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x340dd2(%rip), %r8 # 0x4b2180
movq %rdx, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x171626
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/escaping.cc |
absl::StrCat[abi:cxx11](absl::AlphaNum const&, absl::AlphaNum const&) | std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
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_limits<size_t>::max()};
const uint64_t result_size =
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rdx), %rsi
addq (%r13), %rsi
xorl %edx, %edx
callq 0x6d1f0
movq (%rbx), %r15
movq (%r13), %r12
testq %r12, %r12
je 0x174222
mov... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/str_cat.cc |
absl::substitute_internal::SubstituteAndAppendArray(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>> const*, unsigned long) | void SubstituteAndAppendArray(
absl::Nonnull<std::string*> output, absl::string_view format,
absl::Nullable<const absl::string_view*> args_array, size_t num_args) {
// Determine total size needed.
size_t size = 0;
for (size_t i = 0; i < format.size(); i++) {
if (format[i] == '$') {
if (i + 1 >= ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x174e89
movq %r8, %r13
xorl %esi, %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpb $0x24, (%rbx,%rax)
jne 0x174e7c
incq %rax
cmpq %r14, %rax
jae 0x174ff3
movzb... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/substitute.cc |
absl::strings_internal::ParsedFloat absl::strings_internal::ParseFloat<10>(char const*, char const*, absl::chars_format) | strings_internal::ParsedFloat ParseFloat(const char* begin, const char* end,
chars_format format_flags) {
strings_internal::ParsedFloat result;
// Exit early if we're given an empty range.
if (begin == end) return result;
// Handle the infinity and NaN cases.
if (Par... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0x0, 0x10(%rdi)
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
cmpq %rdx, %rsi
je 0x178049
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_parse.cc |
absl::FindLongestCommonSuffix(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | absl::string_view FindLongestCommonSuffix(absl::string_view a,
absl::string_view b) {
const absl::string_view::size_type limit = std::min(a.size(), b.size());
if (limit == 0) return absl::string_view();
const char* pa = a.data() + a.size() - 1;
const char* pb = b.data(... | cmpq %rdi, %rdx
movq %rdi, %r8
cmovbq %rdx, %r8
testq %r8, %r8
je 0x1784b4
movq %rdx, %rax
leaq (%rsi,%rdi), %rdx
subq %r8, %rdi
addq %rsi, %rdi
addq %rax, %rcx
decq %rcx
xorl %eax, %eax
movb -0x1(%rdx), %sil
cmpb (%rcx), %sil
jne 0x1784b8
decq %rdx
incq %rax
decq %rcx
cmpq %rax, %r8
jne 0x178496
movq %rdi, %rdx
movq %... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/match.cc |
absl::debugging_internal::ParseRequirement(absl::debugging_internal::State*) | static bool ParseRequirement(State *state) {
ComplexityGuard guard(state);
if (guard.IsTooComplex()) return false;
ParseState copy = state->parse_state;
if (ParseOneCharToken(state, 'X') && ParseExpression(state) &&
Optional(ParseOneCharToken(state, 'N')) &&
// This logic backtracks cleanly if we ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %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 %al, %cl
jne... | /google[P]bloaty/third_party/abseil-cpp/absl/debugging/internal/demangle.cc |
absl::debugging_internal::ParseDiscriminator(absl::debugging_internal::State*) | static bool ParseDiscriminator(State *state) {
ComplexityGuard guard(state);
if (guard.IsTooComplex()) return false;
ParseState copy = state->parse_state;
// Both forms start with _ so parse that first.
if (!ParseOneCharToken(state, '_')) return false;
// <digit>
if (ParseDigit(state, nullptr)) return t... | pushq %rbx
subq $0x10, %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 %al, %cl
jne 0x17bec4
movups 0x1c(... | /google[P]bloaty/third_party/abseil-cpp/absl/debugging/internal/demangle.cc |
void google::protobuf::internal::RepeatedFieldHelper<5>::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 0x17f040
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 0x181926
movq 0x8(%r15), %rdi... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::PackedFieldHelper<6>::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 0x17f203
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
movq %rsp, %rdi
movl %eax, (%rdi)
movq %rdx, %rsi
callq 0x181926
movl 0x10(%r14), %eax
leaq 0x4(%rsp), %rdi
movl %eax, (%rdi)
movq %rbx, %rsi
callq 0x181926
cmpl $0x0, (%r14)
jle 0x1... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::SingularFieldHelper<7>::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 0x181926
movl (%r14), %ebp
movq 0x40(%rbx), %rsi
cmpq (%rbx), %rsi
jae 0x17f247
movq 0x40(%rbx), %rax
movl %ebp, (%rax)
addq $0x4, %rax
movq %rax, 0x40(%rbx... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::PackedFieldHelper<9>::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) {
GOOGLE_LOG(FATAL) << "Not implemented field number " << md.tag << " with type "
<< md.type;
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x326a03(%rip), %rdx # 0x4a5f2c
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x205, %ecx # imm = 0x205
callq 0x18d728
leaq 0x326a6a(%rip), %rsi # 0x4a5fb1
movq %r14, %rdi
callq 0x18d1cc
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
void google::protobuf::internal::RepeatedFieldHelper<1>::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 0x17fda4
xorl %eax, %eax
movl 0x4(%rsi), %r9d
movq (%rdx), %rcx
cmpl $0x7f, %r9d
ja 0x17fd3a
movb %r9b, (%rcx)
incq %rcx
jmp 0x17fd84
movl %r9d, %r8d
orb $-0x80, %r8b
movb %r8b, (%rcx)
movl %r9d, %r8d
shrl $0x7, %r8d
cmpl $0x3fff, %r9d # imm = 0x3FFF
ja 0x17fd5e
movb %r8b, 0x1(%rcx)
addq... | /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 0x181f74
movq 0x8(%rsi), %rax
movl (%rsi), %edx
decl %edx
addq $0x18, %rax
movzbl 0x8(%rbx), %ecx
movq (%rbx), %r8
movq %rax, %rsi
callq 0x17d8da
movq %rax, (%rbx)
popq %rbx
retq
movq %rbx, %rsi
popq %rbx
jmp 0x17cf26
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_util.cc |
google::protobuf::io::CodedInputStream::ReadRaw(void*, int) | bool CodedInputStream::ReadRaw(void* buffer, int size) {
int current_buffer_size;
while ((current_buffer_size = BufferSize()) < size) {
// Reading past end of buffer. Copy what we have, then refresh.
memcpy(buffer, buffer_, current_buffer_size);
buffer = reinterpret_cast<uint8*>(buffer) + current_buffe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %ebp, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %r13
subq %rsi, %r13
subl %r13d, %ebp
jle 0x18261d
movslq %r13d, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x6d5a0
addq %r15, %r14
addq %r15, (... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/coded_stream.cc |
google::protobuf::io::FileInputStream::CopyingFileInputStream::Skip(int) | int FileInputStream::CopyingFileInputStream::Skip(int count) {
GOOGLE_CHECK(!is_closed_);
if (!previous_seek_failed_ && lseek(file_, count, SEEK_CUR) != (off_t)-1) {
// Seek succeeded.
return count;
} else {
// Failed to seek.
// Note to self: Don't seek again. This file descriptor doesn't
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
movb 0xd(%rdi), %bpl
cmpb $0x1, %bpl
jne 0x183c29
leaq 0x3225de(%rip), %rdx # 0x4a61ca
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x94, %ecx
callq 0x18d728
leaq 0x322658(%rip), %rsi # 0x4a6262
movq %r15, ... | /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 0x3f9fcf(%rip), %rax # 0x57e2c0
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x184b4c
leaq 0x8(%rbx), %rdi
callq 0x183a54
movq %rbx, %rdi
popq %rbx
jmp 0x6d670
nop
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h |
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 0x184ea6
leaq 0x32166f(%rip), %rdx # 0x4a64d8
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x107, %ecx # imm = 0x107
callq 0x18d728
leaq 0x321771(%rip), %rsi # 0x4a65f8
movq %r15, %rdi
c... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc |
google::protobuf::RepeatedField<bool>::at(int) const | inline const Element& RepeatedField<Element>::at(int index) const {
GOOGLE_CHECK_GE(index, 0);
GOOGLE_CHECK_LT(index, current_size_);
return elements()[index];
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jns 0x18722d
leaq 0xc0253(%rip), %rdx # 0x247443
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x49f, %ecx # imm = 0x49F
callq 0x18d728
leaq 0xc02b1(%rip), %rsi # 0x2474bf
movq ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<bool>::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 %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jns 0x18730b
leaq 0xc0175(%rip), %rdx # 0x247443
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x4a6, %ecx # imm = 0x4A6
callq 0x18d728
leaq 0xc01d3(%rip), %rsi # 0x2474bf
movq ... | /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 0x187642
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
movq (%rdx), %rsi
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rcx
leaq -0x8(%rcx), %rdx
cmpl $0x0, 0x4... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<bool>::erase(bool const*) | inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
const_iterator position) {
return erase(position, position + 1);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
incq %rsi
movq 0x8(%rdi), %r14
subl %r14d, %eax
movslq (%rdi), %r12
addq %r14, %r12
movslq %eax, %r15
addq %r15, %r14
subq %rsi, %r12
je 0x187758
movq %r14, %rdi
movq %r12, %rdx
callq 0x6dc70
cmpl $0x0, (%rbx)
jle 0x187767
addl %r12d... | /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, %rbx
movq 0x8(%rdi), %rax
movq %rsi, %r12
subq %rax, %r12
cmpq %rdx, %rsi
je 0x1877c2
movslq (%rbx), %r14
addq %rax, %r14
movslq %r12d, %r15
addq %rax, %r15
subq %rdx, %r14
je 0x1877b3
movq %r15, %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x6dc70
cmpl $0... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<int>::Reserve(int) | void RepeatedField<Element>::Reserve(int new_size) {
if (total_size_ >= new_size) return;
Rep* old_rep = total_size_ > 0 ? rep() : NULL;
Rep* new_rep;
Arena* arena = GetArenaNoVirtual();
new_size = std::max(internal::kMinRepeatedFieldAllocationSize,
std::max(total_size_ * 2, new_size));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x4(%rdi), %r13d
cmpl %esi, %r13d
jge 0x187902
movq %rdi, %r14
leaq 0x8(%rdi), %rax
movq 0x8(%rdi), %rcx
addq $-0x8, %rcx
xorl %ebx, %ebx
testl %r13d, %r13d
cmovgq %rcx, %rbx
cmoveq %rax, %rcx
movq (%rcx), %r15
leal (,%r13,2), %eax
cmpl %... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<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::internal::WireFormatLite::WriteDoubleArray(double const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteDoubleArray(const double* a, int n,
io::CodedOutputStream* output) {
WriteArray<double>(a, n, output);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
shll $0x3, %edx
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x18fef8
movq %r14, %rdi
movq %r15, %rdx
callq 0x6d5a0
addq %r15, %r14
movq %r14, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
mo... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteFixed32Array(unsigned int const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteFixed32Array(const uint32* a, int n,
io::CodedOutputStream* output) {
WriteArray<uint32>(a, n, output);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
shll $0x2, %edx
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x18ff42
movq %r14, %rdi
movq %r15, %rdx
callq 0x6d5a0
addq %r15, %r14
movq %r14, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
mo... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteFixed64Array(unsigned long const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteFixed64Array(const uint64* a, int n,
io::CodedOutputStream* output) {
WriteArray<uint64>(a, n, output);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
shll $0x3, %edx
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x18ff8c
movq %r14, %rdi
movq %r15, %rdx
callq 0x6d5a0
addq %r15, %r14
movq %r14, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
mo... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteSFixed32Array(int const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteSFixed32Array(const int32* a, int n,
io::CodedOutputStream* output) {
WriteArray<int32>(a, n, output);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
shll $0x2, %edx
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x18ffd6
movq %r14, %rdi
movq %r15, %rdx
callq 0x6d5a0
addq %r15, %r14
movq %r14, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
mo... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteSFixed64Array(long const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteSFixed64Array(const int64* a, int n,
io::CodedOutputStream* output) {
WriteArray<int64>(a, n, output);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
shll $0x3, %edx
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x190020
movq %r14, %rdi
movq %r15, %rdx
callq 0x6d5a0
addq %r15, %r14
movq %r14, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
mo... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format_lite.cc |
unsigned long const& google::protobuf::Reflection::GetRaw<unsigned long>(google::protobuf::Message const&, google::protobuf::FieldDescriptor const*) const | const Type& Reflection::GetRaw(const Message& message,
const FieldDescriptor* field) const {
if (field->containing_oneof() && !HasOneofField(message, field)) {
return DefaultRaw<Type>(field);
}
return GetConstRefAtOffset<Type>(message, schema_.GetFieldOffset(field));
} | pushq %rbx
movq %rsi, %rbx
movq 0x58(%rdx), %rax
testq %rax, %rax
je 0x19b838
movq 0x10(%rax), %rcx
subq 0x30(%rcx), %rax
shrq $0x4, %rax
imull $0xaaaaaaac, %eax, %eax # imm = 0xAAAAAAAC
addl 0x2c(%rdi), %eax
movl (%rbx,%rax), %eax
cmpl 0x44(%rdx), %eax
jne 0x19b84e
addq $0x8, %rdi
movq %rdx, %rsi
callq 0x19b8f8
movl %... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/generated_message_reflection.cc |
google::protobuf::internal::ExtensionSet::MessageSetByteSize() const::$_0 google::protobuf::internal::ExtensionSet::ForEach<std::_Rb_tree_iterator<std::pair<int const, google::protobuf::internal::ExtensionSet::Extension>>, google::protobuf::internal::ExtensionSet::MessageSetByteSize() const::$_0>(std::_Rb_tree_iterator... | static KeyValueFunctor ForEach(Iterator begin, Iterator end,
KeyValueFunctor func) {
for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
return std::move(func);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpq %rsi, %rdi
je 0x1c43b5
movq %rsi, %r14
movq %rdi, %r15
movl 0x20(%r15), %esi
leaq 0x28(%r15), %rdi
callq 0x1c40da
addq %rax, (%rbx)
movq %r15, %rdi
callq 0x6d4a0
movq %rax, %r15
cmpq %r14, %rax
jne 0x1c4395
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set.h |
char const* google::protobuf::internal::ExtensionSet::ParseFieldWithExtensionInfo<google::protobuf::internal::InternalMetadataWithArenaLite>(int, bool, google::protobuf::internal::ExtensionInfo const&, google::protobuf::internal::InternalMetadataWithArenaLite*, char const*, google::protobuf::internal::ParseContext*) | const char* ExtensionSet::ParseFieldWithExtensionInfo(
int number, bool was_packed_on_wire, const ExtensionInfo& extension,
T* metadata, const char* ptr, internal::ParseContext* ctx) {
if (was_packed_on_wire) {
switch (extension.type) {
#define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r12
movl %edx, %eax
movl %esi, %r14d
movq %rdi, %r15
movq 0x90(%rsp), %r13
movzbl (%rcx), %edx
testl %eax, %eax
je 0x1c4451
leal -0x1(%rdx), %eax
cmpl $0x11, %eax
ja 0x1c5028
leaq 0x2e6ce9(%rip),... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set_inl.h |
google::protobuf::ZeroCopyCodedInputStream::Next(void const**, int*) | bool Next(const void** data, int* size) final {
if (!cis_->GetDirectBufferPointer(data, size)) return false;
cis_->Skip(*size);
return true;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x182432
movl %eax, %ebx
testb %al, %al
je 0x1c7303
movslq (%r15), %rsi
testq %rsi, %rsi
js 0x1c7303
movq 0x8(%r14), %rdi
movl 0x8(%rdi), %edx
movq (%rdi), %rax
subl %eax, %edx
cmpl %edx, %esi
jle 0x1c72fd
callq 0x1823c0
jmp 0x1... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/message_lite.cc |
google::protobuf::UnescapeCEscapeSequences(char const*, char*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*) | int UnescapeCEscapeSequences(const char* source, char* dest,
std::vector<string> *errors) {
GOOGLE_DCHECK(errors == nullptr) << "Error reporting not implemented.";
char* d = dest;
const char* p = source;
// Small optimization for case where source = dest and there's no escaping
... | cmpq %rsi, %rdi
je 0x1c7eda
movq %rsi, %rax
jmp 0x1c7f01
movq %rsi, %rcx
movzbl (%rdi), %eax
testl %eax, %eax
je 0x1c7efe
cmpl $0x5c, %eax
je 0x1c7efe
leaq 0x1(%rdi), %r9
leaq 0x1(%rcx), %rax
cmpq %rdi, %rcx
movq %r9, %rdi
movq %rax, %rcx
je 0x1c7edd
jmp 0x1c7f04
movq %rcx, %rax
movq %rdi, %r9
movabsq $0x3f0000003f, %r... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::UnescapeCEscapeString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::... | int UnescapeCEscapeString(const string& src, string* dest,
std::vector<string> *errors) {
std::unique_ptr<char[]> unescaped(new char[src.size() + 1]);
int len = UnescapeCEscapeSequences(src.c_str(), unescaped.get(), errors);
GOOGLE_CHECK(dest);
dest->assign(unescaped.get(), len);
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
incq %rdi
callq 0x6d040
movq %rax, %rbx
movq (%r15), %rdi
movq %rax, %rsi
callq 0x1c7ed0
movl %eax, %ebp
testq %r14, %r14
jne 0x1c8149
leaq 0x2e43a3(%rip), %rdx # 0x4ac4b0
leaq 0x10(%rsp), %rdi
movl $0x3... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::strings::Utf8SafeCEscape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string Utf8SafeCEscape(const string& src) {
const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
std::unique_ptr<char[]> dest(new char[dest_length]);
const int len = CEscapeInternal(src.data(), src.size(),
dest.get(), dest_length, false, true);
GOOGLE_DCHEC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %r12d
leal (,%r12,4), %eax
leal 0x1(,%r12,4), %ebp
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %ebp, %eax
movslq %eax, %rdi
callq 0x6d040
movq %rax, %r14
movq (%r15), %rdi
movl %r12d, %esi... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::FastInt64ToBuffer(long, char*) | char *FastInt64ToBuffer(int64 i, char* buffer) {
// We could collapse the positive and negative sections, but that
// would be slightly slower for positive numbers...
// 22 bytes is enough to store -2**64, -18446744073709551616.
char* p = buffer + kFastInt64ToBufferOffset;
*p-- = '\0';
if (i >= 0) {
do ... | movb $0x0, 0x15(%rsi)
testq %rdi, %rdi
js 0x1c87c5
addq $0x15, %rsi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %r8
leaq -0x1(%rsi), %rcx
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %edi, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, -0x1(%rsi)
movq %rcx,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::FastHexToBuffer(int, char*) | char *FastHexToBuffer(int i, char* buffer) {
GOOGLE_CHECK(i >= 0) << "FastHexToBuffer() wants non-negative integers, not " << i;
static const char *hexdigits = "0123456789abcdef";
char *p = buffer + 21;
*p-- = '\0';
do {
*p-- = hexdigits[i & 15]; // mod by 16
i >>= 4; // divide b... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movl %edi, %ebp
testl %edi, %edi
jns 0x1c895f
leaq 0x2e3ba7(%rip), %rdx # 0x4ac4b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x38d, %ecx # imm = 0x38D
callq 0x18d728
leaq 0x2e3c1a(%rip), %rsi # 0x4ac541
movq %r14, %rdi
c... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::DelocalizeRadix(char*) | void DelocalizeRadix(char* buffer) {
// Fast check: if the buffer has a normal decimal point, assume no
// translation is needed.
if (strchr(buffer, '.') != nullptr) return;
// Find the first unknown character.
while (IsValidFloatChar(*buffer)) ++buffer;
if (*buffer == '\0') {
// No radix character f... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x2e, %esi
callq 0x6d280
testq %rax, %rax
jne 0x1c9042
addq $0x2, %rbx
movabsq $0x400000004000005, %rax # imm = 0x400000004000005
movzbl -0x2(%rbx), %ecx
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x1c9017
leal -0x2b(%rcx), %edx
cmpl $0x3a, %edx
ja 0x1c901c
btq %rdx,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) | string StrCat(const AlphaNum &a, const AlphaNum &b) {
string result;
result.resize(a.size() + b.size());
char *const begin = &*result.begin();
char *out = Append2(begin, a, b);
GOOGLE_DCHECK_EQ(out, begin + result.size());
return result;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq 0x8(%r15), %rsi
xorl %edx, %edx
callq 0x6d1f0
movq (%rbx), %r12
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) | string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c) {
string result;
result.resize(a.size() + b.size() + c.size());
char *const begin = &*result.begin();
char *out = Append2(begin, a, b);
out = Append1(out, c);
GOOGLE_DCHECK_EQ(out, begin + result.size());
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq 0x8(%r12), %rsi
addq 0x8(%rcx), %rsi
xorl %edx, %edx
callq 0x6d1f0
movq (%rbx), %r13
movq (%... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) | string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
const AlphaNum &d, const AlphaNum &e) {
string result;
result.resize(a.size() + b.size() + c.size() + d.size() + e.size());
char *const begin = &*result.begin();
char *out = Append4(begin, a, b, c, d);
out = Append1(out, e);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq 0x8(%r14), %rsi
addq 0x8(%rcx), %rsi
addq 0x8(%r8), %rs... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::Base64EscapeInternal(unsigned char const*, int, char*, int, char const*, bool) | int Base64EscapeInternal(const unsigned char *src, int szsrc,
char *dest, int szdest, const char *base64,
bool do_padding) {
static const char kPad64 = '=';
if (szsrc <= 0) return 0;
if (szsrc * 4 > szdest * 3) return 0;
char *cur_dest = dest;
const unsigne... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %eax, %eax
testl %esi, %esi
jle 0x1caab4
movq %rdx, %rbx
leal (,%rsi,4), %edx
leal (%rcx,%rcx,2), %r10d
cmpl %r10d, %edx
jg 0x1caab4
movl %esi, %edx
leaq (%rdi,%rdx), %r14
addq %rdi, %rdx
addq $-0x3, %rdx
movq %rbx, %r12
cmpq %rdi, %rdx
jbe 0x1ca91e
movl... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::EncodeAsUTF8Char(unsigned int, char*) | int EncodeAsUTF8Char(uint32 code_point, char* output) {
uint32 tmp = 0;
int len = 0;
if (code_point <= 0x7f) {
tmp = code_point;
len = 1;
} else if (code_point <= 0x07ff) {
tmp = 0x0000c080 |
((code_point & 0x07c0) << 2) |
(code_point & 0x003f);
len = 2;
} else if (code_point <... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl $0x0, 0xc(%rsp)
cmpl $0x7f, %edi
ja 0x1cac25
movl %edi, 0xc(%rsp)
movl $0x1, %ebp
jmp 0x1cacb1
cmpl $0x7ff, %edi # imm = 0x7FF
ja 0x1cac4a
movl %edi, %eax
andl $0x7c0, %eax # imm = 0x7C0
andl $0x3f, %edi
leal (%rdi,%rax,4), %ea... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::CleanStringLineEndings(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool) | void CleanStringLineEndings(string *str, bool auto_end_last_line) {
ptrdiff_t output_pos = 0;
bool r_seen = false;
ptrdiff_t len = str->size();
char *p = &(*str)[0];
for (ptrdiff_t input_pos = 0; input_pos < len;) {
if (!r_seen && input_pos + 8 < len) {
uint64_t v = GOOGLE_UNALIGNED_LOAD64(p + inp... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movabsq $-0x7f7f7f7f7f7f7f80, %rdx # imm = 0x8080808080808080
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
xorl %r10d, %r10d
movabsq $0xe0e0e0e0e0e0e0d, %rdi # imm = 0xE0E0E0E0E0E0E0D
xorl %r9d, %r9d
xorl %r11d, %r11d
movq %r11, %r14
movq %r10, %r15
cmpq ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
bool google::protobuf::safe_int_internal<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int*) | bool safe_int_internal(string text, IntType* value_p) {
*value_p = 0;
bool negative;
if (!safe_parse_sign(&text, &negative)) {
return false;
}
if (!negative) {
return safe_parse_positive_int(text, value_p);
} else {
return safe_parse_negative_int(text, value_p);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rsi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq (%rax,%rcx), %rsi
movq %rax, %rdx
testq %rcx, %rcx
jle 0x1caf95
movq %rax, %rdx
cmpb $0x20, (%rdx)
jne 0x1caf95
incq %rdx
cmpq %rsi, %rdx
jb 0x1caf88
addq %rax, %rcx... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
bool google::protobuf::safe_uint_internal<unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long*) | bool safe_uint_internal(string text, IntType* value_p) {
*value_p = 0;
bool negative;
if (!safe_parse_sign(&text, &negative) || negative) {
return false;
}
return safe_parse_positive_int(text, value_p);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rsi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq (%rax,%rcx), %rdi
movq %rax, %rdx
testq %rcx, %rcx
jle 0x1cb2b7
movq %rax, %rdx
cmpb $0x20, (%rdx)
jne 0x1cb2b7
incq %rdx
cmpq %rdi, %rdx
jb 0x1cb2aa
addq %rax, %rcx... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
bool google::protobuf::safe_parse_negative_int<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long*) | char *InternalFastHexToBuffer(uint64 value, char* buffer, int num_byte) {
static const char *hexdigits = "0123456789abcdef";
buffer[num_byte] = '\0';
for (int i = num_byte - 1; i >= 0; i--) {
#ifdef _M_X64
// MSVC x64 platform has a bug optimizing the uint32(value) in the #else
// block. Given that the ui... | pushq %rbx
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setle %al
jle 0x1cb5d4
movq (%rdi), %rdx
addq %rdx, %rcx
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
xorl %edi, %edi
movabsq $-0xccccccccccccccd, %r9 # imm = 0xF333333333333333
leaq 0x8(%r8), %r10
movzbl (%rdx), %r11d
leal -0x3a(%r11), %ebx
cmpb $-0xb, %... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::internal::AnyMetadata::PackFrom(google::protobuf::Message const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void AnyMetadata::PackFrom(const Message& message,
const std::string& type_url_prefix) {
type_url_->SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString(),
GetTypeUrl(message.GetDescriptor()->full_name(), type_url_prefix));
message.SerializeToString(value_->MutableNo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
callq 0x17ce71
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa8(%rax)
movq 0x8(%rax), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq (%r15), %rcx
movq 0x8(%r15), %r8
leaq 0x8(%rsp), %r15
movq %r... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/any.cc |
google::protobuf::internal::AnyMetadata::UnpackTo(google::protobuf::Message*) const | bool AnyMetadata::UnpackTo(Message* message) const {
if (!InternalIs(message->GetDescriptor()->full_name())) {
return false;
}
return message->ParseFromString(value_->GetNoArena());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0xa8(%rax)
movq 0x8(%rax), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x1bb4c0
testb %al, %al
je 0x1cb7d3
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/any.cc |
google::protobuf::FileDescriptor::SyntaxName(google::protobuf::FileDescriptor::Syntax) | const char* FileDescriptor::SyntaxName(FileDescriptor::Syntax syntax) {
switch (syntax) {
case SYNTAX_PROTO2:
return "proto2";
case SYNTAX_PROTO3:
return "proto3";
case SYNTAX_UNKNOWN:
return "unknown";
}
GOOGLE_LOG(FATAL) << "can't reach here.";
return nullptr;
} | pushq %rbx
subq $0x40, %rsp
testl %edi, %edi
je 0x1cb8c9
cmpl $0x2, %edi
je 0x1cb8c0
cmpl $0x3, %edi
jne 0x1cb8d2
leaq 0x2e0fcf(%rip), %rax # 0x4ac88d
jmp 0x1cb918
leaq 0x2e0fbf(%rip), %rax # 0x4ac886
jmp 0x1cb918
leaq 0x2de57b(%rip), %rax # 0x4a9e4b
jmp 0x1cb918
leaq 0x2e0fbb(%rip), %rdx # 0x4ac894
leaq 0x... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorPool::Tables::RollbackToLastCheckpoint() | void DescriptorPool::Tables::RollbackToLastCheckpoint() {
GOOGLE_DCHECK(!checkpoints_.empty());
const CheckPoint& checkpoint = checkpoints_.back();
for (int i = checkpoint.pending_symbols_before_checkpoint;
i < symbols_after_checkpoint_.size(); i++) {
symbols_by_name_.erase(symbols_after_checkpoint_[i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1e0(%rdi), %r12
movq 0x1f0(%rdi), %rsi
movslq -0xc(%r12), %r15
movq 0x1f8(%rdi), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x1cc1c5
leaq 0x138(%rbx), %r14
leaq (,%r15,8), %r13
addq %r13, %rsi
movq %r14, %rdi
callq 0x1eab1a
incq... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorPool::TryFindSymbolInFallbackDatabase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool DescriptorPool::TryFindSymbolInFallbackDatabase(
const std::string& name) const {
if (fallback_database_ == nullptr) return false;
if (tables_->known_bad_symbols_.count(name) > 0) return false;
FileDescriptorProto file_proto;
if ( // We skip looking in the fallback database if the name is a sub-symb... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x1cc4ee
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
addq $0x50, %rdi
callq 0x1ece94
testq %rax, %rax
je 0x1cc4f5
xorl %ebp, %ebp
jmp 0x1cc586
leaq 0x8(%rsp), %rdi
callq 0x1f1e26
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1cf246
testb %al,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::FileDescriptorTables::FieldsByLowercaseNamesLazyInitInternal() const | void FileDescriptorTables::FieldsByLowercaseNamesLazyInitInternal() const {
for (FieldsByNumberMap::const_iterator it = fields_by_number_.begin();
it != fields_by_number_.end(); it++) {
PointerStringPair lowercase_key(FindParentForFieldsByMap(it->second),
it->second->low... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xd8(%rdi), %r15
testq %r15, %r15
je 0x1cc637
movq %rdi, %rbx
addq $0x38, %rbx
movq %rsp, %r14
movq 0x18(%r15), %rax
movl $0x50, %ecx
cmpb $0x1, 0x42(%rax)
jne 0x1cc60c
movq 0x60(%rax), %rcx
testq %rcx, %rcx
jne 0x1cc610
movl $0x28, %ecx
movq (%rax,%rcx), %rcx
leaq... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorPool::Tables::AddSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::Symbol) | bool DescriptorPool::Tables::AddSymbol(const std::string& full_name,
Symbol symbol) {
if (InsertIfNotPresent(&symbols_by_name_, full_name.c_str(), symbol)) {
symbols_after_checkpoint_.push_back(full_name.c_str());
return true;
} else {
return false;
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x138, %rdi # imm = 0x138
movq (%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
leaq 0x18(%rsp), %rdx
movq %rdi, (%rdx)
callq 0x1eb88a
movl %edx, %ebp
testb $0x1, %dl
je 0x1cc969
m... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
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.