name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
DecodeLDRPreReg | static DecodeStatus DecodeLDRPreReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred, Rm;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
imm |= fieldFromInstruction_4(Insn, 16, 4) << 13;
imm |= fieldFromInstruction_4(Insn, 23, 1) << 12;
pred = fieldFromInstruction_4(Insn, 28, 4);
Rm = fieldFromInstruction_4(Insn, 0, 4);
if (Rn == 0xF || Rn == Rt) S = MCDisassembler_SoftFail;
if (Rm == 0xF) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeSORegMemOperand(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %ebp
shrl $0x10, %ebp
andl $0xf, %ebp
shrl $0xc, %esi
andl $0xf, %esi
xorl %r12d, %r12d
cmpl %esi, %ebp
setne %r12b
addl %r12d, %r12d
pushq $0x1
popq %r13
orl %r13d, %r12d
cmpl $0xf, %ebp
movl %ebx, %eax
cmovel %r13d, %r12d
notl %eax
testb $0xf, %al
cmovel %r13d, %r12d
callq 0x4f54f
xorl %r15d, %r15d
cmpl $0x3, %eax
je 0x509a3
cmpl $0x1, %eax
jne 0x50a14
movl %r13d, %r12d
movq %r14, %rdi
movl %ebp, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x509bb
cmpl $0x1, %eax
jne 0x50a14
pushq $0x1
popq %r12
movl %ebx, %eax
andl $0xfff, %eax # imm = 0xFFF
shll $0xd, %ebp
orl %eax, %ebp
movl %ebx, %esi
shrl $0xb, %esi
andl $0x1000, %esi # imm = 0x1000
orl %ebp, %esi
movq %r14, %rdi
callq 0x507a6
cmpl $0x3, %eax
je 0x509ea
cmpl $0x1, %eax
jne 0x50a14
pushq $0x1
popq %r12
shrl $0x1c, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f571
movl %eax, %ecx
leaq 0x7b8fc(%rip), %rdx # 0xcc2fc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
movl %r12d, %r15d
jmpq *%rcx
movl %eax, %r15d
jmp 0x50a14
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeMemMultipleWritebackInstruction | static DecodeStatus DecodeMemMultipleWritebackInstruction(MCInst *Inst,
unsigned Insn, uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned reglist = fieldFromInstruction_4(Insn, 0, 16);
if (pred == 0xF) {
// Ambiguous with RFE and SRS
switch (MCInst_getOpcode(Inst)) {
case ARM_LDMDA:
MCInst_setOpcode(Inst, ARM_RFEDA);
break;
case ARM_LDMDA_UPD:
MCInst_setOpcode(Inst, ARM_RFEDA_UPD);
break;
case ARM_LDMDB:
MCInst_setOpcode(Inst, ARM_RFEDB);
break;
case ARM_LDMDB_UPD:
MCInst_setOpcode(Inst, ARM_RFEDB_UPD);
break;
case ARM_LDMIA:
MCInst_setOpcode(Inst, ARM_RFEIA);
break;
case ARM_LDMIA_UPD:
MCInst_setOpcode(Inst, ARM_RFEIA_UPD);
break;
case ARM_LDMIB:
MCInst_setOpcode(Inst, ARM_RFEIB);
break;
case ARM_LDMIB_UPD:
MCInst_setOpcode(Inst, ARM_RFEIB_UPD);
break;
case ARM_STMDA:
MCInst_setOpcode(Inst, ARM_SRSDA);
break;
case ARM_STMDA_UPD:
MCInst_setOpcode(Inst, ARM_SRSDA_UPD);
break;
case ARM_STMDB:
MCInst_setOpcode(Inst, ARM_SRSDB);
break;
case ARM_STMDB_UPD:
MCInst_setOpcode(Inst, ARM_SRSDB_UPD);
break;
case ARM_STMIA:
MCInst_setOpcode(Inst, ARM_SRSIA);
break;
case ARM_STMIA_UPD:
MCInst_setOpcode(Inst, ARM_SRSIA_UPD);
break;
case ARM_STMIB:
MCInst_setOpcode(Inst, ARM_SRSIB);
break;
case ARM_STMIB_UPD:
MCInst_setOpcode(Inst, ARM_SRSIB_UPD);
break;
default:
return MCDisassembler_Fail;
}
// For stores (which become SRS's, the only operand is the mode.
if (fieldFromInstruction_4(Insn, 20, 1) == 0) {
// Check SRS encoding constraints
if (!(fieldFromInstruction_4(Insn, 22, 1) == 1 &&
fieldFromInstruction_4(Insn, 20, 1) == 0))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, fieldFromInstruction_4(Insn, 0, 4));
return S;
}
return DecodeRFEInstruction(Inst, Insn, Address, Decoder);
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail; // Tied
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeRegListOperand(Inst, reglist, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
movl %esi, %r12d
shrl $0x1c, %r12d
cmpl $0xf, %r12d
jne 0x50be8
callq 0x44a14
xorl %ebp, %ebp
leal -0x8e(%rax), %ecx
cmpl $0x8, %ecx
ja 0x50c55
leaq 0x7b737(%rip), %rax # 0xcc30c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x118, %esi # imm = 0x118
jmp 0x50ce1
movl %r15d, %esi
callq 0x4f54f
movl %eax, %ebp
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x50c4e
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x50c12
cmpl $0x1, %eax
jne 0x50c4e
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %r12d, %esi
callq 0x4f571
cmpl $0x3, %eax
je 0x50c2a
cmpl $0x1, %eax
jne 0x50c4e
pushq $0x1
popq %rbp
movzwl %r14w, %esi
movq %rbx, %rdi
callq 0x50a71
testl %eax, %eax
je 0x50c7a
cmpl $0x3, %eax
je 0x50d3d
movl %eax, %ebp
cmpl $0x1, %eax
je 0x50d3d
xorl %ebp, %ebp
jmp 0x50d3d
addl $0xfffffe6b, %eax # imm = 0xFFFFFE6B
cmpl $0x7, %eax
ja 0x50d3d
leaq 0x7b6c6(%rip), %rcx # 0xcc330
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x171, %esi # imm = 0x171
jmp 0x50ce1
movl %eax, %ebp
jmp 0x50d3d
movl $0x11e, %esi # imm = 0x11E
jmp 0x50ce1
movl $0x11b, %esi # imm = 0x11B
jmp 0x50ce1
movl $0x11c, %esi # imm = 0x11C
jmp 0x50ce1
movl $0x119, %esi # imm = 0x119
jmp 0x50ce1
movl $0x11d, %esi # imm = 0x11D
jmp 0x50ce1
movl $0x11a, %esi # imm = 0x11A
jmp 0x50ce1
movl $0x11f, %esi # imm = 0x11F
jmp 0x50ce1
movl $0x175, %esi # imm = 0x175
jmp 0x50ce1
movl $0x173, %esi # imm = 0x173
jmp 0x50ce1
movl $0x174, %esi # imm = 0x174
jmp 0x50ce1
movl $0x178, %esi # imm = 0x178
jmp 0x50ce1
movl $0x172, %esi # imm = 0x172
jmp 0x50ce1
movl $0x176, %esi # imm = 0x176
jmp 0x50ce1
movl $0x177, %esi # imm = 0x177
movq %rbx, %rdi
callq 0x44a0d
btl $0x14, %r14d
jb 0x50d0b
btl $0x16, %r14d
jae 0x50d3d
andl $0xf, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44ace
pushq $0x3
popq %rbp
jmp 0x50d3d
shrl $0x14, %r14d
andl $0x18, %r14d
leaq 0x7d066(%rip), %rax # 0xcdd80
movq (%r14,%rax), %rsi
movq %rbx, %rdi
callq 0x44ace
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4f54f
movl %eax, %eax
leaq 0x7d066(%rip), %rcx # 0xcdda0
movl (%rcx,%rax,4), %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeGPRwithAPSRRegisterClass | static DecodeStatus DecodeGPRwithAPSRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
if (RegNo == 15) {
MCOperand_CreateReg0(Inst, ARM_APSR_NZCV);
return MCDisassembler_Success;
}
Check(&S, DecodeGPRRegisterClass(Inst, RegNo, Address, Decoder));
return S;
} | pushq %rax
cmpl $0xf, %esi
jne 0x5106d
pushq $0x2
popq %rsi
callq 0x44aa1
pushq $0x3
popq %rax
jmp 0x51088
callq 0x4f54f
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
setne %al
leal 0x1(,%rax,2), %eax
testl %ecx, %ecx
cmovel %ecx, %eax
popq %rcx
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeDPRRegisterClass | static DecodeStatus DecodeDPRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Register = 0;
if (RegNo > 31)
return MCDisassembler_Fail;
Register = DPRDecoderTable[RegNo];
MCOperand_CreateReg0(Inst, Register);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0x510ab
pushq %rax
movl %esi, %eax
leaq 0x7c225(%rip), %rcx # 0xcd2c0
movzwl (%rcx,%rax,2), %esi
callq 0x44aa1
pushq $0x3
popq %rax
addq $0x8, %rsp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVSHLMaxInstruction | static DecodeStatus DecodeVSHLMaxInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rm, size;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rm = fieldFromInstruction_4(Insn, 0, 4);
Rm |= fieldFromInstruction_4(Insn, 5, 1) << 4;
size = fieldFromInstruction_4(Insn, 18, 2);
if (!Check(&S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, 8 << size);
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %esi, %ebp
shrl $0x12, %ebp
movl %ebp, %esi
andl $0x10, %esi
orl %eax, %esi
callq 0x510ac
movl %eax, %r12d
xorl %r14d, %r14d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x51157
movl %r15d, %eax
andl $0xf, %eax
shrl %r15d
andl $0x10, %r15d
orl %eax, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x51142
cmpl $0x1, %eax
jne 0x51157
pushq $0x1
popq %r14
jmp 0x51145
movl %r12d, %r14d
andl $0x3, %ebp
pushq $0x8
popq %rsi
movl %ebp, %ecx
shll %cl, %esi
movq %rbx, %rdi
callq 0x44ace
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeNEONModImmInstruction | static DecodeStatus DecodeNEONModImmInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned imm, Q;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
imm = fieldFromInstruction_4(Insn, 0, 4);
imm |= fieldFromInstruction_4(Insn, 16, 3) << 4;
imm |= fieldFromInstruction_4(Insn, 24, 1) << 7;
imm |= fieldFromInstruction_4(Insn, 8, 4) << 8;
imm |= fieldFromInstruction_4(Insn, 5, 1) << 12;
Q = fieldFromInstruction_4(Insn, 6, 1);
if (Q) {
if (!Check(&S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
} else {
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
}
MCOperand_CreateImm0(Inst, imm);
switch (MCInst_getOpcode(Inst)) {
case ARM_VORRiv4i16:
case ARM_VORRiv2i32:
case ARM_VBICiv4i16:
case ARM_VBICiv2i32:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VORRiv8i16:
case ARM_VORRiv4i32:
case ARM_VBICiv8i16:
case ARM_VBICiv4i32:
if (!Check(&S, DecodeQPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %r12d
shrl $0xc, %r12d
movl %r12d, %eax
andl $0xf, %eax
movl %esi, %ebp
shrl $0x12, %ebp
andl $0x10, %ebp
orl %eax, %ebp
movl %ebp, %esi
testb $0x40, %r15b
jne 0x51283
callq 0x5108a
jmp 0x51288
callq 0x510ac
movl %eax, %ebx
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x51321
andl $0x70, %r12d
movl %r15d, %eax
shrl $0x11, %eax
andl $0x80, %eax
movl %r15d, %ecx
andl $0x20, %ecx
shll $0x7, %ecx
andl $0xf0f, %r15d # imm = 0xF0F
orl %r12d, %r15d
orl %eax, %r15d
orl %ecx, %r15d
movl %r15d, %esi
movq %r14, %rdi
callq 0x44ace
movq %r14, %rdi
callq 0x44a14
leal -0x257(%rax), %ecx
cmpl $0x2, %ecx
jb 0x512fc
leal -0x259(%rax), %ecx
cmpl $0x2, %ecx
jb 0x51308
leal -0x5a4(%rax), %ecx
cmpl $0x2, %ecx
jb 0x51308
addl $0xfffffa5e, %eax # imm = 0xFFFFFA5E
cmpl $0x1, %eax
ja 0x51323
movq %r14, %rdi
movl %ebp, %esi
callq 0x5108a
jmp 0x51312
movq %r14, %rdi
movl %ebp, %esi
callq 0x510ac
cmpl $0x3, %eax
je 0x51323
cmpl $0x1, %eax
jne 0x51321
pushq $0x1
popq %rbx
jmp 0x51323
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVCVTQ | static DecodeStatus DecodeVCVTQ(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, 0, 4) << 0);
Vm |= (fieldFromInstruction_4(Insn, 5, 1) << 4);
imm = fieldFromInstruction_4(Insn, 16, 6);
cmode = fieldFromInstruction_4(Insn, 8, 4);
op = fieldFromInstruction_4(Insn, 5, 1);
// VMOVv4f32 is ambiguous with these decodings.
if (!(imm & 0x38) && cmode == 0xF) {
if (op == 1) return MCDisassembler_Fail;
MCInst_setOpcode(Inst, ARM_VMOVv4f32);
return DecodeNEONModImmInstruction(Inst, Insn, Address, Decoder);
}
if (!(imm & 0x20)) return MCDisassembler_Fail;
if (!Check(&S, DecodeQPRRegisterClass(Inst, Vd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeQPRRegisterClass(Inst, Vm, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, 64 - imm);
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
shrl $0x5, %r15d
andl $0x1, %r15d
movl %esi, %eax
andl $0x380f00, %eax # imm = 0x380F00
xorl %r14d, %r14d
cmpl $0xf00, %eax # imm = 0xF00
jne 0x51444
testl %r15d, %r15d
jne 0x514ac
movq %rbx, %rdi
movl $0x559, %esi # imm = 0x559
callq 0x44a0d
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5124f
btl $0x15, %ebp
jae 0x514ac
movl %ebp, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %ebp, %esi
shrl $0x12, %esi
andl $0x10, %esi
orl %eax, %esi
movq %rbx, %rdi
callq 0x510ac
movl %eax, %r12d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x514ac
movl %ebp, %eax
andl $0xf, %eax
shll $0x4, %r15d
orl %eax, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x510ac
cmpl $0x3, %eax
je 0x51496
cmpl $0x1, %eax
jne 0x514ac
pushq $0x1
popq %r14
jmp 0x51499
movl %r12d, %r14d
shrl $0x10, %ebp
andl $0x3f, %ebp
pushq $0x40
popq %rsi
subl %ebp, %esi
movq %rbx, %rdi
callq 0x44ace
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVST2LN | static DecodeStatus DecodeVST2LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
index = fieldFromInstruction_4(Insn, 5, 3);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 2;
break;
case 1:
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 4;
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
if (fieldFromInstruction_4(Insn, 5, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 4, 1) != 0)
align = 8;
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, align);
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCOperand_CreateReg0(Inst, 0);
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, index);
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shrl $0xa, %eax
andl $0x3, %eax
xorl %ebp, %ebp
leaq 0x7ab8c(%rip), %rcx # 0xcc380
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %ebx, %r12d
shrl $0x5, %r12d
andl $0x7, %r12d
movl %ebx, %r15d
shrl $0x3, %r15d
andl $0x2, %r15d
pushq $0x1
popq %rax
jmp 0x51861
movl %ebx, %r12d
shrl $0x6, %r12d
andl $0x3, %r12d
movl %ebx, %r15d
shrl $0x2, %r15d
andl $0x4, %r15d
movl %ebx, %eax
andl $0x20, %eax
jmp 0x51858
testb $0x20, %bl
jne 0x51935
movl %ebx, %r12d
shrl $0x7, %r12d
andl $0x1, %r12d
movl %ebx, %r15d
shrl %r15d
andl $0x8, %r15d
movl %ebx, %eax
andl $0x40, %eax
cmpl $0x1, %eax
pushq $0x2
popq %rax
sbbl $0x0, %eax
movl %eax, 0x4(%rsp)
movl %ebx, %ebp
shrl $0x10, %ebp
andl $0xf, %ebp
movl %ebx, %r13d
andl $0xf, %r13d
cmpl $0xf, %r13d
jne 0x5187f
pushq $0x3
popq %rax
jmp 0x51897
movq %r14, %rdi
movl %ebp, %esi
callq 0x4f54f
movl %eax, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x51933
movl %eax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x518b8
cmpl $0x1, %eax
jne 0x51933
pushq $0x1
popq %rax
movl %eax, (%rsp)
movl %r15d, %esi
movq %r14, %rdi
callq 0x44ace
cmpl $0xf, %r13d
je 0x518d9
movq %r14, %rdi
cmpl $0xd, %r13d
jne 0x51946
xorl %esi, %esi
callq 0x44aa1
xorl %ebp, %ebp
movl %ebx, %eax
shrl $0xc, %eax
andl $0xf, %eax
shrl $0x12, %ebx
andl $0x10, %ebx
orl %eax, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x51905
cmpl $0x1, %eax
jne 0x51935
pushq $0x1
popq %rax
movl %eax, (%rsp)
movl 0x4(%rsp), %esi
addl %ebx, %esi
movq %r14, %rdi
callq 0x5108a
cmpl $0x3, %eax
je 0x51923
cmpl $0x1, %eax
jne 0x51935
pushq $0x1
popq %rax
movl %eax, (%rsp)
movl %r12d, %esi
movq %r14, %rdi
callq 0x44ace
movl (%rsp), %ebp
jmp 0x51935
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r13d, %esi
callq 0x4f54f
cmpl $0x3, %eax
movl $0x0, %ebp
je 0x518db
cmpl $0x1, %eax
jne 0x51935
pushq $0x1
popq %rax
movl %eax, (%rsp)
jmp 0x518db
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLD2LN | static DecodeStatus DecodeVLD2LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
index = fieldFromInstruction_4(Insn, 5, 3);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 2;
break;
case 1:
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 4, 1))
align = 4;
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
if (fieldFromInstruction_4(Insn, 5, 1))
return MCDisassembler_Fail; // UNDEFINED
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 4, 1) != 0)
align = 8;
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, align);
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCOperand_CreateReg0(Inst, 0);
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, index);
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movl %esi, %eax
shrl $0xa, %eax
andl $0x3, %eax
xorl %ebx, %ebx
leaq 0x7aa07(%rip), %rcx # 0xcc390
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %ebp, %r12d
shrl $0x5, %r12d
andl $0x7, %r12d
movl %ebp, %r14d
shrl $0x3, %r14d
andl $0x2, %r14d
pushq $0x1
popq %r15
jmp 0x519fa
movl %ebp, %r12d
shrl $0x6, %r12d
andl $0x3, %r12d
movl %ebp, %r14d
shrl $0x2, %r14d
andl $0x4, %r14d
movl %ebp, %eax
andl $0x20, %eax
jmp 0x519ef
testb $0x20, %bpl
jne 0x51ac5
movl %ebp, %r12d
shrl $0x7, %r12d
andl $0x1, %r12d
movl %ebp, %r14d
shrl %r14d
andl $0x8, %r14d
movl %ebp, %eax
andl $0x40, %eax
cmpl $0x1, %eax
pushq $0x2
popq %r15
sbbl $0x0, %r15d
movl %ebp, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %ebp, %r13d
shrl $0x12, %r13d
andl $0x10, %r13d
orl %eax, %r13d
movq %rdi, %rbx
movl %r13d, %esi
callq 0x5108a
movl %eax, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x51ac3
movl %eax, 0xc(%rsp)
addl %r13d, %r15d
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x51a56
cmpl $0x1, %eax
movl $0x0, %ebx
jne 0x51ac5
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
movl %ebp, %ebx
shrl $0x10, %ebx
andl $0xf, %ebx
andl $0xf, %ebp
cmpl $0xf, %ebp
movq 0x10(%rsp), %rdi
je 0x51a8d
movq 0x10(%rsp), %rdi
movl %ebx, %esi
callq 0x4f54f
movq 0x10(%rsp), %rdi
cmpl $0x3, %eax
je 0x51a8d
cmpl $0x1, %eax
jne 0x51ac3
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
movl %ebx, %esi
callq 0x4f54f
cmpl $0x3, %eax
movl $0x0, %ebx
je 0x51aaa
cmpl $0x1, %eax
jne 0x51ac5
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
movl %r14d, %esi
movq 0x10(%rsp), %rdi
callq 0x44ace
cmpl $0xf, %ebp
jne 0x51ad6
movq 0x10(%rsp), %rdi
jmp 0x51b19
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0xd, %ebp
jne 0x51af1
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44aa1
movq %rbx, %rdi
xorl %ebx, %ebx
jmp 0x51b19
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4f54f
movq %rbx, %rdi
cmpl $0x3, %eax
movl $0x0, %ebx
je 0x51b19
cmpl $0x1, %eax
jne 0x51ac5
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
movl %r13d, %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x51b32
cmpl $0x1, %eax
jne 0x51ac5
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl %r15d, %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x51b54
cmpl $0x1, %eax
jne 0x51ac5
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
movl %r12d, %esi
movq 0x10(%rsp), %rdi
callq 0x44ace
movl 0xc(%rsp), %ebx
jmp 0x51ac5
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLDST2Instruction | static DecodeStatus DecodeVLDST2Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned type, align, load;
unsigned size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 3) return MCDisassembler_Fail;
type = fieldFromInstruction_4(Insn, 8, 4);
align = fieldFromInstruction_4(Insn, 4, 2);
if (type == 8 && align == 3) return MCDisassembler_Fail;
if (type == 9 && align == 3) return MCDisassembler_Fail;
load = fieldFromInstruction_4(Insn, 21, 1);
return load ? DecodeVLDInstruction(Inst, Insn, Address, Decoder)
: DecodeVSTInstruction(Inst, Insn, Address, Decoder);
} | movl %esi, %eax
notl %eax
testb $-0x40, %al
sete %al
movl %esi, %ecx
andl $0xe30, %ecx # imm = 0xE30
cmpl $0x830, %ecx # imm = 0x830
sete %cl
orb %al, %cl
je 0x51fa1
xorl %eax, %eax
retq
btl $0x15, %esi
jb 0x53f77
jmp 0x54299
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLD4LN | static DecodeStatus DecodeVLD4LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0, inc = 1;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
size = fieldFromInstruction_4(Insn, 10, 2);
switch (size) {
default:
return MCDisassembler_Fail;
case 0:
if (fieldFromInstruction_4(Insn, 4, 1))
align = 4;
index = fieldFromInstruction_4(Insn, 5, 3);
break;
case 1:
if (fieldFromInstruction_4(Insn, 4, 1))
align = 8;
index = fieldFromInstruction_4(Insn, 6, 2);
if (fieldFromInstruction_4(Insn, 5, 1))
inc = 2;
break;
case 2:
switch (fieldFromInstruction_4(Insn, 4, 2)) {
case 0:
align = 0; break;
case 3:
return MCDisassembler_Fail;
default:
align = 4 << fieldFromInstruction_4(Insn, 4, 2); break;
}
index = fieldFromInstruction_4(Insn, 7, 1);
if (fieldFromInstruction_4(Insn, 6, 1))
inc = 2;
break;
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+3*inc, Address, Decoder)))
return MCDisassembler_Fail;
if (Rm != 0xF) { // Writeback
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, align);
if (Rm != 0xF) {
if (Rm != 0xD) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
} else
MCOperand_CreateReg0(Inst, 0);
}
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+2*inc, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd+3*inc, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, index);
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
shrl $0xa, %eax
andl $0x3, %eax
xorl %ebx, %ebx
leaq 0x7a200(%rip), %rcx # 0xcc3d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %ebp, %r12d
shrl $0x2, %r12d
andl $0x4, %r12d
movl %ebp, %r15d
shrl $0x5, %r15d
andl $0x7, %r15d
pushq $0x1
popq %rbx
jmp 0x5224b
movl %ebp, %r12d
shrl %r12d
andl $0x8, %r12d
movl %ebp, %r15d
shrl $0x6, %r15d
andl $0x3, %r15d
movl %ebp, %eax
andl $0x20, %eax
jmp 0x52242
movl %ebp, %r12d
shrl $0x4, %r12d
andl $0x3, %r12d
je 0x52232
cmpl $0x3, %r12d
je 0x52408
pushq $0x4
popq %rax
movl %r12d, %ecx
shll %cl, %eax
movl %eax, %r12d
movl %ebp, %r15d
shrl $0x7, %r15d
andl $0x1, %r15d
movl %ebp, %eax
andl $0x40, %eax
cmpl $0x1, %eax
pushq $0x2
popq %rbx
sbbl $0x0, %ebx
movl %ebp, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %ebp, %r13d
shrl $0x12, %r13d
andl $0x10, %r13d
orl %eax, %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x5108a
movl %eax, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x52406
movl %eax, 0x8(%rsp)
leal (%rbx,%r13), %esi
movq %r14, %rdi
movl %esi, 0x14(%rsp)
callq 0x5108a
cmpl $0x3, %eax
je 0x522a3
cmpl $0x1, %eax
jne 0x52406
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
leal (%r13,%rbx,2), %esi
movq %r14, %rdi
movl %esi, 0x10(%rsp)
callq 0x5108a
cmpl $0x3, %eax
je 0x522c9
cmpl $0x1, %eax
jne 0x52406
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
leal (%rbx,%rbx,2), %ebx
addl %r13d, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x522ee
cmpl $0x1, %eax
jne 0x52406
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
movl %ebx, 0xc(%rsp)
movl %ebp, %ebx
shrl $0x10, %ebx
andl $0xf, %ebx
andl $0xf, %ebp
cmpl $0xf, %ebp
je 0x52321
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x52321
cmpl $0x1, %eax
jne 0x52406
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x52340
cmpl $0x1, %eax
jne 0x52406
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
movl %r12d, %esi
movq %r14, %rdi
callq 0x44ace
cmpl $0xf, %ebp
je 0x5237d
movq %r14, %rdi
cmpl $0xd, %ebp
jne 0x52361
xorl %esi, %esi
callq 0x44aa1
jmp 0x5237d
movl %ebp, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x5237d
cmpl $0x1, %eax
jne 0x52406
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
movl %r13d, %esi
callq 0x5108a
cmpl $0x3, %eax
movl $0x0, %ebx
je 0x5239e
cmpl $0x1, %eax
jne 0x52408
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
movl 0x14(%rsp), %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x523bb
cmpl $0x1, %eax
jne 0x52408
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
movl 0x10(%rsp), %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x523d8
cmpl $0x1, %eax
jne 0x52408
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
movl 0xc(%rsp), %esi
callq 0x5108a
cmpl $0x3, %eax
je 0x523f5
cmpl $0x1, %eax
jne 0x52408
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
movl %r15d, %esi
movq %r14, %rdi
callq 0x44ace
movl 0x8(%rsp), %ebx
jmp 0x52408
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLDST3Instruction | static DecodeStatus DecodeVLDST3Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned align, load;
unsigned size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 3) return MCDisassembler_Fail;
align = fieldFromInstruction_4(Insn, 4, 2);
if (align & 2) return MCDisassembler_Fail;
load = fieldFromInstruction_4(Insn, 21, 1);
return load ? DecodeVLDInstruction(Inst, Insn, Address, Decoder)
: DecodeVSTInstruction(Inst, Insn, Address, Decoder);
} | movl %esi, %eax
notl %eax
testb $-0x40, %al
sete %al
movl %esi, %ecx
andl $0x20, %ecx
shrl $0x5, %ecx
orb %al, %cl
jne 0x5243d
btl $0x15, %esi
jb 0x53f77
jmp 0x54299
xorl %eax, %eax
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLD1DupInstruction | static DecodeStatus DecodeVLD1DupInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn, Rm, align, size;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rm = fieldFromInstruction_4(Insn, 0, 4);
align = fieldFromInstruction_4(Insn, 4, 1);
size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 0 && align == 1)
return MCDisassembler_Fail;
align *= (1 << size);
switch (MCInst_getOpcode(Inst)) {
case ARM_VLD1DUPq16: case ARM_VLD1DUPq32: case ARM_VLD1DUPq8:
case ARM_VLD1DUPq16wb_fixed: case ARM_VLD1DUPq16wb_register:
case ARM_VLD1DUPq32wb_fixed: case ARM_VLD1DUPq32wb_register:
case ARM_VLD1DUPq8wb_fixed: case ARM_VLD1DUPq8wb_register:
if (!Check(&S, DecodeDPairRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
}
if (Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, align);
// The fixed offset post-increment encodes Rm == 0xd. The no-writeback
// variant encodes Rm == 0xf. Anything else is a register offset post-
// increment and we need to add the register operand to the instruction.
if (Rm != 0xD && Rm != 0xF &&
!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r13d
shrl $0x4, %r13d
movl %esi, %ecx
shrl $0x6, %ecx
andl $0x3, %ecx
sete %al
xorl %ebx, %ebx
testb %r13b, %al
jne 0x52513
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %esi, %r15d
shrl $0x12, %r15d
andl $0x10, %r15d
orl %eax, %r15d
andl $0x1, %r13d
shll %cl, %r13d
callq 0x44a14
addl $0xfffffcb7, %eax # imm = 0xFFFFFCB7
movq %r14, %rdi
movl %r15d, %esi
cmpl $0x8, %eax
ja 0x524a6
callq 0x53f55
jmp 0x524ab
callq 0x5108a
movl %eax, %r15d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x52513
movl %ebp, %r12d
shrl $0x10, %r12d
andl $0xf, %r12d
andl $0xf, %ebp
cmpl $0xf, %ebp
je 0x524e2
movq %r14, %rdi
movl %r12d, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x524e2
cmpl $0x1, %eax
jne 0x52513
pushq $0x1
popq %r15
movq %r14, %rdi
movl %r12d, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x524fb
cmpl $0x1, %eax
jne 0x52513
pushq $0x1
popq %r15
movl %r13d, %esi
movq %r14, %rdi
callq 0x44ace
movl %ebp, %eax
orl $0x2, %eax
cmpl $0xf, %eax
jne 0x52524
movl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x52510
cmpl $0x1, %eax
jne 0x52513
pushq $0x1
popq %rbx
jmp 0x52513
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLD2DupInstruction | static DecodeStatus DecodeVLD2DupInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn, Rm, align, size;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rn = fieldFromInstruction_4(Insn, 16, 4);
Rm = fieldFromInstruction_4(Insn, 0, 4);
align = fieldFromInstruction_4(Insn, 4, 1);
size = 1 << fieldFromInstruction_4(Insn, 6, 2);
align *= 2*size;
switch (MCInst_getOpcode(Inst)) {
case ARM_VLD2DUPd16: case ARM_VLD2DUPd32: case ARM_VLD2DUPd8:
case ARM_VLD2DUPd16wb_fixed: case ARM_VLD2DUPd16wb_register:
case ARM_VLD2DUPd32wb_fixed: case ARM_VLD2DUPd32wb_register:
case ARM_VLD2DUPd8wb_fixed: case ARM_VLD2DUPd8wb_register:
if (!Check(&S, DecodeDPairRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
case ARM_VLD2DUPd16x2: case ARM_VLD2DUPd32x2: case ARM_VLD2DUPd8x2:
case ARM_VLD2DUPd16x2wb_fixed: case ARM_VLD2DUPd16x2wb_register:
case ARM_VLD2DUPd32x2wb_fixed: case ARM_VLD2DUPd32x2wb_register:
case ARM_VLD2DUPd8x2wb_fixed: case ARM_VLD2DUPd8x2wb_register:
if (!Check(&S, DecodeDPairSpacedRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
if (!Check(&S, DecodeDPRRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
break;
}
if (Rm != 0xF)
MCOperand_CreateImm0(Inst, 0);
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, align);
if (Rm != 0xD && Rm != 0xF) {
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
}
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %esi, %r14d
shrl $0x12, %r14d
andl $0x10, %r14d
orl %eax, %r14d
movl %ebp, %ecx
shrb $0x6, %cl
pushq $0x2
popq %r13
shll %cl, %r13d
callq 0x44a14
addl $0xfffffc63, %eax # imm = 0xFFFFFC63
cmpl $0x11, %eax
ja 0x5263a
movl $0x71c7, %ecx # imm = 0x71C7
movq %rbx, %rdi
movl %r14d, %esi
btl %eax, %ecx
jae 0x52599
callq 0x53f55
jmp 0x5259e
callq 0x54585
movl %eax, %r14d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x5260a
movl %ebp, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
movl %ebp, %r12d
andl $0xf, %r12d
cmpl $0xf, %r12d
je 0x525cb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44ace
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4f54f
xorl %r15d, %r15d
cmpl $0x3, %eax
je 0x525e7
cmpl $0x1, %eax
jne 0x5260d
pushq $0x1
popq %r14
shll $0x1b, %ebp
sarl $0x1f, %ebp
andl %r13d, %ebp
movl %ebp, %esi
movq %rbx, %rdi
callq 0x44ace
movl %r12d, %eax
orl $0x2, %eax
cmpl $0xf, %eax
jne 0x5261f
movl %r14d, %r15d
jmp 0x5260d
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r12d, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x52605
cmpl $0x1, %eax
jne 0x5260d
pushq $0x1
popq %r15
jmp 0x5260d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5108a
jmp 0x5259e
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeThumbAddrModeRR | static DecodeStatus DecodeThumbAddrModeRR(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 0, 3);
unsigned Rm = fieldFromInstruction_4(Val, 3, 3);
if (!Check(&S, DecodetGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodetGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
andl $0x7, %esi
callq 0x528fc
movl %eax, %ebx
xorl %eax, %eax
movl %ebx, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x52a0a
shrl $0x3, %ebp
andl $0x7, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x528fc
movl %eax, %ecx
leaq 0x799e5(%rip), %rdx # 0xcc3e0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %eax, %eax
jmp 0x52a0a
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeThumbAddrModeIS | static DecodeStatus DecodeThumbAddrModeIS(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 0, 3);
unsigned imm = fieldFromInstruction_4(Val, 3, 5);
if (!Check(&S, DecodetGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, imm);
return S;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
andl $0x7, %esi
callq 0x528fc
movl %eax, %ebp
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x52a3d
shrl $0x3, %ebx
andl $0x1f, %ebx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44ace
jmp 0x52a3f
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeThumbAddSpecialReg | static DecodeStatus DecodeThumbAddSpecialReg(MCInst *Inst, uint16_t Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned dst = fieldFromInstruction_2(Insn, 8, 3);
unsigned imm = fieldFromInstruction_2(Insn, 0, 8);
if (!Check(&S, DecodetGPRRegisterClass(Inst, dst, Address, Decoder)))
return MCDisassembler_Fail;
switch(MCInst_getOpcode(Inst)) {
default:
return MCDisassembler_Fail;
case ARM_tADR:
break; // tADR does not explicitly represent the PC as an operand.
case ARM_tADDrSPi:
MCOperand_CreateReg0(Inst, ARM_SP);
break;
}
MCOperand_CreateImm0(Inst, imm);
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
shrl $0x8, %esi
andl $0x7, %esi
callq 0x528fc
movl %eax, %r14d
xorl %r15d, %r15d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x52ac0
movq %rbx, %rdi
callq 0x44a14
cmpl $0xa88, %eax # imm = 0xA88
je 0x52aae
cmpl $0xa82, %eax # imm = 0xA82
jne 0x52ac0
pushq $0xc
popq %rsi
movq %rbx, %rdi
callq 0x44aa1
movzbl %bpl, %eax
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x44ace
movl %r14d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeThumbBLTargetOperand | static DecodeStatus DecodeThumbBLTargetOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
// Val is passed in as S:J1:J2:imm10:imm11
// Note no trailing zero after imm11. Also the J1 and J2 values are from
// the encoded instruction. So here change to I1 and I2 values via:
// I1 = NOT(J1 EOR S);
// I2 = NOT(J2 EOR S);
// and build the imm32 with one trailing zero as documented:
// imm32 = SignExtend(S:I1:I2:imm10:imm11:'0', 32);
unsigned S = (Val >> 23) & 1;
unsigned J1 = (Val >> 22) & 1;
unsigned J2 = (Val >> 21) & 1;
unsigned I1 = !(J1 ^ S);
unsigned I2 = !(J2 ^ S);
unsigned tmp = (Val & ~0x600000) | (I1 << 22) | (I2 << 21);
int imm32 = SignExtend32(tmp << 1, 25);
MCOperand_CreateImm0(Inst, imm32);
return MCDisassembler_Success;
} | movl %esi, %eax
shrl %eax
xorl %esi, %eax
movl %esi, %ecx
shrl $0x2, %ecx
xorl %esi, %ecx
andl $0x9fffff, %esi # imm = 0x9FFFFF
andl $0x400000, %eax # imm = 0x400000
orl %esi, %eax
andl $0x200000, %ecx # imm = 0x200000
orl %eax, %ecx
shll $0x8, %ecx
sarl $0x7, %ecx
xorl $0xc00000, %ecx # imm = 0xC00000
movslq %ecx, %rsi
jmp 0x44ace
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeThumbTableBranch | static DecodeStatus DecodeThumbTableBranch(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
if (Rn == ARM_SP) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
shrl $0x10, %esi
andl $0xf, %esi
xorl %r15d, %r15d
cmpl $0xc, %esi
setne %r12b
callq 0x4f54f
xorl %ebx, %ebx
cmpl $0x3, %eax
je 0x52c93
cmpl $0x1, %eax
jne 0x52cc1
pushq $0x1
popq %rbx
jmp 0x52c9e
movb %r12b, %r15b
leal 0x1(,%r15,2), %ebx
andl $0xf, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x52bfa
testl %eax, %eax
je 0x52cbf
cmpl $0x3, %eax
je 0x52cc1
movl %eax, %ebx
cmpl $0x1, %eax
je 0x52cc1
xorl %ebx, %ebx
jmp 0x52cc1
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeT2Imm8S4 | static DecodeStatus DecodeT2Imm8S4(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
if (Val == 0)
MCOperand_CreateImm0(Inst, INT32_MIN);
else {
int imm = Val & 0xFF;
if (!(Val & 0x100)) imm *= -1;
MCOperand_CreateImm0(Inst, imm * 4);
}
return MCDisassembler_Success;
} | testl %esi, %esi
je 0x52cea
movzbl %sil, %eax
movl %eax, %ecx
negl %ecx
btl $0x8, %esi
cmovbl %eax, %ecx
shll $0x2, %ecx
movslq %ecx, %rsi
jmp 0x44ace
movq $-0x80000000, %rsi # imm = 0x80000000
jmp 0x44ace
| /bughoho[P]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);
unsigned addr = fieldFromInstruction_4(Insn, 0, 8);
unsigned W = fieldFromInstruction_4(Insn, 21, 1);
unsigned U = fieldFromInstruction_4(Insn, 23, 1);
unsigned P = fieldFromInstruction_4(Insn, 24, 1);
bool writeback = (W == 1) | (P == 0);
addr |= (U << 8) | (Rn << 9);
if (writeback && (Rn == Rt || Rn == Rt2))
Check(&S, MCDisassembler_SoftFail);
// Writeback operand
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
// Rt
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
// Rt2
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rt2, Address, Decoder)))
return MCDisassembler_Fail;
// addr
if (!Check(&S, DecodeT2AddrModeImm8s4(Inst, addr, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r13d
shrl $0xc, %r13d
andl $0xf, %r13d
movl %esi, %r12d
shrl $0x8, %r12d
andl $0xf, %r12d
movl %esi, %r14d
shrl $0x10, %r14d
andl $0xf, %r14d
movl %esi, %eax
andl $0x1200000, %eax # imm = 0x1200000
xorl %ecx, %ecx
cmpl %r12d, %r14d
setne %cl
cmpl %r13d, %r14d
leal 0x1(%rcx,%rcx), %ecx
pushq $0x1
popq %rdx
cmovel %edx, %ecx
cmpl $0x1000000, %eax # imm = 0x1000000
pushq $0x3
popq %r15
cmovnel %ecx, %r15d
movl %r14d, %esi
callq 0x52bfa
cmpl $0x3, %eax
je 0x52d9f
cmpl $0x1, %eax
jne 0x52e04
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r13d, %esi
callq 0x52bfa
cmpl $0x3, %eax
je 0x52db8
cmpl $0x1, %eax
jne 0x52e04
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r12d, %esi
callq 0x52bfa
cmpl $0x3, %eax
je 0x52dd1
cmpl $0x1, %eax
jne 0x52e04
pushq $0x1
popq %r15
movzbl %bpl, %eax
shrl $0xf, %ebp
andl $0x100, %ebp # imm = 0x100
shll $0x9, %r14d
orl %ebp, %r14d
orl %eax, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x52cf6
testl %eax, %eax
je 0x52e19
cmpl $0x3, %eax
je 0x52e07
movl %eax, %r15d
cmpl $0x1, %eax
je 0x52e07
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
jmp 0x52e07
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeT2SOImm | static DecodeStatus DecodeT2SOImm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
unsigned ctrl = fieldFromInstruction_4(Val, 10, 2);
if (ctrl == 0) {
unsigned byte = fieldFromInstruction_4(Val, 8, 2);
unsigned imm = fieldFromInstruction_4(Val, 0, 8);
switch (byte) {
case 0:
MCOperand_CreateImm0(Inst, imm);
break;
case 1:
MCOperand_CreateImm0(Inst, (imm << 16) | imm);
break;
case 2:
MCOperand_CreateImm0(Inst, (imm << 24) | (imm << 8));
break;
case 3:
MCOperand_CreateImm0(Inst, (imm << 24) | (imm << 16) | (imm << 8) | imm);
break;
}
} else {
unsigned unrot = fieldFromInstruction_4(Val, 0, 7) | 0x80;
unsigned rot = fieldFromInstruction_4(Val, 7, 5);
unsigned imm = (unrot >> rot) | (unrot << ((32-rot)&31));
MCOperand_CreateImm0(Inst, imm);
}
return MCDisassembler_Success;
} | testw $0xc00, %si # imm = 0xC00
je 0x52f23
movl %esi, %eax
orl $0x80, %eax
movzbl %al, %eax
shrl $0x7, %esi
movl %esi, %ecx
rorl %cl, %eax
movl %eax, %esi
jmp 0x44ace
movl %esi, %ecx
shrl $0x8, %ecx
andl $0x3, %ecx
movzbl %sil, %eax
leaq 0x794ba(%rip), %rdx # 0xcc3f0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
imull $0x10001, %eax, %eax # imm = 0x10001
jmp 0x52f1c
imull $0x1000100, %eax, %eax # imm = 0x1000100
jmp 0x52f1c
imull $0x1010101, %eax, %eax # imm = 0x1010101
jmp 0x52f1c
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeT2CPSInstruction | static DecodeStatus DecodeT2CPSInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned imod = fieldFromInstruction_4(Insn, 9, 2);
unsigned M = fieldFromInstruction_4(Insn, 8, 1);
unsigned iflags = fieldFromInstruction_4(Insn, 5, 3);
unsigned mode = fieldFromInstruction_4(Insn, 0, 5);
DecodeStatus S = MCDisassembler_Success;
// imod == '01' --> UNPREDICTABLE
// NOTE: Even though this is technically UNPREDICTABLE, we choose to
// return failure here. The '01' imod value is unprintable, so there's
// nothing useful we could do even if we returned UNPREDICTABLE.
if (imod == 1) return MCDisassembler_Fail;
if (imod && M) {
MCInst_setOpcode(Inst, ARM_t2CPS3p);
MCOperand_CreateImm0(Inst, imod);
MCOperand_CreateImm0(Inst, iflags);
MCOperand_CreateImm0(Inst, mode);
} else if (imod && !M) {
MCInst_setOpcode(Inst, ARM_t2CPS2p);
MCOperand_CreateImm0(Inst, imod);
MCOperand_CreateImm0(Inst, iflags);
if (mode) S = MCDisassembler_SoftFail;
} else if (!imod && M) {
MCInst_setOpcode(Inst, ARM_t2CPS1p);
MCOperand_CreateImm0(Inst, mode);
if (iflags) S = MCDisassembler_SoftFail;
} else {
// imod == '00' && M == '0' --> this is a HINT instruction
int imm = fieldFromInstruction_4(Insn, 0, 8);
// HINT are defined only for immediate in [0..4]
if(imm > 4) return MCDisassembler_Fail;
MCInst_setOpcode(Inst, ARM_t2HINT);
MCOperand_CreateImm0(Inst, imm);
}
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
shrl $0x9, %r15d
andl $0x3, %r15d
xorl %eax, %eax
cmpl $0x1, %r15d
je 0x53119
movq %rdi, %rbx
movl %esi, %r14d
shrl $0x5, %r14d
andl $0x7, %r14d
movl %esi, %ebp
andl $0x1f, %ebp
testl %r15d, %r15d
sete %cl
btl $0x8, %esi
setae %dl
orb %cl, %dl
jne 0x530a7
movq %rbx, %rdi
movl $0x911, %esi # imm = 0x911
callq 0x44a0d
movl %r15d, %esi
movq %rbx, %rdi
callq 0x44ace
movl %r14d, %esi
movq %rbx, %rdi
callq 0x44ace
movl %ebp, %esi
movq %rbx, %rdi
callq 0x44ace
pushq $0x3
popq %rax
jmp 0x53119
movl %esi, %ecx
shrl $0x8, %ecx
andl $0x1, %ecx
testl %r15d, %r15d
sete %dl
orb %cl, %dl
je 0x530e8
testl %r15d, %r15d
setne %cl
btl $0x8, %esi
setae %dl
orb %cl, %dl
jne 0x53124
movq %rbx, %rdi
movl $0x90f, %esi # imm = 0x90F
callq 0x44a0d
movl %ebp, %esi
movq %rbx, %rdi
callq 0x44ace
xorl %eax, %eax
testl %r14d, %r14d
jmp 0x5310f
movq %rbx, %rdi
movl $0x910, %esi # imm = 0x910
callq 0x44a0d
movl %r15d, %esi
movq %rbx, %rdi
callq 0x44ace
movl %r14d, %esi
movq %rbx, %rdi
callq 0x44ace
xorl %eax, %eax
testl %ebp, %ebp
sete %al
leal 0x1(,%rax,2), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %sil, %ebp
cmpl $0x4, %ebp
ja 0x53119
movq %rbx, %rdi
movl $0x921, %esi # imm = 0x921
callq 0x44a0d
jmp 0x53098
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeT2AddrModeImm8 | static DecodeStatus DecodeT2AddrModeImm8(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 9, 4);
unsigned imm = fieldFromInstruction_4(Val, 0, 9);
// Thumb stores cannot use PC as dest register.
switch (MCInst_getOpcode(Inst)) {
case ARM_t2STRT:
case ARM_t2STRBT:
case ARM_t2STRHT:
case ARM_t2STRi8:
case ARM_t2STRHi8:
case ARM_t2STRBi8:
if (Rn == 15)
return MCDisassembler_Fail;
break;
default:
break;
}
// Some instructions always use an additive offset.
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRT:
case ARM_t2LDRBT:
case ARM_t2LDRHT:
case ARM_t2LDRSBT:
case ARM_t2LDRSHT:
case ARM_t2STRT:
case ARM_t2STRBT:
case ARM_t2STRHT:
imm |= 0x100;
break;
default:
break;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeT2Imm8(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
shrl $0x9, %r14d
andl $0xf, %r14d
callq 0x44a14
addl $0xfffff5d9, %eax # imm = 0xFFFFF5D9
cmpl $0x1a, %eax
ja 0x5348e
movl $0x4284021, %ecx # imm = 0x4284021
btl %eax, %ecx
jae 0x5348e
cmpl $0xf, %r14d
je 0x5350d
andl $0x1ff, %ebp # imm = 0x1FF
movq %rbx, %rdi
callq 0x44a14
leal -0x942(%rax), %ecx
cmpl $0x27, %ecx
ja 0x534b7
movabsq $0x8080808001, %rdx # imm = 0x8080808001
btq %rcx, %rdx
jb 0x534cb
addl $0xfffff5d9, %eax # imm = 0xFFFFF5D9
cmpl $0x15, %eax
ja 0x534d1
movl $0x204001, %ecx # imm = 0x204001
btl %eax, %ecx
jae 0x534d1
orl $0x100, %ebp # imm = 0x100
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4f54f
movl %eax, %r14d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x5350d
movzbl %bpl, %eax
movl %eax, %ecx
negl %ecx
btl $0x8, %ebp
cmovbl %eax, %ecx
testl %ebp, %ebp
movl $0x80000000, %eax # imm = 0x80000000
cmovnel %ecx, %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x44ace
jmp 0x53510
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeT2LoadShift | static DecodeStatus DecodeT2LoadShift(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned addrmode;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
if (Rn == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRBs:
MCInst_setOpcode(Inst, ARM_t2LDRBpci);
break;
case ARM_t2LDRHs:
MCInst_setOpcode(Inst, ARM_t2LDRHpci);
break;
case ARM_t2LDRSHs:
MCInst_setOpcode(Inst, ARM_t2LDRSHpci);
break;
case ARM_t2LDRSBs:
MCInst_setOpcode(Inst, ARM_t2LDRSBpci);
break;
case ARM_t2LDRs:
MCInst_setOpcode(Inst, ARM_t2LDRpci);
break;
case ARM_t2PLDs:
MCInst_setOpcode(Inst, ARM_t2PLDpci);
break;
case ARM_t2PLIs:
MCInst_setOpcode(Inst, ARM_t2PLIpci);
break;
default:
return MCDisassembler_Fail;
}
return DecodeT2LoadLabel(Inst, Insn, Address, Decoder);
}
if (Rt == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRSHs:
return MCDisassembler_Fail;
case ARM_t2LDRHs:
// FIXME: this instruction is only available with MP extensions,
// this should be checked first but we don't have access to the
// feature bits here.
MCInst_setOpcode(Inst, ARM_t2PLDWs);
break;
default:
break;
}
}
switch (MCInst_getOpcode(Inst)) {
case ARM_t2PLDs:
case ARM_t2PLDWs:
case ARM_t2PLIs:
break;
default:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
}
addrmode = fieldFromInstruction_4(Insn, 4, 2);
addrmode |= fieldFromInstruction_4(Insn, 0, 4) << 2;
addrmode |= fieldFromInstruction_4(Insn, 16, 4) << 6;
if (!Check(&S, DecodeT2AddrModeSOReg(Inst, addrmode, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %ebp
shrl $0x10, %ebp
andl $0xf, %ebp
cmpl $0xf, %ebp
jne 0x535f7
movq %rbx, %rdi
callq 0x44a14
cmpl $0x949, %eax # imm = 0x949
je 0x536bf
cmpl $0x9b4, %eax # imm = 0x9B4
je 0x536cd
cmpl $0x960, %eax # imm = 0x960
je 0x536c6
cmpl $0x968, %eax # imm = 0x968
je 0x536aa
cmpl $0x971, %eax # imm = 0x971
je 0x536b8
cmpl $0x9b0, %eax # imm = 0x9B0
je 0x536b1
cmpl $0x958, %eax # imm = 0x958
jne 0x53694
movl $0x956, %esi # imm = 0x956
jmp 0x536d2
movl %r14d, %r15d
shrl $0xc, %r15d
andl $0xf, %r15d
cmpl $0xf, %r15d
jne 0x5362b
movq %rbx, %rdi
callq 0x44a14
cmpl $0x968, %eax # imm = 0x968
je 0x53694
cmpl $0x958, %eax # imm = 0x958
jne 0x5362b
movq %rbx, %rdi
movl $0x9ac, %esi # imm = 0x9AC
callq 0x44a0d
movq %rbx, %rdi
callq 0x44a14
addl $0xfffff654, %eax # imm = 0xFFFFF654
cmpl $0x8, %eax
ja 0x5367e
movl $0x111, %ecx # imm = 0x111
btl %eax, %ecx
jae 0x5367e
pushq $0x3
popq %r15
movl %r14d, %eax
shrl $0x4, %eax
andl $0x3, %eax
andl $0xf, %r14d
leal (%rax,%r14,4), %eax
shll $0x6, %ebp
orl %eax, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x53263
testl %eax, %eax
je 0x53699
cmpl $0x3, %eax
je 0x5369c
movl %eax, %r15d
cmpl $0x1, %eax
jne 0x53694
jmp 0x5369c
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4f54f
movl %eax, %r15d
orl $0x2, %eax
cmpl $0x3, %eax
je 0x5364b
xorl %r15d, %r15d
jmp 0x5369c
movl %eax, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x966, %esi # imm = 0x966
jmp 0x536d2
movl $0x9af, %esi # imm = 0x9AF
jmp 0x536d2
movl $0x96e, %esi # imm = 0x96E
jmp 0x536d2
movl $0x947, %esi # imm = 0x947
jmp 0x536d2
movl $0x95e, %esi # imm = 0x95E
jmp 0x536d2
movl $0x9b3, %esi # imm = 0x9B3
movq %rbx, %rdi
callq 0x44a0d
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x53a9c
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeT2LoadT | static DecodeStatus DecodeT2LoadT(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 8);
imm |= (Rn << 9);
if (Rn == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRT:
MCInst_setOpcode(Inst, ARM_t2LDRpci);
break;
case ARM_t2LDRBT:
MCInst_setOpcode(Inst, ARM_t2LDRBpci);
break;
case ARM_t2LDRHT:
MCInst_setOpcode(Inst, ARM_t2LDRHpci);
break;
case ARM_t2LDRSBT:
MCInst_setOpcode(Inst, ARM_t2LDRSBpci);
break;
case ARM_t2LDRSHT:
MCInst_setOpcode(Inst, ARM_t2LDRSHpci);
break;
default:
return MCDisassembler_Fail;
}
return DecodeT2LoadLabel(Inst, Insn, Address, Decoder);
}
if (!Check(&S, DecoderGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeT2AddrModeImm8(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
shrl $0x10, %r14d
andl $0xf, %r14d
cmpl $0xf, %r14d
jne 0x538a8
movq %rbx, %rdi
callq 0x44a14
cmpl $0x969, %eax # imm = 0x969
je 0x53913
movl %eax, %ecx
cmpl $0x951, %eax # imm = 0x951
je 0x538f0
cmpl $0x959, %ecx # imm = 0x959
je 0x5390c
cmpl $0x961, %ecx # imm = 0x961
je 0x538f7
xorl %eax, %eax
cmpl $0x942, %ecx # imm = 0x942
jne 0x53901
movl $0x947, %esi # imm = 0x947
jmp 0x53918
movl %ebp, %esi
shrl $0xc, %esi
andl $0xf, %esi
movq %rbx, %rdi
callq 0x52bfa
movl %eax, %r15d
xorl %eax, %eax
movl %r15d, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
jne 0x53901
movzbl %bpl, %eax
shll $0x9, %r14d
orl %eax, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5345b
testl %eax, %eax
je 0x53901
cmpl $0x3, %eax
je 0x538fe
cmpl $0x1, %eax
je 0x53901
xorl %eax, %eax
jmp 0x53901
movl $0x956, %esi # imm = 0x956
jmp 0x53918
movl $0x966, %esi # imm = 0x966
jmp 0x53918
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x95e, %esi # imm = 0x95E
jmp 0x53918
movl $0x96e, %esi # imm = 0x96E
movq %rbx, %rdi
callq 0x44a0d
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x53a9c
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeT2LoadLabel | static DecodeStatus DecodeT2LoadLabel(MCInst *Inst, unsigned Insn,
uint64_t Address, const void* Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned U = fieldFromInstruction_4(Insn, 23, 1);
int imm = fieldFromInstruction_4(Insn, 0, 12);
if (Rt == 15) {
switch (MCInst_getOpcode(Inst)) {
case ARM_t2LDRBpci:
case ARM_t2LDRHpci:
MCInst_setOpcode(Inst, ARM_t2PLDpci);
break;
case ARM_t2LDRSBpci:
MCInst_setOpcode(Inst, ARM_t2PLIpci);
break;
case ARM_t2LDRSHpci:
return MCDisassembler_Fail;
default:
break;
}
}
switch(MCInst_getOpcode(Inst)) {
case ARM_t2PLDpci:
case ARM_t2PLIpci:
break;
default:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
}
if (!U) {
// Special case for #-0.
if (imm == 0)
imm = INT32_MIN;
else
imm = -imm;
}
MCOperand_CreateImm0(Inst, imm);
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
shrl $0xc, %r14d
andl $0xf, %r14d
cmpl $0xf, %r14d
jne 0x53aef
movq %rbx, %rdi
callq 0x44a14
movl $0x9af, %esi # imm = 0x9AF
cmpl $0x947, %eax # imm = 0x947
je 0x53ae7
cmpl $0x956, %eax # imm = 0x956
je 0x53ae7
cmpl $0x966, %eax # imm = 0x966
je 0x53b52
cmpl $0x95e, %eax # imm = 0x95E
jne 0x53aef
movl $0x9b3, %esi # imm = 0x9B3
movq %rbx, %rdi
callq 0x44a0d
movq %rbx, %rdi
callq 0x44a14
pushq $0x3
popq %r15
cmpl $0x9af, %eax # imm = 0x9AF
je 0x53b1f
cmpl $0x9b3, %eax # imm = 0x9B3
je 0x53b1f
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4f54f
movl %eax, %r15d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x53b52
movl %ebp, %eax
andl $0xfff, %eax # imm = 0xFFF
movl %eax, %ecx
negl %ecx
movl $0x80000000, %edx # imm = 0x80000000
cmovbl %ecx, %edx
btl $0x17, %ebp
cmovbl %eax, %edx
movslq %edx, %rsi
movq %rbx, %rdi
callq 0x44ace
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x53b44
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
ARM_printInst | void ARM_printInst(MCInst *MI, SStream *O, void *Info)
{
MCRegisterInfo *MRI = (MCRegisterInfo *)Info;
unsigned Opcode = MCInst_getOpcode(MI), tmp, i, pubOpcode;
switch(Opcode) {
// Check for HINT instructions w/ canonical names.
case ARM_HINT:
case ARM_tHINT:
case ARM_t2HINT:
switch (MCOperand_getImm(MCInst_getOperand(MI, 0))) {
case 0: SStream_concat0(O, "nop"); pubOpcode = ARM_INS_NOP; break;
case 1: SStream_concat0(O, "yield"); pubOpcode = ARM_INS_YIELD; break;
case 2: SStream_concat0(O, "wfe"); pubOpcode = ARM_INS_WFE; break;
case 3: SStream_concat0(O, "wfi"); pubOpcode = ARM_INS_WFI; break;
case 4: SStream_concat0(O, "sev"); pubOpcode = ARM_INS_SEV; break;
case 5:
if ((ARM_getFeatureBits(MI->csh->mode) & ARM_HasV8Ops)) {
SStream_concat0(O, "sevl");
pubOpcode = ARM_INS_SEVL;
break;
}
// Fallthrough for non-v8
default:
// Anything else should just print normally.
printInstruction(MI, O, MRI);
return;
}
printPredicateOperand(MI, 1, O);
if (Opcode == ARM_t2HINT)
SStream_concat0(O, ".w");
MCInst_setOpcodePub(MI, pubOpcode);
return;
// Check for MOVs and print canonical forms, instead.
case ARM_MOVsr: {
// FIXME: Thumb variants?
MCOperand *Dst = MCInst_getOperand(MI, 0);
MCOperand *MO1 = MCInst_getOperand(MI, 1);
MCOperand *MO2 = MCInst_getOperand(MI, 2);
MCOperand *MO3 = MCInst_getOperand(MI, 3);
SStream_concat0(O, ARM_AM_getShiftOpcStr(ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO3))));
printSBitModifierOperand(MI, 6, O);
printPredicateOperand(MI, 4, O);
SStream_concat0(O, "\t");
printRegName(MI->csh, O, MCOperand_getReg(Dst));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(Dst);
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO2));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO2);
MI->flat_insn->detail->arm.op_count++;
}
//assert(ARM_AM_getSORegOffset(MO3.getImm()) == 0);
return;
}
case ARM_MOVsi: {
// FIXME: Thumb variants?
MCOperand *Dst = MCInst_getOperand(MI, 0);
MCOperand *MO1 = MCInst_getOperand(MI, 1);
MCOperand *MO2 = MCInst_getOperand(MI, 2);
SStream_concat0(O, ARM_AM_getShiftOpcStr(ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO2))));
printSBitModifierOperand(MI, 5, O);
printPredicateOperand(MI, 3, O);
SStream_concat0(O, "\t");
printRegName(MI->csh, O, MCOperand_getReg(Dst));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(Dst);
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, ", ");
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MO1);
MI->flat_insn->detail->arm.op_count++;
}
if (ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO2)) == ARM_AM_rrx) {
//printAnnotation(O, Annot);
return;
}
SStream_concat0(O, ", ");
tmp = translateShiftImm(getSORegOffset((unsigned int)MCOperand_getImm(MO2)));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.type =
(arm_shifter)ARM_AM_getSORegShOp((unsigned int)MCOperand_getImm(MO2));
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count - 1].shift.value = tmp;
}
return;
}
// A8.6.123 PUSH
case ARM_STMDB_UPD:
case ARM_t2STMDB_UPD:
if (MCOperand_getReg(MCInst_getOperand(MI, 0)) == ARM_SP &&
MCInst_getNumOperands(MI) > 5) {
// Should only print PUSH if there are at least two registers in the list.
SStream_concat0(O, "push");
MCInst_setOpcodePub(MI, ARM_INS_PUSH);
printPredicateOperand(MI, 2, O);
if (Opcode == ARM_t2STMDB_UPD)
SStream_concat0(O, ".w");
SStream_concat0(O, "\t");
printRegisterList(MI, 4, O);
return;
}
break;
case ARM_STR_PRE_IMM:
if (MCOperand_getReg(MCInst_getOperand(MI, 2)) == ARM_SP &&
MCOperand_getImm(MCInst_getOperand(MI, 3)) == -4) {
SStream_concat0(O, "push");
MCInst_setOpcodePub(MI, ARM_INS_PUSH);
printPredicateOperand(MI, 4, O);
SStream_concat0(O, "\t{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, 1)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, 1));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
return;
}
break;
// A8.6.122 POP
case ARM_LDMIA_UPD:
case ARM_t2LDMIA_UPD:
if (MCOperand_getReg(MCInst_getOperand(MI, 0)) == ARM_SP &&
MCInst_getNumOperands(MI) > 5) {
// Should only print POP if there are at least two registers in the list.
SStream_concat0(O, "pop");
MCInst_setOpcodePub(MI, ARM_INS_POP);
printPredicateOperand(MI, 2, O);
if (Opcode == ARM_t2LDMIA_UPD)
SStream_concat0(O, ".w");
SStream_concat0(O, "\t");
printRegisterList(MI, 4, O);
return;
}
break;
case ARM_LDR_POST_IMM:
if (MCOperand_getReg(MCInst_getOperand(MI, 2)) == ARM_SP) {
MCOperand *MO2 = MCInst_getOperand(MI, 4);
if ((getAM2Op((unsigned int)MCOperand_getImm(MO2)) == ARM_AM_add &&
getAM2Offset((unsigned int)MCOperand_getImm(MO2)) == 4) ||
MCOperand_getImm(MO2) == 4) {
SStream_concat0(O, "pop");
MCInst_setOpcodePub(MI, ARM_INS_POP);
printPredicateOperand(MI, 5, O);
SStream_concat0(O, "\t{");
printRegName(MI->csh, O, MCOperand_getReg(MCInst_getOperand(MI, 0)));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = MCOperand_getReg(MCInst_getOperand(MI, 0));
MI->flat_insn->detail->arm.op_count++;
}
SStream_concat0(O, "}");
return;
}
}
break;
// A8.6.355 VPUSH
case ARM_VSTMSDB_UPD:
case ARM_VSTMDDB_UPD:
if (MCOperand_getReg(MCInst_getOperand(MI, 0)) == ARM_SP) {
SStream_concat0(O, "vpush");
MCInst_setOpcodePub(MI, ARM_INS_VPUSH);
printPredicateOperand(MI, 2, O);
SStream_concat0(O, "\t");
printRegisterList(MI, 4, O);
return;
}
break;
// A8.6.354 VPOP
case ARM_VLDMSIA_UPD:
case ARM_VLDMDIA_UPD:
if (MCOperand_getReg(MCInst_getOperand(MI, 0)) == ARM_SP) {
SStream_concat0(O, "vpop");
MCInst_setOpcodePub(MI, ARM_INS_VPOP);
printPredicateOperand(MI, 2, O);
SStream_concat0(O, "\t");
printRegisterList(MI, 4, O);
return;
}
break;
case ARM_tLDMIA: {
bool Writeback = true;
unsigned BaseReg = MCOperand_getReg(MCInst_getOperand(MI, 0));
unsigned i;
for (i = 3; i < MCInst_getNumOperands(MI); ++i) {
if (MCOperand_getReg(MCInst_getOperand(MI, i)) == BaseReg)
Writeback = false;
}
SStream_concat0(O, "ldm");
MCInst_setOpcodePub(MI, ARM_INS_LDM);
printPredicateOperand(MI, 1, O);
SStream_concat0(O, "\t");
printRegName(MI->csh, O, BaseReg);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_REG;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].reg = BaseReg;
MI->flat_insn->detail->arm.op_count++;
}
if (Writeback) {
MI->writeback = true;
SStream_concat0(O, "!");
}
SStream_concat0(O, ", ");
printRegisterList(MI, 3, O);
return;
}
// Combine 2 GPRs from disassember into a GPRPair to match with instr def.
// ldrexd/strexd require even/odd GPR pair. To enforce this constraint,
// a single GPRPair reg operand is used in the .td file to replace the two
// GPRs. However, when decoding them, the two GRPs cannot be automatically
// expressed as a GPRPair, so we have to manually merge them.
// FIXME: We would really like to be able to tablegen'erate this.
case ARM_LDREXD:
case ARM_STREXD:
case ARM_LDAEXD:
case ARM_STLEXD: {
MCRegisterClass* MRC = MCRegisterInfo_getRegClass(MRI, ARM_GPRRegClassID);
bool isStore = Opcode == ARM_STREXD || Opcode == ARM_STLEXD;
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, isStore ? 1 : 0));
if (MCRegisterClass_contains(MRC, Reg)) {
MCInst NewMI;
MCInst_Init(&NewMI);
MCInst_setOpcode(&NewMI, Opcode);
if (isStore)
MCInst_addOperand2(&NewMI, MCInst_getOperand(MI, 0));
MCOperand_CreateReg0(&NewMI, MCRegisterInfo_getMatchingSuperReg(MRI, Reg, ARM_gsub_0,
MCRegisterInfo_getRegClass(MRI, ARM_GPRPairRegClassID)));
// Copy the rest operands into NewMI.
for(i = isStore ? 3 : 2; i < MCInst_getNumOperands(MI); ++i)
MCInst_addOperand2(&NewMI, MCInst_getOperand(MI, i));
printInstruction(&NewMI, O, MRI);
return;
}
}
}
//if (printAliasInstr(MI, O, MRI))
// printInstruction(MI, O, MRI);
printInstruction(MI, O, MRI);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x338, %rsp # imm = 0x338
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x44a14
movl %eax, %ebp
cmpl $0x6f, %eax
je 0x5b639
cmpl $0x7b, %ebp
je 0x5b677
cmpl $0x94, %ebp
je 0x5b76d
cmpl $0xa5, %ebp
je 0x5b677
cmpl $0xbc, %ebp
je 0x5b86f
cmpl $0xe2, %ebp
je 0x5bca4
cmpl $0xe3, %ebp
je 0x5b963
cmpl $0x192, %ebp # imm = 0x192
je 0x5b677
cmpl $0x198, %ebp # imm = 0x198
je 0x5b70a
cmpl $0x1ad, %ebp # imm = 0x1AD
je 0x5b677
cmpl $0x1ba, %ebp # imm = 0x1BA
je 0x5bec7
cmpl $0x4e0, %ebp # imm = 0x4E0
je 0x5b7e0
cmpl $0x4e4, %ebp # imm = 0x4E4
je 0x5b7e0
cmpl $0x87c, %ebp # imm = 0x87C
je 0x5b814
cmpl $0x880, %ebp # imm = 0x880
je 0x5b814
cmpl $0x921, %ebp # imm = 0x921
je 0x5b639
cmpl $0x941, %ebp # imm = 0x941
je 0x5b76d
cmpl $0xa24, %ebp # imm = 0xA24
je 0x5b70a
cmpl $0xaa6, %ebp # imm = 0xAA6
je 0x5bb74
cmpl $0xaa2, %ebp # imm = 0xAA2
jne 0x5c0b0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x5, %rax
ja 0x5c0b0
leaq 0x72754(%rip), %rcx # 0xcddb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1ab, %r15d # imm = 0x1AB
leaq 0x87516(%rip), %rsi # 0xe2b88
jmp 0x5c0d9
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r13
cmpl $0x1ad, %ebp # imm = 0x1AD
sete %al
cmpl $0x192, %ebp # imm = 0x192
sete %cl
orb %al, %cl
movzbl %cl, %esi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movl %eax, %r12d
movq %r13, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x5c0b0
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x449bc
movq %r13, %rdi
movl %ebp, %esi
callq 0x44a0d
cmpl $0x1ad, %ebp # imm = 0x1AD
je 0x5b6ec
cmpl $0x192, %ebp # imm = 0x192
jne 0x5bfe9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x44a2e
pushq $0x3
jmp 0x5bfeb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0xc, %eax
jne 0x5c0b0
movq %rbx, %rdi
callq 0x44a29
cmpl $0x6, %eax
jb 0x5c0b0
leaq 0x78d72(%rip), %rsi # 0xd44af
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x1aa, %esi # imm = 0x1AA
callq 0x44a11
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
cmpl $0xa24, %ebp # imm = 0xA24
je 0x5b7cf
jmp 0x5b859
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0xc, %eax
jne 0x5c0b0
movq %rbx, %rdi
callq 0x44a29
cmpl $0x6, %eax
jb 0x5c0b0
leaq 0x8814b(%rip), %rsi # 0xe38eb
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x1a9, %esi # imm = 0x1A9
callq 0x44a11
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
cmpl $0x941, %ebp # imm = 0x941
jne 0x5b859
leaq 0x78cd5(%rip), %rsi # 0xd44ab
movq %r14, %rdi
callq 0x44af3
jmp 0x5b859
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0xc, %eax
jne 0x5c0b0
leaq 0x78cb2(%rip), %rsi # 0xd44b4
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x1b2, %esi # imm = 0x1B2
jmp 0x5b846
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0xc, %eax
jne 0x5c0b0
leaq 0x78c78(%rip), %rsi # 0xd44ae
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x1b1, %esi # imm = 0x1B1
callq 0x44a11
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
leaq 0x83254(%rip), %rsi # 0xdeab4
movq %r14, %rdi
callq 0x44af3
pushq $0x4
jmp 0x5bc87
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0xc, %eax
jne 0x5c0b0
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %r12
movq %rax, %rdi
callq 0x44a76
btl $0xc, %eax
jb 0x5b8b9
movq %r12, %rdi
callq 0x44a76
andl $0xfff, %eax # imm = 0xFFF
cmpl $0x4, %eax
je 0x5b8cb
movq %r12, %rdi
callq 0x44a76
cmpq $0x4, %rax
jne 0x5c0b0
leaq 0x88019(%rip), %rsi # 0xe38eb
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x1a9, %esi # imm = 0x1A9
callq 0x44a11
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
leaq 0x78ceb(%rip), %rsi # 0xd45e7
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5bfc9
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x1, 0x64(%rax,%rcx)
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x5bf91
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %r13
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
andl $0x7, %eax
movl %eax, %edi
callq 0x602ef
movq %r14, %rdi
movq %rax, %rsi
callq 0x44af3
pushq $0x6
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6030f
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
leaq 0x830dd(%rip), %rsi # 0xdeab4
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %rbp
movq %r13, %rdi
callq 0x44a6e
movq %rbp, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5ba59
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x1, 0x64(%rax,%rcx)
movq %r13, %rdi
callq 0x44a6e
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x50(%rcx), %edx
imulq $0x28, %rdx, %rdx
movl %eax, 0x68(%rcx,%rdx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x50(%rax)
leaq 0x78c56(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %r13
movq %r12, %rdi
callq 0x44a6e
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5bae2
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x1, 0x64(%rax,%rcx)
movq %r12, %rdi
callq 0x44a6e
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x50(%rcx), %edx
imulq $0x28, %rdx, %rdx
movl %eax, 0x68(%rcx,%rdx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x50(%rax)
leaq 0x78bcd(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %r12
movq %r15, %rdi
callq 0x44a6e
movq %r12, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5c04c
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x1, 0x64(%rax,%rcx)
movq %r15, %rdi
callq 0x44a6e
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x50(%rcx), %edx
imulq $0x28, %rdx, %rdx
movl %eax, 0x68(%rcx,%rdx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x50(%rax)
jmp 0x5c04c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movl %eax, %ebp
pushq $0x3
popq %r15
movb $0x1, %r12b
movq %rbx, %rdi
callq 0x44a29
cmpl %eax, %r15d
jae 0x5bbbc
movq %rbx, %rdi
movl %r15d, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl %ebp, %eax
setne %al
andb %al, %r12b
incl %r15d
jmp 0x5bb8f
leaq 0x788f6(%rip), %rsi # 0xd44b9
movq %r14, %rdi
callq 0x44af3
pushq $0x39
popq %rsi
movq %rbx, %rdi
callq 0x44a11
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
leaq 0x82ec9(%rip), %rsi # 0xdeab4
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5bc5a
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x1, 0x64(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl %ebp, 0x68(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x50(%rax)
testb $0x1, %r12b
je 0x5bc76
movb $0x1, 0x32e(%rbx)
leaq 0x818b3(%rip), %rsi # 0xdd521
movq %r14, %rdi
callq 0x44af3
leaq 0x78a39(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x338, %rsp # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6037b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %r13
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %r15
movq %rax, %rdi
callq 0x44a76
andl $0x7, %eax
movl %eax, %edi
callq 0x602ef
movq %r14, %rdi
movq %rax, %rsi
callq 0x44af3
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6030f
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
leaq 0x82da7(%rip), %rsi # 0xdeab4
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %rbp
movq %r13, %rdi
callq 0x44a6e
movq %rbp, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5bd8f
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x1, 0x64(%rax,%rcx)
movq %r13, %rdi
callq 0x44a6e
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x50(%rcx), %edx
imulq $0x28, %rdx, %rdx
movl %eax, 0x68(%rcx,%rdx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x50(%rax)
leaq 0x78920(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %r13
movq %r12, %rdi
callq 0x44a6e
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5be18
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x1, 0x64(%rax,%rcx)
movq %r12, %rdi
callq 0x44a6e
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x50(%rcx), %edx
imulq $0x28, %rdx, %rdx
movl %eax, 0x68(%rcx,%rdx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x50(%rax)
movq %r15, %rdi
callq 0x44a76
andl $0x7, %eax
cmpl $0x5, %eax
je 0x5c04c
leaq 0x78883(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
movq %r15, %rdi
callq 0x44a76
movl %eax, %ecx
shrl $0x3, %ecx
cmpl $0x8, %eax
pushq $0x20
popq %rbp
cmovael %ecx, %ebp
cmpl $0xa, %ebp
leaq 0x7894f(%rip), %rax # 0xd47aa
leaq 0x78950(%rip), %rsi # 0xd47b2
cmovaeq %rax, %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5c04c
movq %r15, %rdi
callq 0x44a76
andl $0x7, %eax
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x50(%rcx), %edx
imulq $0x28, %rdx, %rdx
movl %eax, 0x34(%rcx,%rdx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl %ebp, 0x38(%rax,%rcx)
jmp 0x5c04c
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0xc, %eax
jne 0x5c0b0
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $-0x4, %rax
jne 0x5c0b0
leaq 0x785a8(%rip), %rsi # 0xd44af
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x1aa, %esi # imm = 0x1AA
callq 0x44a11
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
leaq 0x786b6(%rip), %rsi # 0xd45e7
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x5bfc9
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x1, 0x64(%rax,%rcx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x50(%rcx), %edx
imulq $0x28, %rdx, %rdx
movl %eax, 0x68(%rcx,%rdx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x50(%rax)
leaq 0xea608(%rip), %rsi # 0x1465d8
movq %r14, %rdi
addq $0x338, %rsp # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x44af3
pushq $0x2
popq %rbp
pushq $0x12
popq %rsi
movq %r15, %rdi
callq 0x47bf1
pushq $0x9
popq %rdx
movq %r15, %rdi
movl %r12d, %esi
movq %rax, %rcx
callq 0x47abf
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl %eax, %esi
callq 0x44aa1
jmp 0x5c030
movq %rbx, %rdi
movl %ebp, %esi
callq 0x44a1b
movq %r12, %rdi
movq %rax, %rsi
callq 0x44a2e
incl %ebp
movq %rbx, %rdi
callq 0x44a29
cmpl %eax, %ebp
jb 0x5c019
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5c122
addq $0x338, %rsp # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1af, %r15d # imm = 0x1AF
leaq 0x78437(%rip), %rsi # 0xd44a2
jmp 0x5c0d9
movl $0x1ad, %r15d # imm = 0x1AD
leaq 0x78420(%rip), %rsi # 0xd449a
jmp 0x5c0d9
movl $0x1ae, %r15d # imm = 0x1AE
leaq 0x78415(%rip), %rsi # 0xd449e
jmp 0x5c0d9
movl $0x1ac, %r15d # imm = 0x1AC
leaq 0x783fc(%rip), %rsi # 0xd4494
jmp 0x5c0d9
movq 0x320(%rbx), %rax
movl 0x4(%rax), %edi
callq 0x47d94
btq $0x2b, %rax
jb 0x5c0cc
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x338, %rsp # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5c122
movl $0x1b0, %r15d # imm = 0x1B0
leaq 0x783cd(%rip), %rsi # 0xd44a6
movq %r14, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6026c
cmpl $0x921, %ebp # imm = 0x921
jne 0x5c106
leaq 0x783ad(%rip), %rsi # 0xd44ab
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl %r15d, %esi
addq $0x338, %rsp # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x44a11
| /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printSBitModifierOperand | static void printSBitModifierOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
if (MCOperand_getReg(MCInst_getOperand(MI, OpNum))) {
//assert(MCOperand_getReg(MCInst_getOperand(MI, OpNum)) == ARM_CPSR &&
// "Expect ARM CPSR register!");
SStream_concat0(O, "s");
if (MI->csh->detail)
MI->flat_insn->detail->arm.update_flags = true;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
testl %eax, %eax
je 0x60358
leaq 0x611b1(%rip), %rsi # 0xc14e2
movq %r14, %rdi
callq 0x44af3
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x60358
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movb $0x1, 0x48(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printAddrModeImm12Operand | static void printAddrModeImm12Operand(MCInst *MI, unsigned OpNum,
SStream *O, bool AlwaysPrintImm0)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
int32_t OffImm;
bool isSub;
if (!MCOperand_isReg(MO1)) { // FIXME: This is for CP entries, but isn't right.
printOperand(MI, OpNum, O);
return;
}
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.base = MCOperand_getReg(MO1);
OffImm = (int32_t)MCOperand_getImm(MO2);
isSub = OffImm < 0;
// Special value for #-0. All others are normal.
if (OffImm == INT32_MIN)
OffImm = 0;
if (isSub) {
if (OffImm < -HEX_THRESHOLD)
SStream_concat(O, ", #-0x%x", -OffImm);
else
SStream_concat(O, ", #-%u", -OffImm);
} else if (AlwaysPrintImm0 || OffImm > 0) {
if (OffImm >= 0) {
if (OffImm > HEX_THRESHOLD)
SStream_concat(O, ", #0x%x", OffImm);
else
SStream_concat(O, ", #%u", OffImm);
} else {
if (OffImm < -HEX_THRESHOLD)
SStream_concat(O, ", #-0x%x", -OffImm);
else
SStream_concat(O, ", #-%u", -OffImm);
}
}
if (MI->csh->detail)
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].mem.disp = OffImm;
SStream_concat0(O, "]");
set_mem_access(MI, false);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %rbx
callq 0x44a1b
movq %rax, %r12
leal 0x1(%r13), %esi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %r15
movq %r12, %rdi
callq 0x44a56
testb %al, %al
je 0x60cbb
leaq 0x7c80b(%rip), %rsi # 0xdd437
movq %r14, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x62819
movq 0x320(%rbx), %r13
movq %r12, %rdi
callq 0x44a6e
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x60360
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x60c8a
movq %r12, %rdi
callq 0x44a6e
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x50(%rcx), %edx
imulq $0x28, %rdx, %rdx
movl %eax, 0x68(%rcx,%rdx)
movq %r15, %rdi
callq 0x44a76
xorl %r15d, %r15d
movl %eax, %ecx
negl %ecx
cmovnol %eax, %r15d
testl %eax, %eax
js 0x60cd7
sete %cl
xorb $0x1, %bpl
testb %bpl, %cl
jne 0x60d0a
cmpl $0xa, %eax
jb 0x60cf7
leaq 0x73aef(%rip), %rsi # 0xd47a8
jmp 0x60cfe
movq %rbx, %rdi
movl %r13d, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6059a
movl %r15d, %edx
negl %edx
cmpl $-0xa, %r15d
jg 0x60ceb
leaq 0x73aaf(%rip), %rsi # 0xd4798
jmp 0x60cf2
leaq 0x73aaf(%rip), %rsi # 0xd47a1
movq %r14, %rdi
jmp 0x60d03
leaq 0x73ab2(%rip), %rsi # 0xd47b0
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x60d32
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl %r15d, 0x74(%rax,%rcx)
leaq 0x7d2f5(%rip), %rsi # 0xde02e
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x62819
| /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printFBits16 | static void printFBits16(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp;
tmp = 16 - (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_IMM;
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].imm = tmp;
MI->flat_insn->detail->arm.op_count++;
}
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
pushq $0x10
popq %rbp
subl %eax, %ebp
cmpl $0xa, %ebp
leaq 0x73758(%rip), %rax # 0xd47aa
leaq 0x73759(%rip), %rsi # 0xd47b2
cmovaeq %rax, %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x610bf
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl $0x2, 0x64(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x50(%rax), %ecx
imulq $0x28, %rcx, %rcx
movl %ebp, 0x68(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x50(%rax)
popq %rbx
popq %r14
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printAlignedLabel | static void printAlignedLabel(MCInst *MI, unsigned OpNum, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNum);
// If the label has already been resolved to an immediate offset (say, when
// we're running the disassembler), just print the immediate.
if (MCOperand_isImm(Op)) {
uint64_t imm = (MCOperand_getImm(Op) << 2) + MI->address;
printUInt64Bang(O, imm);
if (MI->csh->detail) {
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count].type = ARM64_OP_IMM;
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count].imm = imm;
MI->flat_insn->detail->arm64.op_count++;
}
return;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x44a1b
movq %rax, %r15
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x82ee5
movq %r15, %rdi
callq 0x44a76
movq %rax, %r15
shlq $0x2, %r15
addq 0x318(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x44c2b
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x82ee5
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x36(%rax), %ecx
imulq $0x30, %rcx, %rcx
movl $0x2, 0x50(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x36(%rax), %ecx
imulq $0x30, %rcx, %rcx
movq %r15, 0x58(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x36(%rax)
popq %rbx
popq %r14
popq %r15
retq
| /bughoho[P]capstone/arch/AArch64/AArch64InstPrinter.c |
Mips64_getInstruction | static DecodeStatus Mips64Disassembler_getInstruction(int mode, MCInst *instr,
const uint8_t *code, size_t code_len,
uint16_t *Size,
uint64_t Address, bool isBigEndian, MCRegisterInfo *MRI)
{
uint32_t Insn;
DecodeStatus Result;
if (code_len < 4)
// not enough data
return MCDisassembler_Fail;
if (instr->flat_insn->detail) {
memset(instr->flat_insn->detail, 0, sizeof(cs_detail));
}
Result = readInstruction32((unsigned char*)code, &Insn, isBigEndian, false);
if (Result == MCDisassembler_Fail)
return MCDisassembler_Fail;
if (instr->flat_insn->detail) {
memset(instr->flat_insn->detail, 0, sizeof(cs_detail));
}
// Calling the auto-generated decoder function.
Result = decodeInstruction(DecoderTableMips6432, instr, Insn, Address, MRI, mode);
if (Result != MCDisassembler_Fail) {
*Size = 4;
return Result;
}
// If we fail to decode in Mips64 decoder space we can try in Mips32
Result = decodeInstruction(DecoderTableMips32, instr, Insn, Address, MRI, mode);
if (Result != MCDisassembler_Fail) {
*Size = 4;
return Result;
}
return MCDisassembler_Fail;
} | cmpq $0x4, %rdx
jae 0x844bd
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %rcx, %r15
movq %rsi, %r13
movq %r8, 0x10(%rsp)
movl 0x4(%rdi), %ebp
movb 0x28(%rdi), %bl
movq 0x310(%rcx), %rax
movq 0xe8(%rax), %rdi
testq %rdi, %rdi
je 0x8450e
movl $0x5f8, %edx # imm = 0x5F8
xorl %esi, %esi
callq 0x430d0
movq 0x310(%r15), %rax
movq 0xe8(%rax), %r12
jmp 0x84511
xorl %r12d, %r12d
movzbl %bl, %edx
leaq 0xc(%rsp), %rsi
movq %r13, %rdi
xorl %ecx, %ecx
callq 0x845a2
testq %r12, %r12
je 0x84537
movl $0x5f8, %edx # imm = 0x5F8
movq %r12, %rdi
xorl %esi, %esi
callq 0x430d0
movl 0xc(%rsp), %r12d
leaq 0x180bbd(%rip), %rdi # 0x205100
movq %r15, %rsi
movl %r12d, %edx
movq %r14, %rcx
movq 0x50(%rsp), %rbx
movq %rbx, %r8
movl %ebp, %r9d
callq 0x845cc
testl %eax, %eax
jne 0x8457f
leaq 0x17d769(%rip), %rdi # 0x201cd0
movq %r15, %rsi
movl %r12d, %edx
movq %r14, %rcx
movq %rbx, %r8
movl %ebp, %r9d
callq 0x845cc
testl %eax, %eax
je 0x8459e
movq 0x10(%rsp), %rcx
movw $0x4, (%rcx)
cmpl $0x3, %eax
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x8458f
| /bughoho[P]capstone/arch/Mips/MipsDisassembler.c |
DecodeACC64DSPRegisterClass | static DecodeStatus DecodeACC64DSPRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo >= 4)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_ACC64DSPRegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x3, %esi
ja 0x88663
pushq %rbx
movl %esi, %ecx
movq %rdi, %rbx
pushq $0x22
popq %rsi
movq %rdx, %rdi
movl %ecx, %edx
callq 0x8886d
movq %rbx, %rdi
movl %eax, %esi
callq 0x44aa1
pushq $0x3
popq %rax
popq %rbx
retq
| /bughoho[P]capstone/arch/Mips/MipsDisassembler.c |
DecodeFGR32RegisterClass | static DecodeStatus DecodeFGR32RegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 31)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_FGR32RegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0x886b5
pushq %rbx
movl %esi, %ecx
movq %rdi, %rbx
pushq $0x5
popq %rsi
movq %rdx, %rdi
movl %ecx, %edx
callq 0x8886d
movq %rbx, %rdi
movl %eax, %esi
callq 0x44aa1
pushq $0x3
popq %rax
popq %rbx
retq
| /bughoho[P]capstone/arch/Mips/MipsDisassembler.c |
DecodeAFGR64RegisterClass | static DecodeStatus DecodeAFGR64RegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 30 || RegNo % 2)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_AFGR64RegClassID, RegNo /2);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | pushq %rbx
movl %esi, %ecx
movq %rdi, %rbx
cmpl $0x1f, %esi
setae %sil
xorl %eax, %eax
movl %ecx, %edi
orb %sil, %dil
testb $0x1, %dil
jne 0x8873e
shrl %ecx
pushq $0x1d
popq %rsi
movq %rdx, %rdi
movl %ecx, %edx
callq 0x8886d
movq %rbx, %rdi
movl %eax, %esi
callq 0x44aa1
pushq $0x3
popq %rax
popq %rbx
retq
| /bughoho[P]capstone/arch/Mips/MipsDisassembler.c |
DecodeMSA128DRegisterClass | static DecodeStatus DecodeMSA128DRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 31)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_MSA128DRegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0x887db
pushq %rbx
movl %esi, %edx
movq %rdi, %rbx
pushq $0x2b
popq %rsi
movq %rcx, %rdi
callq 0x8886d
movq %rbx, %rdi
movl %eax, %esi
callq 0x44aa1
pushq $0x3
popq %rax
popq %rbx
retq
| /bughoho[P]capstone/arch/Mips/MipsDisassembler.c |
DecodeMSACtrlRegisterClass | static DecodeStatus DecodeMSACtrlRegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 7)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_MSACtrlRegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x7, %esi
ja 0x8881a
pushq %rbx
movl %esi, %ecx
movq %rdi, %rbx
pushq $0x12
popq %rsi
movq %rdx, %rdi
movl %ecx, %edx
callq 0x8886d
movq %rbx, %rdi
movl %eax, %esi
callq 0x44aa1
pushq $0x3
popq %rax
popq %rbx
retq
| /bughoho[P]capstone/arch/Mips/MipsDisassembler.c |
DecodeCOP2RegisterClass | static DecodeStatus DecodeCOP2RegisterClass(MCInst *Inst,
unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
{
unsigned Reg;
if (RegNo > 31)
return MCDisassembler_Fail;
Reg = getReg(Decoder, Mips_COP2RegClassID, RegNo);
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0x8886c
pushq %rbx
movl %esi, %ecx
movq %rdi, %rbx
pushq $0x2
popq %rsi
movq %rdx, %rdi
movl %ecx, %edx
callq 0x8886d
movq %rbx, %rdi
movl %eax, %esi
callq 0x44aa1
pushq $0x3
popq %rax
popq %rbx
retq
| /bughoho[P]capstone/arch/Mips/MipsDisassembler.c |
Mips_printInst | void Mips_printInst(MCInst *MI, SStream *O, void *info)
{
char *mnem;
switch (MCInst_getOpcode(MI)) {
default: break;
case Mips_Save16:
case Mips_SaveX16:
case Mips_Restore16:
case Mips_RestoreX16:
return;
}
// Try to print any aliases first.
mnem = printAliasInstr(MI, O, info);
if (!mnem) {
mnem = printAlias(MI, O);
if (!mnem) {
printInstruction(MI, O, NULL);
}
}
if (mnem) {
// fixup instruction id due to the change in alias instruction
MCInst_setOpcodePub(MI, Mips_map_insn(mnem));
cs_mem_free(mnem);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x44a14
leal -0x547(%rax), %ecx
cmpl $0x2, %ecx
jb 0x888b0
addl $0xfffff9bf, %eax # imm = 0xFFFFF9BF
cmpl $0x2, %eax
jae 0x888ba
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x44a14
leal -0xa1(%rax), %ecx
cmpl $0x15, %ecx
jbe 0x88a8d
cmpl $0x69e, %eax # imm = 0x69E
je 0x89a0a
cmpl $0x11a, %eax # imm = 0x11A
je 0x896fe
cmpl $0x20e, %eax # imm = 0x20E
je 0x8953b
cmpl $0x21f, %eax # imm = 0x21F
je 0x89a59
cmpl $0x278, %eax # imm = 0x278
je 0x898ad
cmpl $0x364, %eax # imm = 0x364
je 0x894b5
cmpl $0x366, %eax # imm = 0x366
je 0x88e77
cmpl $0x36a, %eax # imm = 0x36A
je 0x89253
cmpl $0x55c, %eax # imm = 0x55C
je 0x88ad5
cmpl $0x55d, %eax # imm = 0x55D
je 0x88ad5
cmpl $0x5a2, %eax # imm = 0x5A2
je 0x89088
cmpl $0x5fc, %eax # imm = 0x5FC
je 0x88ec7
cmpl $0x623, %eax # imm = 0x623
je 0x898e5
cmpl $0x638, %eax # imm = 0x638
je 0x89113
cmpl $0x63a, %eax # imm = 0x63A
je 0x899b8
cmpl $0x66c, %eax # imm = 0x66C
je 0x893c7
cmpl $0x670, %eax # imm = 0x670
je 0x897bf
cmpl $0x675, %eax # imm = 0x675
je 0x89610
cmpl $0x680, %eax # imm = 0x680
je 0x88f9a
cmpl $0x684, %eax # imm = 0x684
je 0x892d9
cmpl $0x687, %eax # imm = 0x687
je 0x89165
cmpl $0x45, %eax
jne 0x89b2d
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x15, %eax
je 0x89604
jmp 0x89b2d
leaq 0x5773c(%rip), %rax # 0xe01d0
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x5a178(%rip), %rdi # 0xe2c48
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x1, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x5a1ce(%rip), %rdi # 0xe2cf0
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x5a16d(%rip), %rdi # 0xe2cc7
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x9b, %eax
jne 0x89b2d
leaq 0x5a0de(%rip), %rdi # 0xe2c72
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x5a0ea(%rip), %rdi # 0xe2cb6
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x5a05d(%rip), %rdi # 0xe2c61
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x5a069(%rip), %rdi # 0xe2ca5
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x59fe5(%rip), %rdi # 0xe2c59
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x59fa4(%rip), %rdi # 0xe2c50
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x59fb0(%rip), %rdi # 0xe2c94
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x59fa3(%rip), %rdi # 0xe2cbf
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x9b, %eax
jne 0x89b2d
leaq 0x59f2d(%rip), %rdi # 0xe2c83
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x9b, %eax
jne 0x89b2d
leaq 0x59eda(%rip), %rdi # 0xe2c6a
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x59ec4(%rip), %rdi # 0xe2c8c
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x9b, %eax
jne 0x89b2d
leaq 0x59e79(%rip), %rdi # 0xe2c7b
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x59e63(%rip), %rdi # 0xe2c9d
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x1f, %eax
jne 0x89b2d
leaq 0x59e3c(%rip), %rdi # 0xe2cae
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x14b, %eax # imm = 0x14B
jne 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x1c
jmp 0x894fe
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x15, %eax
jne 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
leaq 0x55a77(%rip), %rdi # 0xdea0c
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x59ca9(%rip), %rdi # 0xe2d2c
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x15, %eax
jne 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x15, %eax
jne 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x59a7a(%rip), %rdi # 0xe2b88
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x1, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x5fc6e(%rip), %rdi # 0xe8dce
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x59af5(%rip), %rdi # 0xe2d43
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x13, %eax
jne 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
leaq 0x59a11(%rip), %rdi # 0xe2ce5
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x59975(%rip), %rdi # 0xe2d37
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x5985a(%rip), %rdi # 0xe2d0a
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x15, %eax
jne 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
leaq 0x597a9(%rip), %rdi # 0xe2cdf
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x1c
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x1c
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x14b, %eax # imm = 0x14B
jne 0x89b2d
leaq 0x5dc28(%rip), %rdi # 0xe7233
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x59627(%rip), %rdi # 0xe2d20
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x8976b
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8976b
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x8976b
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8976b
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
je 0x8a3b5
movq %r14, %rdi
callq 0x44a29
cmpl $0x2, %eax
jne 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x5951c(%rip), %rdi # 0xe2cd6
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x5946d(%rip), %rdi # 0xe2d15
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x1, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x15, %eax
jne 0x89b2d
leaq 0x5f8fb(%rip), %rdi # 0xe91db
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x15, %eax
jne 0x89b2d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x89b2d
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x47bf1
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r15, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x89b2d
leaq 0x59343(%rip), %rdi # 0xe2cf6
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x1, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0x592fd(%rip), %rdi # 0xe2d02
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x1, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
jne 0x89b2d
leaq 0xbdfc2(%rip), %rdi # 0x147a19
jmp 0x89a8c
movq %r14, %rdi
callq 0x44a29
cmpl $0x1, %eax
jne 0x89b2d
movq %r14, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl $0x15, %eax
jne 0x89b2d
leaq 0x5f200(%rip), %rdi # 0xe8c8c
callq 0x47ccf
movq %rax, %r15
movq %rax, %r13
movzbl (%r13), %eax
testl %eax, %eax
je 0x89ab7
cmpl $0x20, %eax
je 0x89aaf
cmpl $0x9, %eax
je 0x89aaf
incq %r13
jmp 0x89a97
movb $0x0, (%r13)
incq %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x44af3
cmpb $0x0, (%r13)
je 0x89b24
leaq 0x54fe4(%rip), %rsi # 0xdeab4
movq %rbx, %rdi
callq 0x44af3
leaq 0x53a52(%rip), %r12 # 0xdd531
movzbl (%r13), %eax
cmpl $0x24, %eax
je 0x89aff
testl %eax, %eax
je 0x89b24
movsbl %al, %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
jmp 0x89b1f
movsbl 0x1(%r13), %esi
cmpl $-0x1, %esi
je 0x89b1b
incq %r13
decl %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
jmp 0x89b1f
addq $0x3, %r13
incq %r13
jmp 0x89adf
testq %r15, %r15
jne 0x89dbd
movq %r14, %rdi
callq 0x44a14
cmpl $0xa6, %eax
je 0x89c91
cmpl $0xaa, %eax
je 0x89c19
cmpl $0x4dd, %eax # imm = 0x4DD
je 0x89d03
cmpl $0xc0, %eax
je 0x89c73
cmpl $0xc2, %eax
je 0x89c3c
cmpl $0xcb, %eax
je 0x89d45
cmpl $0x101, %eax # imm = 0x101
je 0x89c83
cmpl $0x102, %eax # imm = 0x102
je 0x89d71
cmpl $0x10c, %eax # imm = 0x10C
je 0x89cd5
cmpl $0x364, %eax # imm = 0x364
je 0x89d27
cmpl $0x366, %eax # imm = 0x366
je 0x89cf7
cmpl $0x4d3, %eax # imm = 0x4D3
je 0x89c0b
cmpl $0x4d4, %eax # imm = 0x4D4
je 0x89cb4
cmpl $0x4d6, %eax # imm = 0x4D6
je 0x89c0b
cmpl $0xbf, %eax
jne 0x89de4
pushq $0x15
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x8a3c1
testb %al, %al
je 0x89d8e
pushq $0x1
popq %rsi
pushq $0x15
popq %rdx
movq %r14, %rdi
callq 0x8a3c1
testb %al, %al
je 0x89d8e
leaq 0x5386a(%rip), %rdi # 0xdd46e
pushq $0x2
jmp 0x89d63
pushq $0x2
popq %rsi
pushq $0x15
popq %rdx
movq %r14, %rdi
jmp 0x89cbf
movq %r14, %rdi
xorl %esi, %esi
movl $0x9b, %edx
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0x58f0f(%rip), %rdi # 0xe2b46
jmp 0x89d61
pushq $0x15
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x8a3c1
testb %al, %al
je 0x89de4
pushq $0x1
popq %rsi
pushq $0x15
popq %rdx
movq %r14, %rdi
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0x58ec7(%rip), %rdi # 0xe2b35
jmp 0x89da7
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x14b, %edx # imm = 0x14B
jmp 0x89d97
pushq $0x1
popq %rsi
pushq $0x15
popq %rdx
movq %r14, %rdi
jmp 0x89d7c
movq %r14, %rdi
xorl %esi, %esi
movl $0x9b, %edx
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0x58e9c(%rip), %rdi # 0xe2b4b
jmp 0x89d61
pushq $0x2
popq %rsi
movq %r14, %rdi
movl $0x14b, %edx # imm = 0x14B
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0xc5590(%rip), %rdi # 0x14f263
jmp 0x89d20
pushq $0x1
popq %rsi
pushq $0x15
popq %rdx
movq %r14, %rdi
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0x58e4e(%rip), %rdi # 0xe2b40
jmp 0x89da7
movq %r14, %rdi
xorl %esi, %esi
movl $0x115, %edx # imm = 0x115
jmp 0x89d2f
pushq $0x2
popq %rsi
pushq $0x15
popq %rdx
movq %r14, %rdi
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0xbd77a(%rip), %rdi # 0x14749a
pushq $0x1
jmp 0x89da9
pushq $0x13
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0x58e0d(%rip), %rdi # 0xe2b50
jmp 0x89d61
pushq $0x15
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0x559a9(%rip), %rdi # 0xdf70a
pushq $0x1
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x8a3fd
jmp 0x89db5
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x14b, %edx # imm = 0x14B
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0x58daf(%rip), %rdi # 0xe2b3b
jmp 0x89da7
pushq $0x1
popq %rsi
pushq $0x15
popq %rdx
movq %r14, %rdi
callq 0x8a3c1
testb %al, %al
je 0x89de4
leaq 0x58d89(%rip), %rdi # 0xe2b30
pushq $0x2
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x8a442
movq %rax, %r15
testq %rax, %rax
je 0x89de4
movq %r15, %rdi
callq 0x8aa90
movq %r14, %rdi
movl %eax, %esi
callq 0x44a11
leaq 0x116312(%rip), %rax # 0x1a00e8
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *(%rax)
movq %r14, %rdi
callq 0x44a14
movl %eax, %eax
leaq 0x56b4b(%rip), %rcx # 0xe0940
movl (%rcx,%rax,4), %r12d
movq %r14, %rdi
callq 0x44a14
movl %eax, %eax
leaq 0x585f6(%rip), %rcx # 0xe2400
movzbl (%rax,%rcx), %r15d
movl %r12d, %eax
andl $0x3fff, %eax # imm = 0x3FFF
leaq 0x17bde2(%rip), %rcx # 0x205c00
leaq (%rax,%rcx), %rsi
decq %rsi
movq %rbx, %rdi
callq 0x44af3
movl %r12d, %eax
shrl $0xe, %eax
andl $0x7, %eax
leaq 0x563eb(%rip), %rcx # 0xe0228
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x8a485
movl %r12d, %eax
shrl $0x11, %eax
andl $0xf, %eax
leaq 0x563e5(%rip), %rcx # 0xe0248
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0x4a835(%rip), %rsi # 0xd46b6
movq %rbx, %rdi
callq 0x44af3
movl %r12d, %eax
shrl $0x11, %eax
andl $0xf, %eax
leaq 0x563af(%rip), %rcx # 0xe0248
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a6a9
leaq 0x4a7ff(%rip), %rsi # 0xd46b6
movq %rbx, %rdi
callq 0x44af3
movq %r14, %rdi
xorl %esi, %esi
jmp 0x8a14a
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
movl %r12d, %eax
shrl $0x11, %eax
andl $0xf, %eax
leaq 0x56361(%rip), %rcx # 0xe0248
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testl $0xffffffe0, %eax # imm = 0xFFFFFFE0
je 0x89f35
xorl %esi, %esi
jmp 0x89f46
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0x4a793(%rip), %rsi # 0xd46b6
movq %rbx, %rdi
callq 0x44af3
movq %r14, %rdi
xorl %esi, %esi
jmp 0x8a091
andl $0x1f, %eax
leaq 0x58b71(%rip), %rcx # 0xe2ab0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x44af3
movl %r12d, %eax
shrl $0x11, %eax
andl $0xf, %eax
leaq 0x562ea(%rip), %rcx # 0xe0248
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4a748(%rip), %rsi # 0xd46b6
jmp 0x8a00a
pushq $0x2
jmp 0x8a146
leaq 0x58c05(%rip), %rsi # 0xe2b86
jmp 0x8a1b0
leaq 0x58bf0(%rip), %rsi # 0xe2b7d
jmp 0x8a1b0
leaq 0x58be0(%rip), %rsi # 0xe2b79
jmp 0x8a067
leaq 0x58c0b(%rip), %rsi # 0xe2bb0
movq %rbx, %rdi
callq 0x44af3
jmp 0x8a03f
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
jmp 0x8a012
leaq 0x58b94(%rip), %rsi # 0xe2b5d
jmp 0x8a083
leaq 0x58bb7(%rip), %rsi # 0xe2b8c
movq %rbx, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0x58bba(%rip), %rsi # 0xe2bac
jmp 0x8a1b0
leaq 0x58b68(%rip), %rsi # 0xe2b66
jmp 0x8a1b0
leaq 0x5342d(%rip), %rsi # 0xdd437
movq %rbx, %rdi
callq 0x44af3
movl %r12d, %eax
shrl $0x15, %eax
andl $0xf, %eax
decq %rax
cmpq $0x9, %rax
ja 0x8a172
leaq 0x56259(%rip), %rcx # 0xe0288
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x2
jmp 0x8a178
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0x4a662(%rip), %rsi # 0xd46b6
movq %rbx, %rdi
callq 0x44af3
pushq $0x2
jmp 0x8a08d
leaq 0x58b0e(%rip), %rsi # 0xe2b75
movq %rbx, %rdi
callq 0x44af3
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x8a485
leaq 0x4a633(%rip), %rsi # 0xd46b6
movq %rbx, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8a485
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a6a9
leaq 0x4a61b(%rip), %rsi # 0xd46d2
movq %rbx, %rdi
callq 0x44af3
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0x53363(%rip), %rsi # 0xdd437
movq %rbx, %rdi
callq 0x44af3
pushq $0x4
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a6a9
leaq 0x53f3d(%rip), %rsi # 0xde02e
jmp 0x8a1b0
leaq 0x58aca(%rip), %rsi # 0xe2bc7
movq %rbx, %rdi
callq 0x44af3
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x8a485
leaq 0x58ab6(%rip), %rsi # 0xe2bcf
jmp 0x8a1b0
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a6a9
leaq 0x4a59f(%rip), %rsi # 0xd46d2
jmp 0x8a054
leaq 0x58a80(%rip), %rsi # 0xe2bbf
jmp 0x89f23
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8a7a8
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8a6a9
pushq $0x1
jmp 0x8a178
pushq $0x4
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
movl %r12d, %eax
shrl $0x19, %eax
andl $0xf, %eax
leaq 0x5611c(%rip), %rcx # 0xe02b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4a512(%rip), %rsi # 0xd46b6
jmp 0x8a241
leaq 0x589b5(%rip), %rsi # 0xe2b65
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x44af3
leaq 0x58a49(%rip), %rsi # 0xe2c11
jmp 0x89fa5
leaq 0x41223(%rip), %rsi # 0xcb3f7
movq %rbx, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0xbc39a(%rip), %rsi # 0x14658b
jmp 0x8a1b0
leaq 0x58a0e(%rip), %rsi # 0xe2c08
movq %rbx, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0x589f5(%rip), %rsi # 0xe2c0c
jmp 0x8a1b0
leaq 0x589d7(%rip), %rsi # 0xe2bf7
jmp 0x8a1b0
leaq 0x589fb(%rip), %rsi # 0xe2c24
jmp 0x89fa5
leaq 0x589b3(%rip), %rsi # 0xe2be8
jmp 0x8a1b0
leaq 0x531f6(%rip), %rsi # 0xdd437
movq %rbx, %rdi
callq 0x44af3
shrl $0x1d, %r12d
decq %r12
cmpq $0x3, %r12
ja 0x8a370
leaq 0x5608f(%rip), %rax # 0xe02f0
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a808
movl %r15d, %eax
andl $0x3, %eax
leaq 0x5607b(%rip), %rcx # 0xe0300
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x58940(%rip), %rsi # 0xe2bd5
jmp 0x8a054
leaq 0x5d0b0(%rip), %rsi # 0xe7351
jmp 0x8a1b0
leaq 0x58931(%rip), %rsi # 0xe2bde
jmp 0x8a054
leaq 0x58943(%rip), %rsi # 0xe2bfc
movq %rbx, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0x58887(%rip), %rsi # 0xe2b5d
movq %rbx, %rdi
callq 0x44af3
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
leaq 0x58912(%rip), %rsi # 0xe2c05
jmp 0x8a1b0
leaq 0x588e8(%rip), %rsi # 0xe2be7
jmp 0x8a1b0
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a808
movl %r15d, %eax
andl $0x3, %eax
leaq 0x55fe1(%rip), %rcx # 0xe0300
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
movl %r15d, %eax
andl $0x3, %eax
leaq 0x55fbd(%rip), %rcx # 0xe0300
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a6a9
movl %r15d, %eax
andl $0x3, %eax
leaq 0x55f99(%rip), %rcx # 0xe0300
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8a485
movl %r15d, %eax
andl $0x3, %eax
leaq 0x55f75(%rip), %rcx # 0xe0300
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4a31b(%rip), %rsi # 0xd46b6
movq %rbx, %rdi
callq 0x44af3
pushq $0x3
popq %rsi
testb $0x4, %r15b
jne 0x8a08e
jmp 0x8a15e
leaq 0x58914(%rip), %rdi # 0xe2cd0
jmp 0x89a8c
| /bughoho[P]capstone/arch/Mips/MipsInstPrinter.c |
printOperand | static void printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op;
if (OpNo >= MI->size)
return;
Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
unsigned int reg = MCOperand_getReg(Op);
printRegName(O, reg);
reg = Mips_map_register(reg);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.base = reg;
} else {
MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_REG;
MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].reg = reg;
MI->flat_insn->detail->mips.op_count++;
}
}
} else if (MCOperand_isImm(Op)) {
int64_t imm = MCOperand_getImm(Op);
if (MI->csh->doing_mem) {
if (imm) { // only print Imm offset if it is not 0
if (imm >= 0) {
if (imm > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, imm);
else
SStream_concat(O, "%"PRIu64, imm);
} else {
if (imm < -HEX_THRESHOLD)
SStream_concat(O, "-0x%"PRIx64, -imm);
else
SStream_concat(O, "-%"PRIu64, -imm);
}
}
if (MI->csh->detail)
MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.disp = imm;
} else {
if (imm >= 0) {
if (imm > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, imm);
else
SStream_concat(O, "%"PRIu64, imm);
} else {
if (imm < -HEX_THRESHOLD)
SStream_concat(O, "-0x%"PRIx64, -imm);
else
SStream_concat(O, "-%"PRIu64, -imm);
}
if (MI->csh->detail) {
MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_IMM;
MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].imm = imm;
MI->flat_insn->detail->mips.op_count++;
}
}
}
} | movzbl 0x4(%rdi), %eax
cmpl %esi, %eax
jbe 0x8a6a8
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
callq 0x44a1b
movq %rax, %r14
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x8a526
movq %r14, %rdi
callq 0x44a6e
movl %eax, %r14d
leal -0x1(%r14), %eax
leaq 0x55e4a(%rip), %rcx # 0xe0310
movl (%rcx,%rax,4), %eax
leaq 0x17b510(%rip), %rdx # 0x2059e0
addq %rax, %rdx
leaq 0x5867f(%rip), %rsi # 0xe2b59
movq %r15, %rdi
xorl %eax, %eax
callq 0x44b3a
movl %r14d, %edi
callq 0x8aaaf
movq 0x320(%rbx), %rdx
cmpl $0x0, 0x68(%rdx)
je 0x8a6a3
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x30(%rcx), %esi
addq $0x38, %rcx
cmpb $0x1, 0x70(%rdx)
jne 0x8a56f
imulq $0x18, %rsi, %rdx
movl %eax, 0x8(%rcx,%rdx)
jmp 0x8a6a3
movq %r14, %rdi
callq 0x44a5e
testb %al, %al
je 0x8a6a3
movq %r14, %rdi
callq 0x44a76
movq %rax, %r14
movq 0x320(%rbx), %rax
cmpb $0x1, 0x70(%rax)
jne 0x8a599
testq %r14, %r14
je 0x8a67b
js 0x8a5d1
cmpq $0xa, %r14
jb 0x8a5ed
leaq 0xbc08b(%rip), %rsi # 0x1465f5
jmp 0x8a5f4
imulq $0x18, %rsi, %rdx
movl $0x1, (%rcx,%rdx)
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x30(%rcx), %edx
imulq $0x18, %rdx, %rdx
movl %eax, 0x40(%rcx,%rdx)
jmp 0x8a657
testq %r14, %r14
js 0x8a5ad
cmpq $0xa, %r14
jb 0x8a5c2
leaq 0xbc04a(%rip), %rsi # 0x1465f5
jmp 0x8a5c9
movq %r14, %rdx
negq %rdx
cmpq $-0xa, %r14
ja 0x8a5fc
leaq 0x37287(%rip), %rsi # 0xc1847
jmp 0x8a603
leaq 0xbc035(%rip), %rsi # 0x1465fe
movq %r15, %rdi
movq %r14, %rdx
jmp 0x8a606
movq %r14, %rdx
negq %rdx
cmpq $-0xa, %r14
ja 0x8a66a
leaq 0x3725f(%rip), %rsi # 0xc1847
jmp 0x8a671
leaq 0xbc00a(%rip), %rsi # 0x1465fe
movq %r15, %rdi
movq %r14, %rdx
jmp 0x8a674
leaq 0x3724c(%rip), %rsi # 0xc184f
movq %r15, %rdi
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8a6a3
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x30(%rax), %ecx
imulq $0x18, %rcx, %rcx
movl $0x2, 0x38(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x30(%rax), %ecx
imulq $0x18, %rcx, %rcx
movq %r14, 0x40(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x30(%rax)
jmp 0x8a6a3
leaq 0x371de(%rip), %rsi # 0xc184f
movq %r15, %rdi
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8a6a3
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x30(%rax), %ecx
imulq $0x18, %rcx, %rcx
movq %r14, 0x48(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
| /bughoho[P]capstone/arch/Mips/MipsInstPrinter.c |
printMemOperand | static void printMemOperand(MCInst *MI, int opNum, SStream *O)
{
// Load/Store memory operands -- imm($reg)
// If PIC target the target is loaded as the
// pattern lw $25,%call16($28)
set_mem_access(MI, true);
printOperand(MI, opNum + 1, O);
SStream_concat0(O, "(");
printOperand(MI, opNum, O);
SStream_concat0(O, ")");
set_mem_access(MI, false);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x8a8da
leal 0x1(%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8a485
leaq 0x40c23(%rip), %rsi # 0xcb3f7
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x8a485
leaq 0xbbd9a(%rip), %rsi # 0x14658b
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x8a8da
| /bughoho[P]capstone/arch/Mips/MipsInstPrinter.c |
Mips_get_insn_id | void Mips_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id)
{
unsigned int 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));
insn->detail->regs_read_count = (uint8_t)count_positive(insns[i].regs_use);
memcpy(insn->detail->regs_write, insns[i].regs_mod, sizeof(insns[i].regs_mod));
insn->detail->regs_write_count = (uint8_t)count_positive(insns[i].regs_mod);
memcpy(insn->detail->groups, insns[i].groups, sizeof(insns[i].groups));
insn->detail->groups_count = (uint8_t)count_positive(insns[i].groups);
if (insns[i].branch || insns[i].indirect_branch) {
// this insn also belongs to JUMP group. add JUMP group
insn->detail->groups[insn->detail->groups_count] = MIPS_GRP_JUMP;
insn->detail->groups_count++;
}
#endif
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x78(%rdi), %rcx
leaq 0x17fb20(%rip), %r14 # 0x20a4a0
movq %r14, %rdi
movl $0x5dc, %esi # imm = 0x5DC
callq 0x47c04
testw %ax, %ax
je 0x8aa39
movzwl %ax, %eax
imulq $0x2e, %rax, %rax
movzwl 0x2(%rax,%r14), %ecx
movl %ecx, (%rbx)
cmpl $0x0, 0x68(%r15)
je 0x8aa39
addq %rax, %r14
movq 0xe8(%rbx), %rax
leaq 0x4(%r14), %rdi
movl 0xc(%r14), %ecx
movl %ecx, 0x8(%rax)
movq 0x4(%r14), %rcx
movq %rcx, (%rax)
callq 0x47cc3
movq 0xe8(%rbx), %rcx
movb %al, 0xc(%rcx)
leaq 0x10(%r14), %rdi
movl 0x20(%r14), %eax
movl %eax, 0x1d(%rcx)
movups 0x10(%r14), %xmm0
movups %xmm0, 0xd(%rcx)
callq 0x47cc3
movq 0xe8(%rbx), %rcx
movb %al, 0x21(%rcx)
leaq 0x24(%r14), %rdi
movq 0x24(%r14), %rax
movq %rax, 0x22(%rcx)
callq 0x47cc3
movq 0xe8(%rbx), %rcx
movb %al, 0x2a(%rcx)
cmpb $0x0, 0x2c(%r14)
jne 0x8aa27
cmpb $0x1, 0x2d(%r14)
jne 0x8aa39
movzbl %al, %eax
movb $0x1, 0x22(%rcx,%rax)
movq 0xe8(%rbx), %rax
incb 0x2a(%rax)
popq %rbx
popq %r14
popq %r15
retq
| /bughoho[P]capstone/arch/Mips/MipsMapping.c |
PPC_getInstruction | bool PPC_getInstruction(csh ud, const uint8_t *code, size_t code_len,
MCInst *instr, uint16_t *size, uint64_t address, void *info)
{
DecodeStatus status = getInstruction(instr,
code, code_len,
size,
address, (MCRegisterInfo *)info);
return status == MCDisassembler_Success;
} | xorl %edi, %edi
movl $0x0, %eax
cmpq $0x4, %rdx
jb 0x8ad09
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x320(%rcx), %rax
cmpl $0x0, 0x4(%rax)
movq %r8, 0x20(%rsp)
js 0x8aafd
movl (%rsi), %eax
jmp 0x8ab01
movl (%rsi), %eax
bswapl %eax
movl %eax, 0xc(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x310(%rcx), %rax
movq 0xe8(%rax), %rdi
testq %rdi, %rdi
je 0x8ab29
movl $0x5f8, %edx # imm = 0x5F8
xorl %esi, %esi
callq 0x430d0
movl 0xc(%rsp), %eax
notl %eax
movl %eax, 0x14(%rsp)
leaq 0x192136(%rip), %rcx # 0x21cc70
xorl %r14d, %r14d
pushq $0x3
popq %rax
movl %eax, 0x10(%rsp)
leaq 0x594f5(%rip), %rbx # 0xe4040
pushq $-0x1
popq %rbp
leaq 0x8(%rsp), %r12
movzbl (%rcx), %eax
decl %eax
cmpl $0x5, %eax
ja 0x8ace5
movq %rcx, %r13
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
leaq 0x1(%r13), %rdi
movq %r12, %rsi
callq 0x8ad78
movl 0x8(%rsp), %edx
leaq (%rdx,%r13), %rcx
addq $0x3, %rcx
cmpl %eax, %r14d
je 0x8ab53
leaq (%rdx,%r13), %rax
incq %rax
jmp 0x8ac02
leaq 0x1(%r13), %rdi
movq %r12, %rsi
callq 0x8ad78
movl 0x8(%rsp), %eax
leaq (%rax,%r13), %rcx
addq $0x3, %rcx
jmp 0x8ab53
movb 0x1(%r13), %al
movzbl 0x2(%r13), %edx
movl %ebp, %r15d
movl %edx, %ecx
shll %cl, %r15d
notl %r15d
movl %eax, %ecx
shll %cl, %r15d
cmpl $0x20, %edx
movl %edx, 0x8(%rsp)
cmovel %ebp, %r15d
andl 0xc(%rsp), %r15d
shrl %cl, %r15d
leaq 0x3(%r13), %rdi
movq %r12, %rsi
callq 0x8ad78
movl 0x8(%rsp), %edx
leaq (%rdx,%r13), %rcx
addq $0x5, %rcx
cmpl %eax, %r15d
je 0x8ab53
leaq (%rdx,%r13), %rax
addq $0x3, %rax
movzwl (%rax), %eax
addq %rax, %rcx
jmp 0x8ab53
movb 0x1(%r13), %al
movzbl 0x2(%r13), %edx
movl %ebp, %r14d
movl %edx, %ecx
shll %cl, %r14d
notl %r14d
movl %eax, %ecx
shll %cl, %r14d
addq $0x3, %r13
cmpl $0x20, %edx
movl %edx, 0x8(%rsp)
cmovel %ebp, %r14d
andl 0xc(%rsp), %r14d
shrl %cl, %r14d
movq %r13, %rcx
jmp 0x8ab53
leaq 0x1(%r13), %rdi
movq %r12, %rsi
callq 0x8ad78
movq %rax, %r15
movl 0x8(%rsp), %eax
addq %rax, %r13
incq %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x8ad78
movl 0x8(%rsp), %ecx
addq %r13, %rcx
andl 0xc(%rsp), %r15d
andl 0x14(%rsp), %eax
orl %r15d, %eax
movl 0x10(%rsp), %eax
pushq $0x1
popq %rdx
cmovnel %edx, %eax
movl %eax, 0x10(%rsp)
jmp 0x8ab53
leaq 0x1(%r13), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x8ad78
movq %rax, %r12
movl (%r15), %eax
leaq (%rax,%r13), %rdi
incq %rdi
movq %r15, %rsi
callq 0x8ad78
movq %rax, %r15
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x44a0d
movl 0x10(%rsp), %edi
movl %r15d, %esi
movl 0xc(%rsp), %edx
movq %rbx, %rcx
callq 0x8ada6
testl %eax, %eax
je 0x8acea
movw $0x4, %di
jmp 0x8acf6
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x449cb
xorl %edi, %edi
xorl %eax, %eax
movq 0x20(%rsp), %r8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movw %di, (%r8)
cmpl $0x3, %eax
sete %al
retq
| /bughoho[P]capstone/arch/PowerPC/PPCDisassembler.c |
PPC_printInst | void PPC_printInst(MCInst *MI, SStream *O, void *Info)
{
char *mnem;
// Check for slwi/srwi mnemonics.
if (MCInst_getOpcode(MI) == PPC_RLWINM) {
unsigned char SH = (unsigned char)MCOperand_getImm(MCInst_getOperand(MI, 2));
unsigned char MB = (unsigned char)MCOperand_getImm(MCInst_getOperand(MI, 3));
unsigned char ME = (unsigned char)MCOperand_getImm(MCInst_getOperand(MI, 4));
bool useSubstituteMnemonic = false;
if (SH <= 31 && MB == 0 && ME == (31-SH)) {
SStream_concat0(O, "slwi\t");
MCInst_setOpcodePub(MI, PPC_INS_SLWI);
useSubstituteMnemonic = true;
}
if (SH <= 31 && MB == (32-SH) && ME == 31) {
SStream_concat0(O, "srwi\t");
MCInst_setOpcodePub(MI, PPC_INS_SRWI);
useSubstituteMnemonic = true;
SH = 32-SH;
}
if (useSubstituteMnemonic) {
printOperand(MI, 0, O);
SStream_concat0(O, ", ");
printOperand(MI, 1, O);
if (SH > HEX_THRESHOLD)
SStream_concat(O, ", 0x%x", (unsigned int)SH);
else
SStream_concat(O, ", %u", (unsigned int)SH);
if (MI->csh->detail) {
cs_ppc *ppc = &MI->flat_insn->detail->ppc;
ppc->operands[ppc->op_count].type = PPC_OP_IMM;
ppc->operands[ppc->op_count].imm = SH;
++ppc->op_count;
}
return;
}
}
if ((MCInst_getOpcode(MI) == PPC_OR || MCInst_getOpcode(MI) == PPC_OR8) &&
MCOperand_getReg(MCInst_getOperand(MI, 1)) == MCOperand_getReg(MCInst_getOperand(MI, 2))) {
SStream_concat0(O, "mr\t");
MCInst_setOpcodePub(MI, PPC_INS_MR);
printOperand(MI, 0, O);
SStream_concat0(O, ", ");
printOperand(MI, 1, O);
return;
}
if (MCInst_getOpcode(MI) == PPC_RLDICR) {
unsigned char SH = (unsigned char)MCOperand_getImm(MCInst_getOperand(MI, 2));
unsigned char ME = (unsigned char)MCOperand_getImm(MCInst_getOperand(MI, 3));
// rldicr RA, RS, SH, 63-SH == sldi RA, RS, SH
if (63-SH == ME) {
SStream_concat0(O, "sldi\t");
MCInst_setOpcodePub(MI, PPC_INS_SLDI);
printOperand(MI, 0, O);
SStream_concat0(O, ", ");
printOperand(MI, 1, O);
if (SH > HEX_THRESHOLD)
SStream_concat(O, ", 0x%x", (unsigned int)SH);
else
SStream_concat(O, ", %u", (unsigned int)SH);
return;
}
}
if ((MCInst_getOpcode(MI) == PPC_gBC)||(MCInst_getOpcode(MI) == PPC_gBCA)||
(MCInst_getOpcode(MI) == PPC_gBCL)||(MCInst_getOpcode(MI) == PPC_gBCLA)) {
int64_t bd = MCOperand_getImm(MCInst_getOperand(MI, 2));
bd = SignExtend64(bd, 14);
MCOperand_setImm(MCInst_getOperand(MI, 2),bd);
}
if (isBOCTRBranch(MCInst_getOpcode(MI))) {
if (MCOperand_isImm(MCInst_getOperand(MI,0)))
{
int64_t bd = MCOperand_getImm(MCInst_getOperand(MI, 0));
bd = SignExtend64(bd, 14);
MCOperand_setImm(MCInst_getOperand(MI, 0),bd);
}
}
if ((MCInst_getOpcode(MI) == PPC_B)||(MCInst_getOpcode(MI) == PPC_BA)||
(MCInst_getOpcode(MI) == PPC_BL)||(MCInst_getOpcode(MI) == PPC_BLA)) {
int64_t bd = MCOperand_getImm(MCInst_getOperand(MI, 0));
bd = SignExtend64(bd, 24);
MCOperand_setImm(MCInst_getOperand(MI, 0),bd);
}
// consider our own alias instructions first
mnem = printAliasInstrEx(MI, O, Info);
if (!mnem)
mnem = printAliasInstr(MI, O, Info);
if (mnem != NULL) {
if (strlen(mnem) > 0) {
struct ppc_alias alias;
// check to remove the last letter of ('.', '-', '+')
if (mnem[strlen(mnem) - 1] == '-' || mnem[strlen(mnem) - 1] == '+' || mnem[strlen(mnem) - 1] == '.')
mnem[strlen(mnem) - 1] = '\0';
if (PPC_alias_insn(mnem, &alias)) {
MCInst_setOpcodePub(MI, alias.id);
if (MI->csh->detail) {
MI->flat_insn->detail->ppc.bc = (ppc_bc)alias.cc;
}
}
}
cs_mem_free(mnem);
} else
printInstruction(MI, O, NULL);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
movq %rdi, %rbx
callq 0x44a14
cmpl $0x311, %eax # imm = 0x311
jne 0x8c1b8
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movq %rax, %r13
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movq %rax, %rbp
movl $0xff, %r15d
movl %r12d, %r14d
andl %r15d, %r14d
cmpl $0x20, %r14d
setb %al
andl %r13d, %r15d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8c0d7
movzbl %bpl, %eax
pushq $0x1f
popq %rcx
subl %r14d, %ecx
cmpl %ecx, %eax
jne 0x8c0e1
leaq 0x5a84a(%rip), %rsi # 0xe6907
movq (%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x301, %esi # imm = 0x301
callq 0x44a11
movb $0x1, %al
jmp 0x8c0e3
cmpl $0x1f, %r14d
ja 0x8c1b8
xorl %eax, %eax
pushq $0x20
popq %rcx
subl %r14d, %ecx
cmpl %ecx, %r15d
sete %cl
cmpb $0x1f, %bpl
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x8c11f
leaq 0x5a809(%rip), %rsi # 0xe690d
movq (%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x302, %esi # imm = 0x302
callq 0x44a11
movq %r13, %r12
jmp 0x8c127
testb %al, %al
je 0x8c1b8
movq %rbx, %rdi
xorl %esi, %esi
movq (%rsp), %r14
movq %r14, %rdx
callq 0x8d693
leaq 0x48577(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8d693
movzbl %r12b, %ebp
cmpb $0xa, %r12b
leaq 0x5a7af(%rip), %rax # 0xe6913
leaq 0x3f1a9(%rip), %rsi # 0xcb314
cmovaeq %rax, %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8ceb9
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x39(%rax), %ecx
leal 0x1(%rcx), %edx
shll $0x4, %ecx
movl $0x2, 0x3c(%rax,%rcx)
movl %ebp, 0x40(%rax,%rcx)
movb %dl, 0x39(%rax)
jmp 0x8ceb9
movq %rbx, %rdi
callq 0x44a14
cmpl $0x2e8, %eax # imm = 0x2E8
je 0x8c1da
movq %rbx, %rdi
callq 0x44a14
cmpl $0x2e9, %eax # imm = 0x2E9
jne 0x8c261
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
cmpl %eax, %ebp
jne 0x8c261
leaq 0x5a70d(%rip), %rsi # 0xe691a
movq (%rsp), %r14
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x34c, %esi # imm = 0x34C
callq 0x44a11
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8d693
leaq 0x4847c(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8d693
movq %rbx, %rdi
callq 0x44a14
cmpl $0x308, %eax # imm = 0x308
movq (%rsp), %r14
jne 0x8c311
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movl $0xff, %ecx
andl %ecx, %r12d
pushq $0x3f
popq %rdx
subl %r12d, %edx
andl %ecx, %eax
cmpl %eax, %edx
jne 0x8c311
leaq 0x5a662(%rip), %rsi # 0xe691e
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x303, %esi # imm = 0x303
callq 0x44a11
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8d693
leaq 0x483d1(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8d693
cmpl $0xa, %r12d
jb 0x8cb4b
leaq 0x5a607(%rip), %rsi # 0xe6913
jmp 0x8cb52
movq %rbx, %rdi
callq 0x44a14
cmpl $0x4ed, %eax # imm = 0x4ED
je 0x8c34d
movq %rbx, %rdi
callq 0x44a14
cmpl $0x4ee, %eax # imm = 0x4EE
je 0x8c34d
movq %rbx, %rdi
callq 0x44a14
cmpl $0x4f1, %eax # imm = 0x4F1
je 0x8c34d
movq %rbx, %rdi
callq 0x44a14
cmpl $0x4f2, %eax # imm = 0x4F2
jne 0x8c382
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movq %rax, %r12
shlq $0x32, %r12
sarq $0x32, %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x44a1b
movq %rax, %rdi
movq %r12, %rsi
callq 0x44a7b
movq %rbx, %rdi
callq 0x44a14
addl $0xffffff46, %eax # imm = 0xFFFFFF46
cmpl $-0x28, %eax
jb 0x8c3dc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8c3dc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movq %rax, %r12
shlq $0x32, %r12
sarq $0x32, %r12
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
movq %r12, %rsi
callq 0x44a7b
movq %rbx, %rdi
callq 0x44a14
cmpl $0x71, %eax
je 0x8c414
movq %rbx, %rdi
callq 0x44a14
cmpl $0x72, %eax
je 0x8c414
movq %rbx, %rdi
callq 0x44a14
cmpl $0xba, %eax
je 0x8c414
movq %rbx, %rdi
callq 0x44a14
cmpl $0xc0, %eax
jne 0x8c446
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movq %rax, %r12
shlq $0x28, %r12
sarq $0x28, %r12
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
movq %r12, %rsi
callq 0x44a7b
leaq 0x10(%rsp), %rdi
callq 0x44ae8
movq %rbx, %rdi
callq 0x44a14
addl $0xfffffb13, %eax # imm = 0xFFFFFB13
cmpl $0x8, %eax
jae 0x8ce21
movl %eax, %eax
leaq 0x106b91(%rip), %rcx # 0x193000
movq (%rcx,%rax,8), %r12
movq %rbx, %rdi
callq 0x44a29
xorl %r15d, %r15d
cmpl $0x3, %eax
jne 0x8c4eb
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8c4eb
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
js 0x8c4eb
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x1, %rax
jg 0x8c4eb
leaq 0x5d4ac(%rip), %rdx # 0xe9984
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
pushq $0x1
popq %r15
movq %rbx, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x8c558
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8c558
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x2, %rax
jl 0x8c558
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x3, %rax
jg 0x8c558
leaq 0x5d445(%rip), %rdx # 0xe998a
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
pushq $0x1
popq %r15
movq %rbx, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x8c69f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8c69f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x4, %rax
jl 0x8c69f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x7, %rax
jg 0x8c69f
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x8c69f
pushq $0x3
popq %rsi
movq 0x8(%rsp), %rdi
callq 0x47bf1
movq %rax, %rbp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %rbp, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x8c69f
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
addl $0xffffff09, %eax # imm = 0xFFFFFF09
sarl $0x3, %eax
cmpl $0x3, %eax
ja 0x8c64a
movl %eax, %eax
leaq 0x5a294(%rip), %rcx # 0xe68c8
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x6, %rax
jne 0x8c676
leaq 0x34f14(%rip), %rsi # 0xc1580
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x7, %rax
jne 0x8c69f
leaq 0x5a270(%rip), %rsi # 0xe6905
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x8c70c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8c70c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x8, %rax
jl 0x8c70c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x9, %rax
jg 0x8c70c
leaq 0x5d285(%rip), %rdx # 0xe997e
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
pushq $0x1
popq %r15
movq %rbx, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x8c779
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8c779
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0xa, %rax
jl 0x8c779
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0xb, %rax
jg 0x8c779
pushq $0x1
popq %r15
leaq 0x5d225(%rip), %rdx # 0xe998f
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
movq %rbx, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x8c8c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8c8c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0xc, %rax
jl 0x8c8c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0xf, %rax
jg 0x8c8c0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0x8c8c0
pushq $0x3
popq %rsi
movq 0x8(%rsp), %rdi
callq 0x47bf1
movq %rax, %rbp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %rbp, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x8c8c0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
addl $0xffffff09, %eax # imm = 0xFFFFFF09
sarl $0x3, %eax
cmpl $0x3, %eax
ja 0x8c86b
movl %eax, %eax
leaq 0x5a083(%rip), %rcx # 0xe68d8
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0xe, %rax
jne 0x8c897
leaq 0x34cf3(%rip), %rsi # 0xc1580
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0xf, %rax
jne 0x8c8c0
leaq 0x5a04f(%rip), %rsi # 0xe6905
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x8c96d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8c96d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
andl $0x12, %eax
cmpl $0x10, %eax
jne 0x8c96d
leaq 0x5b8af(%rip), %rdx # 0xe81bb
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x18, %rax
jne 0x8c944
leaq 0x34c46(%rip), %rsi # 0xc1580
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x19, %rax
jne 0x8c96d
leaq 0x59fa2(%rip), %rsi # 0xe6905
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
callq 0x44a29
cmpl $0x3, %eax
jne 0x8ca18
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8ca18
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
notl %eax
testb $0x12, %al
jne 0x8ca18
leaq 0x5b82b(%rip), %rdx # 0xe81e2
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x44b3a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x1a, %rax
jne 0x8c9ef
leaq 0x34b9b(%rip), %rsi # 0xc1580
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0x1b, %rax
jne 0x8ca18
leaq 0x59ef7(%rip), %rsi # 0xe6905
leaq 0x10(%rsp), %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a56
movb $0x1, %r13b
testb %al, %al
je 0x8cd17
pushq $0x3
popq %rsi
movq 0x8(%rsp), %rdi
callq 0x47bf1
movq %rax, %r12
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movq %r12, %rdi
movl %eax, %esi
callq 0x47b5c
testb %al, %al
je 0x8cd17
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8cd17
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
cmpq $0xf, %rax
jg 0x8cd17
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
movl %eax, %ebp
incl %ebp
andl $0x7, %ebp
testl %r15d, %r15d
je 0x8cb70
leaq 0x5613b(%rip), %rsi # 0xe2c06
leaq 0x10(%rsp), %rdi
callq 0x44af3
testl %ebp, %ebp
je 0x8caee
leaq 0x59e74(%rip), %rsi # 0xe6954
leaq 0x10(%rsp), %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x44b3a
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
addl $0xffffff09, %eax # imm = 0xFFFFFF09
sarl $0x3, %eax
cmpl $0x3, %eax
ja 0x8cc5f
leaq 0x57cb7(%rip), %rcx # 0xe47d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5b644(%rip), %rsi # 0xe816d
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8cc5f
pushq $0x4c
jmp 0x8cc4d
leaq 0x3e7c2(%rip), %rsi # 0xcb314
movq %r14, %rdi
movl %r12d, %edx
xorl %eax, %eax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x44b3a
testl %ebp, %ebp
je 0x8cd17
leaq 0x59ddd(%rip), %rsi # 0xe695c
xorl %r13d, %r13d
leaq 0x10(%rsp), %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8cd17
addl $0x3, %ebp
leaq 0x310(%rbx), %rcx
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x39(%rax), %edx
shll $0x4, %edx
movl $0x1, 0x3c(%rax,%rdx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x39(%rax), %edx
shll $0x4, %edx
movl %ebp, 0x40(%rax,%rdx)
jmp 0x8cd07
leaq 0x5cead(%rip), %rsi # 0xe9a9a
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8cc5f
pushq $0xc
jmp 0x8cc4d
leaq 0x5cea3(%rip), %rsi # 0xe9ab2
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq 0x320(%rbx), %rcx
movl $0x8c, %eax
cmpl $0x0, 0x68(%rcx)
jne 0x8cc4e
jmp 0x8cc5f
leaq 0x5ce72(%rip), %rsi # 0xe9aa6
leaq 0x10(%rsp), %rdi
callq 0x44af3
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8cc5f
pushq $0x2c
popq %rax
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movl %eax, 0x30(%rcx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a6e
incl %eax
andl $0x7, %eax
je 0x8cd14
movq 0x320(%rbx), %rcx
cmpl $0x0, 0x68(%rcx)
je 0x8cd14
leaq 0x310(%rbx), %rcx
movq 0x310(%rbx), %rdx
movq 0xe8(%rdx), %rdx
movzbl 0x39(%rdx), %esi
shll $0x4, %esi
movl $0x40, 0x3c(%rdx,%rsi)
movq 0x310(%rbx), %rdx
movq 0xe8(%rdx), %rdx
movzbl 0x39(%rdx), %esi
shll $0x4, %esi
movl $0x4, 0x40(%rdx,%rsi)
addl $0x3, %eax
movq 0x310(%rbx), %rdx
movq 0xe8(%rdx), %rdx
movzbl 0x39(%rdx), %esi
shll $0x4, %esi
movl %eax, 0x44(%rdx,%rsi)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movl 0x30(%rax), %edx
movzbl 0x39(%rax), %esi
shll $0x4, %esi
movl %edx, 0x48(%rax,%rsi)
movq (%rcx), %rax
movq 0xe8(%rax), %rax
incb 0x39(%rax)
xorl %r13d, %r13d
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a5e
testb %al, %al
je 0x8cd6d
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
testq %rax, %rax
je 0x8cd6d
testb %r13b, %r13b
jne 0x8cd5c
leaq 0x59c10(%rip), %rsi # 0xe6962
leaq 0x10(%rsp), %rdi
callq 0x44af3
leaq 0x59d36(%rip), %rsi # 0xe6a99
leaq 0x10(%rsp), %rdi
callq 0x44af3
leaq 0x10(%rsp), %rdi
callq 0x47ccf
movq %rax, %r12
movq %rax, %rbp
movzbl (%rbp), %eax
testl %eax, %eax
je 0x8cd9b
cmpl $0x20, %eax
je 0x8cd94
cmpl $0x9, %eax
je 0x8cd94
incq %rbp
jmp 0x8cd7d
movb $0x0, (%rbp)
incq %rbp
movq %r14, %rdi
movq %r12, %rsi
callq 0x44af3
cmpb $0x0, (%rbp)
je 0x8ce1c
leaq 0x51d01(%rip), %rsi # 0xdeab4
movq %r14, %rdi
callq 0x44af3
leaq 0x5076f(%rip), %r13 # 0xdd531
movzbl (%rbp), %eax
cmpl $0x24, %eax
je 0x8cde1
testl %eax, %eax
je 0x8ce1c
movsbl %al, %edx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x44b3a
jmp 0x8ce17
movsbl 0x1(%rbp), %esi
cmpl $-0x1, %esi
je 0x8cdfc
incq %rbp
decl %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8d693
jmp 0x8ce17
movsbl 0x2(%rbp), %esi
decl %esi
movsbl 0x3(%rbp), %edx
addq $0x3, %rbp
decl %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x9d22b
incq %rbp
jmp 0x8cdc2
testq %r12, %r12
jne 0x8ce3d
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x8d86f
movq %rax, %r12
testq %rax, %rax
je 0x8cecb
cmpb $0x0, (%r12)
je 0x8cead
movq %r12, %rdi
callq 0x43080
movzbl -0x1(%rax,%r12), %ecx
cmpq $0x2e, %rcx
ja 0x8ce6e
movabsq $0x680000000000, %rdx # imm = 0x680000000000
btq %rcx, %rdx
jae 0x8ce6e
movb $0x0, -0x1(%r12,%rax)
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x9de8f
testb %al, %al
je 0x8cead
movl 0x10(%rsp), %esi
movq %rbx, %rdi
callq 0x44a11
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8cead
movl 0x14(%rsp), %eax
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movl %eax, 0x30(%rcx)
leaq 0x113234(%rip), %rax # 0x1a00e8
movq %r12, %rdi
callq *(%rax)
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x44a14
movl %eax, %eax
leaq 0x58114(%rip), %rcx # 0xe4ff0
movl (%rcx,%rax,4), %r12d
movq %rbx, %rdi
callq 0x44a14
movl %eax, %eax
leaq 0x594df(%rip), %rcx # 0xe63d0
movzbl (%rax,%rcx), %r15d
movl %r12d, %eax
andl $0x3fff, %eax # imm = 0x3FFF
leaq 0x192b2b(%rip), %rcx # 0x21fa30
leaq (%rax,%rcx), %rsi
decq %rsi
movq %r14, %rdi
callq 0x44af3
movl %r12d, %eax
shrl $0xe, %eax
andl $0xf, %eax
decq %rax
cmpq $0xb, %rax
ja 0x8ceb9
leaq 0x578b3(%rip), %rcx # 0xe47e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x8d048
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9db0c
leaq 0x47764(%rip), %rsi # 0xd46b6
jmp 0x8d089
leaq 0xbaaf7(%rip), %rdx # 0x147a55
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9d65c
jmp 0x8d050
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9d940
jmp 0x8ceb9
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9d26d
jmp 0x8d050
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9d2a1
jmp 0x8d050
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9d5c3
jmp 0x8d050
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9d469
jmp 0x8d050
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9dc96
leaq 0x3e41b(%rip), %rsi # 0xcb3f7
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x8d693
leaq 0xb9593(%rip), %rsi # 0x14658b
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9dc96
jmp 0x8d050
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9d8e2
jmp 0x8ceb9
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9dac1
leaq 0x47684(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x8d096
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8d693
movl %r12d, %eax
shrl $0x12, %eax
andl $0x1f, %eax
decq %rax
cmpq $0xf, %rax
ja 0x8d233
leaq 0x577a3(%rip), %rcx # 0xe4810
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x55b89(%rip), %rsi # 0xe2c06
jmp 0x8d23a
leaq 0x598d9(%rip), %rsi # 0xe6962
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8d693
jmp 0x8ceb9
leaq 0x5b15d(%rip), %rsi # 0xe8207
jmp 0x8d18f
leaq 0x598ae(%rip), %rsi # 0xe6964
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x10c, %esi # imm = 0x10C
jmp 0x8d175
leaq 0x5b131(%rip), %rsi # 0xe8203
jmp 0x8d101
leaq 0x59895(%rip), %rsi # 0xe6970
movq %r14, %rdi
callq 0x44af3
pushq $-0x1
popq %rsi
movq %rbx, %rdi
jmp 0x8d175
leaq 0x5b0c0(%rip), %rsi # 0xe81b5
jmp 0x8d18f
leaq 0xbf5ca(%rip), %rsi # 0x14c6cb
movq %r14, %rdi
callq 0x44af3
leaq 0xc140d(%rip), %rdx # 0x14e51d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9d65c
leaq 0x55ae4(%rip), %rsi # 0xe2c06
movq %r14, %rdi
callq 0x44af3
leaq 0x56e55(%rip), %rdx # 0xe3f86
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9d65c
leaq 0x47573(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d2a1
jmp 0x8ceb9
leaq 0x59805(%rip), %rsi # 0xe696a
movq %r14, %rdi
callq 0x44af3
movq %rbx, %rdi
movl $0x100, %esi # imm = 0x100
callq 0x9dba8
jmp 0x8ceb9
leaq 0x5b02a(%rip), %rsi # 0xe81b0
jmp 0x8d18f
leaq 0x4739a(%rip), %rsi # 0xd4529
movq %r14, %rdi
callq 0x44af3
leaq 0xc137f(%rip), %rdx # 0x14e51d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9d65c
leaq 0x55a56(%rip), %rsi # 0xe2c06
movq %r14, %rdi
callq 0x44af3
leaq 0x56dc7(%rip), %rdx # 0xe3f86
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9d65c
jmp 0x8ceb9
leaq 0xc0b04(%rip), %rsi # 0x14dcda
movq %r14, %rdi
callq 0x44af3
leaq 0xc1338(%rip), %rdx # 0x14e51d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9d65c
leaq 0x55a0f(%rip), %rsi # 0xe2c06
movq %r14, %rdi
callq 0x44af3
leaq 0x56d80(%rip), %rdx # 0xe3f86
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9d65c
leaq 0x4749e(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d26d
jmp 0x8ceb9
leaq 0x4747c(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
movl %r12d, %eax
shrl $0x17, %eax
andl $0xf, %eax
leaq 0x575fe(%rip), %rcx # 0xe4850
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x8d283
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9db0c
jmp 0x8ceb9
pushq $0x2
popq %rsi
movq %rbx, %rdi
jmp 0x8d011
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8d693
jmp 0x8d362
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d38a
jmp 0x8ceb9
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d38a
leaq 0x3e13f(%rip), %rsi # 0xcb3f7
movq %r14, %rdi
callq 0x44af3
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8d693
leaq 0xb92b6(%rip), %rsi # 0x14658b
jmp 0x8d3c1
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d8e2
jmp 0x8d362
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
movq %rax, %r15
shll $0x1b, %r15d
sarl $0x1b, %r15d
js 0x8d4fe
cmpl $0xa, %r15d
jb 0x8d512
leaq 0x595f6(%rip), %rsi # 0xe6915
jmp 0x8d519
pushq $0x1
jmp 0x8d222
pushq $0x1
jmp 0x8d3f6
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d469
jmp 0x8ceb9
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8d693
leaq 0x4735c(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
movl %r12d, %eax
shrl $0x1b, %eax
andl $0xf, %eax
decq %rax
cmpq $0x7, %rax
ja 0x8d4b1
leaq 0x57511(%rip), %rcx # 0xe4890
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x55877(%rip), %r15 # 0xe2c06
movq %r14, %rdi
movq %r15, %rsi
callq 0x44af3
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8d693
movq %r14, %rdi
movq %r15, %rsi
callq 0x44af3
pushq $0x4
jmp 0x8d03c
leaq 0x59f90(%rip), %rsi # 0xe7351
movq %r14, %rdi
callq 0x44af3
jmp 0x8ceb9
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9dac1
jmp 0x8ceb9
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d5c3
jmp 0x8d02b
pushq $0x2
popq %rsi
movq %rbx, %rdi
jmp 0x8cf73
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d5c3
leaq 0x472a2(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x2
jmp 0x8d03c
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d5c3
leaq 0x4727e(%rip), %r15 # 0xd46b6
movq %r14, %rdi
movq %r15, %rsi
callq 0x44af3
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d5c3
movq %r14, %rdi
movq %r15, %rsi
callq 0x44af3
pushq $0x5
jmp 0x8d4a0
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x8d4a4
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d52a
leaq 0x4723a(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d52a
jmp 0x8ceb9
pushq $0x3
jmp 0x8d03c
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9d5c3
jmp 0x8ceb9
movq %r14, %rdi
movq %r15, %r14
shlq $0x20, %r14
orq %r12, %r14
leaq 0x471f1(%rip), %rsi # 0xd46b6
callq 0x44af3
shrq $0x1f, %r14
andl $0xf, %r14d
decq %r14
cmpq $0x7, %r14
ja 0x8d5ed
leaq 0x573ca(%rip), %rax # 0xe48b0
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
jmp 0x8d299
movl %r15d, %edx
negl %edx
cmpl $-0xa, %r15d
ja 0x8d521
leaq 0x4728b(%rip), %rsi # 0xd479b
jmp 0x8d528
leaq 0x3ddfd(%rip), %rsi # 0xcb316
movq %r14, %rdi
movl %r15d, %edx
jmp 0x8d52b
leaq 0x4727c(%rip), %rsi # 0xd47a4
movq %r14, %rdi
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x8ceb9
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x39(%rax), %ecx
shll $0x4, %ecx
movl $0x2, 0x3c(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x39(%rax), %ecx
shll $0x4, %ecx
movl %r15d, 0x40(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x39(%rax)
jmp 0x8ceb9
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x8d644
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
callq 0x9d52a
jmp 0x8d5fc
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
callq 0x9d5c3
jmp 0x8d5fc
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
jmp 0x8d154
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
jmp 0x8d33b
pushq $0x2
jmp 0x8d64f
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
jmp 0x8d229
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
callq 0x8d693
testb $0x8, %r15b
movq (%rsp), %rdi
je 0x8ceb9
leaq 0x470a5(%rip), %rsi # 0xd46b6
callq 0x44af3
movl %r15d, %eax
shrl $0x4, %eax
andl $0x3, %eax
leaq 0x572aa(%rip), %rcx # 0xe48d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
jmp 0x8d48d
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
jmp 0x8d099
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq (%rsp), %rdx
callq 0x9dbfd
jmp 0x8ceb9
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq (%rsp), %r14
movq %r14, %rdx
callq 0x9d5c3
testb $0x40, %r15b
je 0x8ceb9
leaq 0x47032(%rip), %rsi # 0xd46b6
movq %r14, %rdi
callq 0x44af3
pushq $0x4
jmp 0x8d4a0
| /bughoho[P]capstone/arch/PowerPC/PPCInstPrinter.c |
X86_getInstruction | bool X86_getInstruction(csh ud, const uint8_t *code, size_t code_len,
MCInst *instr, uint16_t *size, uint64_t address, void *_info)
{
cs_struct *handle = (cs_struct *)(uintptr_t)ud;
InternalInstruction insn;
struct reader_info info;
int ret;
bool result;
info.code = code;
info.size = code_len;
info.offset = address;
memset(&insn, 0, offsetof(InternalInstruction, reader));
if (instr->flat_insn->detail) {
instr->flat_insn->detail->x86.op_count = 0;
instr->flat_insn->detail->x86.sse_cc = X86_SSE_CC_INVALID;
instr->flat_insn->detail->x86.avx_cc = X86_AVX_CC_INVALID;
instr->flat_insn->detail->x86.avx_sae = false;
instr->flat_insn->detail->x86.avx_rm = X86_AVX_RM_INVALID;
memset(instr->flat_insn->detail->x86.prefix, 0, sizeof(instr->flat_insn->detail->x86.prefix));
memset(instr->flat_insn->detail->x86.opcode, 0, sizeof(instr->flat_insn->detail->x86.opcode));
memset(instr->flat_insn->detail->x86.operands, 0, sizeof(instr->flat_insn->detail->x86.operands));
}
if (handle->mode & CS_MODE_16)
ret = decodeInstruction(&insn,
reader, &info,
address,
MODE_16BIT);
else if (handle->mode & CS_MODE_32)
ret = decodeInstruction(&insn,
reader, &info,
address,
MODE_32BIT);
else
ret = decodeInstruction(&insn,
reader, &info,
address,
MODE_64BIT);
if (ret) {
*size = (uint16_t)(insn.readerCursor - address);
return false;
} else {
*size = (uint16_t)insn.length;
result = (!translateInstruction(instr, &insn)) ? true : false;
if (result) {
instr->imm_size = insn.immSize;
if (handle->detail) {
update_pub_insn(instr->flat_insn, &insn, instr->x86_prefix);
} else {
// still copy all prefixes
instr->x86_prefix[0] = insn.prefix0;
instr->x86_prefix[1] = insn.prefix1;
instr->x86_prefix[2] = insn.prefix2;
instr->x86_prefix[3] = insn.prefix3;
}
}
return result;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r14
movq %rsi, 0x150(%rsp)
movq %rdx, 0x158(%rsp)
movq %r9, 0x160(%rsp)
leaq 0x8(%rsp), %rdi
xorl %ebp, %ebp
movl $0x98, %edx
xorl %esi, %esi
callq 0x430d0
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
testq %rax, %rax
je 0x9e089
xorl %ecx, %ecx
movb %cl, 0x5c(%rax)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
andl $0x0, 0x4c(%rax)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
andl $0x0, 0x50(%rax)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movb %cl, 0x54(%rax)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
andl $0x0, 0x58(%rax)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
andl $0x0, 0x30(%rax)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
andl $0x0, 0x34(%rax)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rdi
addq $0x60, %rdi
movl $0x180, %edx # imm = 0x180
xorl %esi, %esi
callq 0x430d0
movl 0x4(%r14), %eax
movl %eax, %ecx
andl $0x4, %ecx
cmpl $0x1, %ecx
movl $0x0, %r8d
adcl $0x1, %r8d
testb $0x2, %al
cmovnel %ebp, %r8d
leaq 0x9ae(%rip), %rsi # 0x9ea5a
leaq 0x8(%rsp), %rdi
leaq 0x150(%rsp), %rdx
movq %r12, %rcx
callq 0x9ea88
testl %eax, %eax
je 0x9e0e7
movl 0xb0(%rsp), %eax
subl %r12d, %eax
movw %ax, (%r15)
xorl %eax, %eax
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0xd8(%rsp), %eax
movw %ax, (%r15)
cmpq $0x0, 0x100(%rsp)
je 0x9e0d3
movq %r14, (%rsp)
movzwl 0xfc(%rsp), %esi
movq %rbx, %rdi
callq 0x44a0d
cmpb $0x1, 0x95(%rsp)
jne 0x9e14c
movq %rbx, %rdi
callq 0x44a14
movl $0x186f, %esi # imm = 0x186F
cmpl $0x943, %eax # imm = 0x943
je 0x9e144
movq %rbx, %rdi
callq 0x44a14
movl $0x1828, %esi # imm = 0x1828
cmpl $0x93b, %eax # imm = 0x93B
jne 0x9e14c
movq %rbx, %rdi
callq 0x44a0d
movb $0x0, 0x112(%rsp)
xorl %r12d, %r12d
leaq 0x4ba9a(%rip), %r13 # 0xe9bf8
cmpq $0x5, %r12
je 0x9e901
movq 0x148(%rsp), %rax
movb (%rax,%r12,2), %cl
testb %cl, %cl
je 0x9e879
leaq (%rax,%r12,2), %r14
addq $-0xa2, %rax
movzbl %cl, %ecx
decl %ecx
cmpl $0x1e, %ecx
ja 0x9e0d3
movslq (%r13,%rcx,4), %rcx
addq %r13, %rcx
jmpq *%rcx
movzbl 0x1(%r14), %ecx
leaq (%rax,%rcx,2), %r14
movb (%r14), %cl
jmp 0x9e186
movzbl 0x1(%r14), %ecx
xorl %eax, %eax
addl $-0x8, %ecx
cmpl $0x4e, %ecx
ja 0x9e0d5
leaq 0x4baae(%rip), %rdx # 0xe9c74
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x138(%rsp), %ecx
xorl %eax, %eax
cmpl $0x15, %ecx
je 0x9e0d5
cmpl $0x25, %ecx
je 0x9e0d5
addl $-0x31, %ecx
cmpl $0xd3, %ecx
jae 0x9e0d3
movl %ecx, %eax
leaq 0x4bc7a(%rip), %rcx # 0xe9e7c
movl (%rcx,%rax,4), %esi
jmp 0x9e871
movzbl 0x112(%rsp), %eax
leal 0x1(%rax), %ecx
movb %cl, 0x112(%rsp)
movq 0x118(%rsp,%rax,8), %r15
movzbl 0x1(%r14), %ebp
leal -0xc(%rbp), %eax
cmpl $0x4, %eax
jae 0x9e43b
movq %rbx, %rdi
callq 0x44a14
movzbl (%r14), %ecx
cmpl $0x13, %ecx
je 0x9e52e
cmpl $0x12, %ecx
je 0x9e51f
cmpl $0x11, %ecx
jne 0x9e545
movl %eax, %ecx
andl $-0x5, %ecx
addl $0xfffff41d, %ecx # imm = 0xFFFFF41D
cmpl $-0x3, %ecx
ja 0x9e545
leal -0xcf9(%rax), %ecx
cmpl $0x3, %ecx
jb 0x9e545
cmpl $0xfc, %eax
je 0x9e545
cmpl $0xfe, %eax
je 0x9e545
cmpl $0x2d8, %eax # imm = 0x2D8
je 0x9e545
cmpl $0x2da, %eax # imm = 0x2DA
je 0x9e545
cmpl $0x390, %eax # imm = 0x390
je 0x9e545
cmpl $0x395, %eax # imm = 0x395
je 0x9e545
cmpl $0x6df, %eax # imm = 0x6DF
je 0x9e545
cmpl $0x79d, %eax # imm = 0x79D
je 0x9e545
cmpl $0xf1b, %eax # imm = 0xF1B
je 0x9e545
cmpl $0x1181, %eax # imm = 0x1181
je 0x9e545
cmpl $0x1268, %eax # imm = 0x1268
je 0x9e545
movq %r15, %rax
orq $-0x100, %rax
testb %r15b, %r15b
jmp 0x9e541
movl 0x128(%rsp), %esi
movq %rbx, %rdi
callq 0x9ea73
jmp 0x9e879
movl 0x138(%rsp), %eax
cmpq $0x30, %rax
ja 0x9e0d3
leaq 0x4ba7b(%rip), %rcx # 0xe9db0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
pushq $0x1
popq %r15
pushq $0xe
popq %r14
pushq $0x2d
popq %rbp
jmpq *%rax
movl 0x90(%rsp), %eax
cmpq $0x20, %rax
ja 0x9e0d3
leaq 0x4be67(%rip), %rcx # 0xea1c8
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
callq 0x44aa1
movq %rbx, %rdi
callq 0x44a14
cmpl $0xef8, %eax # imm = 0xEF8
sete %cl
cmpl $0xeed, %eax # imm = 0xEED
sete %dl
movl %eax, %esi
andl $-0x11, %esi
cmpl $0xeeb, %esi # imm = 0xEEB
sete %sil
cmpl $0x13eb, %eax # imm = 0x13EB
sete %dil
movl %eax, %r8d
andl $-0x5, %r8d
cmpl $0x13e2, %r8d # imm = 0x13E2
sete %r10b
cmpl $0x13e8, %eax # imm = 0x13E8
sete %r8b
leal -0xeea(%rax), %r9d
cmpl $0x13, %r9d
ja 0x9e3d0
movl $0xfc03f, %r11d # imm = 0xFC03F
btl %r9d, %r11d
jb 0x9e3e1
leal -0x13e2(%rax), %r9d
cmpl $0xc, %r9d
jae 0x9e8f8
xorl %r9d, %r9d
cmpb $0x8, 0xf1(%rsp)
setne %r11b
pushq $0x71
popq %rbp
leal -0xeee(%rax), %r14d
cmpl $0xe, %r14d
jbe 0x9e881
addl $0xffffec1d, %eax # imm = 0xFFFFEC1D
cmpl $0x9, %eax
ja 0x9e41e
movl $0x241, %r14d # imm = 0x241
btl %eax, %r14d
jb 0x9e891
orb %dl, %cl
orb %sil, %cl
orb %dil, %r8b
orb %r10b, %r8b
orb %cl, %r8b
movzbl %r8b, %ebp
shll $0x5, %ebp
addl $0x31, %ebp
jmp 0x9e891
cmpl $0x10, %ebp
je 0x9e5a5
cmpl $0x4f, %ebp
je 0x9e235
cmpl $0x50, %ebp
jne 0x9e5ce
movzbl 0xf2(%rsp), %eax
cmpl $0x4, %eax
je 0x9e58d
cmpl $0x2, %eax
je 0x9e64f
cmpl $0x1, %eax
jne 0x9e660
jmp 0x9e60c
movzbl 0x110(%rsp), %esi
andl $0x7, %esi
addl $0x6a, %esi
jmp 0x9e871
movl 0xc8(%rsp), %ecx
movb 0x14(%rsp), %al
cmpl $0x1, %ecx
je 0x9e629
cmpl $0x2, %ecx
jne 0x9e627
testb %al, %al
pushq $0x2b
popq %rsi
pushq $0x1d
popq %rax
cmovnel %eax, %esi
jmp 0x9e632
movl 0xc8(%rsp), %ecx
movb 0x14(%rsp), %al
cmpl $0x1, %ecx
je 0x9e63f
cmpl $0x2, %ecx
jne 0x9e641
xorb $0x1, %al
movzbl %al, %esi
shll $0x4, %esi
addl $0x17, %esi
jmp 0x9e871
movl 0x108(%rsp), %esi
jmp 0x9e310
movl 0x140(%rsp), %esi
jmp 0x9e310
movl 0x10c(%rsp), %esi
testb $-0x8, %sil
jne 0x9e0d3
addl $0x52, %esi
andl $0x5f, %esi
jmp 0x9e871
movq %r15, %rax
orq $-0x10000, %rax # imm = 0xFFFF0000
testw %r15w, %r15w
jmp 0x9e541
movq %r15, %rax
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
orq %rcx, %rax
testl %r15d, %r15d
cmovsq %rax, %r15
leal -0x3d(%rbp), %eax
cmpl $0x3, %eax
jb 0x9e580
leal -0x3(%rbp), %eax
cmpl $0x2, %eax
jb 0x9e58d
cmpl $0x1, %ebp
je 0x9e60c
cmpl $0x40, %ebp
je 0x9e61a
cmpl $0x41, %ebp
jne 0x9e660
shrl $0x4, %r15d
addl $0xb2, %r15d
jmp 0x9e689
shrl $0x4, %r15d
addl $0x72, %r15d
jmp 0x9e689
movq %r15, %rax
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
orq %rcx, %rax
testl %r15d, %r15d
jmp 0x9e65c
cmpq $0x8, %r15
jb 0x9e660
movq %rbx, %rdi
callq 0x44a14
addl $0xfffffdda, %eax # imm = 0xFFFFFDDA
xorl %esi, %esi
cmpl $0x11, %eax
ja 0x9e602
movl %eax, %eax
leaq 0x4be80(%rip), %rcx # 0xea44c
jmp 0x9e5ff
cmpq $0x20, %r15
jb 0x9e545
cmpb $0x11, %bpl
jne 0x9e545
movq %rbx, %rdi
callq 0x44a14
addl $0xfffff3ff, %eax # imm = 0xFFFFF3FF
xorl %esi, %esi
cmpl $0x28, %eax
ja 0x9e602
movl %eax, %eax
leaq 0x4be95(%rip), %rcx # 0xea494
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
callq 0x44a0d
jmp 0x9e660
movq %r15, %rax
orq $-0x100, %rax
testb %r15b, %r15b
jmp 0x9e65c
shrl $0x4, %r15d
addl $0x92, %r15d
jmp 0x9e689
xorb $0x1, %al
movzbl %al, %esi
shll $0x4, %esi
addl $0x1d, %esi
movq %rbx, %rdi
callq 0x44aa1
jmp 0x9e862
xorb $0x1, %al
movzbl %al, %eax
leal (%rax,%rax,8), %esi
addl $0xe, %esi
jmp 0x9e871
movq %r15, %rax
orq $-0x10000, %rax # imm = 0xFFFF0000
testw %r15w, %r15w
cmovsq %rax, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x44ace
addb $-0x2d, %bpl
cmpb $0x3, %bpl
ja 0x9e879
movl 0x74(%rsp), %eax
leaq 0x4b7f0(%rip), %rcx # 0xe9e74
movzbl (%rax,%rcx), %r15d
movq %rbx, %rdi
movl %r15d, %esi
jmp 0x9e874
pushq $0x64
jmp 0x9e832
pushq $0x25
jmp 0x9e832
pushq $0x68
jmp 0x9e832
pushq $0x26
jmp 0x9e832
pushq $0x28
jmp 0x9e832
movq %rbx, %rdi
movl $0xdb, %esi
jmp 0x9e836
pushq $0x23
jmp 0x9e832
movq %rbx, %rdi
movl $0xe9, %esi
jmp 0x9e836
pushq $0x65
jmp 0x9e832
movq %rbx, %rdi
movl $0xe1, %esi
jmp 0x9e836
movq %rbx, %rdi
movl $0xe7, %esi
jmp 0x9e836
pushq $0x69
jmp 0x9e832
movq %rbx, %rdi
movl $0xe4, %esi
jmp 0x9e836
pushq $0x27
jmp 0x9e832
pushq $0x6
jmp 0x9e742
pushq $0x17
jmp 0x9e832
pushq $0x1d
jmp 0x9e832
movq %rbx, %rdi
movl $0xe5, %esi
jmp 0x9e836
movq %rbx, %rdi
movl $0xe2, %esi
jmp 0x9e836
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x44aa1
movl %r14d, %ebp
jmp 0x9e83d
movq %rbx, %rdi
movl $0xe8, %esi
jmp 0x9e836
pushq $0x6
jmp 0x9e7a8
movq %rbx, %rdi
movl $0xdf, %esi
jmp 0x9e836
pushq $0x6
jmp 0x9e832
cmpl $0x0, 0x13c(%rsp)
je 0x9e0d3
cmpl $0x2, 0xc8(%rsp)
jne 0x9e8e5
cmpb $0x67, 0xc(%rsp)
jne 0x9e8f1
pushq $0x1a
jmp 0x9e832
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x44aa1
jmp 0x9e83d
pushq $0x62
jmp 0x9e832
pushq $0x13
jmp 0x9e832
pushq $0x15
jmp 0x9e832
pushq $0x2d
jmp 0x9e832
movq %rbx, %rdi
movl $0xe6, %esi
jmp 0x9e836
movq %rbx, %rdi
movl $0xde, %esi
jmp 0x9e836
movq %rbx, %rdi
movl $0xe0, %esi
jmp 0x9e836
pushq $0xe
jmp 0x9e832
pushq $0x16
jmp 0x9e832
movq %rbx, %rdi
movl $0xe3, %esi
jmp 0x9e836
pushq $0x8
jmp 0x9e832
pushq $0x66
jmp 0x9e832
pushq $0x2b
jmp 0x9e832
pushq $0x63
jmp 0x9e832
pushq $0x14
jmp 0x9e832
pushq $0x18
jmp 0x9e832
movq %rbx, %rdi
movl $0xdc, %esi
jmp 0x9e836
movq %rbx, %rdi
movl $0xdd, %esi
jmp 0x9e836
pushq $0x24
jmp 0x9e832
movq %rbx, %rdi
movl $0xda, %esi
jmp 0x9e836
pushq $0x67
popq %rsi
movq %rbx, %rdi
callq 0x44aa1
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x44ace
movq %rbx, %rdi
movl %ebp, %esi
callq 0x44aa1
movslq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x44ace
movl 0x74(%rsp), %eax
leaq 0x4b607(%rip), %rcx # 0xe9e74
movzbl (%rax,%rcx), %esi
movq %rbx, %rdi
callq 0x44aa1
incq %r12
jmp 0x9e15e
movl $0x4801, %r15d # imm = 0x4801
btl %r14d, %r15d
jae 0x9e404
movl 0x88(%rsp), %eax
movb %r11b, %r9b
shll $0x4, %r9d
leal (%r9,%rax), %ecx
addl $-0x21, %ecx
testl %eax, %eax
pushq $0x4
popq %rax
cmovnel %ecx, %eax
addl %ebp, %eax
movl %eax, 0x88(%rsp)
testl %eax, %eax
je 0x9e8d5
addl $-0x11, %eax
cmpl $0x7f, %eax
ja 0x9e0d3
movl %eax, %eax
leaq 0x4b97c(%rip), %rcx # 0xea24c
movl (%rcx,%rax,4), %ebp
jmp 0x9e8d7
xorl %ebp, %ebp
movzbl 0x8c(%rsp), %r15d
jmp 0x9e83d
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x9e7ac
pushq $0x29
jmp 0x9e832
movl 0x88(%rsp), %eax
jmp 0x9e8b7
movb 0xf4(%rsp), %al
movb %al, 0x32d(%rbx)
movq (%rsp), %rax
cmpl $0x0, 0x68(%rax)
je 0x9e9d7
movq 0x310(%rbx), %r14
movl 0x9(%rsp), %eax
movl %eax, 0x329(%rbx)
cmpl $0x0, 0xe0(%rsp)
je 0x9e9e8
movq 0xe8(%r14), %rax
movl 0x96(%rsp), %ecx
movl %ecx, 0x34(%rax)
movb 0x70(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x38(%rcx)
movb 0xf1(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x39(%rcx)
movb 0x79(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x3a(%rcx)
movb 0x7b(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x3b(%rcx)
movl 0x80(%rsp), %eax
movq 0xe8(%r14), %rcx
movl %eax, 0x3c(%rcx)
movl 0x88(%rsp), %edi
callq 0xa31be
movq 0xe8(%r14), %rcx
movl %eax, 0x40(%rcx)
movb 0x8c(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x44(%rcx)
movl 0x90(%rsp), %edi
callq 0xa31b0
movq 0xe8(%r14), %rcx
movl %eax, 0x48(%rcx)
jmp 0x9e9e1
movl 0x9(%rsp), %eax
movl %eax, 0x329(%rbx)
movb $0x1, %al
jmp 0x9e0d5
movb 0x84(%rsp), %al
testb %al, %al
je 0x9ea2e
cmpb $0x0, 0x85(%rsp)
movq 0xe8(%r14), %rcx
movb %al, 0x34(%rcx)
je 0x9ea44
movb 0x85(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x35(%rcx)
movb 0xf7(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x36(%rcx)
jmp 0x9e94c
movb 0xf7(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x34(%rcx)
jmp 0x9e94c
movb 0xf7(%rsp), %al
movq 0xe8(%r14), %rcx
movb %al, 0x35(%rcx)
jmp 0x9e94c
| /bughoho[P]capstone/arch/X86/X86Disassembler.c |
translateRegister | static void translateRegister(MCInst *mcInst, Reg reg)
{
#define ENTRY(x) X86_##x,
uint8_t llvmRegnums[] = {
ALL_REGS
0
};
#undef ENTRY
uint8_t llvmRegnum = llvmRegnums[reg];
MCOperand_CreateReg0(mcInst, llvmRegnum);
} | movl %esi, %eax
leaq 0x4be54(%rip), %rcx # 0xea8d0
movzbl (%rax,%rcx), %esi
jmp 0x44aa1
nopl (%rax)
| /bughoho[P]capstone/arch/X86/X86Disassembler.c |
fixupReg | static int fixupReg(struct InternalInstruction *insn,
const struct OperandSpecifier *op)
{
uint8_t valid;
// dbgprintf(insn, "fixupReg()");
switch ((OperandEncoding)op->encoding) {
default:
//debug("Expected a REG or R/M encoding in fixupReg");
return -1;
case ENCODING_VVVV:
insn->vvvv = (Reg)fixupRegValue(insn,
(OperandType)op->type,
insn->vvvv,
&valid);
if (!valid)
return -1;
break;
case ENCODING_REG:
insn->reg = (Reg)fixupRegValue(insn,
(OperandType)op->type,
(uint8_t)(insn->reg - insn->regBase),
&valid);
if (!valid)
return -1;
break;
CASE_ENCODING_RM:
if (insn->eaBase >= insn->eaRegBase) {
insn->eaBase = (EABase)fixupRMValue(insn,
(OperandType)op->type,
(uint8_t)(insn->eaBase - insn->eaRegBase),
&valid);
if (!valid)
return -1;
}
break;
}
return 0;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzbl (%rsi), %eax
pushq $-0x1
popq %rbp
leal -0x2(%rax), %ecx
cmpl $0x7, %ecx
jae 0xa0633
movl 0x130(%rbx), %ecx
movl %ecx, %eax
subl 0x128(%rbx), %eax
jb 0xa0777
movzbl 0x1(%rsi), %edx
leal -0x39(%rdx), %esi
cmpl $0x15, %esi
ja 0xa06a2
leaq 0x4a528(%rip), %rdx # 0xeab48
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
addl $0xdd, %eax
jmp 0xa076c
cmpl $0x1, %eax
je 0xa0667
cmpl $0x9, %eax
jne 0xa0779
movzbl 0x1(%rsi), %esi
movzbl 0x100(%rbx), %edx
leaq 0xf(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0xa09eb
movzbl %al, %eax
movl %eax, 0x100(%rbx)
jmp 0xa0693
movzbl 0x1(%rsi), %esi
movl 0x138(%rbx), %eax
subl 0x12c(%rbx), %eax
movzbl %al, %edx
leaq 0xf(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0xa09eb
movzbl %al, %eax
movl %eax, 0x138(%rbx)
cmpb $0x0, (%r14)
jne 0xa0777
jmp 0xa0779
addl $-0x8, %edx
cmpl $0x3, %edx
ja 0xa06dd
leaq 0x4a487(%rip), %rcx # 0xeab38
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movb $0x1, (%rbx)
movl %eax, %ecx
andb $-0x4, %cl
cmpb $0x4, %cl
jne 0xa0769
cmpb $0x0, 0x68(%rbx)
je 0xa0769
addl $0x3d, %eax
jmp 0xa076c
andl $0x0, 0x130(%rbx)
jmp 0xa0779
movl %eax, %ecx
addl $0xeb, %ecx
movzbl %cl, %ecx
movl %ecx, 0x130(%rbx)
cmpb $0x7, %al
jbe 0xa0777
jmp 0xa0779
andl $0x7, %eax
addl $0xe5, %eax
jmp 0xa076c
movb $0x20, (%rbx)
addl $0x9d, %eax
jmp 0xa076c
movb $0x10, %cl
jmp 0xa0730
movb $0x2, %cl
jmp 0xa0730
movb $0x8, %cl
jmp 0xa073d
movb $0x4, %cl
jmp 0xa0730
movb $0x4, (%rbx)
addl $0xf3, %eax
jmp 0xa076c
movb $0x8, %cl
movb %cl, (%rbx)
addl $0x7d, %eax
jmp 0xa076c
movb $0x4, %cl
jmp 0xa073d
movb $0x2, %cl
movb %cl, (%rbx)
andl $0x7, %eax
addl $0x75, %eax
jmp 0xa076c
movb $0x40, (%rbx)
addl $0xbd, %eax
jmp 0xa076c
movb $0x4, (%rbx)
addl $0x55, %eax
jmp 0xa076c
movb $0x8, (%rbx)
addl $0x65, %eax
jmp 0xa076c
movb $0x2, (%rbx)
addl $0x45, %eax
jmp 0xa076c
addl $0x31, %eax
movl %eax, %ecx
movzbl %cl, %eax
movl %eax, 0x130(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /bughoho[P]capstone/arch/X86/X86DisassemblerDecoder.c |
printAVXCC | static void printAVXCC(MCInst *MI, unsigned Op, SStream *O)
{
int64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0x1f;
switch (Imm) {
default: break;//printf("Invalid avxcc argument!\n"); break;
case 0: SStream_concat0(O, "eq"); op_addAvxCC(MI, X86_AVX_CC_EQ); break;
case 1: SStream_concat0(O, "lt"); op_addAvxCC(MI, X86_AVX_CC_LT); break;
case 2: SStream_concat0(O, "le"); op_addAvxCC(MI, X86_AVX_CC_LE); break;
case 3: SStream_concat0(O, "unord"); op_addAvxCC(MI, X86_AVX_CC_UNORD); break;
case 4: SStream_concat0(O, "neq"); op_addAvxCC(MI, X86_AVX_CC_NEQ); break;
case 5: SStream_concat0(O, "nlt"); op_addAvxCC(MI, X86_AVX_CC_NLT); break;
case 6: SStream_concat0(O, "nle"); op_addAvxCC(MI, X86_AVX_CC_NLE); break;
case 7: SStream_concat0(O, "ord"); op_addAvxCC(MI, X86_AVX_CC_ORD); break;
case 8: SStream_concat0(O, "eq_uq"); op_addAvxCC(MI, X86_AVX_CC_EQ_UQ); break;
case 9: SStream_concat0(O, "nge"); op_addAvxCC(MI, X86_AVX_CC_NGE); break;
case 0xa: SStream_concat0(O, "ngt"); op_addAvxCC(MI, X86_AVX_CC_NGT); break;
case 0xb: SStream_concat0(O, "false"); op_addAvxCC(MI, X86_AVX_CC_FALSE); break;
case 0xc: SStream_concat0(O, "neq_oq"); op_addAvxCC(MI, X86_AVX_CC_NEQ_OQ); break;
case 0xd: SStream_concat0(O, "ge"); op_addAvxCC(MI, X86_AVX_CC_GE); break;
case 0xe: SStream_concat0(O, "gt"); op_addAvxCC(MI, X86_AVX_CC_GT); break;
case 0xf: SStream_concat0(O, "true"); op_addAvxCC(MI, X86_AVX_CC_TRUE); break;
case 0x10: SStream_concat0(O, "eq_os"); op_addAvxCC(MI, X86_AVX_CC_EQ_OS); break;
case 0x11: SStream_concat0(O, "lt_oq"); op_addAvxCC(MI, X86_AVX_CC_LT_OQ); break;
case 0x12: SStream_concat0(O, "le_oq"); op_addAvxCC(MI, X86_AVX_CC_LE_OQ); break;
case 0x13: SStream_concat0(O, "unord_s"); op_addAvxCC(MI, X86_AVX_CC_UNORD_S); break;
case 0x14: SStream_concat0(O, "neq_us"); op_addAvxCC(MI, X86_AVX_CC_NEQ_US); break;
case 0x15: SStream_concat0(O, "nlt_uq"); op_addAvxCC(MI, X86_AVX_CC_NLT_UQ); break;
case 0x16: SStream_concat0(O, "nle_uq"); op_addAvxCC(MI, X86_AVX_CC_NLE_UQ); break;
case 0x17: SStream_concat0(O, "ord_s"); op_addAvxCC(MI, X86_AVX_CC_ORD_S); break;
case 0x18: SStream_concat0(O, "eq_us"); op_addAvxCC(MI, X86_AVX_CC_EQ_US); break;
case 0x19: SStream_concat0(O, "nge_uq"); op_addAvxCC(MI, X86_AVX_CC_NGE_UQ); break;
case 0x1a: SStream_concat0(O, "ngt_uq"); op_addAvxCC(MI, X86_AVX_CC_NGT_UQ); break;
case 0x1b: SStream_concat0(O, "false_os"); op_addAvxCC(MI, X86_AVX_CC_FALSE_OS); break;
case 0x1c: SStream_concat0(O, "neq_os"); op_addAvxCC(MI, X86_AVX_CC_NEQ_OS); break;
case 0x1d: SStream_concat0(O, "ge_oq"); op_addAvxCC(MI, X86_AVX_CC_GE_OQ); break;
case 0x1e: SStream_concat0(O, "gt_oq"); op_addAvxCC(MI, X86_AVX_CC_GT_OQ); break;
case 0x1f: SStream_concat0(O, "true_us"); op_addAvxCC(MI, X86_AVX_CC_TRUE_US); break;
}
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x44a1b
movq %rax, %rdi
callq 0x44a76
andl $0x1f, %eax
leaq 0xa39ec(%rip), %rcx # 0x1464e0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leal 0x1(%rax), %ebp
movq %rbx, %rdi
callq 0x44af3
movq %r14, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xa3bb3
| /bughoho[P]capstone/arch/X86/X86IntelInstPrinter.c |
printOperand | static void printOperand(MCInst *MI, int opNum, SStream *O)
{
int Imm;
unsigned reg;
MCOperand *MO = MCInst_getOperand(MI, opNum);
if (MCOperand_isReg(MO)) {
reg = MCOperand_getReg(MO);
printRegName(O, reg);
reg = Sparc_map_register(reg);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
if (MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].mem.base)
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].mem.index = reg;
else
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].mem.base = reg;
} else {
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].type = SPARC_OP_REG;
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].reg = reg;
MI->flat_insn->detail->sparc.op_count++;
}
}
return;
}
if (MCOperand_isImm(MO)) {
Imm = (int)MCOperand_getImm(MO);
// Conditional branches displacements needs to be signextended to be
// able to jump backwards.
//
// Displacements are measured as the number of instructions forward or
// backward, so they need to be multiplied by 4
switch (MI->Opcode) {
case SP_CALL:
Imm = SignExtend32(Imm, 30);
Imm += (uint32_t)MI->address;
break;
// Branch on integer condition with prediction (BPcc)
// Branch on floating point condition with prediction (FBPfcc)
case SP_BPICC:
case SP_BPICCA:
case SP_BPICCANT:
case SP_BPICCNT:
case SP_BPXCC:
case SP_BPXCCA:
case SP_BPXCCANT:
case SP_BPXCCNT:
case SP_BPFCC:
case SP_BPFCCA:
case SP_BPFCCANT:
case SP_BPFCCNT:
Imm = SignExtend32(Imm, 19);
Imm = (uint32_t)MI->address + Imm * 4;
break;
// Branch on integer condition (Bicc)
// Branch on floating point condition (FBfcc)
case SP_BA:
case SP_BCOND:
case SP_BCONDA:
case SP_FBCOND:
case SP_FBCONDA:
Imm = SignExtend32(Imm, 22);
Imm = (uint32_t)MI->address + Imm * 4;
break;
// Branch on integer register with prediction (BPr)
case SP_BPGEZapn:
case SP_BPGEZapt:
case SP_BPGEZnapn:
case SP_BPGEZnapt:
case SP_BPGZapn:
case SP_BPGZapt:
case SP_BPGZnapn:
case SP_BPGZnapt:
case SP_BPLEZapn:
case SP_BPLEZapt:
case SP_BPLEZnapn:
case SP_BPLEZnapt:
case SP_BPLZapn:
case SP_BPLZapt:
case SP_BPLZnapn:
case SP_BPLZnapt:
case SP_BPNZapn:
case SP_BPNZapt:
case SP_BPNZnapn:
case SP_BPNZnapt:
case SP_BPZapn:
case SP_BPZapt:
case SP_BPZnapn:
case SP_BPZnapt:
Imm = SignExtend32(Imm, 16);
Imm = (uint32_t)MI->address + Imm * 4;
break;
}
if (Imm >= 0) {
if (Imm > HEX_THRESHOLD)
SStream_concat(O, "0x%x", Imm);
else
SStream_concat(O, "%u", Imm);
} else {
if (Imm < -HEX_THRESHOLD)
SStream_concat(O, "-0x%x", -Imm);
else
SStream_concat(O, "-%u", -Imm);
}
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].mem.disp = Imm;
} else {
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].type = SPARC_OP_IMM;
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].imm = Imm;
MI->flat_insn->detail->sparc.op_count++;
}
}
}
return;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x44a1b
movq %rax, %r15
movq %rax, %rdi
callq 0x44a56
testb %al, %al
je 0xb9fdf
movq %r15, %rdi
callq 0x44a6e
movl %eax, %r15d
leaq 0x91d51(%rip), %rsi # 0x14bcbb
movq %r14, %rdi
callq 0x44af3
leal -0x1(%r15), %eax
leaq 0x8fac3(%rip), %rcx # 0x149a40
movl (%rcx,%rax,4), %eax
leaq 0x1c3259(%rip), %rsi # 0x27d1e0
addq %rax, %rsi
movq %r14, %rdi
callq 0x44af3
movl %r15d, %edi
callq 0xba4f6
movq 0x320(%rbx), %rdx
cmpl $0x0, 0x68(%rdx)
je 0xba11c
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x38(%rcx), %esi
addq $0x3c, %rcx
cmpb $0x1, 0x70(%rdx)
jne 0xba01f
imulq $0xc, %rsi, %rdx
addq %rdx, %rcx
addq $0x4, %rcx
cmpb $0x0, (%rcx)
je 0xba053
movb %al, 0x1(%rcx)
jmp 0xba11c
movq %r15, %rdi
callq 0x44a5e
testb %al, %al
je 0xba11c
movq %r15, %rdi
callq 0x44a76
movq %rax, %r15
movl 0x8(%rbx), %eax
addl $-0x47, %eax
cmpl $0x4f, %eax
ja 0xba069
leaq 0x8f8e8(%rip), %rcx # 0x1498f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movswl %r15w, %r15d
shll $0x2, %r15d
jmp 0xba062
imulq $0xc, %rsi, %rdx
movl $0x1, (%rcx,%rdx)
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x38(%rcx), %edx
imulq $0xc, %rdx, %rdx
movl %eax, 0x40(%rcx,%rdx)
jmp 0xba10b
shll $0xd, %r15d
sarl $0xb, %r15d
jmp 0xba062
movb %al, (%rcx)
jmp 0xba11c
shll $0xa, %r15d
sarl $0x8, %r15d
addl 0x318(%rbx), %r15d
testl %r15d, %r15d
js 0xba07d
cmpl $0xa, %r15d
jb 0xba091
leaq 0x2c89a(%rip), %rsi # 0xe6915
jmp 0xba098
movl %r15d, %edx
negl %edx
cmpl $-0xa, %r15d
ja 0xba0a0
leaq 0x1a70c(%rip), %rsi # 0xd479b
jmp 0xba0a7
leaq 0x1127e(%rip), %rsi # 0xcb316
movq %r14, %rdi
movl %r15d, %edx
jmp 0xba0aa
leaq 0x1a6fd(%rip), %rsi # 0xd47a4
movq %r14, %rdi
xorl %eax, %eax
callq 0x44b3a
movq 0x320(%rbx), %rcx
cmpl $0x0, 0x68(%rcx)
je 0xba11c
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x38(%rax), %edx
addq $0x3c, %rax
cmpb $0x1, 0x70(%rcx)
jne 0xba0e5
imulq $0xc, %rdx, %rcx
movl %r15d, 0x8(%rax,%rcx)
jmp 0xba11c
imulq $0xc, %rdx, %rcx
movl $0x2, (%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x38(%rax), %ecx
imulq $0xc, %rcx, %rcx
movl %r15d, 0x40(%rax,%rcx)
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
incb 0x38(%rax)
popq %rbx
popq %r14
popq %r15
retq
shll $0x2, %r15d
sarl $0x2, %r15d
jmp 0xba062
| /bughoho[P]capstone/arch/Sparc/SparcInstPrinter.c |
SystemZ_group_name | const char *SystemZ_group_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
// verify group id
if (id >= SYSZ_GRP_ENDING || (id > SYSZ_GRP_JUMP && id < SYSZ_GRP_DISTINCTOPS))
return NULL;
// NOTE: when new generic groups are added, 2 must be changed accordingly
if (id >= 128)
return group_name_maps[id - 128 + 2].name;
else
return group_name_maps[id].name;
#else
return NULL;
#endif
} | cmpl $0x85, %esi
setae %al
leal -0x2(%rsi), %ecx
cmpl $0x7e, %ecx
setb %cl
orb %al, %cl
je 0xbd9d0
xorl %eax, %eax
retq
leal -0x7e(%rsi), %eax
cmpl $0x7f, %esi
cmovbel %esi, %eax
shlq $0x4, %rax
leaq 0xdfccc(%rip), %rcx # 0x19d6b0
movq 0x8(%rax,%rcx), %rax
retq
| /bughoho[P]capstone/arch/SystemZ/SystemZMapping.c |
SystemZ_map_register | sysz_reg SystemZ_map_register(unsigned int r)
{
static unsigned int map[] = { 0,
SYSZ_REG_CC, SYSZ_REG_F0, SYSZ_REG_F1, SYSZ_REG_F2, SYSZ_REG_F3,
SYSZ_REG_F4, SYSZ_REG_F5, SYSZ_REG_F6, SYSZ_REG_F7, SYSZ_REG_F8,
SYSZ_REG_F9, SYSZ_REG_F10, SYSZ_REG_F11, SYSZ_REG_F12, SYSZ_REG_F13,
SYSZ_REG_F14, SYSZ_REG_F15, SYSZ_REG_F0, SYSZ_REG_F1, SYSZ_REG_F4,
SYSZ_REG_F5, SYSZ_REG_F8, SYSZ_REG_F9, SYSZ_REG_F12, SYSZ_REG_F13,
SYSZ_REG_F0, SYSZ_REG_F1, SYSZ_REG_F2, SYSZ_REG_F3, SYSZ_REG_F4,
SYSZ_REG_F5, SYSZ_REG_F6, SYSZ_REG_F7, SYSZ_REG_F8, SYSZ_REG_F9,
SYSZ_REG_F10, SYSZ_REG_F11, SYSZ_REG_F12, SYSZ_REG_F13, SYSZ_REG_F14,
SYSZ_REG_F15, SYSZ_REG_0, SYSZ_REG_1, SYSZ_REG_2, SYSZ_REG_3,
SYSZ_REG_4, SYSZ_REG_5, SYSZ_REG_6, SYSZ_REG_7, SYSZ_REG_8,
SYSZ_REG_9, SYSZ_REG_10, SYSZ_REG_11, SYSZ_REG_12, SYSZ_REG_13,
SYSZ_REG_14, SYSZ_REG_15, SYSZ_REG_0, SYSZ_REG_1, SYSZ_REG_2,
SYSZ_REG_3, SYSZ_REG_4, SYSZ_REG_5, SYSZ_REG_6, SYSZ_REG_7,
SYSZ_REG_8, SYSZ_REG_9, SYSZ_REG_10, SYSZ_REG_11, SYSZ_REG_12,
SYSZ_REG_13, SYSZ_REG_14, SYSZ_REG_15, SYSZ_REG_0, SYSZ_REG_1,
SYSZ_REG_2, SYSZ_REG_3, SYSZ_REG_4, SYSZ_REG_5, SYSZ_REG_6,
SYSZ_REG_7, SYSZ_REG_8, SYSZ_REG_9, SYSZ_REG_10, SYSZ_REG_11,
SYSZ_REG_12, SYSZ_REG_13, SYSZ_REG_14, SYSZ_REG_15, SYSZ_REG_0,
SYSZ_REG_2, SYSZ_REG_4, SYSZ_REG_6, SYSZ_REG_8, SYSZ_REG_10,
SYSZ_REG_12, SYSZ_REG_14,
};
if (r < ARR_SIZE(map))
return map[r];
// cannot find this register
return 0;
} | xorl %eax, %eax
cmpl $0x61, %edi
ja 0xbd9fd
movl %edi, %eax
leaq 0x90156(%rip), %rcx # 0x14db50
movl (%rcx,%rax,4), %eax
retq
nop
| /bughoho[P]capstone/arch/SystemZ/SystemZMapping.c |
SystemZMC_getFirstReg | unsigned SystemZMC_getFirstReg(unsigned Reg)
{
static unsigned Map[SystemZ_NUM_TARGET_REGS];
static int Initialized = 0;
unsigned I;
if (!Initialized) {
Initialized = 1;
for (I = 0; I < 16; ++I) {
Map[SystemZMC_GR32Regs[I]] = I;
Map[SystemZMC_GRH32Regs[I]] = I;
Map[SystemZMC_GR64Regs[I]] = I;
Map[SystemZMC_GR128Regs[I]] = I;
Map[SystemZMC_FP32Regs[I]] = I;
Map[SystemZMC_FP64Regs[I]] = I;
Map[SystemZMC_FP128Regs[I]] = I;
}
}
// assert(Reg < SystemZ_NUM_TARGET_REGS);
return Map[Reg];
} | cmpb $0x0, 0x1d63d1(%rip) # 0x293dd8
jne 0xbdaa2
pushq %r15
pushq %r14
pushq %rbx
movb $0x1, 0x1d63bf(%rip) # 0x293dd8
xorl %eax, %eax
leaq 0x90f6e(%rip), %rcx # 0x14e990
leaq 0x1d6227(%rip), %rdx # 0x293c50
leaq 0x90fa0(%rip), %rsi # 0x14e9d0
leaq 0x90fd9(%rip), %r8 # 0x14ea10
leaq 0x91012(%rip), %r9 # 0x14ea50
leaq 0x9104b(%rip), %r10 # 0x14ea90
leaq 0x91084(%rip), %r11 # 0x14ead0
leaq 0x910bd(%rip), %rbx # 0x14eb10
xorl %r14d, %r14d
cmpq $0x10, %r14
je 0xbda9d
movl (%rax,%rcx), %r15d
movl %r14d, (%rdx,%r15,4)
movl (%rax,%rsi), %r15d
movl %r14d, (%rdx,%r15,4)
movl (%rax,%r8), %r15d
movl %r14d, (%rdx,%r15,4)
movl (%rax,%r9), %r15d
movl %r14d, (%rdx,%r15,4)
movl (%rax,%r10), %r15d
movl %r14d, (%rdx,%r15,4)
movl (%rax,%r11), %r15d
movl %r14d, (%rdx,%r15,4)
movl (%rax,%rbx), %r15d
movl %r14d, (%rdx,%r15,4)
incq %r14
addq $0x4, %rax
jmp 0xbda56
popq %rbx
popq %r14
popq %r15
movl %edi, %eax
leaq 0x1d61a5(%rip), %rcx # 0x293c50
movl (%rcx,%rax,4), %eax
retq
nop
| /bughoho[P]capstone/arch/SystemZ/SystemZMCTargetDesc.c |
XCore_init | void XCore_init(MCRegisterInfo *MRI)
{
/*
InitMCRegisterInfo(XCoreRegDesc, 17, RA, PC,
XCoreMCRegisterClasses, 2,
XCoreRegUnitRoots,
16,
XCoreRegDiffLists,
XCoreRegStrings,
XCoreSubRegIdxLists,
1,
XCoreSubRegIdxRanges,
XCoreRegEncodingTable);
*/
MCRegisterInfo_InitMCRegisterInfo(MRI, XCoreRegDesc, 17,
0, 0,
XCoreMCRegisterClasses, 2,
0, 0,
XCoreRegDiffLists,
0,
XCoreSubRegIdxLists, 1,
0);
} | subq $0x48, %rsp
andq $0x0, 0x38(%rsp)
leaq 0x1d58f7(%rip), %rax # 0x293dda
andq $0x0, 0x20(%rsp)
movq %rax, 0x28(%rsp)
andl $0x0, 0x10(%rsp)
leaq 0x1d1cf6(%rip), %rax # 0x2901f0
andq $0x0, 0x8(%rsp)
movq %rax, 0x18(%rsp)
movl $0x1, 0x30(%rsp)
movl $0x2, (%rsp)
leaq 0x1d1b25(%rip), %rsi # 0x290040
leaq 0x1d1c7e(%rip), %r9 # 0x2901a0
pushq $0x11
popq %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x47a68
addq $0x48, %rsp
retq
| /bughoho[P]capstone/arch/XCore/XCoreDisassembler.c |
decodeULEB128 | static inline uint64_t decodeULEB128(const uint8_t *p, unsigned *n)
{
const uint8_t *orig_p = p;
uint64_t Value = 0;
unsigned Shift = 0;
do {
Value += (*p & 0x7f) << Shift;
Shift += 7;
} while (*p++ >= 128);
if (n)
*n = (unsigned)(p - orig_p);
return Value;
} | xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movzbl (%rdi,%rdx), %r8d
movl %r8d, %r9d
andl $0x7f, %r9d
shll %cl, %r9d
movslq %r9d, %r9
addq %r9, %rax
addl $0x7, %ecx
incq %rdx
testb %r8b, %r8b
js 0xbe53a
testq %rsi, %rsi
je 0xbe561
movl %edx, (%rsi)
retq
| /bughoho[P]capstone/arch/XCore/../../LEB128.h |
OpenMD::Mesh::getHydroProp(double) | virtual HydroProp* getHydroProp(RealType viscosity) {
HydroProp* props = new HydroProp();
props->setCenterOfResistance(V3Zero);
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"Mesh was asked to return an analytic HydroProps.\n");
painCave.severity = OPENMD_ERROR;
painCave.isFatal = 1;
simError();
return props;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x280, %edi # imm = 0x280
callq 0x134d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x6b228
leaq 0x103dd3(%rip), %rsi # 0x11ec28
movq %rsp, %r14
movq %r14, %rdi
callq 0x1b032
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1afda
leaq 0x104232(%rip), %rax # 0x11f0a4
movups 0xaa394(%rip), %xmm0 # 0xc520d
movups %xmm0, 0x20(%rax)
movups 0xaa379(%rip), %xmm0 # 0xc51fd
movups %xmm0, 0x10(%rax)
movups 0xaa35e(%rip), %xmm0 # 0xc51ed
movups %xmm0, (%rax)
movw $0xa, 0x30(%rax)
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x7d0(%rax)
callq 0x2beaa
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x280, %esi # imm = 0x280
movq %rbx, %rdi
callq 0x134e0
movq %r14, %rdi
callq 0x13960
nop
| /OpenMD[P]OpenMD/src/hydrodynamics/Mesh.hpp |
rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::GenericDocument(rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>*, unsigned long, rapidjson::CrtAllocator*) | GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; } | pushq %r15
pushq %r14
pushq %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rdx, 0x48(%rdi)
andl $0x0, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
testq %rsi, %rsi
jne 0x1b789
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x134d0
movq %rax, %r14
movl $0x10000, %esi # imm = 0x10000
movq %rax, %rdi
xorl %edx, %edx
callq 0x1b7b6
movq %r14, 0x10(%rbx)
movq %r14, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x134e0
jmp 0x1b7a2
movq %rax, %r15
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x1b814
movq %r15, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/build_O2/_deps/rapidjson-src/include/rapidjson/document.h |
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::MemoryPoolAllocator(unsigned long, rapidjson::CrtAllocator*) | explicit
MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
chunk_capacity_(chunkSize),
baseAllocator_(baseAllocator ? baseAllocator : RAPIDJSON_NEW(BaseAllocator)()),
shared_(static_cast<SharedData*>(baseAllocator_ ? baseAllocator_->Malloc(SIZEOF_SHARED_DATA + SIZEOF_CHUNK_HEADER) : 0))
{
RAPIDJSON_ASSERT(baseAllocator_ != 0);
RAPIDJSON_ASSERT(shared_ != 0);
if (baseAllocator) {
shared_->ownBaseAllocator = 0;
}
else {
shared_->ownBaseAllocator = baseAllocator_;
}
shared_->chunkHead = GetChunkHead(shared_);
shared_->chunkHead->capacity = 0;
shared_->chunkHead->size = 0;
shared_->chunkHead->next = 0;
shared_->ownBuffer = true;
shared_->refcount = 1;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
testq %rdx, %rdx
je 0x1b7ca
xorl %r14d, %r14d
jmp 0x1b7d8
pushq $0x1
popq %rdi
callq 0x134d0
movq %rax, %r14
movq %rax, %rdx
movq %rdx, 0x8(%rbx)
pushq $0x38
popq %rdi
callq 0x136b0
movq %rax, 0x10(%rbx)
movq %r14, 0x8(%rax)
leaq 0x20(%rax), %rcx
movq %rcx, (%rax)
andq $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movb $0x1, 0x18(%rax)
movq $0x1, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /OpenMD[P]OpenMD/build_O2/_deps/rapidjson-src/include/rapidjson/allocators.h |
stl_reader::stl_reader_impl::CoordWithIndex<double, unsigned int>::operator<(stl_reader::stl_reader_impl::CoordWithIndex<double, unsigned int> const&) const | bool operator < (const CoordWithIndex& c) const
{
return (data[0] < c[0])
|| (data[0] == c[0] && data[1] < c[1])
|| (data[0] == c[0] && data[1] == c[1] && data[2] < c[2]);
} | movsd (%rdi), %xmm0
movsd (%rsi), %xmm1
movb $0x1, %al
ucomisd %xmm0, %xmm1
ja 0x1dd25
ucomisd %xmm1, %xmm0
jne 0x1dd26
jp 0x1dd26
movsd 0x8(%rdi), %xmm0
movsd 0x8(%rsi), %xmm1
ucomisd %xmm0, %xmm1
ja 0x1dd25
ucomisd %xmm1, %xmm0
jne 0x1dd26
jp 0x1dd26
movsd 0x10(%rsi), %xmm0
ucomisd 0x10(%rdi), %xmm0
seta %al
retq
xorl %eax, %eax
retq
| /OpenMD[P]OpenMD/build_O2/_deps/stl_reader-src/stl_reader.h |
cmdline_parser_file_save | int
cmdline_parser_file_save(const char *filename, struct gengetopt_args_info *args_info)
{
FILE *outfile;
int i = 0;
outfile = fopen(filename, "w");
if (!outfile)
{
fprintf (stderr, "%s: cannot open file for writing: %s\n", CMDLINE_PARSER_PACKAGE, filename);
return EXIT_FAILURE;
}
i = cmdline_parser_dump(outfile, args_info);
fclose (outfile);
return i;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xae723(%rip), %rsi # 0xcd3fc
callq 0x135d0
testq %rax, %rax
je 0x1ed03
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1ea59
movl %eax, %ebx
movq %r15, %rdi
callq 0x134c0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0xff2ae(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
leaq 0xa733e(%rip), %rsi # 0xc6052
leaq 0xaa8d6(%rip), %rdx # 0xc95f1
movq %rbx, %rcx
xorl %eax, %eax
callq 0x13750
pushq $0x1
popq %rax
jmp 0x1ecfd
| /OpenMD[P]OpenMD/src/applications/hydrodynamics/HydroCmd.cpp |
cmdline_parser_internal(int, char**, gengetopt_args_info*, cmdline_parser_params*, char const*) | int
cmdline_parser_internal (
int argc, char **argv, struct gengetopt_args_info *args_info,
struct cmdline_parser_params *params, const char *additional_error)
{
int c; /* Character of the parsed option. */
int error_occurred = 0;
struct gengetopt_args_info local_args_info;
int override;
int initialize;
int check_required;
int check_ambiguity;
char *optarg;
int optind;
int opterr;
int optopt;
package_name = argv[0];
/* TODO: Why is this here? It is not used anywhere. */
override = params->override;
FIX_UNUSED(override);
initialize = params->initialize;
check_required = params->check_required;
/* TODO: Why is this here? It is not used anywhere. */
check_ambiguity = params->check_ambiguity;
FIX_UNUSED(check_ambiguity);
if (initialize)
cmdline_parser_init (args_info);
cmdline_parser_init (&local_args_info);
optarg = 0;
optind = 0;
opterr = params->print_errors;
optopt = '?';
while (1)
{
int option_index = 0;
static struct option long_options[] = {
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'V' },
{ "input", 1, NULL, 'i' },
{ "xyz", 1, NULL, 'x' },
{ "stl", 1, NULL, 0 },
{ "msms", 1, NULL, 0 },
{ "output", 1, NULL, 'o' },
{ "model", 1, NULL, 0 },
{ "beadSize", 1, NULL, 's' },
{ "elements", 0, NULL, 'e' },
{ "viscosity", 1, NULL, 'v' },
{ "temperature", 1, NULL, 't' },
{ 0, 0, 0, 0 }
};
custom_optarg = optarg;
custom_optind = optind;
custom_opterr = opterr;
custom_optopt = optopt;
c = custom_getopt_long (argc, argv, "hVi:x:o:s:ev:t:", long_options, &option_index);
optarg = custom_optarg;
optind = custom_optind;
opterr = custom_opterr;
optopt = custom_optopt;
if (c == -1) break; /* Exit from `while (1)' loop. */
switch (c)
{
case 'h': /* Print help and exit. */
cmdline_parser_print_help ();
cmdline_parser_free (&local_args_info);
exit (EXIT_SUCCESS);
case 'V': /* Print version and exit. */
cmdline_parser_print_version ();
cmdline_parser_free (&local_args_info);
exit (EXIT_SUCCESS);
case 'i': /* input MetaData (omd) file. */
if (args_info->input_file_group_counter && override)
reset_group_input_file (args_info);
args_info->input_file_group_counter += 1;
if (update_arg( (void *)&(args_info->input_arg),
&(args_info->input_orig), &(args_info->input_given),
&(local_args_info.input_given), optarg, 0, 0, ARG_STRING,
check_ambiguity, override, 0, 0,
"input", 'i',
additional_error))
goto failure;
break;
case 'x': /* xyz file for AtomicBead model. */
if (args_info->input_file_group_counter && override)
reset_group_input_file (args_info);
args_info->input_file_group_counter += 1;
if (update_arg( (void *)&(args_info->xyz_arg),
&(args_info->xyz_orig), &(args_info->xyz_given),
&(local_args_info.xyz_given), optarg, 0, 0, ARG_STRING,
check_ambiguity, override, 0, 0,
"xyz", 'x',
additional_error))
goto failure;
break;
case 'o': /* output file prefix. */
if (update_arg( (void *)&(args_info->output_arg),
&(args_info->output_orig), &(args_info->output_given),
&(local_args_info.output_given), optarg, 0, 0, ARG_STRING,
check_ambiguity, override, 0, 0,
"output", 'o',
additional_error))
goto failure;
break;
case 's': /* bead size (diameter) for RoughShell model (in angstroms). */
if (update_arg( (void *)&(args_info->beadSize_arg),
&(args_info->beadSize_orig), &(args_info->beadSize_given),
&(local_args_info.beadSize_given), optarg, 0, "0.2", ARG_DOUBLE,
check_ambiguity, override, 0, 0,
"beadSize", 's',
additional_error))
goto failure;
break;
case 'e': /* output the hydrodynamic elements (beads or triangles) only, hydrodynamics calculation will not be performed. */
if (update_arg((void *)&(args_info->elements_flag), 0, &(args_info->elements_given),
&(local_args_info.elements_given), optarg, 0, 0, ARG_FLAG,
check_ambiguity, override, 1, 0, "elements", 'e',
additional_error))
goto failure;
break;
case 'v': /* viscosity (in poise). */
if (update_arg( (void *)&(args_info->viscosity_arg),
&(args_info->viscosity_orig), &(args_info->viscosity_given),
&(local_args_info.viscosity_given), optarg, 0, "0.01", ARG_DOUBLE,
check_ambiguity, override, 0, 0,
"viscosity", 'v',
additional_error))
goto failure;
break;
case 't': /* temperature (in Kelvin. */
if (update_arg( (void *)&(args_info->temperature_arg),
&(args_info->temperature_orig), &(args_info->temperature_given),
&(local_args_info.temperature_given), optarg, 0, "300", ARG_DOUBLE,
check_ambiguity, override, 0, 0,
"temperature", 't',
additional_error))
goto failure;
break;
case 0: /* Long option with no short option */
/* stl file for BoundaryElement model. */
if (strcmp (long_options[option_index].name, "stl") == 0)
{
if (args_info->input_file_group_counter && override)
reset_group_input_file (args_info);
args_info->input_file_group_counter += 1;
if (update_arg( (void *)&(args_info->stl_arg),
&(args_info->stl_orig), &(args_info->stl_given),
&(local_args_info.stl_given), optarg, 0, 0, ARG_STRING,
check_ambiguity, override, 0, 0,
"stl", '-',
additional_error))
goto failure;
}
/* filename root for MSMS .vert and .face files. */
else if (strcmp (long_options[option_index].name, "msms") == 0)
{
if (args_info->input_file_group_counter && override)
reset_group_input_file (args_info);
args_info->input_file_group_counter += 1;
if (update_arg( (void *)&(args_info->msms_arg),
&(args_info->msms_orig), &(args_info->msms_given),
&(local_args_info.msms_given), optarg, 0, 0, ARG_STRING,
check_ambiguity, override, 0, 0,
"msms", '-',
additional_error))
goto failure;
}
/* hydrodynamics model. */
else if (strcmp (long_options[option_index].name, "model") == 0)
{
if (update_arg( (void *)&(args_info->model_arg),
&(args_info->model_orig), &(args_info->model_given),
&(local_args_info.model_given), optarg, cmdline_parser_model_values, 0, ARG_ENUM,
check_ambiguity, override, 0, 0,
"model", '-',
additional_error))
goto failure;
}
break;
case '?': /* Invalid option. */
/* `getopt_long' already printed an error message. */
goto failure;
default: /* bug: option not considered. */
fprintf (stderr, "%s: option unknown: %c%s\n", CMDLINE_PARSER_PACKAGE, c, (additional_error ? additional_error : ""));
abort ();
} /* switch */
} /* while */
if (args_info->input_file_group_counter > 1)
{
fprintf (stderr, "%s: %d options of group input file were given. One is required%s.\n", argv[0], args_info->input_file_group_counter, (additional_error ? additional_error : ""));
error_occurred = 1;
}
if (check_required)
{
error_occurred += cmdline_parser_required2 (args_info, argv[0], additional_error);
}
cmdline_parser_release (&local_args_info);
if ( error_occurred )
return (EXIT_FAILURE);
if (optind < argc)
{
int i = 0 ;
int found_prog_name = 0;
/* whether program name, i.e., argv[0], is in the remaining args
(this may happen with some implementations of getopt,
but surely not with the one included by gengetopt) */
args_info->inputs_num = argc - optind - found_prog_name;
args_info->inputs =
(char **)(malloc ((args_info->inputs_num)*sizeof(char *))) ;
while (optind < argc)
args_info->inputs[ i++ ] = gengetopt_strdup (argv[optind++]) ;
}
return 0;
failure:
cmdline_parser_release (&local_args_info);
return (EXIT_FAILURE);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, 0x8(%rsp)
movq (%rsi), %rax
movq %rax, 0xffe5b(%rip) # 0x11ecd8
movl (%rcx), %eax
movq %rax, 0x10(%rsp)
movl 0x8(%rcx), %eax
movl %eax, 0x54(%rsp)
movl 0xc(%rcx), %eax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x4(%rcx)
je 0x1eea1
movq %rbx, %rdi
callq 0x1e8e8
leaq 0x190(%rsp), %r12
movq %r12, %rdi
callq 0x1e8e8
movl $0x114, %eax # imm = 0x114
leaq (%rbx,%rax), %rcx
movq %rcx, 0x68(%rsp)
addq %r12, %rax
movq %rax, 0x70(%rsp)
movl $0x10c, %eax # imm = 0x10C
leaq (%rbx,%rax), %rcx
movq %rcx, 0x160(%rsp)
addq %r12, %rax
movq %rax, 0x168(%rsp)
movl $0x108, %eax # imm = 0x108
leaq (%rbx,%rax), %rcx
movq %rcx, 0x180(%rsp)
addq %r12, %rax
movq %rax, 0x188(%rsp)
movl $0x124, %eax # imm = 0x124
leaq (%rbx,%rax), %rcx
movq %rcx, 0x140(%rsp)
addq %r12, %rax
movq %rax, 0x148(%rsp)
movl $0x120, %eax # imm = 0x120
leaq (%rbx,%rax), %rcx
movq %rcx, 0x130(%rsp)
addq %r12, %rax
movq %rax, 0x138(%rsp)
movl $0x11c, %eax # imm = 0x11C
leaq (%rbx,%rax), %rcx
movq %rcx, 0x120(%rsp)
addq %r12, %rax
movq %rax, 0x128(%rsp)
movl $0x118, %eax # imm = 0x118
leaq (%rbx,%rax), %rcx
movq %rcx, 0x110(%rsp)
addq %r12, %rax
movq %rax, 0x118(%rsp)
movl $0x110, %eax # imm = 0x110
leaq (%rbx,%rax), %rcx
movq %rcx, 0x100(%rsp)
addq %r12, %rax
movq %rax, 0x108(%rsp)
movl $0x104, %eax # imm = 0x104
leaq (%rbx,%rax), %rcx
movq %rcx, 0xf0(%rsp)
addq %r12, %rax
movq %rax, 0xf8(%rsp)
movl $0x100, %eax # imm = 0x100
leaq (%rbx,%rax), %rcx
movq %rcx, 0xe0(%rsp)
addq %r12, %rax
movq %rax, 0xe8(%rsp)
movl 0x10(%r15), %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %r12d
movl %r12d, %eax
movq %rax, 0x40(%rsp)
leaq 0x88(%rbx), %rax
movq %rax, 0x60(%rsp)
leaq 0x90(%rbx), %rax
movq %rax, 0x58(%rsp)
leaq 0x58(%rbx), %rax
movq %rax, 0x158(%rsp)
leaq 0x60(%rbx), %rax
movq %rax, 0x150(%rsp)
leaq 0x40(%rbx), %rax
movq %rax, 0x178(%rsp)
leaq 0x48(%rbx), %rax
movq %rax, 0x170(%rsp)
leaq 0xe0(%rbx), %rax
movq %rax, 0xd8(%rsp)
leaq 0xe8(%rbx), %rax
movq %rax, 0xd0(%rsp)
leaq 0xc8(%rbx), %rax
movq %rax, 0xc8(%rsp)
leaq 0xd0(%rbx), %rax
movq %rax, 0xc0(%rsp)
leaq 0xb8(%rbx), %rax
movq %rax, 0xb8(%rsp)
leaq 0xa0(%rbx), %rax
movq %rax, 0xb0(%rsp)
leaq 0xa8(%rbx), %rax
movq %rax, 0xa8(%rsp)
leaq 0x70(%rbx), %rax
movq %rax, 0xa0(%rsp)
leaq 0x78(%rbx), %rax
movq %rax, 0x98(%rsp)
leaq 0x28(%rbx), %rax
movq %rax, 0x90(%rsp)
leaq 0x30(%rbx), %rax
movq %rax, 0x88(%rsp)
leaq 0x10(%rbx), %rax
movq %rax, 0x80(%rsp)
movq %rbx, 0x20(%rsp)
leaq 0x18(%rbx), %rax
movq %rax, 0x78(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r14, 0x38(%rsp)
movq %r13, 0xffbfc(%rip) # 0x11ece0
movl 0x4(%rsp), %eax
movl %eax, 0xff532(%rip) # 0x11e620
movl %ebp, 0xffbf4(%rip) # 0x11ece8
testl %r12d, %r12d
jle 0x1fa7d
andq $0x0, 0xffbeb(%rip) # 0x11ecf0
testl %ebp, %ebp
je 0x1f12f
testb $0x1, 0xffbe8(%rip) # 0x11ecf8
je 0x1f12f
movq 0xffbe7(%rip), %r13 # 0x11ed00
testq %r13, %r13
je 0x1f162
cmpb $0x0, (%r13)
je 0x1f162
movslq %ebp, %rax
movl %ebp, %esi
jmp 0x1f256
testl %ebp, %ebp
movq 0x40(%rsp), %rbx
jne 0x1f145
movl $0x1, 0xffba6(%rip) # 0x11ece8
pushq $0x1
popq %rbp
movl %ebp, 0xffbc5(%rip) # 0x11ed10
movl %ebp, 0xffbb7(%rip) # 0x11ed08
andq $0x0, 0xffba7(%rip) # 0x11ed00
movb $0x1, 0xffb98(%rip) # 0x11ecf8
jmp 0x1f167
movq 0x40(%rsp), %rbx
movl 0xffba3(%rip), %eax # 0x11ed10
cmpl %ebp, %eax
jle 0x1f179
movl %ebp, 0xffb99(%rip) # 0x11ed10
movl %ebp, %eax
movl 0xffb89(%rip), %ecx # 0x11ed08
cmpl %ebp, %ecx
jle 0x1f18b
movl %ebp, 0xffb7f(%rip) # 0x11ed08
movl %ebp, %ecx
cmpl %eax, %ecx
sete %cl
cmpl %ebp, %eax
sete %dl
orb %cl, %dl
je 0x1f1a5
cmpl %ebp, %eax
je 0x1f1b3
movl %ebp, 0xffb65(%rip) # 0x11ed08
jmp 0x1f1b3
movq %r14, %rdi
callq 0x200fa
movl 0xffb35(%rip), %ebp # 0x11ece8
movslq %ebp, %rbp
cmpl %r12d, %ebp
movl %r12d, %eax
cmovgl %ebp, %eax
cmpq %rbx, %rbp
movq %rbx, %rsi
cmovgq %rbp, %rsi
cmpq %rbx, %rbp
jge 0x1f1ef
movq (%r14,%rbp,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x1f1dd
cmpb $0x0, 0x1(%rcx)
jne 0x1f1eb
leal 0x1(%rbp), %ecx
incq %rbp
movl %ecx, 0xffaff(%rip) # 0x11ece8
jmp 0x1f1c9
movl %ebp, %esi
movl %ebp, %eax
movl %eax, 0xffb1b(%rip) # 0x11ed10
movl %r12d, %ecx
cmpl %r12d, %eax
je 0x1f21b
movslq %eax, %rcx
movq (%r14,%rcx,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x1f219
cmpb $0x2d, 0x1(%rcx)
jne 0x1f219
cmpb $0x0, 0x2(%rcx)
je 0x1f9fc
movl %eax, %ecx
cmpl %r12d, %esi
je 0x1fa6b
movslq %esi, %rax
movq (%r14,%rax,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x1fc37
movb 0x1(%rcx), %dl
testb %dl, %dl
je 0x1fc37
incq %rcx
xorl %r13d, %r13d
cmpb $0x2d, %dl
sete %r13b
addq %rcx, %r13
movq %r13, 0xffaaa(%rip) # 0x11ed00
movq (%r14,%rax,8), %rax
cmpb $0x2d, 0x1(%rax)
jne 0x1f284
movq %rax, 0x30(%rsp)
xorl %r12d, %r12d
movzbl (%r13,%r12), %eax
testl %eax, %eax
je 0x1f308
cmpl $0x3d, %eax
je 0x1f308
incq %r12
jmp 0x1f268
movq %rsi, %r12
leaq 0x1(%r13), %rbx
movq %rbx, 0xffa6e(%rip) # 0x11ed00
movb (%r13), %al
movl %eax, %r15d
movsbl %al, %esi
leaq 0xa6e55(%rip), %rdi # 0xc60f8
movq %rsi, 0x28(%rsp)
pushq $0x10
popq %rdx
callq 0x13560
cmpb $0x0, 0x1(%r13)
jne 0x1f2c5
movq %r12, %rbp
incl %ebp
movl %ebp, 0xffa26(%rip) # 0x11ece8
movq %rbp, %r12
testq %rax, %rax
je 0x1f935
cmpb $0x3a, %r15b
je 0x1f935
cmpb $0x3a, 0x1(%rax)
jne 0x1f3a9
cmpb $0x3a, 0x2(%rax)
movb (%rbx), %al
jne 0x1f46e
testb %al, %al
je 0x1f497
incl %r12d
movl %r12d, 0xff9e8(%rip) # 0x11ece8
movl %r12d, %ebp
jmp 0x1f499
movq %rsi, 0x48(%rsp)
xorl %ebx, %ebx
leaq 0xfa5fa(%rip), %r15 # 0x119910
movl $0x0, 0x28(%rsp)
pushq $-0x1
popq %rax
movl %eax, 0xc(%rsp)
xorl %r14d, %r14d
movq (%r15), %rbp
testq %rbp, %rbp
je 0x1f38a
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x13240
testl %eax, %eax
jne 0x1f381
movq %rbp, %rdi
callq 0x13210
cmpl %r12d, %eax
je 0x1f3bb
testq %rbx, %rbx
je 0x1f379
movl 0x8(%rbx), %eax
cmpl 0x8(%r15), %eax
jne 0x1f370
movq 0x10(%rbx), %rax
cmpq 0x10(%r15), %rax
jne 0x1f370
movl 0x18(%rbx), %eax
cmpl 0x18(%r15), %eax
je 0x1f381
pushq $0x1
popq %rax
movl %eax, 0x28(%rsp)
jmp 0x1f381
movq %r15, %rbx
movl %r14d, 0xc(%rsp)
addq $0x20, %r15
incl %r14d
jmp 0x1f328
cmpl $0x0, 0x28(%rsp)
jne 0x1f965
testq %rbx, %rbx
movq 0x38(%rsp), %r14
movq 0x48(%rsp), %rcx
jne 0x1f3cd
jmp 0x1f999
movl $0x0, 0xc(%rsp)
movl 0x8(%rsp), %r12d
jmp 0x1f4b5
movq %r15, %rbx
movl %r14d, 0xc(%rsp)
movq 0x38(%rsp), %r14
movq 0x48(%rsp), %rcx
leal 0x1(%rcx), %ebp
movl %ebp, 0xff912(%rip) # 0x11ece8
cmpb $0x0, (%r13,%r12)
movl 0x8(%rbx), %eax
je 0x1f3f7
testl %eax, %eax
je 0x1f9bc
leaq (%r12,%r13), %rax
incq %rax
movl 0x8(%rsp), %r12d
jmp 0x1f420
cmpl $0x1, %eax
jne 0x1f490
movl 0x8(%rsp), %r12d
cmpl %r12d, %ebp
jge 0x1fa15
addl $0x2, %ecx
movl %ecx, 0xff8d1(%rip) # 0x11ece8
movslq %ebp, %rax
movq (%r14,%rax,8), %rax
movl %ecx, %ebp
movq %rax, 0xff8c9(%rip) # 0x11ecf0
movq %r13, %rdi
callq 0x13210
addq %r13, %rax
movq %rax, 0xff8c7(%rip) # 0x11ed00
movq 0x10(%rbx), %rax
movl 0x18(%rbx), %edx
testq %rax, %rax
je 0x1f515
movl %edx, (%rax)
movl 0xff897(%rip), %ebp # 0x11ece8
movq 0xff898(%rip), %r13 # 0x11ecf0
movq %r13, 0xff881(%rip) # 0x11ece0
movl 0xff1bb(%rip), %eax # 0x11e620
movl %eax, 0x4(%rsp)
jmp 0x1f583
testb %al, %al
je 0x1f4bc
movl $0x0, 0xc(%rsp)
movq %rbx, 0xff86f(%rip) # 0x11ecf0
incl %r12d
movl %r12d, 0xff85d(%rip) # 0x11ece8
movl %r12d, %ebp
jmp 0x1f504
movl 0x8(%rsp), %r12d
jmp 0x1f427
xorl %ebx, %ebx
movl 0x8(%rsp), %r12d
movl $0x0, 0xc(%rsp)
movq %rbx, 0xff843(%rip) # 0x11ecf0
andq $0x0, 0xff84b(%rip) # 0x11ed00
movq 0x28(%rsp), %rdx
jmp 0x1f515
cmpl 0x8(%rsp), %r12d
jne 0x1f4e3
movl $0x0, 0xc(%rsp)
movb $0x3f, %r15b
cmpl $0x0, 0x4(%rsp)
jne 0x1f900
movl $0x0, 0x4(%rsp)
jmp 0x1f504
movl $0x0, 0xc(%rsp)
leal 0x1(%r12), %ebp
movl %ebp, 0xff7f2(%rip) # 0x11ece8
movslq %r12d, %rax
movq (%r14,%rax,8), %rax
movq %rax, 0xff7ec(%rip) # 0x11ecf0
andq $0x0, 0xff7f4(%rip) # 0x11ed00
movsbl %r15b, %edx
movl 0x8(%rsp), %r12d
movq 0xff7d4(%rip), %r13 # 0x11ecf0
movq %r13, 0xff7bd(%rip) # 0x11ece0
leal -0x65(%rdx), %eax
cmpl $0x13, %eax
ja 0x1f57b
leaq 0xa61ae(%rip), %rcx # 0xc56e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
subq $0x8, %rsp
movq 0xc0(%rsp), %rdi
xorl %esi, %esi
movq 0x128(%rsp), %rdx
movq 0x130(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x65
leaq 0xa6acb(%rip), %rax # 0xc6033
pushq %rax
pushq $0x1
popq %rax
pushq %rax
pushq 0x30(%rsp)
pushq 0x40(%rsp)
pushq %rax
jmp 0x1f8e8
testl %edx, %edx
jne 0x1f9db
movslq 0xc(%rsp), %rax
shlq $0x5, %rax
leaq 0xfa37d(%rip), %rcx # 0x119910
movq (%rax,%rcx), %r15
movq %r15, %rdi
leaq 0xa5c33(%rip), %rsi # 0xc51d4
callq 0x13720
testl %eax, %eax
je 0x1f615
movq %r15, %rdi
leaq 0xa6a6a(%rip), %rsi # 0xc601e
callq 0x13720
testl %eax, %eax
je 0x1f682
movq %r15, %rdi
leaq 0xa6670(%rip), %rsi # 0xc5c3b
callq 0x13720
testl %eax, %eax
jne 0x1f0dd
subq $0x8, %rsp
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
movq %r13, %r8
leaq 0xff006(%rip), %r9 # 0x11e600
pushq $0x2d
leaq 0xa6638(%rip), %rax # 0xc5c3b
pushq %rax
pushq $0x0
pushq 0x30(%rsp)
pushq 0x40(%rsp)
pushq $0x4
jmp 0x1f8e8
cmpl $0x0, 0x10(%rsp)
setne %cl
movq 0x20(%rsp), %rbx
movl 0x134(%rbx), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1f642
movq %rbx, %rdi
callq 0x1fdb3
movl 0x134(%rbx), %eax
incl %eax
movl %eax, 0x134(%rbx)
subq $0x8, %rsp
movq 0x180(%rsp), %rdi
movq 0x178(%rsp), %rsi
movq 0x188(%rsp), %rdx
movq 0x190(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x2d
leaq 0xa5b57(%rip), %rax # 0xc51d4
jmp 0x1f8db
cmpl $0x0, 0x10(%rsp)
setne %cl
movq 0x20(%rsp), %rbx
movl 0x134(%rbx), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1f6af
movq %rbx, %rdi
callq 0x1fdb3
movl 0x134(%rbx), %eax
incl %eax
movl %eax, 0x134(%rbx)
subq $0x8, %rsp
movq 0x160(%rsp), %rdi
movq 0x158(%rsp), %rsi
movq 0x168(%rsp), %rdx
movq 0x170(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x2d
leaq 0xa6934(%rip), %rax # 0xc601e
jmp 0x1f8db
subq $0x8, %rsp
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0x138(%rsp), %rdx
movq 0x140(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x76
leaq 0xa691a(%rip), %rax # 0xc603c
pushq %rax
pushq $0x0
pushq 0x30(%rsp)
pushq 0x40(%rsp)
pushq $0x3
leaq 0xa69d6(%rip), %rax # 0xc610c
jmp 0x1f870
subq $0x8, %rsp
movq 0xa8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0x108(%rsp), %rdx
movq 0x110(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x6f
leaq 0xa68b5(%rip), %rax # 0xc6023
jmp 0x1f8db
cmpl $0x0, 0x10(%rsp)
setne %cl
movq 0x20(%rsp), %rbx
movl 0x134(%rbx), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1f7a0
movq %rbx, %rdi
callq 0x1fdb3
movl 0x134(%rbx), %eax
incl %eax
movl %eax, 0x134(%rbx)
subq $0x8, %rsp
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0xe8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x69
leaq 0xa683d(%rip), %rax # 0xc6018
jmp 0x1f8db
subq $0x8, %rsp
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
movq 0x148(%rsp), %rdx
movq 0x150(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x74
leaq 0xa6833(%rip), %rax # 0xc6046
pushq %rax
pushq $0x0
pushq 0x30(%rsp)
pushq 0x40(%rsp)
pushq $0x3
leaq 0xa68ea(%rip), %rax # 0xc6111
jmp 0x1f870
subq $0x8, %rsp
movq 0xb8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0x118(%rsp), %rdx
movq 0x120(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x73
leaq 0xa67ce(%rip), %rax # 0xc602a
pushq %rax
pushq $0x0
pushq 0x30(%rsp)
pushq 0x40(%rsp)
pushq $0x3
leaq 0xa6898(%rip), %rax # 0xc6108
pushq %rax
jmp 0x1f8ea
cmpl $0x0, 0x10(%rsp)
setne %cl
movq 0x20(%rsp), %rbx
movl 0x134(%rbx), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1f8a0
movq %rbx, %rdi
callq 0x1fdb3
movl 0x134(%rbx), %eax
incl %eax
movl %eax, 0x134(%rbx)
subq $0x8, %rsp
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x100(%rsp), %rcx
movq %r13, %r8
xorl %r9d, %r9d
pushq $0x78
leaq 0xa58fe(%rip), %rax # 0xc51d9
pushq %rax
pushq $0x0
pushq 0x30(%rsp)
pushq 0x40(%rsp)
pushq $0x2
pushq $0x0
callq 0x1fe2d
addq $0x40, %rsp
testl %eax, %eax
je 0x1f0dd
jmp 0x1fa40
movq 0xfe6b1(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xa68f3(%rip), %rsi # 0xc6207
movq 0x28(%rsp), %rcx
xorl %eax, %eax
callq 0x13750
movl 0xff3c2(%rip), %ebp # 0x11ece8
movl 0xfecf4(%rip), %eax # 0x11e620
movl %eax, 0x4(%rsp)
jmp 0x1f504
cmpl $0x0, 0x4(%rsp)
je 0x1fa32
movq 0xfe671(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xa6899(%rip), %rsi # 0xc61ed
movq 0x28(%rsp), %rcx
xorl %eax, %eax
callq 0x13750
jmp 0x1fa32
cmpl $0x0, 0x4(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rbx
jne 0x1fb69
movq %r13, %rdi
callq 0x13210
addq %r13, %rax
movq %rax, 0xff374(%rip) # 0x11ed00
incl %ebx
movl %ebx, 0xff354(%rip) # 0x11ece8
jmp 0x1fa32
cmpl $0x0, 0x4(%rsp)
jne 0x1fb9b
leaq 0xb153f(%rip), %rax # 0xd0eea
movq %rax, 0xff34e(%rip) # 0x11ed00
incl %ecx
movl %ecx, 0xff32e(%rip) # 0x11ece8
jmp 0x1fa32
cmpl $0x0, 0x4(%rsp)
jne 0x1fbc4
movq 0xff332(%rip), %rbx # 0x11ed00
movq %rbx, %rdi
callq 0x13210
addq %rbx, %rax
jmp 0x1fa2b
cmpl $-0x1, %edx
je 0x1fa8b
cmpl $0x3f, %edx
je 0x1fa40
cmpl $0x56, %edx
jne 0x1fc7b
callq 0x1e83c
jmp 0x1fc85
leal 0x1(%rax), %ecx
movl %ecx, 0xff2e3(%rip) # 0x11ece8
cmpl %eax, 0xff2fd(%rip) # 0x11ed08
jne 0x1fa4f
movl %ecx, 0xff2f5(%rip) # 0x11ed08
jmp 0x1fa57
cmpl $0x0, 0x4(%rsp)
jne 0x1fc0b
movq %r13, %rdi
callq 0x13210
addq %r13, %rax
movq %rax, 0xff2ce(%rip) # 0x11ed00
movq 0xff2b7(%rip), %rax # 0x11ecf0
movq %rax, 0xff2a0(%rip) # 0x11ece0
leaq 0x190(%rsp), %rdi
callq 0x1ed2c
jmp 0x1fac8
movq %r14, %rdi
callq 0x200fa
movl %r12d, 0xff2b2(%rip) # 0x11ed10
movl %r12d, 0xff283(%rip) # 0x11ece8
movl %r12d, %ebp
movl %r12d, %ecx
movl 0xff297(%rip), %eax # 0x11ed08
cmpl %ecx, %eax
je 0x1fa7d
movl %eax, 0xff26d(%rip) # 0x11ece8
movl %eax, %ebp
movq 0xff26c(%rip), %rax # 0x11ecf0
movq %rax, 0xff255(%rip) # 0x11ece0
movq 0x20(%rsp), %rax
movl 0x134(%rax), %ecx
xorl %ebx, %ebx
cmpl $0x2, %ecx
jge 0x1fb3f
cmpl $0x0, 0x54(%rsp)
je 0x1fab7
movq (%r14), %rsi
movq 0x20(%rsp), %rdi
callq 0x1fc9b
addl %eax, %ebx
leaq 0x190(%rsp), %rdi
callq 0x1ed2c
testl %ebx, %ebx
je 0x1fae1
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x2c8, %rsp # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movl %r12d, %edi
subl %ebp, %edi
jle 0x1facc
movq 0x20(%rsp), %r15
movl %edi, 0x130(%r15)
shlq $0x3, %rdi
callq 0x136b0
movq %rax, 0x128(%r15)
movslq %ebp, %rbx
movq %r15, %rbp
movq %r14, %rax
movslq %r12d, %r14
leaq (%rax,%rbx,8), %r12
xorl %r15d, %r15d
xorl %r13d, %r13d
leaq (%rbx,%r13), %rax
cmpq %r14, %rax
jge 0x1facc
movq (%r12,%r13,8), %rdi
callq 0x200ce
movq 0x128(%rbp), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x1fb1d
movq 0xfe472(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xa6562(%rip), %rsi # 0xc60b5
leaq 0xb1390(%rip), %r8 # 0xd0eea
xorl %eax, %eax
callq 0x13750
pushq $0x1
popq %rbx
jmp 0x1faa1
movq 0xfe448(%rip), %rcx # 0x11dfb8
movq (%rcx), %rdi
movq (%rax), %rdx
leaq 0xa65b2(%rip), %rsi # 0xc612f
movq 0x30(%rsp), %rcx
xorl %eax, %eax
callq 0x13750
movq 0xff170(%rip), %r13 # 0x11ed00
movl 0xff152(%rip), %ebx # 0x11ece8
jmp 0x1f97a
movq 0xfe416(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xa661e(%rip), %rsi # 0xc61cd
movq %r13, %rcx
xorl %eax, %eax
callq 0x13750
movl 0xff129(%rip), %ecx # 0x11ece8
jmp 0x1f9a4
movq 0x30(%rsp), %rcx
cmpb $0x2d, 0x1(%rcx)
movq 0xfe3e4(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq (%r14), %rdx
jne 0x1fbf2
movq (%rbx), %rcx
leaq 0xa6567(%rip), %rsi # 0xc614d
xorl %eax, %eax
callq 0x13750
jmp 0x1f9c7
movsbl (%rcx), %ecx
movq (%rbx), %r8
leaq 0xa657b(%rip), %rsi # 0xc617a
xorl %eax, %eax
callq 0x13750
jmp 0x1f9c7
movq 0xfe3a6(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xa6588(%rip), %rsi # 0xc61a7
movq 0x30(%rsp), %rcx
xorl %eax, %eax
callq 0x13750
movq 0xff0ce(%rip), %r13 # 0x11ed00
jmp 0x1fa20
incl %esi
movl %esi, 0xff0a9(%rip) # 0x11ece8
movq %rcx, 0xff0aa(%rip) # 0x11ecf0
movq %rcx, 0xff093(%rip) # 0x11ece0
pushq $0x1
popq %rcx
movq 0xfe361(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
leaq 0xa64b4(%rip), %rsi # 0xc6115
leaq 0xa9989(%rip), %rdx # 0xc95f1
leaq 0xb127b(%rip), %r8 # 0xd0eea
xorl %eax, %eax
callq 0x13750
callq 0x132a0
movq %rdx, %rcx
jmp 0x1fc50
callq 0x1e876
leaq 0x190(%rsp), %rdi
callq 0x1ed2a
xorl %edi, %edi
callq 0x13600
| /OpenMD[P]OpenMD/src/applications/hydrodynamics/HydroCmd.cpp |
check_possible_values(char const*, char const**) | static int
check_possible_values(const char *val, const char *values[])
{
int i, found, last;
size_t len;
if (!val) /* otherwise strlen() crashes below */
return -1; /* -1 means no argument for the option */
found = last = 0;
for (i = 0, len = strlen(val); values[i]; ++i)
{
if (strncmp(val, values[i], len) == 0)
{
++found;
last = i;
if (strlen(values[i]) == len)
return i; /* exact macth no need to check more */
}
}
if (found == 1) /* one match: OK */
return last;
return (found ? -2 : -1); /* return many values or none matched */
} | testq %rdi, %rdi
je 0x1fd87
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x13210
movq %rax, %r15
xorl %ebp, %ebp
xorl %r13d, %r13d
movl $0x0, 0x4(%rsp)
movq (%rbx,%rbp,8), %r12
testq %r12, %r12
je 0x1fd70
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x13240
testl %eax, %eax
jne 0x1fd6b
movq %r12, %rdi
callq 0x13210
cmpq %r15, %rax
je 0x1fd8b
incl %r13d
movl %ebp, 0x4(%rsp)
incq %rbp
jmp 0x1fd3c
cmpl $0x1, %r13d
movl 0x4(%rsp), %eax
je 0x1fd8d
xorl %eax, %eax
testl %r13d, %r13d
sete %al
orl $-0x2, %eax
jmp 0x1fd8d
pushq $-0x1
popq %rax
retq
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /OpenMD[P]OpenMD/src/applications/hydrodynamics/HydroCmd.cpp |
reset_group_input_file(gengetopt_args_info*) | static void
reset_group_input_file(struct gengetopt_args_info *args_info)
{
if (! args_info->input_file_group_counter)
return;
args_info->input_given = 0 ;
free_string_field (&(args_info->input_arg));
free_string_field (&(args_info->input_orig));
args_info->xyz_given = 0 ;
free_string_field (&(args_info->xyz_arg));
free_string_field (&(args_info->xyz_orig));
args_info->stl_given = 0 ;
free_string_field (&(args_info->stl_arg));
free_string_field (&(args_info->stl_orig));
args_info->msms_given = 0 ;
free_string_field (&(args_info->msms_arg));
free_string_field (&(args_info->msms_orig));
args_info->input_file_group_counter = 0;
} | cmpl $0x0, 0x134(%rdi)
je 0x1fe2c
pushq %rbx
movq %rdi, %rbx
andl $0x0, 0x100(%rdi)
addq $0x10, %rdi
callq 0x1fd9c
leaq 0x18(%rbx), %rdi
callq 0x1fd9c
andl $0x0, 0x104(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x1fd9c
leaq 0x30(%rbx), %rdi
callq 0x1fd9c
andl $0x0, 0x108(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x1fd9c
leaq 0x48(%rbx), %rdi
callq 0x1fd9c
andl $0x0, 0x10c(%rbx)
leaq 0x58(%rbx), %rdi
callq 0x1fd9c
leaq 0x60(%rbx), %rdi
callq 0x1fd9c
andl $0x0, 0x134(%rbx)
popq %rbx
retq
| /OpenMD[P]OpenMD/src/applications/hydrodynamics/HydroCmd.cpp |
update_arg(void*, char**, unsigned int*, unsigned int*, char*, char const**, char const*, cmdline_parser_arg_type, int, int, int, int, char const*, char, char const*) | static
int update_arg(void *field, char **orig_field,
unsigned int *field_given, unsigned int *prev_given,
char *value, const char *possible_values[],
const char *default_value,
cmdline_parser_arg_type arg_type,
int check_ambiguity, int override,
int no_free, int multiple_option,
const char *long_opt, char short_opt,
const char *additional_error)
{
char *stop_char = 0;
const char *val = value;
int found;
char **string_field;
FIX_UNUSED (field);
stop_char = 0;
found = 0;
if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given)))
{
if (short_opt != '-')
fprintf (stderr, "%s: `--%s' (`-%c') option given more than once%s\n",
package_name, long_opt, short_opt,
(additional_error ? additional_error : ""));
else
fprintf (stderr, "%s: `--%s' option given more than once%s\n",
package_name, long_opt,
(additional_error ? additional_error : ""));
return 1; /* failure */
}
if (possible_values && (found = check_possible_values((value ? value : default_value), possible_values)) < 0)
{
if (short_opt != '-')
fprintf (stderr, "%s: %s argument, \"%s\", for option `--%s' (`-%c')%s\n",
package_name, (found == -2) ? "ambiguous" : "invalid", value, long_opt, short_opt,
(additional_error ? additional_error : ""));
else
fprintf (stderr, "%s: %s argument, \"%s\", for option `--%s'%s\n",
package_name, (found == -2) ? "ambiguous" : "invalid", value, long_opt,
(additional_error ? additional_error : ""));
return 1; /* failure */
}
if (field_given && *field_given && ! override)
return 0;
if (prev_given)
(*prev_given)++;
if (field_given)
(*field_given)++;
if (possible_values)
val = possible_values[found];
switch(arg_type) {
case ARG_FLAG:
*((int *)field) = !*((int *)field);
break;
case ARG_DOUBLE:
if (val) *((double *)field) = strtod (val, &stop_char);
break;
case ARG_ENUM:
if (val) *((int *)field) = found;
break;
case ARG_STRING:
if (val) {
string_field = (char **)field;
if (!no_free && *string_field)
free (*string_field); /* free previous string */
*string_field = gengetopt_strdup (val);
}
break;
default:
break;
};
/* check numeric conversion */
switch(arg_type) {
case ARG_DOUBLE:
if (val && !(stop_char && *stop_char == '\0')) {
fprintf(stderr, "%s: invalid numeric value: %s\n", package_name, val);
return 1; /* failure */
}
break;
default:
;
};
/* store the original value */
switch(arg_type) {
case ARG_NO:
case ARG_FLAG:
break;
default:
if (value && orig_field) {
if (no_free) {
*orig_field = value;
} else {
if (*orig_field)
free (*orig_field); /* free previous string */
*orig_field = gengetopt_strdup (value);
}
}
};
return 0; /* OK */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movb 0x80(%rsp), %r14b
movq 0x78(%rsp), %rcx
andq $0x0, 0x10(%rsp)
testq %r12, %r12
je 0x1fe83
cmpl $0x0, (%r12)
jne 0x20011
cmpl $0x0, 0x60(%rsp)
je 0x1fe83
cmpl $0x0, (%rbp)
jne 0x20011
testq %r13, %r13
je 0x1fef4
testq %rbx, %rbx
movq 0x50(%rsp), %rdi
cmovneq %rbx, %rdi
movq %r13, %rsi
callq 0x1fd11
testl %eax, %eax
jns 0x1fef6
cmpb $0x2d, %r14b
jne 0x2006b
movq 0xfe107(%rip), %rcx # 0x11dfb8
movq (%rcx), %rdi
movq 0xfee1d(%rip), %rdx # 0x11ecd8
cmpl $-0x2, %eax
leaq 0xa63f9(%rip), %rax # 0xc62be
leaq 0xa87c0(%rip), %rcx # 0xc868c
cmoveq %rax, %rcx
subq $0x8, %rsp
leaq 0xb100f(%rip), %r10 # 0xd0eea
leaq 0xa63e6(%rip), %rsi # 0xc62c8
movq %rbx, %r8
movq 0x80(%rsp), %r9
xorl %eax, %eax
jmp 0x200af
xorl %eax, %eax
testq %rbp, %rbp
je 0x1ff0f
cmpl $0x0, 0x68(%rsp)
jne 0x1ff0f
xorl %r14d, %r14d
cmpl $0x0, (%rbp)
jne 0x200bc
testq %r12, %r12
je 0x1ff18
incl (%r12)
testq %rbp, %rbp
je 0x1ff20
incl (%rbp)
movl 0x58(%rsp), %ecx
movq %rbx, %r12
testq %r13, %r13
je 0x1ff33
movl %eax, %edx
movq (%r13,%rdx,8), %r12
movl 0x70(%rsp), %ebp
decl %ecx
leaq 0xa57f0(%rip), %rdx # 0xc5730
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %eax, %eax
cmpl $0x0, (%r15)
sete %al
movl %eax, (%r15)
xorl %r14d, %r14d
jmp 0x200bc
testq %r12, %r12
je 0x1ffd1
leaq 0x10(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x133b0
movsd %xmm0, (%r15)
movq (%r14), %rax
testq %rax, %rax
je 0x1ff84
cmpb $0x0, (%rax)
je 0x1ffd1
movq 0xfe02d(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq 0xfed43(%rip), %rdx # 0x11ecd8
leaq 0xa6358(%rip), %rsi # 0xc62f4
movq %r12, %rcx
xorl %eax, %eax
callq 0x13750
jmp 0x200b8
testq %r12, %r12
je 0x1ffd1
movl %eax, (%r15)
jmp 0x1ffd1
testq %r12, %r12
je 0x1ffd1
testl %ebp, %ebp
jne 0x1ffc6
movq (%r15), %rdi
callq 0x135e0
movq %r12, %rdi
callq 0x200ce
movq %rax, (%r15)
testq %rbx, %rbx
sete %al
movq 0x8(%rsp), %r15
testq %r15, %r15
sete %cl
xorl %r14d, %r14d
orb %al, %cl
jne 0x200bc
testl %ebp, %ebp
je 0x1fff9
movq %rbx, (%r15)
jmp 0x200bc
movq (%r15), %rdi
callq 0x135e0
movq %rbx, %rdi
callq 0x200ce
movq %rax, (%r15)
jmp 0x200bc
cmpb $0x2d, %r14b
jne 0x2003f
movq 0xfdf9a(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq 0xfecb0(%rip), %rdx # 0x11ecd8
leaq 0xa6231(%rip), %rsi # 0xc6260
leaq 0xb0eb4(%rip), %r8 # 0xd0eea
xorl %eax, %eax
callq 0x13750
jmp 0x200b8
movzbl %r14b, %r8d
movq 0xfdf6e(%rip), %rax # 0x11dfb8
movq (%rax), %rdi
movq 0xfec84(%rip), %rdx # 0x11ecd8
leaq 0xa61d3(%rip), %rsi # 0xc622e
leaq 0xb0e88(%rip), %r9 # 0xd0eea
xorl %eax, %eax
callq 0x13750
jmp 0x200b8
movzbl %r14b, %r10d
movq 0xfdf42(%rip), %rcx # 0x11dfb8
movq (%rcx), %rdi
movq 0xfec58(%rip), %rdx # 0x11ecd8
cmpl $-0x2, %eax
leaq 0xa6234(%rip), %rax # 0xc62be
leaq 0xa85fb(%rip), %rcx # 0xc868c
cmoveq %rax, %rcx
leaq 0xb0e4e(%rip), %r11 # 0xd0eea
leaq 0xa61e7(%rip), %rsi # 0xc628a
movq %rbx, %r8
movq 0x78(%rsp), %r9
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x13750
popq %rcx
popq %rdx
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /OpenMD[P]OpenMD/src/applications/hydrodynamics/HydroCmd.cpp |
gengetopt_strdup(char const*) | char *
gengetopt_strdup (const char *s)
{
char *result = 0;
if (!s)
return result;
result = (char*)malloc(strlen(s) + 1);
if (result == (char*)0)
return (char*)0;
strcpy(result, s);
return result;
} | pushq %rbx
testq %rdi, %rdi
je 0x200f6
movq %rdi, %rbx
callq 0x13210
leaq 0x1(%rax), %rdi
callq 0x136b0
testq %rax, %rax
je 0x200f6
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x13470
xorl %eax, %eax
popq %rbx
retq
| /OpenMD[P]OpenMD/src/applications/hydrodynamics/HydroCmd.cpp |
exchange(char**, custom_getopt_data*) | static void exchange(char **argv, struct custom_getopt_data *d)
{
int bottom = d->first_nonopt;
int middle = d->last_nonopt;
int top = d->custom_optind;
char *tem;
/*
* Exchange the shorter segment with the far end of the longer segment.
* That puts the shorter segment into the right place. It leaves the
* longer segment in the right place overall, but it consists of two
* parts that need to be swapped next.
*/
while (top > middle && middle > bottom) {
if (top - middle > middle - bottom) {
/* Bottom segment is the short one. */
int len = middle - bottom;
int i;
/* Swap it with the top part of the top segment. */
for (i = 0; i < len; i++) {
tem = argv[bottom + i];
argv[bottom + i] =
argv[top - (middle - bottom) + i];
argv[top - (middle - bottom) + i] = tem;
}
/* Exclude the moved bottom segment from further swapping. */
top -= len;
} else {
/* Top segment is the short one. */
int len = top - middle;
int i;
/* Swap it with the bottom part of the bottom segment. */
for (i = 0; i < len; i++) {
tem = argv[bottom + i];
argv[bottom + i] = argv[middle + i];
argv[middle + i] = tem;
}
/* Exclude the moved top segment from further swapping. */
bottom += len;
}
}
/* Update records for the slots the non-options now occupy. */
d->first_nonopt += (d->custom_optind - d->last_nonopt);
d->last_nonopt = d->custom_optind;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0xfebfe(%rip), %eax # 0x11ed08
movslq 0xfebff(%rip), %rdx # 0x11ed10
movl 0xfebd0(%rip), %r10d # 0x11ece8
leaq (%rdi,%rdx,8), %rsi
movl %edx, %r8d
negl %r8d
movl %r10d, -0x14(%rsp)
movl %eax, %r11d
movq %rdi, -0x8(%rsp)
movq %r8, -0x10(%rsp)
movl %r10d, %ebp
subl %edx, %ebp
testl %ebp, %ebp
movl $0x0, %r15d
cmovgl %ebp, %r15d
movslq %r11d, %rcx
leaq (%rdi,%rcx,8), %rbx
movslq %ebp, %r12
shlq $0x3, %r12
leal (%r8,%rcx), %r13d
addl %r10d, %r13d
movl %edx, %r14d
subl %ecx, %r14d
movl %edx, %r9d
subl %r10d, %r9d
cmpl %edx, %r10d
jle 0x201e1
movl %edx, %ecx
subl %r11d, %ecx
jle 0x201e1
cmpl %ecx, %ebp
jg 0x201a0
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x20192
movq (%rbx,%rcx,8), %r8
movq (%rsi,%rcx,8), %rdi
movq %rdi, (%rbx,%rcx,8)
movq %r8, (%rsi,%rcx,8)
incq %rcx
jmp 0x20178
addl %ebp, %r11d
addq %r12, %rbx
addl %ebp, %r13d
addl %r9d, %r14d
jmp 0x20166
subl %ecx, %r10d
movslq %r13d, %rcx
movq -0x8(%rsp), %rdi
leaq (%rdi,%rcx,8), %r9
testl %r14d, %r14d
movl $0x0, %ecx
cmovlel %ecx, %r14d
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x201d7
movq (%rbx,%rcx,8), %r15
movq (%r9,%rcx,8), %r12
movq %r12, (%rbx,%rcx,8)
movq %r15, (%r9,%rcx,8)
incq %rcx
jmp 0x201bd
movq -0x10(%rsp), %r8
jmp 0x20134
subl %edx, %eax
movl -0x14(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xfeb19(%rip) # 0x11ed08
movl %ecx, 0xfeb1b(%rip) # 0x11ed10
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /OpenMD[P]OpenMD/src/applications/hydrodynamics/HydroCmd.cpp |
OpenMD::SimCreator::parseFile(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int) | Globals* SimCreator::parseFile(std::istream& rawMetaDataStream,
const std::string& filename, int mdFileVersion,
int startOfMetaDataBlock) {
Globals* simParams = NULL;
try {
// Create a preprocessor that preprocesses md file into an ostringstream
std::stringstream ppStream;
#ifdef IS_MPI
int streamSize;
const int primaryNode = 0;
if (worldRank == primaryNode) {
MPI_Bcast(&mdFileVersion, 1, MPI_INT, primaryNode, MPI_COMM_WORLD);
#endif
SimplePreprocessor preprocessor;
preprocessor.preprocess(rawMetaDataStream, filename,
startOfMetaDataBlock, ppStream);
#ifdef IS_MPI
// broadcasting the stream size
streamSize = ppStream.str().size() + 1;
MPI_Bcast(&streamSize, 1, MPI_INT, primaryNode, MPI_COMM_WORLD);
MPI_Bcast(static_cast<void*>(const_cast<char*>(ppStream.str().c_str())),
streamSize, MPI_CHAR, primaryNode, MPI_COMM_WORLD);
} else {
MPI_Bcast(&mdFileVersion, 1, MPI_INT, primaryNode, MPI_COMM_WORLD);
// get stream size
MPI_Bcast(&streamSize, 1, MPI_INT, primaryNode, MPI_COMM_WORLD);
char* buf = new char[streamSize];
assert(buf);
// receive file content
MPI_Bcast(buf, streamSize, MPI_CHAR, primaryNode, MPI_COMM_WORLD);
ppStream.str(buf);
delete[] buf;
}
#endif
// Create a scanner that reads from the input stream
MDLexer lexer(ppStream);
lexer.setFilename(filename);
lexer.initDeferredLineCount();
// Create a parser that reads from the scanner
MDParser parser(lexer);
parser.setFilename(filename);
// Create an observer that synchorizes file name change
FilenameObserver observer;
observer.setLexer(&lexer);
observer.setParser(&parser);
lexer.setObserver(&observer);
antlr::ASTFactory factory;
parser.initializeASTFactory(factory);
parser.setASTFactory(&factory);
parser.mdfile();
// Create a tree parser that reads information into Globals
MDTreeParser treeParser;
treeParser.initializeASTFactory(factory);
treeParser.setASTFactory(&factory);
simParams = treeParser.walkTree(parser.getAST());
}
catch (antlr::MismatchedCharException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"Mismatched Character: %s in file %s at line %d, column %d\n",
e.getMessage().c_str(), e.getFilename().c_str(), e.getLine(),
e.getColumn());
painCave.isFatal = 1;
simError();
} catch (antlr::MismatchedTokenException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"Mismatched Token: %s in file %s at line %d, column %d\n",
e.getMessage().c_str(), e.getFilename().c_str(), e.getLine(),
e.getColumn());
painCave.isFatal = 1;
simError();
} catch (antlr::NoViableAltForCharException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"No Viable Alternative for Character: %s in file %s at line %d, "
"column %d\n",
e.getMessage().c_str(), e.getFilename().c_str(), e.getLine(),
e.getColumn());
painCave.isFatal = 1;
simError();
} catch (antlr::NoViableAltException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"No Viable Alternative: %s in file %s at line %d, column %d\n",
e.getMessage().c_str(), e.getFilename().c_str(), e.getLine(),
e.getColumn());
painCave.isFatal = 1;
simError();
}
catch (antlr::TokenStreamRecognitionException& e) {
snprintf(
painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"Token Stream Recognition: %s in file %s at line %d, column %d\n",
e.getMessage().c_str(), e.getFilename().c_str(), e.getLine(),
e.getColumn());
painCave.isFatal = 1;
simError();
}
catch (antlr::TokenStreamIOException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"Token Stream IO exception: %s\n", e.getMessage().c_str());
painCave.isFatal = 1;
simError();
}
catch (antlr::TokenStreamException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"Token Stream exception: %s\n", e.getMessage().c_str());
painCave.isFatal = 1;
simError();
} catch (antlr::RecognitionException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"Recognition exception: %s in file %s at line %d, column %d\n",
e.getMessage().c_str(), e.getFilename().c_str(), e.getLine(),
e.getColumn());
painCave.isFatal = 1;
simError();
} catch (antlr::CharStreamException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"Character Stream exception: %s\n", e.getMessage().c_str());
painCave.isFatal = 1;
simError();
} catch (OpenMDException& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH, "%s\n", e.what());
painCave.isFatal = 1;
simError();
} catch (std::exception& e) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"parser exception: %s\n", e.what());
painCave.isFatal = 1;
simError();
}
simParams->setMDfileVersion(mdFileVersion);
return simParams;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x118(%rsp), %rdi
callq 0x13350
leaq 0x128(%rsp), %r8
leaq 0xf(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x222d0
leaq 0x80(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x2cb94
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
callq 0x22394
leaq 0x80(%rsp), %rsi
andl $0x0, 0x8c(%rsi)
leaq 0x18(%rsp), %rdi
callq 0x3292e
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x223a4
leaq 0x40(%rsp), %rdi
callq 0x92130
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x9213c
leaq 0x40(%rsp), %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x92138
movq %r14, 0x110(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4f3c4
leaq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %r14
movq %r14, %rsi
callq 0x3d6f0
leaq 0x18(%rsp), %rdi
movq %r14, 0x10(%rdi)
callq 0x3296a
leaq 0x2a0(%rsp), %rdi
callq 0x3d788
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x4a02e
movq %r14, 0x2a8(%rsp)
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x2031d
incl 0x8(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x2a0(%rsp), %rdi
callq 0x223c0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x22462
leaq 0x2a0(%rsp), %rdi
callq 0x22486
leaq 0x50(%rsp), %rdi
callq 0x4f482
leaq 0x18(%rsp), %rdi
callq 0x224bc
leaq 0x80(%rsp), %rdi
callq 0x22724
leaq 0x118(%rsp), %rdi
callq 0x13390
movb $0x0, 0x12a2(%r14)
movl %ebx, 0x12a4(%r14)
movq %r14, %rax
addq $0x328, %rsp # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x22462
jmp 0x203b6
movq %rdx, %r14
movq %rax, %rbx
leaq 0x2a0(%rsp), %rdi
callq 0x22486
jmp 0x203ed
jmp 0x203e7
jmp 0x203f9
jmp 0x203f9
jmp 0x203cd
movq %rdx, %r14
movq %rax, %rbx
jmp 0x20409
jmp 0x203d7
movq %rdx, %r14
movq %rax, %rbx
jmp 0x20416
movq %rdx, %r14
movq %rax, %rbx
jmp 0x20423
movq %rdx, %r14
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4f482
jmp 0x203ff
movq %rdx, %r14
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x224bc
leaq 0x80(%rsp), %rdi
callq 0x22724
leaq 0x118(%rsp), %rdi
callq 0x13390
cmpl $0xb, %r14d
jne 0x204d1
movq %rbx, %rdi
callq 0x131f0
movq %rax, %r12
movq (%rax), %rax
leaq 0x118(%rsp), %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x118(%rsp), %rbx
movq (%rbx), %r15
movq (%r12), %rax
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movq (%r14), %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
movl %eax, %ebp
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
movl %eax, (%rsp)
leaq 0xfec18(%rip), %r12 # 0x11f0a4
leaq 0xa6066(%rip), %rdx # 0xc64f9
movl $0x7d0, %esi # imm = 0x7D0
movq %r12, %rdi
movq %r15, %rcx
movq %r13, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x13830
movq %r14, %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r12)
callq 0x2beaa
jmp 0x209f5
cmpl $0xa, %r14d
jne 0x2057f
movq %rbx, %rdi
callq 0x131f0
movq %rax, %r12
movq (%rax), %rax
leaq 0x118(%rsp), %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x118(%rsp), %rbx
movq (%rbx), %r15
movq (%r12), %rax
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movq (%r14), %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
movl %eax, %ebp
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
movl %eax, (%rsp)
leaq 0xfeb6a(%rip), %r12 # 0x11f0a4
leaq 0xa5f81(%rip), %rdx # 0xc64c2
movl $0x7d0, %esi # imm = 0x7D0
movq %r12, %rdi
movq %r15, %rcx
movq %r13, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x13830
movq %r14, %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r12)
callq 0x2beaa
jmp 0x209f5
cmpl $0x9, %r14d
jne 0x2062d
movq %rbx, %rdi
callq 0x131f0
movq %rax, %r12
movq (%rax), %rax
leaq 0x118(%rsp), %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x118(%rsp), %rbx
movq (%rbx), %r15
movq (%r12), %rax
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movq (%r14), %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
movl %eax, %ebp
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
movl %eax, (%rsp)
leaq 0xfeabc(%rip), %r12 # 0x11f0a4
leaq 0xa5e89(%rip), %rdx # 0xc6478
movl $0x7d0, %esi # imm = 0x7D0
movq %r12, %rdi
movq %r15, %rcx
movq %r13, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x13830
movq %r14, %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r12)
callq 0x2beaa
jmp 0x209f5
cmpl $0x8, %r14d
jne 0x206db
movq %rbx, %rdi
callq 0x131f0
movq %rax, %r12
movq (%rax), %rax
leaq 0x118(%rsp), %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x118(%rsp), %rbx
movq (%rbx), %r15
movq (%r12), %rax
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movq (%r14), %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
movl %eax, %ebp
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
movl %eax, (%rsp)
leaq 0xfea0e(%rip), %r12 # 0x11f0a4
leaq 0xa5d9f(%rip), %rdx # 0xc643c
movl $0x7d0, %esi # imm = 0x7D0
movq %r12, %rdi
movq %r15, %rcx
movq %r13, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x13830
movq %r14, %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r12)
callq 0x2beaa
jmp 0x209f5
cmpl $0x7, %r14d
jne 0x20789
movq %rbx, %rdi
callq 0x131f0
movq %rax, %r12
movq (%rax), %rax
leaq 0x118(%rsp), %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x118(%rsp), %rbx
movq (%rbx), %r15
movq (%r12), %rax
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movq (%r14), %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
movl %eax, %ebp
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
movl %eax, (%rsp)
leaq 0xfe960(%rip), %r12 # 0x11f0a4
leaq 0xa5cb2(%rip), %rdx # 0xc63fd
movl $0x7d0, %esi # imm = 0x7D0
movq %r12, %rdi
movq %r15, %rcx
movq %r13, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x13830
movq %r14, %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r12)
callq 0x2beaa
jmp 0x209f5
cmpl $0x6, %r14d
jne 0x207ed
movq %rbx, %rdi
callq 0x131f0
movq (%rax), %rcx
leaq 0x118(%rsp), %rdi
movq %rax, %rsi
callq *0x18(%rcx)
leaq 0x118(%rsp), %rbx
movq (%rbx), %rcx
leaq 0xfe8ea(%rip), %r14 # 0x11f0a4
leaq 0xa5c1d(%rip), %rdx # 0xc63de
movl $0x7d0, %esi # imm = 0x7D0
movq %r14, %rdi
xorl %eax, %eax
callq 0x13830
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r14)
callq 0x2beaa
jmp 0x209f5
cmpl $0x5, %r14d
jne 0x20851
movq %rbx, %rdi
callq 0x131f0
movq (%rax), %rcx
leaq 0x118(%rsp), %rdi
movq %rax, %rsi
callq *0x18(%rcx)
leaq 0x118(%rsp), %rbx
movq (%rbx), %rcx
leaq 0xfe886(%rip), %r14 # 0x11f0a4
leaq 0xa5b9d(%rip), %rdx # 0xc63c2
movl $0x7d0, %esi # imm = 0x7D0
movq %r14, %rdi
xorl %eax, %eax
callq 0x13830
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r14)
callq 0x2beaa
jmp 0x209f5
cmpl $0x4, %r14d
jne 0x208ff
movq %rbx, %rdi
callq 0x131f0
movq %rax, %r12
movq (%rax), %rax
leaq 0x118(%rsp), %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x118(%rsp), %rbx
movq (%rbx), %r15
movq (%r12), %rax
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq *0x20(%rax)
movq (%r14), %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
movl %eax, %ebp
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
movl %eax, (%rsp)
leaq 0xfe7ea(%rip), %r12 # 0x11f0a4
leaq 0xa5ac5(%rip), %rdx # 0xc6386
movl $0x7d0, %esi # imm = 0x7D0
movq %r12, %rdi
movq %r15, %rcx
movq %r13, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x13830
movq %r14, %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r12)
callq 0x2beaa
jmp 0x209f5
cmpl $0x3, %r14d
jne 0x20963
movq %rbx, %rdi
callq 0x131f0
movq (%rax), %rcx
leaq 0x118(%rsp), %rdi
movq %rax, %rsi
callq *0x18(%rcx)
leaq 0x118(%rsp), %rbx
movq (%rbx), %rcx
leaq 0xfe774(%rip), %r14 # 0x11f0a4
leaq 0xa5a2f(%rip), %rdx # 0xc6366
movl $0x7d0, %esi # imm = 0x7D0
movq %r14, %rdi
xorl %eax, %eax
callq 0x13830
movq %rbx, %rdi
callq 0x13a98
movl $0x1, 0x7d0(%r14)
callq 0x2beaa
jmp 0x209f5
cmpl $0x2, %r14d
jne 0x209ab
movq %rbx, %rdi
callq 0x131f0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0xfe723(%rip), %rbx # 0x11f0a4
leaq 0xa64ea(%rip), %rdx # 0xc6e72
movl $0x7d0, %esi # imm = 0x7D0
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x13830
movl $0x1, 0x7d0(%rbx)
callq 0x2beaa
jmp 0x209f5
cmpl $0x1, %r14d
jne 0x20a78
movq %rbx, %rdi
callq 0x131f0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0xfe6d7(%rip), %rbx # 0x11f0a4
leaq 0xa597c(%rip), %rdx # 0xc6350
movl $0x7d0, %esi # imm = 0x7D0
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x13830
movl $0x1, 0x7d0(%rbx)
callq 0x2beaa
callq 0x138a0
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a10
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a1c
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a28
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a34
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a40
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a4c
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a58
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a64
movq %rax, %rbx
callq 0x138a0
jmp 0x20a78
jmp 0x20a70
movq %rax, %rbx
callq 0x138a0
movq %rbx, %rdi
callq 0x13960
movq %rax, %rdi
callq 0x1ab08
| /OpenMD[P]OpenMD/src/brains/SimCreator.cpp |
OpenMD::SimInfo::getMoleculeByGlobalIndex(int) | Molecule* getMoleculeByGlobalIndex(int index) {
MoleculeIterator i;
i = molecules_.find(index);
return i != molecules_.end() ? i->second : NULL;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0xa8, %rdi
movq %rax, %rsi
callq 0x250fe
addq $0xb0, %rbx
cmpq %rbx, %rax
je 0x225d0
movq 0x28(%rax), %rax
jmp 0x225d2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
| /OpenMD[P]OpenMD/src/brains/SimInfo.hpp |
antlr::CharScanner::append(char) | virtual void append(char c)
{
if (saveConsumedInput)
{
size_t l = text.length();
if ((l%256) == 0)
text.reserve(l+256);
text.replace(l,0,&c,1);
}
} | pushq %r14
pushq %rbx
pushq %rax
movb %sil, 0x7(%rsp)
cmpb $0x1, 0x28(%rdi)
jne 0x227a0
movq %rdi, %rbx
movq 0x10(%rdi), %r14
addq $0x8, %rbx
testb %r14b, %r14b
jne 0x2278a
leaq 0x100(%r14), %rsi
movq %rbx, %rdi
callq 0x137f0
leaq 0x7(%rsp), %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x13580
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /OpenMD[P]OpenMD/src/antlr/CharScanner.hpp |
antlr::CharScanner::match(char const*) | virtual void match( const char* s )
{
while( *s != '\0' )
{
// the & 0xFF is here to prevent sign extension lateron
int la_1 = LA(1), c = (*s++ & 0xFF);
if ( la_1 != c )
throw MismatchedCharException(la_1, c, false, this);
consume();
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rbp
cmpb $0x0, (%r14)
je 0x22a51
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x18(%rax)
movzbl (%r14), %r12d
cmpl %r12d, %eax
jne 0x22a5a
incq %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
jmp 0x22a29
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movl $0x90, %edi
callq 0x13260
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
movl %r12d, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x52996
leaq 0xf7f34(%rip), %rsi # 0x11a9b8
leaq 0x2813(%rip), %rdx # 0x2529e
movq %r14, %rdi
callq 0x13910
movq %rax, %rbx
movq %r14, %rdi
callq 0x13380
movq %rbx, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/CharScanner.hpp |
antlr::CharScanner::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual void match(const ANTLR_USE_NAMESPACE(std)string& s)
{
size_t len = s.length();
for (size_t i = 0; i < len; i++)
{
// the & 0xFF is here to prevent sign extension lateron
int la_1 = LA(1), c = (s[i] & 0xFF);
if ( la_1 != c )
throw MismatchedCharException(la_1, c, false, this);
consume();
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x22aec
movq (%rbx), %rax
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq *0x18(%rax)
movl %eax, %r15d
movq (%r14), %rax
movzbl (%rax,%rbp), %r12d
cmpl %r12d, %r15d
jne 0x22afb
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
incq %rbp
jmp 0x22abd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x90, %edi
callq 0x13260
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
movl %r12d, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x52996
leaq 0xf7e96(%rip), %rsi # 0x11a9b8
leaq 0x2775(%rip), %rdx # 0x2529e
movq %r14, %rdi
callq 0x13910
movq %rax, %rbx
movq %r14, %rdi
callq 0x13380
movq %rbx, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/CharScanner.hpp |
antlr::CharScanner::testLiteralsTable(int) const | virtual int testLiteralsTable(int ttype) const
{
ANTLR_USE_NAMESPACE(std)map<ANTLR_USE_NAMESPACE(std)string,int,CharScannerLiteralsLess>::const_iterator i = literals.find(text);
if (i != literals.end())
ttype = (*i).second;
return ttype;
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addq $0x40, %rdi
leaq 0x8(%r14), %rsi
callq 0x2530a
addq $0x48, %r14
cmpq %r14, %rax
je 0x22d68
movl 0x40(%rax), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /OpenMD[P]OpenMD/src/antlr/CharScanner.hpp |
OpenMD::SimplePreprocessor::doPreprocess(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::ostream&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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>>>>&, std::stack<bool, std::deque<bool, std::allocator<bool>>>&) | bool doPreprocess(std::istream& myStream, const std::string& filename, int startingLine, ostream& os, std::set<std::string>& defineSet, std::stack<bool>& ifStates) {
//std::ifstream input(filename.c_str());
//if (!input.is_open()) {
// std::stringstream ss;
// ss << "Can not open " << filename << " for preprocessing\n";
//
// snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
// "Can not open (%s) for processing. \n"
// "\tPlease check md file name syntax.\n", filename.c_str());
//
// painCave.isFatal = 1;
// simError();
//
// throw OpenMDException(ss.str());
//}
int lineNo = startingLine;
os << "#line " << lineNo << " \"" << filename << "\"\n";
const int bufferSize = 8192;
char buffer[bufferSize];
while(myStream.getline(buffer, bufferSize)) {
++lineNo;
std::string line = Utils::trimLeftCopy(buffer);
if (!line.empty() && line[0] == '#') {
StringTokenizer tokenizer(line.substr(1, line.length()));
std::vector<std::string> tokens = tokenizer.getAllTokens();
if (tokens.empty()) {
return false;
}
if (tokens[0] == "endif") {
ifStates.pop();
if (ifStates.empty()) {
std::cout << "Error in preprocessing: endif \n";
return false;
}
os << std::endl;
} else if (tokens.size() == 2) {
if (tokens[0] == "include") {
SimplePreprocessor subPreprocessor;
std::string includeFilename = tokens[1];
includeFilename = includeFilename.substr(1, includeFilename.length() -2);
std::ifstream includeStream(includeFilename.c_str());
if (!includeStream.is_open()) {
std::stringstream ss;
ss << "Can not open " << includeFilename << " for preprocessing\n";
throw OpenMDException(ss.str());
}
bool ret = subPreprocessor.doPreprocess(includeStream, includeFilename, 1, os, defineSet, ifStates);
if (!ret) {
std::cout << "Error in preprocessing\n";
return false;
}
os << "#line " << lineNo << " \"" << filename << "\"\n";
} else if (tokens[0] == "define") {
defineSet.insert(tokens[1]);
os << std::endl;
} else if (tokens[0] == "undef") {
defineSet.erase(tokens[1]);
os << std::endl;
} else if (tokens[0] == "ifdef") {
if (defineSet.find(tokens[1]) != defineSet.end() ) {
ifStates.push(true);
} else {
ifStates.push(false);
}
os << std::endl;
} else if (tokens[0] == "ifndef") {
if (defineSet.find(tokens[1]) == defineSet.end() ) {
ifStates.push(true);
} else {
ifStates.push(false);
}
os << std::endl;
} else {
std::cout << tokens[0] << " is not supported (yet)." << std::endl;
return false;
}
}else {
return false;
}
}else if (ifStates.top()){
os << buffer << std::endl;
}
}
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x24c8, %rsp # imm = 0x24C8
movq %r9, %r14
movq %r8, %rdi
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, 0x50(%rsp)
movq 0x2500(%rsp), %r15
leaq 0xa38b9(%rip), %rsi # 0xc672b
movq %r8, 0x38(%rsp)
callq 0x134b0
movq %rax, %rdi
movl %ebp, %esi
callq 0x13920
leaq 0xa38a5(%rip), %rsi # 0xc6732
movq %rax, %rdi
callq 0x134b0
movq %rax, %rdi
movq %rbx, 0x48(%rsp)
movq %rbx, %rsi
callq 0x13450
leaq 0xa31e5(%rip), %rsi # 0xc6091
movq %rax, %rdi
callq 0x134b0
movq %r14, 0x10(%rsp)
leaq 0x8(%r14), %rax
movq %rax, 0x40(%rsp)
incl %ebp
movl %ebp, 0x1c(%rsp)
leaq 0x4c0(%rsp), %rbx
leaq 0x338(%rsp), %rbp
leaq 0x130(%rsp), %r14
movl $0x2000, %edx # imm = 0x2000
movq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x13190
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %r12d
testb $0x5, %r12b
jne 0x232f4
movq %rbp, %rdx
leaq 0xb8(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %r13
movq %rbx, %rsi
movq %rdx, %rbx
callq 0x1a8b4
movq %r14, %rdi
callq 0x13a70
leaq 0x78(%rsp), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x224dc
movq %r14, %rdi
callq 0x13730
movq %rbp, %rdi
callq 0x13a98
movq 0x80(%rsp), %rcx
testq %rcx, %rcx
je 0x2300a
movq 0x78(%rsp), %rax
cmpb $0x23, (%rax)
jne 0x2300a
movq %r14, %rdi
leaq 0x78(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x13510
movq %rbx, %rbp
movq %rbx, %rdi
leaq 0xa20fd(%rip), %rsi # 0xc5085
leaq 0x58(%rsp), %rdx
callq 0x1a8b4
leaq 0xd8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xb9030
movq %rbp, %rdi
callq 0x13a98
movq %r14, %rdi
callq 0x13a98
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0xb9570
movq 0x20(%rsp), %rdi
cmpq 0x28(%rsp), %rdi
je 0x232d3
leaq 0xa3759(%rip), %rsi # 0xc6735
callq 0x2251c
testb %al, %al
je 0x2304b
movq %r15, %rdi
callq 0x2393a
movq 0x30(%r15), %rax
cmpq 0x10(%r15), %rax
je 0x232c0
movq 0x38(%rsp), %rdi
callq 0x13250
jmp 0x2317d
movq 0x30(%r15), %rax
cmpq 0x38(%r15), %rax
movq %rbx, %rbp
jne 0x23027
movq 0x48(%r15), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx # imm = 0x200
addq %rcx, %rax
cmpb $0x1, -0x1(%rax)
jne 0x23194
movq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x134b0
movq %rax, %rdi
callq 0x13250
jmp 0x23194
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
subq %rdi, %rax
cmpq $0x40, %rax
jne 0x232d3
leaq 0xa36f2(%rip), %rsi # 0xc675b
callq 0x2251c
testb %al, %al
je 0x231aa
movq 0x20(%rsp), %rsi
addq $0x20, %rsi
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x13700
movq 0x60(%rsp), %rcx
addq $-0x2, %rcx
movq %r14, %rdi
movq %rbx, %rsi
pushq $0x1
popq %rdx
callq 0x13510
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13620
movq %r14, %rdi
callq 0x13a98
movq 0x58(%rsp), %rsi
movq %r14, %rdi
pushq $0x8
popq %rdx
callq 0x139b0
leaq 0x1a8(%rsp), %rdi
callq 0x13130
testb %al, %al
je 0x23332
movq %r15, (%rsp)
leaq 0xf(%rsp), %rdi
movq %r14, %rsi
leaq 0x58(%rsp), %rdx
pushq $0x1
popq %rcx
movq 0x38(%rsp), %r8
movq %r8, %r15
movq 0x10(%rsp), %r9
callq 0x22e42
movl %eax, %ebx
movq 0xfaea6(%rip), %rax # 0x11dfb0
leaq 0xa3674(%rip), %rsi # 0xc6785
testb %bl, %bl
je 0x23153
movq %r15, %rdi
leaq 0xa360c(%rip), %rsi # 0xc672b
callq 0x134b0
movq %rax, %rdi
movl 0x1c(%rsp), %esi
callq 0x13920
movq %rax, %rdi
leaq 0xa35f8(%rip), %rsi # 0xc6732
callq 0x134b0
movq %rax, %rdi
movq 0x48(%rsp), %rsi
callq 0x13450
leaq 0xa2f3e(%rip), %rsi # 0xc6091
movq %rax, %rdi
callq 0x134b0
movq %r14, %rdi
callq 0x13160
leaq 0x58(%rsp), %rdi
callq 0x13a98
testb %bl, %bl
movq 0x2500(%rsp), %r15
je 0x232d3
leaq 0x20(%rsp), %rdi
callq 0x1d0d0
leaq 0xd8(%rsp), %rdi
callq 0x1a91c
leaq 0x78(%rsp), %rdi
callq 0x13a98
incl 0x1c(%rsp)
movq %r13, %rbx
jmp 0x22ee0
movq 0x20(%rsp), %rdi
leaq 0xa35e7(%rip), %rsi # 0xc679d
callq 0x2251c
movq 0x20(%rsp), %rsi
testb %al, %al
je 0x231d7
addq $0x20, %rsi
movq 0x10(%rsp), %rdi
callq 0x239aa
jmp 0x22ffb
movq %rsi, %rdi
leaq 0xa35c3(%rip), %rsi # 0xc67a4
callq 0x2251c
movq 0x20(%rsp), %rsi
testb %al, %al
je 0x23202
addq $0x20, %rsi
movq 0x10(%rsp), %rdi
callq 0x23b88
jmp 0x22ffb
movq %rsi, %rdi
leaq 0xa359e(%rip), %rsi # 0xc67aa
callq 0x2251c
movq 0x20(%rsp), %rsi
testb %al, %al
je 0x23247
addq $0x20, %rsi
movq 0x10(%rsp), %rdi
callq 0x23dda
cmpq 0x40(%rsp), %rax
je 0x23290
movb $0x1, 0x130(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x23698
jmp 0x22ffb
movq %rsi, %rdi
leaq 0xa355f(%rip), %rsi # 0xc67b0
callq 0x2251c
movq 0x20(%rsp), %rsi
testb %al, %al
je 0x2330d
addq $0x20, %rsi
movq 0x10(%rsp), %rdi
callq 0x23dda
cmpq 0x40(%rsp), %rax
je 0x232a8
movb $0x0, 0x130(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x23698
jmp 0x22ffb
movb $0x0, 0x130(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x23698
jmp 0x22ffb
movb $0x1, 0x130(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x23698
jmp 0x22ffb
movq 0xface9(%rip), %rdi # 0x11dfb0
leaq 0xa346d(%rip), %rsi # 0xc673b
callq 0x134b0
leaq 0x20(%rsp), %rdi
callq 0x1d0d0
leaq 0xd8(%rsp), %rdi
callq 0x1a91c
leaq 0x78(%rsp), %rdi
callq 0x13a98
testb $0x5, %r12b
setne %al
addq $0x24c8, %rsp # imm = 0x24C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xfac9c(%rip), %rdi # 0x11dfb0
callq 0x13450
leaq 0xa3497(%rip), %rsi # 0xc67b7
movq %rax, %rdi
callq 0x134b0
movq %rax, %rdi
callq 0x13250
jmp 0x232d3
leaq 0x338(%rsp), %rdi
callq 0x13350
leaq 0x348(%rsp), %rdi
leaq 0xa3415(%rip), %rsi # 0xc6763
callq 0x134b0
leaq 0x58(%rsp), %rsi
movq %rax, %rdi
callq 0x13450
leaq 0xa340a(%rip), %rsi # 0xc6771
movq %rax, %rdi
callq 0x134b0
pushq $0x28
popq %rdi
callq 0x13260
movq %rax, %r14
leaq 0x350(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x13800
movb $0x1, %bpl
leaq 0x98(%rsp), %rsi
movq %r14, %rdi
callq 0x238e4
xorl %ebp, %ebp
leaq 0xf6775(%rip), %rsi # 0x119b20
leaq 0x568(%rip), %rdx # 0x2391a
movq %r14, %rdi
callq 0x13910
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x13a98
testb %bpl, %bpl
jne 0x233d4
jmp 0x233ef
movq %rax, %rbx
movq %r14, %rdi
callq 0x13380
jmp 0x233ef
jmp 0x23409
jmp 0x23409
jmp 0x23409
jmp 0x23409
jmp 0x23409
jmp 0x23409
jmp 0x23409
movq %rax, %rbx
leaq 0x338(%rsp), %rdi
callq 0x13390
jmp 0x23411
jmp 0x2340e
jmp 0x23402
movq %rax, %rbx
jmp 0x2341e
jmp 0x23409
movq %rax, %rbx
jmp 0x23428
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
callq 0x13160
leaq 0x58(%rsp), %rdi
callq 0x13a98
leaq 0x20(%rsp), %rdi
callq 0x1d0d0
jmp 0x23437
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x1a91c
jmp 0x2346f
movq %rax, %rbx
leaq 0x338(%rsp), %rdi
callq 0x13a98
jmp 0x2345b
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
callq 0x13a98
jmp 0x2346f
jmp 0x2346c
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0x23493
movq %rax, %rbx
jmp 0x23498
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
callq 0x13730
leaq 0xb8(%rsp), %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/mdParser/SimplePreprocessor.hpp |
antlr::TreeParser::matchNot(antlr::ASTRefCount<antlr::AST>, int) | virtual void matchNot(RefAST t, int ttype)
{
if ( !t || t == ASTNULL || t->getType() == ttype )
throw MismatchedTokenException( getTokenNames(), getNumTokens(),
t, ttype, true );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
testq %rax, %rax
je 0x243ec
movq (%rax), %rdi
testq %rdi, %rdi
je 0x243ec
leaq 0xfc563(%rip), %rax # 0x120928
movq (%rax), %rax
testq %rax, %rax
je 0x243d2
cmpq (%rax), %rdi
je 0x243ec
movq (%rdi), %rax
callq *0x80(%rax)
cmpl %ebp, %eax
je 0x243ec
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xc8, %edi
callq 0x13260
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq (%r14), %rdx
testq %rdx, %rdx
je 0x24419
incl 0x8(%rdx)
leaq 0x8(%rsp), %rcx
movq %rdx, (%rcx)
movb $0x1, %r15b
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
movl %ebp, %r8d
callq 0x534ec
xorl %r15d, %r15d
leaq 0xf65de(%rip), %rsi # 0x11aa20
leaq 0xb1(%rip), %rdx # 0x244fa
movq %rbx, %rdi
callq 0x13910
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x22462
testb %r15b, %r15b
jne 0x24468
jmp 0x24470
movq %rax, %r14
movq %rbx, %rdi
callq 0x13380
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/TreeParser.hpp |
OpenMD::CutoffGroup::getMass() | RealType getMass() {
if (!haveTotalMass) {
totalMass = 0.0;
std::vector<Atom*>::iterator i;
for (Atom* atom = beginAtom(i); atom != NULL; atom = nextAtom(i)) {
RealType mass = atom->getMass();
totalMass += mass;
}
haveTotalMass = true;
}
return totalMass;
} | cmpb $0x1, 0x18(%rdi)
jne 0x27e78
movsd 0x20(%rdi), %xmm0
retq
andq $0x0, 0x20(%rdi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
jne 0x27eac
xorl %edx, %edx
testq %rdx, %rdx
je 0x27eb1
addsd 0x38(%rdx), %xmm0
movsd %xmm0, 0x20(%rdi)
addq $0x8, %rax
movl $0x0, %edx
cmpq %rcx, %rax
je 0x27e8f
movq (%rax), %rdx
jmp 0x27e8f
movb $0x1, 0x18(%rdi)
retq
| /OpenMD[P]OpenMD/src/primitives/CutoffGroup.hpp |
OpenMD::DumpReader::readFrame(int) | void DumpReader::readFrame(int whichFrame) {
if (!isScanned_) scanFile();
int asl = info_->getSnapshotManager()->getAtomStorageLayout();
int rbsl = info_->getSnapshotManager()->getRigidBodyStorageLayout();
needPos_ =
(asl & DataStorage::dslPosition || rbsl & DataStorage::dslPosition) ?
true :
false;
needVel_ =
(asl & DataStorage::dslVelocity || rbsl & DataStorage::dslVelocity) ?
true :
false;
needQuaternion_ =
(asl & DataStorage::dslAmat || asl & DataStorage::dslDipole ||
asl & DataStorage::dslQuadrupole || rbsl & DataStorage::dslAmat ||
rbsl & DataStorage::dslDipole || rbsl & DataStorage::dslQuadrupole) ?
true :
false;
needAngMom_ = (asl & DataStorage::dslAngularMomentum ||
rbsl & DataStorage::dslAngularMomentum) ?
true :
false;
// some dump files contain the efield, but we should only parse
// and set the field if we have actually allocated memory for it
readField_ = (asl & DataStorage::dslElectricField) ? true : false;
readSet(whichFrame);
if (needCOMprops_) {
Thermo thermo(info_);
Vector3d com;
if (needPos_ && needVel_) {
Vector3d comvel;
Vector3d comw;
thermo.getComAll(com, comvel);
comw = thermo.getAngularMomentum();
} else {
com = thermo.getCom();
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x28(%rdi)
jne 0x29e6d
movq %rbx, %rdi
callq 0x29b9a
movq (%rbx), %rax
movq 0x2f8(%rax), %rcx
movl 0x8(%rcx), %eax
movl 0xc(%rcx), %edx
movl %edx, %ecx
orl %eax, %ecx
movl %ecx, %esi
andb $0x1, %sil
movb %sil, 0x250(%rbx)
movl %ecx, %esi
shrb %sil
andb $0x1, %sil
movl %eax, %edi
andl $0xc08, %edi # imm = 0xC08
movl %edx, %r8d
andl $0x408, %r8d # imm = 0x408
shrl $0xb, %edx
andb $0x1, %dl
orl %edi, %r8d
movzbl %dl, %edx
pushq $0x1
popq %rdi
cmovel %edx, %edi
movb %sil, 0x251(%rbx)
movb %dil, 0x252(%rbx)
shrb $0x4, %cl
andb $0x1, %cl
movb %cl, 0x253(%rbx)
shrl $0xc, %eax
andb $0x1, %al
movb %al, 0x255(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x29f84
cmpb $0x1, 0x254(%rbx)
jne 0x29f79
movq (%rbx), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1b928
cmpb $0x1, 0x250(%rbx)
jne 0x29f5c
cmpb $0x1, 0x251(%rbx)
jne 0x29f5c
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x1b928
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x1b928
movq %rsp, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x4d87e
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e0cc
movq %r14, %rdi
jmp 0x29f71
leaq 0x20(%rsp), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4d754
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1aff0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /OpenMD[P]OpenMD/src/io/DumpReader.cpp |
OpenMD::DumpReader::readFrameProperties(std::istream&) | void DumpReader::readFrameProperties(std::istream& inputStream) {
Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
// We're about to overwrite all frame properties, so clear out any
// derived properties from previous use:
s->clearDerivedProperties();
inputStream.getline(buffer, bufferSize);
std::string line(buffer);
if (line.find("<FrameData>") == std::string::npos) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"DumpReader Error: Missing <FrameData>\n");
painCave.isFatal = 1;
simError();
}
while (inputStream.getline(buffer, bufferSize)) {
line = buffer;
if (line.find("</FrameData>") != std::string::npos) { break; }
StringTokenizer tokenizer(line, " ;\t\n\r{}:,");
if (!tokenizer.hasMoreTokens()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
painCave.isFatal = 1;
simError();
}
std::string propertyName = tokenizer.nextToken();
if (propertyName == "Time") {
RealType currTime = tokenizer.nextTokenAsDouble();
s->setTime(currTime);
} else if (propertyName == "Hmat") {
Mat3x3d hmat;
hmat(0, 0) = tokenizer.nextTokenAsDouble();
hmat(0, 1) = tokenizer.nextTokenAsDouble();
hmat(0, 2) = tokenizer.nextTokenAsDouble();
hmat(1, 0) = tokenizer.nextTokenAsDouble();
hmat(1, 1) = tokenizer.nextTokenAsDouble();
hmat(1, 2) = tokenizer.nextTokenAsDouble();
hmat(2, 0) = tokenizer.nextTokenAsDouble();
hmat(2, 1) = tokenizer.nextTokenAsDouble();
hmat(2, 2) = tokenizer.nextTokenAsDouble();
s->setHmat(hmat);
} else if (propertyName == "Thermostat") {
pair<RealType, RealType> thermostat;
thermostat.first = tokenizer.nextTokenAsDouble();
thermostat.second = tokenizer.nextTokenAsDouble();
s->setThermostat(thermostat);
} else if (propertyName == "Barostat") {
Mat3x3d eta;
eta(0, 0) = tokenizer.nextTokenAsDouble();
eta(0, 1) = tokenizer.nextTokenAsDouble();
eta(0, 2) = tokenizer.nextTokenAsDouble();
eta(1, 0) = tokenizer.nextTokenAsDouble();
eta(1, 1) = tokenizer.nextTokenAsDouble();
eta(1, 2) = tokenizer.nextTokenAsDouble();
eta(2, 0) = tokenizer.nextTokenAsDouble();
eta(2, 1) = tokenizer.nextTokenAsDouble();
eta(2, 2) = tokenizer.nextTokenAsDouble();
s->setBarostat(eta);
} else if (propertyName == "SPFData") {
std::shared_ptr<SPFData> spfData = s->getSPFData();
spfData->pos[0] = tokenizer.nextTokenAsDouble();
spfData->pos[1] = tokenizer.nextTokenAsDouble();
spfData->pos[2] = tokenizer.nextTokenAsDouble();
spfData->lambda = tokenizer.nextTokenAsDouble();
spfData->globalID = tokenizer.nextTokenAsInt();
} else {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"DumpReader Error: %s is an invalid property in <FrameData>\n",
propertyName.c_str());
painCave.isFatal = 0;
simError();
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x2f8(%rax), %rax
movq 0x18(%rax), %rdi
movq %rdi, 0x8(%rsp)
callq 0x629ee
addq $0x256, %r14 # imm = 0x256
movl $0x1000, %edx # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13190
leaq 0x60(%rsp), %r15
leaq 0xa0(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a8b4
leaq 0x9cddd(%rip), %rsi # 0xc6fa0
movq %r15, %rdi
xorl %edx, %edx
callq 0x13a60
cmpq $-0x1, %rax
jne 0x2a20c
movups 0x9cde2(%rip), %xmm0 # 0xc6fbc
leaq 0xf4ec3(%rip), %rax # 0x11f0a4
movups %xmm0, 0x10(%rax)
movups 0x9cdc0(%rip), %xmm0 # 0xc6fac
movups %xmm0, (%rax)
movabsq $0xa3e6174614465, %rcx # imm = 0xA3E6174614465
movq %rcx, 0x1f(%rax)
movl $0x1, 0x7d0(%rax)
callq 0x2beaa
leaq 0x60(%rsp), %r13
leaq 0x10(%rsp), %r12
leaq 0x80(%rsp), %rbp
leaq 0xa0(%rsp), %r15
movq %rbx, 0x58(%rsp)
movl $0x1000, %edx # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13190
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2a587
movq %r13, %rdi
movq %r14, %rsi
callq 0x13a20
movq %r13, %rdi
leaq 0x9cd71(%rip), %rsi # 0xc6fd3
xorl %edx, %edx
callq 0x13a60
cmpq $-0x1, %rax
jne 0x2a587
movq %r12, %rdi
leaq 0x9cd63(%rip), %rsi # 0xc6fe0
movq %rbp, %rdx
callq 0x1a8b4
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xb9030
movq %r12, %rdi
callq 0x13a98
movq %r15, %rdi
callq 0xb91a0
testb %al, %al
jne 0x2a2dd
movq 0x60(%rsp), %rcx
movl $0x7d0, %esi # imm = 0x7D0
leaq 0xf4dec(%rip), %rbx # 0x11f0a4
movq %rbx, %rdi
leaq 0x9cb3e(%rip), %rdx # 0xc6e00
xorl %eax, %eax
callq 0x13830
movl $0x1, 0x7d0(%rbx)
movq 0x58(%rsp), %rbx
callq 0x2beaa
movq %rbp, %rdi
movq %r15, %rsi
callq 0xb91ec
movq %rbp, %rdi
leaq 0xa6cac(%rip), %rsi # 0xd0f9e
callq 0x2251c
testb %al, %al
je 0x2a312
movq %r15, %rdi
callq 0xb9476
movq 0x8(%rsp), %rdi
callq 0x633ba
jmp 0x2a572
movq %rbp, %rdi
leaq 0x9ccce(%rip), %rsi # 0xc6fea
callq 0x2251c
testb %al, %al
je 0x2a3c1
movq %r12, %rdi
callq 0x1e636
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x30(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x40(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x48(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x50(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x62e48
jmp 0x2a572
movq %rbp, %rdi
leaq 0xa1194(%rip), %rsi # 0xcb55f
callq 0x2251c
testb %al, %al
je 0x2a40a
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x63a10
jmp 0x2a572
movq %rbp, %rdi
leaq 0xa1dba(%rip), %rsi # 0xcc1ce
callq 0x2251c
testb %al, %al
je 0x2a4b9
movq %r12, %rdi
callq 0x1e636
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x30(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x40(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x48(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x50(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x63a4c
jmp 0x2a572
movq %rbp, %rdi
leaq 0x9cb2c(%rip), %rsi # 0xc6fef
callq 0x2251c
testb %al, %al
je 0x2a53c
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x63a7a
movq %r15, %rdi
callq 0xb9476
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq %r15, %rdi
callq 0xb9476
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq %r15, %rdi
callq 0xb9476
movq 0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq %r15, %rdi
callq 0xb9476
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq %r15, %rdi
callq 0xb93d6
movq 0x10(%rsp), %rcx
movl %eax, 0x20(%rcx)
leaq 0x18(%rsp), %rdi
callq 0x28296
jmp 0x2a572
movq 0x80(%rsp), %rcx
movl $0x7d0, %esi # imm = 0x7D0
leaq 0xf4b54(%rip), %rbx # 0x11f0a4
movq %rbx, %rdi
leaq 0x9ca9d(%rip), %rdx # 0xc6ff7
xorl %eax, %eax
callq 0x13830
andl $0x0, 0x7d0(%rbx)
movq 0x58(%rsp), %rbx
callq 0x2beaa
movq %rbp, %rdi
callq 0x13a98
movq %r15, %rdi
callq 0x1a91c
jmp 0x2a22b
leaq 0x60(%rsp), %rdi
callq 0x13a98
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a5da
jmp 0x2a5df
jmp 0x2a5df
jmp 0x2a5df
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x28296
jmp 0x2a5e2
jmp 0x2a5df
jmp 0x2a5df
jmp 0x2a5df
jmp 0x2a5da
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13a98
jmp 0x2a5fc
jmp 0x2a5df
jmp 0x2a5d5
movq %rax, %rbx
jmp 0x2a5ef
movq %rax, %rbx
jmp 0x2a5fc
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x13a98
leaq 0xa0(%rsp), %rdi
callq 0x1a91c
leaq 0x60(%rsp), %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/io/DumpReader.cpp |
OpenMD::DumpReader::readStuntDoubles(std::istream&) | int DumpReader::readStuntDoubles(std::istream& inputStream) {
inputStream.getline(buffer, bufferSize);
std::string line(buffer);
if (line.find("<StuntDoubles>") == std::string::npos) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"DumpReader Error: Missing <StuntDoubles>\n");
painCave.isFatal = 1;
simError();
}
int nSD = 0;
while (inputStream.getline(buffer, bufferSize)) {
line = buffer;
if (line.find("</StuntDoubles>") != std::string::npos) { break; }
parseDumpLine(line);
nSD++;
}
return nSD;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x256(%rdi), %r15
movl $0x1000, %edx # imm = 0x1000
movq %rsi, %rdi
movq %r15, %rsi
callq 0x13190
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x1a8b4
leaq 0x9c8f6(%rip), %rsi # 0xc6f4b
xorl %r12d, %r12d
movq %r13, %rdi
xorl %edx, %edx
callq 0x13a60
cmpq $-0x1, %rax
jne 0x2a69e
movups 0x9c905(%rip), %xmm0 # 0xc6f74
leaq 0xf4a2e(%rip), %rax # 0x11f0a4
movups %xmm0, 0x1a(%rax)
movups 0x9c8e9(%rip), %xmm0 # 0xc6f6a
movups %xmm0, 0x10(%rax)
movups 0x9c8ce(%rip), %xmm0 # 0xc6f5a
movups %xmm0, (%rax)
movl $0x1, 0x7d0(%rax)
callq 0x2beaa
leaq 0x8(%rsp), %r13
leaq 0x9c8da(%rip), %rbp # 0xc6f84
movl $0x1000, %edx # imm = 0x1000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13190
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2a6f6
movq %r13, %rdi
movq %r15, %rsi
callq 0x13a20
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x13a60
cmpq $-0x1, %rax
jne 0x2a6f6
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a7d6
incl %r12d
jmp 0x2a6aa
leaq 0x8(%rsp), %rdi
callq 0x13a98
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a714
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13960
nop
| /OpenMD[P]OpenMD/src/io/DumpReader.cpp |
OpenMD::DumpReader::parseSiteLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void DumpReader::parseSiteLine(const std::string& line) {
StringTokenizer tokenizer(line);
int nTokens;
nTokens = tokenizer.countTokens();
if (nTokens < 1) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
painCave.isFatal = 1;
simError();
}
/**
* The first token is the global integrable object index.
*/
int index = tokenizer.nextTokenAsInt();
StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
if (sd == NULL) { return; }
// StuntDoubles have a line even if there is nothing stored in the
// site data:
if (nTokens == 1) { return; }
/**
* Test to see if the next token is an integer or not. If not,
* we've got data on the integrable object itself. If there is an
* integer, we're parsing data for a site on a rigid body.
*/
std::string indexTest = tokenizer.peekNextToken();
std::istringstream i(indexTest);
int siteIndex;
if (i >> siteIndex) {
// chew up this token and parse as an int:
siteIndex = tokenizer.nextTokenAsInt();
if (sd->isRigidBody()) {
RigidBody* rb = static_cast<RigidBody*>(sd);
// Sometimes site lines are inherited from other models, so
// just ignore a site line that exceeds the number of atoms in
// our RB:
if (siteIndex >= static_cast<int>(rb->getNumAtoms())) { return; }
sd = rb->getAtoms()[siteIndex];
}
}
/**
* The next token contains information on what follows.
*/
std::string type = tokenizer.nextToken();
int size = type.size();
for (int i = 0; i < size; ++i) {
switch (type[i]) {
case 'u': {
RealType particlePot;
particlePot = tokenizer.nextTokenAsDouble();
sd->setParticlePot(particlePot);
break;
}
case 'c': {
RealType flucQPos;
flucQPos = tokenizer.nextTokenAsDouble();
if (sd->isAtom())
if (dynamic_cast<Atom*>(sd)->isFluctuatingCharge())
sd->setFlucQPos(flucQPos);
break;
}
case 'w': {
RealType flucQVel;
flucQVel = tokenizer.nextTokenAsDouble();
if (sd->isAtom())
if (dynamic_cast<Atom*>(sd)->isFluctuatingCharge())
sd->setFlucQVel(flucQVel);
break;
}
case 'g': {
RealType flucQFrc;
flucQFrc = tokenizer.nextTokenAsDouble();
if (sd->isAtom())
if (dynamic_cast<Atom*>(sd)->isFluctuatingCharge())
sd->setFlucQFrc(flucQFrc);
break;
}
case 'e': {
Vector3d eField;
eField[0] = tokenizer.nextTokenAsDouble();
eField[1] = tokenizer.nextTokenAsDouble();
eField[2] = tokenizer.nextTokenAsDouble();
if (readField_) sd->setElectricField(eField);
break;
}
case 's': {
RealType sPot;
sPot = tokenizer.nextTokenAsDouble();
sd->setSitePotential(sPot);
break;
}
case 'd': {
RealType dens;
dens = tokenizer.nextTokenAsDouble();
sd->setDensity(dens);
break;
}
default: {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"DumpReader Error: %s is an unrecognized type\n",
type.c_str());
painCave.isFatal = 1;
simError();
break;
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x9a16f(%rip), %rsi # 0xc5085
leaq 0xc8(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x1a8b4
leaq 0x70(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
movq %r14, %rsi
callq 0xb9030
leaq 0xc8(%rsp), %rdi
callq 0x13a98
leaq 0x70(%rsp), %rdi
callq 0xb912e
movl %eax, %ebp
testl %eax, %eax
jg 0x2af8a
movq (%r14), %rcx
leaq 0xf4140(%rip), %r14 # 0x11f0a4
leaq 0x9be95(%rip), %rdx # 0xc6e00
movl $0x7d0, %esi # imm = 0x7D0
movq %r14, %rdi
xorl %eax, %eax
callq 0x13830
movl $0x1, 0x7d0(%r14)
callq 0x2beaa
leaq 0x70(%rsp), %rdi
callq 0xb93d6
movq 0x10(%rsp), %rcx
movq (%rcx), %rdi
movl %eax, %esi
callq 0x27b8e
movq %rax, %r14
testq %rax, %rax
sete %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
jne 0x2b2f9
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xb94b6
leaq 0xc8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x138c0
leaq 0xc8(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x132d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2b057
leaq 0x70(%rsp), %rdi
callq 0xb93d6
movl %eax, 0xc(%rsp)
cmpl $0x2, 0x8(%r14)
jne 0x2b057
movq 0x130(%r14), %rcx
subq 0x128(%r14), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jge 0x2b2e2
addq $0x128, %r14 # imm = 0x128
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x2843c
movslq 0xc(%rsp), %rax
leaq 0x18(%rsp), %rdi
movq (%rdi), %rcx
movq (%rcx,%rax,8), %r14
callq 0x2848a
leaq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xb91ec
movl 0x20(%rsp), %r13d
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
leaq 0x70(%rsp), %r15
leaq 0xf4024(%rip), %rbp # 0x11f0a4
leaq 0x9bb3d(%rip), %r12 # 0xc6bc4
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x2b2d8
movq 0x18(%rsp), %rcx
movzbl (%rcx,%rbx), %eax
leal -0x63(%rax), %edx
cmpl $0x4, %edx
ja 0x2b10e
movslq (%r12,%rdx,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r15, %rdi
callq 0xb9476
cmpl $0x1, 0x8(%r14)
ja 0x2b2d0
movq %r14, %rdi
leaq 0xeefdf(%rip), %rsi # 0x11a0a8
leaq 0xf1318(%rip), %rdx # 0x11c3e8
xorl %ecx, %ecx
movsd %xmm0, (%rsp)
callq 0x13590
movq %rax, %rdi
callq 0x27df0
movsd (%rsp), %xmm0
testb %al, %al
je 0x2b2d0
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
movslq 0x30(%r14), %rdx
movq 0x150(%rcx,%rax), %rax
jmp 0x2b2cb
cmpl $0x73, %eax
je 0x2b2ab
cmpl $0x75, %eax
je 0x2b289
cmpl $0x77, %eax
jne 0x2b187
movq %r15, %rdi
callq 0xb9476
cmpl $0x1, 0x8(%r14)
ja 0x2b2d0
movq %r14, %rdi
leaq 0xeef66(%rip), %rsi # 0x11a0a8
leaq 0xf129f(%rip), %rdx # 0x11c3e8
xorl %ecx, %ecx
movsd %xmm0, (%rsp)
callq 0x13590
movq %rax, %rdi
callq 0x27df0
movsd (%rsp), %xmm0
testb %al, %al
je 0x2b2d0
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
movslq 0x30(%r14), %rdx
movq 0x168(%rcx,%rax), %rax
jmp 0x2b2cb
movl $0x7d0, %esi # imm = 0x7D0
movq %rbp, %rdi
leaq 0x9bd87(%rip), %rdx # 0xc6f1d
xorl %eax, %eax
callq 0x13830
movl $0x1, 0x7d0(%rbp)
callq 0x2beaa
jmp 0x2b2d0
movq %r15, %rdi
callq 0xb9476
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
movslq 0x30(%r14), %rdx
movq 0xa8(%rcx,%rax), %rax
jmp 0x2b2cb
movq %r15, %rdi
callq 0xb9476
cmpl $0x1, 0x8(%r14)
ja 0x2b2d0
movq %r14, %rdi
leaq 0xeeeb5(%rip), %rsi # 0x11a0a8
leaq 0xf11ee(%rip), %rdx # 0x11c3e8
xorl %ecx, %ecx
movsd %xmm0, (%rsp)
callq 0x13590
movq %rax, %rdi
callq 0x27df0
movsd (%rsp), %xmm0
testb %al, %al
je 0x2b2d0
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
movslq 0x30(%r14), %rdx
movq 0x180(%rcx,%rax), %rax
jmp 0x2b2cb
leaq 0x38(%rsp), %rdi
callq 0x1b928
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x40(%rsp)
movq %r15, %rdi
callq 0xb9476
movsd %xmm0, 0x48(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x1, 0x255(%rax)
jne 0x2b2d0
movq %r14, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2b478
jmp 0x2b2d0
movq %r15, %rdi
callq 0xb9476
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
movslq 0x30(%r14), %rdx
movq 0x90(%rcx,%rax), %rax
jmp 0x2b2cb
movq %r15, %rdi
callq 0xb9476
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
movslq 0x30(%r14), %rdx
movq 0x198(%rcx,%rax), %rax
movsd %xmm0, (%rax,%rdx,8)
incq %rbx
jmp 0x2b089
leaq 0x18(%rsp), %rdi
callq 0x13a98
leaq 0xc8(%rsp), %rdi
callq 0x13230
leaq 0x50(%rsp), %rdi
callq 0x13a98
leaq 0x70(%rsp), %rdi
callq 0x1a91c
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b320
jmp 0x2b320
movq %rax, %rbx
jmp 0x2b36d
jmp 0x2b340
movq %rax, %rbx
jmp 0x2b360
jmp 0x2b340
jmp 0x2b340
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x13a98
jmp 0x2b381
movq %rax, %rbx
jmp 0x2b381
movq %rax, %rbx
jmp 0x2b377
jmp 0x2b353
jmp 0x2b353
jmp 0x2b353
jmp 0x2b353
jmp 0x2b353
jmp 0x2b353
jmp 0x2b353
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13a98
leaq 0xc8(%rsp), %rdi
callq 0x13230
leaq 0x50(%rsp), %rdi
callq 0x13a98
leaq 0x70(%rsp), %rdi
callq 0x1a91c
movq %rbx, %rdi
callq 0x13960
nop
| /OpenMD[P]OpenMD/src/io/DumpReader.cpp |
OpenMD::Quaternion<double>::toRotationMatrix3() | SquareMatrix<Real, 3> toRotationMatrix3() {
SquareMatrix<Real, 3> rotMat3;
Real w2;
Real x2;
Real y2;
Real z2;
if (!this->isNormalized()) this->normalize();
w2 = w() * w();
x2 = x() * x();
y2 = y() * y();
z2 = z() * z();
rotMat3(0, 0) = w2 + x2 - y2 - z2;
rotMat3(0, 1) = 2.0 * (x() * y() + w() * z());
rotMat3(0, 2) = 2.0 * (x() * z() - w() * y());
rotMat3(1, 0) = 2.0 * (x() * y() - w() * z());
rotMat3(1, 1) = w2 - x2 + y2 - z2;
rotMat3(1, 2) = 2.0 * (y() * z() + w() * x());
rotMat3(2, 0) = 2.0 * (x() * z() + w() * y());
rotMat3(2, 1) = 2.0 * (y() * z() - w() * x());
rotMat3(2, 2) = w2 - x2 - y2 + z2;
return rotMat3;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1e636
movq %r14, %rdi
callq 0x2b6e6
testb %al, %al
jne 0x2b583
movq %r14, %rdi
callq 0x2b3e2
movsd (%r14), %xmm7
movsd 0x18(%r14), %xmm0
movapd 0x9b5aa(%rip), %xmm6 # 0xc6b40
xorpd %xmm7, %xmm6
movupd 0x8(%r14), %xmm1
movapd %xmm1, %xmm4
movapd %xmm1, %xmm5
movapd %xmm1, %xmm3
movapd %xmm1, %xmm2
movapd %xmm1, %xmm10
movapd %xmm7, %xmm8
movapd %xmm1, %xmm9
movapd %xmm0, %xmm11
mulsd %xmm7, %xmm11
movapd %xmm1, %xmm12
movapd %xmm7, %xmm13
unpcklpd %xmm7, %xmm13 # xmm13 = xmm13[0],xmm7[0]
mulpd %xmm1, %xmm13
mulsd %xmm7, %xmm1
mulsd %xmm7, %xmm7
movapd %xmm0, %xmm14
mulsd %xmm0, %xmm14
mulsd %xmm5, %xmm5
mulpd %xmm2, %xmm2
unpckhpd %xmm2, %xmm2 # xmm2 = xmm2[1,1]
movapd %xmm7, %xmm15
addsd %xmm5, %xmm15
subsd %xmm2, %xmm15
subsd %xmm14, %xmm15
movsd %xmm15, (%rbx)
unpcklpd %xmm6, %xmm8 # xmm8 = xmm8[0],xmm6[0]
movsd %xmm0, %xmm10 # xmm10 = xmm0[0],xmm10[1]
mulpd %xmm10, %xmm8
shufpd $0x1, %xmm4, %xmm4 # xmm4 = xmm4[1,0]
unpcklpd %xmm0, %xmm9 # xmm9 = xmm9[0],xmm0[0]
mulpd %xmm4, %xmm9
addpd %xmm8, %xmm9
unpckhpd %xmm3, %xmm3 # xmm3 = xmm3[1,1]
addpd %xmm9, %xmm9
movupd %xmm9, 0x8(%rbx)
mulsd %xmm3, %xmm12
subsd %xmm11, %xmm12
addsd %xmm12, %xmm12
movsd %xmm12, 0x18(%rbx)
subsd %xmm5, %xmm7
movapd %xmm7, %xmm5
addsd %xmm2, %xmm5
subsd %xmm14, %xmm5
movsd %xmm5, 0x20(%rbx)
mulsd %xmm0, %xmm3
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
mulpd %xmm4, %xmm0
addpd %xmm13, %xmm0
addpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rbx)
subsd %xmm1, %xmm3
addsd %xmm3, %xmm3
movsd %xmm3, 0x38(%rbx)
subsd %xmm2, %xmm7
addsd %xmm14, %xmm7
movsd %xmm7, 0x40(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /OpenMD[P]OpenMD/src/math/Quaternion.hpp |
OpenMD::Utils::RandNumGen::RandNumGen(unsigned long) | RandNumGen::RandNumGen(result_type seed) {
int worldRank {};
int nProcessors {1};
#ifdef IS_MPI
MPI_Comm_rank(MPI_COMM_WORLD, &worldRank);
MPI_Comm_size(MPI_COMM_WORLD, &nProcessors);
#endif
result_type result;
std::vector<result_type> seeds(nProcessors);
#ifdef IS_MPI
if (worldRank == 0) {
#endif
std::vector<result_type> initalSequence(nProcessors);
std::iota(initalSequence.begin(), initalSequence.end(), seed);
// Generate the seed_seq to initialize the RNG on each processor
std::seed_seq seq(initalSequence.begin(), initalSequence.end());
seq.generate(seeds.begin(), seeds.end());
#ifdef IS_MPI
}
MPI_Bcast(&seeds[0], nProcessors, MPI_UINT32_T, 0, MPI_COMM_WORLD);
#endif
result = seeds[worldRank];
engine = std::mt19937(result);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x13d0, %rsp # imm = 0x13D0
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2b9c8
movq %rsp, %rdi
pushq $0x1
popq %r15
leaq 0x48(%rsp), %rdx
movq %r15, %rsi
callq 0x2b9d2
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r15, %rsi
callq 0x2b9d2
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rsi, %rax
cmpq %rdx, %rax
je 0x2b92b
movq %r14, (%rax)
incq %r14
addq $0x8, %rax
jmp 0x2b91a
leaq 0x30(%rsp), %rdi
callq 0x2ba24
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x2ba92
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0x48(%rsp), %rdi
callq 0x2bcd8
leaq 0x48(%rsp), %rsi
movl $0x1388, %edx # imm = 0x1388
movq %rbx, %rdi
callq 0x133f0
leaq 0x30(%rsp), %rdi
callq 0x1b552
leaq 0x18(%rsp), %rdi
callq 0x2bd3c
movq %rsp, %rdi
callq 0x2bd3c
addq $0x13d0, %rsp # imm = 0x13D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2b996
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1b552
jmp 0x2b9a8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2bd3c
jmp 0x2b9b7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2bd3c
movq %rbx, %rdi
callq 0x13960
nop
| /OpenMD[P]OpenMD/src/utils/RandNumGen.cpp |
antlr::CharScanner::CharScanner(antlr::InputBuffer&, bool) | CharScanner::CharScanner(InputBuffer& cb, bool case_sensitive )
: saveConsumedInput(true) //, caseSensitiveLiterals(true)
, caseSensitive(case_sensitive)
, literals(CharScannerLiteralsLess(this))
, inputState(new LexerInputState(cb))
, commitToPath(false)
, tabsize(8)
, traceDepth(0)
{
setTokenObjectFactory(&CommonToken::factory);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xedb7a(%rip), %rax # 0x119b48
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
movb $0x0, 0x18(%rdi)
movb $0x1, 0x28(%rdi)
movb %dl, 0x38(%rdi)
movq %rdi, 0x40(%rdi)
andl $0x0, 0x48(%rdi)
leaq 0x48(%rdi), %rax
andq $0x0, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rax, 0x60(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rdi)
pushq $0x50
popq %rdi
callq 0x134d0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x2c468
leaq 0x78(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2c4b2
movb $0x0, 0x80(%rbx)
movq $0x8, 0x84(%rbx)
movq (%rbx), %rax
leaq 0x26277(%rip), %rsi # 0x522c4
movq %rbx, %rdi
callq *0x150(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x24ece
jmp 0x2c082
movq %rax, %r14
pushq $0x50
popq %rsi
movq %r12, %rdi
callq 0x134e0
jmp 0x2c082
movq %rax, %r14
leaq 0x8(%rbx), %r15
leaq 0x40(%rbx), %r12
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x2476c
movq %r12, %rdi
callq 0x24ef8
movq %r15, %rdi
callq 0x13a98
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/CharScanner.cpp |
antlr::CharScanner::reportError(antlr::RecognitionException const&) | void CharScanner::reportError(const RecognitionException& ex)
{
ANTLR_USE_NAMESPACE(std)cerr << ex.toString().c_str() << ANTLR_USE_NAMESPACE(std)endl;
} | pushq %rbx
subq $0x20, %rsp
movq (%rsi), %rax
movq %rsp, %rbx
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rbx), %rsi
movq 0xf1dad(%rip), %rdi # 0x11dfd8
callq 0x134b0
movq %rax, %rdi
callq 0x13250
movq %rsp, %rdi
callq 0x13a98
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13960
nop
| /OpenMD[P]OpenMD/src/antlr/CharScanner.cpp |
antlr::TokenBuffer::LT(unsigned int) | RefToken TokenBuffer::LT(unsigned int i)
{
fill(i);
return queue.elementAt(markerOffset+i-1);
} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x2c652
movl 0x14(%r15), %eax
addl %r14d, %eax
decl %eax
movq 0x38(%r15), %rcx
shlq $0x3, %rcx
addq 0x20(%r15), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x2c75d
incl 0x8(%rax)
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /OpenMD[P]OpenMD/src/antlr/TokenBuffer.cpp |
void OpenMD::DataHolder::assign<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(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>>) | void assign(const std::string& keyword, T val) {
ParamMap::iterator i = parameters_.find(keyword);
if (i != parameters_.end()) {
bool result = i->second->setData(val);
if (!result) {
std::stringstream ss;
ss << "Error in parsing " << keyword << ": expected "
<< i->second->getParamType() << " but got " << &val << "\n";
throw OpenMDException(ss.str());
}
} else if (deprecatedKeywords_.find(keyword) !=
deprecatedKeywords_.end()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"%s keyword has been deprecated in OpenMD. Please update your "
".omd file.\n",
keyword.c_str());
painCave.isFatal = 0;
painCave.severity = OPENMD_WARNING;
simError();
} else {
std::stringstream ss;
ss << keyword << " is not a recognized keyword.\n";
throw OpenMDException(ss.str());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
addq $0x8, %rdi
callq 0x4b9e8
movq %rax, %r15
leaq 0x10(%r12), %rax
cmpq %rax, %r15
je 0x4a558
movq 0x40(%r15), %r12
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x13700
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x18(%rax)
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x13a98
testb %bpl, %bpl
je 0x4a5b9
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%r12), %rdi
movq %r14, %rsi
callq 0x23dda
addq $0x40, %r12
cmpq %r12, %rax
je 0x4a67a
movq (%r14), %rcx
leaq 0xd4b28(%rip), %rbx # 0x11f0a4
leaq 0x7e18f(%rip), %rdx # 0xc8712
movl $0x7d0, %esi # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13830
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0x7d0(%rbx)
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2beaa
leaq 0x40(%rsp), %rdi
callq 0x13350
leaq 0x50(%rsp), %rdi
leaq 0x7e11b(%rip), %rsi # 0xc86ea
callq 0x134b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x13450
leaq 0x7e116(%rip), %rsi # 0xc86fc
movq %rax, %rdi
callq 0x134b0
movq %rax, %r14
movq 0x40(%r15), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x48(%rax)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x13450
leaq 0x7e0f8(%rip), %rsi # 0xc8708
movq %rax, %rdi
callq 0x134b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x133a0
leaq 0x7f7e1(%rip), %rsi # 0xc9e0b
movq %rax, %rdi
callq 0x134b0
movq %rsp, %rdi
callq 0x13a98
pushq $0x28
popq %rdi
callq 0x13260
movq %rax, %r14
leaq 0x58(%rsp), %rsi
movq %rsp, %rdi
callq 0x13800
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x238e4
xorl %ebp, %ebp
leaq 0xcf4b7(%rip), %rsi # 0x119b20
leaq -0x26d56(%rip), %rdx # 0x2391a
movq %r14, %rdi
callq 0x13910
jmp 0x4a6de
leaq 0x40(%rsp), %rdi
callq 0x13350
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x13450
leaq 0x7e0c3(%rip), %rsi # 0xc875b
movq %rax, %rdi
callq 0x134b0
pushq $0x28
popq %rdi
callq 0x13260
movq %rax, %r14
leaq 0x58(%rsp), %rsi
movq %rsp, %rdi
callq 0x13800
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x238e4
xorl %ebp, %ebp
leaq 0xcf451(%rip), %rsi # 0x119b20
leaq -0x26dbc(%rip), %rdx # 0x2391a
movq %r14, %rdi
callq 0x13910
jmp 0x4a6f1
jmp 0x4a703
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13a98
jmp 0x4a715
jmp 0x4a712
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13a98
testb %bpl, %bpl
jne 0x4a706
jmp 0x4a715
movq %rax, %rbx
movq %r14, %rdi
callq 0x13380
jmp 0x4a715
jmp 0x4a712
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x13390
jmp 0x4a72e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x13a98
movq %rbx, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/types/DataHolder.hpp |
void OpenMD::DataHolder::assign<std::vector<double, std::allocator<double>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<double, std::allocator<double>>) | void assign(const std::string& keyword, T val) {
ParamMap::iterator i = parameters_.find(keyword);
if (i != parameters_.end()) {
bool result = i->second->setData(val);
if (!result) {
std::stringstream ss;
ss << "Error in parsing " << keyword << ": expected "
<< i->second->getParamType() << " but got " << &val << "\n";
throw OpenMDException(ss.str());
}
} else if (deprecatedKeywords_.find(keyword) !=
deprecatedKeywords_.end()) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"%s keyword has been deprecated in OpenMD. Please update your "
".omd file.\n",
keyword.c_str());
painCave.isFatal = 0;
painCave.severity = OPENMD_WARNING;
simError();
} else {
std::stringstream ss;
ss << keyword << " is not a recognized keyword.\n";
throw OpenMDException(ss.str());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
addq $0x8, %rdi
callq 0x4b9e8
movq %rax, %r15
leaq 0x10(%r12), %rax
cmpq %rax, %r15
je 0x4a7aa
movq 0x40(%r15), %r12
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4a99a
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x40(%rax)
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x1b586
testb %bpl, %bpl
je 0x4a80b
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%r12), %rdi
movq %r14, %rsi
callq 0x23dda
addq $0x40, %r12
cmpq %r12, %rax
je 0x4a8d6
movq (%r14), %rcx
leaq 0xd48d6(%rip), %rbx # 0x11f0a4
leaq 0x7df3d(%rip), %rdx # 0xc8712
movl $0x7d0, %esi # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13830
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0x7d0(%rbx)
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2beaa
leaq 0x40(%rsp), %rdi
callq 0x13350
leaq 0x50(%rsp), %rdi
leaq 0x7dec9(%rip), %rsi # 0xc86ea
callq 0x134b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x13450
leaq 0x7dec4(%rip), %rsi # 0xc86fc
movq %rax, %rdi
callq 0x134b0
movq %rax, %r14
movq 0x40(%r15), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x48(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x13450
leaq 0x7dea2(%rip), %rsi # 0xc8708
movq %rax, %rdi
callq 0x134b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x133a0
leaq 0x7f58b(%rip), %rsi # 0xc9e0b
movq %rax, %rdi
callq 0x134b0
leaq 0x8(%rsp), %rdi
callq 0x13a98
pushq $0x28
popq %rdi
callq 0x13260
movq %rax, %r14
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x13800
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x238e4
xorl %ebp, %ebp
leaq 0xcf25b(%rip), %rsi # 0x119b20
leaq -0x26fb2(%rip), %rdx # 0x2391a
movq %r14, %rdi
callq 0x13910
jmp 0x4a93e
leaq 0x40(%rsp), %rdi
callq 0x13350
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x13450
leaq 0x7de67(%rip), %rsi # 0xc875b
movq %rax, %rdi
callq 0x134b0
pushq $0x28
popq %rdi
callq 0x13260
movq %rax, %r14
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x13800
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x238e4
xorl %ebp, %ebp
leaq 0xcf1f1(%rip), %rsi # 0x119b20
leaq -0x2701c(%rip), %rdx # 0x2391a
movq %r14, %rdi
callq 0x13910
jmp 0x4a953
jmp 0x4a967
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13a98
jmp 0x4a979
jmp 0x4a976
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13a98
testb %bpl, %bpl
jne 0x4a96a
jmp 0x4a979
movq %rax, %rbx
movq %r14, %rdi
callq 0x13380
jmp 0x4a979
jmp 0x4a976
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x13390
jmp 0x4a992
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1b586
movq %rbx, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/types/DataHolder.hpp |
OpenMD::BendStamp::setMembers(std::vector<int, std::allocator<int>> const&) | void setMembers(const std::vector<int>& members) {
members_ = members;
if (members_.size() < 2 || members_.size() > 3) {
std::ostringstream oss;
oss << "members" << containerToString(members) << " is invalid"
<< std::endl;
throw OpenMDException(oss.str());
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %rbx
movq %rdi, %r14
addq $0x98, %rdi
callq 0x25150
movq 0xa0(%r14), %rax
subq 0x98(%r14), %rax
andq $-0x8, %rax
cmpq $0x8, %rax
jne 0x4ad49
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x136e0
leaq 0x7d923(%rip), %rsi # 0xc8680
movq %r14, %rdi
callq 0x134b0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4b4dd
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x13450
leaq 0x7d8ff(%rip), %rsi # 0xc8688
movq %rax, %rdi
callq 0x134b0
movq %rax, %rdi
callq 0x13250
leaq 0x8(%rsp), %rdi
callq 0x13a98
pushq $0x28
popq %rdi
callq 0x13260
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x13800
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x238e4
xorl %ebp, %ebp
leaq 0xced4a(%rip), %rsi # 0x119b20
leaq -0x274c3(%rip), %rdx # 0x2391a
movq %rbx, %rdi
callq 0x13910
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13a98
testb %bpl, %bpl
jne 0x4adfc
jmp 0x4ae1a
movq %rax, %r14
movq %rbx, %rdi
callq 0x13380
jmp 0x4ae1a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13a98
jmp 0x4ae1a
jmp 0x4ae17
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x13140
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/types/BendStamp.hpp |
OpenMD::DataHolder::DataHolder() | DataHolder() {} | leaq 0xcf0f1(%rip), %rax # 0x11a410
movq %rax, (%rdi)
leaq 0x10(%rdi), %rax
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x40(%rdi), %rax
andl $0x0, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
retq
nop
| /OpenMD[P]OpenMD/src/types/DataHolder.hpp |
OpenMD::Thermo::getTranslationalKinetic() | RealType Thermo::getTranslationalKinetic() {
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!snap->hasTranslationalKineticEnergy) {
SimInfo::MoleculeIterator miter;
vector<StuntDouble*>::iterator iiter;
Molecule* mol;
StuntDouble* sd;
Vector3d vel;
RealType mass;
RealType kinetic(0.0);
for (mol = info_->beginMolecule(miter); mol != NULL;
mol = info_->nextMolecule(miter)) {
for (sd = mol->beginIntegrableObject(iiter); sd != NULL;
sd = mol->nextIntegrableObject(iiter)) {
mass = sd->getMass();
vel = sd->getVel();
kinetic +=
mass * (vel[0] * vel[0] + vel[1] * vel[1] + vel[2] * vel[2]);
}
}
#ifdef IS_MPI
MPI_Allreduce(MPI_IN_PLACE, &kinetic, 1, MPI_REALTYPE, MPI_SUM,
MPI_COMM_WORLD);
#endif
kinetic = kinetic * 0.5 / Constants::energyConvert;
snap->setTranslationalKineticEnergy(kinetic);
}
return snap->getTranslationalKineticEnergy();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq (%rdi), %rax
movq 0x2f8(%rax), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0xa71(%rbx)
jne 0x4bbe5
movq %rdi, %r14
movq %rbx, 0x10(%rsp)
leaq 0x38(%rsp), %r15
andq $0x0, (%r15)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x1b928
movq (%r14), %rdi
movq %r15, %rsi
callq 0x27020
movq %rax, %rbp
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x40(%rsp), %r13
testq %rbp, %rbp
je 0x4bbc2
movq 0xa0(%rbp), %rbx
cmpq 0xa8(%rbp), %rbx
je 0x4bb35
movsd 0x8(%rsp), %xmm0
jmp 0x4bba4
xorl %esi, %esi
testq %rsi, %rsi
je 0x4bbaf
movsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r13, %rdi
callq 0x4e5ee
movq %r12, %rdi
movq %r13, %rsi
callq 0x1aff0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd 0x18(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addq $0x8, %rbx
movl $0x0, %esi
movsd %xmm0, 0x8(%rsp)
cmpq 0xa8(%rbp), %rbx
je 0x4bb37
movq (%rbx), %rsi
movsd %xmm0, 0x8(%rsp)
jmp 0x4bb37
movq (%r14), %rdi
movq %r15, %rsi
callq 0x2703e
movq %rax, %rbp
jmp 0x4bb14
movsd 0x8(%rsp), %xmm0
mulsd 0x7cbe0(%rip), %xmm0 # 0xc87b0
divsd 0x7cbe0(%rip), %xmm0 # 0xc87b8
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x637a2
movq %rbx, %rdi
callq 0x6377a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
OpenMD::Thermo::getRotationalKinetic() | RealType Thermo::getRotationalKinetic() {
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!snap->hasRotationalKineticEnergy) {
SimInfo::MoleculeIterator miter;
vector<StuntDouble*>::iterator iiter;
Molecule* mol;
StuntDouble* sd;
Vector3d angMom;
Mat3x3d I;
int i, j, k;
RealType kinetic(0.0);
for (mol = info_->beginMolecule(miter); mol != NULL;
mol = info_->nextMolecule(miter)) {
for (sd = mol->beginIntegrableObject(iiter); sd != NULL;
sd = mol->nextIntegrableObject(iiter)) {
if (sd->isDirectional()) {
angMom = sd->getJ();
I = sd->getI();
if (sd->isLinear()) {
i = sd->linearAxis();
j = (i + 1) % 3;
k = (i + 2) % 3;
kinetic += angMom[j] * angMom[j] / I(j, j) +
angMom[k] * angMom[k] / I(k, k);
} else {
kinetic += angMom[0] * angMom[0] / I(0, 0) +
angMom[1] * angMom[1] / I(1, 1) +
angMom[2] * angMom[2] / I(2, 2);
}
}
}
}
#ifdef IS_MPI
MPI_Allreduce(MPI_IN_PLACE, &kinetic, 1, MPI_REALTYPE, MPI_SUM,
MPI_COMM_WORLD);
#endif
kinetic = kinetic * 0.5 / Constants::energyConvert;
snap->setRotationalKineticEnergy(kinetic);
}
return snap->getRotationalKineticEnergy();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq (%rdi), %rax
movq 0x2f8(%rax), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0xa72(%rbx)
jne 0x4bdfb
movq %rdi, %r15
movq %rbx, 0x28(%rsp)
leaq 0x38(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0x1b928
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x1e636
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x27020
movq %rax, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x90(%rsp), %rbp
pushq $0x3
popq %r14
movq %r15, 0x30(%rsp)
testq %rbx, %rbx
je 0x4bdd8
movq 0xa0(%rbx), %r12
cmpq 0xa8(%rbx), %r12
jne 0x4bdb5
xorl %r15d, %r15d
testq %r15, %r15
je 0x4bdbe
movl 0x8(%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x4bd9e
movq %rbp, %rdi
movq %r15, %rsi
callq 0x4e616
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x1aff0
movq (%r15), %rax
movq %rbp, %rdi
movq %r15, %rsi
callq *0x28(%rax)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1e688
cmpb $0x1, 0x20(%r15)
jne 0x4bd4f
movl 0x24(%r15), %ecx
leal 0x1(%rcx), %eax
cltd
idivl %r14d
movl %edx, %esi
addl $0x2, %ecx
movl %ecx, %eax
cltd
idivl %r14d
imulq $0x18, %rsi, %rax
addq %rsp, %rax
addq $0x40, %rax
imulq $0x18, %rdx, %rcx
addq %rsp, %rcx
addq $0x40, %rcx
movsd 0x10(%rsp,%rsi,8), %xmm0
movhpd 0x10(%rsp,%rdx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
mulpd %xmm0, %xmm0
movsd (%rax,%rsi,8), %xmm1
movhpd (%rcx,%rdx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
divpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x4bd9e
movapd 0x10(%rsp), %xmm0
movapd 0x40(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm2
divsd 0x60(%rsp), %xmm2
movhpd 0x20(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
mulpd %xmm0, %xmm0
movhpd 0x80(%rsp), %xmm1 # xmm1 = xmm1[0],mem[0]
divpd %xmm1, %xmm0
addsd %xmm0, %xmm2
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
addq $0x8, %r12
movl $0x0, %r15d
cmpq 0xa8(%rbx), %r12
je 0x4bc99
movq (%r12), %r15
jmp 0x4bc99
movq 0x30(%rsp), %r15
movq (%r15), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2703e
movq %rax, %rbx
jmp 0x4bc79
movsd 0x8(%rsp), %xmm0
mulsd 0x7c9ca(%rip), %xmm0 # 0xc87b0
divsd 0x7c9ca(%rip), %xmm0 # 0xc87b8
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x637bc
movq %rbx, %rdi
callq 0x63784
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
OpenMD::Thermo::getElectronicKinetic() | RealType Thermo::getElectronicKinetic() {
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!snap->hasElectronicKineticEnergy) {
SimInfo::MoleculeIterator miter;
vector<Atom*>::iterator iiter;
Molecule* mol;
Atom* atom;
RealType cvel;
RealType cmass;
RealType kinetic(0.0);
for (mol = info_->beginMolecule(miter); mol != NULL;
mol = info_->nextMolecule(miter)) {
for (atom = mol->beginFluctuatingCharge(iiter); atom != NULL;
atom = mol->nextFluctuatingCharge(iiter)) {
cmass = atom->getChargeMass();
cvel = atom->getFlucQVel();
kinetic += cmass * cvel * cvel;
}
}
#ifdef IS_MPI
MPI_Allreduce(MPI_IN_PLACE, &kinetic, 1, MPI_REALTYPE, MPI_SUM,
MPI_COMM_WORLD);
#endif
kinetic *= 0.5;
snap->setElectronicKineticEnergy(kinetic);
}
return snap->getElectronicKineticEnergy();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x2f8(%rdi), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0xa73(%rbx)
jne 0x4bf50
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %r15, %rsi
callq 0x27020
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x4bf40
movq 0x100(%rax), %rcx
movq 0x108(%rax), %rax
cmpq %rax, %rcx
je 0x4bed2
movapd %xmm0, %xmm2
jmp 0x4bf1d
xorl %edx, %edx
testq %rdx, %rdx
je 0x4bf26
movq 0x10(%rdx), %rsi
movq 0x18(%rdx), %rdi
movq 0x18(%rdi), %rdi
movslq 0x30(%rdx), %r8
movq 0x168(%rdi,%rsi), %rsi
movsd (%rsi,%r8,8), %xmm1
movsd 0x80(%rdx), %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
addq $0x8, %rcx
movl $0x0, %edx
movapd %xmm2, %xmm0
cmpq %rax, %rcx
je 0x4bed4
movq (%rcx), %rdx
movapd %xmm2, %xmm0
jmp 0x4bed4
movq (%r14), %rdi
movq %r15, %rsi
movsd %xmm0, (%rsp)
callq 0x2703e
movsd (%rsp), %xmm0
jmp 0x4beb0
mulsd 0x7c868(%rip), %xmm0 # 0xc87b0
movq %rbx, %rdi
callq 0x637da
movq %rbx, %rdi
callq 0x6378e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
OpenMD::Thermo::getTotalEnergy() | RealType Thermo::getTotalEnergy() {
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!snap->hasTotalEnergy) {
snap->setTotalEnergy(this->getKinetic() + this->getPotential());
}
return snap->getTotalEnergy();
} | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x2f8(%rax), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0xa70(%rbx)
jne 0x4bfcf
movq %rdi, %r14
callq 0x4be16
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x4bf62
addsd (%rsp), %xmm0
movq %rbx, %rdi
callq 0x63816
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6380c
| /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
OpenMD::Thermo::getElectronicTemperature() | RealType Thermo::getElectronicTemperature() {
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!snap->hasElectronicTemperature) {
RealType eTemp = (2.0 * this->getElectronicKinetic()) /
(info_->getNFluctuatingCharges() * Constants::kb);
snap->setElectronicTemperature(eTemp);
}
return snap->getElectronicTemperature();
} | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x2f8(%rax), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0xa80(%rbx)
jne 0x4c0bd
movq %rdi, %r14
callq 0x4be74
movq (%r14), %rax
cvtsi2sdl 0x64(%rax), %xmm1
addsd %xmm0, %xmm0
mulsd 0x7c70f(%rip), %xmm1 # 0xc87c0
divsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x6385e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x63854
| /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
antlr::MismatchedCharException::MismatchedCharException(int, int, int, bool, antlr::CharScanner*) | MismatchedCharException::MismatchedCharException(
int c,
int lower,
int upper_,
bool matchNot,
CharScanner* scanner_
) : RecognitionException("Mismatched char",
scanner_->getFilename(),
scanner_->getLine(), scanner_->getColumn())
, mismatchType(matchNot ? NOT_RANGE : RANGE)
, foundChar(c)
, expecting(lower)
, upper(upper_)
, scanner(scanner_)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movl %r8d, %r13d
movl %ecx, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x761b5(%rip), %rsi # 0xc8a82
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1a8b4
movq (%r14), %rax
movq %r14, %rdi
callq *0xd0(%rax)
movq %rax, %rbp
movq (%r14), %rax
movq %r14, %rdi
callq *0xb0(%rax)
movl %eax, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
movl %eax, %r8d
callq 0x54c5a
leaq 0x18(%rsp), %rdi
callq 0x13a98
leaq 0xc804b(%rip), %rax # 0x11a978
movq %rax, (%rbx)
movzbl %r13b, %eax
addl $0x3, %eax
movl %eax, 0x50(%rbx)
movl %r12d, 0x54(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x58(%rbx)
movl 0x14(%rsp), %eax
movl %eax, 0x5c(%rbx)
leaq 0x60(%rbx), %rdi
pushq $0x40
popq %rsi
callq 0x512f4
movq %r14, 0x88(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24790
jmp 0x5298d
movq %rax, %r14
jmp 0x5298d
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x13a98
movq %r14, %rdi
callq 0x13960
nop
| /OpenMD[P]OpenMD/src/antlr/MismatchedCharException.cpp |
antlr::MismatchedCharException::MismatchedCharException(int, int, bool, antlr::CharScanner*) | MismatchedCharException::MismatchedCharException(
int c,
int expecting_,
bool matchNot,
CharScanner* scanner_
) : RecognitionException("Mismatched char",
scanner_->getFilename(),
scanner_->getLine(), scanner_->getColumn())
, mismatchType(matchNot ? NOT_CHAR : CHAR)
, foundChar(c)
, expecting(expecting_)
, scanner(scanner_)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %r12d
movl %edx, 0x4(%rsp)
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x760c7(%rip), %rsi # 0xc8a82
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x1a8b4
movq (%r14), %rax
movq %r14, %rdi
callq *0xd0(%rax)
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0xb0(%rax)
movl %eax, %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x54c5a
leaq 0x8(%rsp), %rdi
callq 0x13a98
leaq 0xc7f5f(%rip), %rax # 0x11a978
movq %rax, (%rbx)
movzbl %r12b, %eax
incl %eax
movl %eax, 0x50(%rbx)
movl %r15d, 0x54(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x58(%rbx)
leaq 0x60(%rbx), %rdi
pushq $0x40
popq %rsi
callq 0x512f4
movq %r14, 0x88(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24790
jmp 0x52a71
movq %rax, %r14
jmp 0x52a71
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13a98
movq %r14, %rdi
callq 0x13960
nop
| /OpenMD[P]OpenMD/src/antlr/MismatchedCharException.cpp |
antlr::MismatchedCharException::MismatchedCharException(int, antlr::BitSet, bool, antlr::CharScanner*) | MismatchedCharException::MismatchedCharException(
int c,
BitSet set_,
bool matchNot,
CharScanner* scanner_
) : RecognitionException("Mismatched char",
scanner_->getFilename(),
scanner_->getLine(), scanner_->getColumn())
, mismatchType(matchNot ? NOT_SET : SET)
, foundChar(c)
, set(set_)
, scanner(scanner_)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movl %ecx, %r12d
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x75fe3(%rip), %rsi # 0xc8a82
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1a8b4
movq (%r14), %rax
movq %r14, %rdi
callq *0xd0(%rax)
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0xb0(%rax)
movl %eax, %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
movl %r15d, %ecx
movl %eax, %r8d
callq 0x54c5a
leaq 0x18(%rsp), %rdi
callq 0x13a98
leaq 0xc7e79(%rip), %rax # 0x11a978
movq %rax, (%rbx)
movzbl %r12b, %eax
addl $0x5, %eax
movl %eax, 0x50(%rbx)
movl %ebp, 0x54(%rbx)
leaq 0x60(%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0x2453c
movq %r14, 0x88(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24790
jmp 0x52b52
movq %rax, %r14
jmp 0x52b52
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x13a98
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/MismatchedCharException.cpp |
antlr::MismatchedTokenException::MismatchedTokenException() | MismatchedTokenException::MismatchedTokenException()
: RecognitionException("Mismatched Token: expecting any AST node","<AST>",-1,-1)
, token(0)
, node(nullASTptr)
, tokenNames(0)
, numTokens(0)
{
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x75922(%rip), %rsi # 0xc8b8b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1a8b4
leaq 0x75935(%rip), %rsi # 0xc8bb4
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1a8b4
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movl %ecx, %r8d
callq 0x54c5a
leaq 0x8(%rsp), %rdi
callq 0x13a98
leaq 0x28(%rsp), %rdi
callq 0x13a98
leaq 0xc771f(%rip), %rax # 0x11a9e0
movq %rax, (%rbx)
andq $0x0, 0x50(%rbx)
leaq 0x58(%rbx), %r15
leaq 0x7567c(%rip), %rax # 0xc8950
movq (%rax), %rsi
movq %r15, %rdi
callq 0x50004
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
leaq 0x60(%rbx), %r12
movb $0x0, 0x70(%rbx)
leaq 0x90(%rbx), %rdi
pushq $0x40
popq %rsi
callq 0x512f4
andq $0x0, 0xb8(%rbx)
andl $0x0, 0xc0(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x13a98
movq %r15, %rdi
callq 0x22462
jmp 0x53336
movq %rax, %r14
leaq 0x50(%rbx), %rdi
callq 0x2476c
movq %rbx, %rdi
callq 0x24790
jmp 0x5336a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13a98
jmp 0x5335b
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x13a98
jmp 0x5336a
movq %rax, %r14
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/MismatchedTokenException.cpp |
antlr::MismatchedTokenException::MismatchedTokenException(char const* const*, int, antlr::ASTRefCount<antlr::AST>, int, int, bool) | MismatchedTokenException::MismatchedTokenException(
const char* const* tokenNames_,
const int numTokens_,
RefAST node_,
int lower,
int upper_,
bool matchNot
) : RecognitionException("Mismatched Token","<AST>",-1,-1)
, token(0)
, node(node_)
, tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
, mismatchType(matchNot ? NOT_RANGE : RANGE)
, expecting(lower)
, upper(upper_)
, tokenNames(tokenNames_)
, numTokens(numTokens_)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, %r12d
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x75820(%rip), %rsi # 0xc8bba
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x1a8b4
leaq 0x75804(%rip), %rsi # 0xc8bb4
leaq 0x28(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x1a8b4
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movl %ecx, %r8d
callq 0x54c5a
movl %ebp, %r14d
leaq 0x28(%rsp), %rdi
callq 0x13a98
leaq 0x8(%rsp), %rdi
callq 0x13a98
leaq 0xc75eb(%rip), %rax # 0x11a9e0
movq %rax, (%rbx)
andq $0x0, 0x50(%rbx)
movq (%r13), %rax
testq %rax, %rax
je 0x53409
incl 0x8(%rax)
movq %rax, 0x58(%rbx)
leaq 0x60(%rbx), %rbp
movq (%r13), %rax
testq %rax, %rax
je 0x53430
movq (%rax), %rsi
testq %rsi, %rsi
je 0x53430
movq (%rsi), %rax
movq %rbp, %rdi
callq *0xc0(%rax)
jmp 0x53444
leaq 0x75794(%rip), %rsi # 0xc8bcb
leaq 0x8(%rsp), %rdx
movq %rbp, %rdi
callq 0x1a8b4
movzbl 0x80(%rsp), %eax
addl $0x3, %eax
movl %eax, 0x80(%rbx)
movl %r12d, 0x84(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x88(%rbx)
leaq 0x90(%rbx), %rdi
pushq $0x40
popq %rsi
callq 0x512f4
movq %r15, 0xb8(%rbx)
movl %r14d, 0xc0(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53494
movq %rax, %r14
jmp 0x534a4
movq %rax, %r14
movq %rbp, %rdi
callq 0x13a98
leaq 0x50(%rbx), %r15
leaq 0x58(%rbx), %rdi
callq 0x22462
movq %r15, %rdi
callq 0x2476c
movq %rbx, %rdi
callq 0x24790
jmp 0x534e4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x13a98
jmp 0x534d5
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13a98
jmp 0x534e4
movq %rax, %r14
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/MismatchedTokenException.cpp |
antlr::MismatchedTokenException::MismatchedTokenException(char const* const*, int, antlr::ASTRefCount<antlr::AST>, int, bool) | MismatchedTokenException::MismatchedTokenException(
const char* const* tokenNames_,
const int numTokens_,
RefAST node_,
int expecting_,
bool matchNot
) : RecognitionException("Mismatched Token","<AST>",-1,-1)
, token(0)
, node(node_)
, tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
, mismatchType(matchNot ? NOT_TOKEN : TOKEN)
, expecting(expecting_)
, tokenNames(tokenNames_)
, numTokens(numTokens_)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r12d
movl %r8d, 0x4(%rsp)
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x756a6(%rip), %rsi # 0xc8bba
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x1a8b4
leaq 0x7568a(%rip), %rsi # 0xc8bb4
leaq 0x28(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x1a8b4
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movl %ecx, %r8d
callq 0x54c5a
movl %ebp, %r14d
leaq 0x28(%rsp), %rdi
callq 0x13a98
leaq 0x8(%rsp), %rdi
callq 0x13a98
leaq 0xc7471(%rip), %rax # 0x11a9e0
movq %rax, (%rbx)
andq $0x0, 0x50(%rbx)
movq (%r13), %rax
testq %rax, %rax
je 0x53583
incl 0x8(%rax)
movq %rax, 0x58(%rbx)
leaq 0x60(%rbx), %rbp
movq (%r13), %rax
testq %rax, %rax
je 0x535aa
movq (%rax), %rsi
testq %rsi, %rsi
je 0x535aa
movq (%rsi), %rax
movq %rbp, %rdi
callq *0xc0(%rax)
jmp 0x535be
leaq 0x7561a(%rip), %rsi # 0xc8bcb
leaq 0x8(%rsp), %rdx
movq %rbp, %rdi
callq 0x1a8b4
movzbl %r12b, %eax
incl %eax
movl %eax, 0x80(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x84(%rbx)
leaq 0x90(%rbx), %rdi
pushq $0x40
popq %rsi
callq 0x512f4
movq %r15, 0xb8(%rbx)
movl %r14d, 0xc0(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53602
movq %rax, %r14
jmp 0x53612
movq %rax, %r14
movq %rbp, %rdi
callq 0x13a98
leaq 0x50(%rbx), %r15
leaq 0x58(%rbx), %rdi
callq 0x22462
movq %r15, %rdi
callq 0x2476c
movq %rbx, %rdi
callq 0x24790
jmp 0x53652
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x13a98
jmp 0x53643
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13a98
jmp 0x53652
movq %rax, %r14
movq %r14, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/MismatchedTokenException.cpp |
antlr::MismatchedTokenException::MismatchedTokenException(char const* const*, int, antlr::TokenRefCount<antlr::Token>, int, int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | MismatchedTokenException::MismatchedTokenException(
const char* const* tokenNames_,
const int numTokens_,
RefToken token_,
int lower,
int upper_,
bool matchNot,
const ANTLR_USE_NAMESPACE(std)string& fileName_
) : RecognitionException("Mismatched Token",fileName_,token_->getLine(),token_->getColumn())
, token(token_)
, node(nullASTptr)
, tokenText(token_->getText())
, mismatchType(matchNot ? NOT_RANGE : RANGE)
, expecting(lower)
, upper(upper_)
, tokenNames(tokenNames_)
, numTokens(numTokens_)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebp
movl %r8d, %r12d
movq %rcx, %r13
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x753d1(%rip), %rsi # 0xc8bba
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1a8b4
movl %r12d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq (%r13), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%r13), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x78(%rsp), %rdx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %ecx
movl %eax, %r8d
callq 0x54c5a
movq %r15, %r12
leaq 0x18(%rsp), %rdi
callq 0x13a98
leaq 0xc7198(%rip), %rax # 0x11a9e0
movq %rax, (%rbx)
movq (%r13), %rax
testq %rax, %rax
je 0x53857
incl 0x8(%rax)
movl %r14d, %r15d
movq %rax, 0x50(%rbx)
leaq 0x58(%rbx), %rbp
leaq 0x750e7(%rip), %rax # 0xc8950
movq (%rax), %rsi
movq %rbp, %rdi
callq 0x50004
leaq 0x60(%rbx), %r14
movq (%r13), %rax
movq (%rax), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x20(%rax)
movzbl 0x70(%rsp), %eax
addl $0x3, %eax
movl %eax, 0x80(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x84(%rbx)
movl 0x14(%rsp), %eax
movl %eax, 0x88(%rbx)
leaq 0x90(%rbx), %rdi
pushq $0x40
popq %rsi
callq 0x512f4
movq %r12, 0xb8(%rbx)
movl %r15d, 0xc0(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x13a98
jmp 0x538e6
movq %rax, %r15
movq %rbp, %rdi
callq 0x22462
jmp 0x538f3
movq %rax, %r15
leaq 0x50(%rbx), %rdi
callq 0x2476c
movq %rbx, %rdi
callq 0x24790
jmp 0x53918
movq %rax, %r15
jmp 0x53918
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x13a98
movq %r15, %rdi
callq 0x13960
| /OpenMD[P]OpenMD/src/antlr/MismatchedTokenException.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.