Dataset Viewer (First 5GB)
idx
int64 0
2.11M
| name
stringlengths 1
118k
| code
stringlengths 6
516k
| asm
stringlengths 21
4.64M
| file
stringlengths 39
143
| opt
stringclasses 1
value | path
stringlengths 20
133
|
|---|---|---|---|---|---|---|
0 | hitvmiss_measurement | uint64_t hitvmiss_measurement(struct cache_t cache) {
int8_t dummyMem[5 * cache.size];
uint64_t alignedMem = ((uint64_t)&dummyMem + cache.size) & cache.mask_Tag;
uint8_t dummyVar = 0;
uint64_t start, end;
uint64_t data_index = 0;
volatile uint8_t* current_addr= 0;
FILE *f = fopen(DATAFILE, "w");
struct l1pp_result_t *results = malloc(sizeof(struct l1pp_result_t) * cache.sets * cache.ways * 5 * 10);
for(uint64_t n=0; n<10; n++) {
flushcache(alignedMem, cache.size, cache);
flushcache(alignedMem, cache.size, cache);
flushcache(alignedMem, cache.size, cache);
for (uint64_t k=0; k<5; k++) {
for (uint64_t i=0; i<cache.sets; i++) {
uint64_t setOffset = (((alignedMem & cache.mask_Set) >> cache.numbits_Offset) + i) << cache.numbits_Offset;
for (uint64_t j=0; j<cache.ways; ++j) {
uint64_t wayOffset = j << (cache.numbits_Offset + cache.numbits_Set);
current_addr = (volatile uint8_t*)((uint64_t)alignedMem + setOffset + wayOffset);
start = cycles();
dummyVar = *current_addr;
end = cycles();
results[data_index].addr = ((uint64_t)alignedMem + setOffset + wayOffset);
results[data_index].time = end-start;
results[data_index].phys = 0;
results[data_index].run = k;
data_index++;
}
}
}
for (uint64_t i=0; i<data_index; i++) {
fprintf(f, "0x%lx,0x%lx,%ld,%ld\n",
results[i].addr,
results[i].phys,
results[i].time,
results[i].run
);
}
}
fclose(f);
return data_index;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movl 0x8(%rcx), %edx
movl %edx, %eax
leal (%rax,%rax,4), %eax
movl %eax, %edx
movq %rsp, %rax
movq %rax, -0x8(%rbp)
movq %rdx, %rsi
addq $0xf, %rsi
andq $-0x10, %rsi
movq %rsp, %rax
subq %rsi, %rax
movq %rax, %rsp
movq %rdx, -0x10(%rbp)
movslq 0x8(%rcx), %rdx
addq %rdx, %rax
andq 0x40(%rcx), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
leaq 0xeb687(%rip), %rdi # 0x4ed110
leaq 0xb9574(%rip), %rsi # 0x4bb004
callq 0x41baa0
movq -0x90(%rbp), %rcx
movq %rax, -0x48(%rbp)
movslq 0xc(%rcx), %rax
shlq $0x5, %rax
movslq (%rcx), %rcx
imulq %rcx, %rax
imulq $0x5, %rax, %rax
imulq $0xa, %rax, %rdi
callq 0x429410
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
cmpq $0xa, -0x58(%rbp)
jae 0x401ced
movq $0x0, -0x60(%rbp)
cmpq $0x5, -0x60(%rbp)
jae 0x401c3e
movq $0x0, -0x68(%rbp)
movq -0x90(%rbp), %rcx
movq -0x68(%rbp), %rax
movslq 0xc(%rcx), %rcx
cmpq %rcx, %rax
jae 0x401c2b
movq -0x90(%rbp), %rcx
movq -0x18(%rbp), %rax
andq 0x38(%rcx), %rax
movl 0x20(%rcx), %ecx
shrq %cl, %rax
movq -0x90(%rbp), %rcx
addq -0x68(%rbp), %rax
movl 0x20(%rcx), %ecx
shlq %cl, %rax
movq %rax, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x90(%rbp), %rcx
movq -0x78(%rbp), %rax
movslq (%rcx), %rcx
cmpq %rcx, %rax
jae 0x401c18
movq -0x90(%rbp), %rdx
movq -0x78(%rbp), %rax
movl 0x20(%rdx), %ecx
addl 0x24(%rdx), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
addq -0x70(%rbp), %rax
addq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x401dd0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
callq 0x401dd0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
addq -0x70(%rbp), %rcx
addq -0x80(%rbp), %rcx
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
subq -0x28(%rbp), %rcx
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x60(%rbp), %rcx
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x401b38
jmp 0x401c1a
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x401aee
jmp 0x401c2d
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x401adb
movq $0x0, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x401cda
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movq -0x88(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x50(%rbp), %rax
movq -0x88(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x50(%rbp), %rax
movq -0x88(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movq 0x10(%rax), %r8
movq -0x50(%rbp), %rax
movq -0x88(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movq 0x18(%rax), %r9
leaq 0xb934a(%rip), %rsi # 0x4bb006
movb $0x0, %al
callq 0x40d0f0
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x401c49
jmp 0x401cdc
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x401ac8
movq -0x48(%rbp), %rdi
callq 0x41b660
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/hitvsmiss_datacollect.c |
1 | main | int main() {
struct cache_t cache = getL1DCache();
uint64_t datasize = 0;
// FILE *f = fopen(DATAFILE, 'w'); // Destroy the DATAFILE if it already exists.
// fclose(f);
printf("\nChecking hit vs miss cache read times.\n");
datasize = hitvmiss_measurement(cache);
printf("\tCollected %d data points.\n", datasize);
printf("\tCache sets: %ld. Cache ways: %ld. Expected datapoints: %ld\n",
cache.sets,
cache.ways,
cache.sets*cache.ways*5*10);
printf("Done.\n");
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
movb $0x0, %al
callq 0x402590
movq $0x0, -0x58(%rbp)
leaq 0xb92df(%rip), %rdi # 0x4bb01b
movb $0x0, %al
callq 0x40d1b0
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x40(%rax)
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups -0x30(%rbp), %xmm2
movups -0x20(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x401a20
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
leaq 0xb92c3(%rip), %rdi # 0x4bb044
movb $0x0, %al
callq 0x40d1b0
movl -0x44(%rbp), %esi
movl -0x50(%rbp), %edx
movl -0x44(%rbp), %eax
imull -0x50(%rbp), %eax
imull $0x5, %eax, %eax
imull $0xa, %eax, %ecx
leaq 0xb92be(%rip), %rdi # 0x4bb060
movb $0x0, %al
callq 0x40d1b0
leaq 0xb92ed(%rip), %rdi # 0x4bb09d
movb $0x0, %al
callq 0x40d1b0
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/hitvsmiss_datacollect.c |
2 | x86_64_rdtsc | static inline uint64_t _x86_64_rdtsc() {
unsigned int lo, hi;
asm volatile(
"rdtsc"
: "=a" (lo), "=d" (hi)
);
char *msg = malloc(100);
sprintf(msg, "cycles: %ld", ((uint64_t)hi << 32) | lo);
debug_msg(msg);
return ((uint64_t)hi << 32) | lo;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
rdtsc
movl %eax, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl $0x64, %edi
callq 0x429410
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %eax
movl %eax, %edx
shlq $0x20, %rdx
movl -0x4(%rbp), %eax
orq %rax, %rdx
leaq 0xb929c(%rip), %rsi # 0x4bb0a4
movb $0x0, %al
callq 0x40d280
movq -0x10(%rbp), %rsi
leaq 0xb9296(%rip), %rdi # 0x4bb0b0
callq 0x402cc0
movl -0x8(%rbp), %eax
shlq $0x20, %rax
movl -0x4(%rbp), %ecx
orq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/low.h |
3 | get_numCaches | int get_numCaches(int hart_id) {
DIR *dirp;
struct dirent *dir;
int count = 0;
char target[50];
sprintf(target, "/sys/devices/system/cpu/cpu%d/cache/", hart_id);
DIR* d = opendir(target);
if(d==NULL) {
printf("Number of caches could not be determined from device tree. Are you in an emulator?\n");
printf("Generating a default number of caches.\n");
return 2;
}
dirp = opendir(target);
if (dirp == NULL) {
return -1;
}
while((dir = readdir(dirp)) != NULL) {
if(dir->d_type == DT_DIR) {
count++;
}
}
// -2, do not count "." and ".." directories
return count-2;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x50(%rbp), %rdi
movl -0x8(%rbp), %edx
leaq 0xb925e(%rip), %rsi # 0x4bb0be
movb $0x0, %al
callq 0x40d280
leaq -0x50(%rbp), %rdi
callq 0x45c400
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x401ea0
leaq 0xb9261(%rip), %rdi # 0x4bb0e3
movb $0x0, %al
callq 0x40d1b0
leaq 0xb92a7(%rip), %rdi # 0x4bb137
movb $0x0, %al
callq 0x40d1b0
movl $0x2, -0x4(%rbp)
jmp 0x401ef3
leaq -0x50(%rbp), %rdi
callq 0x45c400
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x401ebd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x401ef3
jmp 0x401ebf
movq -0x10(%rbp), %rdi
callq 0x45c630
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x401eea
movq -0x18(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x401ee8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x401ebf
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/low.c |
4 | get_numCPUOnline | int get_numCPUOnline() {
char sysfile[] = "/sys/devices/system/cpu/online";
char *online = get_StringFromSysFile(sysfile);
int numCPU = 0;
if (strcmp(online, "0") == 0) {
return 1;
}
char *ptr;
ptr = strtok(online, "-");
while (ptr != NULL) {
ptr = strtok(NULL, "-");
if (ptr != NULL) { numCPU = atoi(ptr) + 1; }
}
return numCPU;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0xb9361(%rip), %rax # 0x4bb270
movq %rax, -0x30(%rbp)
movq 0xb935e(%rip), %rax # 0x4bb278
movq %rax, -0x28(%rbp)
movq 0xb935b(%rip), %rax # 0x4bb280
movq %rax, -0x20(%rbp)
movl 0xb9359(%rip), %eax # 0x4bb288
movl %eax, -0x18(%rbp)
movw 0xb9353(%rip), %ax # 0x4bb28c
movw %ax, -0x14(%rbp)
movb 0xb934b(%rip), %al # 0x4bb28e
movb %al, -0x12(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x402ad0
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
leaq 0xbf86e(%rip), %rsi # 0x4c17d3
callq 0x4010b0
cmpl $0x0, %eax
jne 0x401f78
movl $0x1, -0x4(%rbp)
jmp 0x401fc5
movq -0x38(%rbp), %rdi
leaq 0xbf997(%rip), %rsi # 0x4c191a
callq 0x42c540
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x401fbf
xorl %eax, %eax
movl %eax, %edi
leaq 0xbf97c(%rip), %rsi # 0x4c191a
callq 0x42c540
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x401fbd
movq -0x48(%rbp), %rdi
callq 0x40b4d0
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x401f8c
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/low.c |
5 | get_CacheParameters | struct cache_t get_CacheParameters(int hart_id, int cache_index) {
struct cache_t cache;
char buff[200];
char *buff_ptr;
char *workingdir;
sprintf(buff, "/sys/devices/system/cpu/cpu%d/cache/index%d/",
hart_id, cache_index);
workingdir = calloc(strlen(buff), sizeof(char));
strcpy(workingdir, buff);
DIR* dir = opendir(workingdir);
if(dir==NULL) {
if (cache_index==0) {
// generate a emulator default instr cache
printf("Generating a default instruction cache object.\n");
cache.ways=4;
cache.level=1;
cache.type=malloc(100);
strcpy(cache.type,"Instruction");
cache.sets=64;
cache.size=32768;
cache.linesize = cache.size / (cache.sets * cache.ways);
cache.blocksize=4096;
} else if (cache_index==1) {
// generate a emulator default data cache
printf("Generating a default data cache object.\n");
cache.ways=4;
cache.level=1;
cache.type=malloc(100);
strcpy(cache.type,"Data");
cache.sets=64;
cache.size=32768;
cache.linesize = cache.size / (cache.sets * cache.ways);
cache.blocksize=4096;
}
// derived parameters
uint64_t fullmask = 0xFFFFFFFFFFFFFFFF;
cache.numbits_Offset = log2(cache.linesize);
cache.numbits_Set = log2(cache.sets);
cache.numbits_Tag = sizeof(void*)*8 - cache.numbits_Set - cache.numbits_Offset;
cache.mask_Offset = (~(fullmask << cache.numbits_Offset));
cache.mask_Tag = (fullmask << (cache.numbits_Set + cache.numbits_Offset));
cache.mask_Set = (~(cache.mask_Tag | cache.mask_Offset));
return cache;
}
// get cache ways of associativity
cache.ways = atoi(get_StringFromSysFile(concat(workingdir,"ways_of_associativity")));
// get cache level (eg L1, L3, etc)
cache.level = atoi(get_StringFromSysFile(concat(workingdir,"level")));
// get cache type (eg data, instruction)
cache.type = malloc(100); // TODO: allocate better
strcpy(cache.type, get_StringFromSysFile(concat(workingdir,"type")));
// get number of sets
cache.sets = atoi(get_StringFromSysFile(concat(workingdir,"number_of_sets")));
// get cache size. Usually this will return as some string like "32K".
// Remember, here K is base2 so 32K means 32*1024 =
buff_ptr = get_StringFromSysFile(concat(workingdir,"size"));
cache.size = atoi(buff_ptr);
if (strchr(buff_ptr,'K') != NULL) {
cache.size = cache.size * 1024;
}
// derive line size
cache.linesize = cache.size / ( cache.sets * cache.ways );
char *blocksize = get_StringFromSysFile("/sys/devices/system/memory/block_size_bytes");
if (blocksize == NULL) {
cache.blocksize = 4096;
} else {
cache.blocksize = atoi(blocksize);
}
// derived parameters
uint64_t fullmask = 0xFFFFFFFFFFFFFFFF;
cache.numbits_Offset = log2(cache.linesize);
cache.numbits_Set = log2(cache.sets);
cache.numbits_Tag = sizeof(void*) * 8 - cache.numbits_Set - cache.numbits_Offset;
cache.mask_Offset = (~(fullmask << cache.numbits_Offset));
cache.mask_Tag = (fullmask << (cache.numbits_Set + cache.numbits_Offset));
cache.mask_Set = (~(cache.mask_Tag | cache.mask_Offset));
return cache;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x110(%rbp)
movq %rdi, -0x108(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
leaq -0xd0(%rbp), %rdi
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0xb915c(%rip), %rsi # 0x4bb15f
movb $0x0, %al
callq 0x40d280
leaq -0xd0(%rbp), %rdi
callq 0x4010e0
movq %rax, %rdi
movl $0x1, %esi
callq 0x42a860
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x401020
movq -0xe0(%rbp), %rdi
callq 0x45c400
movq %rax, -0xe8(%rbp)
cmpq $0x0, -0xe8(%rbp)
jne 0x40220f
cmpl $0x0, -0x8(%rbp)
jne 0x4020eb
leaq 0xb911d(%rip), %rdi # 0x4bb18c
movb $0x0, %al
callq 0x40d1b0
movq -0x110(%rbp), %rax
movl $0x4, (%rax)
movl $0x1, 0x4(%rax)
movl $0x64, %edi
callq 0x429410
movq %rax, %rcx
movq -0x110(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
leaq 0xb910f(%rip), %rsi # 0x4bb1bc
callq 0x401020
movq -0x110(%rbp), %rdx
movl $0x40, 0xc(%rdx)
movl $0x8000, 0x8(%rdx) # imm = 0x8000
movl 0x8(%rdx), %eax
movl 0xc(%rdx), %ecx
imull (%rdx), %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x1000, 0x14(%rax) # imm = 0x1000
jmp 0x402171
cmpl $0x1, -0x8(%rbp)
jne 0x40216f
leaq 0xb90d0(%rip), %rdi # 0x4bb1c8
movb $0x0, %al
callq 0x40d1b0
movq -0x110(%rbp), %rax
movl $0x4, (%rax)
movl $0x1, 0x4(%rax)
movl $0x64, %edi
callq 0x429410
movq %rax, %rcx
movq -0x110(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
leaq 0xb90bb(%rip), %rsi # 0x4bb1f1
callq 0x401020
movq -0x110(%rbp), %rdx
movl $0x40, 0xc(%rdx)
movl $0x8000, 0x8(%rdx) # imm = 0x8000
movl 0x8(%rdx), %eax
movl 0xc(%rdx), %ecx
imull (%rdx), %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x1000, 0x14(%rax) # imm = 0x1000
jmp 0x402171
movq -0x110(%rbp), %rax
movq $-0x1, -0xf0(%rbp)
cvtsi2sdl 0x10(%rax), %xmm0
callq 0x402650
movq -0x110(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x20(%rax)
cvtsi2sdl 0xc(%rax), %xmm0
callq 0x402650
movq -0x110(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x24(%rax)
movslq 0x24(%rax), %rdx
movl $0x40, %ecx
subq %rdx, %rcx
movslq 0x20(%rax), %rdx
subq %rdx, %rcx
movl %ecx, 0x28(%rax)
movq -0xf0(%rbp), %rdx
movl 0x20(%rax), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
xorq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0xf0(%rbp), %rdx
movl 0x24(%rax), %ecx
addl 0x20(%rax), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x40(%rax)
movq 0x40(%rax), %rcx
orq 0x30(%rax), %rcx
xorq $-0x1, %rcx
movq %rcx, 0x38(%rax)
jmp 0x402446
movq -0xe0(%rbp), %rdi
leaq 0xb8fd9(%rip), %rsi # 0x4bb1f6
callq 0x402a70
movq %rax, %rdi
callq 0x402ad0
movq %rax, %rdi
callq 0x40b4d0
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, (%rax)
movq -0xe0(%rbp), %rdi
leaq 0xb8fc1(%rip), %rsi # 0x4bb20c
callq 0x402a70
movq %rax, %rdi
callq 0x402ad0
movq %rax, %rdi
callq 0x40b4d0
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x64, %edi
callq 0x429410
movq %rax, %rcx
movq -0x110(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rax
movq %rax, -0x118(%rbp)
movq -0xe0(%rbp), %rdi
leaq 0xbb2a3(%rip), %rsi # 0x4bd540
callq 0x402a70
movq %rax, %rdi
callq 0x402ad0
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x401020
movq -0xe0(%rbp), %rdi
leaq 0xb8f4b(%rip), %rsi # 0x4bb212
callq 0x402a70
movq %rax, %rdi
callq 0x402ad0
movq %rax, %rdi
callq 0x40b4d0
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0xe0(%rbp), %rdi
leaq 0xd624f(%rip), %rsi # 0x4d8545
callq 0x402a70
movq %rax, %rdi
callq 0x402ad0
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x40b4d0
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0xd8(%rbp), %rdi
movl $0x4b, %esi
callq 0x4010e8
cmpq $0x0, %rax
je 0x402349
movq -0x110(%rbp), %rax
movl 0x8(%rax), %ecx
shll $0xa, %ecx
movl %ecx, 0x8(%rax)
movq -0x110(%rbp), %rdx
movl 0x8(%rdx), %eax
movl 0xc(%rdx), %ecx
imull (%rdx), %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0x10(%rax)
leaq 0xb8eb2(%rip), %rdi # 0x4bb221
callq 0x402ad0
movq %rax, -0xf8(%rbp)
cmpq $0x0, -0xf8(%rbp)
jne 0x402395
movq -0x110(%rbp), %rax
movl $0x1000, 0x14(%rax) # imm = 0x1000
jmp 0x4023ad
movq -0xf8(%rbp), %rdi
callq 0x40b4d0
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x110(%rbp), %rax
movq $-0x1, -0x100(%rbp)
cvtsi2sdl 0x10(%rax), %xmm0
callq 0x402650
movq -0x110(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x20(%rax)
cvtsi2sdl 0xc(%rax), %xmm0
callq 0x402650
movq -0x110(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x24(%rax)
movslq 0x24(%rax), %rdx
movl $0x40, %ecx
subq %rdx, %rcx
movslq 0x20(%rax), %rdx
subq %rdx, %rcx
movl %ecx, 0x28(%rax)
movq -0x100(%rbp), %rdx
movl 0x20(%rax), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
xorq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x100(%rbp), %rdx
movl 0x24(%rax), %ecx
addl 0x20(%rax), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x40(%rax)
movq 0x40(%rax), %rcx
orq 0x30(%rax), %rcx
xorq $-0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x108(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/low.c |
6 | get_CPUParameters | struct cpu_t get_CPUParameters(int hart_id) {
struct cpu_t cpu;
cpu.hart = hart_id;
cpu.numCaches = get_numCaches(hart_id);
// printf("[get_CPUParameters] Hart cpu%d has %d caches.\n", hart_id,
// cpu.numCaches);
cpu.cache = calloc(cpu.numCaches, sizeof(struct cache_t));
for(int cache_index=0; cache_index<cpu.numCaches; cache_index++) {
cpu.cache[cache_index] = get_CacheParameters(hart_id, cache_index);
}
return cpu;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %edi
callq 0x401e40
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x48, %esi
callq 0x42a860
movq %rax, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4024dc
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x401fd0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x48, %edx
callq 0x401040
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x402495
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/low.c |
7 | initialize_cpu | struct cpu_t * initialize_cpu() {
int numCPU = get_numCPUOnline();
if (numCPU == -1) {
return NULL;
}
struct cpu_t *cpu;
cpu = malloc(numCPU * sizeof(struct cpu_t));
for(int i=0; i<numCPU; i++) {
cpu[i] = get_CPUParameters(i);
}
return cpu;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x401f00
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x402510
movq $0x0, -0x8(%rbp)
jmp 0x40257c
movslq -0xc(%rbp), %rdi
shlq $0x4, %rdi
callq 0x429410
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x402574
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x402460
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x402528
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/low.c |
8 | getL1DCache | struct cache_t getL1DCache() {
int numCPU = get_numCPUOnline();
struct cpu_t *cpu = initialize_cpu();
int currCPU = get_hartid();
struct cache_t cache = cpu[currCPU].cache[0];
if (strcmp(cache.type, "Instruction") == 0) {
cache = cpu[currCPU].cache[1];
}
return cache;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
callq 0x401f00
movl %eax, -0x4(%rbp)
callq 0x4024f0
movq %rax, -0x10(%rbp)
movb $0x0, %al
callq 0x402b40
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movl $0x48, %edx
callq 0x401040
movq -0x20(%rbp), %rdi
movq 0x18(%rdi), %rdi
leaq 0xb8bd1(%rip), %rsi # 0x4bb1bc
callq 0x4010b0
cmpl $0x0, %eax
jne 0x40261a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
addq $0x48, %rsi
movl $0x48, %edx
callq 0x401040
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/low.c |
9 | notimplemented | void notimplemented() {
debug_msg("Not implemented.");
} | pushq %rbp
movq %rsp, %rbp
leaq 0xb8c12(%rip), %rdi # 0x4bb24d
leaq 0xb8c1a(%rip), %rsi # 0x4bb25c
callq 0x402cc0
popq %rbp
retq
nopl (%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/low.c |
10 | concat | char* concat(char *s1, char *s2) {
char *result = malloc(strlen(s1) + strlen(s2) + 1);
strcpy(result, s1);
strcat(result, s2);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4010e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4010e0
movq -0x20(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x429410
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x401020
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x401058
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/util.c |
11 | get_StringFromSysFile | char* get_StringFromSysFile(char filename[]){
FILE *fp;
char *buff = malloc(100); // TODO: allocate this better
fp = fopen(filename, "r");
if (fp == NULL) {
return NULL;
}
fscanf(fp, "%s", buff);
fclose(fp);
// printf("about to return from sysstring reader, buff is %s\n", buff);
return buff;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x64, %edi
callq 0x429410
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd4a12(%rip), %rsi # 0x4d7507
callq 0x41baa0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x402b0f
movq $0x0, -0x8(%rbp)
jmp 0x402b36
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xd5b93(%rip), %rsi # 0x4d86b1
movb $0x0, %al
callq 0x40d410
movq -0x18(%rbp), %rdi
callq 0x41b660
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/util.c |
12 | get_hartid | int get_hartid() {
FILE *fp = fopen("/proc/self/stat", "r");
long to_read = 8192;
char buff[to_read];
int read = fread(buff, sizeof(char), to_read, fp);
fclose(fp);
char* line = strtok(buff, " ");
for (int i=1; i<38; i++) {
line = strtok(NULL, " ");
}
line = strtok(NULL, " ");
return atoi(line);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0xb9041(%rip), %rdi # 0x4bbb90
leaq 0xd49b1(%rip), %rsi # 0x4d7507
callq 0x41baa0
movq %rax, -0x8(%rbp)
movq $0x2000, -0x10(%rbp) # imm = 0x2000
movq -0x10(%rbp), %rax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rsp
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x41bba0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41b660
movq -0x40(%rbp), %rdi
leaq 0xbf07c(%rip), %rsi # 0x4c1c33
callq 0x42c540
movq %rax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
cmpl $0x26, -0x34(%rbp)
jge 0x402bec
xorl %eax, %eax
movl %eax, %edi
leaq 0xbf05b(%rip), %rsi # 0x4c1c33
callq 0x42c540
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x402bc7
xorl %eax, %eax
movl %eax, %edi
leaq 0xbf03c(%rip), %rsi # 0x4c1c33
callq 0x42c540
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x40b4d0
movq -0x18(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/util.c |
13 | int_to_binary_string | char* int_to_binary_string(long long num, int numbits) {
char *binary_string = malloc((numbits+1) * sizeof(char));
binary_string[numbits] = '\0';
for (int i=numbits-1; i>=0; i--) {
binary_string[i] = (num % 2) ? '1' : '0';
num = num / 2;
}
return binary_string;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x429410
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x402ca9
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movl $0x30, %eax
movl $0x31, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x402c5a
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/util.c |
14 | debug_msg | void _debug_msg(char const * caller_name, char msg[]) {
if (g_DEBUG) {
printf("DEBUG: [%s] %s\n", caller_name, msg);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x4ef3f0, %rax # imm = 0x4EF3F0
cmpb $0x0, (%rax)
je 0x402cf2
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xb8eb5(%rip), %rdi # 0x4bbba0
movb $0x0, %al
callq 0x40d1b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| bradley-evans[P]riscv-uarch-attacks[P]build_O0[P]bin[P]hitvsmiss_datacollect.asm_src.json | O0 | bradley-evans[P]riscv-uarch-attacks/src/debug_log.c |
15 | main | int main()
{
key_t key;
int msgid;
size_t len = 0;
// ftok to generate unique key
key = ftok("progfile", 65);
// msgget creates a message queue
// and returns identifier
msgid = msgget(key, 0666 | IPC_CREAT);
message.mesg_type = 1;
printf("Write Data : ");
fgets(message.mesg_text, 100, stdin);
// msgsnd to send message
msgsnd(msgid, &message, sizeof(message), 0);
// display the message
printf("Data send is : %s \n", message.mesg_text);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xe66(%rip), %rdi # 0x2004
movl $0x41, %esi
callq 0x1070
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl $0x3b6, %esi # imm = 0x3B6
callq 0x1030
movl %eax, -0xc(%rbp)
movq $0x1, 0x2e92(%rip) # 0x4058
leaq 0xe40(%rip), %rdi # 0x200d
movb $0x0, %al
callq 0x1040
movq 0x2e05(%rip), %rax # 0x3fe0
movq (%rax), %rdx
leaq 0x2e73(%rip), %rdi # 0x4058
addq $0x8, %rdi
movl $0x64, %esi
callq 0x1050
movl -0xc(%rbp), %edi
leaq 0x2e5b(%rip), %rsi # 0x4058
movl $0x70, %edx
xorl %ecx, %ecx
callq 0x1060
leaq 0xe0b(%rip), %rdi # 0x201b
leaq 0x2e41(%rip), %rsi # 0x4058
addq $0x8, %rsi
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
| ADVRHumanoids[P]RT-NRT_IPC_Xenomai[P]build_O0[P]message_queue_writer.asm_src.json | O0 | ADVRHumanoids[P]RT-NRT_IPC_Xenomai/src/ipc/message_queue_writer.c |
16 | _cxx_global_var_init | int main()
{
std::vector<int32_t> fib_seq;
fibonacci(0, 1, fib_seq, 100);
print("fib:", fib_seq);
return 0;
} | pushq %rbp
movq %rsp, %rbp
leaq 0x3ece(%rip), %rdi # 0x6149
callq 0x21c0
movq 0x3d71(%rip), %rdi # 0x5ff8
leaq 0x3ebb(%rip), %rsi # 0x6149
leaq 0x3ea3(%rip), %rdx # 0x6138
callq 0x2110
popq %rbp
retq
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | vocasle[P]principles_and_practice_using_cpp/part_1_the_basics/chapter_8/problem_3.cpp |
17 | GLOBAL__sub_I_problem_3.cpp | int main()
{
std::vector<int32_t> fib_seq;
fibonacci(0, 1, fib_seq, 100);
print("fib:", fib_seq);
return 0;
} | pushq %rbp
movq %rsp, %rbp
callq 0x2270
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | vocasle[P]principles_and_practice_using_cpp/part_1_the_basics/chapter_8/problem_3.cpp |
18 | error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void error(const std::string& msg)
{
throw std::runtime_error(msg);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x2080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
callq 0x21d0
jmp 0x23cb
movq -0x20(%rbp), %rdi
movq 0x3c1a(%rip), %rsi # 0x5ff0
movq 0x3beb(%rip), %rdx # 0x5fc8
callq 0x2200
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x20d0
movq -0x10(%rbp), %rdi
callq 0x2220
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | vocasle[P]principles_and_practice_using_cpp/part_1_the_basics/chapter_8/chapter_8.h |
19 | fibonacci(int, int, std::vector<int, std::allocator<int>>&, int) | void fibonacci(int32_t first, int32_t second, std::vector<int32_t>& numbers, int32_t numOfElements)
{
// Fn = Fn-1 + Fn-2
if (first < 0 || second < 0 || numOfElements < 0)
error("'first' or 'second' or 'numOfElements' must be nonnegative");
if (numOfElements == 0)
return;
numbers.push_back(first);
numbers.push_back(second);
auto fn_1 = first;
auto fn_2 = second;
for (; numbers.size() != numOfElements;)
{
auto fn = fn_1 + fn_2;
numbers.push_back(fn);
fn_1 = fn_2;
fn_2 = fn;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x2427
cmpl $0x0, -0x8(%rbp)
jl 0x2427
cmpl $0x0, -0x14(%rbp)
jge 0x2497
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2230
movq -0x60(%rbp), %rdx
leaq 0x1bc5(%rip), %rsi # 0x4004
leaq -0x38(%rbp), %rdi
callq 0x25f0
jmp 0x244a
leaq -0x38(%rbp), %rdi
callq 0x23a0
jmp 0x2455
leaq -0x38(%rbp), %rdi
callq 0x20a0
leaq -0x39(%rbp), %rdi
callq 0x2160
jmp 0x2497
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x248c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20a0
leaq -0x39(%rbp), %rdi
callq 0x2160
jmp 0x2501
cmpl $0x0, -0x14(%rbp)
jne 0x249f
jmp 0x24fb
movq -0x10(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0x26a0
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x26a0
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2710
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x24fb
movl -0x50(%rbp), %eax
addl -0x54(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x26a0
movl -0x54(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x24c5
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2220
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | vocasle[P]principles_and_practice_using_cpp/part_1_the_basics/chapter_8/problem_3.h |
20 | main | int main()
{
std::vector<int32_t> fib_seq;
fibonacci(0, 1, fib_seq, 100);
print("fib:", fib_seq);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2730
movq -0x60(%rbp), %rdx
xorl %edi, %edi
movl $0x1, %esi
movl $0x64, %ecx
callq 0x2400
jmp 0x2543
leaq -0x51(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2230
movq -0x68(%rbp), %rdx
leaq 0x1ae4(%rip), %rsi # 0x403f
leaq -0x50(%rbp), %rdi
callq 0x25f0
jmp 0x2566
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2750
jmp 0x2575
leaq -0x50(%rbp), %rdi
callq 0x20a0
leaq -0x51(%rbp), %rdi
callq 0x2160
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x27f0
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x25da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x25d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20a0
leaq -0x51(%rbp), %rdi
callq 0x2160
leaq -0x20(%rbp), %rdi
callq 0x27f0
movq -0x28(%rbp), %rdi
callq 0x2220
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | vocasle[P]principles_and_practice_using_cpp/part_1_the_basics/chapter_8/problem_3.cpp |
21 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string<std::allocator<char>>(char const*, std::allocator<char> const&) | basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{
const _CharT* __end = __s ? __s + traits_type::length(__s)
// We just need a non-null pointer here to get an exception:
: reinterpret_cast<const _CharT*>(__alignof__(_CharT));
_M_construct(__s, __end, random_access_iterator_tag());
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x20f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x2150
cmpq $0x0, -0x10(%rbp)
je 0x264c
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2900
movq %rax, -0x40(%rbp)
jmp 0x263b
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
jmp 0x2657
movl $0x1, %eax
movq %rax, -0x50(%rbp)
jmp 0x2657
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2950
jmp 0x2672
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2a60
movq -0x28(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
22 | std::vector<int, std::allocator<int>>::push_back(int const&) | void
push_back(const value_type& __x)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
__x);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), __x);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x26e5
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x2ba0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x8(%rax)
jmp 0x2703
movq -0x20(%rbp), %rdi
callq 0x2d50
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x2bd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
23 | std::vector<int, std::allocator<int>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x2, %rax
popq %rbp
retq
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
24 | std::vector<int, std::allocator<int>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2850
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
25 | void print<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>> const&) | void print(const std::string& label, const std::vector<T>& vec)
{
for (auto&& el : vec)
std::cout << label << ' ' << el << '\n';
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3470
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x34a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x34d0
testb $0x1, %al
jne 0x2795
jmp 0x27e5
leaq -0x20(%rbp), %rdi
callq 0x3510
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq 0x3823(%rip), %rdi # 0x5fd0
callq 0x2120
movq %rax, %rdi
movl $0x20, %esi
callq 0x2190
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x2210
movq %rax, %rdi
movl $0xa, %esi
callq 0x2190
leaq -0x20(%rbp), %rdi
callq 0x3530
jmp 0x2782
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | vocasle[P]principles_and_practice_using_cpp/part_1_the_basics/chapter_8/chapter_8.h |
26 | std::vector<int, std::allocator<int>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x2f90
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x3370
jmp 0x282a
movq -0x20(%rbp), %rdi
callq 0x33a0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2b60
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
27 | std::_Vector_base<int, std::allocator<int>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2870
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
28 | std::_Vector_base<int, std::allocator<int>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x28a0
movq -0x10(%rbp), %rdi
callq 0x28c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
29 | std::allocator<int>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
30 | std::_Vector_base<int, std::allocator<int>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
31 | _gnu_cxx::new_allocator<int>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
32 | std::char_traits<char>::length(char const*) | static _GLIBCXX17_CONSTEXPR size_t
length(const char_type* __s)
{
#if __cplusplus >= 201703L
if (__constant_string_p(__s))
return __gnu_cxx::char_traits<char_type>::length(__s);
#endif
return __builtin_strlen(__s);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x291c
jmp 0x292b
movq -0x18(%rbp), %rdi
callq 0x2a80
movq %rax, -0x10(%rbp)
jmp 0x2938
movq -0x18(%rbp), %rdi
callq 0x2070
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/char_traits.h |
33 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_Alloc_hider::~_Alloc_hider() | _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
: allocator_type(__a), _M_p(__dat) { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
34 | _gnu_cxx::char_traits<char>::eq(char const&, char const&) | static _GLIBCXX_CONSTEXPR bool
eq(const char_type& __c1, const char_type& __c2)
{ return __c1 == __c2; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/char_traits.h |
35 | bool __gnu_cxx::__is_null_pointer<char const>(char const*) | inline bool
__is_null_pointer(_Type* __ptr)
{ return __ptr == 0; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
sete %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/type_traits.h |
36 | void std::allocator_traits<std::allocator<int>>::construct<int, int const&>(std::allocator<int>&, int*, int const&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2d80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
37 | void std::vector<int, std::allocator<int>>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, int const&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %esi
leaq 0x1473(%rip), %rdx # 0x406e
callq 0x2da0
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x2ec0
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2e80
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x2ef0
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x2ba0
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x2f80
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x2f90
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x2f40
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x2f80
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x2f90
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x2f40
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
sarq $0x2, %rdx
callq 0x2fa0
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
38 | std::vector<int, std::allocator<int>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x3150
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
39 | void __gnu_cxx::new_allocator<int>::construct<int, int const&>(int*, int const&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
40 | std::vector<int, std::allocator<int>>::_M_check_len(unsigned long, char const*) const | size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2fe0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x2710
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x2de7
movq -0x18(%rbp), %rdi
callq 0x2090
movq -0x38(%rbp), %rdi
callq 0x2710
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x2710
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3010
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2710
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x2e56
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x2fe0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x2e65
movq -0x38(%rbp), %rdi
callq 0x2fe0
movq %rax, -0x58(%rbp)
jmp 0x2e6d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
41 | std::vector<int, std::allocator<int>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x3150
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
42 | std::_Vector_base<int, std::allocator<int>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2f22
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3170
movq %rax, -0x20(%rbp)
jmp 0x2f2a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x2f2a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
43 | std::vector<int, std::allocator<int>>::_S_relocate(int*, int*, int*, std::allocator<int>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3200
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
44 | std::_Vector_base<int, std::allocator<int>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
45 | std::_Vector_base<int, std::allocator<int>>::_M_deallocate(int*, unsigned long) | void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __p, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2fd4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3310
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
46 | std::vector<int, std::allocator<int>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movq %rax, %rdi
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
47 | std::vector<int, std::allocator<int>>::_S_max_size(std::allocator<int> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30b0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x30d0
movq %rax, -0x20(%rbp)
jmp 0x308a
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2b60
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
48 | std::_Vector_base<int, std::allocator<int>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
49 | std::allocator_traits<std::allocator<int>>::max_size(std::allocator<int> const&) | static _GLIBCXX20_CONSTEXPR size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3110
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
50 | _gnu_cxx::new_allocator<int>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
51 | _gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>::__normal_iterator(int* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
52 | std::allocator_traits<std::allocator<int>>::allocate(std::allocator<int>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x31a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
53 | _gnu_cxx::new_allocator<int>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x3130
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x31eb
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, -0x10(%rbp)
jbe 0x31e6
callq 0x20e0
callq 0x2050
movq -0x10(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
54 | std::vector<int, std::allocator<int>>::_S_do_relocate(int*, int*, int*, std::allocator<int>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x3240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
55 | int* std::__relocate_a<int*, int*, std::allocator<int>>(int*, int*, int*, std::allocator<int>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3300
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3300
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3300
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x32a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
56 | std::enable_if<std::__is_bitwise_relocatable<int>::value, int*>::type std::__relocate_a_1<int, int>(int*, int*, int*, std::allocator<int>&) | inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
__relocate_a_1(_Tp* __first, _Tp* __last,
_Tp* __result, allocator<_Up>&) noexcept
{
ptrdiff_t __count = __last - __first;
if (__count > 0)
__builtin_memmove(__result, __first, __count * sizeof(_Tp));
return __result + __count;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jle 0x32e7
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
shlq $0x2, %rdx
callq 0x21e0
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
57 | std::allocator_traits<std::allocator<int>>::deallocate(std::allocator<int>&, int*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3340
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
58 | void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x33e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
59 | std::_Vector_base<int, std::allocator<int>>::~_Vector_base() | ~_Vector_base() _GLIBCXX_NOEXCEPT
{
_M_deallocate(_M_impl._M_start,
_M_impl._M_end_of_storage - _M_impl._M_start);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
callq 0x2fa0
jmp 0x33c9
movq -0x10(%rbp), %rdi
callq 0x3420
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2b60
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
60 | void std::_Destroy<int*>(int*, int*) | _GLIBCXX20_CONSTEXPR inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
#if __cplusplus >= 201103L
// A deleted destructor is trivial, this ensures we reject such types:
static_assert(is_destructible<_Value_type>::value,
"value type is destructible");
#endif
#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return _Destroy_aux<false>::__destroy(__first, __last);
#endif
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
__destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3410
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
61 | void std::_Destroy_aux<true>::__destroy<int*>(int*, int*) | static void
__destroy(_ForwardIterator, _ForwardIterator) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
62 | std::_Vector_base<int, std::allocator<int>>::_Vector_impl::~_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3440
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
63 | std::allocator<int>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
64 | _gnu_cxx::new_allocator<int>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
65 | std::vector<int, std::allocator<int>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x3550
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
66 | std::vector<int, std::allocator<int>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x3550
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
67 | _gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
68 | _gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>::__normal_iterator(int const* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| vocasle[P]principles_and_practice_using_cpp[P]build_O0[P]part_1_the_basics[P]chapter_8[P]p1c8pr3.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
69 | Omega_h::UserTransfer::out_of_line_virtual_method() | void UserTransfer::out_of_line_virtual_method() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
70 | Omega_h::TransferOpts::TransferOpts() | TransferOpts::TransferOpts() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c7c50
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x1cc000
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x1cc000
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x1cc000
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0x1e0360
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
callq 0x1c24c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
71 | Omega_h::TransferOpts::validate(Omega_h::Mesh*) const | void TransferOpts::validate(Mesh* mesh) const {
for (auto& pair : type_map) {
auto& name = pair.first;
bool tag_exists = false;
for (Int d = 0; d <= mesh->dim(); ++d) {
if (mesh->has_tag(d, name)) tag_exists = true;
}
if (!tag_exists) {
Omega_h_fail("Field \"%s\" needs to be transferred but is not attached\n",
name.c_str());
}
if (pair.second == OMEGA_H_MOMENTUM_VELOCITY) {
auto velocity_name = pair.first;
OMEGA_H_CHECK(velocity_momentum_map.count(velocity_name));
OMEGA_H_CHECK(velocity_density_map.count(velocity_name));
auto density_name = velocity_density_map.find(velocity_name)->second;
OMEGA_H_CHECK(mesh->has_tag(mesh->dim(), density_name));
auto density = mesh->get_tagbase(mesh->dim(), density_name);
OMEGA_H_CHECK(density->type() == OMEGA_H_REAL);
OMEGA_H_CHECK(density->ncomps() == 1);
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cd0c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1daae0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1bebe0
testb $0x1, %al
jne 0x1e6aa2
jmp 0x1e6dd7
leaq -0x20(%rbp), %rdi
callq 0x1d7280
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0xac(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ddc00
movl %eax, %ecx
movl -0xac(%rbp), %eax
cmpl %ecx, %eax
jg 0x1e6b07
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x1cccb0
testb $0x1, %al
jne 0x1e6af6
jmp 0x1e6afa
movb $0x1, -0x39(%rbp)
jmp 0x1e6afc
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x1e6ac2
testb $0x1, -0x39(%rbp)
jne 0x1e6b27
movq -0x38(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq 0x444510(%rip), %rdi # 0x62b030
movb $0x0, %al
callq 0x1ce550
movq -0x30(%rbp), %rax
cmpl $0x5, 0x20(%rax)
jne 0x1e6dc7
movq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1c00c0
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
addq $0x90, %rdi
callq 0x1e47a0
movq %rax, -0xb8(%rbp)
jmp 0x1e6b6c
movq -0xb8(%rbp), %rax
cmpq $0x0, %rax
je 0x1e6b7b
jmp 0x1e6baf
leaq 0x4444e6(%rip), %rdi # 0x62b068
leaq 0x4444fe(%rip), %rsi # 0x62b087
leaq 0x444522(%rip), %rdx # 0x62b0b2
xorl %eax, %eax
movl $0x29, %ecx
callq 0x1ce550
jmp 0x1e6b9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1e6dbc
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
leaq -0x60(%rbp), %rsi
callq 0x1e47a0
movq %rax, -0xc8(%rbp)
jmp 0x1e6bcc
movq -0xc8(%rbp), %rax
cmpq $0x0, %rax
je 0x1e6bdb
jmp 0x1e6bfe
leaq 0x444486(%rip), %rdi # 0x62b068
leaq 0x444529(%rip), %rsi # 0x62b112
leaq 0x4444c2(%rip), %rdx # 0x62b0b2
xorl %eax, %eax
movl $0x2a, %ecx
callq 0x1ce550
jmp 0x1e6bfe
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c93a0
movq %rax, -0xd0(%rbp)
jmp 0x1e6c1b
movq -0xd0(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1e3750
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x90(%rbp), %rdi
callq 0x1c00c0
jmp 0x1e6c4a
movq -0x10(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1ddc00
movl %eax, -0xd4(%rbp)
jmp 0x1e6c62
movl -0xd4(%rbp), %esi
movq -0xe0(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x1cccb0
movb %al, -0xe1(%rbp)
jmp 0x1e6c83
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x1e6c8f
jmp 0x1e6c91
jmp 0x1e6cd1
leaq 0x4443d0(%rip), %rdi # 0x62b068
leaq 0x44449d(%rip), %rsi # 0x62b13c
leaq 0x44440c(%rip), %rdx # 0x62b0b2
xorl %eax, %eax
movl $0x2c, %ecx
callq 0x1ce550
jmp 0x1e6cb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
jmp 0x1e6dbc
movq -0x10(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1ddc00
movl %eax, -0xe8(%rbp)
jmp 0x1e6ce9
movl -0xe8(%rbp), %esi
movq -0xf0(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x1cd080
movq %rax, -0xf8(%rbp)
jmp 0x1e6d0b
movq -0xf8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0xfc(%rbp)
jmp 0x1e6d31
movl -0xfc(%rbp), %eax
cmpl $0x5, %eax
jne 0x1e6d3e
jmp 0x1e6d61
leaq 0x444323(%rip), %rdi # 0x62b068
leaq 0x444419(%rip), %rsi # 0x62b165
leaq 0x44435f(%rip), %rdx # 0x62b0b2
xorl %eax, %eax
movl $0x2e, %ecx
callq 0x1ce550
jmp 0x1e6d61
movq -0xa0(%rbp), %rdi
callq 0x1d42d0
movl %eax, -0x100(%rbp)
jmp 0x1e6d75
movl -0x100(%rbp), %eax
cmpl $0x1, %eax
jne 0x1e6d82
jmp 0x1e6da5
leaq 0x4442df(%rip), %rdi # 0x62b068
leaq 0x4443f5(%rip), %rsi # 0x62b185
leaq 0x44431b(%rip), %rdx # 0x62b0b2
xorl %eax, %eax
movl $0x2f, %ecx
callq 0x1ce550
jmp 0x1e6da5
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
jmp 0x1e6dc7
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
jmp 0x1e6de0
jmp 0x1e6dc9
leaq -0x20(%rbp), %rdi
callq 0x1d62f0
jmp 0x1e6a8c
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
72 | Omega_h::AdaptOpts::AdaptOpts(int) | AdaptOpts::AdaptOpts(Int dim) {
min_length_desired = 1.0 / std::sqrt(2.0);
max_length_desired = std::sqrt(2.0);
max_length_allowed = max_length_desired * 2.0;
if (dim == 3) {
min_quality_allowed = 0.20;
min_quality_desired = 0.30;
} else if (dim == 2) {
min_quality_allowed = 0.30;
min_quality_desired = 0.40;
} else if (dim == 1) {
min_quality_allowed = 0.0;
min_quality_desired = 0.0;
} else {
Omega_h_fail("unexpected dim %d\n", dim);
}
nsliver_layers = 4;
verbosity = EACH_REBUILD;
length_histogram_min = 0.0;
length_histogram_max = 3.0;
nlength_histogram_bins = 10;
nquality_histogram_bins = 10;
#ifdef OMEGA_H_USE_EGADS
egads_model = nullptr;
should_smooth_snap = true;
snap_smooth_tolerance = 1e-2;
allow_snap_failure = false;
#endif
should_refine = true;
should_coarsen = true;
should_swap = true;
should_coarsen_slivers = true;
should_prevent_coarsen_flip = false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x50, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1e36e0
movsd 0x4441e4(%rip), %xmm0 # 0x62b000
callq 0x1c8900
movq -0x28(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0x4441d8(%rip), %xmm0 # 0x62b008
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd 0x4441c0(%rip), %xmm0 # 0x62b000
callq 0x1c8900
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x4441aa(%rip), %xmm0 # 0x62b000
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
cmpl $0x3, -0xc(%rbp)
jne 0x1e6e86
movq -0x28(%rbp), %rax
movsd 0x4441ae(%rip), %xmm0 # 0x62b020
movsd %xmm0, 0x18(%rax)
movsd 0x444199(%rip), %xmm0 # 0x62b018
movsd %xmm0, 0x20(%rax)
jmp 0x1e6ef6
cmpl $0x2, -0xc(%rbp)
jne 0x1e6eac
movq -0x28(%rbp), %rax
movsd 0x444180(%rip), %xmm0 # 0x62b018
movsd %xmm0, 0x18(%rax)
movsd 0x44416b(%rip), %xmm0 # 0x62b010
movsd %xmm0, 0x20(%rax)
jmp 0x1e6ef4
cmpl $0x1, -0xc(%rbp)
jne 0x1e6ec8
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
jmp 0x1e6ef2
movl -0xc(%rbp), %esi
leaq 0x4442ca(%rip), %rdi # 0x62b19c
xorl %eax, %eax
callq 0x1ce550
jmp 0x1e6edb
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1cced0
jmp 0x1e6f45
jmp 0x1e6ef4
jmp 0x1e6ef6
movq -0x28(%rbp), %rax
movl $0x4, 0x28(%rax)
movl $0x2, 0x2c(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movsd 0x444110(%rip), %xmm0 # 0x62b028
movsd %xmm0, 0x38(%rax)
movl $0xa, 0x40(%rax)
movl $0xa, 0x44(%rax)
movb $0x1, 0x48(%rax)
movb $0x1, 0x49(%rax)
movb $0x1, 0x4a(%rax)
movb $0x1, 0x4b(%rax)
movb $0x0, 0x4c(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
73 | Omega_h::min_fixable_quality(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | Real min_fixable_quality(Mesh* mesh, AdaptOpts const& opts) {
return get_min(mesh->comm(), get_fixable_qualities(mesh, opts));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1be0a0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1e6ff0
jmp 0x1e6f80
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1df0f0
movsd %xmm0, -0x48(%rbp)
jmp 0x1e6f94
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
leaq -0x20(%rbp), %rdi
callq 0x1cb520
movsd -0x48(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1e6fd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
leaq -0x20(%rbp), %rdi
callq 0x1cb520
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
74 | Omega_h::get_fixable_qualities(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static Reals get_fixable_qualities(Mesh* mesh, AdaptOpts const&) {
/* This used to be an attempt to continue adapting when certain
elements were constrained to by geometry to have small dihedral angles.
We'll leave it here as a placeholder for reimplementing such a system
in the future, but for now it just returns all qualities */
return mesh->ask_qualities();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d9c20
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
75 | Omega_h::AdaptOpts::AdaptOpts(Omega_h::Mesh*) | AdaptOpts::AdaptOpts(Mesh* mesh) : AdaptOpts(mesh->dim()) {} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ddc00
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x1c3320
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
76 | Omega_h::print_adapt_status(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | bool print_adapt_status(Mesh* mesh, AdaptOpts const& opts) {
OMEGA_H_TIME_FUNCTION;
auto qualstats = get_minmax(mesh->comm(), get_fixable_qualities(mesh, opts));
auto lenstats = get_minmax(mesh->comm(), mesh->ask_lengths());
if (opts.verbosity > SILENT) {
adapt_summary(mesh, opts, qualstats, lenstats);
}
return (qualstats.min >= opts.min_quality_desired &&
lenstats.min >= opts.min_length_desired &&
lenstats.max <= opts.max_length_desired);
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1dfbb0
movq -0x138(%rbp), %rdx
leaq 0x444021(%rip), %rsi # 0x62b0b2
leaq -0x78(%rbp), %rdi
callq 0x1d5e00
jmp 0x1e709c
leaq 0x4441d2(%rip), %rdx # 0x62b275
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1bb5a0
jmp 0x1e70b2
leaq -0xb0(%rbp), %rdi
movl $0x6f, %esi
callq 0x1d4960
jmp 0x1e70c5
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x1ca480
jmp 0x1e70db
leaq -0x38(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x4440c1(%rip), %rsi # 0x62b1af
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x1e70f9
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
leaq -0xb0(%rbp), %rdi
callq 0x1c4d10
leaq -0x58(%rbp), %rdi
callq 0x1c4d10
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
movq -0x8(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x1be0a0
jmp 0x1e713b
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0xe0(%rbp), %rdi
callq 0x1e6ff0
jmp 0x1e7151
leaq -0xd0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1d2320
movsd %xmm1, -0x148(%rbp)
movsd %xmm0, -0x140(%rbp)
jmp 0x1e7176
movsd -0x148(%rbp), %xmm0
movsd -0x140(%rbp), %xmm1
movsd %xmm1, -0xc0(%rbp)
movsd %xmm0, -0xb8(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x1e0ab0
leaq -0xd0(%rbp), %rdi
callq 0x1cb520
movq -0x8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x1be0a0
jmp 0x1e71c0
movq -0x8(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x1bec10
jmp 0x1e71d2
leaq -0x100(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x1d2320
movsd %xmm1, -0x158(%rbp)
movsd %xmm0, -0x150(%rbp)
jmp 0x1e71f7
movsd -0x158(%rbp), %xmm0
movsd -0x150(%rbp), %xmm1
movsd %xmm1, -0xf0(%rbp)
movsd %xmm0, -0xe8(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x1e0ab0
leaq -0x100(%rbp), %rdi
callq 0x1cb520
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x1e73be
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movups -0xc0(%rbp), %xmm0
movaps %xmm0, -0x120(%rbp)
movups -0xf0(%rbp), %xmm0
movaps %xmm0, -0x130(%rbp)
movsd -0x120(%rbp), %xmm0
movsd -0x118(%rbp), %xmm1
movsd -0x130(%rbp), %xmm2
movsd -0x128(%rbp), %xmm3
callq 0x1e7450
jmp 0x1e7288
jmp 0x1e73be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e7316
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e730d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e7304
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e72f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
leaq -0xb0(%rbp), %rdi
callq 0x1c4d10
leaq -0x58(%rbp), %rdi
callq 0x1c4d10
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
jmp 0x1e7440
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e7437
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e736d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x1e0ab0
leaq -0xd0(%rbp), %rdi
callq 0x1cb520
jmp 0x1e7437
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e73b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x1e0ab0
leaq -0x100(%rbp), %rdi
callq 0x1cb520
jmp 0x1e7437
movsd -0xc0(%rbp), %xmm0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
ucomisd 0x20(%rcx), %xmm0
movb %al, -0x159(%rbp)
jb 0x1e7411
movsd -0xf0(%rbp), %xmm0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
ucomisd (%rcx), %xmm0
movb %al, -0x159(%rbp)
jb 0x1e7411
movsd -0xe8(%rbp), %xmm1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x159(%rbp)
movb -0x159(%rbp), %al
movb %al, -0x15a(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
movb -0x15a(%rbp), %al
andb $0x1, %al
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
77 | Omega_h::adapt_summary(Omega_h::Mesh*, Omega_h::AdaptOpts const&, Omega_h::MinMax<double>, Omega_h::MinMax<double>) | static void adapt_summary(Mesh* mesh, AdaptOpts const& opts,
MinMax<Real> qualstats, MinMax<Real> lenstats) {
print_goal_stats(mesh, "quality", mesh->dim(),
get_fixable_qualities(mesh, opts),
{opts.min_quality_allowed, opts.min_quality_desired}, qualstats);
print_goal_stats(mesh, "length", EDGE, mesh->ask_lengths(),
{opts.min_length_desired, opts.max_length_desired}, lenstats);
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1ddc00
movl %eax, -0xac(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1e6ff0
movq -0xb8(%rbp), %rdi
movl -0xac(%rbp), %edx
movq -0xa8(%rbp), %rcx
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x30(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movsd -0x58(%rbp), %xmm3
leaq 0x446c0f(%rip), %rsi # 0x62e107
callq 0x1bd600
jmp 0x1e74ff
leaq -0x40(%rbp), %rdi
callq 0x1e0ab0
movq -0x28(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1bec10
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rcx
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x90(%rbp)
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movsd -0x90(%rbp), %xmm0
movsd -0x88(%rbp), %xmm1
movsd -0xa0(%rbp), %xmm2
movsd -0x98(%rbp), %xmm3
leaq 0x44d580(%rip), %rsi # 0x634b04
movl $0x1, %edx
callq 0x1bd600
jmp 0x1e7590
leaq -0x80(%rbp), %rdi
callq 0x1e0ab0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1e0ab0
jmp 0x1e75ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1e0ab0
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
78 | Omega_h::print_adapt_histograms(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | void print_adapt_histograms(Mesh* mesh, AdaptOpts const& opts) {
auto qh = get_histogram(mesh, mesh->dim(), opts.nquality_histogram_bins, 0.0,
1.0, mesh->ask_qualities());
auto lh = get_histogram(mesh, EDGE, opts.nlength_histogram_bins,
opts.length_histogram_min, opts.length_histogram_max,
mesh->ask_lengths());
auto owned_qualities =
mesh->owned_array(mesh->dim(), mesh->ask_qualities(), 1);
auto qual_sum = get_sum(mesh->comm(), owned_qualities);
auto global_nelems = mesh->nglobal_ents(mesh->dim());
auto avg_qual = qual_sum / global_nelems;
if (can_print(mesh)) {
print_histogram(qh, "quality");
print_histogram(lh, "length");
std::cout << "average quality: " << avg_qual << '\n';
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x1ddc00
movl %eax, -0x148(%rbp)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x144(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x1d9c20
movq -0x150(%rbp), %rsi
movl -0x148(%rbp), %edx
movl -0x144(%rbp), %ecx
movq -0x140(%rbp), %r8
leaq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x4439b5(%rip), %xmm1 # 0x62b008
callq 0x1c8d70
jmp 0x1e765a
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
movq -0x8(%rbp), %rsi
movq %rsi, -0x170(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
movl %ecx, -0x164(%rbp)
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x160(%rbp)
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x158(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1bec10
jmp 0x1e76a3
movsd -0x158(%rbp), %xmm1
movsd -0x160(%rbp), %xmm0
movl -0x164(%rbp), %ecx
movq -0x170(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x1, %edx
leaq -0x90(%rbp), %r8
callq 0x1c8d70
jmp 0x1e76d7
leaq -0x90(%rbp), %rdi
callq 0x1e0ab0
movq -0x8(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1ddc00
movl %eax, -0x174(%rbp)
jmp 0x1e76fb
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x1d9c20
jmp 0x1e770d
movl -0x174(%rbp), %edx
movq -0x180(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
leaq -0xb0(%rbp), %rcx
movl $0x1, %r8d
callq 0x1dd5d0
jmp 0x1e7735
leaq -0xb0(%rbp), %rdi
callq 0x1e0ab0
movq -0x8(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x1be0a0
jmp 0x1e7753
leaq -0xd8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1cae10
jmp 0x1e7768
leaq -0xc8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1b97f0
movsd %xmm0, -0x188(%rbp)
jmp 0x1e7785
leaq -0xd8(%rbp), %rdi
callq 0x1e0ab0
leaq -0xc8(%rbp), %rdi
callq 0x1cb520
movsd -0x188(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x1ddc00
movl %eax, -0x18c(%rbp)
jmp 0x1e77c5
movl -0x18c(%rbp), %esi
movq -0x198(%rbp), %rdi
callq 0x1ba280
movq %rax, -0x1a0(%rbp)
jmp 0x1e77e0
movq -0x1a0(%rbp), %rax
movq %rax, -0xe0(%rbp)
movsd -0xb8(%rbp), %xmm0
cvtsi2sdq -0xe0(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0xe8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e3aa0
movb %al, -0x1a1(%rbp)
jmp 0x1e781c
movb -0x1a1(%rbp), %al
testb $0x1, %al
jne 0x1e782b
jmp 0x1e7a54
leaq -0x109(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x1dfbb0
movq -0x1b0(%rbp), %rdx
leaq 0x4468bb(%rip), %rsi # 0x62e107
leaq -0x108(%rbp), %rdi
callq 0x1d5e00
jmp 0x1e785a
leaq -0x38(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x1bf930
jmp 0x1e786c
leaq -0x108(%rbp), %rdi
callq 0x1c4d10
leaq -0x109(%rbp), %rdi
callq 0x1cf450
leaq -0x131(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x1dfbb0
movq -0x1b8(%rbp), %rdx
leaq 0x44d25f(%rip), %rsi # 0x634b04
leaq -0x130(%rbp), %rdi
callq 0x1d5e00
jmp 0x1e78b3
leaq -0x80(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1bf930
jmp 0x1e78c5
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
movq 0x51042c(%rip), %rdi # 0x6f7d10
leaq 0x4438d7(%rip), %rsi # 0x62b1c2
callq 0x1cd8f0
movq %rax, -0x1c0(%rbp)
jmp 0x1e78f9
movq -0x1c0(%rbp), %rdi
movsd -0xe8(%rbp), %xmm0
callq 0x1e2ee0
movq %rax, -0x1c8(%rbp)
jmp 0x1e7916
movq -0x1c8(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x1e7929
jmp 0x1e7a54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
jmp 0x1e7a99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1e7a90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1e0ab0
jmp 0x1e7a90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1e7a87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1e0ab0
jmp 0x1e7a87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1e7a7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1e79db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1e0ab0
leaq -0xc8(%rbp), %rdi
callq 0x1cb520
jmp 0x1e7a7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1e7a12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x1c4d10
leaq -0x109(%rbp), %rdi
callq 0x1cf450
jmp 0x1e7a7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1e7a46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
jmp 0x1e7a7b
leaq -0xa0(%rbp), %rdi
callq 0x1e0ab0
leaq -0x80(%rbp), %rdi
callq 0x1bfef0
leaq -0x38(%rbp), %rdi
callq 0x1bfef0
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
leaq -0xa0(%rbp), %rdi
callq 0x1e0ab0
leaq -0x80(%rbp), %rdi
callq 0x1bfef0
leaq -0x38(%rbp), %rdi
callq 0x1bfef0
movq -0x50(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
79 | Omega_h::adapt(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | bool adapt(Mesh* mesh, AdaptOpts const& opts) {
ScopedTimer adapt_timer("adapt");
OMEGA_H_CHECK(mesh->family() == OMEGA_H_SIMPLEX);
auto t0 = now();
if (!pre_adapt(mesh, opts)) return false;
setup_conservation_tags(mesh, opts);
auto t1 = now();
satisfy_lengths(mesh, opts);
auto t2 = now();
snap_and_satisfy_quality(mesh, opts);
auto t3 = now();
correct_integral_errors(mesh, opts);
auto t4 = now();
mesh->set_parting(OMEGA_H_ELEM_BASED);
post_adapt(mesh, opts, t0, t1, t2, t3, t4);
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x44d3bd(%rip), %rsi # 0x634e87
xorl %eax, %eax
movl %eax, %edx
leaq -0x19(%rbp), %rdi
callq 0x1dc4d0
movq -0x10(%rbp), %rdi
callq 0x1e0020
movl %eax, -0x8c(%rbp)
jmp 0x1e7ae8
movl -0x8c(%rbp), %eax
cmpl $0x0, %eax
jne 0x1e7af5
jmp 0x1e7b32
leaq 0x44356c(%rip), %rdi # 0x62b068
leaq 0x4436d1(%rip), %rsi # 0x62b1d4
leaq 0x4435a8(%rip), %rdx # 0x62b0b2
xorl %eax, %eax
movl $0x112, %ecx # imm = 0x112
callq 0x1ce550
jmp 0x1e7b18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1d03d0
jmp 0x1e7ca4
callq 0x1c5a40
movq %rax, -0x98(%rbp)
jmp 0x1e7b40
movq -0x98(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e7cb0
movb %al, -0x99(%rbp)
jmp 0x1e7b60
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x1e7b7c
jmp 0x1e7b6c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x1e7c8d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c6000
jmp 0x1e7b8b
callq 0x1c5a40
movq %rax, -0xa8(%rbp)
jmp 0x1e7b99
movq -0xa8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e7e80
jmp 0x1e7bb3
callq 0x1c5a40
movq %rax, -0xb0(%rbp)
jmp 0x1e7bc1
movq -0xb0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e80c0
jmp 0x1e7bdb
callq 0x1c5a40
movq %rax, -0xb8(%rbp)
jmp 0x1e7be9
movq -0xb8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cce80
jmp 0x1e7c03
callq 0x1c5a40
movq %rax, -0xc0(%rbp)
jmp 0x1e7c11
movq -0xc0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1ddac0
jmp 0x1e7c2b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x80(%rbp), %r9
movq -0x88(%rbp), %r10
movq %rsp, %rax
movq %r10, (%rax)
callq 0x1e80f0
jmp 0x1e7c82
movb $0x1, -0x1(%rbp)
movl $0x1, -0x3c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1d03d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
80 | Omega_h::pre_adapt(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static bool pre_adapt(Mesh* mesh, AdaptOpts const& opts) {
validate(mesh, opts);
opts.xfer_opts.validate(mesh);
if (opts.verbosity >= EACH_ADAPT && !mesh->comm()->rank()) {
std::cout << "before adapting:\n";
}
if (print_adapt_status(mesh, opts)) return false;
if (opts.verbosity >= EXTRA_STATS) {
print_adapt_histograms(mesh, opts);
}
if ((opts.verbosity >= EACH_REBUILD) && !mesh->comm()->rank()) {
std::cout << "addressing edge lengths\n";
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e8690
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x1c0330
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %ecx
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x52(%rbp)
jl 0x1e7d2f
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1be0a0
movq -0x60(%rbp), %rdi
movb $0x1, -0x29(%rbp)
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x58(%rbp)
jmp 0x1e7d21
movl -0x58(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
movb %al, -0x61(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x1e7d3d
jmp 0x1e7d46
leaq -0x28(%rbp), %rdi
callq 0x1cb520
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x1e7d4f
jmp 0x1e7d86
movq 0x50ffba(%rip), %rdi # 0x6f7d10
leaq 0x443534(%rip), %rsi # 0x62b291
callq 0x1cd8f0
jmp 0x1e7d86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x1e7d78
jmp 0x1e7d81
leaq -0x28(%rbp), %rdi
callq 0x1cb520
jmp 0x1e7e6d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1dfd20
testb $0x1, %al
jne 0x1e7d99
jmp 0x1e7da2
movb $0x0, -0x1(%rbp)
jmp 0x1e7e5f
movq -0x18(%rbp), %rax
cmpl $0x3, 0x2c(%rax)
jl 0x1e7db9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d23c0
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %ecx
movb $0x0, -0x51(%rbp)
xorl %eax, %eax
cmpl $0x2, %ecx
movb %al, -0x62(%rbp)
jl 0x1e7e07
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1be0a0
movq -0x70(%rbp), %rdi
movb $0x1, -0x51(%rbp)
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x68(%rbp)
jmp 0x1e7df9
movl -0x68(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x62(%rbp)
movb -0x62(%rbp), %al
movb %al, -0x71(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x1e7e15
jmp 0x1e7e1e
leaq -0x50(%rbp), %rdi
callq 0x1cb520
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x1e7e27
jmp 0x1e7e5b
movq 0x50fee2(%rip), %rdi # 0x6f7d10
leaq 0x44346e(%rip), %rsi # 0x62b2a3
callq 0x1cd8f0
jmp 0x1e7e5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x1e7e50
jmp 0x1e7e59
leaq -0x50(%rbp), %rdi
callq 0x1cb520
jmp 0x1e7e6d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
81 | Omega_h::satisfy_lengths(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static void satisfy_lengths(Mesh* mesh, AdaptOpts const& opts) {
OMEGA_H_TIME_FUNCTION;
bool did_anything;
do {
did_anything = false;
if (opts.should_refine && refine_by_size(mesh, opts)) {
post_rebuild(mesh, opts);
did_anything = true;
}
if (opts.should_coarsen && coarsen_by_size(mesh, opts)) {
post_rebuild(mesh, opts);
did_anything = true;
}
} while (did_anything);
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1dfbb0
movq -0xc0(%rbp), %rdx
leaq 0x443201(%rip), %rsi # 0x62b0b2
leaq -0x78(%rbp), %rdi
callq 0x1d5e00
jmp 0x1e7ebc
leaq 0x4433b2(%rip), %rdx # 0x62b275
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1bb5a0
jmp 0x1e7ed2
leaq -0xb0(%rbp), %rdi
movl $0xae, %esi
callq 0x1d4960
jmp 0x1e7ee5
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x1ca480
jmp 0x1e7efb
leaq -0x38(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x443499(%rip), %rsi # 0x62b3a7
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x1e7f19
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
leaq -0xb0(%rbp), %rdi
callq 0x1c4d10
leaq -0x58(%rbp), %rdi
callq 0x1c4d10
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
movb $0x0, -0xb1(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0x1e804e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c41e0
movb %al, -0xc1(%rbp)
jmp 0x1e7f73
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x1e7f82
jmp 0x1e804e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e88b0
jmp 0x1e7f91
movb $0x1, -0xb1(%rbp)
jmp 0x1e804e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e8026
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e801d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e8014
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e8008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
leaq -0xb0(%rbp), %rdi
callq 0x1c4d10
leaq -0x58(%rbp), %rdi
callq 0x1c4d10
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
jmp 0x1e80b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
jmp 0x1e80b0
movq -0x10(%rbp), %rax
testb $0x1, 0x49(%rax)
je 0x1e808f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c6510
movb %al, -0xc2(%rbp)
jmp 0x1e806d
movb -0xc2(%rbp), %al
testb $0x1, %al
jne 0x1e8079
jmp 0x1e808f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e88b0
jmp 0x1e8088
movb $0x1, -0xb1(%rbp)
jmp 0x1e8091
testb $0x1, -0xb1(%rbp)
jne 0x1e7f49
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
82 | Omega_h::snap_and_satisfy_quality(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static void snap_and_satisfy_quality(Mesh* mesh, AdaptOpts const& opts) {
#ifdef OMEGA_H_USE_EGADS
if (opts.egads_model) {
ScopedTimer snap_timer("snap");
mesh->set_parting(OMEGA_H_GHOSTED);
auto warp = egads_get_snap_warp(
mesh, opts.egads_model, opts.verbosity >= EACH_REBUILD);
if (opts.should_smooth_snap) {
if (opts.verbosity >= EACH_REBUILD) {
std::cout << "Solving Laplacian of warp field...\n";
}
auto t0 = now();
warp =
solve_laplacian(mesh, warp, mesh->dim(), opts.snap_smooth_tolerance);
auto t1 = now();
if (opts.verbosity >= EACH_REBUILD) {
std::cout << "Solving Laplacian of warp field took " << (t1 - t0)
<< " seconds\n";
}
}
mesh->add_tag(VERT, "warp", mesh->dim(), warp);
while (warp_to_limit(mesh, opts, opts.allow_snap_failure)) {
if (!satisfy_quality(mesh, opts)) {
mesh->remove_tag(VERT, "warp");
break;
}
}
} else
#endif
satisfy_quality(mesh, opts);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e88e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
83 | Omega_h::post_adapt(Omega_h::Mesh*, Omega_h::AdaptOpts const&, Omega_h::Now, Omega_h::Now, Omega_h::Now, Omega_h::Now, Omega_h::Now) | static void post_adapt(
Mesh* mesh, AdaptOpts const& opts, Now t0, Now t1, Now t2, Now t3, Now t4) {
if (opts.verbosity == EACH_ADAPT) {
if (!mesh->comm()->rank()) std::cout << "after adapting:\n";
print_adapt_status(mesh, opts);
}
if (opts.verbosity >= EXTRA_STATS) print_adapt_histograms(mesh, opts);
if (opts.verbosity > SILENT && !mesh->comm()->rank()) {
std::cout << "addressing edge lengths took " << (t2 - t1) << " seconds\n";
}
if (opts.verbosity > SILENT && !mesh->comm()->rank()) {
#ifdef OMEGA_H_USE_EGADS
if (opts.egads_model) std::cout << "snapping while ";
#endif
std::cout << "addressing element qualities took " << (t3 - t2);
std::cout << " seconds\n";
}
if (opts.verbosity > SILENT && should_conserve_any(mesh, opts.xfer_opts) &&
!mesh->comm()->rank()) {
std::cout << "correcting integral errors took " << (t4 - t3)
<< " seconds\n";
}
Now t5 = now();
if (opts.verbosity > SILENT && !mesh->comm()->rank()) {
std::cout << "adapting took " << (t5 - t0) << " seconds\n\n";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq 0x10(%rbp), %rax
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x1e81be
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1be0a0
movq -0x110(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x104(%rbp)
jmp 0x1e8159
movl -0x104(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x111(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1cb520
movb -0x111(%rbp), %al
testb $0x1, %al
jne 0x1e8182
jmp 0x1e81b1
movq 0x50fb87(%rip), %rdi # 0x6f7d10
leaq 0x443270(%rip), %rsi # 0x62b400
callq 0x1cd8f0
jmp 0x1e81b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1cb520
jmp 0x1e8678
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1dfd20
movq -0x38(%rbp), %rax
cmpl $0x3, 0x2c(%rax)
jl 0x1e81d5
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1d23c0
movq -0x38(%rbp), %rax
movl 0x2c(%rax), %ecx
movb $0x0, -0x69(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x112(%rbp)
jle 0x1e8235
movq -0x30(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x1be0a0
movq -0x120(%rbp), %rdi
movb $0x1, -0x69(%rbp)
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x118(%rbp)
jmp 0x1e8221
movl -0x118(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x112(%rbp)
movb -0x112(%rbp), %al
movb %al, -0x121(%rbp)
testb $0x1, -0x69(%rbp)
jne 0x1e8249
jmp 0x1e8252
leaq -0x68(%rbp), %rdi
callq 0x1cb520
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0x1e825e
jmp 0x1e82d4
movq 0x50faab(%rip), %rdi # 0x6f7d10
leaq 0x4431a5(%rip), %rsi # 0x62b411
callq 0x1cd8f0
movq %rax, -0x130(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x1bd070
movq -0x130(%rbp), %rdi
callq 0x1e2ee0
movq %rax, %rdi
leaq 0x443184(%rip), %rsi # 0x62b42f
callq 0x1cd8f0
jmp 0x1e82d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x69(%rbp)
jne 0x1e82c6
jmp 0x1e82cf
leaq -0x68(%rbp), %rdi
callq 0x1cb520
jmp 0x1e8678
movq -0x38(%rbp), %rax
movl 0x2c(%rax), %ecx
movb $0x0, -0x91(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x131(%rbp)
jle 0x1e833d
movq -0x30(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x1be0a0
movq -0x140(%rbp), %rdi
movb $0x1, -0x91(%rbp)
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x138(%rbp)
jmp 0x1e8329
movl -0x138(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x131(%rbp)
movb -0x131(%rbp), %al
movb %al, -0x141(%rbp)
testb $0x1, -0x91(%rbp)
jne 0x1e8354
jmp 0x1e8360
leaq -0x90(%rbp), %rdi
callq 0x1cb520
movb -0x141(%rbp), %al
testb $0x1, %al
jne 0x1e836f
jmp 0x1e83fb
movq 0x50f99a(%rip), %rdi # 0x6f7d10
leaq 0x4430bc(%rip), %rsi # 0x62b439
callq 0x1cd8f0
movq %rax, -0x150(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x1bd070
movq -0x150(%rbp), %rdi
callq 0x1e2ee0
movq 0x50f94b(%rip), %rdi # 0x6f7d10
leaq 0x443063(%rip), %rsi # 0x62b42f
callq 0x1cd8f0
jmp 0x1e83fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x91(%rbp)
jne 0x1e83ea
jmp 0x1e83f6
leaq -0x90(%rbp), %rdi
callq 0x1cb520
jmp 0x1e8678
movq -0x38(%rbp), %rax
movl 0x2c(%rax), %ecx
movb $0x0, -0xb9(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x151(%rbp)
jle 0x1e8486
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x50, %rsi
callq 0x1da830
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x151(%rbp)
jne 0x1e8438
jmp 0x1e8486
movq -0x30(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x1be0a0
movq -0x160(%rbp), %rdi
movb $0x1, -0xb9(%rbp)
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x158(%rbp)
jmp 0x1e8472
movl -0x158(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x151(%rbp)
movb -0x151(%rbp), %al
movb %al, -0x161(%rbp)
testb $0x1, -0xb9(%rbp)
jne 0x1e849d
jmp 0x1e84a9
leaq -0xb8(%rbp), %rdi
callq 0x1cb520
movb -0x161(%rbp), %al
testb $0x1, %al
jne 0x1e84b8
jmp 0x1e8540
movq 0x50f851(%rip), %rdi # 0x6f7d10
leaq 0x442f96(%rip), %rsi # 0x62b45c
callq 0x1cd8f0
movq %rax, -0x170(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xc8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x1bd070
movq -0x170(%rbp), %rdi
callq 0x1e2ee0
movq %rax, %rdi
leaq 0x442f1e(%rip), %rsi # 0x62b42f
callq 0x1cd8f0
jmp 0x1e8540
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0xb9(%rbp)
jne 0x1e852f
jmp 0x1e853b
leaq -0xb8(%rbp), %rdi
callq 0x1cb520
jmp 0x1e8678
callq 0x1c5a40
movq %rax, -0xd8(%rbp)
movq -0x38(%rbp), %rax
movl 0x2c(%rax), %ecx
movb $0x0, -0xe9(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x171(%rbp)
jle 0x1e85b5
movq -0x30(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1be0a0
movq -0x180(%rbp), %rdi
movb $0x1, -0xe9(%rbp)
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x178(%rbp)
jmp 0x1e85a1
movl -0x178(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x171(%rbp)
movb -0x171(%rbp), %al
movb %al, -0x181(%rbp)
testb $0x1, -0xe9(%rbp)
jne 0x1e85cc
jmp 0x1e85d8
leaq -0xe8(%rbp), %rdi
callq 0x1cb520
movb -0x181(%rbp), %al
testb $0x1, %al
jne 0x1e85e7
jmp 0x1e866f
movq 0x50f722(%rip), %rdi # 0x6f7d10
leaq 0x442e88(%rip), %rsi # 0x62b47d
callq 0x1cd8f0
movq %rax, -0x190(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x100(%rbp), %rsi
callq 0x1bd070
movq -0x190(%rbp), %rdi
callq 0x1e2ee0
movq %rax, %rdi
leaq 0x442e49(%rip), %rsi # 0x62b48c
callq 0x1cd8f0
jmp 0x1e866f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0xe9(%rbp)
jne 0x1e8661
jmp 0x1e866d
leaq -0xe8(%rbp), %rdi
callq 0x1cb520
jmp 0x1e8678
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
84 | Omega_h::validate(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static void validate(Mesh* mesh, AdaptOpts const& opts) {
OMEGA_H_CHECK(0.0 <= opts.min_quality_allowed);
OMEGA_H_CHECK(opts.min_quality_allowed <= opts.min_quality_desired);
OMEGA_H_CHECK(opts.min_quality_desired <= 1.0);
OMEGA_H_CHECK(opts.nsliver_layers >= 0);
OMEGA_H_CHECK(opts.nsliver_layers < 100);
auto mq = min_fixable_quality(mesh, opts);
if (mq < opts.min_quality_allowed && !mesh->comm()->rank()) {
std::cout << "WARNING: worst input element has quality " << mq
<< " but minimum allowed is " << opts.min_quality_allowed << "\n";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1e86b4
jmp 0x1e86d5
leaq 0x4429ad(%rip), %rdi # 0x62b068
leaq 0x442bfa(%rip), %rsi # 0x62b2bc
leaq 0x4429e9(%rip), %rdx # 0x62b0b2
movl $0x8d, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x1e86ef
jmp 0x1e8710
leaq 0x442972(%rip), %rdi # 0x62b068
leaq 0x442bdf(%rip), %rsi # 0x62b2dc
leaq 0x4429ae(%rip), %rdx # 0x62b0b2
movl $0x8e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x10(%rbp), %rax
movsd 0x4428ec(%rip), %xmm0 # 0x62b008
ucomisd 0x20(%rax), %xmm0
jb 0x1e8725
jmp 0x1e8746
leaq 0x44293c(%rip), %rdi # 0x62b068
leaq 0x442bde(%rip), %rsi # 0x62b311
leaq 0x442978(%rip), %rdx # 0x62b0b2
movl $0x8f, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jl 0x1e8752
jmp 0x1e8773
leaq 0x44290f(%rip), %rdi # 0x62b068
leaq 0x442bd1(%rip), %rsi # 0x62b331
leaq 0x44294b(%rip), %rdx # 0x62b0b2
movl $0x90, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x10(%rbp), %rax
cmpl $0x64, 0x28(%rax)
jge 0x1e877f
jmp 0x1e87a0
leaq 0x4428e2(%rip), %rdi # 0x62b068
leaq 0x442bbd(%rip), %rsi # 0x62b34a
leaq 0x44291e(%rip), %rdx # 0x62b0b2
movl $0x91, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dce50
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm1
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x3d(%rbp)
jbe 0x1e8808
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1be0a0
movq -0x50(%rbp), %rdi
movb $0x1, -0x29(%rbp)
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x44(%rbp)
jmp 0x1e87fa
movl -0x44(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
movb %al, -0x51(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x1e8816
jmp 0x1e881f
leaq -0x28(%rbp), %rdi
callq 0x1cb520
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1e8828
jmp 0x1e8898
movq 0x50f4e1(%rip), %rdi # 0x6f7d10
leaq 0x442b2e(%rip), %rsi # 0x62b364
callq 0x1cd8f0
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x1e2ee0
movq %rax, %rdi
leaq 0x442b3c(%rip), %rsi # 0x62b38e
callq 0x1cd8f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x1e2ee0
movq %rax, %rdi
leaq 0x448b0c(%rip), %rsi # 0x63137e
callq 0x1cd8f0
jmp 0x1e8898
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x1e888d
jmp 0x1e8896
leaq -0x28(%rbp), %rdi
callq 0x1cb520
jmp 0x1e889e
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
85 | Omega_h::post_rebuild(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static void post_rebuild(Mesh* mesh, AdaptOpts const& opts) {
if (opts.verbosity >= EACH_REBUILD) print_adapt_status(mesh, opts);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x2c(%rax)
jl 0x1e88d7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dfd20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
86 | Omega_h::satisfy_quality(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static bool satisfy_quality(Mesh* mesh, AdaptOpts const& opts) {
OMEGA_H_TIME_FUNCTION;
if (min_fixable_quality(mesh, opts) >= opts.min_quality_desired) return true;
if ((opts.verbosity >= EACH_REBUILD) && can_print(mesh)) {
std::cout << "addressing element qualities\n";
}
do {
if (opts.should_swap && swap_edges(mesh, opts)) {
post_rebuild(mesh, opts);
continue;
}
if (opts.should_coarsen_slivers && coarsen_slivers(mesh, opts)) {
post_rebuild(mesh, opts);
continue;
}
if ((opts.verbosity > SILENT) && can_print(mesh)) {
std::cout << "could not satisfy quality\n";
}
return false;
} while (min_fixable_quality(mesh, opts) < opts.min_quality_desired);
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1dfbb0
movq -0xc8(%rbp), %rdx
leaq 0x44279e(%rip), %rsi # 0x62b0b2
leaq -0x80(%rbp), %rdi
callq 0x1d5e00
jmp 0x1e891f
leaq 0x44294f(%rip), %rdx # 0x62b275
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1bb5a0
jmp 0x1e8935
leaq -0xb8(%rbp), %rdi
movl $0xbe, %esi
callq 0x1d4960
jmp 0x1e8948
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x1ca480
jmp 0x1e895e
leaq -0x40(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x442a46(%rip), %rsi # 0x62b3b7
leaq -0x19(%rbp), %rdi
callq 0x1dc4d0
jmp 0x1e897c
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
leaq -0xb8(%rbp), %rdi
callq 0x1c4d10
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1dce50
movsd %xmm0, -0xd0(%rbp)
jmp 0x1e89c6
movsd -0xd0(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x20(%rax), %xmm0
jb 0x1e8aaa
movb $0x1, -0x1(%rbp)
movl $0x1, -0xbc(%rbp)
jmp 0x1e8bf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1e8a79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1e8a70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1e8a67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1e8a5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
leaq -0xb8(%rbp), %rdi
callq 0x1c4d10
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
jmp 0x1e8c0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1d03d0
jmp 0x1e8c0a
movq -0x18(%rbp), %rax
cmpl $0x2, 0x2c(%rax)
jl 0x1e8ae8
movq -0x10(%rbp), %rdi
callq 0x1e3aa0
movb %al, -0xd1(%rbp)
jmp 0x1e8ac5
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x1e8ad1
jmp 0x1e8ae8
movq 0x50f238(%rip), %rdi # 0x6f7d10
leaq 0x4428e8(%rip), %rsi # 0x62b3c7
callq 0x1cd8f0
jmp 0x1e8ae6
jmp 0x1e8ae8
jmp 0x1e8aea
movq -0x18(%rbp), %rax
testb $0x1, 0x4a(%rax)
je 0x1e8b29
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cec80
movb %al, -0xd2(%rbp)
jmp 0x1e8b09
movb -0xd2(%rbp), %al
testb $0x1, %al
jne 0x1e8b15
jmp 0x1e8b29
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e88b0
jmp 0x1e8b24
jmp 0x1e8bb3
movq -0x18(%rbp), %rax
testb $0x1, 0x4b(%rax)
je 0x1e8b65
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bba30
movb %al, -0xd3(%rbp)
jmp 0x1e8b48
movb -0xd3(%rbp), %al
testb $0x1, %al
jne 0x1e8b54
jmp 0x1e8b65
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e88b0
jmp 0x1e8b63
jmp 0x1e8bb3
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x1e8ba3
movq -0x10(%rbp), %rdi
callq 0x1e3aa0
movb %al, -0xd4(%rbp)
jmp 0x1e8b80
movb -0xd4(%rbp), %al
testb $0x1, %al
jne 0x1e8b8c
jmp 0x1e8ba3
movq 0x50f17d(%rip), %rdi # 0x6f7d10
leaq 0x44284b(%rip), %rsi # 0x62b3e5
callq 0x1cd8f0
jmp 0x1e8ba1
jmp 0x1e8ba3
movb $0x0, -0x1(%rbp)
movl $0x1, -0xbc(%rbp)
jmp 0x1e8bf3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1dce50
movsd %xmm0, -0xe0(%rbp)
jmp 0x1e8bca
movsd -0xe0(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd %xmm1, %xmm0
ja 0x1e8aea
movb $0x1, -0x1(%rbp)
movl $0x1, -0xbc(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1d03d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adapt.cpp |
87 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Omega_h_Transfer, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h_Transfer>>>::map() | map() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d2910
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
88 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::map() | map() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dbb20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
89 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Omega_h::VarCompareOpts, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::VarCompareOpts>>>::map() | map() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c5d60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
90 | std::shared_ptr<Omega_h::UserTransfer>::shared_ptr() | constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
91 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Omega_h_Transfer, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h_Transfer>>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return _M_t.begin(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e3c80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
92 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Omega_h_Transfer, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h_Transfer>>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return _M_t.end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cbe90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
93 | std::operator!=(std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h_Transfer>> const&, std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h_Transfer>> const&) | bool
operator!=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT
{ return __x._M_node != __y._M_node; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setne %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
94 | std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h_Transfer>>::operator*() const | reference
operator*() const _GLIBCXX_NOEXCEPT
{ return *static_cast<_Link_type>(_M_node)->_M_valptr(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1d4f30
movq %rax, -0x10(%rbp)
jmp 0x1e8d4e
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
95 | Omega_h::Mesh::dim() const | inline Int dim() const {
OMEGA_H_CHECK(0 <= dim_ && dim_ <= 3);
return dim_;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpl 0x4(%rcx), %eax
jg 0x1e8d87
movq -0x10(%rbp), %rax
cmpl $0x3, 0x4(%rax)
jg 0x1e8d87
jmp 0x1e8da8
leaq 0x4422da(%rip), %rdi # 0x62b068
leaq 0x442461(%rip), %rsi # 0x62b1f6
leaq 0x442471(%rip), %rdx # 0x62b20d
movl $0x33, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mesh.hpp |
96 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::count(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | size_type
count(const key_type& __x) const
{ return _M_t.find(__x) == _M_t.end() ? 0 : 1; } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1da930
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1d04b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1d4630
movb %al, %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
97 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1da930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
98 | std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::operator->() const | pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return static_cast<_Link_type>(_M_node)->_M_valptr(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1c7d40
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
99 | std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h_Transfer>>::operator++() | _Self&
operator++() _GLIBCXX_NOEXCEPT
{
_M_node = _Rb_tree_increment(_M_node);
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x1d1740
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
End of preview. Expand
in Data Studio
The raw data for decompile-bench, with 100M items. Please refer to LLM4Decompile for details.
- Downloads last month
- 76