name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
irr::io::CXMLReaderImpl<unsigned short, irr::io::IXMLBase>::equalsn(unsigned short const*, unsigned short const*, int) | bool equalsn(const char_type* str1, const char_type* str2, int len)
{
int i;
for(i=0; str1[i] && str2[i] && i < len; ++i)
if (str1[i] != str2[i])
return false;
// if one (or both) of the strings was smaller then they
// are only equal if they have the same lenght
return (i == len) || (str1[i] == 0 && str2[i] == 0);
} | movzwl (%rsi), %eax
testw %ax, %ax
je 0x5467f6
movslq %ecx, %r8
xorl %edi, %edi
cmpq %r8, %rdi
jge 0x546807
movzwl (%rdx,%rdi,2), %r9d
testw %r9w, %r9w
je 0x546807
cmpw %r9w, %ax
jne 0x54680d
movzwl 0x2(%rsi,%rdi,2), %eax
incq %rdi
testw %ax, %ax
jne 0x5467cf
movl %edi, %esi
jmp 0x5467fa
xorl %esi, %esi
xorl %edi, %edi
movb $0x1, %al
cmpl %ecx, %esi
je 0x54680c
cmpw $0x0, (%rdx,%rdi,2)
jmp 0x546809
cmpl %edi, %ecx
sete %al
retq
xorl %eax, %eax
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::core::string<unsigned short>::subString(int, int) | string<T> subString(s32 begin, s32 length)
{
if (length <= 0)
return string<T>("");
string<T> o;
o.reserve(length+1);
for (s32 i=0; i<length; ++i)
o.array[i] = array[i+begin];
o.array[length] = 0;
o.used = o.allocated;
return o;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %ecx, %ecx
jle 0x5468e7
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
movl $0x2, %edi
callq 0x1a57a0
movq %rax, (%rbx)
movw $0x0, (%rax)
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x546966
movslq %ebp, %rcx
movl %r15d, %eax
addq %rcx, %rcx
xorl %edx, %edx
movq (%r14), %rsi
addq %rcx, %rsi
movzwl (%rsi,%rdx,2), %esi
movq (%rbx), %rdi
movw %si, (%rdi,%rdx,2)
incq %rdx
cmpq %rdx, %rax
jne 0x5468bd
movq (%rbx), %rcx
movw $0x0, (%rcx,%rax,2)
movl 0x8(%rbx), %eax
movl %eax, 0xc(%rbx)
jmp 0x5468fc
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x6224d(%rip), %rsi # 0x5a8b41
movq %rbx, %rdi
callq 0x545d60
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x54691a
callq 0x1a5610
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/irrString.h |
irr::io::CXMLReaderImpl<unsigned short, irr::io::IXMLBase>::getAttributeByName(unsigned short const*) const | const SAttribute* getAttributeByName(const char_type* name) const
{
if (!name)
return 0;
core::string<char_type> n = name;
for (int i=0; i<(int)Attributes.size(); ++i)
if (Attributes[i].Name == n)
return &Attributes[i];
return 0;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x546dd8
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x546de6
movslq 0x7c(%rbx), %rax
movq (%r14), %rdi
testq %rax, %rax
jle 0x546dca
movq 0x70(%rbx), %rcx
movl 0xc(%rsp), %edx
xorl %esi, %esi
movq %rsi, %rbx
shlq $0x5, %rbx
movq (%rcx,%rbx), %r8
movzwl (%r8), %r9d
testw %r9w, %r9w
je 0x546dba
xorl %r10d, %r10d
movzwl (%rdi,%r10), %r11d
testw %r11w, %r11w
je 0x546dba
cmpw %r11w, %r9w
jne 0x546dc2
movzwl 0x2(%r8,%r10), %r9d
addq $0x2, %r10
testw %r9w, %r9w
jne 0x546d99
addq %rcx, %rbx
cmpl %edx, 0xc(%rbx)
je 0x546dcc
incq %rsi
cmpq %rax, %rsi
jne 0x546d81
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x546dda
callq 0x1a5610
jmp 0x546dda
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<unsigned long, irr::io::IXMLBase>::createSpecialCharacterList() | void createSpecialCharacterList()
{
// list of strings containing special symbols,
// the first character is the special character,
// the following is the symbol string without trailing &.
SpecialCharacters.push_back("&");
SpecialCharacters.push_back("<lt;");
SpecialCharacters.push_back(">gt;");
SpecialCharacters.push_back("\"quot;");
SpecialCharacters.push_back("'apos;");
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x58, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x96fa9(%rip), %rsi # 0x5de044
movq %r14, %rdi
callq 0x547802
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54757e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5470bc
callq 0x1a5610
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x96f7d(%rip), %rsi # 0x5de04a
movq %r14, %rdi
callq 0x547802
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54757e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5470ee
callq 0x1a5610
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x96f50(%rip), %rsi # 0x5de04f
movq %r14, %rdi
callq 0x547802
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54757e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x547120
callq 0x1a5610
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x96f23(%rip), %rsi # 0x5de054
movq %r14, %rdi
callq 0x547802
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54757e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x547152
callq 0x1a5610
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x96ef8(%rip), %rsi # 0x5de05b
movq %r14, %rdi
callq 0x547802
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54757e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x547184
callq 0x1a5610
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x547194
jmp 0x547194
jmp 0x547194
jmp 0x547194
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5471a5
callq 0x1a5610
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<unsigned long, irr::io::IXMLBase>::read() | virtual bool read()
{
// if not end reached, parse the node
if (P && (unsigned int)(P - TextBegin) < TextSize - 1 && *P != 0)
{
parseCurrentNode();
return true;
}
_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
return false;
} | movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x547326
movq %rax, %rcx
subq 0x18(%rdi), %rcx
shrq $0x3, %rcx
movl 0x20(%rdi), %edx
decl %edx
cmpl %ecx, %edx
jbe 0x547326
cmpq $0x0, (%rax)
je 0x547326
pushq %rax
callq 0x5478d8
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<unsigned long, irr::io::IXMLBase>::getAttributeValueAsFloat(int) const | float getAttributeValueAsFloat(int idx) const
{
const char_type* attrvalue = getAttributeValue(idx);
if (!attrvalue)
return 0;
core::stringc c = attrvalue;
return static_cast<float>(atof(c.c_str()));
//return fast_atof(c.c_str());
} | pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
je 0x547462
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54894c
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x1a5f00
testq %rbx, %rbx
je 0x54745c
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x1a5610
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
jmp 0x547465
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
void irr::io::CXMLReaderImpl<unsigned long, irr::io::IXMLBase>::convertTextData<unsigned short>(unsigned short*, char*, int) | void convertTextData(src_char_type* source, char* pointerToStore, int sizeWithoutHeader)
{
// convert little to big endian if necessary
if (sizeof(src_char_type) > 1 &&
isLittleEndian(TargetFormat) != isLittleEndian(SourceFormat))
convertToLittleEndian(source);
// check if conversion is necessary:
if (sizeof(src_char_type) == sizeof(char_type))
{
// no need to convert
TextBegin = (char_type*)source;
TextData = (char_type*)pointerToStore;
TextSize = sizeWithoutHeader;
}
else
{
// convert source into target data format.
// TODO: implement a real conversion. This one just
// copies bytes. This is a problem when there are
// unicode symbols using more than one character.
TextData = new char_type[sizeWithoutHeader];
// MSVC debugger complains here about loss of data ...
size_t numShift = sizeof( char_type) * 8;
assert(numShift < 64);
const src_char_type cc = (src_char_type)(((uint64_t(1u) << numShift) - 1));
for (int i=0; i<sizeWithoutHeader; ++i)
TextData[i] = char_type( source[i] & cc);
TextBegin = TextData;
TextSize = sizeWithoutHeader;
// delete original data because no longer needed
delete [] pointerToStore;
}
} | pushq %rbx
movl %ecx, %eax
movq %rdi, %rbx
movl 0x2c(%rdi), %ecx
cmpl $0x6, %ecx
setb %dil
movb $0x2b, %dl
shrb %cl, %dl
movl 0x28(%rbx), %ecx
andb %dil, %dl
cmpl $0x5, %ecx
ja 0x54753f
movl $0x2b, %edi
btl %ecx, %edi
jae 0x54753f
testb %dl, %dl
jne 0x547543
movzwl (%rsi), %ecx
testw %cx, %cx
je 0x547543
addq $0x2, %rsi
rolw $0x8, %cx
movw %cx, -0x2(%rsi)
movzwl (%rsi), %ecx
addq $0x2, %rsi
testw %cx, %cx
jne 0x547529
jmp 0x547543
testb %dl, %dl
jne 0x54751d
movl %eax, %ecx
shlq $0x3, %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x1a57a0
movq %rax, 0x8(%rbx)
leaq 0x96a55(%rip), %rdi # 0x5ddfbb
leaq 0x96a5c(%rip), %rsi # 0x5ddfc9
leaq 0x96aee(%rip), %rcx # 0x5de062
movl $0x2a3, %edx # imm = 0x2A3
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::core::array<irr::core::string<unsigned long>>::push_back(irr::core::string<unsigned long> const&) | void push_back(const T& element)
{
if (used + 1 > allocated)
{
// reallocate(used * 2 +1);
// this doesn't work if the element is in the same array. So
// we'll copy the element first to be sure we'll get no data
// corruption
T e;
e = element; // copy element
reallocate(used * 2 +1); // increase data block
data[used++] = e; // push_back
is_sorted = false;
return;
}
data[used++] = element;
is_sorted = false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %edi
leal 0x1(%rdi), %eax
cmpl 0x8(%rbx), %eax
jbe 0x547606
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rsp, %r15
movq %rax, 0x8(%r15)
movl $0x8, %edi
callq 0x1a57a0
movq %rax, (%r15)
movq $0x0, (%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x547640
movl 0xc(%rbx), %eax
leal 0x1(,%rax,2), %esi
movq %rbx, %rdi
callq 0x5476b2
movl 0xc(%rbx), %edi
leal 0x1(%rdi), %eax
movl %eax, 0xc(%rbx)
shlq $0x4, %rdi
addq (%rbx), %rdi
movq %rsp, %rsi
callq 0x547640
movb $0x0, 0x11(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x54761c
callq 0x1a5610
jmp 0x54761c
movl %eax, 0xc(%rbx)
shlq $0x4, %rdi
addq (%rbx), %rdi
movq %r14, %rsi
callq 0x547640
movb $0x0, 0x11(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x547637
callq 0x1a5610
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/irrArray.h |
irr::io::CXMLReaderImpl<unsigned long, irr::io::IXMLBase>::parseClosingXMLElement() | void parseClosingXMLElement()
{
CurrentNodeType = EXN_ELEMENT_END;
IsEmptyElement = false;
Attributes.clear();
++P;
const char_type* pBeginClose = P;
while(*P != L'>')
++P;
// remove trailing whitespace, if any
while( std::isspace( P[-1]))
--P;
NodeName = core::string<char_type>(pBeginClose, (int)(P - pBeginClose));
++P;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x2, 0x24(%rdi)
movb $0x0, 0x50(%rdi)
addq $0x70, %rdi
callq 0x548490
movq 0x10(%rbx), %r14
addq $0x8, %r14
movq %r14, %r15
movq %r15, 0x10(%rbx)
cmpq $0x3e, (%r15)
leaq 0x8(%r15), %r15
jne 0x547a89
movl -0x10(%r15), %edi
callq 0x1a5dc0
testl %eax, %eax
je 0x547ac3
addq $-0x10, %r15
movq %r15, 0x10(%rbx)
movl -0x8(%r15), %edi
addq $-0x8, %r15
callq 0x1a5dc0
testl %eax, %eax
jne 0x547aa8
addq $0x8, %r15
jmp 0x547ac7
addq $-0x8, %r15
subq %r14, %r15
shrq $0x3, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x547fda
leaq 0x30(%rbx), %rdi
movq %r12, %rsi
callq 0x547640
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x547afc
callq 0x1a5610
addq $0x8, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x547b1f
callq 0x1a5610
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<unsigned long, irr::io::IXMLBase>::replaceSpecialCharacters(irr::core::string<unsigned long>&) | core::string<char_type> replaceSpecialCharacters(
core::string<char_type>& origstr)
{
int pos = origstr.findFirst(L'&');
int oldPos = 0;
if (pos == -1)
return origstr;
core::string<char_type> newstr;
while(pos != -1 && pos < origstr.size()-2)
{
// check if it is one of the special characters
int specialChar = -1;
for (int i=0; i<(int)SpecialCharacters.size(); ++i)
{
const char_type* p = &origstr.c_str()[pos]+1;
if (equalsn(&SpecialCharacters[i][1], p, SpecialCharacters[i].size()-1))
{
specialChar = i;
break;
}
}
if (specialChar != -1)
{
newstr.append(origstr.subString(oldPos, pos - oldPos));
newstr.append(SpecialCharacters[specialChar][0]);
pos += SpecialCharacters[specialChar].size();
}
else
{
newstr.append(origstr.subString(oldPos, pos - oldPos + 1));
pos += 1;
}
// find next &
oldPos = pos;
pos = origstr.findNext(L'&', pos);
}
if (oldPos < origstr.size()-1)
newstr.append(origstr.subString(oldPos, origstr.size()-oldPos));
return newstr;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rdi, %rbx
movslq 0xc(%rdx), %rbp
testq %rbp, %rbp
jle 0x54807a
movq %rsi, %r15
movq (%r13), %rax
xorl %r12d, %r12d
cmpq $0x26, (%rax,%r12,8)
je 0x54809d
incq %r12
cmpq %r12, %rbp
jne 0x54806b
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x547640
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
movl $0x8, %edi
callq 0x1a57a0
movq %rax, (%rbx)
movq $0x0, (%rax)
xorl %edx, %edx
movq %rbx, 0x18(%rsp)
leal -0x3(%rbp), %eax
cmpl %r12d, %eax
jle 0x5481ec
movq %rdx, 0x20(%rsp)
cmpl $0x0, 0x64(%r15)
jle 0x548125
movslq %r12d, %rbx
shlq $0x3, %rbx
xorl %ebp, %ebp
xorl %r14d, %r14d
movq (%r13), %rax
leaq (%rax,%rbx), %rdx
addq $0x8, %rdx
movq 0x58(%r15), %rax
movq (%rax,%rbp), %rsi
addq $0x8, %rsi
movl 0xc(%rax,%rbp), %ecx
addl $-0x2, %ecx
movq %r15, %rdi
callq 0x54826c
testb %al, %al
jne 0x548167
incq %r14
movslq 0x64(%r15), %rax
addq $0x10, %rbp
cmpq %rax, %r14
jl 0x5480ea
movl %r12d, %ecx
movq 0x20(%rsp), %rdx
subl %edx, %ecx
incl %ecx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x548318
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5482b8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x548160
callq 0x1a5610
movl $0x1, %edx
jmp 0x5481bc
movl %r12d, %ecx
movq 0x20(%rsp), %rdx
subl %edx, %ecx
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x548318
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x5482b8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x54819f
callq 0x1a5610
movq 0x58(%r15), %rax
movq (%rax,%rbp), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5483d0
movq 0x58(%r15), %rax
movl 0xc(%rax,%rbp), %edx
decl %edx
addl %r12d, %edx
movl 0xc(%r13), %ebp
cmpl %edx, %ebp
jle 0x5481ec
movslq %ebp, %rax
movq (%r13), %rcx
movslq %edx, %r12
cmpq $0x26, (%rcx,%r12,8)
je 0x5481e2
incq %r12
cmpq %r12, %rax
jne 0x5481d1
jmp 0x5481ec
cmpq $-0x1, %r12
jne 0x5480c6
leal -0x2(%rbp), %eax
cmpl %eax, %edx
jge 0x54808b
movl %edx, %eax
notl %eax
addl %eax, %ebp
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movl %ebp, %ecx
callq 0x548318
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5482b8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x54808b
callq 0x1a5610
jmp 0x54808b
jmp 0x54823b
jmp 0x54824f
jmp 0x54824f
jmp 0x54823b
jmp 0x54824f
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x548252
callq 0x1a5610
jmp 0x548252
movq %rax, %r14
movq 0x18(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x548264
callq 0x1a5610
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<unsigned long, irr::io::IXMLBase>::equalsn(unsigned long const*, unsigned long const*, int) | bool equalsn(const char_type* str1, const char_type* str2, int len)
{
int i;
for(i=0; str1[i] && str2[i] && i < len; ++i)
if (str1[i] != str2[i])
return false;
// if one (or both) of the strings was smaller then they
// are only equal if they have the same lenght
return (i == len) || (str1[i] == 0 && str2[i] == 0);
} | movq (%rsi), %rax
testq %rax, %rax
je 0x54829d
movslq %ecx, %r8
xorl %edi, %edi
cmpq %r8, %rdi
jge 0x5482ae
movq (%rdx,%rdi,8), %r9
testq %r9, %r9
je 0x5482ae
cmpq %r9, %rax
jne 0x5482b4
movq 0x8(%rsi,%rdi,8), %rax
incq %rdi
testq %rax, %rax
jne 0x548279
movl %edi, %esi
jmp 0x5482a1
xorl %esi, %esi
xorl %edi, %edi
movb $0x1, %al
cmpl %ecx, %esi
je 0x5482b3
cmpq $0x0, (%rdx,%rdi,8)
jmp 0x5482b0
cmpl %edi, %ecx
sete %al
retq
xorl %eax, %eax
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<unsigned long, irr::io::IXMLBase>::getAttributeByName(unsigned long const*) const | const SAttribute* getAttributeByName(const char_type* name) const
{
if (!name)
return 0;
core::string<char_type> n = name;
for (int i=0; i<(int)Attributes.size(); ++i)
if (Attributes[i].Name == n)
return &Attributes[i];
return 0;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x54888d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x54889a
movslq 0x7c(%rbx), %rax
movq (%r14), %rdi
testq %rax, %rax
jle 0x54887f
movq 0x70(%rbx), %rcx
movl 0xc(%rsp), %edx
xorl %esi, %esi
movq %rsi, %rbx
shlq $0x5, %rbx
movq (%rcx,%rbx), %r8
movq (%r8), %r9
testq %r9, %r9
je 0x54886f
xorl %r10d, %r10d
movq (%rdi,%r10), %r11
testq %r11, %r11
je 0x54886f
cmpq %r11, %r9
jne 0x548877
movq 0x8(%r8,%r10), %r9
addq $0x8, %r10
testq %r9, %r9
jne 0x548853
addq %rcx, %rbx
cmpl %edx, 0xc(%rbx)
je 0x548881
incq %rsi
cmpq %rax, %rsi
jne 0x54883d
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x54888f
callq 0x1a5610
jmp 0x54888f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
MidiOutAlsa::setPortName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void MidiOutAlsa :: setPortName( const std::string &portName )
{
AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
snd_seq_port_info_t *pinfo;
snd_seq_port_info_alloca( &pinfo );
snd_seq_get_port_info( data->seq, data->vport, pinfo );
snd_seq_port_info_set_name( pinfo, portName.c_str() );
snd_seq_set_port_info( data->seq, data->vport, pinfo );
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %r15
callq 0x77b0
movq %rsp, %r14
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
callq 0x77b0
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x7230
movq (%r15), %rdi
movl 0xc(%r15), %esi
movq %r14, %rdx
callq 0x79f0
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x79c0
movq (%r15), %rdi
movl 0xc(%r15), %esi
movq %r14, %rdx
callq 0x7260
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /samhocevar[P]midi2pico8/RtMidi.cpp |
MidiOutAlsa::openVirtualPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void MidiOutAlsa :: openVirtualPort( const std::string &portName )
{
AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
if ( data->vport < 0 ) {
data->vport = snd_seq_create_simple_port( data->seq, portName.c_str(),
SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ,
SND_SEQ_PORT_TYPE_MIDI_GENERIC|SND_SEQ_PORT_TYPE_APPLICATION );
if ( data->vport < 0 ) {
errorString_ = "MidiOutAlsa::openVirtualPort: ALSA error creating virtual port.";
error( RtMidiError::DRIVER_ERROR, errorString_ );
}
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x8(%rdi), %r14
cmpl $0x0, 0xc(%r14)
jns 0xad7b
movq %rdi, %rbx
movq (%r14), %rdi
movq (%rsi), %rsi
movl $0x21, %edx
movl $0x100002, %ecx # imm = 0x100002
callq 0x7730
movl %eax, 0xc(%r14)
testl %eax, %eax
jns 0xad7b
leaq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rdx
leaq 0x2a11(%rip), %rcx # 0xd73a
movl $0x3f, %r8d
xorl %esi, %esi
callq 0x7760
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x7150
movq %rbx, %rdi
movl $0x8, %esi
movq %r14, %rdx
callq 0x7270
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xad7b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7470
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xad9e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7470
movq %rbx, %rdi
callq 0x78f0
| /samhocevar[P]midi2pico8/RtMidi.cpp |
rtmidi_compiled_api_by_name | enum RtMidiApi rtmidi_compiled_api_by_name(const char *name) {
RtMidi::Api api = RtMidi::UNSPECIFIED;
if (name) {
api = RtMidi::getCompiledApiByName(name);
}
return (enum RtMidiApi)api;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0xbc27
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
callq 0x71a0
leaq (%rax,%rbx), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7120
movq %r14, %rdi
callq 0x76a0
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xbc29
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7470
jmp 0xbc29
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xbc4e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7470
movq %rbx, %rdi
callq 0x78f0
| /samhocevar[P]midi2pico8/rtmidi_c.cpp |
rtmidi_in_set_callback | void rtmidi_in_set_callback (RtMidiInPtr device, RtMidiCCallback callback, void *userData)
{
device->data = (void*) new CallbackProxyUserData (callback, userData);
try {
((RtMidiIn*) device->ptr)->setCallback (callback_proxy, device->data);
} catch (const RtMidiError & err) {
device->ok = false;
device->msg = err.what ();
delete (CallbackProxyUserData*) device->data;
device->data = 0;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10, %edi
callq 0x7460
movq %r15, (%rax)
movq %r14, 0x8(%rax)
leaq 0x8(%rbx), %r14
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x8(%rcx), %rdi
leaq 0x20(%rip), %rsi # 0xc1c9
movq %rax, %rdx
callq 0x7090
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl %edx, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7a82
jmp 0xc1b1
| /samhocevar[P]midi2pico8/rtmidi_c.cpp |
rtmidi_out_get_current_api | enum RtMidiApi rtmidi_out_get_current_api (RtMidiPtr device)
{
try {
return (RtMidiApi) ((RtMidiOut*) device->ptr)->getCurrentApi ();
} catch (const RtMidiError & err) {
device->ok = false;
device->msg = err.what ();
return RTMIDI_API_UNSPECIFIED;
}
} | pushq %rax
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
popq %rcx
retq
movq %rax, %rdi
callq 0xb23f
| /samhocevar[P]midi2pico8/rtmidi_c.cpp |
blobCreate | blob_t blobCreate(size_t size)
{
size_t* ptr;
if (size == 0)
return 0;
ptr = (size_t*)memAlloc(blobActualSize(size));
if (ptr == 0)
return 0;
*ptr = size;
memSetZero(blobValueOf(ptr), size);
return blobValueOf(ptr);
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1092d
movq %rdi, %r14
addq $0x407, %rdi # imm = 0x407
andq $-0x400, %rdi # imm = 0xFC00
callq 0xe530
testq %rax, %rax
je 0x1092d
movq %rax, %rbx
movq %r14, (%rax)
addq $0x8, %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xf710
jmp 0x1092f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/blob.c |
derTEnc | static size_t derTEnc(octet der[], u32 tag)
{
size_t t_count = 0;
// проверить корректность
if (!derTIsValid(tag))
return SIZE_MAX;
// определить длину кода
{
u32 t = tag;
for (; t; ++t_count, t >>= 8);
if (t_count == 0)
t_count = 1;
}
// кодировать
if (der)
{
size_t pos = t_count;
ASSERT(memIsValid(der, t_count));
while (pos--)
{
der[pos] = (octet)tag;
tag >>= 8;
}
ASSERT(tag == 0);
}
return t_count;
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x11f93
testl %eax, %eax
je 0x10f3a
xorl %eax, %eax
movl %ebx, %ecx
testl %ecx, %ecx
je 0x10f14
incq %rax
shrl $0x8, %ecx
jmp 0x10f08
cmpq $0x1, %rax
adcq $0x0, %rax
testq %r14, %r14
je 0x10f3d
movq %rax, %rdx
movq %rax, %rcx
subq $0x1, %rcx
jb 0x10f3d
movb %bl, -0x1(%r14,%rdx)
shrl $0x8, %ebx
movq %rcx, %rdx
jmp 0x10f27
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/der.c |
derEnc | size_t derEnc(octet der[], u32 tag, const void* val, size_t len)
{
size_t t_count;
size_t l_count;
// t_count <- len(T)
t_count = derTEnc(0, tag);
if (t_count == SIZE_MAX)
return SIZE_MAX;
// l_count <- len(L)
l_count = derLEnc(0, len);
if (l_count == SIZE_MAX)
return SIZE_MAX;
// кодировать?
if (der)
{
ASSERT(memIsValid(val, len));
ASSERT(memIsValid(der, t_count + l_count + len));
// der <- TLV
memMove(der + t_count + l_count, val, len);
if (derTEnc(der, tag) != t_count ||
derLEnc(der + t_count, len) != l_count)
return SIZE_MAX;
}
return t_count + l_count + len;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
xorl %edi, %edi
callq 0x10ef0
pushq $-0x1
popq %r14
cmpq $-0x1, %rax
je 0x11028
movq %rax, %r15
movq %r12, 0x10(%rsp)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x10f45
cmpq $-0x1, %rax
je 0x11028
movq %rax, %r12
testq %r13, %r13
je 0x1101f
leaq (%r15,%r13), %rax
movq %rax, 0x8(%rsp)
leaq (%rax,%r12), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0xe130
movq %r13, %rdi
movl %ebp, %esi
callq 0x10ef0
cmpq %r15, %rax
jne 0x11028
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x10f45
cmpq %r12, %rax
jne 0x11028
addq %rbx, %r15
addq %r12, %r15
movq %r15, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/der.c |
derTSIZEDec | size_t derTSIZEDec(size_t* val, const octet der[], size_t count, u32 tag)
{
u32 t;
size_t t_count;
size_t l_count;
size_t len;
// pre
ASSERT(memIsNullOrValid(val, O_PER_S));
ASSERT(val == 0 || memIsDisjoint2(val, O_PER_S, der, count));
// декодировать T
t_count = derTDec(&t, der, count);
if (t_count == SIZE_MAX || t != tag)
return SIZE_MAX;
der += t_count, count -= t_count;
// декодировать L
l_count = derLDec(&len, der, count);
if (l_count == SIZE_MAX || len > O_PER_S + 1)
return SIZE_MAX;
der += l_count, count -= l_count;
// декодировать V
{
register size_t v = 0;
size_t pos = 0;
// в старшем октете установлен старший бит?
// избыточный нулевой старший октет?
// переполнение?
if ((der[0] & 0x80) ||
der[0] == 0 && len > 1 && (der[1] & 0x80) == 0 ||
len == O_PER_S + 1 && der[0] != 0)
return SIZE_MAX;
// декодировать
for (; pos < len; ++pos)
v <<= 8, v |= der[pos];
if (val)
*val = v;
v = 0;
}
return t_count + l_count + len;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
callq 0x10d53
pushq $-0x1
popq %r12
cmpq $-0x1, %rax
je 0x1157b
cmpl %ebp, 0xc(%rsp)
jne 0x1157b
movq %rax, %r15
addq %rax, %r14
subq %rax, %r13
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x10de9
cmpq $-0x1, %rax
sete %dl
movq (%rbp), %rcx
cmpq $0xa, %rcx
setae %sil
orb %dl, %sil
jne 0x1157b
movb (%r14,%rax), %dl
addq %rax, %r14
testb %dl, %dl
js 0x1157b
sete %sil
cmpq $0x2, %rcx
setae %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x11546
cmpb $0x0, 0x1(%r14)
jns 0x1157b
jmp 0x11550
cmpq $0x9, %rcx
jne 0x11550
testb %dl, %dl
jne 0x1157b
xorl %edx, %edx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x1156a
shlq $0x8, %rdx
movzbl (%r14,%rsi), %edi
orq %rdi, %rdx
incq %rsi
jmp 0x11554
testq %rbx, %rbx
je 0x11572
movq %rdx, (%rbx)
addq %r15, %rax
addq %rcx, %rax
movq %rax, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/der.c |
derTUINTDec2 | size_t derTUINTDec2(octet* val, const octet der[], size_t count, u32 tag,
size_t len)
{
const octet* v;
size_t l;
size_t ex;
// декодировать
count = derDec2(&v, &l, der, count, tag);
if (count == SIZE_MAX)
return SIZE_MAX;
// в значении менее одного октета?
// установлен старший бит в первом (старшем) октете?
// незначащий нулевой октет?
if (l < 1 || (v[0] & 128) ||
v[0] == 0 && l > 1 && !(v[1] & 128))
return SIZE_MAX;
// дополнительный нулевой октет?
ex = (v[0] == 0 && l > 1 && (v[1] & 128)) ? 1 : 0;
// длина не соответствует ожидаемой?
if (l - ex != len)
return SIZE_MAX;
// возвратить значение
if (val)
{
ASSERT(memIsValid(val, len));
memMove(val, v + ex, len);
memRev(val, len);
}
return count;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xfaf0
movq %rax, %r15
pushq $-0x1
popq %rax
cmpq $-0x1, %r15
je 0x1178b
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x1178b
movq 0x8(%rsp), %rsi
cmpb $0x0, (%rsi)
js 0x1178b
setne %dl
cmpq $0x1, %rcx
sete %dil
orb %dl, %dil
jne 0x11760
cmpb $0x0, 0x1(%rsi)
jns 0x1178b
movzbl 0x1(%rsi), %edx
shrl $0x7, %edx
jmp 0x11762
xorl %edx, %edx
subq %rdx, %rcx
cmpq %rbx, %rcx
jne 0x1178b
testq %r14, %r14
je 0x11788
addq %rdx, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xe130
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10000
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/core/der.c |
derOIDEnc | size_t derOIDEnc(octet der[], const char* oid)
{
u32 d1;
u32 val = 0;
size_t pos = 0;
size_t count = 0;
// корректен?
if (!oidIsValid(oid))
return SIZE_MAX;
// pre
ASSERT(oid[0] == '0' || oid[0] == '1' || oid[0] == '2');
ASSERT(oid[1] == '.');
// обработать d1
d1 = oid[0] - '0';
oid += 2;
// цикл по символам oid
while (1)
{
// закончили очередное число?
if (oid[pos] == '.' || oid[pos] == '\0')
{
// закончили d2?
if (d1 != 3)
val += 40 * d1, d1 = 3;
// обработать число
count += derSIDEnc(der ? der + count : der, val);
// конец строки?
if (oid[pos] == '\0')
break;
// к следующему числу
oid += ++pos, pos = 0, val = 0;
continue;
}
// обработать цифру
val *= 10;
val += oid[pos] - '0';
++pos;
}
// кодировать TL
count = derEnc(der, 0x06, der, count);
// очистка и выход
d1 = val = 0, pos = 0;
return count;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe110
testl %eax, %eax
je 0x11b15
movsbl (%r14), %r9d
addl $-0x30, %r9d
addq $0x2, %r14
xorl %eax, %eax
pushq $0x1
popq %rdx
pushq $0x3
popq %rsi
xorl %ecx, %ecx
movq %rcx, %rdi
incq %r14
xorl %r11d, %r11d
movzbl -0x1(%r14), %r10d
cmpl $0x2e, %r10d
je 0x11a94
testl %r10d, %r10d
je 0x11a94
movsbl %r10b, %ecx
imull $0xa, %r11d, %r8d
leal (%r8,%rcx), %r11d
addl $-0x30, %r11d
incq %r14
jmp 0x11a6f
imull $0x28, %r9d, %r8d
cmpl $0x3, %r9d
cmovel %eax, %r8d
leaq (%rbx,%rdi), %r9
testq %rbx, %rbx
cmoveq %rbx, %r9
movq %rdx, %rcx
addl %r11d, %r8d
je 0x11ac6
xorl %ecx, %ecx
movl %r8d, %r11d
testl %r11d, %r11d
je 0x11ac6
shrl $0x7, %r11d
incq %rcx
jmp 0x11ab8
testq %r9, %r9
je 0x11af1
movl %r8d, %r11d
andb $0x7f, %r11b
leaq -0x1(%rcx), %r10
movb %r11b, (%r9,%r10)
subq $0x1, %r10
jb 0x11aed
shrl $0x7, %r8d
movl %r8d, %r11d
orb $-0x80, %r11b
jmp 0x11ad6
movb -0x1(%r14), %r10b
addq %rdi, %rcx
movl %esi, %r9d
testb %r10b, %r10b
jne 0x11a66
pushq $0x6
popq %rsi
movq %rbx, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe720
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/der.c |
derOIDDec | size_t derOIDDec(char* oid, size_t* len, const octet der[], size_t count)
{
u32 d1 = 3;
u32 val = 0;
size_t l, pos, oid_len;
// pre
ASSERT(memIsValid(der, count));
// проверить тег и определить значение
count = derDec2(&der, &l, der, count, 0x06);
if (count == SIZE_MAX)
return SIZE_MAX;
// обработать sid
for (pos = oid_len = 0; pos < l; ++pos)
{
// переполнение?
if (val & 0xFE000000)
return SIZE_MAX;
// лидирующий 0?
if (val == 0 && der[pos] == 128)
return SIZE_MAX;
// обработать октет sid
val <<= 7, val |= (size_t)der[pos] & 127;
// последний октет sid?
if ((der[pos] & 128) == 0)
{
// первый sid?
if (d1 == 3)
{
if (val < 40)
d1 = 0;
else if (val < 80)
d1 = 1, val -= 40;
else
d1 = 2, val -= 80;
oid_len += derSIDDec(oid ? oid + oid_len : oid, d1);
d1 = 0;
}
// добавить ".val"
oid ? oid[oid_len++] = '.' : oid_len++;
oid_len += derSIDDec(oid ? oid + oid_len : oid, val);
// к следующему sid
val = 0;
}
}
// очистка и выход
d1 = val = 0, pos = l = 0;
oid ? oid[oid_len] = '\0' : oid_len;
if (len)
{
ASSERT(memIsValid(len, O_PER_S));
ASSERT(oid == 0 || memIsDisjoint2(len, O_PER_S, oid, strLen(oid)));
*len = oid_len;
}
return count;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rdi
movq %rdx, (%rdi)
leaq 0x18(%rsp), %rsi
pushq $0x6
popq %r8
callq 0xfaf0
pushq $-0x1
popq %rcx
cmpq $-0x1, %rax
je 0x11c23
movq %rax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq 0x18(%rsp), %r12
xorl %eax, %eax
pushq $0x3
popq %rcx
movl %ecx, 0x4(%rsp)
movq 0x20(%rsp), %rbx
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpq %r14, %r12
je 0x11c28
cmpl $0x1ffffff, %eax # imm = 0x1FFFFFF
ja 0x11c1e
testl %eax, %eax
sete %dl
movb (%rbx,%r14), %cl
cmpb $-0x80, %cl
sete %sil
testb %sil, %dl
jne 0x11c1e
movzbl %cl, %ebp
shll $0x7, %eax
andl $0x7f, %ebp
orl %eax, %ebp
testb %cl, %cl
js 0x11c14
cmpl $0x3, 0x4(%rsp)
jne 0x11bef
movl $0x0, 0x4(%rsp)
cmpl $0x28, %ebp
jae 0x11bca
xorl %esi, %esi
jmp 0x11bdc
cmpl $0x4f, %ebp
ja 0x11bd6
addl $-0x28, %ebp
pushq $0x1
jmp 0x11bdb
addl $-0x50, %ebp
pushq $0x2
popq %rsi
leaq (%r15,%r13), %rdi
testq %r15, %r15
cmoveq %r15, %rdi
callq 0x11c53
addq %rax, %r13
testq %r15, %r15
je 0x11bf9
movb $0x2e, (%r15,%r13)
testq %r15, %r15
leaq 0x1(%r15,%r13), %rdi
cmoveq %r15, %rdi
movl %ebp, %esi
callq 0x11c53
addq %rax, %r13
incq %r13
xorl %ebp, %ebp
incq %r14
movl %ebp, %eax
jmp 0x11b7a
pushq $-0x1
popq %rax
jmp 0x11c44
movq %rcx, %rax
jmp 0x11c44
testq %r15, %r15
je 0x11c32
movb $0x0, (%r15,%r13)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x11c3f
movq %r13, (%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/der.c |
derSIDDec2 | static size_t derSIDDec2(u32 val, const char* oid)
{
size_t count = 0, pos;
u32 t = val;
// число символов для val
do
t /= 10, count++;
while (t > 0);
// сравнение
ASSERT(strIsValid(oid));
pos = count - 1;
if (oid[pos] != '0' + (char)((t = val) % 10))
return SIZE_MAX;
while (pos--)
{
t /= 10;
if (oid[pos] != '0' + (char)(t % 10))
return SIZE_MAX;
}
return count;
} | movabsq $-0x1, %r9
movl $0xa, %r8d
movl %edi, %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
incq %r9
cmpl $0x9, %ecx
movl %eax, %ecx
ja 0x11db4
movsbl (%rsi,%r9), %r10d
movl %edi, %eax
xorl %edx, %edx
divl %r8d
orl $0x30, %edx
movabsq $-0x1, %rcx
cmpl %r10d, %edx
jne 0x11e15
pushq %rbx
leaq 0x1(%r9), %r10
movq %r9, %r11
subq $0x1, %r11
jb 0x11e11
movl %edi, %eax
xorl %edx, %edx
divl %r8d
movsbl -0x1(%rsi,%r9), %ebx
movl %eax, %edi
xorl %edx, %edx
divl %r8d
orl $0x30, %edx
movq %r11, %r9
cmpl %ebx, %edx
je 0x11deb
jmp 0x11e14
movq %r10, %rcx
popq %rbx
movq %rcx, %rax
retq
| /agievich[P]bee2/src/core/der.c |
derTPSTRDec | size_t derTPSTRDec(char* val, size_t* len, const octet der[], size_t count,
u32 tag)
{
const octet* v;
size_t l;
size_t pos;
// декодировать
count = derDec2(&v, &l, der, count, tag);
if (count == SIZE_MAX)
return SIZE_MAX;
// проверить символы (см. strIsPrintable())
for (pos = 0; pos < l; ++pos)
{
register char ch = (char)v[pos];
if ((ch < '0' || ch > '9') &&
(ch < 'A' || ch > 'Z') &&
(ch < 'a' || ch > 'z') &&
strchr(" '()+,-./:=?", ch) == 0)
{
ch = 0;
return SIZE_MAX;
}
ch = 0;
}
// возвратить строку
if (val)
{
ASSERT(memIsValid(val, l + 1));
ASSERT(len == 0 || memIsDisjoint2(len, O_PER_S, val, l + 1));
memMove(val, v, l);
val[l] = 0;
}
// возвратить длину строки
if (len)
{
ASSERT(memIsValid(len, O_PER_S));
*len = l;
}
return count;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xfaf0
movq %rax, %r14
pushq $-0x1
popq %rax
cmpq $-0x1, %r14
je 0x11f17
movq %r15, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
movq 0x10(%rsp), %r12
movq 0x20(%rsp), %r13
xorl %r15d, %r15d
leaq 0x3b362(%rip), %rbp # 0x4d214
pushq $0xd
popq %rbx
cmpq %r15, %r12
je 0x11ee6
movsbl (%r13,%r15), %esi
leal -0x3a(%rsi), %eax
cmpb $-0xb, %al
ja 0x11ee1
movl %esi, %eax
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
ja 0x11ee1
movq %rbp, %rdi
movq %rbx, %rdx
callq 0xed50
testq %rax, %rax
je 0x11f1c
incq %r15
jmp 0x11eb5
movq 0x18(%rsp), %rbx
testq %rbx, %rbx
je 0x11f08
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xe130
movq 0x10(%rsp), %r12
movb $0x0, (%rbx,%r12)
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x11f20
movq %r12, (%rax)
jmp 0x11f20
movq %rax, %r14
jmp 0x11f20
pushq $-0x1
popq %r14
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/der.c |
derTIsValid | static bool_t derTIsValid(u32 tag)
{
if (tag == 0)
return FALSE;
else if (tag < 256)
{
// установлены 5 младших битов?
if ((tag & 31) == 31)
return FALSE;
}
// длинный код
else
{
u32 t;
u32 b;
// установлен старший бит в последнем (младшем) октете?
if (tag & 128)
return FALSE;
// пробегаем ненулевые октеты вплоть до первого (старшего)
for (b = tag & 127, t = b, tag >>= 8; tag > 255; tag >>= 8)
{
// в промежуточном октете снят старший бит?
// будет переполнение при пересчете тега-как-значения?
if ((tag & 128) == 0 || (t >> 25) != 0)
return FALSE;
// пересчитать тег-как-значение
b = tag & 127, t = t << 7, t |= b;
}
// можно кодировать одним октетом? меньшим числом октетов?
// в первом (старшем) октете не установлены 5 младших битов?
if (t < 31 || b == 0 || (tag & 31) != 31)
return FALSE;
}
return TRUE;
} | xorl %eax, %eax
testl %edi, %edi
je 0x11fa9
cmpl $0xff, %edi
ja 0x11faa
notl %edi
testb $0x1f, %dil
jne 0x11fec
retq
testb %dil, %dil
js 0x11fa9
movl %edi, %ecx
andl $0x7f, %ecx
movl %ecx, %edx
cmpl $0x10000, %edi # imm = 0x10000
jb 0x11fda
testw %di, %di
jns 0x11fa9
cmpl $0x1ffffff, %ecx # imm = 0x1FFFFFF
ja 0x11fa9
shrl $0x8, %edi
movl %edi, %edx
andl $0x7f, %edx
shll $0x7, %ecx
orl %edx, %ecx
jmp 0x11fb6
notl %edi
testw $0x1f00, %di # imm = 0x1F00
jne 0x11fa9
cmpl $0x1f, %ecx
jb 0x11fa9
testl %edx, %edx
je 0x11fa9
pushq $0x1
popq %rax
retq
| /agievich[P]bee2/src/core/der.c |
derTSEQEncStop | size_t derTSEQEncStop(octet der[], size_t pos, const der_anchor_t* anchor)
{
size_t t_count;
size_t l_count;
size_t len;
size_t l_count1;
ASSERT(memIsValid(anchor, sizeof(der_anchor_t)));
ASSERT(anchor->der == 0 ||
der != 0 && anchor->der + pos == der + anchor->pos);
// определить длину вложенных данных
t_count = derTEnc(0, anchor->tag);
l_count = derLEnc(0, anchor->len);
if (anchor->pos + t_count + l_count > pos)
return SIZE_MAX;
len = pos - anchor->pos - t_count - l_count;
l_count1 = derLEnc(0, len);
// определить величину смещения вложенных данных
pos = l_count1 - l_count;
// сдвинуть вложенные данные и уточнить длину
if (anchor->der)
{
ASSERT(anchor->der + t_count == der - len - l_count);
memMove(der - len + pos, der - len, len);
if (derLEnc(der - len - l_count, len) != l_count1)
return SIZE_MAX;
}
return pos;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdx), %esi
xorl %edi, %edi
callq 0x10ef0
movq %rax, %rbp
movq 0x18(%r12), %rsi
xorl %edi, %edi
callq 0x10f45
addq %rax, %rbp
addq 0x8(%r12), %rbp
pushq $-0x1
popq %r15
subq %rbp, %rbx
jb 0x1207e
movq %rax, %r13
xorl %edi, %edi
movq %rbx, %rsi
callq 0x10f45
movq %rax, %rbp
subq %r13, %rbp
cmpq $0x0, (%r12)
je 0x1207b
subq %rbx, %r14
leaq (%r14,%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rax, %r12
callq 0xe130
subq %r13, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10f45
cmpq %r12, %rax
jne 0x1207e
movq %rbp, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/der.c |
derTSEQDecStart | size_t derTSEQDecStart(der_anchor_t* anchor, const octet der[], size_t count,
u32 tag)
{
size_t t_count;
size_t l_count;
// pre
ASSERT(memIsValid(anchor, sizeof(der_anchor_t)));
// проверить тег
if (!derTIsConstructive(tag))
return SIZE_MAX;
// бросить якорь
anchor->der = der;
// декодировать тег
t_count = derTDec(&anchor->tag, der, count);
if (t_count == SIZE_MAX || anchor->tag != tag)
return SIZE_MAX;
// декодировать длину
l_count = derLDec(&anchor->len, der + t_count, count - t_count);
if (l_count == SIZE_MAX)
return SIZE_MAX;
return t_count + l_count;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, %edi
callq 0x11ff0
pushq $-0x1
popq %r12
testl %eax, %eax
je 0x12102
movq %r14, (%r15)
leaq 0x10(%r15), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, (%rsp)
movq %r13, %rdx
callq 0x10d53
cmpq $-0x1, %rax
je 0x12102
cmpl %ebp, (%rbx)
jne 0x12102
movq %rax, %r13
addq $0x18, %r15
addq %rax, %r14
movq (%rsp), %rdx
subq %rax, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x10de9
addq %rax, %r13
cmpq $-0x1, %rax
cmoveq %rax, %r13
movq %r13, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/der.c |
fileWrite | err_t fileWrite(size_t* written, const void* buf, size_t count, file_t file)
{
ASSERT(memIsValid(buf, count));
ASSERT(fileIsValid(file));
ASSERT(memIsValid(written, O_PER_S));
*written = fwrite(buf, 1, count, file);
if (*written != count)
return ERR_FILE_WRITE;
return ERR_OK;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xfdf0
movq %rax, (%r14)
xorl %ecx, %ecx
cmpq %rbx, %rax
movl $0xce, %eax
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/file.c |
fileRead | err_t fileRead(size_t* read, void* buf, size_t count, file_t file)
{
ASSERT(memIsValid(buf, count));
ASSERT(fileIsValid(file));
ASSERT(memIsValid(read, O_PER_S));
*read = fread(buf, 1, count, file);
if (*read != count)
return feof(file) ? ERR_MAX : ERR_FILE_READ;
return ERR_OK;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xe460
movq %rax, %rcx
movq %rax, (%r15)
xorl %eax, %eax
cmpq %r14, %rcx
je 0x1228a
movq %rbx, %rdi
callq 0xf050
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0xcf, %eax
popq %rbx
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/core/file.c |
fileSize | size_t fileSize(file_t file)
{
size_t pos;
size_t size;
ASSERT(fileIsValid(file));
if ((pos = fileTell(file)) == SIZE_MAX ||
!fileSeek(file, 0, SEEK_END) ||
(size = fileTell(file)) == SIZE_MAX ||
!fileSeek(file, pos, SEEK_SET))
return SIZE_MAX;
return size;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xf010
pushq $-0x1
popq %rbx
cmpq $-0x1, %rax
je 0x1233c
movq %rax, %r15
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0xe450
testl %eax, %eax
je 0x1233c
movq %r14, %rdi
callq 0xf010
cmpq $-0x1, %rax
je 0x1233c
movq %rax, %r12
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xe450
cmpl $0x1, %eax
sbbq %rbx, %rbx
orq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/core/file.c |
memJoin | void memJoin(void* dest, const void* src1, size_t count1, const void* src2,
size_t count2)
{
register octet o;
size_t i;
ASSERT(memIsValid(src1, count1));
ASSERT(memIsValid(src2, count2));
ASSERT(memIsValid(dest, count1 + count2));
repeat:
if (memIsDisjoint2(dest, count1, src2, count2))
{
memMove(dest, src1, count1);
memMove((octet*)dest + count1, src2, count2);
}
else if (memIsDisjoint2((octet*)dest + count1, count2, src1, count1))
{
memMove((octet*)dest + count1, src2, count2);
memMove(dest, src1, count1);
}
else if (memIsDisjoint2(dest, count2, src1, count1))
{
// dest <- src2 || src1
memMove(dest, src2, count2);
memMove((octet*)dest + count2, src1, count1);
// dest <- dest <<< count2
for (i = 0; i < count2; ++i)
{
o = ((octet*)dest)[0];
memMove(dest, (octet*)dest + 1, count1 + count2 - 1);
((octet*)dest)[count1 + count2 - 1] = o;
}
}
else if (memIsDisjoint2((octet*)dest + count2, count1, src2, count2))
{
// dest <- src2 || src1
memMove((octet*)dest + count2, src1, count1);
memMove(dest, src2, count2);
// dest <- dest <<< count2
for (i = 0; i < count2; ++i)
{
o = ((octet*)dest)[0];
memMove(dest, (octet*)dest + 1, count1 + count2 - 1);
((octet*)dest)[count1 + count2 - 1] = o;
}
}
else
{
// src1 (src2) пересекается и с префиксом, и с суффиксом dest
// длины count2 (count1) => и первый, и последний октет dest
// не входят не входят ни в src1, ни в src2
((octet*)dest)[0] = ((const octet*)src1)[0];
((octet*)dest)[count1 + count2 - 1] = ((const octet*)src2)[count2 - 1];
VERIFY(count1--);
VERIFY(count2--);
src1 = (const octet*)src1 + 1;
dest = (octet*)dest + 1;
goto repeat;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq (%rdi,%r8), %r9
leaq (%rdi,%rdx), %rax
movq %rax, (%rsp)
leaq (%rsi,%rdx), %rax
pushq $0x1
popq %r10
subq %r8, %r10
movq %rdx, 0x10(%rsp)
leaq (%r8,%rdx), %r11
movq %rdi, 0x20(%rsp)
addq %rdi, %r11
movq %r9, %rdi
leaq (%rcx,%r8), %r9
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %r11, 0x18(%rsp)
leaq (%rsi,%r14), %r13
movq 0x20(%rsp), %rdx
leaq (%rdx,%r14), %r15
leaq (%r8,%r12), %rbp
movq 0x10(%rsp), %rbx
addq %r12, %rbx
je 0x1294b
testq %rbp, %rbp
je 0x1294b
cmpq %rcx, (%rsp)
jbe 0x1294b
leaq (%r9,%r12), %rdx
cmpq %r15, %rdx
jbe 0x1294b
leaq (%r11,%r12), %rdx
cmpq %r13, %rdx
jbe 0x12982
cmpq %r15, %r13
jbe 0x12982
movq %r10, 0x8(%rsp)
cmpq %r13, %rdi
jbe 0x129ad
cmpq %r15, %rax
jbe 0x129ad
cmpq %rcx, %rdx
jbe 0x12a1e
cmpq %rcx, %r15
jae 0x12a1e
movb (%r13), %dl
movb %dl, (%r15)
movb -0x1(%r9,%r12), %dl
movb %dl, -0x1(%r11,%r12)
incq %r14
decq %r12
movq 0x8(%rsp), %r10
addq $0x2, %r10
jmp 0x128b8
testq %rbx, %rbx
je 0x1296a
movq %r8, %r14
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %rcx, %rbx
callq 0xf980
movq %r14, %r8
movq %rbx, %rcx
testq %rbp, %rbp
je 0x12a96
addq %r12, %r8
movq %r8, %rdx
movq (%rsp), %rdi
movq %rcx, %rsi
jmp 0x1299a
movq (%rsp), %rdi
movq %rcx, %rsi
movq %rbp, %rdx
callq 0xf980
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf980
movq %rdi, (%rsp)
movq %r15, %rdi
movq %rcx, %rsi
movq %rbp, %rdx
callq 0xf980
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xf980
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rax
subq %rax, %rbx
movq 0x20(%rsp), %rdx
addq %rdx, %r14
incq %r14
subq $0x1, %rbp
jb 0x12a96
movb (%r15), %r13b
cmpq %rax, 0x10(%rsp)
je 0x12a17
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf980
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movb %r13b, -0x1(%rcx,%r12)
jmp 0x129eb
movq %r8, %rbp
movq %r13, %rsi
movq %rbx, %rdx
movq %rcx, %rbx
callq 0xf980
addq %r12, %rbp
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xf980
movq %rbp, %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rax
subq %rax, %rbx
movq 0x20(%rsp), %rdx
leaq (%rdx,%r14), %r13
incq %r13
subq $0x1, %rsi
jb 0x12a96
movb (%r15), %bpl
cmpq %rax, 0x10(%rsp)
je 0x12a8f
movq %rsi, %r14
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xf980
movq %r14, %rsi
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movb %bpl, -0x1(%rcx,%r12)
jmp 0x12a61
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/mem.c |
memXor | void memXor(void* dest, const void* src1, const void* src2, size_t count)
{
ASSERT(memIsSameOrDisjoint(src1, dest, count));
ASSERT(memIsSameOrDisjoint(src2, dest, count));
for (; count >= O_PER_W; count -= O_PER_W)
{
*(word*)dest = *(const word*)src1 ^ *(const word*)src2;
src1 = (const word*)src1 + 1;
src2 = (const word*)src2 + 1;
dest = (word*)dest + 1;
}
while (count--)
{
*(octet*)dest = *(const octet*)src1 ^ *(const octet*)src2;
src1 = (const octet*)src1 + 1;
src2 = (const octet*)src2 + 1;
dest = (octet*)dest + 1;
}
} | cmpq $0x7, %rcx
jbe 0x12ac6
movq (%rdx), %rax
xorq (%rsi), %rax
movq %rax, (%rdi)
addq $0x8, %rsi
addq $0x8, %rdx
addq $0x8, %rdi
addq $-0x8, %rcx
jmp 0x12aa5
xorl %eax, %eax
cmpq %rax, %rcx
je 0x12ade
movb (%rdx,%rax), %r8b
xorb (%rsi,%rax), %r8b
movb %r8b, (%rdi,%rax)
incq %rax
jmp 0x12ac8
retq
| /agievich[P]bee2/src/core/mem.c |
memXor2 | void memXor2(void* dest, const void* src, size_t count)
{
ASSERT(memIsSameOrDisjoint(src, dest, count));
for (; count >= O_PER_W; count -= O_PER_W)
{
*(word*)dest ^= *(const word*)src;
src = (const word*)src + 1;
dest = (word*)dest + 1;
}
while (count--)
{
*(octet*)dest ^= *(const octet*)src;
src = (const octet*)src + 1;
dest = (octet*)dest + 1;
}
} | cmpq $0x7, %rdx
jbe 0x12af9
movq (%rsi), %rax
xorq %rax, (%rdi)
addq $0x8, %rsi
addq $0x8, %rdi
addq $-0x8, %rdx
jmp 0x12adf
xorl %eax, %eax
cmpq %rax, %rdx
je 0x12b0b
movb (%rsi,%rax), %cl
xorb %cl, (%rdi,%rax)
incq %rax
jmp 0x12afb
retq
| /agievich[P]bee2/src/core/mem.c |
memSwap | void memSwap(void* buf1, void* buf2, size_t count)
{
ASSERT(memIsDisjoint(buf1, buf2, count));
for (; count >= O_PER_W; count -= O_PER_W)
{
SWAP(*(word*)buf1, *(word*)buf2);
buf1 = (word*)buf1 + 1;
buf2 = (word*)buf2 + 1;
}
while (count--)
{
SWAP(*(octet*)buf1, *(octet*)buf2);
buf1 = (octet*)buf1 + 1;
buf2 = (octet*)buf2 + 1;
}
} | cmpq $0x7, %rdx
jbe 0x12b32
movq (%rdi), %rax
xorq (%rsi), %rax
movq %rax, (%rdi)
xorq (%rsi), %rax
movq %rax, (%rsi)
xorq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
addq $-0x8, %rdx
jmp 0x12b0c
xorl %eax, %eax
cmpq %rax, %rdx
je 0x12b50
movb (%rdi,%rax), %cl
xorb (%rsi,%rax), %cl
movb %cl, (%rdi,%rax)
xorb (%rsi,%rax), %cl
movb %cl, (%rsi,%rax)
xorb %cl, (%rdi,%rax)
incq %rax
jmp 0x12b34
retq
| /agievich[P]bee2/src/core/mem.c |
mtCallOnce | bool_t mtCallOnce(size_t* once, void (*fn)())
{
size_t t;
// попытки вызова
do
// удается захватить триггер?...
if ((t = mtAtomicCmpSwap(once, 0, SIZE_MAX)) == 0)
{
// ... да, обработать захват
fn(), *once = 1;
break;
}
// ... нет, ожидаем обработки захвата в другом потоке
while (t == SIZE_MAX);
// завершить
ASSERT(*once == 1);
return TRUE;
} | pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %rcx
xorl %eax, %eax
lock
cmpxchgq %rcx, (%rbx)
cmpq $-0x1, %rax
je 0x12bef
testq %rax, %rax
jne 0x12c0c
xorl %eax, %eax
callq *%rsi
movq $0x1, (%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
| /agievich[P]bee2/src/core/mt.c |
hexIsValid | bool_t hexIsValid(const char* hex)
{
if (!strIsValid(hex) || strLen(hex) % 2)
return FALSE;
for (; *hex; ++hex)
if (hex_dec_table[(octet)*hex] == 0xFF)
return FALSE;
return TRUE;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xe0d0
xorl %ebx, %ebx
testl %eax, %eax
je 0x12c72
movq %r14, %rdi
callq 0xf210
testb $0x1, %al
jne 0x12c72
pushq $0x1
popq %rax
leaq 0x3ac34(%rip), %rcx # 0x4d890
movzbl (%r14), %edx
testq %rdx, %rdx
je 0x12c70
incq %r14
cmpb $-0x1, (%rdx,%rcx)
jne 0x12c5c
jmp 0x12c72
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/hex.c |
hexUpper | void hexUpper(char* hex)
{
ASSERT(hexIsValid(hex));
for (; *hex; hex += 2)
hexFromOUpper(hex, hexToO(hex));
} | leaq 0x3ac0d(%rip), %rax # 0x4d890
leaq 0x3ad06(%rip), %rcx # 0x4d990
movzbl (%rdi), %edx
testq %rdx, %rdx
je 0x12cbd
movb (%rdx,%rax), %dl
movzbl 0x1(%rdi), %esi
movzbl (%rsi,%rax), %esi
shlb $0x4, %dl
orb %sil, %dl
movzbl %dl, %edx
shrl $0x4, %edx
movb (%rdx,%rcx), %dl
movb %dl, (%rdi)
andl $0xf, %esi
movb (%rsi,%rcx), %dl
movb %dl, 0x1(%rdi)
addq $0x2, %rdi
jmp 0x12c8a
retq
| /agievich[P]bee2/src/core/hex.c |
hexLower | void hexLower(char* hex)
{
ASSERT(hexIsValid(hex));
for (; *hex; hex += 2)
hexFromOLower(hex, hexToO(hex));
} | leaq 0x3abcb(%rip), %rax # 0x4d890
leaq 0x3ace4(%rip), %rcx # 0x4d9b0
movzbl (%rdi), %edx
testq %rdx, %rdx
je 0x12cff
movb (%rdx,%rax), %dl
movzbl 0x1(%rdi), %esi
movzbl (%rsi,%rax), %esi
shlb $0x4, %dl
orb %sil, %dl
movzbl %dl, %edx
shrl $0x4, %edx
movb (%rdx,%rcx), %dl
movb %dl, (%rdi)
andl $0xf, %esi
movb (%rsi,%rcx), %dl
movb %dl, 0x1(%rdi)
addq $0x2, %rdi
jmp 0x12ccc
retq
| /agievich[P]bee2/src/core/hex.c |
hexEq | bool_t SAFE(hexEq)(const void* buf, const char* hex)
{
register word diff = 0;
size_t count;
ASSERT(hexIsValid(hex));
ASSERT(memIsValid(buf, strLen(hex) / 2));
count = strLen(hex);
for (; count; count -= 2, hex += 2, buf = (const octet*)buf + 1)
diff |= *(const octet*)buf ^ hexToO(hex);
return wordEq(diff, 0);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xf210
xorl %ecx, %ecx
leaq 0x3ab75(%rip), %rdx # 0x4d890
xorl %esi, %esi
cmpq %rcx, %rax
je 0x12d4b
movzbl (%rbx,%rcx), %edi
movb (%rdi,%rdx), %dil
movzbl 0x1(%rbx,%rcx), %r8d
shlb $0x4, %dil
orb (%r8,%rdx), %dil
xorb (%r14), %dil
movzbl %dil, %edi
orq %rdi, %rsi
incq %r14
addq $0x2, %rcx
jmp 0x12d1d
xorl %eax, %eax
testq %rsi, %rsi
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/hex.c |
hexEq_fast | bool_t FAST(hexEq)(const void* buf, const char* hex)
{
size_t count;
ASSERT(hexIsValid(hex));
ASSERT(memIsValid(buf, strLen(hex) / 2));
count = strLen(hex);
for (; count; count -= 2, hex += 2, buf = (const octet*)buf + 1)
if (*(const octet*)buf != hexToO(hex))
return FALSE;
return TRUE;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xf210
movq %rax, %rcx
xorl %edx, %edx
pushq $0x1
popq %rax
leaq 0x3ab14(%rip), %rsi # 0x4d890
cmpq %rdx, %rcx
je 0x12da7
movzbl (%rbx,%rdx), %edi
movb (%rdi,%rsi), %dil
movzbl 0x1(%rbx,%rdx), %r8d
shlb $0x4, %dil
orb (%r8,%rsi), %dil
cmpb %dil, (%r14)
jne 0x12da5
incq %r14
addq $0x2, %rdx
jmp 0x12d7c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/hex.c |
hexEqRev | bool_t SAFE(hexEqRev)(const void* buf, const char* hex)
{
register word diff = 0;
size_t count;
ASSERT(hexIsValid(hex));
ASSERT(memIsValid(buf, strLen(hex) / 2));
count = strLen(hex);
hex = hex + count;
for (; count; count -= 2, buf = (const octet*)buf + 1)
diff |= *(const octet*)buf ^ hexToO(hex -= 2);
return wordEq(diff, 0);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xf210
xorl %ecx, %ecx
leaq 0x3aac6(%rip), %rdx # 0x4d890
testq %rax, %rax
je 0x12df8
movzbl -0x2(%rbx,%rax), %esi
movb (%rsi,%rdx), %sil
movzbl -0x1(%rbx,%rax), %edi
shlb $0x4, %sil
orb (%rdi,%rdx), %sil
xorb (%r14), %sil
movzbl %sil, %esi
orq %rsi, %rcx
addq $-0x2, %rax
incq %r14
jmp 0x12dca
xorl %eax, %eax
testq %rcx, %rcx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/hex.c |
hexEqRev_fast | bool_t FAST(hexEqRev)(const void* buf, const char* hex)
{
size_t count;
ASSERT(hexIsValid(hex));
ASSERT(memIsValid(buf, strLen(hex) / 2));
count = strLen(hex);
hex = hex + count;
for (; count; count -= 2, buf = (const octet*)buf + 1)
if (*(const octet*)buf != hexToO(hex -= 2))
return FALSE;
return TRUE;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xf210
movq %rax, %rcx
pushq $0x1
popq %rax
leaq 0x3aa69(%rip), %rdx # 0x4d890
testq %rcx, %rcx
je 0x12e52
movzbl -0x2(%rbx,%rcx), %esi
movb (%rsi,%rdx), %sil
movzbl -0x1(%rbx,%rcx), %edi
shlb $0x4, %sil
orb (%rdi,%rdx), %sil
cmpb %sil, (%r14)
jne 0x12e50
addq $-0x2, %rcx
incq %r14
jmp 0x12e27
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/hex.c |
hexFrom | void hexFrom(char* dest, const void* src, size_t count)
{
ASSERT(memIsDisjoint2(src, count, dest, 2 * count + 1));
for (; count--; dest += 2, src = (const octet*)src + 1)
hexFromOUpper(dest, *(const octet*)src);
*dest = '\0';
} | xorl %eax, %eax
leaq 0x3ab2d(%rip), %rcx # 0x4d990
cmpq %rax, %rdx
je 0x12e8e
movzbl (%rsi,%rax), %r8d
movl %r8d, %r9d
shrl $0x4, %r9d
movb (%r9,%rcx), %r9b
movb %r9b, (%rdi,%rax,2)
andl $0xf, %r8d
movb (%r8,%rcx), %r8b
movb %r8b, 0x1(%rdi,%rax,2)
incq %rax
jmp 0x12e63
movb $0x0, (%rdi,%rax,2)
retq
| /agievich[P]bee2/src/core/hex.c |
hexTo | void hexTo(void* dest, const char* src)
{
size_t count;
ASSERT(hexIsValid(src));
ASSERT(memIsDisjoint2(src, strLen(src) + 1, dest, strLen(src) / 2));
count = strLen(src);
for (; count; count -= 2, src += 2, dest = (octet*)dest + 1)
*(octet*)dest = hexToO(src);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xf210
xorl %ecx, %ecx
leaq 0x3a9af(%rip), %rdx # 0x4d890
cmpq %rcx, %rax
je 0x12f07
movzbl (%rbx,%rcx), %esi
movb (%rsi,%rdx), %sil
movzbl 0x1(%rbx,%rcx), %edi
shlb $0x4, %sil
orb (%rdi,%rdx), %sil
movb %sil, (%r14)
incq %r14
addq $0x2, %rcx
jmp 0x12ee1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/hex.c |
hexToRev | void hexToRev(void* dest, const char* src)
{
size_t count;
ASSERT(hexIsValid(src));
ASSERT(memIsDisjoint2(src, strLen(src) + 1, dest, strLen(src) / 2));
count = strLen(src);
src = src + count;
for (; count; count -= 2, dest = (octet*)dest + 1)
*(octet*)dest = hexToO(src -= 2);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xf210
leaq 0x3a968(%rip), %rcx # 0x4d890
testq %rax, %rax
je 0x12f4c
movzbl -0x2(%rbx,%rax), %edx
movb (%rdx,%rcx), %dl
movzbl -0x1(%rbx,%rax), %esi
shlb $0x4, %dl
orb (%rsi,%rcx), %dl
movb %dl, (%r14)
addq $-0x2, %rax
incq %r14
jmp 0x12f28
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/hex.c |
objIsOperable2 | bool_t objIsOperable2(const void* obj)
{
return memIsValid(obj, sizeof(obj_hdr_t)) &&
memIsValid(obj, objKeep(obj)) &&
objOCount(obj) <= objPCount(obj) &&
sizeof(obj_hdr_t) + sizeof(void*) * objPCount(obj) <= objKeep(obj);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x18
popq %rsi
callq 0xeeb0
xorl %ebx, %ebx
testl %eax, %eax
je 0x12f92
movq (%r14), %rsi
movq %r14, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x12f92
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
ja 0x12f92
leaq 0x18(,%rax,8), %rax
xorl %ebx, %ebx
cmpq (%r14), %rax
setbe %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/obj.c |
objIsOperable | bool_t objIsOperable(const void* obj)
{
size_t i;
// проверить сам объект
if (!objIsOperable2(obj))
return FALSE;
// проверить ссылочные объекты
for (i = 0; i < objOCount(obj); ++i)
if (!objIsOperable(objCPtr(obj, i, void)))
return FALSE;
// все нормально
return TRUE;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xe7d0
testl %eax, %eax
je 0x12fc9
xorl %r14d, %r14d
pushq $0x1
popq %rbp
cmpq 0x10(%rbx), %r14
jae 0x12fcb
movq 0x18(%rbx,%r14,8), %rdi
callq 0xf850
incq %r14
testl %eax, %eax
jne 0x12fb2
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /agievich[P]bee2/src/core/obj.c |
objCopy | void objCopy(void* dest, const void* src)
{
ASSERT(objIsOperable(src));
ASSERT(memIsValid(dest, objKeep(src)));
// скопировать данные
memMove(dest, src, objKeep(src));
// сдвинуть указатели
objShiftPtrs(dest, (const octet*)dest - (const octet*)src);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdx
callq 0xe130
movq %r14, %rsi
subq %rbx, %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12ff6
| /agievich[P]bee2/src/core/obj.c |
objShiftPtrs | static void objShiftPtrs(void* obj, ptrdiff_t diff)
{
size_t i;
// просмотреть объекты
for (i = 0; i < objOCount(obj); ++i)
// вложенный объект?
if ((octet*)obj <= objPtr(obj, i, octet) + diff &&
objPtr(obj, i, octet) + diff < objEnd(obj, octet))
{
objShiftPtrs(objPtr(obj, i, void), diff);
objPtr(obj, i, octet) += diff;
}
// просмотреть оставшиеся указатели
for (; i < objPCount(obj); ++i)
// вложенный указатель?
if ((octet*)obj <= objPtr(obj, i, octet) + diff &&
objPtr(obj, i, octet) + diff < objEnd(obj, octet))
objPtr(obj, i, octet) += diff;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq 0x10(%r14), %r15
jae 0x13055
movq 0x18(%r14,%r15,8), %rdi
leaq (%rdi,%rbx), %rax
cmpq %r14, %rax
jb 0x13030
movq (%r14), %rcx
addq %r14, %rcx
cmpq %rcx, %rax
jae 0x13030
movq %rbx, %rsi
callq 0x12ff6
addq %rbx, 0x18(%r14,%r15,8)
incq %r15
jmp 0x13004
movq 0x18(%r14,%r15,8), %rax
addq %rbx, %rax
cmpq %r14, %rax
jb 0x13052
movq (%r14), %rcx
addq %r14, %rcx
cmpq %rcx, %rax
jae 0x13052
movq %rax, 0x18(%r14,%r15,8)
incq %r15
cmpq 0x8(%r14), %r15
jb 0x13035
popq %rbx
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/core/obj.c |
objAppend | void objAppend(void* dest, const void* src, size_t i)
{
size_t t;
// pre
ASSERT(objIsOperable(src));
ASSERT(objIsOperable(dest));
ASSERT(memIsValid(objEnd(dest, void), objKeep(src)));
ASSERT(i < objOCount(dest));
// запомнить размер src
t = objKeep(src);
// скопировать src в конец dest
objCopy(objEnd(dest, void), src);
// установить ссылку на конец dest
objPtr(dest, i, void) = objEnd(dest, void);
// расширить dest
objHdr(dest)->keep += t;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq (%rdi), %rdi
addq %r14, %rdi
callq 0xfa50
movq (%r14), %rax
addq %r14, %rax
movq %rax, 0x18(%r14,%rbx,8)
addq %r15, (%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
| /agievich[P]bee2/src/core/obj.c |
oidIsValid | bool_t oidIsValid(const char* oid)
{
u32 val = 0;
u32 d1 = 0;
size_t pos = 0;
size_t n = 0;
// pre
if (!strIsValid(oid))
return FALSE;
// цикл по символам oid
while (1)
{
// закончили очередное число?
if (oid[pos] == '.' || oid[pos] == '\0')
{
// пустое число? d1 > 2? d1 < 2 && d2 >= 40?
// 40 * d1 + d2 не укладывается в u32?
if (pos == 0 ||
n == 0 && val > 2 ||
n == 1 && d1 < 2 && val >= 40 ||
n == 1 && val > U32_MAX - 40 * d1)
{
n = 0;
break;
}
// сохранить d1
if (n == 0)
d1 = val;
// закончить обработку
n++;
// конец строки?
if (oid[pos] == '\0')
break;
// к следующему числу (пропустить .)
oid += ++pos, pos = 0, val = 0;
continue;
}
// недопустимый символ? лидирующий 0? переполнение?
if (oid[pos] < '0' || oid[pos] > '9' ||
pos == 1 && oid[0] == '0' ||
val > U32_MAX / 10 ||
val == U32_MAX / 10 && (u32)(oid[pos] - '0') > U32_MAX % 10)
{
n = 0;
break;
}
// обработать цифру
val *= 10;
val += oid[pos] - '0';
++pos;
}
// очистка и выход
val = d1 = 0, pos = 0;
return n >= 2;
} | pushq %rbx
movq %rdi, %rbx
callq 0xe0d0
testl %eax, %eax
je 0x13165
xorl %ecx, %ecx
xorl %edx, %edx
xorl %edi, %edi
xorl %esi, %esi
movzbl (%rbx,%rsi), %r8d
cmpl $0x2e, %r8d
je 0x1310e
testl %r8d, %r8d
je 0x1310e
leal -0x3a(%r8), %r9d
xorl %eax, %eax
cmpb $-0xa, %r9b
jb 0x13167
cmpq $0x1, %rsi
jne 0x130d8
cmpb $0x30, (%rbx)
je 0x13167
cmpl $0x19999999, %edi # imm = 0x19999999
ja 0x13167
cmpl $0x19999999, %edi # imm = 0x19999999
sete %r9b
leal -0x36(%r8), %r10d
cmpl $-0x6, %r10d
setb %r10b
testb %r10b, %r9b
jne 0x13167
imull $0xa, %edi, %eax
leal (%rax,%r8), %edi
addl $-0x30, %edi
incq %rsi
jmp 0x130a9
testq %rsi, %rsi
je 0x13169
testq %rdx, %rdx
jne 0x1311d
cmpl $0x2, %edi
ja 0x13169
cmpq $0x1, %rdx
sete %al
cmpl $0x2, %ecx
setb %r9b
andb %al, %r9b
cmpl $0x28, %edi
setae %al
testb %al, %r9b
jne 0x13169
cmpq $0x1, %rdx
jne 0x13148
imull $-0x28, %ecx, %eax
decl %eax
cmpl %eax, %edi
ja 0x13169
leaq 0x1(%rdx), %r9
testl %r8d, %r8d
je 0x1316c
testq %rdx, %rdx
cmovel %edi, %ecx
addq %rsi, %rbx
incq %rbx
movq %r9, %rdx
jmp 0x130a5
xorl %eax, %eax
popq %rbx
retq
xorl %r9d, %r9d
xorl %eax, %eax
cmpq $0x2, %r9
setae %al
jmp 0x13167
| /agievich[P]bee2/src/core/oid.c |
prngCOMBOStart | void prngCOMBOStart(void* state, u32 seed)
{
prng_combo_st* s = (prng_combo_st*)state;
ASSERT(memIsValid(s, sizeof(*s)));
s->x = 0xF8B7BB93;
s->y = 0xBEE3B54B;
s->z = 0x1F6B7FBD + seed;
if (s->z)
++s->z;
s->reserved = 0;
} | movabsq $-0x411c4ab40748446d, %rax # imm = 0xBEE3B54BF8B7BB93
movq %rax, (%rdi)
leal 0x1f6b7fbe(%rsi), %eax
xorl %ecx, %ecx
cmpl $0xe0948043, %esi # imm = 0xE0948043
cmovnel %eax, %ecx
movl %ecx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
retq
| /agievich[P]bee2/src/core/prng.c |
prngCOMBOStepR | void prngCOMBOStepR(void* buf, size_t count, void* state)
{
prng_combo_st* s = (prng_combo_st*)state;
ASSERT(memIsValid(buf, count));
ASSERT(memIsValid(s, sizeof(*s)));
// есть резерв?
if (s->reserved)
{
if (s->reserved >= count)
{
memCopy(buf, s->r.block + 4 - s->reserved, count);
s->reserved -= count;
return;
}
memCopy(buf, s->r.block + 4 - s->reserved, s->reserved);
count -= s->reserved;
buf = (octet*)buf + s->reserved;
s->reserved = 0;
}
// цикл по полным блокам
while (count >= 4)
{
prngCOMBOStep(s);
memCopy(buf, s->r.block, 4);
buf = (octet*)buf + 4;
count -= 4;
}
// неполный блок?
if (count)
{
prngCOMBOStep(s);
memCopy(buf, s->r.block, count);
s->reserved = 4 - count;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdx), %rbp
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x13222
movq %rbp, %rsi
subq %rdx, %rsi
cmpq %rbx, %rdx
jae 0x1326d
movq %r14, %rdi
callq 0xe970
movq (%rbp), %rax
subq %rax, %rbx
addq %rax, %r14
andq $0x0, (%rbp)
leaq 0xc(%r15), %r13
pushq $0x4
popq %r12
cmpq $0x4, %rbx
jb 0x13250
movq %r15, %rdi
callq 0x13292
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xe970
addq $0x4, %r14
addq $-0x4, %rbx
jmp 0x1322a
testq %rbx, %rbx
je 0x13283
movq %r15, %rdi
callq 0x13292
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xe970
jmp 0x1327c
movq %r14, %rdi
movq %rbx, %rdx
callq 0xe970
movq (%rbp), %r12
subq %rbx, %r12
movq %r12, (%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/prng.c |
prngCOMBOStep | static void prngCOMBOStep(prng_combo_st* s)
{
s->r.u32 = s->x * s->x;
s->x = s->y;
s->y = s->r.u32;
s->z = (s->z & 0xFFFF) * 30903 + (s->z >> 16);
s->r.u32 += s->z;
#if (OCTET_ORDER == BIG_ENDIAN)
s->r.u32 = u32Rev(s->r.u32);
#endif
} | movl (%rdi), %eax
movl 0x4(%rdi), %ecx
imull %eax, %eax
movl %ecx, (%rdi)
movl %eax, 0x4(%rdi)
movl 0x8(%rdi), %ecx
movzwl %cx, %edx
imull $0x78b7, %edx, %edx # imm = 0x78B7
shrl $0x10, %ecx
addl %edx, %ecx
movl %ecx, 0x8(%rdi)
addl %eax, %ecx
movl %ecx, 0xc(%rdi)
retq
| /agievich[P]bee2/src/core/prng.c |
prngEchoStart | void prngEchoStart(void* state, const void* seed, size_t seed_len)
{
prng_echo_st* s = (prng_echo_st*)state;
ASSERT(memIsValid(s, sizeof(prng_echo_st)));
ASSERT(seed_len > 0);
ASSERT(memIsValid(seed, seed_len));
// инициализировать
s->seed = (const octet*)seed;
s->seed_len = seed_len;
s->pos = 0;
} | movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
retq
| /agievich[P]bee2/src/core/prng.c |
prngSTBStart | void prngSTBStart(void* state, const u16 z[31])
{
prng_stb_st* s = (prng_stb_st*)state;
size_t i;
// pre
ASSERT(memIsValid(s, sizeof(prng_stb_st)));
ASSERT(memIsNullOrValid(z, 2 * 31));
// загрузить z
for (i = 0; i < 31; ++i)
{
s->z[i] = z ? z[i] : (u16)(i + 1);
ASSERT(s->z[i] > 0 && s->z[i] < 65257);
}
// настроить состояние
s->v = s->w = 0;
s->i = 0;
// холостой ход
for (i = 0; i < 256; ++i)
_prngSTBClock(s);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x4
popq %rax
cmpq $0x23, %rax
je 0x1332a
testq %rsi, %rsi
je 0x1331e
movzwl -0x8(%rsi,%rax,2), %ecx
jmp 0x13321
leal -0x3(%rax), %ecx
movw %cx, (%rbx,%rax,2)
incq %rax
jmp 0x1330c
andl $0x0, 0x46(%rbx)
andq $0x0, (%rbx)
movl $0x100, %r14d # imm = 0x100
subq $0x1, %r14
jb 0x13348
movq %rbx, %rdi
callq 0x13350
jmp 0x13338
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/prng.c |
prngSTBClock | static void _prngSTBClock(prng_stb_st* s)
{
size_t j = (s->i + 10) % 31;
// v <- v + z[i]
s->v += s->z[s->i];
// w <- z[i + 20] + rotHi(w, 1)
s->w = (s->w >> 1) | (s->w << 15);
s->w += s->z[(s->i + 20) % 31];
// u <- v ^ w
s->u = s->v ^ s->w;
// z[i] <- (z[i - 31] - z[i - 21]) \mod 65257
ASSERT(s->z[s->i] < 65257 && s->z[j] < 65257);
if (s->z[s->i] >= s->z[j])
s->z[s->i] -= s->z[j];
else
s->z[s->i] = 65257 - (s->z[j] - s->z[s->i]);
// i <- i + 1
s->i = (s->i + 1) % 31;
} | movq (%rdi), %r8
leaq 0xa(%r8), %rax
pushq $0x1f
popq %rsi
xorl %edx, %edx
divq %rsi
movq %rdx, %rcx
movzwl 0x46(%rdi), %r9d
addw 0x8(%rdi,%r8,2), %r9w
movw %r9w, 0x46(%rdi)
movzwl 0x48(%rdi), %r10d
rorw %r10w
leaq 0x14(%r8), %rax
xorl %edx, %edx
divq %rsi
movl %edx, %eax
addw 0x8(%rdi,%rax,2), %r10w
movw %r10w, 0x48(%rdi)
xorl %r9d, %r10d
movw %r10w, 0x4a(%rdi)
movzwl 0x8(%rdi,%r8,2), %eax
movl %ecx, %ecx
movzwl 0x8(%rdi,%rcx,2), %ecx
movl %eax, %edx
subw %cx, %dx
leal -0x117(%rdx), %r9d
cmpw %cx, %ax
cmovael %edx, %r9d
movw %r9w, 0x8(%rdi,%r8,2)
movq (%rdi), %rax
incq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, (%rdi)
retq
| /agievich[P]bee2/src/core/prng.c |
rngTestFIPS1 | bool_t rngTestFIPS1(const octet buf[2500])
{
size_t s = 0;
size_t count = W_OF_O(2500);
ASSERT(memIsValid(buf, 2500));
if (O_OF_W(count) > 2500)
{
ASSERT(B_PER_W == 64);
s = u32Weight(*(const u32*)(buf + 2496));
--count;
}
while (count--)
s += wordWeight(((const word*)buf)[count]);
return 9725 < s && s < 10275;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x9c0(%rdi), %edi
callq 0xf6e0
movq %rax, %r14
movl $0x137, %r15d # imm = 0x137
cmpq $-0x1, %r15
je 0x13453
movq (%rbx,%r15,8), %rdi
callq 0xeae0
addq %rax, %r14
decq %r15
jmp 0x1343c
addq $-0x25fe, %r14 # imm = 0xDA02
xorl %eax, %eax
cmpq $0x225, %r14 # imm = 0x225
setb %al
popq %rbx
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/core/rng.c |
rngTestFIPS2 | bool_t rngTestFIPS2(const octet buf[2500])
{
u32 s[16];
size_t i = 2500;
ASSERT(memIsValid(buf, 2500));
memSetZero(s, sizeof(s));
while (i--)
++s[buf[i] & 15], ++s[buf[i] >> 4];
s[0] *= s[0];
for (i = 1; i < 16; ++i)
s[0] += s[i] * s[i];
s[0] = 16 * s[0] - 5000 * 5000;
return 10800 < s[0] && s[0] < 230850;
} | pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
pushq $0x40
popq %rdx
xorl %esi, %esi
callq 0xf710
movl $0x9c4, %ecx # imm = 0x9C4
movl $0x9c4, %eax # imm = 0x9C4
subq $0x1, %rax
jb 0x134a9
movzbl -0x1(%rbx,%rcx), %ecx
movl %ecx, %edx
andl $0xf, %edx
incl (%rsp,%rdx,4)
shrl $0x4, %ecx
incl (%rsp,%rcx,4)
movq %rax, %rcx
jmp 0x1348b
movl (%rsp), %ecx
imull %ecx, %ecx
pushq $0x1
popq %rax
cmpq $0x10, %rax
je 0x134c5
movl (%rsp,%rax,4), %edx
imull %edx, %edx
addl %edx, %ecx
incq %rax
jmp 0x134b2
shll $0x4, %ecx
addl $0xfe825d8f, %ecx # imm = 0xFE825D8F
xorl %eax, %eax
cmpl $0x35b91, %ecx # imm = 0x35B91
setb %al
addq $0x40, %rsp
popq %rbx
retq
| /agievich[P]bee2/src/core/rng.c |
rngTestFIPS3 | bool_t rngTestFIPS3(const octet buf[2500])
{
word s[2][7];
octet b;
size_t l;
size_t i;
ASSERT(memIsValid(buf, 2500));
memSetZero(s, sizeof(s));
b = buf[0] & 1;
l = 1;
for (i = 1; i < 20000; ++i)
if ((buf[i / 8] >> i % 8 & 1) == b)
++l;
else
++s[b][MIN2(l, 6)], b = !b, l = 1;
++s[b][MIN2(l, 6)];
return 2315 <= s[0][1] && s[0][1] <= 2685 &&
2315 <= s[1][1] && s[1][1] <= 2685 &&
1114 <= s[0][2] && s[0][2] <= 1386 &&
1114 <= s[1][2] && s[1][2] <= 1386 &&
527 <= s[0][3] && s[0][3] <= 723 &&
527 <= s[1][3] && s[1][3] <= 723 &&
240 <= s[0][4] && s[0][4] <= 384 &&
240 <= s[1][4] && s[1][4] <= 384 &&
103 <= s[0][5] && s[0][5] <= 209 &&
103 <= s[1][5] && s[1][5] <= 209 &&
103 <= s[0][6] && s[0][6] <= 209 &&
103 <= s[1][6] && s[1][6] <= 209;
} | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
pushq $0x70
popq %rdx
xorl %esi, %esi
callq 0xf710
movb (%rbx), %dil
andb $0x1, %dil
pushq $0x1
popq %rcx
pushq $0x6
popq %rax
movq %rcx, %rsi
movq %rcx, %rdx
movzbl %dil, %r8d
cmpq $0x4e20, %rdx # imm = 0x4E20
je 0x13560
movq %rdx, %r9
shrq $0x3, %r9
movzbl (%rbx,%r9), %r9d
movl %edx, %r10d
andl $0x7, %r10d
xorl %r11d, %r11d
btl %r10d, %r9d
setb %r11b
cmpl %r8d, %r11d
jne 0x1353c
incq %rsi
jmp 0x1355b
cmpq $0x6, %rsi
cmovaeq %rax, %rsi
movl %esi, %esi
imulq $0x38, %r8, %rdi
addq %rsp, %rdi
incq (%rdi,%rsi,8)
testb %r8b, %r8b
sete %dil
movq %rcx, %rsi
incq %rdx
jmp 0x13507
cmpq $0x6, %rsi
cmovbq %rsi, %rax
movl %eax, %eax
imulq $0x38, %r8, %rcx
addq %rsp, %rcx
incq (%rcx,%rax,8)
movq $-0x90b, %rax # imm = 0xF6F5
movq 0x8(%rsp), %rcx
addq %rax, %rcx
movl $0x173, %edx # imm = 0x173
cmpq %rdx, %rcx
setb %cl
addq 0x40(%rsp), %rax
cmpq %rdx, %rax
setb %al
andb %cl, %al
movq $-0x45a, %rcx # imm = 0xFBA6
movq 0x10(%rsp), %rdx
addq %rcx, %rdx
movl $0x111, %esi # imm = 0x111
cmpq %rsi, %rdx
setb %dl
addq 0x48(%rsp), %rcx
cmpq %rsi, %rcx
setb %cl
andb %dl, %cl
andb %al, %cl
movq $-0x20f, %rax # imm = 0xFDF1
movq 0x18(%rsp), %rdx
addq %rax, %rdx
movl $0xc5, %esi
cmpq %rsi, %rdx
setb %dl
addq 0x50(%rsp), %rax
cmpq %rsi, %rax
setb %sil
andb %dl, %sil
movq $-0xf0, %rdx
movq 0x20(%rsp), %rax
addq %rdx, %rax
movl $0x91, %edi
cmpq %rdi, %rax
setb %al
andb %sil, %al
andb %cl, %al
addq 0x58(%rsp), %rdx
cmpq %rdi, %rdx
setb %cl
movq 0x28(%rsp), %rdx
addq $-0x67, %rdx
cmpq $0x6b, %rdx
setb %dl
andb %cl, %dl
movq 0x60(%rsp), %rcx
addq $-0x67, %rcx
cmpq $0x6b, %rcx
setb %cl
andb %dl, %cl
movq 0x30(%rsp), %rdx
addq $-0x67, %rdx
cmpq $0x6b, %rdx
setb %dl
andb %cl, %dl
andb %al, %dl
movq 0x68(%rsp), %rax
addq $-0x67, %rax
cmpq $0x6b, %rax
setb %al
andb %dl, %al
movzbl %al, %eax
addq $0x70, %rsp
popq %rbx
retq
| /agievich[P]bee2/src/core/rng.c |
rngTestFIPS4 | bool_t rngTestFIPS4(const octet buf[2500])
{
octet b;
size_t l;
size_t i;
ASSERT(memIsValid(buf, 2500));
b = buf[0] & 1;
l = 1;
for (i = 1; i < 20000; ++i)
if ((buf[i / 8] >> i % 8 & 1) == b)
++l;
else
{
if (l >= 26)
return FALSE;
b = !b, l = 1;
}
return l < 26;
} | movb (%rdi), %al
andb $0x1, %al
pushq $0x1
popq %rcx
movq %rcx, %rsi
movq %rcx, %rdx
cmpq $0x4e20, %rdx # imm = 0x4E20
je 0x136c0
movq %rdx, %r8
shrq $0x3, %r8
movzbl (%rdi,%r8), %r8d
movl %edx, %r9d
andl $0x7, %r9d
xorl %r10d, %r10d
btl %r9d, %r8d
setb %r10b
movzbl %al, %r8d
cmpl %r8d, %r10d
jne 0x136ad
incq %rsi
jmp 0x136bb
cmpq $0x19, %rsi
ja 0x136ca
testb %al, %al
sete %al
movq %rcx, %rsi
incq %rdx
jmp 0x13678
xorl %eax, %eax
cmpq $0x1a, %rsi
setb %al
retq
xorl %eax, %eax
retq
| /agievich[P]bee2/src/core/rng.c |
rngESRead | err_t rngESRead(size_t* read, void* buf, size_t count, const char* source)
{
if (strEq(source, "trng"))
return rngTRNGRead(buf, read, count);
else if (strEq(source, "trng2"))
return rngTRNG2Read(buf, read, count);
else if (strEq(source, "timer"))
return rngTimerRead(buf, read, count);
else if (strEq(source, "sys"))
return rngSysRead(buf, read, count);
else if (strEq(source, "sys2"))
return rngSys2Read(buf, read, count);
return ERR_FILE_NOT_FOUND;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
leaq 0x3a2d1(%rip), %rsi # 0x4d9c1
movq %rcx, %rdi
callq 0xebd0
testl %eax, %eax
je 0x137db
leaq 0x3a2bf(%rip), %rsi # 0x4d9c6
movq %r12, %rdi
callq 0xebd0
testl %eax, %eax
je 0x1388b
leaq 0x39b44(%rip), %rsi # 0x4d262
movq %r12, %rdi
callq 0xebd0
testl %eax, %eax
je 0x1393b
leaq 0x3a297(%rip), %rsi # 0x4d9cc
movq %r12, %rdi
callq 0xebd0
testl %eax, %eax
je 0x139d6
leaq 0x3a284(%rip), %rsi # 0x4d9d0
movq %r12, %rdi
callq 0xebd0
movl $0xca, %ebp
testl %eax, %eax
jne 0x13a75
movq %rbx, 0x28(%rsp)
xorl %ebx, %ebx
leaq 0x3a315(%rip), %r14 # 0x4da84
pushq $0x2
popq %r13
cmpq $0x10, %rbx
je 0x13a75
movslq (%rbx,%r14), %rdi
addq %r14, %rdi
movl %r13d, %esi
callq 0xef40
addq $0x4, %rbx
testq %rax, %rax
je 0x13773
movq %rax, %r12
andq $0x0, (%r15)
leaq 0x3a29c(%rip), %rsi # 0x4da3f
movq %rax, %rdi
callq 0xfc20
testq %rax, %rax
movq 0x28(%rsp), %rbx
je 0x13a6a
movq 0x8(%rsp), %rdi
movl %ebx, %esi
callq *%rax
cmpl $0x1, %eax
jne 0x13a6a
movq %r12, %rdi
callq 0x10040
movq %rbx, (%r15)
jmp 0x13a1d
xorl %eax, %eax
xorl %ecx, %ecx
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
andq $0x0, (%r15)
leaq 0x10(%rsp), %rdi
movl %eax, (%rdi)
movl %esi, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %edx, 0xc(%rdi)
leaq 0x3a1d3(%rip), %rsi # 0x4d9d5
callq 0x13fb5
testl %eax, %eax
jne 0x13824
leaq 0x3a1d0(%rip), %rsi # 0x4d9e2
leaq 0x10(%rsp), %rdi
callq 0x13fb5
testl %eax, %eax
je 0x13a0e
pushq $0x7
popq %rax
xorl %ecx, %ecx
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl $0xca, %ebp
btl $0x12, %esi
jae 0x13a75
xorl %ebp, %ebp
cmpq $0x4, %rbx
jb 0x13a75
movq (%r15), %rcx
movq 0x8(%rsp), %rax
leaq 0x4(%rcx), %rdx
cmpq %rbx, %rdx
ja 0x13a21
movb $0x0, 0x10(%rsp)
rdseedl %ecx
setb 0x10(%rsp)
movl %ecx, (%rax)
cmpb $0x0, 0x10(%rsp)
je 0x13a63
movq (%r15), %rcx
addq $0x4, %rcx
movq %rcx, (%r15)
addq $0x4, %rax
jmp 0x13854
xorl %eax, %eax
xorl %ecx, %ecx
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
andq $0x0, (%r15)
leaq 0x10(%rsp), %rdi
movl %eax, (%rdi)
movl %esi, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %edx, 0xc(%rdi)
leaq 0x3a123(%rip), %rsi # 0x4d9d5
callq 0x13fb5
testl %eax, %eax
jne 0x138d4
leaq 0x3a120(%rip), %rsi # 0x4d9e2
leaq 0x10(%rsp), %rdi
callq 0x13fb5
testl %eax, %eax
je 0x13a0e
pushq $0x1
popq %rax
xorl %ecx, %ecx
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl $0xca, %ebp
btl $0x1e, %ecx
jae 0x13a75
xorl %ebp, %ebp
cmpq $0x4, %rbx
jb 0x13a75
movq (%r15), %rcx
movq 0x8(%rsp), %rax
leaq 0x4(%rcx), %rdx
cmpq %rbx, %rdx
ja 0x13a3c
movb $0x0, 0x10(%rsp)
rdrandl %ecx
setb 0x10(%rsp)
movl %ecx, (%rax)
cmpb $0x0, 0x10(%rsp)
je 0x13a63
movq (%r15), %rcx
addq $0x4, %rcx
movq %rcx, (%r15)
addq $0x4, %rax
jmp 0x13904
xorl %eax, %eax
callq 0xe350
movl $0xca, %ebp
cmpq $0x3b9aca00, %rax # imm = 0x3B9ACA00
jb 0x13a75
movq %r15, 0x30(%rsp)
pushq $0x8
popq %r15
xorl %r14d, %r14d
movq %rbx, 0x28(%rsp)
cmpq %rbx, %r14
je 0x13a15
movq 0x8(%rsp), %rax
movb $0x0, (%rax,%r14)
xorl %eax, %eax
callq 0xedd0
movq %rax, %r13
xorl %r12d, %r12d
cmpq $0x8, %r12
je 0x139cc
movq %r15, %rbx
xorl %ebp, %ebp
subq $0x1, %rbx
jb 0x139b1
xorl %edi, %edi
callq 0xefe0
xorl %eax, %eax
callq 0xedd0
movq %rax, %rcx
subq %r13, %rcx
xorq %rcx, %rbp
movq %rax, %r13
jmp 0x1398f
movq %rbp, %rdi
callq 0xf4d0
movl %r12d, %ecx
shll %cl, %eax
movq 0x8(%rsp), %rcx
xorb %al, (%rcx,%r14)
incq %r12
jmp 0x13984
incq %r14
movq 0x28(%rsp), %rbx
jmp 0x13964
leaq 0x3a012(%rip), %rdi # 0x4d9ef
leaq 0x3a018(%rip), %rsi # 0x4d9fc
callq 0xf730
testq %rax, %rax
je 0x13a35
movq %rax, %r12
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xe890
movq %rax, (%r15)
movq %r12, %rdi
callq 0xe6a0
jmp 0x13a1d
movl $0xca, %ebp
jmp 0x13a75
movq 0x30(%rsp), %rax
movq %rbx, (%rax)
xorl %ebp, %ebp
jmp 0x13a75
cmpq %rbx, %rcx
jae 0x13a75
movb $0x0, 0x10(%rsp)
rdseedl %eax
setb 0x10(%rsp)
jmp 0x13a4e
movl $0xcb, %ebp
jmp 0x13a75
cmpq %rbx, %rcx
jae 0x13a75
movb $0x0, 0x10(%rsp)
rdrandl %eax
setb 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl %eax, -0x4(%rcx,%rbx)
cmpb $0x0, 0x10(%rsp)
je 0x13a63
movq %rbx, (%r15)
jmp 0x13a75
movl $0x12e, %ebp # imm = 0x12E
jmp 0x13a75
movq %r12, %rdi
callq 0x10040
pushq $0x70
popq %rbp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/rng.c |
rngESHealth2 | err_t rngESHealth2()
{
const char* sources[] = { "trng", "trng2" };
size_t pos;
// проверить физические источники
for (pos = 0; pos < COUNT_OF(sources); ++pos)
if (rngESTest(sources[pos]) == ERR_OK)
return ERR_OK;
// работоспособные источники не найдены
return ERR_NOT_ENOUGH_ENTROPY;
} | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x39f26(%rip), %r14 # 0x4da4c
cmpq $0x8, %rbx
je 0x13b44
movslq (%rbx,%r14), %rdi
addq %r14, %rdi
callq 0xfc30
addq $0x4, %rbx
testl %eax, %eax
jne 0x13b26
xorl %eax, %eax
jmp 0x13b49
movl $0x12f, %eax # imm = 0x12F
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/rng.c |
rngESHealth | err_t rngESHealth()
{
const char* sources[] = { "sys", "sys2", "timer" };
size_t valid_sources = 0;
size_t pos;
// есть работоспособный физический источник?
if (rngESHealth2() == ERR_OK)
return ERR_OK;
// проверить остальные источники
for (pos = 0; pos < COUNT_OF(sources); ++pos)
{
if (rngESTest(sources[pos]) != ERR_OK)
continue;
// два работоспособных источника?
if (++valid_sources == 2)
return ERR_OK;
}
// только один?
if (valid_sources == 1)
return ERR_NOT_ENOUGH_ENTROPY;
// ни одного
return ERR_BAD_ENTROPY;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0xeac0
testl %eax, %eax
je 0x13b97
xorl %ebx, %ebx
leaq 0x39ee9(%rip), %r14 # 0x4da54
pushq $0x1
popq %r15
xorl %r12d, %r12d
cmpq $0xc, %rbx
je 0x13b9b
movslq (%rbx,%r14), %rdi
addq %r14, %rdi
callq 0xfc30
testl %eax, %eax
jne 0x13b91
cmpq $0x1, %r12
movq %r15, %r12
je 0x13b97
addq $0x4, %rbx
jmp 0x13b72
xorl %eax, %eax
jmp 0x13ba9
xorl %eax, %eax
cmpq $0x1, %r12
sete %al
orl $0x12e, %eax # imm = 0x12E
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/core/rng.c |
rngCreate | err_t rngCreate(read_i source, void* source_state)
{
const char* sources[] = { "trng", "trng2", "sys", "timer" };
size_t read, count, pos;
// инициализировать однократно
if (!mtCallOnce(&_once, rngInit) || !_inited)
return ERR_FILE_CREATE;
// заблокировать мьютекс
mtMtxLock(_mtx);
// состояние уже создано?
if (_ctr)
{
// учесть дополнительный источник
if (source && source(&read, _state->block, 32, source_state) == ERR_OK)
brngCTRStepR(_state->block, 32, _state->alg_state);
// увеличить счетчик обращений и завершить
++_ctr;
mtMtxUnlock(_mtx);
return ERR_OK;
}
// создать состояние
_state = (rng_state_st*)blobCreate(rngCreate_keep());
if (!_state)
{
mtMtxUnlock(_mtx);
return ERR_OUTOFMEMORY;
}
// опрос источников случайности
count = 0;
beltHashStart(_state->alg_state);
for (pos = 0; pos < COUNT_OF(sources); ++pos)
if (rngESRead(&read, _state->block, 32, sources[pos]) == ERR_OK)
{
beltHashStepH(_state->block, read, _state->alg_state);
count += read;
}
if (source && source(&read, _state->block, 32, source_state) == ERR_OK)
{
beltHashStepH(_state->block, read, _state->alg_state);
count += read;
}
if (count < 32)
{
blobClose(_state), _state = 0;
mtMtxUnlock(_mtx);
return ERR_NOT_ENOUGH_ENTROPY;
}
// создать brngCTR
beltHashStepG(_state->block, _state->alg_state);
memWipe(_state->alg_state, beltHash_keep());
brngCTRStart(_state->alg_state, _state->block, 0);
memWipe(_state->block, 32);
// завершить
_ctr = 1;
mtMtxUnlock(_mtx);
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x548a3(%rip), %rdi # 0x684a0
leaq 0x406(%rip), %rsi # 0x1400a
callq 0xf2f0
movl $0xc9, %r15d
testl %eax, %eax
je 0x13c76
testb $0x1, 0x5488e(%rip) # 0x684a8
je 0x13c76
leaq 0x5488d(%rip), %rdi # 0x684b0
callq 0xfc50
cmpq $0x0, 0x548a8(%rip) # 0x684d8
je 0x13c88
testq %rbx, %rbx
je 0x13c60
movq 0x548a2(%rip), %rsi # 0x684e0
movq %rsp, %rdi
pushq $0x20
popq %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
jne 0x13c60
movq 0x5488c(%rip), %rdi # 0x684e0
leaq 0x20(%rdi), %rdx
pushq $0x20
popq %rsi
callq 0xff40
incq 0x54871(%rip) # 0x684d8
leaq 0x54842(%rip), %rdi # 0x684b0
callq 0x101b0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xe1b0
movq %rax, %rdi
callq 0xf190
movq %rax, 0x54844(%rip) # 0x684e0
testq %rax, %rax
je 0x13d7c
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
addq $0x20, %rax
movq %rax, %rdi
callq 0xe5d0
xorl %r14d, %r14d
leaq 0x39d9b(%rip), %rbx # 0x4da60
movq %rsp, %r15
pushq $0x20
popq %r12
xorl %ebp, %ebp
cmpq $0x10, %r14
je 0x13d11
movq 0x54805(%rip), %rsi # 0x684e0
movslq (%r14,%rbx), %rcx
addq %rbx, %rcx
movq %r15, %rdi
movq %r12, %rdx
callq 0xf600
testl %eax, %eax
jne 0x13d0b
movq 0x547e8(%rip), %rdi # 0x684e0
movq (%rsp), %r13
leaq 0x20(%rdi), %rdx
movq %r13, %rsi
callq 0xe360
addq %r13, %rbp
addq $0x4, %r14
jmp 0x13cce
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x13d4b
movq 0x547be(%rip), %rsi # 0x684e0
movq %rsp, %rdi
pushq $0x20
popq %rdx
movq 0x8(%rsp), %rcx
callq *%rax
testl %eax, %eax
jne 0x13d4b
movq 0x547a6(%rip), %rdi # 0x684e0
movq (%rsp), %rsi
leaq 0x20(%rdi), %rdx
callq 0xe360
addq (%rsp), %rbp
movq 0x5478e(%rip), %rdi # 0x684e0
cmpq $0x1f, %rbp
ja 0x13d91
callq 0xe920
andq $0x0, 0x5477b(%rip) # 0x684e0
leaq 0x54744(%rip), %rdi # 0x684b0
callq 0x101b0
movl $0x12f, %r15d # imm = 0x12F
jmp 0x13c76
leaq 0x5472d(%rip), %rdi # 0x684b0
callq 0x101b0
pushq $0x6e
popq %r15
jmp 0x13c76
leaq 0x20(%rdi), %rsi
callq 0xf1f0
movq 0x5473f(%rip), %rbx # 0x684e0
addq $0x20, %rbx
xorl %r15d, %r15d
xorl %eax, %eax
callq 0xe560
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf560
movq 0x5471f(%rip), %rsi # 0x684e0
leaq 0x20(%rsi), %rdi
xorl %edx, %edx
callq 0xe280
movq 0x5470d(%rip), %rdi # 0x684e0
pushq $0x20
popq %rsi
callq 0xf560
movq $0x1, 0x546f2(%rip) # 0x684d8
leaq 0x546c3(%rip), %rdi # 0x684b0
callq 0x101b0
jmp 0x13c76
| /agievich[P]bee2/src/core/rng.c |
rngIsValid | bool_t rngIsValid()
{
bool_t b;
if (!_inited)
return FALSE;
mtMtxLock(_mtx);
b = rngIsValid_internal();
mtMtxUnlock(_mtx);
return b;
} | pushq %rbx
xorl %ebx, %ebx
cmpb $0x1, 0x546a7(%rip) # 0x684a8
jne 0x13e48
leaq 0x546a6(%rip), %rdi # 0x684b0
callq 0xfc50
cmpq $0x0, 0x546c1(%rip) # 0x684d8
setne %al
movq 0x546bf(%rip), %rdi # 0x684e0
testq %rdi, %rdi
setne %cl
andb %al, %cl
xorl %ebx, %ebx
cmpb $0x1, %cl
jne 0x13e3c
callq 0xffb0
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
leaq 0x5466d(%rip), %rdi # 0x684b0
callq 0x101b0
movl %ebx, %eax
popq %rbx
retq
| /agievich[P]bee2/src/core/rng.c |
rngClose | void rngClose()
{
ASSERT(_inited);
mtMtxLock(_mtx);
ASSERT(rngIsValid_internal());
if (--_ctr == 0)
blobClose(_state), _state = 0;
mtMtxUnlock(_mtx);
} | pushq %rax
leaq 0x5465c(%rip), %rdi # 0x684b0
callq 0xfc50
decq 0x54678(%rip) # 0x684d8
jne 0x13e76
movq 0x54677(%rip), %rdi # 0x684e0
callq 0xe920
andq $0x0, 0x5466a(%rip) # 0x684e0
leaq 0x54633(%rip), %rdi # 0x684b0
popq %rax
jmp 0x101b0
| /agievich[P]bee2/src/core/rng.c |
rngStepR | void rngStepR(void* buf, size_t count, void* state)
{
const char* sources[] = {"trng", "trng2", "sys", "sys2", "timer"};
size_t read, r, pos;
// блокировать мьютекс
ASSERT(_inited);
mtMtxLock(_mtx);
// опросить источники
read = pos = 0;
while (read < count && pos < COUNT_OF(sources))
{
if (rngESRead(&r, (octet*)buf + read, count - read,
sources[pos]) != ERR_OK)
r = 0;
read += r, ++pos;
}
read = r = pos = 0;
// генерация
ASSERT(rngIsValid_internal());
brngCTRStepR(buf, count, _state->alg_state);
// снять блокировку
mtMtxUnlock(_mtx);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x545d8(%rip), %rdi # 0x684b0
callq 0xfc50
leaq 0x39b8c(%rip), %rbp # 0x4da70
xorl %r13d, %r13d
movq %rbp, %r15
xorl %r12d, %r12d
movq %rbx, %rdx
subq %r13, %rdx
jbe 0x13f2b
cmpq $0x4, %r12
ja 0x13f2b
leaq (%r14,%r13), %rsi
movslq (%rbp), %rcx
addq %r15, %rcx
movq %rsp, %rdi
callq 0xf600
testl %eax, %eax
je 0x13f1b
andq $0x0, (%rsp)
xorl %eax, %eax
jmp 0x13f1f
movq (%rsp), %rax
addq %rax, %r13
incq %r12
addq $0x4, %rbp
jmp 0x13eed
movq 0x545ae(%rip), %rdx # 0x684e0
addq $0x20, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xff40
leaq 0x54568(%rip), %rdi # 0x684b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x101b0
| /agievich[P]bee2/src/core/rng.c |
rngRekey | void rngRekey()
{
// блокировать мьютекс
ASSERT(_inited);
mtMtxLock(_mtx);
// сгенерировать новый ключ
ASSERT(rngIsValid_internal());
brngCTRStepR(_state->block, 32, _state->alg_state);
// пересоздать brngCTR
brngCTRStart(_state->alg_state, _state->block, 0);
memWipe(_state->block, 32);
// снять блокировку
mtMtxUnlock(_mtx);
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x5454a(%rip), %rbx # 0x684b0
movq %rbx, %rdi
callq 0xfc50
movq 0x5456b(%rip), %rdi # 0x684e0
leaq 0x20(%rdi), %rdx
pushq $0x20
popq %r14
movq %r14, %rsi
callq 0xff40
movq 0x54554(%rip), %rsi # 0x684e0
leaq 0x20(%rsi), %rdi
xorl %edx, %edx
callq 0xe280
movq 0x54542(%rip), %rdi # 0x684e0
movq %r14, %rsi
callq 0xf560
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x101b0
| /agievich[P]bee2/src/core/rng.c |
rngCPUIDIsManufId | static bool_t rngCPUIDIsManufId(const u32 info[4], const char id[12 + 1])
{
ASSERT(strIsValid(id));
ASSERT(strLen(id) == 12);
return memEq(info + 1, id + 0, 4) &&
memEq(info + 3, id + 4, 4) &&
memEq(info + 2, id + 8, 4);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x4, %rdi
pushq $0x4
popq %rdx
callq 0xf140
xorl %ebp, %ebp
testl %eax, %eax
je 0x14003
leaq 0xc(%r14), %rdi
leaq 0x4(%rbx), %rsi
pushq $0x4
popq %rdx
callq 0xf140
testl %eax, %eax
je 0x14003
addq $0x8, %r14
addq $0x8, %rbx
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf140
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /agievich[P]bee2/src/core/rng.c |
rngInit | static void rngInit()
{
ASSERT(!_inited);
// создать мьютекс
if (!mtMtxCreate(_mtx))
return;
// зарегистрировать деструктор
if (!utilOnExit(rngDestroy))
{
mtMtxClose(_mtx);
return;
}
_inited = TRUE;
} | pushq %rax
leaq 0x5449e(%rip), %rdi # 0x684b0
callq 0xe620
testl %eax, %eax
je 0x14032
leaq 0x1f(%rip), %rdi # 0x14041
callq 0xe9d0
testl %eax, %eax
je 0x14034
movb $0x1, 0x54476(%rip) # 0x684a8
popq %rax
retq
leaq 0x54475(%rip), %rdi # 0x684b0
popq %rax
jmp 0xff00
| /agievich[P]bee2/src/core/rng.c |
rngDestroy | static void rngDestroy()
{
// закрыть состояние (могли забыть)
mtMtxLock(_mtx);
blobClose(_state), _state = 0, _ctr = 0;
mtMtxUnlock(_mtx);
// закрыть мьютекс
mtMtxClose(_mtx);
} | pushq %rbx
leaq 0x54467(%rip), %rbx # 0x684b0
movq %rbx, %rdi
callq 0xfc50
movq 0x54488(%rip), %rdi # 0x684e0
callq 0xe920
andq $0x0, 0x5447b(%rip) # 0x684e0
andq $0x0, 0x5446b(%rip) # 0x684d8
movq %rbx, %rdi
callq 0x101b0
movq %rbx, %rdi
popq %rbx
jmp 0xff00
nop
| /agievich[P]bee2/src/core/rng.c |
strIsAlphanumeric | bool_t strIsAlphanumeric(const char* str)
{
ASSERT(strIsValid(str));
for (; *str; ++str)
if ((*str < '0' || *str > '9') &&
(*str < 'A' || *str > 'Z') &&
(*str < 'a' || *str > 'z'))
return FALSE;
return TRUE;
} | pushq $0x1
popq %rax
movb (%rdi), %cl
testb %cl, %cl
je 0x14120
leal -0x3a(%rcx), %edx
incq %rdi
cmpb $-0xb, %dl
ja 0x14102
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1b, %cl
ja 0x14102
xorl %eax, %eax
retq
| /agievich[P]bee2/src/core/str.c |
strIsPrintable | bool_t strIsPrintable(const char* str)
{
ASSERT(strIsValid(str));
for (; *str; ++str)
if ((*str < '0' || *str > '9') &&
(*str < 'A' || *str > 'Z') &&
(*str < 'a' || *str > 'z') &&
strchr(" '()+,-./:=?", *str) == 0)
return FALSE;
return TRUE;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
leaq 0x390de(%rip), %r15 # 0x4d214
pushq $0xd
popq %r12
movsbl (%r14), %esi
testl %esi, %esi
je 0x1416a
leal -0x3a(%rsi), %eax
cmpb $-0xb, %al
ja 0x14163
movl %esi, %eax
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
ja 0x14163
movq %r15, %rdi
movq %r12, %rdx
callq 0xed50
testq %rax, %rax
je 0x14168
incq %r14
jmp 0x1413a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/core/str.c |
strStartsWith | bool_t strStartsWith(const char* str, const char* prefix)
{
ASSERT(strIsValid(str));
ASSERT(strIsValid(prefix));
for(; *prefix; ++prefix, ++str)
if (*str != *prefix)
return FALSE;
return TRUE;
} | xorl %ecx, %ecx
pushq $0x1
popq %rax
movb (%rsi,%rcx), %dl
testb %dl, %dl
je 0x141a2
cmpb %dl, (%rdi,%rcx)
jne 0x141a0
incq %rcx
jmp 0x1418f
xorl %eax, %eax
retq
| /agievich[P]bee2/src/core/str.c |
strEndsWith | bool_t strEndsWith(const char* str, const char* suffix)
{
ASSERT(strIsValid(str));
ASSERT(strIsValid(suffix));
if (strLen(str) < strLen(suffix))
return FALSE;
for(str += strLen(str) - strLen(suffix); *suffix; ++suffix, ++str)
if (*str != *suffix)
return FALSE;
return TRUE;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe750
movq %rax, %r15
movq %rbx, %rdi
callq 0xe750
subq %rax, %r15
jae 0x141cb
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
addq %r15, %r14
xorl %ecx, %ecx
pushq $0x1
popq %rax
movb (%rbx,%rcx), %dl
testb %dl, %dl
je 0x141c5
cmpb %dl, (%r14,%rcx)
jne 0x141c3
incq %rcx
jmp 0x141d3
| /agievich[P]bee2/src/core/str.c |
strRev | void strRev(char* str)
{
size_t i, j;
ASSERT(strIsValid(str));
for (i = 0, j = strLen(str); i + 1 < j;)
{
str[i] ^= str[--j];
str[j] ^= str[i];
str[i++] ^= str[j];
}
} | pushq %rbx
movq %rdi, %rbx
callq 0xe750
pushq $0x1
popq %rcx
cmpq %rax, %rcx
jae 0x14216
movb -0x1(%rbx,%rcx), %dl
xorb -0x1(%rbx,%rax), %dl
movb %dl, -0x1(%rbx,%rcx)
xorb -0x1(%rbx,%rax), %dl
movb %dl, -0x1(%rbx,%rax)
xorb %dl, -0x1(%rbx,%rcx)
decq %rax
incq %rcx
jmp 0x141f1
popq %rbx
retq
| /agievich[P]bee2/src/core/str.c |
tmDate | bool_t tmDate(size_t* y, size_t* m, size_t* d)
{
struct tm lt;
time_t et;
// входной контроль
ASSERT(memIsNullOrValid(y, O_PER_S));
ASSERT(memIsNullOrValid(m, O_PER_S));
ASSERT(memIsNullOrValid(d, O_PER_S));
// получить отметку времени
if (time(&et) == -1 || !localtime_r(&et, <))
return FALSE;
// возвратить данные
if (y)
*y = (size_t)lt.tm_year, *y += 1900;
if (m)
*m = (size_t)lt.tm_mon + 1;
if (d)
*d = (size_t)lt.tm_mday;
return TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0xf230
xorl %ebp, %ebp
cmpq $-0x1, %rax
je 0x1431e
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe2f0
testq %rax, %rax
je 0x1431e
testq %r15, %r15
je 0x142fe
movslq 0x24(%rsp), %rax
addq $0x76c, %rax # imm = 0x76C
movq %rax, (%r15)
testq %r14, %r14
je 0x1430e
movslq 0x20(%rsp), %rax
incq %rax
movq %rax, (%r14)
pushq $0x1
popq %rbp
testq %rbx, %rbx
je 0x1431e
movslq 0x1c(%rsp), %rax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/core/tm.c |
tmDateIsValid2 | bool_t tmDateIsValid2(const octet date[6])
{
return memIsValid(date, 6) &&
tmDateIsValid(
(size_t)10 * date[0] + date[1] + 2000,
(size_t)10 * date[2] + date[3],
(size_t)10 * date[4] + date[5]);
} | pushq %rbx
movq %rdi, %rbx
pushq $0x6
popq %rsi
callq 0xeeb0
testl %eax, %eax
je 0x1447a
movzbl (%rbx), %eax
imulq $0xa, %rax, %rax
movzbl 0x1(%rbx), %ecx
leaq (%rcx,%rax), %rdi
addq $0x7d0, %rdi # imm = 0x7D0
movzbl 0x2(%rbx), %eax
imulq $0xa, %rax, %rax
movzbl 0x3(%rbx), %esi
addq %rax, %rsi
movzbl 0x4(%rbx), %eax
imulq $0xa, %rax, %rax
movzbl 0x5(%rbx), %edx
addq %rax, %rdx
popq %rbx
jmp 0xf380
xorl %eax, %eax
popq %rbx
retq
| /agievich[P]bee2/src/core/tm.c |
tmCalcFreq | static void tmCalcFreq()
{
tm_ticks_t start;
tm_ticks_t overhead;
start = tmTicks();
overhead = tmTicks() - start;
start = tmTicks();
mtSleep(100);
_freq = tmTicks();
_freq = (_freq - start - overhead) * 10;
} | pushq %r15
pushq %r14
pushq %rbx
rdtsc
movq %rdx, %rbx
shlq $0x20, %rbx
orq %rax, %rbx
rdtsc
movq %rdx, %r14
shlq $0x20, %r14
orq %rax, %r14
rdtsc
movq %rdx, %r15
shlq $0x20, %r15
orq %rax, %r15
pushq $0x64
popq %rdi
callq 0xefe0
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
addq %r14, %r15
subq %r15, %rbx
addq %rdx, %rbx
imulq $0xa, %rbx, %rax
movq %rax, 0x54024(%rip) # 0x684f0
popq %rbx
popq %r14
popq %r15
retq
nop
| /agievich[P]bee2/src/core/tm.c |
u16CLZ_fast | size_t FAST(u16CLZ)(register u16 w)
{
register size_t l = 16;
register u16 t;
if (t = w >> 8)
l -= 8, w = t;
if (t = w >> 4)
l -= 4, w = t;
if (t = w >> 2)
l -= 2, w = t;
t = 0;
return (w >> 1) ? l - 2 : l - (w ? 1 : 0);
} | movl %edi, %eax
shrl $0x8, %eax
xorl %ecx, %ecx
cmpw $0x100, %di # imm = 0x100
setb %cl
cmovbl %edi, %eax
shll $0x3, %ecx
leaq 0x8(%rcx), %rdx
movl %eax, %esi
shrl $0x4, %esi
orq $0x4, %rcx
cmpw $0x10, %ax
cmovbl %eax, %esi
cmovbq %rdx, %rcx
movl %esi, %eax
shrl $0x2, %eax
leaq -0x2(%rcx), %rdx
cmpw $0x4, %si
cmovbl %esi, %eax
cmovbq %rcx, %rdx
movq %rax, %rcx
negq %rcx
cmpw $0x2, %ax
pushq $-0x2
popq %rax
cmovbq %rcx, %rax
addq %rdx, %rax
retq
| /agievich[P]bee2/src/core/u16.c |
u16Shuffle | u16 u16Shuffle(register u16 w)
{
register u16 t;
t = (w ^ (w >> 4)) & 0x00F0, w ^= t ^ (t << 4);
t = (w ^ (w >> 2)) & 0x0C0C, w ^= t ^ (t << 2);
t = (w ^ (w >> 1)) & 0x2222, w ^= t ^ (t << 1);
t = 0;
return w;
} | movl %edi, %eax
shrl $0x4, %eax
xorl %edi, %eax
andl $0xf0, %eax
imull $0x11, %eax, %eax
xorl %edi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
xorl %eax, %ecx
andl $0xc0c, %ecx # imm = 0xC0C
leal (%rcx,%rcx,4), %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl %eax
xorl %ecx, %eax
andl $0x2222, %eax # imm = 0x2222
leal (%rax,%rax,2), %eax
xorl %ecx, %eax
retq
| /agievich[P]bee2/src/core/u16.c |
u16Deshuffle | u16 u16Deshuffle(register u16 w)
{
register u16 t;
t = (w ^ (w >> 1)) & 0x2222, w ^= t ^ (t << 1);
t = (w ^ (w >> 2)) & 0x0C0C, w ^= t ^ (t << 2);
t = (w ^ (w >> 4)) & 0x00F0, w ^= t ^ (t << 4);
t = 0;
return w;
} | movl %edi, %eax
shrl %eax
xorl %edi, %eax
andl $0x2222, %eax # imm = 0x2222
leal (%rax,%rax,2), %eax
xorl %edi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
xorl %eax, %ecx
andl $0xc0c, %ecx # imm = 0xC0C
leal (%rcx,%rcx,4), %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
xorl %ecx, %eax
andl $0xf0, %eax
imull $0x11, %eax, %eax
xorl %ecx, %eax
retq
| /agievich[P]bee2/src/core/u16.c |
u16NegInv | u16 u16NegInv(register u16 w)
{
register u16 ret = w;
ASSERT(w & 1);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
w = 0;
return ret;
} | movl %edi, %eax
imull %edi, %eax
orl $0x2, %eax
imull %edi, %eax
movl %eax, %ecx
imull %edi, %ecx
addl $0x2, %ecx
imull %eax, %ecx
movl %ecx, %edx
imull %edi, %edx
addl $0x2, %edx
imull %ecx, %edx
imull %edx, %edi
leal 0x2(%rdi), %eax
imull %edx, %eax
retq
| /agievich[P]bee2/src/core/u16.c |
u16From | void u16From(u16 dest[], const void* src, size_t count)
{
ASSERT(memIsValid(src, count));
ASSERT(memIsValid(dest, count + count % 2));
memMove(dest, src, count);
if (count % 2)
((octet*)dest)[count] = 0;
#if (OCTET_ORDER == BIG_ENDIAN)
for (count = (count + 1) / 2; count--;)
dest[count] = u16Rev(dest[count]);
#endif // OCTET_ORDER
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0xe130
testb $0x1, %bl
je 0x14712
movb $0x0, (%r14,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/u16.c |
u16To | void u16To(void* dest, size_t count, const u16 src[])
{
ASSERT(memIsValid(src, count + count % 2));
ASSERT(memIsValid(dest, count));
memMove(dest, src, count);
#if (OCTET_ORDER == BIG_ENDIAN)
if (count % 2)
{
register u16 u = src[--count / 2];
((octet*)dest)[count] = (octet)u;
u = 0;
}
for (count /= 2; count--;)
((u16*)dest)[count] = u16Rev(((u16*)dest)[count]);
#endif // OCTET_ORDER
} | movq %rsi, %rax
movq %rdx, %rsi
movq %rax, %rdx
jmp 0xe130
| /agievich[P]bee2/src/core/u16.c |
u32Bitrev | u32 u32Bitrev(register u32 w)
{
w = ((w >> 1) & 0x55555555) | ((w & 0x55555555) << 1);
w = ((w >> 2) & 0x33333333) | ((w & 0x33333333) << 2);
w = ((w >> 4) & 0x0F0F0F0F) | ((w & 0x0F0F0F0F) << 4);
w = ((w >> 8) & 0x00FF00FF) | ((w & 0x00FF00FF) << 8);
w = (w >> 16) | (w << 16);
return w;
} | bswapl %edi
movl %edi, %eax
shrl $0x4, %eax
movl $0xf0f0f0f, %ecx # imm = 0xF0F0F0F
andl %ecx, %eax
andl %ecx, %edi
shll $0x4, %edi
orl %eax, %edi
movl $0x33333333, %eax # imm = 0x33333333
movl %edi, %ecx
andl %eax, %ecx
shrl $0x2, %edi
andl %eax, %edi
leal (%rdi,%rcx,4), %eax
movl $0x55555555, %ecx # imm = 0x55555555
movl %eax, %edx
andl %ecx, %edx
shrl %eax
andl %ecx, %eax
leal (%rax,%rdx,2), %eax
retq
| /agievich[P]bee2/src/core/u32.c |
u32Weight | size_t u32Weight(register u32 w)
{
w -= ((w >> 1) & 0x55555555);
w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
w = (w + (w >> 4)) & 0x0F0F0F0F;
w += w >> 8;
w += w >> 16;
return (size_t)(w & 0x0000003F);
} | movl %edi, %eax
shrl %eax
andl $0x55555555, %eax # imm = 0x55555555
subl %eax, %edi
movl $0x33333333, %eax # imm = 0x33333333
movl %edi, %ecx
andl %eax, %ecx
shrl $0x2, %edi
andl %eax, %edi
addl %ecx, %edi
movl %edi, %eax
shrl $0x4, %eax
addl %edi, %eax
andl $0xf0f0f0f, %eax # imm = 0xF0F0F0F
movl %eax, %ecx
shrl $0x8, %ecx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
movzbl %al, %eax
retq
| /agievich[P]bee2/src/core/u32.c |
u32Parity | bool_t u32Parity(register u32 w)
{
w ^= w >> 1;
w ^= w >> 2;
w ^= w >> 4;
w ^= w >> 8;
w ^= w >> 16;
return (bool_t)(w & U32_1);
} | movl %edi, %eax
shrl %eax
xorl %edi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
xorl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
andl $0x1, %eax
retq
| /agievich[P]bee2/src/core/u32.c |
u32CTZ_fast | size_t FAST(u32CTZ)(register u32 w)
{
register size_t l = 32;
register u32 t;
// дихотомия
if (t = w << 16)
l -= 16, w = t;
if (t = w << 8)
l -= 8, w = t;
if (t = w << 4)
l -= 4, w = t;
if (t = w << 2)
l -= 2, w = t;
// возврат
t = 0;
return ((u32)(w << 1)) ? l - 2 : l - (w ? 1 : 0);
} | xorl %eax, %eax
movl %edi, %ecx
shll $0x10, %ecx
sete %al
cmovel %edi, %ecx
shll $0x4, %eax
leaq 0x10(%rax), %rdx
movl %ecx, %esi
shll $0x8, %esi
orq $0x8, %rax
testl %esi, %esi
cmovel %ecx, %esi
cmoveq %rdx, %rax
movl %esi, %ecx
shll $0x4, %ecx
testl %ecx, %ecx
cmovel %esi, %ecx
leaq -0x4(%rax), %rdx
cmoveq %rax, %rdx
leal (,%rcx,4), %eax
leaq -0x2(%rdx), %rsi
testl %eax, %eax
cmovnel %eax, %ecx
cmoveq %rdx, %rsi
movl %ecx, %eax
sarl $0x1f, %eax
testl $0x7ffffffc, %ecx # imm = 0x7FFFFFFC
pushq $-0x2
popq %rcx
cmovel %eax, %ecx
movslq %ecx, %rax
addq %rsi, %rax
retq
| /agievich[P]bee2/src/core/u32.c |
u32CLZ | size_t SAFE(u32CLZ)(register u32 w)
{
w = w | w >> 1;
w = w | w >> 2;
w = w | w >> 4;
w = w | w >> 8;
w = w | w >> 16;
return u32Weight(~w);
} | movl %edi, %eax
shrl %eax
orl %eax, %edi
movl %edi, %eax
shrl $0x2, %eax
orl %eax, %edi
movl %edi, %eax
shrl $0x4, %eax
orl %eax, %edi
movl %edi, %eax
shrl $0x8, %eax
orl %eax, %edi
movl %edi, %eax
shrl $0x10, %eax
orl %eax, %edi
notl %edi
jmp 0xf6e0
| /agievich[P]bee2/src/core/u32.c |
u32CLZ_fast | size_t FAST(u32CLZ)(register u32 w)
{
register size_t l = 32;
register u32 t;
// дихотомия
if (t = w >> 16)
l -= 16, w = t;
if (t = w >> 8)
l -= 8, w = t;
if (t = w >> 4)
l -= 4, w = t;
if (t = w >> 2)
l -= 2, w = t;
// возврат
t = 0;
return (w >> 1) ? l - 2 : l - (w ? 1 : 0);
} | movl %edi, %eax
shrl $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setb %cl
cmovbl %edi, %eax
shll $0x4, %ecx
leaq 0x10(%rcx), %rdx
movl %eax, %esi
shrl $0x8, %esi
orq $0x8, %rcx
cmpl $0x100, %eax # imm = 0x100
cmovbl %eax, %esi
cmovbq %rdx, %rcx
movl %esi, %eax
shrl $0x4, %eax
leaq -0x4(%rcx), %rdx
cmpl $0x10, %esi
cmovbl %esi, %eax
cmovbq %rcx, %rdx
movl %eax, %ecx
shrl $0x2, %ecx
leaq -0x2(%rdx), %rsi
cmpl $0x4, %eax
cmovbl %eax, %ecx
cmovbq %rdx, %rsi
movq %rcx, %rdx
negq %rdx
cmpl $0x2, %ecx
pushq $-0x2
popq %rax
cmovbq %rdx, %rax
addq %rsi, %rax
retq
| /agievich[P]bee2/src/core/u32.c |
u32Shuffle | u32 u32Shuffle(register u32 w)
{
register u32 t;
t = (w ^ (w >> 8)) & 0x0000FF00, w ^= t ^ (t << 8);
t = (w ^ (w >> 4)) & 0x00F000F0, w ^= t ^ (t << 4);
t = (w ^ (w >> 2)) & 0x0C0C0C0C, w ^= t ^ (t << 2);
t = (w ^ (w >> 1)) & 0x22222222, w ^= t ^ (t << 1);
t = 0;
return w;
} | movl %edi, %eax
shrl $0x8, %eax
xorl %edi, %eax
andl $0xff00, %eax # imm = 0xFF00
imull $0x101, %eax, %eax # imm = 0x101
xorl %edi, %eax
movl %eax, %ecx
shrl $0x4, %ecx
xorl %eax, %ecx
andl $0xf000f0, %ecx # imm = 0xF000F0
imull $0x11, %ecx, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
xorl %ecx, %eax
andl $0xc0c0c0c, %eax # imm = 0xC0C0C0C
leal (%rax,%rax,4), %edx
xorl %ecx, %edx
movl %edx, %eax
shrl %eax
xorl %edx, %eax
andl $0x22222222, %eax # imm = 0x22222222
leal (%rax,%rax,2), %eax
xorl %edx, %eax
retq
| /agievich[P]bee2/src/core/u32.c |
u32Deshuffle | u32 u32Deshuffle(register u32 w)
{
register u32 t;
t = (w ^ (w >> 1)) & 0x22222222, w ^= t ^ (t << 1);
t = (w ^ (w >> 2)) & 0x0C0C0C0C, w ^= t ^ (t << 2);
t = (w ^ (w >> 4)) & 0x00F000F0, w ^= t ^ (t << 4);
t = (w ^ (w >> 8)) & 0x0000FF00, w ^= t ^ (t << 8);
t = 0;
return w;
} | movl %edi, %eax
shrl %eax
xorl %edi, %eax
andl $0x22222222, %eax # imm = 0x22222222
leal (%rax,%rax,2), %eax
xorl %edi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
xorl %eax, %ecx
andl $0xc0c0c0c, %ecx # imm = 0xC0C0C0C
leal (%rcx,%rcx,4), %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
xorl %ecx, %eax
andl $0xf000f0, %eax # imm = 0xF000F0
imull $0x11, %eax, %edx
xorl %ecx, %edx
movl %edx, %eax
shrl $0x8, %eax
xorl %edx, %eax
andl $0xff00, %eax # imm = 0xFF00
imull $0x101, %eax, %eax # imm = 0x101
xorl %edx, %eax
retq
| /agievich[P]bee2/src/core/u32.c |
u32NegInv | u32 u32NegInv(register u32 w)
{
register u32 ret = w;
ASSERT(w & 1);
// для t = 1,...,k: ret <- ret * (w * ret + 2)
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
ret = ret * (w * ret + 2);
w = 0;
return ret;
} | movl %edi, %eax
imull %edi, %eax
orl $0x2, %eax
imull %edi, %eax
movl %eax, %ecx
imull %edi, %ecx
addl $0x2, %ecx
imull %eax, %ecx
movl %ecx, %eax
imull %edi, %eax
addl $0x2, %eax
imull %ecx, %eax
movl %eax, %ecx
imull %edi, %ecx
addl $0x2, %ecx
imull %eax, %ecx
imull %ecx, %edi
leal 0x2(%rdi), %eax
imull %ecx, %eax
retq
| /agievich[P]bee2/src/core/u32.c |
u32From | void u32From(u32 dest[], const void* src, size_t count)
{
ASSERT(memIsValid(src, count));
ASSERT(memIsValid(dest, ((count + 3) / 4) * 4));
memMove(dest, src, count);
if (count % 4)
memSetZero((octet*)dest + count, 4 - count % 4);
#if (OCTET_ORDER == BIG_ENDIAN)
for (count = (count + 3) / 4; count--;)
dest[count] = u32Rev(dest[count]);
#endif // OCTET_ORDER
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0xe130
movq %r14, %rax
andq $0x3, %rax
je 0x149d9
addq %r14, %rbx
pushq $0x4
popq %rdx
subq %rax, %rdx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf710
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/core/u32.c |
u32To | void u32To(void* dest, size_t count, const u32 src[])
{
ASSERT(memIsValid(src, (count + 3) / 4 * 4));
ASSERT(memIsValid(dest, count));
memMove(dest, src, count);
#if (OCTET_ORDER == BIG_ENDIAN)
if (count % 4)
{
size_t t = count / 4;
register u32 u = src[t];
for (t *= 4; t < count; ++t, u >>= 8)
((octet*)dest)[t] = (octet)u;
}
for (count /= 4; count--;)
((u32*)dest)[count] = u32Rev(((u32*)dest)[count]);
#endif // OCTET_ORDER
} | movq %rsi, %rax
movq %rdx, %rsi
movq %rax, %rdx
jmp 0xe130
nop
| /agievich[P]bee2/src/core/u32.c |
u64Weight | size_t u64Weight(register u64 w)
{
w -= ((w >> 1) & 0x5555555555555555);
w = (w & 0x3333333333333333) + ((w >> 2) & 0x3333333333333333);
w = (w + (w >> 4)) & 0x0F0F0F0F0F0F0F0F;
w += w >> 8;
w += w >> 16;
w += w >> 32;
return (size_t)(w & 0x000000000000007F);
} | movq %rdi, %rax
shrq %rax
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
andq %rax, %rcx
subq %rcx, %rdi
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
movq %rdi, %rcx
andq %rax, %rcx
shrq $0x2, %rdi
andq %rdi, %rax
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rax, %rcx
movabsq $0xf0f0f0f0f0f0f0f, %rax # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
addq %rax, %rcx
movq %rcx, %rdx
shrq $0x10, %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x20, %rax
addl %edx, %eax
andl $0x7f, %eax
retq
| /agievich[P]bee2/src/core/u64.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.