name string | code string | asm string | file string |
|---|---|---|---|
PPC_alias_insn | bool PPC_alias_insn(const char *name, struct ppc_alias *alias)
{
size_t i;
#ifndef CAPSTONE_DIET
int x;
#endif
for(i = 0; i < ARR_SIZE(alias_insn_name_maps); i++) {
if (!strcmp(name, alias_insn_name_maps[i].mnem)) {
alias->id = alias_insn_name_maps[i].id;
alias->cc = alias_insn_name_maps[i].cc;
return tr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x10
popq %rcx
leaq 0xfa172(%rip), %r15 # 0x198c20
leaq 0x10(%rcx), %r12
cmpq $0x500, %r12 # imm = 0x500
je 0x9eada
movq 0x18(%rcx,%r15), %rsi
movq %r14, %rdi
callq 0x440d0
movq %r12, %rcx
testl %eax, %eax
jne ... | /radare[P]capstone/arch/PowerPC/PPCMapping.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 = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa08, %rsp # imm = 0xA08
movq %r9, %r12
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r9, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
xorl %ebp, %ebp
movl $0x938, %edx # imm = 0x938
xorl... | /radare[P]capstone/arch/X86/X86Disassembler.c |
decodeInstruction | int decodeInstruction(struct InternalInstruction *insn,
byteReader_t reader,
const void *readerArg,
uint64_t startLoc,
DisassemblerMode mode)
{
insn->reader = reader;
insn->readerArg = readerArg;
insn->startLocation = startLoc;
insn->readerCursor = startLoc;
insn->mode = mode;
if (readPrefixes(insn) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, 0x938(%rdi)
movq %rdx, 0x940(%rdi)
movq %rcx, 0x968(%rdi)
movq %rcx, 0x948(%rdi)
movl %r8d, 0x960(%rdi)
leaq 0xd(%rsp), %r14
movb $0x0, (%r14)
movb $0x1, %al
xorl %r12d, %r12d
leaq 0x4afa7(%rip), %r13 # 0xe... | /radare[P]capstone/arch/X86/X86DisassemblerDecoder.c |
readModRM | static int readModRM(struct InternalInstruction *insn)
{
uint8_t mod, rm, reg;
// dbgprintf(insn, "readModRM()");
// already got ModRM byte?
if (insn->consumedModRM)
return 0;
if (consumeByte(insn, &insn->modRM))
return -1;
// mark that we already got ModRM
insn->consumedModRM = true;
// save original ... | pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpb $0x0, 0x10c(%rdi)
jne 0xa0ca1
movq %rdi, %r14
leaq 0x9a8(%rdi), %r15
movq %r15, %rsi
callq 0xa09cc
pushq $-0x1
popq %rbx
testl %eax, %eax
jne 0xa0ca1
movb $0x1, 0x10c(%r14)
movb 0x9a8(%r14), %al
movb 0x9a9(%r14), %cl
movb %al, 0x10d(%r14)
cmpb $0xf, %cl
jne 0xa0a62
... | /radare[P]capstone/arch/X86/X86DisassemblerDecoder.c |
readSIB | static int readSIB(struct InternalInstruction *insn)
{
SIBIndex sibIndexBase = SIB_INDEX_NONE;
SIBBase sibBaseBase = SIB_BASE_NONE;
uint8_t index, base;
// dbgprintf(insn, "readSIB()");
if (insn->consumedSIB)
return 0;
insn->consumedSIB = true;
switch (insn->addressSize) {
case 2:
// dbgprintf(insn, "... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
cmpb $0x0, 0x10e(%rdi)
jne 0xa0f95
movq %rdi, %rbx
movb $0x1, 0x10e(%rdi)
movzbl 0x989(%rdi), %eax
pushq $-0x1
popq %rbp
cmpl $0x2, %eax
je 0xa0f95
cmpl $0x8, %eax
je 0xa0e89
xorl %r15d, %r15d
movl $0x0, %r14d
cmpl $0x4, %eax
jne 0xa0e91
pushq $0x1
... | /radare[P]capstone/arch/X86/X86DisassemblerDecoder.c |
getIDWithAttrMask | static int getIDWithAttrMask(uint16_t *instructionID,
struct InternalInstruction *insn,
uint16_t attrMask)
{
bool hasModRMExtension;
InstructionContext instructionClass;
#ifndef CAPSTONE_X86_REDUCE
// HACK for femms. to be handled properly in next version 3.x
if (insn->opcode == 0x0e && insn->opcodeType == T3... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x98f(%rsi), %edx
movl 0x990(%rsi), %edi
cmpq $0xe, %rdx
jne 0xa0fcf
movw $0x2fc, %ax # imm = 0x2FC
cmpl $0x7, %edi
jne 0xa0fd9
jmp 0xa106c
cmpl $0x7, %edi
jne 0xa0fd9
pushq $0x4
popq %rbp
jmp 0xa1037
movzwl %cx, %eax
le... | /radare[P]capstone/arch/X86/X86DisassemblerDecoder.c |
decode | static InstrUID decode(OpcodeType type,
InstructionContext insnContext,
uint8_t opcode,
uint8_t modRM)
{
const struct ModRMDecision *dec = NULL;
const uint8_t *indextable = NULL;
uint8_t index;
switch (type) {
default:
case ONEBYTE:
indextable = index_x86DisassemblerOneByteOpcodes;
index = indextab... | movl %esi, %eax
decl %edi
cmpl $0x6, %edi
ja 0xa113f
leaq 0x4968e(%rip), %rsi # 0xea718
movslq (%rsi,%rdi,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
leaq 0x536e6(%rip), %rsi # 0xf4780
movzbl (%rax,%rsi), %esi
testq %rsi, %rsi
je 0xa11d6
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addl %eax, %esi
shlq $0xa, %rsi
le... | /radare[P]capstone/arch/X86/X86DisassemblerDecoder.c |
readOpcodeRegister | static int readOpcodeRegister(struct InternalInstruction *insn, uint8_t size)
{
// dbgprintf(insn, "readOpcodeRegister()");
if (size == 0)
size = insn->registerSize;
insn->operandSize = size;
switch (size) {
case 1:
insn->opcodeRegister = (Reg)(MODRM_REG_AL + ((bFromREX(insn->rexPrefix) << 3)
| (ins... | testl %esi, %esi
jne 0xa15e3
movb 0x988(%rdi), %sil
movb %sil, (%rdi)
movzbl %sil, %eax
decl %eax
cmpl $0x7, %eax
ja 0xa1691
leaq 0x491d4(%rip), %rcx # 0xea7d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl 0x105(%rdi), %ecx
leal (,%rcx,8), %edx
andl $0x8, %edx
movzbl 0x98f(%rdi), %eax
andl $0x7, %eax... | /radare[P]capstone/arch/X86/X86DisassemblerDecoder.c |
printSrcIdx | static void printSrcIdx(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *SegReg;
int reg;
if (MI->csh->detail) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize;
MI->flat_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x320(%rdi), %rax
cmpl $0x0, 0xe0(%rax)
je 0xa1872
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x5c(%rax), %ecx
imulq $0x30, %rcx, %rcx
movl $0x3, 0x60(%rax,%rcx)
movb 0x328(%rbx), %al
movq 0x310(%rbx), ... | /radare[P]capstone/arch/X86/X86IntelInstPrinter.c |
printDstIdx | static void printDstIdx(MCInst *MI, unsigned Op, SStream *O)
{
if (MI->csh->detail) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize;
MI->flat_insn->detail->x86.operands[MI->... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x320(%rdi), %rax
cmpl $0x0, 0xe0(%rax)
je 0xa1aeb
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movzbl 0x5c(%rax), %ecx
imulq $0x30, %rcx, %rcx
movl $0x3, 0x60(%rax,%rcx)
movb 0x328(%rbx), %al
movq 0x310(%rbx), %rcx
movq 0xe8(%rcx), %... | /radare[P]capstone/arch/X86/X86IntelInstPrinter.c |
printOperand | static void _printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
printRegName(O, MCOperand_getReg(Op));
} else if (MCOperand_isImm(Op)) {
int64_t imm = MCOperand_getImm(Op);
if (imm < 0) {
if (imm < -HEX_THRESHOLD)
SStream_concat... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0x45587
movq %rax, %r14
movq %rax, %rdi
callq 0x455c2
testb %al, %al
je 0xa2f9a
movq %r14, %rdi
callq 0x455da
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa32e1
movq %r14, %rdi
callq 0x455ca
testb %al, %al
je 0xa2fc2
movq %r14, %rdi
cal... | /radare[P]capstone/arch/X86/X86IntelInstPrinter.c |
printOperand | static void printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
unsigned int reg = MCOperand_getReg(Op);
printRegName(O, reg);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->de... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
callq 0x45587
movq %rax, %r14
movq %rax, %rdi
callq 0x455c2
testb %al, %al
je 0xa30af
movq %r14, %rdi
callq 0x455da
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
callq 0xa32e1
movq 0x320(%rbx), %rcx
cmpl $0x0, 0xe0(%rcx)
movl %ebp,... | /radare[P]capstone/arch/X86/X86IntelInstPrinter.c |
printopaquemem | static void printopaquemem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "ptr ");
switch(MI->csh->mode) {
case CS_MODE_16:
MI->x86opsize = 2;
break;
case CS_MODE_32:
MI->x86opsize = 4;
break;
case CS_MODE_64:
MI->x86opsize = 8;
break;
default: // never reach
break;
}
pri... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0xa2cc6(%rip), %rsi # 0x146180
movq %rdx, %rdi
callq 0x4565f
movq 0x320(%r14), %rax
movl 0x4(%rax), %eax
cmpl $0x2, %eax
je 0xa34e3
cmpl $0x8, %eax
je 0xa34df
cmpl $0x4, %eax
jne 0xa34ec
movb $0x4, %al
jmp 0xa34e5
movb $0x8, %al
j... | /radare[P]capstone/arch/X86/X86IntelInstPrinter.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, "l... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x45587
movq %rax, %rdi
callq 0x455e2
andl $0x1f, %eax
leaq 0xa2bd2(%rip), %rcx # 0x1460f0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leal 0x1(%rax), %ebp
movq %rbx, %rdi
callq 0x4565f
movq %r14, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rb... | /radare[P]capstone/arch/X86/X86IntelInstPrinter.c |
printMemReference | static void printMemReference(MCInst *MI, unsigned Op, SStream *O)
{
bool NeedPlus = false;
MCOperand *BaseReg = MCInst_getOperand(MI, Op + X86_AddrBaseReg);
uint64_t ScaleVal = MCOperand_getImm(MCInst_getOperand(MI, Op + X86_AddrScaleAmt));
MCOperand *IndexReg = MCInst_getOperand(MI, Op + X86_AddrIndexReg);
MCO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x18(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
callq 0x45587
movq %rax, %r12
leal 0x1(%rbp), %esi
movq %rbx, %rdi
callq 0x45587
movq %rax, %rdi
callq 0x455e2
movq %rax, %r13
leal 0x2(%rbp), %esi
movq %rbx, %rdi
movl %esi, 0xc(%rsp... | /radare[P]capstone/arch/X86/X86IntelInstPrinter.c |
X86_reg_name | const char *X86_reg_name(csh handle, unsigned int reg)
{
#ifndef CAPSTONE_DIET
cs_struct *ud = (cs_struct *)handle;
if (reg >= X86_REG_ENDING)
return NULL;
if (reg == X86_REG_EFLAGS) {
if (ud->mode & CS_MODE_32)
return "eflags";
if (ud->mode & CS_MODE_64)
return "rflags";
}
return reg_name_maps[reg]... | cmpl $0xe9, %esi
jbe 0xa3c29
xorl %eax, %eax
retq
cmpl $0x19, %esi
jne 0xa3c39
movl 0x4(%rdi), %eax
testb $0x4, %al
jne 0xa3c4c
testb $0x8, %al
jne 0xa3c54
movl %esi, %eax
shlq $0x4, %rax
leaq 0xf54da(%rip), %rcx # 0x199120
movq 0x8(%rax,%rcx), %rax
retq
leaq 0xa2fc5(%rip), %rax # 0x146c18
retq
leaq 0xa2fc4(%ri... | /radare[P]capstone/arch/X86/X86Mapping.c |
DecodeFPRegsRegisterClass | static DecodeStatus DecodeFPRegsRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
unsigned Reg;
if (RegNo > 31)
return MCDisassembler_Fail;
Reg = FPRegDecoderTable[RegNo];
MCOperand_CreateReg0(Inst, Reg);
return MCDisassembler_Success;
} | xorl %eax, %eax
cmpl $0x1f, %esi
ja 0xa52c9
pushq %rax
movl %esi, %eax
leaq 0xa3ec6(%rip), %rcx # 0x149180
movl (%rcx,%rax,4), %esi
callq 0x4560d
pushq $0x3
popq %rax
addq $0x8, %rsp
retq
| /radare[P]capstone/arch/Sparc/SparcDisassembler.c |
Sparc_post_printer | void Sparc_post_printer(csh ud, cs_insn *insn, char *insn_asm, MCInst *mci)
{
if (((cs_struct *)ud)->detail != CS_OPT_ON)
return;
// fix up some instructions
if (insn->id == SPARC_INS_CASX) {
// first op is actually a memop, not regop
insn->detail->sparc.operands[0].type = SPARC_OP_MEM;
insn->detail->sparc.... | cmpl $0x3, 0xe0(%rdi)
jne 0xa5417
cmpl $0x1c, (%rsi)
jne 0xa5417
movq 0xe8(%rsi), %rax
movl $0x3, 0x3c(%rax)
movq 0xe8(%rsi), %rax
andl $0x0, 0x44(%rax)
retq
| /radare[P]capstone/arch/Sparc/SparcInstPrinter.c |
Sparc_printInst | void Sparc_printInst(MCInst *MI, SStream *O, void *Info)
{
char *mnem, *p;
char instr[64]; // Sparc has no instruction this long
mnem = printAliasInstr(MI, O, Info);
if (mnem) {
// fixup instruction id due to the change in alias instruction
strncpy(instr, mnem, strlen(mnem));
instr[strlen(mnem)] = '\0';
//... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa5e6e
testq %rax, %rax
je 0xa54e1
movq %rax, %r15
movq %rax, %rdi
callq 0x44080
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x44040
movq %r15, %rdi
callq 0x44080
movb $0x0, (%rsp,%rax)
pushq $0... | /radare[P]capstone/arch/Sparc/SparcInstPrinter.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->fla... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x45587
movq %rax, %r15
movq %rax, %rdi
callq 0x455c2
testb %al, %al
je 0xba804
movq %r15, %rdi
callq 0x455da
movl %eax, %r15d
leaq 0x90fc6(%rip), %rsi # 0x14b74b
movq %r14, %rdi
callq 0x4565f
leal -0x1(%r15), %eax
leaq 0x8ed38(%rip), %rcx #... | /radare[P]capstone/arch/Sparc/SparcInstPrinter.c |
Decode2RUSBitpInstruction | static DecodeStatus Decode2RUSBitpInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2, Op3;
DecodeStatus S = Decode3OpInstruction(Insn, &Op1, &Op2, &Op3);
if (S == MCDisassembler_Success) {
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeGRRegsRegisterCla... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movl %eax, %edi
callq 0xbf8de
movl %eax, %ebp
cmpl $0x3, %eax
jne 0xbf1ea
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xbeda6
movl 0x8(%rsp), %e... | /radare[P]capstone/arch/XCore/XCoreDisassembler.c |
mbedtls_md_info_from_string | const mbedtls_md_info_t *mbedtls_md_info_from_string( const char *md_name )
{
if( NULL == md_name )
return( NULL );
/* Get the appropriate digest information */
#if defined(MBEDTLS_MD2_C)
if( !strcmp( "MD2", md_name ) )
return mbedtls_md_info_from_type( MBEDTLS_MD_MD2 );
#endif
#if defined(... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa540
movq %rdi, %rbx
leaq 0x22d05(%rip), %rdi # 0x2d19c
movq %rbx, %rsi
callq 0xa0f0
testl %eax, %eax
je 0xa545
leaq 0x1fd12(%rip), %rdi # 0x2a1c0
movq %rbx, %rsi
callq 0xa0f0
testl %eax, %eax
je 0xa54e
leaq 0x22dff(%rip), %rdi # 0x2d2c4
movq %rbx, %rsi... | /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_pk_load_file | int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n )
{
FILE *f;
long size;
if( ( f = fopen( path, "rb" ) ) == NULL )
return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
if( ( size = ftell( f ) ) == -1 )
{
fclose( f );
return( MBEDTLS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1e921(%rip), %rsi # 0x2a089
callq 0xa150
movl $0xffffc200, %ebx # imm = 0xFFFFC200
testq %rax, %rax
je 0xb82e
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xa140
movq %r... | /Dragonchang[P]https_client/mbedtls/library/pkparse.c |
mbedtls_ripemd160_process | void mbedtls_ripemd160_process( mbedtls_ripemd160_context *ctx, const unsigned char data[64] )
{
uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16];
GET_UINT32_LE( X[ 0], data, 0 );
GET_UINT32_LE( X[ 1], data, 4 );
GET_UINT32_LE( X[ 2], data, 8 );
GET_UINT32_LE( X[ 3], data, 12 );
GET_UINT32_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movl (%rsi), %ebp
movl 0x4(%rsi), %r12d
movq %r12, -0x58(%rsp)
movl 0x14(%rsi), %r11d
movq %r11, -0x60(%rsp)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %r10d
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %r13d
movl 0x18(%rdi), %r8d
movl %... | /Dragonchang[P]https_client/mbedtls/library/ripemd160.c |
mbedtls_rsa_check_pub_priv | int mbedtls_rsa_check_pub_priv( const mbedtls_rsa_context *pub, const mbedtls_rsa_context *prv )
{
if( mbedtls_rsa_check_pubkey( pub ) != 0 ||
mbedtls_rsa_check_privkey( prv ) != 0 )
{
return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
}
if( mbedtls_mpi_cmp_mpi( &pub->N, &prv->N ) != 0 ||
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe87f
movl $0xffffbe00, %ebp # imm = 0xFFFFBE00
testl %eax, %eax
jne 0xece8
movq %rbx, %rdi
callq 0xe8fd
testl %eax, %eax
jne 0xece8
leaq 0x10(%r14), %rdi
leaq 0x10(%rbx), %rsi
callq 0x15449
testl %eax, %eax
jne 0xece8
addq $0x28, %r14
addq $... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mgf_mask | static void mgf_mask( unsigned char *dst, size_t dlen, unsigned char *src,
size_t slen, mbedtls_md_context_t *md_ctx )
{
unsigned char mask[MBEDTLS_MD_MAX_SIZE];
unsigned char counter[4];
unsigned char *p;
unsigned int hlen;
size_t i, use_len;
memset( mask, 0, MBEDTLS_MD_M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movl $0x0, 0xc(%rsp)
movq (... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_rsa_pkcs1_encrypt | int mbedtls_rsa_pkcs1_encrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t ilen,
const unsigned char *input,
unsigned char *output )
{
switch(... | movq %r9, %r10
movq %r8, %rax
movl 0x148(%rdi), %r8d
cmpl $0x1, %r8d
je 0xf629
testl %r8d, %r8d
jne 0xf646
movq %rax, %r8
movq %r10, %r9
jmp 0xf449
pushq %rax
subq $0x8, %rsp
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq 0x18(%rsp)
pushq %r10
pushq %rax
callq 0xf12f
addq $0x20, %rsp
popq %rcx
retq
movl $0xffffbf00, %eax ... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_rsa_rsassa_pss_verify_ext | int mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
unsi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp # imm = 0x488
movl %r9d, %ebx
movl %r8d, %ebp
movq %rdi, %r14
cmpl $0x1, %ecx
jne 0xff7d
movl $0xffffbf80, %r15d # imm = 0xFFFFBF80
cmpl $0x1, 0x148(%r14)
jne 0x1016f
movq 0x8(%r14), %r12
leaq -0x401(%r12), %rax
cmpq $-0... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_sha256_starts | void mbedtls_sha256_starts( mbedtls_sha256_context *ctx, int is224 )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
if( is224 == 0 )
{
/* SHA-256 */
ctx->state[0] = 0x6A09E667;
ctx->state[1] = 0xBB67AE85;
ctx->state[2] = 0x3C6EF372;
ctx->state[3] = 0xA54FF53A;
c... | pushq %rbp
pushq %rbx
movq $0x0, (%rdi)
testl %esi, %esi
movl $0x6a09e667, %ecx # imm = 0x6A09E667
movl $0xc1059ed8, %eax # imm = 0xC1059ED8
cmovel %ecx, %eax
movl $0xbb67ae85, %ecx # imm = 0xBB67AE85
movl $0x367cd507, %edx # imm = 0x367CD507
cmovel %ecx, %edx
movl $0x3c6ef372, %ecx # imm ... | /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_sha512_update | void mbedtls_sha512_update( mbedtls_sha512_context *ctx, const unsigned char *input,
size_t ilen )
{
size_t fill;
unsigned int left;
if( ilen == 0 )
return;
left = (unsigned int) (ctx->total[0] & 0x7F);
fill = 128 - left;
ctx->total[0] += (uint64_t) ilen;
if( ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x135b1
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl %eax, %ecx
andl $0x7f, %ecx
movq %rax, %rsi
addq %rdx, %rsi
movq %rsi, (%rdi)
jae 0x1351c
incq 0x8(%r14)
xorl %ebp, %ebp
testl %ecx, %ecx
je 0x1353a
movl $0x80,... | /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_sha512 | void mbedtls_sha512( const unsigned char *input, size_t ilen,
unsigned char output[64], int is384 )
{
mbedtls_sha512_context ctx;
mbedtls_sha512_init( &ctx );
mbedtls_sha512_starts( &ctx, is384 );
mbedtls_sha512_update( &ctx, input, ilen );
mbedtls_sha512_finish( &ctx, output );
mb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r14
xorl %r13d, %r13d
movl $0xd8, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa0c0
testl %ebp, %ebp
movabsq $0x6a09e667f3bcc908, %rcx # imm = 0x6A09E667F3BCC908... | /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_asn1_get_tag | int mbedtls_asn1_get_tag( unsigned char **p,
const unsigned char *end,
size_t *len, int tag )
{
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( **p != tag )
return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
(*p)++;
return( mbedtls_asn1_g... | movq (%rdi), %r8
movq %rsi, %rax
subq %r8, %rax
testq %rax, %rax
jle 0x13d9d
movzbl (%r8), %r9d
movl $0xffffff9e, %eax # imm = 0xFFFFFF9E
cmpl %ecx, %r9d
jne 0x13da2
incq %r8
movq %r8, (%rdi)
jmp 0x13ca4
movl $0xffffffa0, %eax # imm = 0xFFFFFFA0
retq
| /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_get_alg | int mbedtls_asn1_get_alg( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_buf *alg, mbedtls_asn1_buf *params )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rcx
movq %rsi, %rax
subq %rcx, %rax
testq %rax, %rax
jle 0x14158
movl $0xffffff9e, %eax # imm = 0xFFFFFF9E
cmpb $0x30, (%rcx)
jne 0x1415d
incq %rcx
movq %rcx, (%r14)
movq %rsp, %rdx... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_mpi_set_bit | int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
{
int ret = 0;
size_t off = pos / biL;
size_t idx = pos % biL;
if( val != 0 && val != 1 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( X->n * biL <= pos )
{
if( val == 0 )
return( 0 );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
cmpb $0x1, %bpl
ja 0x1476e
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
shrq $0x6, %r15
movq 0x8(%rdi), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0x14755
andl $0x3f, %ebx
movq 0x10(%r14), %rax
movq (... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_read_string | int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s )
{
int ret;
size_t i, j, slen, n;
mbedtls_mpi_uint d;
mbedtls_mpi T;
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_mpi_init( &T );
slen = strlen( s );
if( radix == 16 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %r13d
leal -0x11(%r13), %eax
movl $0xfffffffc, %r12d # imm = 0xFFFFFFFC
cmpl $-0xf, %eax
jb 0x149c0
movq %rdx, %rbx
movq %rdi, %r14
movl $0x1, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movq %rdx, %rdi
callq 0... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_add_int | int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_add_mpi( X, A, &_B ) );
} | subq $0x28, %rsp
movq %rdx, %rax
negq %rax
cmovsq %rdx, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
sarq $0x3f, %rdx
orl $0x1, %edx
leaq 0x10(%rsp), %rax
movl %edx, (%rax)
movq $0x1, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x15775
addq $0x28, %rsp
retq
| /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_cmp_abs | int mbedtls_mpi_cmp_abs( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
for( i = X->n; i > 0; i-- )
if( X->p[i - 1] != 0 )
break;
for( j = Y->n; j > 0; j-- )
if( Y->p[j - 1] != 0 )
break;
if( i == 0 && j == 0 )
return( 0 );
if( i > j )... | movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x153f6
movq 0x10(%rdi), %rax
cmpq $0x0, -0x8(%rax,%rcx,8)
jne 0x153f6
decq %rcx
jne 0x153e7
xorl %ecx, %ecx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x15412
movq 0x10(%rsi), %rax
cmpq $0x0, -0x8(%rax,%rdx,8)
jne 0x15412
decq %rdx
jne 0x15403
xorl %edx, %edx
xorl %eax, %eax
movq... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_is_prime | int mbedtls_mpi_is_prime( const mbedtls_mpi *X,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
mbedtls_mpi XX;
XX.s = 1;
XX.n = X->n;
XX.p = X->p;
if( mbedtls_mpi_cmp_int( &XX, 0 ) == 0 ||
mbedtls_mpi_cmp_int( &XX, 1 ) == 0 )... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl $0x1, %ecx
leaq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rdi), %rdx
movq %rdx, 0x10(%rax)
movq %rsp, %r15
movq $0x0, (%r15)
leaq 0x20(%rsp), %rsi
movl %ecx, (%rsi)
movq $0x1, 0... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_gen_prime | int mbedtls_mpi_gen_prime( mbedtls_mpi *X, size_t nbits, int dh_flag,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
size_t k, n;
mbedtls_mpi_uint r;
mbedtls_mpi Y;
if( nbits < 3 || nbits > MBEDTLS_MPI_MAX_BITS )
return( MBEDTLS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
leaq -0x2001(%rsi), %rax
movl $0xfffffffc, %ebp # imm = 0xFFFFFFFC
cmpq $-0x1ffe, %rax # imm = 0xE002
jb 0x183e9
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
movq %r8, 0x8(%rsp... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_ecdsa_sign_det | int mbedtls_ecdsa_sign_det( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s,
const mbedtls_mpi *d, const unsigned char *buf, size_t blen,
mbedtls_md_type_t md_alg )
{
int ret;
mbedtls_hmac_drbg_context rng_ctx;
unsigned char data[2 * MBEDTLS_ECP_MAX_BYTES];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rbp
movl 0x180(%rsp), %edi
movq 0xb8(%rbp), %r12
callq 0xa57b
testq %rax, %rax
je 0x18ec9
movq %rax, %r13
mov... | /Dragonchang[P]https_client/mbedtls/library/ecdsa.c |
mbedtls_ecdsa_write_signature | int mbedtls_ecdsa_write_signature( mbedtls_ecdsa_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hlen,
unsigned char *sig, size_t *slen,
int (*f_rng)(void *, unsigned char *, size_t),
vo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x14310
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x14310
leaq 0xf8(%r13), %rcx
movl ... | /Dragonchang[P]https_client/mbedtls/library/ecdsa.c |
mbedtls_ecp_tls_write_point | int mbedtls_ecp_tls_write_point( const mbedtls_ecp_group *grp, const mbedtls_ecp_point *pt,
int format, size_t *olen,
unsigned char *buf, size_t blen )
{
int ret;
/*
* buffer length must be at least one, for our length byte
*/
if( blen < 1 )
... | testq %r9, %r9
je 0x199ad
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
incq %r8
decq %r9
callq 0x1978f
testl %eax, %eax
jne 0x199a5
movb (%rbx), %al
movb %al, (%r14)
incq (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffb080, %eax # imm = 0xFFFFB080
retq
| /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_ecp_tls_read_group | int mbedtls_ecp_tls_read_group( mbedtls_ecp_group *grp, const unsigned char **buf, size_t len )
{
uint16_t tls_id;
const mbedtls_ecp_curve_info *curve_info;
/*
* We expect at least three bytes (see below)
*/
if( len < 3 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* First ... | movl $0xffffb080, %eax # imm = 0xFFFFB080
cmpq $0x3, %rdx
jb 0x19a12
movq (%rsi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsi)
cmpb $0x3, (%rcx)
jne 0x19a12
leaq 0x2(%rcx), %rax
movq %rax, (%rsi)
movzbl 0x1(%rcx), %eax
shll $0x8, %eax
leaq 0x3(%rcx), %rdx
movq %rdx, (%rsi)
movzbl 0x2(%rcx), %ecx
orl %eax, %ecx
lea... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_ecp_gen_keypair_base | int mbedtls_ecp_gen_keypair_base( mbedtls_ecp_group *grp,
const mbedtls_ecp_point *G,
mbedtls_mpi *d, mbedtls_ecp_point *Q,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret;
size_t n_size = ( grp->nbits + 7... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r12
movq 0x60(%rdi), %rax
movl $0xffffb080, %edx # imm = 0xFFFFB080
testq %rax, %rax
je 0x1b647
movq %r9, %rbx
movq %r8, %r14
movq %rsi, %rbp
movq %rcx, 0x28(%rsp)
movq 0xb8(%rdi), %r13
addq $0x7, %r13
movq %r13, %r15
s... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_ecp_self_test | int mbedtls_ecp_self_test( int verbose )
{
int ret;
size_t i;
mbedtls_ecp_group grp;
mbedtls_ecp_point R, P;
mbedtls_mpi m;
unsigned long add_c_prev, dbl_c_prev, mul_c_prev;
/* exponents especially adapted for secp192r1 */
const char *exponents[] =
{
"000000000000000000000000... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %edi, %ebx
leaq 0xc0(%rsp), %r14
movl $0xf8, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa0c0
leaq 0x30(%rsp), %rdi
callq 0x14310
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x14310
leaq 0x60(%rsp), %r12
m... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
ecp_safe_invert_jac | static int ecp_safe_invert_jac( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *Q,
unsigned char inv )
{
int ret;
unsigned char nonzero;
mbedtls_mpi mQY;
mbedtls_mpi_init( &mQY );
/* Use the fact that -Q.Y mod P = P - Q.Y unless Q.Y == 0 */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x14310
addq $0x8, %r14
addq $0x18, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x157e3
movl %eax, %r14d
testl %eax, %eax
jne 0x1c380
movq %rbx, %rdi
xorl %es... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
ecp_mod_p224k1 | static int ecp_mod_p224k1( mbedtls_mpi *N )
{
static mbedtls_mpi_uint Rp[] = {
BYTES_TO_T_UINT_8( 0x93, 0x1A, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 ) };
#if defined(MBEDTLS_HAVE_INT64)
return( ecp_mod_koblitz( N, Rp, 4, 1, 32, 0xFFFFFFFF ) );
#else
return( ecp_mod_koblitz( N, Rp, 224 / 8 / sizeof( mbe... | leaq 0x1df4f(%rip), %rsi # 0x3c0e8
movl $0x4, %edx
movl $0x1, %ecx
movl $0x20, %r8d
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
jmp 0x1e2a7
| /Dragonchang[P]https_client/mbedtls/library/ecp_curves.c |
mbedtls_hmac_drbg_seed | int mbedtls_hmac_drbg_seed( mbedtls_hmac_drbg_context *ctx,
const mbedtls_md_info_t * md_info,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const unsigned char *custom,
size_t len )
{
int ret;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movl $0x1, %edx
callq 0xa642
testl %eax, %eax
jne 0x1e75e
movq %rbp, %rdi
callq 0xab31
movzbl %al, %ebp
movq %r14, (%rsp)
leaq 0x18(%rbx), %r14
movq ... | /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c |
mbedtls_md5_update | void mbedtls_md5_update( mbedtls_md5_context *ctx, const unsigned char *input, size_t ilen )
{
size_t fill;
uint32_t left;
if( ilen == 0 )
return;
left = ctx->total[0] & 0x3F;
fill = 64 - left;
ctx->total[0] += (uint32_t) ilen;
ctx->total[0] &= 0xFFFFFFFF;
if( ctx->total[0] <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x1f574
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %edx, %esi
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x1f4e3
incl 0x4(%r14)
xorl %ebp, %ebp
testl %eax, %eax
je 0x1f501
movl $0x40,... | /Dragonchang[P]https_client/mbedtls/library/md5.c |
mbedtls_md5_finish | void mbedtls_md5_finish( mbedtls_md5_context *ctx, unsigned char output[16] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_LE( low, msglen, 0 );
PUT_UINT32_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shldl $0x3, %eax, %ecx
leal (,%rax,8), %edx
leaq 0x8(%rsp), %r15
movb %dl, (%r15)
movl %eax, %edx
shrl $0x5, %edx
movb %dl, 0x1(%r15)
movl %eax, %edx
shrl $0xd, %edx
movb %dl, 0x2(%r15)
movl %eax, %e... | /Dragonchang[P]https_client/mbedtls/library/md5.c |
mbedtls_md5_self_test | int mbedtls_md5_self_test( int verbose )
{
int i;
unsigned char md5sum[16];
for( i = 0; i < 7; i++ )
{
if( verbose != 0 )
mbedtls_printf( " MD5 test #%d: ", i + 1 );
mbedtls_md5( md5_test_buf[i], md5_test_buflen[i], md5sum );
if( memcmp( md5sum, md5_test_sum[i], 1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movl $0x1, %ebp
leaq 0xd503(%rip), %r12 # 0x2cc20
leaq 0xd29c(%rip), %r14 # 0x2c9c0
movq %rsp, %r15
xorl %r13d, %r13d
testl %ebx, %ebx
je 0x1f73e
leaq 0xd26b(%rip), %rdi # 0x2c9a0
movl %ebp, %esi
xorl %eax,... | /Dragonchang[P]https_client/mbedtls/library/md5.c |
pem_pbkdf1 | static void pem_pbkdf1( unsigned char *key, size_t keylen,
unsigned char *iv,
const unsigned char *pwd, size_t pwdlen )
{
mbedtls_md5_context md5_ctx;
unsigned char md5sum[16];
size_t use_len;
mbedtls_md5_init( &md5_ctx );
/*
* key[ 0..15] = MD5... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x1ecac
movq %rbp, %rdi
callq 0x1ece8
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1f4b6
movl $0x8, %ed... | /Dragonchang[P]https_client/mbedtls/library/pem.c |
mbedtls_pkcs12_derivation | int mbedtls_pkcs12_derivation( unsigned char *data, size_t datalen,
const unsigned char *pwd, size_t pwdlen,
const unsigned char *salt, size_t saltlen,
mbedtls_md_type_t md_type, int id, int iterations )
{
int ret;
unsigned int j;
unsigne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rcx, %r13
movq %rdx, 0x20(%rsp)
cmpq $0x81, %rsi
setae %al
cmpq $0x41, %rcx
setae %cl
orb %al, %cl
cmpq $0x41, %r9
setae %al
orb %cl, %al
movl $0xffffe080, %r14d # imm = 0xFFFFE080
jne 0x20fbb
movq %r... | /Dragonchang[P]https_client/mbedtls/library/pkcs12.c |
mbedtls_aes_crypt_ecb | int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
return( mbe... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x2000000, %edi # imm = 0x2000000
callq 0x23200
movq %r15, %rdi
testl %eax, %eax
je 0x22873
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
po... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aesni_inverse_key | void mbedtls_aesni_inverse_key( unsigned char *invkey,
const unsigned char *fwdkey, int nr )
{
unsigned char *ik = invkey;
const unsigned char *fk = fwdkey + 16 * nr;
memcpy( ik, fk, 16 );
for( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 )
asm( "movdqu (%0), %%x... | shll $0x4, %edx
movslq %edx, %rax
addq %rsi, %rax
addq $-0x10, %rax
movups 0x10(%rax), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
cmpq %rsi, %rax
jbe 0x23405
movdqu (%rax), %xmm0
aesimc %xmm0, %xmm0
movdqu %xmm0, (%rdi)
addq $-0x10, %rax
jmp 0x233e9
movups (%rax), %xmm0
movups %xmm0, (%rdi)
retq
| /Dragonchang[P]https_client/mbedtls/library/aesni.c |
mbedtls_asn1_write_len | int mbedtls_asn1_write_len( unsigned char **p, unsigned char *start, size_t len )
{
if( len < 0x80 )
{
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (unsigned char) len;
return( 1 );
}
if( len <= 0xFF )
{
if( *p - start < 2 )
... | cmpq $0x7f, %rdx
ja 0x2385a
movq (%rdi), %rcx
movq %rcx, %rax
subq %rsi, %rax
testq %rax, %rax
jle 0x238db
movl $0x1, %eax
jmp 0x2399a
cmpq $0xff, %rdx
ja 0x23894
movq (%rdi), %rcx
movq %rcx, %r8
subq %rsi, %r8
movl $0xffffff94, %eax # imm = 0xFFFFFF94
cmpq $0x2, %r8
jl 0x239a4
leaq -0x1(%rcx), %rax
movq %rax, (%... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_asn1_write_bool | int mbedtls_asn1_write_bool( unsigned char **p, unsigned char *start, int boolean )
{
int ret;
size_t len = 0;
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (boolean) ? 255 : 0;
len++;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
... | movq (%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
testq %rcx, %rcx
jle 0x23cb5
xorl %ecx, %ecx
negl %edx
sbbl %ecx, %ecx
leaq -0x1(%rax), %rdx
movq %rdx, (%rdi)
movb %cl, -0x1(%rax)
movq (%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
testq %rcx, %rcx
jle 0x23cbb
leaq -0x1(%rax), %rdx
movq %rdx, (%rdi)
movb $0x1, -0x1(%ra... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_asn1_write_int | int mbedtls_asn1_write_int( unsigned char **p, unsigned char *start, int val )
{
int ret;
size_t len = 0;
// TODO negative values and values larger than 128
// DER format assumes 2s complement for numbers, so the leftmost bit
// should be 0 for positive numbers and 1 for negative numbers.
//
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rcx
movq %rcx, %rsi
subq %r14, %rsi
movl $0xffffff94, %eax # imm = 0xFFFFFF94
testq %rsi, %rsi
jle 0x23d97
movq %rdi, %rbx
leaq -0x1(%rcx), %rsi
movq %rsi, (%rdi)
movb %dl, -0x1(%rcx)
movl $0x1, %r15d
testl %edx, %edx
jle 0x23d51
movq (%rbx), %rcx
cmp... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_asn1_store_named_data | mbedtls_asn1_named_data *mbedtls_asn1_store_named_data( mbedtls_asn1_named_data **head,
const char *oid, size_t oid_len,
const unsigned char *val,
size_t val_len )
{
mbedtls_asn1_named_data *cur;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x142d0
testq %rax, %rax
je 0x2407f
movq %rax, %rbx
cmpq %r14, 0x20(%rax)
jae 0x240f3
movq %r15, %r12
movl $0x1, %edi
movq %r14, %rsi
callq ... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_cipher_info_from_values | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
int key_bitlen,
const mbedtls_cipher_mode_t mode )
{
const mbedtls_cipher_definition_t *def;
for( def = mbedtls_cipher_d... | leaq 0x17152(%rip), %rcx # 0x3b780
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x2465a
addq $0x18, %rcx
movq 0x28(%rax), %r8
cmpl %edi, (%r8)
jne 0x2464e
cmpl %esi, 0x8(%rax)
jne 0x2464e
cmpl %edx, 0x4(%rax)
je 0x2465c
movq (%rcx), %rax
addq $0x10, %rcx
testq %rax, %rax
jne 0x2463b
xorl %eax, %eax
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_update_ad | int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
const unsigned char *ad, size_t ad_len )
{
if( NULL == ctx || NULL == ctx->cipher_info )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
return mbedtls_gcm_star... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x24874
movq %rdx, %r9
movq %rdi, %rdx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x24874
xorl %eax, %eax
cmpl $0x6, 0x4(%rcx)
jne 0x24874
movq %rsi, %r8
movq 0x50(%rdx), %rdi
movl 0xc(%rdx), %esi
movq 0x48(%rdx), %rcx
addq $0x38, %rdx
jmp 0x26adc
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_finish | int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
unsigned char *output, size_t *olen )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
*olen = 0;
if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
MBEDT... | pushq %r15
pushq %r14
pushq %rbx
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x24c75
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rbx, %rbx
sete %sil
orb %dl, %sil
jne 0x24c75
movq $0x0, (%rbx)
movl 0x4(%rcx), %edx
decl %edx
cmpl $0x6, %edx
j... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
get_pkcs_padding | static int get_pkcs_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
size_t i, pad_idx;
unsigned char padding_len, bad = 0;
if( NULL == input || NULL == data_len )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
padding_len = input[input_len - 1];
*data_len = inpu... | testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
jne 0x24d07
movzbl -0x1(%rdi,%rsi), %ecx
testq %rcx, %rcx
sete %r9b
movq %rsi, %r8
subq %rcx, %r8
setb %al
movq %r8, (%rdx)
orb %r9b, %al
testq %rsi, %rsi
je 0x24cfb
xorl %edx, %edx
xorl %r9d, %r9d
movb (%rd... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
get_one_and_zeros_padding | static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
size_t i;
unsigned char done = 0, prev_done, bad;
if( NULL == input || NULL == data_len )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
bad = 0xFF;
*data_... | testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
jne 0x24da1
movq $0x0, (%rdx)
testq %rsi, %rsi
je 0x24da2
movq (%rdx), %rax
decq %rsi
xorl %r8d, %r8d
movb $-0x1, %cl
xorl %r9d, %r9d
cmpb $0x0, (%rdi,%rsi)
setne %r9b
orl %r8d, %r9d
cmpl %r8d, %r9d
sete %r8... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_write_tag | int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
unsigned char *tag, size_t tag_len )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_ENCRYPT != ctx->operation )
return( MBEDTLS_ERR_CIPHER_... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x24ef9
movq (%rdi), %rcx
testq %rcx, %rcx
sete %r8b
testq %rsi, %rsi
sete %r9b
orb %r8b, %r9b
jne 0x24ef9
cmpl $0x1, 0xc(%rdi)
jne 0x24ef9
xorl %eax, %eax
cmpl $0x6, 0x4(%rcx)
jne 0x24ef9
movq 0x50(%rdi), %rdi
jmp 0x26f45
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
blowfish_ctx_alloc | static void * blowfish_ctx_alloc( void )
{
mbedtls_blowfish_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_blowfish_init( ctx );
return( ctx );
} | pushq %rbx
movl $0x1, %edi
movl $0x1048, %esi # imm = 0x1048
callq 0xa0e0
testq %rax, %rax
je 0x2530b
movq %rax, %rbx
movq %rax, %rdi
callq 0x277c4
jmp 0x2530d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher_wrap.c |
mbedtls_des_setkey | void mbedtls_des_setkey( uint32_t SK[32], const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
uint32_t X, Y, T;
GET_UINT32_BE( X, key, 0 );
GET_UINT32_BE( Y, key, 4 );
/*
* Permuted Choice 1
*/
T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
T = ((Y ) ^ X) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, -0x8(%rsp)
movzbl (%rsi), %ecx
movl %ecx, %eax
shll $0x18, %eax
movzbl 0x1(%rsi), %edx
shll $0x10, %edx
orl %eax, %edx
movzbl 0x2(%rsi), %eax
shll $0x8, %eax
movzbl 0x3(%rsi), %r8d
orl %edx, %r8d
orl %eax, %r8d
movl 0x4(%rsi), %edx
bswapl %edx... | /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_des_setkey_dec | int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
mbedtls_des_setkey( ctx->sk, key );
for( i = 0; i < 16; i += 2 )
{
SWAP( ctx->sk[i ], ctx->sk[30 - i] );
SWAP( ctx->sk[i + 1], ctx->sk[31 - i] );
}
return( 0 );
} | pushq %rbx
movq %rdi, %rbx
callq 0x2551b
leaq 0x7c(%rbx), %rax
movq $-0x2, %rcx
movl 0x8(%rbx,%rcx,4), %edx
movl -0x4(%rax), %esi
movl %esi, 0x8(%rbx,%rcx,4)
movl %edx, -0x4(%rax)
movl 0xc(%rbx,%rcx,4), %edx
movl (%rax), %esi
movl %esi, 0xc(%rbx,%rcx,4)
movl %edx, (%rax)
addq $0x2, %rcx
addq $-0x8, %rax
cmpq $0xe, %rcx... | /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_des_crypt_ecb | int mbedtls_des_crypt_ecb( mbedtls_des_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i < 8... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x10(%rsp)
movq %rdi, -0x8(%rsp)
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
bswapl %ecx
bswapl %eax
movl %ecx, %edx
shrl $0x4, %edx
xorl %eax, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %eax
shll $0x4, %edx
xorl %ecx, %edx
mov... | /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_des_crypt_cbc | int mbedtls_des_crypt_cbc( mbedtls_des_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[8];
if( length % 8 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl $0xffffffce, %eax # imm = 0xFFFFFFCE
testb $0x7, %r12b
jne 0x25ebe
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r13
cmpl $0x1, %esi
jne 0x25e83
testq %r12, %r12
je 0x25ebc
xorl %eax, %eax
movb (%r15,%rax... | /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_des3_crypt_ecb | int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movl (%rsi), %eax
movl 0x4(%rsi), %ecx
bswapl %eax
bswapl %ecx
movl %eax, %edx
shrl $0x4, %edx
xorl %ecx, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %ecx
shll $0x4, %edx
xorl %eax, %edx
movl %edx, %esi
shrl $0x10... | /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_gcm_starts | int mbedtls_gcm_starts( mbedtls_gcm_context *ctx,
int mode,
const unsigned char *iv,
size_t iv_len,
const unsigned char *add,
size_t add_len )
{
int ret;
unsigned char work_buf[16];
size_t i;
const unsigned char *p;
size... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq $0x0, 0x20(%rsp)
movq %r9, %rax
orq %rcx, %rax
shrq $0x3d, %rax
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
jne 0x26c85
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rdi, %r15
leaq 0x178(%rdi), %r9
xorps %x... | /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_gcm_update | int mbedtls_gcm_update( mbedtls_gcm_context *ctx,
size_t length,
const unsigned char *input,
unsigned char *output )
{
int ret;
unsigned char ectr[16];
size_t i;
const unsigned char *p;
unsigned char *out_p = output;
size_t use_len, olen = 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq $0x0, 0x8(%rsp)
movq %rcx, %rax
subq %rdx, %rax
seta %cl
cmpq %rsi, %rax
setb %dl
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
testb %dl, %cl
jne 0x26f36
movq %rsi, %r15
movq %rdi, %r12
movq 0x158(... | /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_gcm_finish | int mbedtls_gcm_finish( mbedtls_gcm_context *ctx,
unsigned char *tag,
size_t tag_len )
{
unsigned char work_buf[16];
size_t i;
uint64_t orig_len = ctx->len * 8;
uint64_t orig_add_len = ctx->add_len * 8;
if( tag_len > 16 || tag_len < 4 )
return( MBEDTLS_ERR_GC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x11(%rdx), %rax
movl $0xffffffec, %r15d # imm = 0xFFFFFFEC
cmpq $-0xd, %rax
jb 0x27085
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r12
movq 0x158(%rdi), %r15
movq 0x160(%rdi), %rbx
shlq $0x3, %r15
shlq $0x3, %rbx
leaq 0x168(%... | /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_gcm_auth_decrypt | int mbedtls_gcm_auth_decrypt( mbedtls_gcm_context *ctx,
size_t length,
const unsigned char *iv,
size_t iv_len,
const unsigned char *add,
size_t add_len,
const unsigned char *tag,
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rax
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rbx
movq 0x48(%rsp), %r14
movq 0x38(%rsp), %r15
subq $0x8, %rsp
leaq 0x8(%rsp), %r10
xorl %esi, %esi
movq %rbx, %rdx
pushq %r10
pushq %r15
pushq %r14
pushq 0x60(%rsp)
pushq %rax
callq 0x27097
addq $... | /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_blowfish_crypt_ecb | int mbedtls_blowfish_crypt_ecb( mbedtls_blowfish_context *ctx,
int mode,
const unsigned char input[MBEDTLS_BLOWFISH_BLOCKSIZE],
unsigned char output[MBEDTLS_BLOWFISH_BLOCKSIZE] )
{
uint32_t X0, X1;
GET_UINT32_BE( X0, input, 0 );
GET_UINT32_BE( X1... | pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %ecx
bswapl %ecx
movl %ecx, 0xc(%rsp)
movl 0x4(%rdx), %eax
bswapl %eax
movl %eax, 0x8(%rsp)
testl %esi, %esi
je 0x279d3
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x27936
jmp 0x27a3d
movl $0x12, %edx
movl $0xff, %esi
movl %eax, %r8d
movl %ecx, %eax
xorl -0x4... | /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
mbedtls_blowfish_crypt_cbc | int mbedtls_blowfish_crypt_cbc( mbedtls_blowfish_context *ctx,
int mode,
size_t length,
unsigned char iv[MBEDTLS_BLOWFISH_BLOCKSIZE],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char tem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl $0xffffffe8, %eax # imm = 0xFFFFFFE8
testb $0x7, %r12b
jne 0x27b08
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %r13
testl %esi, %esi
je 0x27ac6
testq %r12, %r12
je 0x27b06
xorl %eax, %eax... | /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
mbedtls_camellia_setkey_dec | int mbedtls_camellia_setkey_dec( mbedtls_camellia_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int idx, ret;
size_t i;
mbedtls_camellia_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_camellia_init( &cty );
/* Also checks keybits */
if( ( r... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movl $0x114, %edx # imm = 0x114
movq %r15, %rdi
xorl %esi, %esi
callq 0xa0c0
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x27c9b
testl %eax, %e... | /Dragonchang[P]https_client/mbedtls/library/camellia.c |
mbedtls_camellia_crypt_ecb | int mbedtls_camellia_crypt_ecb( mbedtls_camellia_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
int NR;
uint32_t *RK, X[4];
( (void) mode );
NR = ctx->nr;
RK = ctx->rk;
GET_UINT32_BE( X[0], input,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl (%rdi), %ebp
movl (%rdx), %eax
bswapl %eax
movl %eax, (%rsp)
movl 0x4(%rdx), %esi
bswapl %esi
movl %esi, 0x4(%rsp)
movl 0x8(%rdx), %edi
bswapl %edi
movl %edi, 0x8(%rsp)
movl 0xc(%rdx), %edx
bswapl %edx
movl %edx, 0xc... | /Dragonchang[P]https_client/mbedtls/library/camellia.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2a88
movl $0x6, %edi
leaq 0x604(%rip), %rsi # 0x3098
callq 0x20a0
cmpl $0x2, -0x8(%rbp)
jge 0x2ac0
movq 0x253a(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0x6b7(%rip), %rsi # 0x3167
movb... | /pelya[P]curl/tests/libtest/first.c |
curlx_uitouc | unsigned char curlx_uitouc(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_UCHAR);
return (unsigned char) (uinum & (unsigned int) CURL_MASK_UCHAR);
#ifdef __INTEL_CO... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x2d19
movl -0x4(%rbp), %eax
andl $0xff, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /pelya[P]curl/lib/warnless.c |
curlx_uitosi | int curlx_uitosi(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
return (int) (uinum & (unsigned int) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warni... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x2d39
movl -0x4(%rbp), %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /pelya[P]curl/lib/warnless.c |
api_dynamic_suite::dynamic_remove_back_n() | void dynamic_remove_back_n()
{
int array[4] = { 11, 22, 33, 44 };
vista::span<int> span(array);
BOOST_TEST_EQ(span.size(), 4);
BOOST_TEST_EQ(span.back(), 44);
span.remove_back(2);
BOOST_TEST_EQ(span.size(), 2);
BOOST_TEST_EQ(span.back(), 22);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps 0x39a4(%rip), %xmm0 # 0x5d10
leaq 0x2c(%rsp), %r13
movaps %xmm0, -0xc(%r13)
leaq 0x10(%rsp), %r12
movq $0x4, (%r12)
leaq 0x1c(%rsp), %r15
movl $0x4, (%r15)
movq %r15, (%rsp)
leaq 0x30cf(%rip), %rdi # 0x5469
leaq 0x2fb7(%r... | /breese[P]vista/test/span_suite.cpp |
QtMWidgets::ScrollArea::qt_metacall(QMetaObject::Call, int, void**) | int QtMWidgets::ScrollArea::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = AbstractScrollArea::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::Res... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x5fea2
movl %eax, %ebx
testl %eax, %eax
js 0x61a27
cmpl $0x8, %ebp
ja 0x61a27
movl $0x14e, %eax # imm = 0x14E
btl %ebp, %eax
jae 0x61a27
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
movq %r14, %rc... | /igormironchik[P]qtmwidgets/build_O2/src/QtMWidgets_autogen/EWIEGA46WW/moc_scrollarea.cpp |
QtMWidgets::Stepper::mouseReleaseEvent(QMouseEvent*) | void
Stepper::mouseReleaseEvent( QMouseEvent * event )
{
if( event->button() == Qt::LeftButton )
{
d->button = StepperPrivate::NoButton;
d->timer->stop();
event->accept();
}
else
event->ignore();
} | pushq %rbx
movq %rsi, %rbx
cmpl $0x1, 0x40(%rsi)
jne 0x66171
movq 0x28(%rdi), %rax
andl $0x0, 0x30(%rax)
movq 0x38(%rax), %rdi
callq 0x5cea0
movb $0x1, %al
jmp 0x66173
xorl %eax, %eax
movb %al, 0xc(%rbx)
popq %rbx
retq
| /igormironchik[P]qtmwidgets/src/stepper.cpp |
QtMWidgets::ScrollIndicator::ScrollIndicator(QColor const&, Qt::Orientation, QWidget*) | ScrollIndicator::ScrollIndicator( const QColor & c, Qt::Orientation o,
QWidget * parent )
: QWidget( parent )
, policy( AbstractScrollArea::ScrollIndicatorAsNeeded )
, minimumSize( 10 )
, size( minimumSize )
, width( 3 )
, orientation( o )
, needPaint( false )
, color( c )
, animate( false )
, alp... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rcx, %rsi
xorl %edx, %edx
callq 0x5ccb0
leaq 0x447a2(%rip), %rax # 0xaab30
leaq 0x10(%rax), %rcx
movq %rcx, (%r15)
addq $0x1c0, %rax # imm = 0x1C0
movq %rax, 0x10(%r15)
movaps 0x25... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::ScrollIndicator::drawIndicator(QPainter*, QColor const&) | void
ScrollIndicator::drawIndicator( QPainter * p, const QColor & c )
{
if( policy != AbstractScrollArea::ScrollIndicatorAlwaysOff )
{
QColor paintColor = c;
if( animate && policy != AbstractScrollArea::ScrollIndicatorAlwaysOn )
paintColor.setAlpha( alpha );
p->setPen( QPen( paintColor, width, Qt... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x66532
movq %rsi, %rbx
movq %rdi, %r14
movups (%rdx), %xmm0
movaps %xmm0, 0x10(%rsp)
cmpl $0x2, %eax
je 0x664b2
cmpb $0x0, 0x58(%r14)
je 0x664b2
movl 0x5c(%r14), %esi
leaq 0x10(%rsp), %rdi
callq 0x5c180
leaq 0x8(%rsp)... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::BlurEffect::BlurEffect(QColor const&, Qt::Orientation, QWidget*) | BlurEffect::BlurEffect( const QColor & c, Qt::Orientation o, QWidget * parent )
: QWidget( parent )
, policy( AbstractScrollArea::BlurAlwaysOff )
, orientation( o )
, color( c )
, pressure( 0 )
, darkBlurWidth( 4 )
, maxPressure( 20.0 )
{
} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rsi
xorl %edx, %edx
callq 0x5ccb0
leaq 0x447b2(%rip), %rax # 0xaad30
leaq 0x10(%rax), %rcx
movq %rcx, (%r15)
addq $0x1c0, %rax # imm = 0x1C0
movq %rax, 0x10(%r15)
movl $0x3, 0x28(%r15)
movl %ebx, 0x2c(%r15)
movup... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::BlurEffect::drawBlur(QPainter*, QColor const&) | void
BlurEffect::drawBlur( QPainter * p, const QColor & c )
{
const QRect r = rect();
const qreal realPressure = qMin(
(qreal) qAbs( pressure ) / maxPressure, 1.0 );
QColor c1 = c;
c1.setAlpha( 255 * realPressure );
const QRect dark(
( orientation == Qt::Vertical ? r.x() + r.width() / 2 - 2 : r.... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
callq 0x5ed0a
movq %rax, %r14
movl 0x40(%r13), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cvtsi2sd %ecx, %xmm0
divsd 0x48(%r13), %xmm0
minsd 0x24f45(%rip), %xmm0 # 0x8b660
movq %rdx, %r15
mov... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::init() | void
AbstractScrollAreaPrivate::init()
{
QStyleOption opt;
opt.initFrom( q );
const QColor ic = opt.palette.color( QPalette::Highlight );
viewport = new QWidget( q );
viewport->setObjectName( QLatin1String( "qt_scrollarea_viewport" ) );
viewport->setBackgroundRole( QPalette::Base );
viewport->setAut... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5dc50
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x5c160
leaq 0x50(%rsp), %rdi
pushq $0xc
popq %rsi
callq 0x5f828
movups (%rax), %xmm0
movaps %xmm0, (%rsp)
pushq $0x28
popq %rdi
call... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::layoutChildren(QStyleOption const&) | void
AbstractScrollAreaPrivate::layoutChildren( const QStyleOption & opt )
{
QRect viewportRect = q->contentsRect();
if( q->isRightToLeft() )
viewportRect.adjust( right, top, -left, -bottom );
else
viewportRect.adjust( left, top, -right, -bottom );
viewport->setGeometry( QStyle::visualRect( opt.dire... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x5c970
movq %rax, %r13
movq %rdx, %r12
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq 0x8(%rbx), %rdi
callq 0x685fc
movzbl %al, %ecx
xorb $0x1, %al
movzbl %al... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::normalizePosition() | void
AbstractScrollAreaPrivate::normalizePosition()
{
if( topLeftCorner.x() < 0 )
topLeftCorner.setX( 0 );
if( topLeftCorner.y() < 0 )
topLeftCorner.setY( 0 );
const QSize s = viewport->size();
const QPoint maxPos = QPoint( scrolledAreaSize.width() - s.width(),
scrolledAreaSize.height() - s.hei... | pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x30(%rdi)
jns 0x66c1e
andl $0x0, 0x30(%rbx)
cmpl $0x0, 0x34(%rbx)
jns 0x66c28
andl $0x0, 0x34(%rbx)
movq 0x20(%rbx), %rdi
callq 0x6860a
movq %rax, %rcx
shrq $0x20, %rcx
movl 0x28(%rbx), %edi
movl 0x2c(%rbx), %edx
xorl %esi, %esi
subl %eax, %edi
jle 0x66c4b
movl %edi, %esi
cmpl 0x3... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::calcIndicator(Qt::Orientation, int, int, bool&, int&, QPoint&) | void
AbstractScrollAreaPrivate::calcIndicator( Qt::Orientation orient,
int minSize, int width, bool & needPaint,
int & indicatorSize, QPoint & indicatorPos )
{
int viewportSize = 0;
int scrolledSize = 0;
int x = 0;
int y = 0;
double posRatio = 0.0;
int totalIndicatorSize = 0;
double ratio = 0.0;
d... | pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %esi
je 0x66dd5
cmpl $0x1, %esi
jne 0x66eed
movq 0x20(%rdi), %r10
movq 0x20(%r10), %rsi
movl 0x1c(%rsi), %ebp
movl 0x20(%rsi), %eax
subl 0x14(%rsi), %ebp
incl %ebp
movl 0x28(%rdi), %ebx
subl 0x18(%rsi), %eax
leal (%rcx,%rcx), %esi
incl %eax
movl 0x2c(%rdi), %r11d
cmpl %r11d, ... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::makeBlurEffectIfNeeded() | void
AbstractScrollAreaPrivate::makeBlurEffectIfNeeded()
{
if( horBlur->policy != AbstractScrollArea::BlurAlwaysOff )
{
const QRect r = viewport->rect();
const QPoint p = topLeftCorner;
normalizePosition();
const QSize s = viewport->size();
const QPoint maxPos = QPoint( scrolledAreaSize.wid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x88(%rdi), %rax
cmpl $0x3, 0x28(%rax)
jne 0x66ffe
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x66c10
movq 0x20(%rbx), %rdi
callq 0x5ed0a
movq %rax, %r15
movq %rd... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::animateScrollIndicators() | void
AbstractScrollAreaPrivate::animateScrollIndicators()
{
animationTimer->stop();
horIndicator->alpha = horIndicator->color.alpha();
vertIndicator->alpha = vertIndicator->color.alpha();
animationTimer->start( animationTimeout );
if( horIndicator->needPaint )
{
horIndicator->animate = true;
horIn... | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x5cea0
movq 0x58(%rbx), %rdi
addq $0x48, %rdi
callq 0x5c470
movq 0x58(%rbx), %rcx
movl %eax, 0x5c(%rcx)
movq 0x60(%rbx), %rdi
addq $0x48, %rdi
callq 0x5c470
movq 0x60(%rbx), %rcx
movl %eax, 0x5c(%rcx)
movq 0x68(%rbx), %rdi
movl 0x78(%rbx), %esi
callq 0x5cfa0
movq ... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollArea::AbstractScrollArea(QWidget*) | AbstractScrollArea::AbstractScrollArea( QWidget * parent )
: QFrame( parent )
, d( new AbstractScrollAreaPrivate( this ) )
{
d->init();
connect( d->animationTimer, &QTimer::timeout,
this, &AbstractScrollArea::_q_animateScrollIndicators );
connect( d->startBlurAnimTimer, &QTimer::timeout,
this, &Abs... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorl %edx, %edx
callq 0x5d7f0
leaq 0x3f8ae(%rip), %rax # 0xa6e78
leaq 0x10(%rax), %rcx
movq %rcx, (%rbx)
addq $0x1d8, %rax # imm = 0x1D8
movq %rax, 0x10(%rbx)
movl $0xa8, %edi
callq 0x5d090
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6862... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollArea::AbstractScrollArea(QtMWidgets::AbstractScrollAreaPrivate*, QWidget*) | AbstractScrollArea::AbstractScrollArea( AbstractScrollAreaPrivate * dd,
QWidget * parent )
: QFrame( parent )
, d( dd )
{
d->init();
connect( d->animationTimer, &QTimer::timeout,
this, &AbstractScrollArea::_q_animateScrollIndicators );
connect( d->startBlurAnimTimer, &QTimer::timeout,
this, &Abst... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
xorl %edx, %edx
callq 0x5d7f0
leaq 0x3f448(%rip), %rax # 0xa6e78
leaq 0x10(%rax), %rcx
movq %rcx, (%rbx)
addq $0x1d8, %rax # imm = 0x1D8
movq %rax, 0x10(%rbx)
movq %r14, 0x28(%rbx)
movq %r14, %rdi
callq 0x66832
movq 0x... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollArea::setViewportMargins(int, int, int, int) | void
AbstractScrollArea::setViewportMargins( int left, int top,
int right, int bottom )
{
d->left = left;
d->top = top;
d->right = right;
d->bottom = bottom;
QStyleOption opt;
opt.initFrom( this );
d->layoutChildren( opt );
d->normalizePosition();
d->calcIndicators();
update();
d->horIndic... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movl %esi, 0x44(%rax)
movl %edx, 0x38(%rax)
movl %ecx, 0x40(%rax)
movl %r8d, 0x3c(%rax)
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5dc50
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5c160
movq 0x28(%rbx), %rdi... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollArea::resizeEvent(QResizeEvent*) | void
AbstractScrollArea::resizeEvent( QResizeEvent * e )
{
QStyleOption opt;
opt.initFrom( this );
d->layoutChildren( opt );
d->normalizePosition();
d->calcIndicators();
update();
e->accept();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
pushq $0x1
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x5dc50
movq %r15, %rdi
movq %r14, %rsi
callq 0x5c160
movq 0x28(%r14), %rdi
movq %rsp, %rsi
callq 0x66afc
movq 0x28(%r14), %rdi
callq 0x66c10
movq 0x28(%r14), %rdi... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollArea::mouseReleaseEvent(QMouseEvent*) | void
AbstractScrollArea::mouseReleaseEvent( QMouseEvent * e )
{
if( e->button() == Qt::LeftButton )
{
d->leftMouseButtonPressed = false;
if( ( d->horIndicator->needPaint || d->vertIndicator->needPaint ) &&
( d->horIndicator->policy == ScrollIndicatorAsNeeded ||
d->vertIndicator->policy == ScrollI... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, 0x40(%rsi)
jne 0x683f5
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movb $0x0, 0x48(%rdi)
movq 0x58(%rdi), %rax
cmpb $0x0, 0x44(%rax)
jne 0x683de
movq 0x60(%rdi), %rcx
cmpb $0x1, 0x44(%rcx)
jne 0x683ee
cmpl $0x0, 0x28(%rax)
je 0x683f9
movq 0x60(%rdi), %rax
cmpl $0x0,... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.