name string | code string | asm string | file string |
|---|---|---|---|
PF_FileHandle::GetPrevPage(int, PF_PageHandle&) const | RC PF_FileHandle::GetPrevPage(PageNum current, PF_PageHandle &pageHandle) const
{
int rc; // return code
// File must be open
if (!bFileOpen)
return (PF_CLOSEDFILE);
// Validate page number (note that hdr.numPages is acceptable here)
if (current != hdr.numPages && !IsValid... | cmpl $0x0, 0x10(%rdi)
je 0x602a
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl 0xc(%rdi), %eax
cmpl %esi, %eax
je 0x6010
testl %ebp, %ebp
sets %cl
cmpl %ebp, %eax
setle %al
orb %cl, %al
movl $0x3, %eax
jne 0x6035
testl %ebp, %ebp
jle 0x6030
decl %ebp
movq %r14, %rdi
movl %ebp, %es... | /lyang1024[P]redbase/src/pf_filehandle.cc |
PF_FileHandle::FlushPages() const | RC PF_FileHandle::FlushPages() const
{
// File must be open
if (!bFileOpen)
return (PF_CLOSEDFILE);
// If the file header has changed, write it back to the file
if (bHdrChanged) {
// First seek to the appropriate place
if (lseek(unixfd, 0, L_SET) < 0)
return (PF_UNIX)... | pushq %rbx
cmpl $0x0, 0x10(%rdi)
je 0x62bb
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
je 0x62db
movl 0x18(%rbx), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4540
testq %rax, %rax
js 0x62c2
movl 0x18(%rbx), %edi
leaq 0x8(%rbx), %rsi
movl $0x8, %edx
callq 0x4120
testl %eax, %eax
js 0x62c9
andl $0x7fffffff, %eax # imm =... | /lyang1024[P]redbase/src/pf_filehandle.cc |
PF_HashTable::PF_HashTable(int) | PF_HashTable::PF_HashTable(int _numBuckets)
{
// Initialize numBuckets local variable from parameter
this->numBuckets = _numBuckets;
// Allocate memory for hash table
hashTable = new PF_HashEntry* [numBuckets];
// Initialize all buckets to empty
for (int i = 0; i < numBuckets; i++)
hashTable... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
movslq %esi, %r14
leaq (,%r14,8), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x4030
movq %rax, 0x8(%rbx)
testl %r14d, %r14d
jle 0x63c6
movl %ebp, %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movq $0x0, (%rdx,%rcx,8)
i... | /lyang1024[P]redbase/src/pf_hashtable.cc |
StatisticsMgr::Reset(char const*) | RC StatisticsMgr::Reset(const char *psKey)
{
int i, iCount;
Statistic *pStat = NULL;
if (psKey==NULL)
return STAT_INVALID_ARGS;
iCount = llStats.GetLength();
for (i=0; i < iCount; i++) {
pStat = llStats[i];
if (*pStat == psKey)
break;
}
// If we found ... | testq %rsi, %rsi
je 0x6bcc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
testl %ebp, %ebp
jle 0x6bd2
movq %rsi, %r15
leaq 0x8(%rbx), %r12
movl 0x20(%rbx), %ecx
xorl %r14d, %r14d
leal 0x1(%r14), %r13d
cmpl $-0x1, %ecx
je 0x6b64
movl %r13d, %eax
subl %ecx, ... | /lyang1024[P]redbase/src/statistics.cc |
LinkList<Statistic>::Delete(int) | inline void LinkList<T>::Delete(int which)
{
if (which>iLength || which == 0)
return;
InternalNode *pnDeleteMe = pnHead;
for (int i=1; i<which; i++)
pnDeleteMe = pnDeleteMe->next;
if (pnDeleteMe == pnHead)
{
if (pnDeleteMe->next == NULL)
{
delete pnDelete... | testl %esi, %esi
je 0x6d85
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl %esi, (%rdi)
jl 0x6d80
leaq 0x8(%rbx), %r15
movq 0x8(%rbx), %r14
cmpl $0x2, %esi
jl 0x6c8d
decl %esi
movq 0x10(%r14), %r14
decl %esi
jne 0x6c85
cmpq (%r15), %r14
je 0x6cd3
cmpq 0x10(%rbx), %r14
je 0x6d07
movq 0x10(%r14), %rax
movq %rax, 0x... | /lyang1024[P]redbase/include/linkedlist.h |
RM_Manager::OpenFile(char const*, RM_FileHandle&) | RC RM_Manager::OpenFile (const char *fileName, RM_FileHandle &fileHandle){
if(fileName == NULL)
return (RM_BADFILENAME);
// if the filehandle is associated with another open file. exit immediately
if(fileHandle.openedFH == true)
return (RM_INVALIDFILEHANDLE);
RC rc;
// Open the file
PF_F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
testq %rsi, %rsi
je 0x7032
movq %rdx, %r14
movl $0x6b, %ebp
cmpb $0x0, (%rdx)
jne 0x7037
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x5f18
movq (%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4e60
movl %eax, %e... | /lyang1024[P]redbase/src/rm_manager.cc |
RM_Manager::CloseFile(RM_FileHandle&) | RC RM_Manager::CloseFile (RM_FileHandle &fileHandle) {
RC rc;
PF_PageHandle ph;
PageNum page;
char *pData;
// If header was modified, put the first page into buffer again,
// and update its contents, marking the page as dirty
if(fileHandle.header_modified == true){
if((rc = fileHandle.pfh.G... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
callq 0x1c784
cmpb $0x1, 0x40(%rbx)
jne 0x718e
leaq 0x20(%rbx), %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x5f76
movl %eax, %ebp
testl %eax, %eax
jne 0x71b1
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rs... | /lyang1024[P]redbase/src/rm_manager.cc |
RM_FileHandle::AllocateNewPage(PF_PageHandle&, int&) | RC RM_FileHandle::AllocateNewPage(PF_PageHandle &ph, PageNum &page){
RC rc;
// allocate the page
if((rc = pfh.AllocatePage(ph))){
return (rc);
}
// get the page number of this allocated page
if((rc = ph.GetPageNum(page)))
return (rc);
// create the page header
char *bitmap;
struc... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x20, %rdi
callq 0x60fc
testl %eax, %eax
jne 0x72d3
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1c7d0
testl %eax, %eax
jne 0x72d3
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x1c7ba
testl %eax, %eax
jne 0x72d3
movq 0x8(%r... | /lyang1024[P]redbase/src/rm_filehandle.cc |
RM_FileHandle::GetFirstZeroBit(char*, int, int&) | RC RM_FileHandle::GetFirstZeroBit(char *bitmap, int size, int &location){
for(int i = 0; i < size; i++){
int chunk = i /8;
int offset = i - chunk*8;
if ((bitmap[chunk] & (1 << offset)) == 0){
location = i;
return (0);
}
}
return RM_PAGEFULL;
} | movl $0x69, %eax
testl %edx, %edx
jle 0x7720
xorl %edi, %edi
movl %edi, %r8d
shrl $0x3, %r8d
movzbl (%rsi,%r8), %r8d
movl %edi, %r9d
andl $0x7, %r9d
btl %r9d, %r8d
jae 0x7721
incl %edi
cmpl %edi, %edx
jne 0x7701
retq
movl %edi, (%rcx)
xorl %eax, %eax
retq
| /lyang1024[P]redbase/src/rm_filehandle.cc |
RM_FileHandle::UpdateRec(RM_Record const&) | RC RM_FileHandle::UpdateRec (const RM_Record &rec) {
// only proceed if this filehandle is associated with an open file
if (!isValidFH())
return (RM_INVALIDFILE);
RC rc = 0;
// retrieves the page and slot number of the record
RID rid;
if((rc = rec.GetRid(rid)))
return (rc);
PageNum page... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0x6a, %ebp
cmpb $0x1, (%rdi)
jne 0x7a3b
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x7e80
movq %r14, %rdi
movq %r15, %rsi
callq 0x7dd4
movl %eax, %ebp
testl %eax, %eax
jne 0x7a31
leaq 0x10(%rsp), %r... | /lyang1024[P]redbase/src/rm_filehandle.cc |
RM_FileHandle::GetNextOneBit(char*, int, int, int&) | RC RM_FileHandle::GetNextOneBit(char *bitmap, int size, int start, int &location){
for(int i = start; i < size; i++){
int chunk = i /8;
int offset = i - chunk*8;
if (((bitmap[chunk] & (1 << offset)) != 0)){
location = i;
return (0);
}
}
return RM_ENDOFPAGE;
} | movl $0x6d, %eax
cmpl %edx, %ecx
jge 0x7ca8
leal 0x7(%rcx), %edi
testl %ecx, %ecx
cmovnsl %ecx, %edi
movl %edi, %r9d
sarl $0x3, %r9d
andl $-0x8, %edi
movl %ecx, %r10d
subl %edi, %r10d
movslq %r9d, %rdi
movsbl (%rsi,%rdi), %edi
btl %r10d, %edi
jb 0x7ca9
incl %ecx
cmpl %ecx, %edx
jne 0x7c7d
retq
movl %ecx, (%r8)
xorl %ea... | /lyang1024[P]redbase/src/rm_filehandle.cc |
SM_Manager::CreateTable(char const*, int, AttrInfo*) | RC SM_Manager::CreateTable(const char *relName,
int attrCount,
AttrInfo *attributes)
{
cout << "CreateTable\n"
<< " relName =" << relName << "\n"
<< " attrCount =" << attrCount << "\n";
for (int i = 0; i < attrCount; i++)
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r12
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movq 0x209fe(%rip), %rbx # 0x28fc8
leaq 0x14baf(%rip), %rsi # 0x1d180
movl $0xc, %edx
movq %rbx, %rdi
callq 0x4330
leaq 0x14ba8(%rip), %rsi # 0x1d18d
movl... | /lyang1024[P]redbase/src/sm_manager.cc |
SM_Manager::InsertRelCat(char const*, int, int) | RC SM_Manager::InsertRelCat(const char *relName, int attrCount, int recSize){
RC rc = 0;
RelCatEntry* rEntry = (RelCatEntry *) malloc(sizeof(RelCatEntry));
memset((void*)rEntry, 0, sizeof(*rEntry));
*rEntry = (RelCatEntry) {"\0", 0, 0, 0, 0};
memcpy(rEntry->relName, relName, MAXNAME + 1); // name
rE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl $0x34, %edi
callq 0x43a0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rax)
xorl %eax, %eax
movq %rax, 0x2c(%rbx)
movups (%r15), %xmm0
movups 0x9(%r15), %xmm1
movups %xm... | /lyang1024[P]redbase/src/sm_manager.cc |
SM_Manager::SetUpPrint(RelCatEntry*, DataAttrInfo*) | RC SM_Manager::SetUpPrint(RelCatEntry* rEntry, DataAttrInfo *attributes){
RC rc = 0;
RID attrRID;
RM_Record attrRec;
AttrCatEntry *aEntry;
// Iterate through attrcat for attributes related to this relation
SM_AttrIterator attrIt;
if((rc = attrIt.OpenIterator(attrcatFH, rEntry->relName)))
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0x7e80
leaq 0x18(%rsp), %rdi
callq 0x7d24
leaq 0x30(%rsp), %rdi
callq 0xe1c0
addq $0x58, %r15
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe1fc
m... | /lyang1024[P]redbase/src/sm_manager.cc |
SM_Manager::PrintPageStats() | RC SM_Manager::PrintPageStats(){
int *piGP = pStatisticsMgr->Get(PF_GETPAGE);
int *piPF = pStatisticsMgr->Get(PF_PAGEFOUND);
int *piPNF = pStatisticsMgr->Get(PF_PAGENOTFOUND);
cout << "PF Layer Statistics" << endl;
cout << "-------------------" << endl;
if(piGP)
cout << "Total number of calls t... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x1d6cc(%rip), %rbx # 0x294f8
movq (%rbx), %rdi
leaq 0x1d4aa(%rip), %rax # 0x292e0
movq (%rax), %rsi
callq 0x68be
movq %rax, %r12
movq (%rbx), %rdi
leaq 0x1d49d(%rip), %rax # 0x292e8
movq (%rax), %rsi
callq 0x68be
movq %rax, %r15
movq (%rbx), %rdi
... | /lyang1024[P]redbase/src/sm_manager.cc |
SM_Manager::SetUpRelCatAttributes(DataAttrInfo*) | RC SM_Manager::SetUpRelCatAttributes(DataAttrInfo *attributes){
int numAttr = 4;
for(int i= 0; i < numAttr; i++){
memcpy(attributes[i].relName, "relcat", strlen("relcat") + 1);
attributes[i].indexNo = 0;
}
memcpy(attributes[0].attrName, "relName", MAXNAME + 1);
memcpy(attributes[1].attrName... | movl $0x40, %eax
movl $0x746163, -0x3d(%rsi,%rax) # imm = 0x746163
movl $0x636c6572, -0x40(%rsi,%rax) # imm = 0x636C6572
movl $0x0, (%rsi,%rax)
addq $0x44, %rax
cmpq $0x150, %rax # imm = 0x150
jne 0xc1e7
movups 0x111b5(%rip), %xmm0 # 0x1d3c6
movups %xmm0, 0x22(%rsi)
movups 0x111a1(%rip), %xmm0 # 0x1d3b... | /lyang1024[P]redbase/src/sm_manager.cc |
Printer::Printer(DataAttrInfo const*, int) | Printer::Printer(const DataAttrInfo *attributes_, const int attrCount_)
{
attrCount = attrCount_;
attributes = new DataAttrInfo[attrCount];
for (int i=0; i < attrCount; i++)
attributes[i] = attributes_[i];
// Number of tuples printed
iCount = 0;
// Figure out what the heade... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x8(%rdi)
movslq %edx, %r15
movl $0x44, %ecx
movq %r15, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x4030
testl %r15d, %r15d
je 0xd6a0
movq %r15, %rcx
shlq $0x6, %rcx
leaq (%rcx,%r... | /lyang1024[P]redbase/src/printer.cc |
Printer::PrintHeader(std::ostream&) const | void Printer::PrintHeader( ostream &c ) const
{
int dashes = 0;
int iLen;
int i,j;
for (i = 0; i < attrCount; i++) {
// Print out the header information name
c << psHeader[i];
iLen = strlen(psHeader[i]);
dashes += iLen;
for (j = 0; j < spaces[i]; j++... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0xd994
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x1124b(%rip), %r15 # 0x1eb4a
xorl %ebp, %ebp
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0xd926
movq %r12, %rdi
callq 0x4160
mov... | /lyang1024[P]redbase/src/printer.cc |
QL_Manager::Reset() | RC QL_Manager::Reset(){
relToInt.clear();
relToAttrIndex.clear();
attrToRel.clear();
conditionToRel.clear();
nAttrs = 0;
nRels = 0;
nConds = 0;
condptr = NULL;
isUpdate = false;
return (0);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x126e2
leaq 0x78(%rbx), %rdi
callq 0x126e2
leaq 0x48(%rbx), %rdi
callq 0x12710
leaq 0xa8(%rbx), %rdi
callq 0x1273e
xorl %eax, %eax
movq %rax, 0xf8(%rbx)
movq %rax, 0xe8(%rbx)
movq %rax, 0xed(%rbx)
xorl %eax, %eax
popq %rbx
retq
| /lyang1024[P]redbase/src/ql_manager.cc |
QL_Manager::RunSelect(QL_Node*) | RC QL_Manager::RunSelect(QL_Node *topNode){
RC rc = 0;
// Retrieve the appropriate tuples that one is supposed to
// print out by asking for the attribute information from the top node
int finalTupLength;
topNode->GetTupleLength(finalTupLength);
int *attrList;
int attrListSize;
if((rc = topNode-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x136c4
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x136b4
testl %eax, %eax
jne 0xf59c
movslq (%rsp), %rax
movq %rax, %rcx
shlq $0x6, %rcx
leaq (... | /lyang1024[P]redbase/src/ql_manager.cc |
QL_Manager::SetUpOneRelation(char const*) | RC QL_Manager::SetUpOneRelation(const char *relName){
RC rc = 0;
RelCatEntry *rEntry;
RM_Record relRec;
if((rc = smm.GetRelEntry(relName, relRec, rEntry))){
return (rc);
}
memcpy(relEntries, rEntry, sizeof(RelCatEntry));
nRels = 1;
nAttrs = rEntry->attrCount;
string relString(relName);... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x7d24
movq 0x10(%rbx), %rdi
leaq 0x28(%rsp), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x8f10
movl %eax, %ebp
testl %eax, %eax
jne 0x10f3c
movq 0xd8(%rbx), %rax
movq 0x28(%rsp), %rc... | /lyang1024[P]redbase/src/ql_manager.cc |
QL_Manager::InsertIntoIndex(char*, RID) | RC QL_Manager::InsertIntoIndex(char *recbuf, RID recRID){
RC rc = 0;
for(int i = 0; i < relEntries->attrCount; i++){
AttrCatEntry aEntry = attrEntries[i];
if(aEntry.indexNo != -1){
IX_IndexHandle ih;
if((rc = ixm.OpenIndex(relEntries->relName, aEntry.indexNo, ih)))
return (rc);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0xd8(%rdi), %rax
cmpl $0x0, 0x20(%rax)
jle 0x1134b
movq %rdi, %r15
movl $0x40, %r14d
xorl %ebp, %ebp
leaq 0x3(%rsp), %r12
movq 0xe0(%r15), %rax
movl (%rax,%r14), %ebx
cmpl $-0x1, %ebx
je 0x... | /lyang1024[P]redbase/src/ql_manager.cc |
QL_Manager::CleanUpRun(Attr*, RM_FileHandle&) | RC QL_Manager::CleanUpRun(Attr* attributes, RM_FileHandle &relFH){
RC rc = 0;
if( (rc = rmm.CloseFile(relFH)))
return (rc);
// Destroy and close the pointers in Attr struct
if((rc = smm.CleanUpAttr(attributes, relEntries->attrCount)))
return (rc);
return (0);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdx, %rsi
callq 0x70d8
testl %eax, %eax
je 0x11a7b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%r14), %rdi
movq 0xd8(%r14), %rax
movl 0x20(%rax), %edx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa9f0
| /lyang1024[P]redbase/src/ql_manager.cc |
QL_Node::CheckConditions(char*) | RC QL_Node::CheckConditions(char *recData){
RC rc = 0;
for(int i = 0; i < condIndex; i++){
int offset1 = condList[i].offset1;
// If we are comparing this to a value
if(! condList[i].isValue){
// If it's not a string, or string of equal length, just compare
if(condList[i].type != STRIN... | cmpl $0x0, 0x30(%rdi)
jle 0x1369f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl $0x2c, %ebp
xorl %ebx, %ebx
movq %rsi, 0x8(%rsp)
movq 0x28(%r14), %r13
movslq -0x2c(%r13,%rbp), %r15
movl (%r13,%rbp), %edx
cmpb $0x0, -0x1c(%r13,%rbp)
je 0x134c7
cmp... | /lyang1024[P]redbase/src/ql_node.cc |
QL_NodeProj::DeleteNodes() | RC QL_NodeProj::DeleteNodes(){
prevNode.DeleteNodes();
delete &prevNode;
if(listsInitialized == true){
free(attrsInRec);
free(buffer);
//free(attrsToKeep);
}
listsInitialized = false;
return (0);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x13a6a
movq %r14, %rdi
callq 0x12fb6
movq %r14, %rdi
callq 0x42b0
cmpb $0x1, 0x24(%rbx)
jne 0x13a82
movq 0x18(%rbx), %rdi
callq 0x4350
movq 0x58(%rbx), %rdi
callq 0x4350
... | /lyang1024[P]redbase/src/ql_nodeproj.cc |
QL_NodeRel::~QL_NodeRel() | QL_NodeRel::~QL_NodeRel(){
if(relNameInitialized == true){
free(relName);
}
relNameInitialized = false;
if(listsInitialized == true){
free(attrsInRec);
}
listsInitialized = false;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x14e87(%rip), %rax # 0x28a18
movq %rax, (%rdi)
cmpb $0x1, 0x50(%rdi)
jne 0x13ba3
movq 0x48(%rbx), %rdi
callq 0x4350
movb $0x0, 0x50(%rbx)
cmpb $0x1, 0x24(%rbx)
jne 0x13bb6
movq 0x18(%rbx), %rdi
callq 0x4350
movb $0x0, 0x24(%rbx)
leaq 0x118(%rbx), %rdi
callq 0x184ea
leaq 0xb8(%rbx), ... | /lyang1024[P]redbase/src/ql_noderel.cc |
QL_NodeRel::RetrieveNextRec(RM_Record&, char*&) | RC QL_NodeRel::RetrieveNextRec(RM_Record &rec, char *&recData){
RC rc = 0;
if(useIndex){
RID rid;
if((rc = is.GetNextEntry(rid) ))
return (rc);
if((rc = fh.GetRec(rid, rec) ))
return (rc);
}
else{
if((rc = fs.GetNextRec(rec)))
return (rc);
}
if((rc = rec.GetDat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x51(%rdi)
jne 0x13de0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x7e80
leaq 0x118(%r15), %rdi
movq %r12, %rsi
callq 0x184ec
movl %eax, %ebp
testl %eax, %eax
je 0x13dfa
xorl %r15d, %r15d
j... | /lyang1024[P]redbase/src/ql_noderel.cc |
QL_NodeSel::GetNext(char*) | RC QL_NodeSel::GetNext(char *data){
RC rc = 0;
while(true){
if((rc = prevNode.GetNext(buffer))){
return (rc);
}
// keep retrieving records until the conditions are met
RC cond = CheckConditions(buffer);
if(cond == 0)
break;
}
memcpy(data, buffer, tupleLength);
retur... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%r14), %rdi
movq 0x50(%r14), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
testl %eax, %eax
jne 0x149d4
movq 0x50(%r14), %rsi
movq %r14, %rdi
callq 0x1346a
testl %eax, %eax
jne 0x149a0
movq 0x50(%r14), %rsi
movslq 0x14(%r14), %rdx
movq %rbx, %rdi
call... | /lyang1024[P]redbase/src/ql_nodesel.cc |
QO_Manager::QO_Manager(QL_Manager&, int, RelCatEntry*, int, AttrCatEntry*, int, Condition const*) | QO_Manager::QO_Manager(QL_Manager &qlm, int nRelations, RelCatEntry *relations, int nAttributes, AttrCatEntry *attributes,
int nConditions, const Condition conditions[]) : qlm(qlm) {
// Construct the new optjoin
for(int i=0; i < nRelations; i++){
map<int, costElem*> mapper;
optcost.push_back(map... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdi, %r15
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq $0x0, 0x40(%rdi)
movl %edx, (%rsp)
testl %edx, %edx
jle 0x14c89
leaq 0x30(%r15), %r13
leaq ... | /lyang1024[P]redbase/src/qo_manager.cc |
QO_Manager::Compute(QO_Rel*, float&, float&) | RC QO_Manager::Compute(QO_Rel *relOrder, float &costEst, float &tupleEst){
RC rc = 0;
// initialize the base relations
if((rc = InitializeBaseCases()))
return (rc);
// create a vector containing bitmaps that
// reflect all subsets of size 1
vector<int> allSubsets;
for(int i=0; i < nRels; i++... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15748
movl %eax, %ebp
testl %eax, %eax
jne 0x15703
movq %r12, 0x60(%rsp)
movq %r15, 0x68(%rsp)
movq %rbx, 0x70(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq... | /lyang1024[P]redbase/src/qo_manager.cc |
QO_Manager::CalculateOptJoin(int, int) | RC QO_Manager::CalculateOptJoin(int relsInJoin, int relSize){
RC rc = 0;
// create a vector of these relations in the bitmap
vector<int> relsInJoinVec;
ConvertBitmapToVec(relsInJoin, relsInJoinVec);
// Create a cost element, and initialize its values
vector<int>::iterator it;
costElem *costTable ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, (%rsp)
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movl %esi, 0x4(%rsp)
callq 0x151fe
movl $0x48, %edi
callq 0x42f0
movq %rax, %r15
addq $0x20, %rax
xorps %xmm0, %x... | /lyang1024[P]redbase/src/qo_manager.cc |
QO_Manager::UseCondition(int, int, int) | bool QO_Manager::UseCondition(int relsJoined, int condIndex, int relIdx){
// If attributes on both sides, one of the attributes must fall within
// the relation specified by relIdx, and the other must be in a relation
// specified in relsJoined
if(conds[condIndex].bRhsIsAttr){
int firstRel, secondRel;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdi, %r14
movq 0x28(%rdi), %rax
movslq %edx, %rcx
imulq $0x38, %rcx, %r12
cmpl $0x0, 0x14(%rax,%r12)
je 0x161fd
movl %esi, %ebp
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %... | /lyang1024[P]redbase/src/qo_manager.cc |
QO_Manager::ApplyLTCond(std::map<int, attrStat, std::less<int>, std::allocator<std::pair<int const, attrStat>>>&, int, float&) | RC QO_Manager::ApplyLTCond(map<int, attrStat> &attr_stats, int condIdx, float& numTuples){
RC rc = 0;
// Retrieves the indices of the condition attributes
int idx, idx2;
if((rc = CondToAttrIdx(condIdx, idx, idx2)))
return (rc);
float frac = 0.0;
if(conds[condIdx].bRhsIsAttr){
// calculate th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1c(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movl %ebp, %esi
callq 0x17180
testl %eax, %eax
jne 0x16890
movq 0x28(%r15), %rax
movslq %ebp, %rcx
imulq $0x38, %rcx, %rcx
cmpl $... | /lyang1024[P]redbase/src/qo_manager.cc |
yy_create_buffer(_IO_FILE*, int) | YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size g... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x40, %edi
callq 0x43a0
testq %rax, %rax
je 0x1a44c
movq %rax, %r14
movl %ebp, 0x18(%rax)
addl $0x2, %ebp
movslq %ebp, %rdi
callq 0x43a0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x1a44c
movl $0x1, 0x20(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1... | /lyang1024[P]redbase/build_O1/scan.cpp |
yy_scan_buffer(char*, unsigned long) | YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
{
YY_BUFFER_STATE b;
if ( size < 2 ||
base[size-2] != YY_END_OF_BUFFER_CHAR ||
base[size-1] != YY_END_OF_BUFFER_CHAR )
/* They forgot to leave room for the EOB's. */
return NULL;
b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buf... | pushq %r15
pushq %r14
pushq %rbx
cmpq $0x2, %rsi
jb 0x1a95d
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, -0x2(%rdi,%rsi)
jne 0x1a95d
cmpb $0x0, -0x1(%r15,%r14)
je 0x1a968
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x40, %edi
callq 0x43a0
testq %rax, %rax
je 0x1a9b6
movq %rax, %rbx
addq $-0x2... | /lyang1024[P]redbase/build_O1/scan.cpp |
RM_FileScan::OpenScan(RM_FileHandle const&, AttrType, int, int, CompOp, void*, ClientHint) | RC RM_FileScan::OpenScan (const RM_FileHandle &fileHandle,
AttrType attrType,
int attrLength,
int attrOffset,
CompOp compOp,
void *value,
ClientHint pinHint) {
// If this is alr... | cmpb $0x0, (%rdi)
je 0x1bd69
movl $0x6c, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movl %r8d, %r15d
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7cb0
movl %eax, %ecx
movl $0x6a, %eax
testb %cl, %cl
je 0x1be6b
movq ... | /lyang1024[P]redbase/src/rm_filescan.cc |
RM_FileScan::GetNextRec(RM_Record&) | RC RM_FileScan::GetNextRec(RM_Record &rec) {
// If the scan has ended, or is not valid, return immediately
if(scanEnded == true)
return (RM_EOF);
if(openScan == false)
return (RM_INVALIDSCAN);
hasPagePinned = true;
RC rc;
while(true){
// Retrieve next record
RM_Record temprec;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0x6e, %r12d
cmpb $0x0, 0x30(%rdi)
jne 0x1c090
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x1c08a
movq %rsi, 0x10(%rsp)
movb $0x1, 0x59(%r14)
leaq 0x34(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x4... | /lyang1024[P]redbase/src/rm_filescan.cc |
lcp<dna_bwt<dna_string>, unsigned short>::lcp(dna_bwt<dna_string>*) | lcp(bwt_t * bwt){
this->bwt;
n = bwt->size();
LCP = vector<lcp_int_t>(n, nil);
LCP[0] = 0;
/*
* FIRST PASS: LEAVES NAVIGATION. COMPUTE LCP VALUES INSIDE SUFFIX TREE LEAVES.
*/
cout << "\nNow navigating suffix tree leaves of size >= 2 to compute internal LCP values." << endl;
uint64_t m = 0;//p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movups %xmm0, (%rdi)
orw $-0x1, 0x28(%rdi)
leaq 0x28(%rdi), %rdx
movq %rsi, 0x20(%rsp)
movq 0x8(%rsi), %rsi
movq %rsi, 0x18(%rdi)... | /nicolaprezza[P]bwt2lcp/internal/lcp.hpp |
void update_lcp<unsigned long>(sa_node_n&, std::vector<unsigned long, std::allocator<unsigned long>>&, unsigned long&) | void update_lcp(sa_node_n & x, vector<lcp_int_t> & LCP, uint64_t & lcp_values){
assert(x.first_A >= x.first_TERM);
assert(x.first_C >= x.first_A);
assert(x.first_G >= x.first_C);
assert(x.first_N >= x.first_G);
assert(x.first_T >= x.first_N);
assert(number_of_children(x) >= 2);
lcp_int_t nil = ~lcp_int_t(0);
... | movq 0x8(%rdi), %rcx
cmpq (%rdi), %rcx
setbe %r8b
movq 0x30(%rdi), %rax
cmpq %rax, %rcx
sete %r9b
orb %r8b, %r9b
jne 0x156a0
movq 0x38(%rdi), %rax
movq (%rsi), %r8
movq %rax, (%r8,%rcx,8)
incq (%rdx)
movq 0x8(%rdi), %rcx
movq 0x30(%rdi), %rax
movq 0x10(%rdi), %r8
cmpq %rcx, %r8
setbe %cl
cmpq %rax, %r8
sete %r9b
orb %c... | /nicolaprezza[P]bwt2lcp/internal/include.hpp |
Fir1::Fir1(unsigned int, double) | Fir1::Fir1(unsigned number_of_taps, double value) :
coefficients(new double[number_of_taps]),
buffer(new double[number_of_taps]),
taps(number_of_taps) {
for(unsigned int i=0;i<number_of_taps;i++) {
coefficients[i] = value;
buffer[i] = 0;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %xmm0, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r15
movl %esi, %r12d
leaq (,%r12,8), %r14
movq %r14, %rdi
callq 0x2030
movq %rax, %rbx
movq %rax, (%r15)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x8(%r15)
movl %ebp, 0x10(%r15)
movl $0x0, 0x14(%r15)... | /berndporr[P]fir1/Fir1.cpp |
Fir1::setCoeff(double const*, unsigned int) | void Fir1::setCoeff(const double* coeff_data, const unsigned number_of_taps) {
if (number_of_taps != taps) {
throw std::runtime_error("Invalid number of taps in new coefficient array");
}
for (unsigned int i = 0; i < number_of_taps; i++) {
coefficients[i] = coeff_data[i];
}
} | pushq %r14
pushq %rbx
pushq %rax
cmpl %edx, 0x10(%rdi)
jne 0x2e74
testl %edx, %edx
je 0x2e6c
movq (%rdi), %rax
movl %edx, %ecx
xorl %edx, %edx
movsd (%rsi,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x2e5a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx... | /berndporr[P]fir1/Fir1.cpp |
nk_subimage_id | NK_API struct nk_image
nk_subimage_id(int id, unsigned short w, unsigned short h, struct nk_rect r)
{
struct nk_image s;
nk_zero(&s, sizeof(s));
s.handle.id = id;
s.w = w; s.h = h;
s.region[0] = (unsigned short)r.x;
s.region[1] = (unsigned short)r.y;
s.region[2] = (unsigned short)r.w;
s.... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movw %cx, %ax
movw %dx, %cx
movq %rdi, %rdx
movq %rdx, -0x20(%rbp)
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movl %esi, -0x14(%rbp)
movw %cx, -0x16(%rbp)
movw %ax, -0x18(%rbp)
movl $0x18, %esi
callq 0x1f6c0
movq -0x28(%rbp), %rdi
movq -0x20(%rb... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_subimage_handle | NK_API struct nk_image
nk_subimage_handle(nk_handle handle, unsigned short w, unsigned short h,
struct nk_rect r)
{
struct nk_image s;
nk_zero(&s, sizeof(s));
s.handle = handle;
s.w = w; s.h = h;
s.region[0] = (unsigned short)r.x;
s.region[1] = (unsigned short)r.y;
s.region[2] = (unsigne... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movw %cx, %ax
movw %dx, %cx
movq %rdi, %rdx
movq %rdx, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movlpd %xmm0, -0x18(%rbp)
movlpd %xmm1, -0x10(%rbp)
movw %cx, -0x1a(%rbp)
movw %ax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x1f6c0
movq -0x30(%rbp), %rdi
movq -0x28(%rb... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_button_image_styled | NK_API int
nk_button_image_styled(struct nk_context *ctx, const struct nk_style_button *style,
struct nk_image img)
{
struct nk_window *win;
struct nk_panel *layout;
const struct nk_input *in;
struct nk_rect bounds;
enum nk_widget_layout_states state;
NK_ASSERT(ctx);
NK_ASSERT(ctx->cur... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x44711
jmp 0x44730
leaq 0x4ca3a(%rip), %rdi # 0x91152
leaq 0x487e1(%rip), %rsi # 0x8cf00
movl $0x4e27, %edx # imm = 0x4E27
leaq 0x4d25d(%rip... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_check_flags_text | NK_API unsigned int
nk_check_flags_text(struct nk_context *ctx, const char *text, int len,
unsigned int flags, unsigned int value)
{
int old_active;
NK_ASSERT(ctx);
NK_ASSERT(text);
if (!ctx || !text) return flags;
old_active = (int)((flags & value) & value);
if (nk_check_text(ctx, text, len... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45643
jmp 0x45662
leaq 0x4bb08(%rip), %rdi # 0x91152
leaq 0x478af(%rip), %rsi # 0x8cf00
movl $0x4f6a, %edx # imm = ... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_selectable_text | NK_API int
nk_selectable_text(struct nk_context *ctx, const char *str, int len,
nk_flags align, int *value)
{
struct nk_window *win;
struct nk_panel *layout;
const struct nk_input *in;
const struct nk_style *style;
enum nk_widget_layout_states state;
struct nk_rect bounds;
NK_ASSERT(ct... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movl %ecx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x45dc7
jmp 0x45de6
leaq 0x4b384(%rip), %rdi # 0x91152
leaq 0x4712b(%rip), %rsi # 0x8cf00
movl $0x50a4, %edx ... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_do_selectable_symbol | NK_LIB int
nk_do_selectable_symbol(nk_flags *state, struct nk_command_buffer *out,
struct nk_rect bounds, const char *str, int len, nk_flags align, int *value,
enum nk_symbol_type sym, const struct nk_style_selectable *style,
const struct nk_input *in, const struct nk_user_font *font)
{
int old_value;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movlpd %xmm0, -0x2c(%rbp)
movlpd %xmm1, -0x24(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movl %ecx, -0x4c(%rbp)
movl %r8d, ... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_do_slider | NK_LIB float
nk_do_slider(nk_flags *state,
struct nk_command_buffer *out, struct nk_rect bounds,
float min, float val, float max, float step,
const struct nk_style_slider *style, struct nk_input *in,
const struct nk_user_font *font)
{
float slider_range;
float slider_min;
float slider_max;
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movlpd %xmm0, -0x14(%rbp)
movlpd %xmm1, -0xc(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movss %xmm2, -0x2c(%rbp)
movss %xmm3, -0x30(%rbp)
movss %xmm4, -0x34(%rbp)
movss %xmm5, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
cmpq $0x0, ... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_textedit_cut | NK_API int
nk_textedit_cut(struct nk_text_edit *state)
{
/* API cut: delete selection */
if (state->mode == NK_TEXT_EDIT_MODE_VIEW)
return 0;
if (NK_TEXT_HAS_SELECTION(state)) {
nk_textedit_delete_selection(state); /* implicitly clamps */
state->has_preferred_x = 0;
return 1;... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0xb4(%rax), %eax
cmpl $0x0, %eax
jne 0x484e5
movl $0x0, -0x4(%rbp)
jmp 0x4851f
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xb0(%rcx), %eax
je 0x48518
movq -0x10(%rbp), %rdi
callq 0x48320
movq -... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_textedit_init_fixed | NK_API void
nk_textedit_init_fixed(struct nk_text_edit *state, void *memory, nk_size size)
{
NK_ASSERT(state);
NK_ASSERT(memory);
if (!state || !memory || !size) return;
NK_MEMSET(state, 0, sizeof(struct nk_text_edit));
nk_textedit_clear_state(state, NK_TEXT_EDIT_SINGLE_LINE, 0);
nk_str_init_fix... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x48fad
jmp 0x48fcc
leaq 0x48f64(%rip), %rdi # 0x91f18
leaq 0x43f45(%rip), %rsi # 0x8cf00
movl $0x57ae, %edx # imm = 0x57AE
leaq 0x48f97(%rip), %rcx # 0x91f5e
ca... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_property_int | NK_API void
nk_property_int(struct nk_context *ctx, const char *name,
int min, int *val, int max, int step, float inc_per_pixel)
{
struct nk_property_variant variant;
NK_ASSERT(ctx);
NK_ASSERT(name);
NK_ASSERT(val);
if (!ctx || !ctx->current || !name || !val) return;
variant = nk_property_v... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movss %xmm0, -0x2c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4bce0
jmp 0x4bcff
leaq 0x4546b(%rip), %rdi # 0x91152
leaq 0x41212(%rip), %rsi #... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_property_variant_double | NK_LIB struct nk_property_variant
nk_property_variant_double(double value, double min_value, double max_value,
double step)
{
struct nk_property_variant result;
result.kind = NK_PROPERTY_DOUBLE;
result.value.d = value;
result.min_value.d = min_value;
result.max_value.d = max_value;
result.st... | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movl $0x2, (%rdi)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd -0x20(%rb... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_chart_add_slot_colored | NK_API void
nk_chart_add_slot_colored(struct nk_context *ctx, const enum nk_chart_type type,
struct nk_color color, struct nk_color highlight,
int count, float min_value, float max_value)
{
NK_ASSERT(ctx);
NK_ASSERT(ctx->current);
NK_ASSERT(ctx->current->layout);
NK_ASSERT(ctx->current->layout->... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edx, -0x4(%rbp)
movl %ecx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4d00c
jmp 0x4d02b
leaq 0x4413f(%rip), %rdi # 0x91152
leaq 0x3fee6(%rip), %rsi ... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_color_pick | NK_API int
nk_color_pick(struct nk_context * ctx, struct nk_colorf *color,
enum nk_color_format fmt)
{
struct nk_window *win;
struct nk_panel *layout;
const struct nk_style *config;
const struct nk_input *in;
enum nk_widget_layout_states state;
struct nk_rect bounds;
NK_ASSERT(ctx);
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4e48f
jmp 0x4e4ae
leaq 0x42cbc(%rip), %rdi # 0x91152
leaq 0x3ea63(%rip), %rsi # 0x8cf00
movl $0x5ee1, %edx # imm = 0x5EE1
leaq 0x441a6(%rip), %rcx # 0x9264f
... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_combo_begin_image | NK_API int
nk_combo_begin_image(struct nk_context *ctx, struct nk_image img, struct nk_vec2 size)
{
struct nk_window *win;
struct nk_style *style;
const struct nk_input *in;
struct nk_rect header;
int is_clicked = nk_false;
enum nk_widget_layout_states s;
const struct nk_style_item *backgro... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movlpd %xmm0, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5072f
jmp 0x5074e
leaq 0x40a1c(%rip), %rdi # 0x91152
leaq 0x3c7c3(%rip), %rsi # 0x8cf00
movl $0x6092, %edx # imm =... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_combo_callback | NK_API int
nk_combo_callback(struct nk_context *ctx, void(*item_getter)(void*, int, const char**),
void *userdata, int selected, int count, int item_height, struct nk_vec2 size)
{
int i;
int max_height;
struct nk_vec2 item_spacing;
struct nk_vec2 window_padding;
const char *item;
NK_ASSERT(... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movlpd %xmm0, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5195d
jmp 0x5197c
leaq 0x3f7ee(%rip), %rdi # 0x91152
leaq 0x3b595(%rip), %rsi ... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_glfw3_render | NK_API void
nk_glfw3_render(enum nk_anti_aliasing AA)
{
/* setup global state */
struct nk_glfw_device *dev = &glfw.ogl;
glPushAttrib(GL_ENABLE_BIT|GL_COLOR_BUFFER_BIT|GL_TRANSFORM_BIT);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glEnable(GL_BLEND);
glE... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movl %edi, -0x4(%rbp)
leaq 0x7509b(%rip), %rax # 0xc7310
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movl $0x7000, %edi # imm = 0x7000
leaq 0x7a687(%rip), %rax # 0xcc910
callq *(%rax)
movl $0xb44, %edi # imm = 0xB44
leaq 0x79... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear_glfw_gl2.h |
nk_range_glyph_count | NK_INTERN int
nk_range_glyph_count(const nk_rune *range, int count)
{
int i = 0;
int total_glyphs = 0;
for (i = 0; i < count; ++i) {
int diff;
nk_rune f = range[(i*2)+0];
nk_rune t = range[(i*2)+1];
NK_ASSERT(t >= f);
diff = (int)((t - f) + 1);
total_glyphs +=... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x558ef
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
shll %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_tt_PackBegin | NK_INTERN int
nk_tt_PackBegin(struct nk_tt_pack_context *spc, unsigned char *pixels,
int pw, int ph, int stride_in_bytes, int padding, struct nk_allocator *alloc)
{
int num_nodes = pw - padding;
struct nk_rp_context *context = (struct nk_rp_context *)
alloc->alloc(alloc->userdata,0, sizeof(*context)... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl -0x1c(%rbp), %eax
subl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq 0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_rp_init_target | NK_INTERN void
nk_rp_init_target(struct nk_rp_context *context, int width, int height,
struct nk_rp_node *nodes, int num_nodes)
{
int i;
#ifndef STBRP_LARGE_RECTS
NK_ASSERT(width <= 0xffff && height <= 0xffff);
#endif
for (i=0; i < num_nodes-1; ++i)
nodes[i].next = &nodes[i+1];
nodes[i].nex... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpl $0xffff, -0xc(%rbp) # imm = 0xFFFF
jg 0x5632e
cmpl $0xffff, -0x10(%rbp) # imm = 0xFFFF
jg 0x5632e
jmp 0x5634d
leaq 0x3d31c(%rip), %rdi # 0x93651
le... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_tt_PackFontRangesRenderIntoRects | NK_INTERN int
nk_tt_PackFontRangesRenderIntoRects(struct nk_tt_pack_context *spc,
struct nk_tt_fontinfo *info, struct nk_tt_pack_range *ranges,
int num_ranges, struct nk_rp_rect *rects, struct nk_allocator *alloc)
{
int i,j,k, return_value = 1;
/* save current values */
int old_h_over = (int)spc->h_... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x1, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %e... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_tt__v_prefilter | NK_INTERN void
nk_tt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes,
int kernel_width)
{
unsigned char buffer[NK_TT_MAX_OVERSAMPLE];
int safe_h = h - kernel_width;
int j;
for (j=0; j < w; ++j)
{
int i;
unsigned int total;
NK_MEMSET(buffer, 0, (nk_s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x10(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x58a42
movslq -0x18(%... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_tt_Rasterize | NK_INTERN void
nk_tt_Rasterize(struct nk_tt__bitmap *result, float flatness_in_pixels,
struct nk_tt_vertex *vertices, int num_verts,
float scale_x, float scale_y, float shift_x, float shift_y,
int x_off, int y_off, int invert, struct nk_allocator *alloc)
{
float scale = scale_x > scale_y ? scale_y : sca... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movss %xmm3, -0x28(%rbp)
movss %xmm4, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movl %r9d, -0x38... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_tt__rasterize_sorted_edges | NK_INTERN void
nk_tt__rasterize_sorted_edges(struct nk_tt__bitmap *result, struct nk_tt__edge *e,
int n, int vsubsample, int off_x, int off_y, struct nk_allocator *alloc)
{
/* directly AA rasterize edges w/o supersampling */
struct nk_tt__hheap hh;
struct nk_tt__active_edge *active = 0;
int y,j=0, i... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x30, %esi
callq... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_tt__sort_edges_ins_sort | NK_INTERN void
nk_tt__sort_edges_ins_sort(struct nk_tt__edge *p, int n)
{
int i,j;
#define NK_TT__COMPARE(a,b) ((a)->y0 < (b)->y0)
for (i=1; i < n; ++i) {
struct nk_tt__edge t = p[i], *a = &t;
j = i;
while (j > 0) {
struct nk_tt__edge *b = &p[j-1];
int c = NK... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5afdb
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rb... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_free_page_element | NK_LIB void
nk_free_page_element(struct nk_context *ctx, struct nk_page_element *elem)
{
/* we have a pool so just add to free list */
if (ctx->use_pool) {
nk_link_page_element_into_freelist(ctx, elem);
return;
}
/* if possible remove last element from back of fixed memory buffer */
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4074(%rax)
je 0x5c6bc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c720
jmp 0x5c716
movq -0x10(%rbp), %rax
addq $0x200, %rax # imm = 0x200
movq %rax, -0x18(%rbp)
movq -0x8(%rbp... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_do_scrollbarh | NK_LIB float
nk_do_scrollbarh(nk_flags *state,
struct nk_command_buffer *out, struct nk_rect scroll, int has_scrolling,
float offset, float target, float step, float button_pixel_inc,
const struct nk_style_scrollbar *style, struct nk_input *in,
const struct nk_user_font *font)
{
struct nk_rect curso... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movlpd %xmm0, -0x14(%rbp)
movlpd %xmm1, -0xc(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
movss %xmm2, -0x30(%rbp)
movss %xmm3, -0x34(%rbp)
movss %xmm4, -0x38(%rbp)
movss %xmm5, -0x3c(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_tree_element_image_push_hashed_base | NK_INTERN int
nk_tree_element_image_push_hashed_base(struct nk_context *ctx, enum nk_tree_type type,
struct nk_image *img, const char *title, int title_len,
enum nk_collapse_states *state, int *selected)
{
struct nk_window *win;
struct nk_panel *layout;
const struct nk_style *style;
struct nk_co... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1b0f0
leaq -0xa8(%rbp), %rd... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_vsnprintf | NK_INTERN int
nk_vsnprintf(char *buf, int buf_size, const char *fmt, va_list args)
{
enum nk_arg_type {
NK_ARG_TYPE_CHAR,
NK_ARG_TYPE_SHORT,
NK_ARG_TYPE_DEFAULT,
NK_ARG_TYPE_LONG
};
enum nk_arg_flags {
NK_ARG_FLAG_LEFT = 0x01,
NK_ARG_FLAG_PLUS = 0x02,
... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x2, -0x74(%rbp)
movl $0xffffffff, -0x78(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x7c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x80(%rbp)
movl $0x0, -0x... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
nk_draw_option | NK_LIB void
nk_draw_option(struct nk_command_buffer *out,
nk_flags state, const struct nk_style_toggle *style, int active,
const struct nk_rect *label, const struct nk_rect *selector,
const struct nk_rect *cursors, const char *string, int len,
const struct nk_user_font *font)
{
const struct nk_style... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0xc(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax... | /Tigermouthbear[P]flappytiger/external/glfw/deps/nuklear.h |
glfwInitHint | GLFWAPI void glfwInitHint(int hint, int value)
{
switch (hint)
{
case GLFW_JOYSTICK_HAT_BUTTONS:
_glfwInitHints.hatButtons = value;
return;
case GLFW_COCOA_CHDIR_RESOURCES:
_glfwInitHints.ns.chdir = value;
return;
case GLFW_COCOA_MENUBAR:
... | cmpl $0x51002, %edi # imm = 0x51002
je 0x1918b
movl %edi, %edx
cmpl $0x51001, %edi # imm = 0x51001
je 0x19184
cmpl $0x50001, %edx # imm = 0x50001
jne 0x19192
movl %esi, 0x3b095(%rip) # 0x54218
retq
movl %esi, 0x3b096(%rip) # 0x54220
retq
movl %esi, 0x3b08b(%rip) # 0x5421c
retq
lea... | /Konf[P]LearnOpenGL-CLion/glfw/src/init.c |
glfwInputCursorPos | void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
{
if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
return;
window->virtualCursorPosX = xpos;
window->virtualCursorPosY = ypos;
if (window->callbacks.cursorPos)
window->callbacks.cursorPos... | movsd 0x1e0(%rdi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x19388
jp 0x19388
movsd 0x1e8(%rdi), %xmm2
ucomisd %xmm1, %xmm2
jne 0x19388
jnp 0x193a6
movsd %xmm0, 0x1e0(%rdi)
movsd %xmm1, 0x1e8(%rdi)
movq 0x300(%rdi), %rax
testq %rax, %rax
je 0x193a6
jmpq *%rax
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwAllocJoystick | _GLFWjoystick* _glfwAllocJoystick(const char* name,
const char* guid,
int axisCount,
int buttonCount,
int hatCount)
{
int jid;
_GLFWjoystick* js;
for (jid = 0; jid <= GLF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movl $0x400, %ebx # imm = 0x400
addq 0x39b52(%rip), %rbx # 0x52fd8
movl $0x10, %eax
cmpl $0x0, (%rbx)
je 0x194a0
addq $0x1fa0, %rbx # imm = 0x1FA0
decq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwGetMouseButton | GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Inval... | pushq %rbx
testq %rdi, %rdi
je 0x19a92
leaq 0x3c0c5(%rip), %rax # 0x55b08
cmpl $0x0, (%rax)
je 0x19a66
movl %esi, %edx
cmpl $0x8, %esi
jb 0x19a78
leaq 0x2e804(%rip), %rsi # 0x4825a
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x18da7
jmp 0x19a8e
xorl %ebx, %ebx
movl $0x1000... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwSetCursorPos | GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (xpos != xpos || xpos < -DBL_MAX || xpos > DBL_MAX ||
ypos != ypos || ypos < -DBL_MAX || ypos > DBL_MAX)
{
_gl... | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x19c0e
leaq 0x3bfbb(%rip), %rax # 0x55b08
cmpl $0x0, (%rax)
je 0x19be3
ucomisd 0x2e592(%rip), %xmm0 # 0x480f0
ja 0x19bcb
ucomisd %xmm0, %xmm0
jp 0x19bcb
movsd 0x2e58a(%rip), %xmm2 # 0x480f8
ucomisd %xmm0, %xmm2
ja 0x19bcb
ucomisd 0x2e574(%rip), %xmm1 # 0x480... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwGetVideoModes | GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = m... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1bda7
movq %rsi, %r14
testq %rsi, %rsi
je 0x1bdc6
movl $0x0, (%r14)
leaq 0x39d9d(%rip), %rax # 0x55b08
cmpl $0x0, (%rax)
je 0x1bd88
movq %rdi, %rbx
callq 0x1b9b7
testl %eax, %eax
je 0x1bd9a
movl 0x28(%rbx), %eax
movl %eax, (%r14)
movq 0x20(%rbx), %rbx
jmp 0x1bd... | /Konf[P]LearnOpenGL-CLion/glfw/src/monitor.c |
glfwGetWindowContentScale | GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
float* xscale, float* yscale)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (xscale)
*xscale = 0.f;
if (yscale)
*yscale = 0.f;
_GLFW_REQUIRE_INIT();
_gl... | testq %rdi, %rdi
je 0x1d55d
testq %rsi, %rsi
je 0x1d533
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1d53e
movl $0x0, (%rdx)
leaq 0x385c3(%rip), %rax # 0x55b08
cmpl $0x0, (%rax)
je 0x1d54f
jmp 0x22a6e
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x18da7
pushq %rax
leaq 0xf4fc(%rip), %... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwSetWindowAttrib | GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
value = value ? GLFW_TRUE : GLFW_FALSE;
if (attrib == GLFW_AUTO_ICONIFY)
window->autoIconify = value;
else if (attri... | testq %rdi, %rdi
je 0x1da90
leaq 0x38108(%rip), %rcx # 0x55b08
cmpl $0x0, (%rcx)
je 0x1da40
movl %esi, %eax
xorl %esi, %esi
testl %edx, %edx
setne %dl
leal -0x20003(%rax), %ecx
cmpl $0x4, %ecx
ja 0x1da76
movb %dl, %sil
leaq 0x2bc79(%rip), %rdx # 0x4969c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
acquireMonitor | static void acquireMonitor(_GLFWwindow* window)
{
if (_glfw.x11.saver.count == 0)
{
// Remember old screen saver settings
XGetScreenSaver(_glfw.x11.display,
&_glfw.x11.saver.timeout,
&_glfw.x11.saver.interval,
&_glfw.x11.sav... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x33b2f(%rip), %r13 # 0x55b08
cmpl $0x0, 0x20624(%r13)
jne 0x22023
movq 0x1feb8(%r13), %rdi
leaq 0x20628(%r13), %rsi
leaq 0x2062c(%r13), %rdx
leaq 0x20630(%r13), %rcx
leaq 0x20634(%r13), %r8
callq 0x13790
movq 0x1feb8(%r13)... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformRestoreWindow | void _glfwPlatformRestoreWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification ... | cmpl $0x0, 0x350(%rdi)
je 0x22b08
leaq 0x2847d(%rip), %rsi # 0x4af79
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x18da7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq 0x340(%rdi), %rdi
callq 0x2306c
cmpl $0x3, %eax
jne 0x22b54
leaq 0x32f... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
waitForVisibilityNotify | static GLFWbool waitForVisibilityNotify(_GLFWwindow* window)
{
XEvent dummy;
double timeout = 0.1;
while (!XCheckTypedWindowEvent(_glfw.x11.display,
window->x11.handle,
VisibilityNotify,
&dummy))
{
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x32e95(%rip), %r12 # 0x55b08
leaq 0x8(%rsp), %r15
movq 0x1feb8(%r12), %rdi
movq 0x340(%rbx), %rsi
movl $0xf, %edx
movq %r15, %rcx
callq 0x... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformWindowMaximized | int _glfwPlatformWindowMaximized(_GLFWwindow* window)
{
Atom* states;
unsigned long i;
GLFWbool maximized = GLFW_FALSE;
const unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x340(%rdi), %rsi
leaq 0x329fb(%rip), %r14 # 0x55b08
movq 0x20438(%r14), %rdx
movq 0x1feb8(%r14), %rdi
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rax
leaq 0x18(%rsp), %r12
leaq 0x4(%rsp), %r10
leaq 0x20(%rsp), %r11
xorl %ebx, %ebx
movabsq $0x7fffffffffff... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
isSelPropNewValueNotify | static Bool isSelPropNewValueNotify(Display* display, XEvent* event, XPointer pointer)
{
XEvent* notification = (XEvent*) pointer;
return event->type == PropertyNotify &&
event->xproperty.state == PropertyNewValue &&
event->xproperty.window == notification->xselection.requestor &&
... | xorl %eax, %eax
cmpl $0x1c, (%rsi)
jne 0x2539f
cmpl $0x0, 0x38(%rsi)
je 0x253a0
retq
movq 0x20(%rsi), %rcx
cmpq 0x20(%rdx), %rcx
jne 0x2539f
movq 0x28(%rsi), %rcx
xorl %eax, %eax
cmpq 0x38(%rdx), %rcx
sete %al
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
convertLatin1toUTF8 | static char* convertLatin1toUTF8(const char* source)
{
size_t size = 1;
const char* sp;
for (sp = source; *sp; sp++)
size += (*sp & 0x80) ? 2 : 1;
char* target = calloc(size, 1);
char* tp = target;
for (sp = source; *sp; sp++)
tp += encodeUTF8(tp, *sp);
return target;... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x2542c
movq %rdi, %rbx
leaq 0x1(%rdi), %rax
movl $0x1, %edi
movl %ebp, %ecx
xorl %edx, %edx
testb %cl, %cl
setns %dl
subq %rdx, %rdi
addq $0x2, %rdi
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x253d5
movl $0x1, %esi
callq 0... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwKeySym2Unicode | long _glfwKeySym2Unicode(unsigned int keysym)
{
int min = 0;
int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
int mid;
// First check for Latin-1 characters (1:1 mapping)
if ((keysym >= 0x0020 && keysym <= 0x007e) ||
(keysym >= 0x00a0 && keysym <= 0x00ff))
{
return key... | movl %edi, %eax
leal -0x20(%rax), %ecx
cmpl $0x5f, %ecx
setae %cl
leal -0xa0(%rax), %edx
cmpl $0x60, %edx
setae %dl
testb %dl, %cl
jne 0x25466
movl %eax, %eax
retq
movl %eax, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
cmpl $0x1000000, %ecx # imm = 0x1000000
jne 0x2547c
andl $0xffffff, %eax # im... | /Konf[P]LearnOpenGL-CLion/glfw/src/xkb_unicode.c |
chooseGLXFBConfig | static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired,
GLXFBConfig* result)
{
GLXFBConfig* nativeConfigs;
_GLFWfbconfig* usableConfigs;
const _GLFWfbconfig* closest;
int i, nativeCount, usableCount;
const char* vendor;
GLFWbool trustWindowBit = GLFW_TRU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0x2fa49(%rip), %r12 # 0x55b08
movq 0x1feb8(%r12), %rdi
movl $0x1, %esi
callq *0x20780(%r12)
testq %rax, %rax
je 0x260f1
leaq 0x26667(%rip), %rsi # 0x4c747
movq %rax, %rdi
callq 0x13690
t... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
glfwTerminateEGL | void _glfwTerminateEGL(void)
{
if (_glfw.egl.display)
{
eglTerminate(_glfw.egl.display);
_glfw.egl.display = EGL_NO_DISPLAY;
}
if (_glfw.egl.handle)
{
_glfw_dlclose(_glfw.egl.handle);
_glfw.egl.handle = NULL;
}
} | pushq %rbx
leaq 0x2efdf(%rip), %rbx # 0x55b08
movq 0x20888(%rbx), %rdi
testq %rdi, %rdi
je 0x26b46
callq *0x208e0(%rbx)
movq $0x0, 0x20888(%rbx)
movq 0x208b0(%rbx), %rdi
testq %rdi, %rdi
je 0x26b62
callq 0x13a10
movq $0x0, 0x208b0(%rbx)
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
makeContextCurrentEGL | static void makeContextCurrentEGL(_GLFWwindow* window)
{
if (window)
{
if (!eglMakeCurrent(_glfw.egl.display,
window->context.egl.surface,
window->context.egl.surface,
window->context.egl.handle))
{
_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2e741(%rip), %r14 # 0x55b08
movq 0x20888(%r14), %rdi
movq 0x20910(%r14), %rax
testq %rbx, %rbx
je 0x27408
movq 0x280(%rbx), %rcx
movq 0x288(%rbx), %rdx
movq %rdx, %rsi
callq *%rax
testl %eax, %eax
jne 0x27414
callq *0x208d0(%r14)
movl %eax, %edi
callq 0x26b64
... | /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
mbedtls_pkcs12_pbe | int mbedtls_pkcs12_pbe( mbedtls_asn1_buf *pbe_params, int mode,
mbedtls_cipher_type_t cipher_type, mbedtls_md_type_t md_type,
const unsigned char *pwd, size_t pwdlen,
const unsigned char *data, size_t len,
unsigned char *output )
{
int ret, keylen = 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %rbx
movq %r8, %r12
movl %ecx, %r13d
movl %esi, %r15d
movq %rdi, %rbp
andq $0x0, 0x8(%rsp)
movl %edx, %edi
callq 0x2ae64
testq %rax, %rax
je 0x29a48
movq %rax, %r14
movl %r15d, 0x4(%rsp)
movl 0x8(%rax), %r15d
movl 0x18(%rax), %... | /project-everest[P]mbedtls/library/pkcs12.c |
mbedtls_pkcs12_derivation | int mbedtls_pkcs12_derivation( unsigned char *data, size_t datalen,
const unsigned char *pwd, size_t pwdlen,
const unsigned char *salt, size_t saltlen,
mbedtls_md_type_t md_type, int id, int iterations )
{
int ret;
unsigned int j;
unsigne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
cmpq $0x81, %rsi
setae %al
cmpq $0x41, %rcx
setae %cl
orb %al, %cl
cmpq $0x41, %r9
setae %al
orb %cl, %al
movl $0xffffe080, %eax # imm = 0xFFFFE080
jne 0x29dd5
movq %r... | /project-everest[P]mbedtls/library/pkcs12.c |
mbedtls_pkcs5_pbes2 | int mbedtls_pkcs5_pbes2( const mbedtls_asn1_buf *pbe_params, int mode,
const unsigned char *pwd, size_t pwdlen,
const unsigned char *data, size_t datalen,
unsigned char *output )
{
int ret, iterations = 0, keylen = 0;
unsigned char *p, *end;
mbedtls_asn1_b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
andl $0x0, 0x20(%rsp)
andl $0x0, 0xc(%rsp)
movl $0x4, 0x1c(%rsp)
andq $0x0, 0x60(%rsp)
movq 0x10(%rdi), %r13
movq %r13, 0x28(%rsp)
movl $0xffffd09e, %ebx # imm = 0xFFFFD09E
cmpl $0x30, (%rdi)
jne 0x29e9a
m... | /project-everest[P]mbedtls/library/pkcs5.c |
mbedtls_pkcs5_pbkdf2_hmac | int mbedtls_pkcs5_pbkdf2_hmac( mbedtls_md_context_t *ctx, const unsigned char *password,
size_t plen, const unsigned char *salt, size_t slen,
unsigned int iteration_count,
uint32_t key_length, unsigned char *output )
{
int ret, j;
unsigned int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0xf8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xf0(%rsp), %ebx
movq (%rdi), %rdi
callq 0x1450a
leaq 0x4(%rsp), %rcx
movl $... | /project-everest[P]mbedtls/library/pkcs5.c |
mbedtls_pkcs5_self_test | int mbedtls_pkcs5_self_test( int verbose )
{
mbedtls_md_context_t sha1_ctx;
const mbedtls_md_info_t *info_sha1;
int ret, i;
unsigned char key[64];
mbedtls_md_init( &sha1_ctx );
info_sha1 = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
if( info_sha1 == NULL )
{
ret = 1;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edi, %r12d
leaq 0x18(%rsp), %rdi
callq 0x13fa4
pushq $0x4
popq %rdi
callq 0x13f8b
testq %rax, %rax
je 0x2a45c
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rbx
movq %rax, %rsi
movl %ebx, %edx
callq 0x1404a
testl %eax, %eax
jne 0x2a45f
lea... | /project-everest[P]mbedtls/library/pkcs5.c |
mbedtls_arc4_setup | void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
unsigned int keylen )
{
int i, j, a;
unsigned int k;
unsigned char *m;
ctx->x = 0;
ctx->y = 0;
m = ctx->m;
for( i = 0; i < 256; i++ )
m[i] = (unsigned char) i;
j = k = 0;
for( i... | andq $0x0, (%rdi)
xorl %eax, %eax
cmpq $0x100, %rax # imm = 0x100
je 0x2a4ce
movb %al, 0x8(%rdi,%rax)
incq %rax
jmp 0x2a4bd
pushq %rbx
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq $0x100, %rcx # imm = 0x100
je 0x2a50f
cmpl %edx, %r9d
cmovael %eax, %r9d
movb 0x8(%rdi,%rcx), ... | /project-everest[P]mbedtls/library/arc4.c |
mbedtls_arc4_self_test | int mbedtls_arc4_self_test( int verbose )
{
int i, ret = 0;
unsigned char ibuf[8];
unsigned char obuf[8];
mbedtls_arc4_context ctx;
mbedtls_arc4_init( &ctx );
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
mbedtls_printf( " ARC4 test #%d: ", i + 1 );
memcpy( ib... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edi, %ebx
leaq 0x10(%rsp), %r14
movl $0x108, %edx # imm = 0x108
movq %r14, %rdi
xorl %esi, %esi
callq 0xc0e0
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
leaq 0xe929(%rip), %r12 # 0x38ec0
xorl... | /project-everest[P]mbedtls/library/arc4.c |
mbedtls_asn1_write_len | int mbedtls_asn1_write_len( unsigned char **p, unsigned char *start, size_t len )
{
if( len < 0x80 )
{
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (unsigned char) len;
return( 1 );
}
if( len <= 0xFF )
{
if( *p - start < 2 )
... | cmpq $0x7f, %rdx
ja 0x2a670
movq (%rdi), %rcx
movq %rcx, %rax
subq %rsi, %rax
testq %rax, %rax
jle 0x2a744
pushq $0x1
popq %rax
jmp 0x2a78d
cmpq $0xff, %rdx
ja 0x2a6a3
movq (%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
cmpq $0x2, %rcx
jl 0x2a744
leaq -0x1(%rax), %rcx
movq %rcx, (%rdi)
movb %dl, -0x1(%rax)
movq (%rdi), %... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_raw_buffer | int mbedtls_asn1_write_raw_buffer( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t size )
{
size_t len = 0;
if( *p < start || (size_t)( *p - start ) < size )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len = size;
(*p) -= len;
memcpy( *p, ... | pushq %rbx
movq %rcx, %rbx
movq %rdi, %rax
movq (%rdi), %rdi
movq %rdi, %rcx
subq %rsi, %rcx
setb %sil
cmpq %rbx, %rcx
setb %cl
orb %sil, %cl
je 0x2a7dc
pushq $-0x6c
popq %rbx
jmp 0x2a7ed
subq %rbx, %rdi
movq %rdi, (%rax)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0xc150
movl %ebx, %eax
popq %rbx
retq
| /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_mpi | int mbedtls_asn1_write_mpi( unsigned char **p, unsigned char *start, const mbedtls_mpi *X )
{
int ret;
size_t len = 0;
// Write the MPI
//
len = mbedtls_mpi_size( X );
if( *p < start || (size_t)( *p - start ) < len )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
(*p) -= len;
MBEDT... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rdi
callq 0x10d1c
movq %rax, %r15
movq (%r14), %rsi
pushq $-0x6c
popq %rbx
movq %rsi, %rax
subq %r12, %rax
jb 0x2a838
cmpq %r15, %rax
jb 0x2a838
subq %r15, %rsi
movq %rsi, (%r14)
movq %r13, %rdi
movq %r15,... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_null | int mbedtls_asn1_write_len( unsigned char **p, unsigned char *start, size_t len )
{
if( len < 0x80 )
{
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (unsigned char) len;
return( 1 );
}
if( len <= 0xFF )
{
if( *p - start < 2 )
... | movq (%rdi), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
pushq $-0x6c
popq %rax
testq %rdx, %rdx
jle 0x2a8db
leaq -0x1(%rcx), %rdx
movq %rdx, (%rdi)
movb $0x0, -0x1(%rcx)
movq (%rdi), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
testq %rdx, %rdx
jle 0x2a8db
leaq -0x1(%rcx), %rax
movq %rax, (%rdi)
movb $0x5, -0x1(%rcx)
pushq $0x2
popq... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_oid | int mbedtls_asn1_write_oid( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len )
{
int ret;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) oid, oid_len ) );
MBEDTLS_A... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %cl
cmpq %rbx, %rax
setb %al
orb %cl, %al
pushq $-0x6c
popq %rbp
jne 0x2a957
movq %rsi, %r15
subq %rbx, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0xc150
testl ... | /project-everest[P]mbedtls/library/asn1write.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.