diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..8331996 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,14 @@ +{ + "configurations": [ + { + "type": "cppdbg", + "request": "launch", + "MIMode": "gdb", + "miDebuggerPath": "/usr/bin/gdb", + "name": "QEMU", + "program": "${workspaceFolder}/kernel/bin-x86_64/kernel", + "miDebuggerServerAddress": "127.0.0.1:1234", + "cwd": "${workspaceFolder}" + } + ] +} \ No newline at end of file diff --git a/GNUmakefile b/GNUmakefile index 9751975..5d338f6 100644 --- a/GNUmakefile +++ b/GNUmakefile @@ -6,7 +6,7 @@ MAKEFLAGS += -rR ARCH := x86_64 # Default user QEMU flags. These are appended to the QEMU command calls. -QEMUFLAGS := -m 2G +QEMUFLAGS := -m 2G -s -S override IMAGE_NAME := template-$(ARCH) diff --git a/kernel/src/Common/Panic.cpp b/kernel/src/Common/Panic.cpp index e3a99b2..d41f027 100644 --- a/kernel/src/Common/Panic.cpp +++ b/kernel/src/Common/Panic.cpp @@ -7,12 +7,11 @@ void Panic(const char *meditationString, System::PanicFrame* frame) { #if defined (__x86_64__) if (frame != nullptr) { + kerr << "\t" << "InterruptVector: " << "0x" << base::hex << frame->InterruptVector << "\n"; if (frame->InterruptVector == 0xE) { // In case of #PF the CPU pushes an error code to the frame auto pf_frame = (System::PageFaultPanicFrame*)frame; frame = (System::PanicFrame*)&pf_frame->IP; - kerr << "\t" << "InterruptVector: " << "0x" << base::hex << 0xE << "\n"; - /* Page fault error details */ kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n"; kerr << "\t" << "PageFaultWrite: " << base::dec << pf_frame->PageFaultError.Write << "\n"; @@ -23,9 +22,11 @@ void Panic(const char *meditationString, System::PanicFrame* frame) { kerr << "\t" << "PageFaultShadowStack: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n"; kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n"; } - else - { - kerr << "\t" << "InterruptVector: " << "0x" << base::hex << frame->InterruptVector << "\n"; + else if (frame->InterruptVector == 0xD) { + auto gpf_frame = (System::GPFPanicFrame*)frame; + frame = (System::PanicFrame*)&frame->IP; + + kerr << "\t" << "ErrorCode: " << base::dec << gpf_frame->GeneralProtectionFaultError << "\n"; } kerr << "\t" << "InstructionPointer: " << "0x" << base::hex << frame->IP << "\n"; diff --git a/kernel/src/Common/Panic.hpp b/kernel/src/Common/Panic.hpp index a6c52fc..0b77ce9 100644 --- a/kernel/src/Common/Panic.hpp +++ b/kernel/src/Common/Panic.hpp @@ -1,5 +1,5 @@ #pragma once #include -#include +#include void Panic(const char *meditationString, System::PanicFrame* frame); \ No newline at end of file diff --git a/kernel/src/CppLib/CString.cpp b/kernel/src/CppLib/CString.cpp new file mode 100644 index 0000000..f777b43 --- /dev/null +++ b/kernel/src/CppLib/CString.cpp @@ -0,0 +1,42 @@ +/* + * CString.cpp + * C++ string tooling + * Copyright (c) 2025 Daniel Hammer +*/ + +#include "CString.hpp" +#include "Stream.hpp" + +#include +#include + +namespace kcp { + vector splitstr(const char* str, char delimiter) { + vector result; + cstringstream current_stream = cstringstream(); + + do { + if (*str == delimiter || *str == '\0') { + auto cstr = current_stream.cstr(); + auto cstr_len = Lib::strlen(cstr); + + result.push_back((const char*)Memory::g_heap->Request(sizeof(char) * (cstr_len + 1))); + + memcpy((void*)result.at(result.size() - 1), cstr, cstr_len + 1); + + if (*str == '\0') { + break; + } + + current_stream = cstringstream(); + str++; + continue; + } + + current_stream << (char)*str; + str++; + } while (*str != '\0'); + + return result; + } +}; \ No newline at end of file diff --git a/kernel/src/CppLib/CString.hpp b/kernel/src/CppLib/CString.hpp new file mode 100644 index 0000000..6d450dc --- /dev/null +++ b/kernel/src/CppLib/CString.hpp @@ -0,0 +1,12 @@ +/* + * CString.cpp + * C++ string tooling + * Copyright (c) 2025 Daniel Hammer +*/ + +#pragma once +#include + +namespace kcp { + vector splitstr(const char* str, char delimiter); +}; \ No newline at end of file diff --git a/kernel/src/CppLib/Stream.cpp b/kernel/src/CppLib/Stream.cpp index d50e71c..18ad53a 100644 --- a/kernel/src/CppLib/Stream.cpp +++ b/kernel/src/CppLib/Stream.cpp @@ -6,8 +6,8 @@ #include "Stream.hpp" #include -#include -#include +#include +#include kcp::cstringstream::cstringstream() { @@ -21,7 +21,7 @@ kcp::cstringstream::~cstringstream() } kcp::cstringstream& kcp::cstringstream::operator<<(char c) { - this->string = (const char *)Memory::g_heap->Realloc((void *)this->string, this->size + 1); + this->string = (char *)Memory::g_heap->Realloc((void *)this->string, this->size + 2); if (!this->string) { diff --git a/kernel/src/CppLib/Stream.hpp b/kernel/src/CppLib/Stream.hpp index d54c143..3e3e32a 100644 --- a/kernel/src/CppLib/Stream.hpp +++ b/kernel/src/CppLib/Stream.hpp @@ -20,7 +20,7 @@ namespace kcp { }; class cstringstream { - const char* string; + char* string; std::size_t size; base current_base = base::dec; diff --git a/kernel/src/CppLib/Vector.hpp b/kernel/src/CppLib/Vector.hpp index 2ce5ae4..77cde59 100644 --- a/kernel/src/CppLib/Vector.hpp +++ b/kernel/src/CppLib/Vector.hpp @@ -6,7 +6,7 @@ #pragma once #include -#include +#include #include namespace kcp @@ -24,11 +24,12 @@ namespace kcp array = nullptr; } - T operator[](std::size_t position) + T& operator[](std::size_t position) { if (position > (sz - 1)) { kerr << "Vector out of bounds caught!" << Kt::newline; - return T{}; + + return at(0); } else { @@ -36,13 +37,17 @@ namespace kcp } } - T at(std::int64_t position) { + T& at(std::int64_t position) { return this->operator[](position); } - void push_back(T value) { + size_t push_back(T value) { + size_t _sz = sz; + array = (T *)Memory::g_heap->Realloc(array, sizeof(T) * (sz + 1)); array[sz++] = value; + + return _sz; } T* get_array() diff --git a/kernel/src/Hal/GDT.cpp b/kernel/src/Hal/GDT.cpp index e4f28ec..febd462 100644 --- a/kernel/src/Hal/GDT.cpp +++ b/kernel/src/Hal/GDT.cpp @@ -3,7 +3,7 @@ */ #include "GDT.hpp" -#include "../Terminal/terminal.hpp" +#include "../Terminal/Terminal.hpp" // Limine loads a GDT of course, (CS = 0x28) but we will need to make a TSS someday... therefore we load our own now @@ -14,7 +14,7 @@ namespace Hal { BasicGDT kernelGDT{}; void PrepareGDT() { - kout << "[Hal] GDT at " << base::hex << (uint64_t)&kernelGDT << "\n"; + kout << "HardwareAbstraction: GDT at " << base::hex << (uint64_t)&kernelGDT << "\n"; kernelGDT = { // Code segment offset 0x08 // Data segment offset 0x10 @@ -61,10 +61,10 @@ namespace Hal { void BridgeLoadGDT() { // Puts the GDT pointer structure into the GDTR - kout << "[Hal] Setting GDTR" << Kt::newline; + kout << "HardwareAbstraction: Setting GDTR" << Kt::newline; LoadGDT(&gdtPointer); - kout << "[Hal] Reloading segments" << Kt::newline; + kout << "HardwareAbstraction: Reloading segments" << Kt::newline; ReloadSegments(); } }; \ No newline at end of file diff --git a/kernel/src/Hal/IDT.cpp b/kernel/src/Hal/IDT.cpp index 3dfeaf3..68ce764 100644 --- a/kernel/src/Hal/IDT.cpp +++ b/kernel/src/Hal/IDT.cpp @@ -16,6 +16,7 @@ namespace Hal { constexpr auto TrapGate = 0x8F; InterruptDescriptor* IDT; + InterruptDescriptor InterruptDescriptorTable[255]{}; IDTRStruct IDTR{}; const char* ExceptionStrings[] = { @@ -55,12 +56,12 @@ namespace Hal { template __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) { - kcp::cstringstream stream; - stream << "Caught " << base::hex << "0x" << i << " " << ExceptionStrings[i] << " in kernel"; + // kcp::cstringstream stream; + // stream << "Caught " << base::hex << "0x" << i << " " << ExceptionStrings[i] << " in kernel"; frame->InterruptVector = i; - Panic(stream.cstr(), frame); + Panic(ExceptionStrings[i], frame); } void LoadIDT(IDTRStruct& idtr) { @@ -112,16 +113,16 @@ namespace Hal { struct SetHandler {static void run() {}}; void IDTInitialize() { - IDT = (InterruptDescriptor*)Memory::g_heap->Request(4096); + IDT = (InterruptDescriptor*)&InterruptDescriptorTable; IDTR.Limit = 0x0FF; IDTR.Base = (uint64_t)&IDT; SetHandler<0, 31>::run(); - kout << "[Hal] Created exception interrupt vectors" << "\n"; + kout << "HardwareAbstraction: Created exception interrupt vectors" << "\n"; LoadIDT(IDTR); - kout << "[Hal] Loaded new IDT" << "\n"; + kout << "HardwareAbstraction: Loaded new IDT" << "\n"; } }; \ No newline at end of file diff --git a/kernel/src/Libraries/string.cpp b/kernel/src/Libraries/String.cpp similarity index 98% rename from kernel/src/Libraries/string.cpp rename to kernel/src/Libraries/String.cpp index 630e16e..0bac1a4 100644 --- a/kernel/src/Libraries/string.cpp +++ b/kernel/src/Libraries/String.cpp @@ -1,4 +1,4 @@ -#include "string.hpp" +#include "String.hpp" #include #include diff --git a/kernel/src/Libraries/string.hpp b/kernel/src/Libraries/String.hpp similarity index 100% rename from kernel/src/Libraries/string.hpp rename to kernel/src/Libraries/String.hpp diff --git a/kernel/src/main.cpp b/kernel/src/Main.cpp similarity index 60% rename from kernel/src/main.cpp rename to kernel/src/Main.cpp index a63b5ec..71294ee 100644 --- a/kernel/src/main.cpp +++ b/kernel/src/Main.cpp @@ -9,19 +9,23 @@ #include #include -#include -#include +#include +#include #include #include #include #include +#include #include #include +#include #include #include +#include + #include using namespace Kt; @@ -39,7 +43,6 @@ extern void (*__init_array[])(); extern void (*__init_array_end[])(); extern "C" void kmain() { - // Ensure the bootloader actually understands our base revision (see spec). if (LIMINE_BASE_REVISION_SUPPORTED == false) { hcf(); } @@ -49,19 +52,25 @@ extern "C" void kmain() { __init_array[i](); } - // Ensure we got a framebuffer. if (framebuffer_request.response == nullptr || framebuffer_request.response->framebuffer_count < 1) { hcf(); } - // Fetch the first framebuffer. limine_framebuffer *framebuffer{framebuffer_request.response->framebuffers[0]}; - // Initialize the terminal - Kt::Initialize((uint32_t*)framebuffer->address, framebuffer->width, framebuffer->height, framebuffer->pitch, framebuffer->red_mask_size, framebuffer->red_mask_shift, - framebuffer->green_mask_size, framebuffer->green_mask_shift, - framebuffer->blue_mask_size, framebuffer->blue_mask_shift); + Kt::Initialize( + (uint32_t*)framebuffer->address, + framebuffer->width, + framebuffer->height, + framebuffer->pitch, + framebuffer->red_mask_size, + framebuffer->red_mask_shift, + framebuffer->green_mask_size, + framebuffer->green_mask_shift, + framebuffer->blue_mask_size, + framebuffer->blue_mask_shift + ); #if defined (__x86_64__) Hal::PrepareGDT(); @@ -69,20 +78,10 @@ extern "C" void kmain() { #endif uint64_t hhdm_offset = hhdm_request.response->offset; - - kout << "[Mem] HHDM offset: 0x" << base::hex << hhdm_offset << newline; - Memory::HHDMBase = hhdm_offset; - if (!system_table_request. response || !system_table_request.response->address) { - kout << "[Mp] Firmware type: PC BIOS" << newline; - } else { - kout << "[Mp] Firmware type: EFI" << newline; - kout << "[Efi] EFI system table at 0x" << base::hex << (uint64_t)system_table_request.response->address << newline; - } - if (memmap_request.response != nullptr) { - kout << "[Mem] Creating Allocator for system conventional memory" << newline; + kout << "MemoryManagement: Creating global HeapAllocator" << newline; auto result = Memory::Scan(memmap_request.response); auto allocator = Memory::HeapAllocator(result); @@ -96,9 +95,7 @@ extern "C" void kmain() { Hal::IDTInitialize(); #endif - int*x =(int*)0xffffffff; - - *x=0; - + int*a = (int*)0xffffff; + *a=10; hcf(); } diff --git a/kernel/src/Memory/Heap.cpp b/kernel/src/Memory/Heap.cpp index 358616e..eeb19c9 100644 --- a/kernel/src/Memory/Heap.cpp +++ b/kernel/src/Memory/Heap.cpp @@ -9,152 +9,43 @@ #include "HHDM.hpp" #include -#include +#include +#include +#include + +#include namespace Memory { + constexpr size_t metadata_size = 8; // 8 bytes + HeapAllocator::HeapAllocator(LargestSection section) { - g_section = section; - - Block *current_ref{&head}; - Block *start_block_ptr {(Block *)HHDM(section.address)}; - Block& start_block = *start_block_ptr; - - start_block = Block { - .size = section.size, - .next = nullptr - }; - - *start_block_ptr = start_block; - - current_ref->next = start_block_ptr; - - kout << "[Mem] HeapAllocator object created for memory section starting at 0x" << base::hex << section.address << Kt::newline; + kout << "HeapAllocator: constructor called" << Kt::newline; } - void* HeapAllocator::Request(size_t size, bool phys) { - Block* current_block_ptr{head.next}; - Block* current_prev_ptr{(Block *)&head}; - - while (true) { - if (current_block_ptr == nullptr) { - kerr << "A HeapAllocator was forced to return a Null pointer. (1)" << Kt::newline; - return nullptr; - } - - if (current_prev_ptr == nullptr) { - kerr << "An HeapAllocator was forced to return a Null pointer. (2)" << Kt::newline; - return nullptr; - } - - size_t descriptor_size = 8; - size_t total_size = size + descriptor_size; - - if (current_block_ptr->size >= total_size) { - Block block_copy = *current_block_ptr; - BlockDescriptor* descriptor {(BlockDescriptor *)current_block_ptr}; - descriptor->block_size = size; - - void* block_start = (void *)((uint64_t)current_block_ptr + descriptor_size); - - if (!block_copy.size) { - current_prev_ptr->next = block_copy.next; - } - else - { - block_copy.size -= total_size; - - current_prev_ptr->next = (Block *)(uint64_t)descriptor + total_size; - *current_prev_ptr->next = block_copy; - } - - if (phys) { - return (void *)SubHHDM(current_block_ptr); - } - - return (void *)block_start; - } else { - if (current_block_ptr->next != nullptr) { - current_prev_ptr = current_block_ptr; - current_block_ptr = current_block_ptr->next; - - continue; - } else { - kerr << "An HeapAllocator was forced to return a Null pointer. (3)" << Kt::newline; - return nullptr; - } - } - - if (current_block_ptr != nullptr) { - if (current_block_ptr->next == nullptr) { - kerr << "An HeapAllocator was forced to return a Null pointer. (4)" << Kt::newline; - return nullptr; - } - - current_block_ptr = current_block_ptr->next; - } else - { - kerr << "An HeapAllocator was forced to return a Null pointer. (5)" << Kt::newline; - return nullptr; - } - } - + void* HeapAllocator::Request(size_t size) { return nullptr; } void* HeapAllocator::Realloc(void* ptr, size_t size) { - void *new_block = this->Request(size); - - if (ptr == nullptr) { - return new_block; - } - - if (new_block == nullptr) { - kerr << "HeapAllocator: Reallocation failed due to memory starvation" << Kt::newline; - return nullptr; - } - - BlockDescriptor* descriptor = (BlockDescriptor*)((uint64_t)ptr - 8); - - memcpy(new_block, ptr, descriptor->block_size); - - this->Free(ptr); - - return new_block; + return nullptr; } - void HeapAllocator::Free(void *pagePtr) { - if (!IsHDDMVirtAddr((uint64_t)pagePtr)) { - pagePtr = (void *)HHDM(pagePtr); - } + void HeapAllocator::Free(void* ptr) { - BlockDescriptor* descriptor_ptr = (BlockDescriptor*)((uint64_t)pagePtr - 8); - BlockDescriptor descriptor = *descriptor_ptr; - - Block* fmrNext = head.next; - Block* blockPtr = (Block *)pagePtr; - - // Merge the descriptor with the block - Block* base = (Block *)((uint64_t)blockPtr - 8); - head.next = base; - - // Set the full size - base->size = descriptor.block_size + 8; - - // Attach the merged block to the structure - head.next->next = fmrNext; } // Traverses the Allocator's linked list for debugging void HeapAllocator::Walk() { - Block* current = {head.next}; - size_t i{0}; + // Node* current = {head.next}; + // size_t i{0}; - while (current != nullptr) { - kout << "Block " << base::dec << i << " {" << current->size << " bytes & address 0x" << base::hex << (uint64_t)current << "}" << Kt::newline; - current = current->next; - i++; - } + // while (current != nullptr) { + // kout << "Block " << base::dec << i << " {" << current->size << " bytes & address 0x" << base::hex << (uint64_t)current << "}" << Kt::newline; + // current = current->next; + // i++; + // } } + }; \ No newline at end of file diff --git a/kernel/src/Memory/Heap.hpp b/kernel/src/Memory/Heap.hpp index dcdc0cd..b551524 100644 --- a/kernel/src/Memory/Heap.hpp +++ b/kernel/src/Memory/Heap.hpp @@ -5,19 +5,20 @@ namespace Memory { class HeapAllocator { LargestSection g_section; - struct Block { + struct Node { size_t size; - Block* next; + Node* next; }; - struct BlockDescriptor { - size_t block_size; + struct Metadata { + size_t size; }; - Block head; + Node head{0, 0}; + public: HeapAllocator(LargestSection section); - void* Request(size_t size, bool phys = false); + void* Request(size_t size); void* Realloc(void* ptr, size_t size); void Free(void *pagePtr); void Walk(); diff --git a/kernel/src/Memory/Memmap.cpp b/kernel/src/Memory/Memmap.cpp index 15937ff..5429c61 100644 --- a/kernel/src/Memory/Memmap.cpp +++ b/kernel/src/Memory/Memmap.cpp @@ -1,5 +1,5 @@ #include "Memmap.hpp" -#include +#include #include #include "Heap.hpp" @@ -18,7 +18,7 @@ namespace Memory { } if (entry->type == LIMINE_MEMMAP_USABLE) { - kout << "[Mem] Found conventional memory section (size = " << base::dec << entry->length << " bytes, address = 0x" << base::hex << (uint64_t)entry->base << ")" << newline; + kout << "MemoryManagement: Found conventional memory section (size = " << base::dec << entry->length << " bytes, address = 0x" << base::hex << (uint64_t)entry->base << ")" << newline; if (entry->length > currentLargestSection.size) { currentLargestSection = { diff --git a/kernel/src/ObjC/Test.mm b/kernel/src/ObjC/Test.mm deleted file mode 100644 index 5f56c88..0000000 --- a/kernel/src/ObjC/Test.mm +++ /dev/null @@ -1,5 +0,0 @@ -extern "C" { - int foobar(){ - return 3; - } -} diff --git a/kernel/src/Platform/Itanium.cpp b/kernel/src/Platform/ABI.cpp similarity index 100% rename from kernel/src/Platform/Itanium.cpp rename to kernel/src/Platform/ABI.cpp diff --git a/kernel/src/Platform/Registers.hpp b/kernel/src/Platform/Registers.hpp index 5da1bf1..6b6020a 100644 --- a/kernel/src/Platform/Registers.hpp +++ b/kernel/src/Platform/Registers.hpp @@ -39,5 +39,16 @@ namespace System { uint8_t InterruptVector; }__attribute__((packed)); + struct GPFPanicFrame { + uint64_t GeneralProtectionFaultError; + uint64_t IP; + uint64_t CS; + uint64_t Flags; + uint64_t SP; + uint64_t SS; + + uint8_t InterruptVector; + }__attribute__((packed)); + }; #endif \ No newline at end of file diff --git a/kernel/src/Terminal/terminal.cpp b/kernel/src/Terminal/Terminal.cpp similarity index 94% rename from kernel/src/Terminal/terminal.cpp rename to kernel/src/Terminal/Terminal.cpp index 47d1144..3ff51f2 100644 --- a/kernel/src/Terminal/terminal.cpp +++ b/kernel/src/Terminal/Terminal.cpp @@ -1,8 +1,8 @@ -#include "terminal.hpp" +#include "Terminal.hpp" #include "../Libraries/flanterm/backends/fb.h" #include "../Libraries/flanterm/flanterm.h" -#include "../Libraries/string.hpp" +#include "../Libraries/String.hpp" namespace Kt { flanterm_context *ctx; diff --git a/kernel/src/Terminal/terminal.hpp b/kernel/src/Terminal/Terminal.hpp similarity index 98% rename from kernel/src/Terminal/terminal.hpp rename to kernel/src/Terminal/Terminal.hpp index 054ec72..4cfe8d9 100644 --- a/kernel/src/Terminal/terminal.hpp +++ b/kernel/src/Terminal/Terminal.hpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include using namespace kcp; diff --git a/objdump b/objdump new file mode 100644 index 0000000..0069bc4 --- /dev/null +++ b/objdump @@ -0,0 +1,18745 @@ + +kernel/bin-x86_64/kernel: file format elf64-x86-64 + + +Disassembly of section .text: + +ffffffff80001000 : +#endif + +static uint8_t bump_alloc_pool[FLANTERM_FB_BUMP_ALLOC_POOL_SIZE]; +static size_t bump_alloc_ptr = 0; + +static void *bump_alloc(size_t s) { +ffffffff80001000: f3 0f 1e fa endbr64 + static bool base_offset_added = false; + if (!base_offset_added) { +ffffffff80001004: 80 3d f5 b0 00 00 00 cmpb $0x0,0xb0f5(%rip) # ffffffff8000c100 +ffffffff8000100b: 75 07 jne ffffffff80001014 + if ((uintptr_t)bump_alloc_pool & 0xf) { + bump_alloc_ptr += 0x10 - ((uintptr_t)bump_alloc_pool & 0xf); + } + base_offset_added = true; +ffffffff8000100d: c6 05 ec b0 00 00 01 movb $0x1,0xb0ec(%rip) # ffffffff8000c100 + } + + if ((s & 0xf) != 0) { + s += 0x10; + s &= ~(size_t)0xf; +ffffffff80001014: 48 8d 47 10 lea 0x10(%rdi),%rax +ffffffff80001018: 48 83 e0 f0 and $0xfffffffffffffff0,%rax +ffffffff8000101c: 40 f6 c7 0f test $0xf,%dil +ffffffff80001020: 48 0f 45 f8 cmovne %rax,%rdi + } + + size_t next_ptr = bump_alloc_ptr + s; +ffffffff80001024: 48 8b 05 dd b0 00 00 mov 0xb0dd(%rip),%rax # ffffffff8000c108 +ffffffff8000102b: 48 01 c7 add %rax,%rdi + if (next_ptr > FLANTERM_FB_BUMP_ALLOC_POOL_SIZE) { +ffffffff8000102e: 48 81 ff 28 52 0d 00 cmp $0xd5228,%rdi +ffffffff80001035: 77 11 ja ffffffff80001048 + return NULL; + } + void *ret = &bump_alloc_pool[bump_alloc_ptr]; + bump_alloc_ptr = next_ptr; +ffffffff80001037: 48 89 3d ca b0 00 00 mov %rdi,0xb0ca(%rip) # ffffffff8000c108 + void *ret = &bump_alloc_pool[bump_alloc_ptr]; +ffffffff8000103e: 48 05 20 c1 00 80 add $0xffffffff8000c120,%rax + return ret; +ffffffff80001044: c3 ret +ffffffff80001045: 0f 1f 00 nopl (%rax) + return NULL; +ffffffff80001048: 31 c0 xor %eax,%eax +} +ffffffff8000104a: c3 ret +ffffffff8000104b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001050 : + uint32_t g = (colour >> 8) & 0xff; + uint32_t b = colour & 0xff; + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +} + +static void flanterm_fb_save_state(struct flanterm_context *_ctx) { +ffffffff80001050: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + ctx->saved_state_text_fg = ctx->text_fg; +ffffffff80001054: 48 8b 87 e0 02 00 00 mov 0x2e0(%rdi),%rax + ctx->saved_state_text_bg = ctx->text_bg; + ctx->saved_state_cursor_x = ctx->cursor_x; +ffffffff8000105b: 48 8b 97 e8 02 00 00 mov 0x2e8(%rdi),%rdx + ctx->saved_state_text_fg = ctx->text_fg; +ffffffff80001062: 48 89 87 f8 02 00 00 mov %rax,0x2f8(%rdi) + ctx->saved_state_cursor_x = ctx->cursor_x; +ffffffff80001069: 48 8b 87 f0 02 00 00 mov 0x2f0(%rdi),%rax +ffffffff80001070: 48 89 97 00 03 00 00 mov %rdx,0x300(%rdi) +ffffffff80001077: 48 89 87 08 03 00 00 mov %rax,0x308(%rdi) + ctx->saved_state_cursor_y = ctx->cursor_y; +} +ffffffff8000107e: c3 ret +ffffffff8000107f: 90 nop + +ffffffff80001080 : + +static void flanterm_fb_restore_state(struct flanterm_context *_ctx) { +ffffffff80001080: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + ctx->text_fg = ctx->saved_state_text_fg; +ffffffff80001084: 48 8b 87 f8 02 00 00 mov 0x2f8(%rdi),%rax + ctx->text_bg = ctx->saved_state_text_bg; + ctx->cursor_x = ctx->saved_state_cursor_x; +ffffffff8000108b: 48 8b 97 00 03 00 00 mov 0x300(%rdi),%rdx + ctx->text_fg = ctx->saved_state_text_fg; +ffffffff80001092: 48 89 87 e0 02 00 00 mov %rax,0x2e0(%rdi) + ctx->cursor_x = ctx->saved_state_cursor_x; +ffffffff80001099: 48 8b 87 08 03 00 00 mov 0x308(%rdi),%rax +ffffffff800010a0: 48 89 97 e8 02 00 00 mov %rdx,0x2e8(%rdi) +ffffffff800010a7: 48 89 87 f0 02 00 00 mov %rax,0x2f0(%rdi) + ctx->cursor_y = ctx->saved_state_cursor_y; +} +ffffffff800010ae: c3 ret +ffffffff800010af: 90 nop + +ffffffff800010b0 : + +static void flanterm_fb_swap_palette(struct flanterm_context *_ctx) { +ffffffff800010b0: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + uint32_t tmp = ctx->text_bg; + ctx->text_bg = ctx->text_fg; + ctx->text_fg = tmp; +ffffffff800010b4: 8b 97 e0 02 00 00 mov 0x2e0(%rdi),%edx +ffffffff800010ba: 8b 87 e4 02 00 00 mov 0x2e4(%rdi),%eax +ffffffff800010c0: 48 c1 e2 20 shl $0x20,%rdx +ffffffff800010c4: 48 09 d0 or %rdx,%rax +ffffffff800010c7: 48 89 87 e0 02 00 00 mov %rax,0x2e0(%rdi) +} +ffffffff800010ce: c3 ret +ffffffff800010cf: 90 nop + +ffffffff800010d0 : + +static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) { + return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg); +} + +static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff800010d0: 49 89 f0 mov %rsi,%r8 +ffffffff800010d3: 48 89 ce mov %rcx,%rsi + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff800010d6: 48 8b 8f e8 00 00 00 mov 0xe8(%rdi),%rcx +static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff800010dd: 48 89 f8 mov %rdi,%rax + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff800010e0: 48 39 ca cmp %rcx,%rdx +ffffffff800010e3: 73 31 jae ffffffff80001116 +ffffffff800010e5: 48 3b b7 e0 00 00 00 cmp 0xe0(%rdi),%rsi +ffffffff800010ec: 73 28 jae ffffffff80001116 + return; + } + + size_t i = y * _ctx->cols + x; +ffffffff800010ee: 48 0f af ce imul %rsi,%rcx + + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800010f2: 48 8b bf d8 02 00 00 mov 0x2d8(%rdi),%rdi + size_t i = y * _ctx->cols + x; +ffffffff800010f9: 48 01 d1 add %rdx,%rcx + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800010fc: 4c 8d 0c cf lea (%rdi,%rcx,8),%r9 +ffffffff80001100: 49 8b 39 mov (%r9),%rdi + + if (q == NULL) { +ffffffff80001103: 48 85 ff test %rdi,%rdi +ffffffff80001106: 74 18 je ffffffff80001120 + q->x = x; + q->y = y; + ctx->map[i] = q; + } + + q->c = *c; +ffffffff80001108: 49 8b 00 mov (%r8),%rax +ffffffff8000110b: 48 89 47 10 mov %rax,0x10(%rdi) +ffffffff8000110f: 41 8b 40 08 mov 0x8(%r8),%eax +ffffffff80001113: 89 47 18 mov %eax,0x18(%rdi) +} +ffffffff80001116: c3 ret +ffffffff80001117: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000111e: 00 00 + if (compare_char(&ctx->grid[i], c)) { +ffffffff80001120: 48 8d 3c 49 lea (%rcx,%rcx,2),%rdi +ffffffff80001124: 48 8b 88 c0 02 00 00 mov 0x2c0(%rax),%rcx +ffffffff8000112b: 48 8d 0c b9 lea (%rcx,%rdi,4),%rcx + return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg); +ffffffff8000112f: 41 8b 38 mov (%r8),%edi +ffffffff80001132: 39 39 cmp %edi,(%rcx) +ffffffff80001134: 74 2a je ffffffff80001160 + q = &ctx->queue[ctx->queue_i++]; +ffffffff80001136: 48 8b b8 d0 02 00 00 mov 0x2d0(%rax),%rdi +ffffffff8000113d: 48 8d 4f 01 lea 0x1(%rdi),%rcx +ffffffff80001141: 48 c1 e7 05 shl $0x5,%rdi +ffffffff80001145: 48 03 b8 c8 02 00 00 add 0x2c8(%rax),%rdi +ffffffff8000114c: 48 89 88 d0 02 00 00 mov %rcx,0x2d0(%rax) + q->x = x; +ffffffff80001153: 48 89 17 mov %rdx,(%rdi) + q->y = y; +ffffffff80001156: 48 89 77 08 mov %rsi,0x8(%rdi) + ctx->map[i] = q; +ffffffff8000115a: 49 89 39 mov %rdi,(%r9) +ffffffff8000115d: eb a9 jmp ffffffff80001108 +ffffffff8000115f: 90 nop + return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg); +ffffffff80001160: 41 8b 78 08 mov 0x8(%r8),%edi +ffffffff80001164: 39 79 08 cmp %edi,0x8(%rcx) +ffffffff80001167: 75 cd jne ffffffff80001136 +ffffffff80001169: 41 8b 78 04 mov 0x4(%r8),%edi +ffffffff8000116d: 39 79 04 cmp %edi,0x4(%rcx) +ffffffff80001170: 75 c4 jne ffffffff80001136 +} +ffffffff80001172: c3 ret +ffffffff80001173: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000117a: 00 00 00 +ffffffff8000117d: 0f 1f 00 nopl (%rax) + +ffffffff80001180 : + +static void flanterm_fb_revscroll(struct flanterm_context *_ctx) { +ffffffff80001180: f3 0f 1e fa endbr64 +ffffffff80001184: 41 55 push %r13 +ffffffff80001186: 41 54 push %r12 +ffffffff80001188: 55 push %rbp +ffffffff80001189: 53 push %rbx +ffffffff8000118a: 48 89 fb mov %rdi,%rbx +ffffffff8000118d: 48 83 ec 10 sub $0x10,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1; +ffffffff80001191: 48 8b 47 70 mov 0x70(%rdi),%rax +ffffffff80001195: 4c 8b 9f e8 00 00 00 mov 0xe8(%rdi),%r11 + i >= _ctx->scroll_top_margin * _ctx->cols; i--) { +ffffffff8000119c: 48 8b 6f 68 mov 0x68(%rdi),%rbp + for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1; +ffffffff800011a0: 48 83 e8 01 sub $0x1,%rax + i >= _ctx->scroll_top_margin * _ctx->cols; i--) { +ffffffff800011a4: 4d 89 dc mov %r11,%r12 + for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1; +ffffffff800011a7: 49 0f af c3 imul %r11,%rax + i >= _ctx->scroll_top_margin * _ctx->cols; i--) { +ffffffff800011ab: 4c 0f af e5 imul %rbp,%r12 + if (i == (size_t)-1) { +ffffffff800011af: 48 85 c0 test %rax,%rax +ffffffff800011b2: 74 5c je ffffffff80001210 +ffffffff800011b4: 4c 8d 50 ff lea -0x1(%rax),%r10 +ffffffff800011b8: 4d 39 e2 cmp %r12,%r10 +ffffffff800011bb: 72 53 jb ffffffff80001210 + break; + } + struct flanterm_fb_char *c; + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800011bd: 4c 8b af d8 02 00 00 mov 0x2d8(%rdi),%r13 +ffffffff800011c4: eb 2d jmp ffffffff800011f3 +ffffffff800011c6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800011cd: 00 00 00 + if (q != NULL) { + c = &q->c; +ffffffff800011d0: 48 83 c6 10 add $0x10,%rsi + } else { + c = &ctx->grid[i]; + } + push_to_queue(_ctx, c, (i + _ctx->cols) % _ctx->cols, (i + _ctx->cols) / _ctx->cols); +ffffffff800011d4: 4b 8d 04 13 lea (%r11,%r10,1),%rax +ffffffff800011d8: 31 d2 xor %edx,%edx +ffffffff800011da: 48 89 df mov %rbx,%rdi +ffffffff800011dd: 49 f7 f3 div %r11 +ffffffff800011e0: 48 89 c1 mov %rax,%rcx +ffffffff800011e3: e8 e8 fe ff ff call ffffffff800010d0 + if (i == (size_t)-1) { +ffffffff800011e8: 49 83 ea 01 sub $0x1,%r10 +ffffffff800011ec: 72 22 jb ffffffff80001210 +ffffffff800011ee: 4d 39 e2 cmp %r12,%r10 +ffffffff800011f1: 72 1d jb ffffffff80001210 + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800011f3: 4b 8b 74 d5 00 mov 0x0(%r13,%r10,8),%rsi + if (q != NULL) { +ffffffff800011f8: 48 85 f6 test %rsi,%rsi +ffffffff800011fb: 75 d3 jne ffffffff800011d0 + c = &ctx->grid[i]; +ffffffff800011fd: 48 8b 93 c0 02 00 00 mov 0x2c0(%rbx),%rdx +ffffffff80001204: 4b 8d 04 52 lea (%r10,%r10,2),%rax +ffffffff80001208: 48 8d 34 82 lea (%rdx,%rax,4),%rsi +ffffffff8000120c: eb c6 jmp ffffffff800011d4 +ffffffff8000120e: 66 90 xchg %ax,%ax + } + + // Clear the first line of the screen. + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; +ffffffff80001210: 48 8b 83 e0 02 00 00 mov 0x2e0(%rbx),%rax + empty.c = ' '; +ffffffff80001217: c7 44 24 04 20 00 00 movl $0x20,0x4(%rsp) +ffffffff8000121e: 00 + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff8000121f: 31 d2 xor %edx,%edx + empty.fg = ctx->text_fg; +ffffffff80001221: 48 89 44 24 08 mov %rax,0x8(%rsp) + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff80001226: 4d 85 db test %r11,%r11 +ffffffff80001229: 74 1e je ffffffff80001249 +ffffffff8000122b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + push_to_queue(_ctx, &empty, i, _ctx->scroll_top_margin); +ffffffff80001230: 48 89 e9 mov %rbp,%rcx +ffffffff80001233: 48 8d 74 24 04 lea 0x4(%rsp),%rsi +ffffffff80001238: 48 89 df mov %rbx,%rdi +ffffffff8000123b: e8 90 fe ff ff call ffffffff800010d0 + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff80001240: 48 83 c2 01 add $0x1,%rdx +ffffffff80001244: 49 39 d3 cmp %rdx,%r11 +ffffffff80001247: 75 e7 jne ffffffff80001230 + } +} +ffffffff80001249: 48 83 c4 10 add $0x10,%rsp +ffffffff8000124d: 5b pop %rbx +ffffffff8000124e: 5d pop %rbp +ffffffff8000124f: 41 5c pop %r12 +ffffffff80001251: 41 5d pop %r13 +ffffffff80001253: c3 ret +ffffffff80001254: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000125b: 00 00 00 +ffffffff8000125e: 66 90 xchg %ax,%ax + +ffffffff80001260 : + +static void flanterm_fb_scroll(struct flanterm_context *_ctx) { +ffffffff80001260: f3 0f 1e fa endbr64 +ffffffff80001264: 41 56 push %r14 +ffffffff80001266: 41 55 push %r13 +ffffffff80001268: 41 54 push %r12 +ffffffff8000126a: 55 push %rbp +ffffffff8000126b: 53 push %rbx +ffffffff8000126c: 48 89 fb mov %rdi,%rbx +ffffffff8000126f: 48 83 ec 10 sub $0x10,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols; +ffffffff80001273: 4c 8b 9f e8 00 00 00 mov 0xe8(%rdi),%r11 +ffffffff8000127a: 48 8b 47 68 mov 0x68(%rdi),%rax + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff8000127e: 48 8b 6f 70 mov 0x70(%rdi),%rbp + for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols; +ffffffff80001282: 48 83 c0 01 add $0x1,%rax + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff80001286: 4d 89 dc mov %r11,%r12 + for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols; +ffffffff80001289: 49 0f af c3 imul %r11,%rax + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff8000128d: 4c 0f af e5 imul %rbp,%r12 +ffffffff80001291: 4c 39 e0 cmp %r12,%rax +ffffffff80001294: 73 62 jae ffffffff800012f8 +ffffffff80001296: 49 89 c2 mov %rax,%r10 +ffffffff80001299: 4c 8d 34 40 lea (%rax,%rax,2),%r14 +ffffffff8000129d: 48 8b 87 d8 02 00 00 mov 0x2d8(%rdi),%rax +ffffffff800012a4: 4d 29 dc sub %r11,%r12 +ffffffff800012a7: 4d 29 da sub %r11,%r10 +ffffffff800012aa: 49 c1 e6 02 shl $0x2,%r14 +ffffffff800012ae: 4e 8d 2c d8 lea (%rax,%r11,8),%r13 +ffffffff800012b2: eb 28 jmp ffffffff800012dc +ffffffff800012b4: 0f 1f 40 00 nopl 0x0(%rax) + struct flanterm_fb_char *c; + struct flanterm_fb_queue_item *q = ctx->map[i]; + if (q != NULL) { + c = &q->c; +ffffffff800012b8: 48 83 c6 10 add $0x10,%rsi + } else { + c = &ctx->grid[i]; + } + push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols); +ffffffff800012bc: 4c 89 d0 mov %r10,%rax +ffffffff800012bf: 31 d2 xor %edx,%edx +ffffffff800012c1: 48 89 df mov %rbx,%rdi + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff800012c4: 49 83 c2 01 add $0x1,%r10 +ffffffff800012c8: 49 f7 f3 div %r11 +ffffffff800012cb: 49 83 c6 0c add $0xc,%r14 +ffffffff800012cf: 48 89 c1 mov %rax,%rcx + push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols); +ffffffff800012d2: e8 f9 fd ff ff call ffffffff800010d0 + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff800012d7: 4d 39 d4 cmp %r10,%r12 +ffffffff800012da: 74 1c je ffffffff800012f8 + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800012dc: 4b 8b 74 d5 00 mov 0x0(%r13,%r10,8),%rsi + if (q != NULL) { +ffffffff800012e1: 48 85 f6 test %rsi,%rsi +ffffffff800012e4: 75 d2 jne ffffffff800012b8 + c = &ctx->grid[i]; +ffffffff800012e6: 48 8b b3 c0 02 00 00 mov 0x2c0(%rbx),%rsi +ffffffff800012ed: 4c 01 f6 add %r14,%rsi +ffffffff800012f0: eb ca jmp ffffffff800012bc +ffffffff800012f2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + } + + // Clear the last line of the screen. + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; +ffffffff800012f8: 48 8b 83 e0 02 00 00 mov 0x2e0(%rbx),%rax + empty.c = ' '; +ffffffff800012ff: c7 44 24 04 20 00 00 movl $0x20,0x4(%rsp) +ffffffff80001306: 00 + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->cols; i++) { + push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1); +ffffffff80001307: 48 83 ed 01 sub $0x1,%rbp + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff8000130b: 31 d2 xor %edx,%edx + empty.fg = ctx->text_fg; +ffffffff8000130d: 48 89 44 24 08 mov %rax,0x8(%rsp) + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff80001312: 4d 85 db test %r11,%r11 +ffffffff80001315: 74 22 je ffffffff80001339 +ffffffff80001317: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000131e: 00 00 + push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1); +ffffffff80001320: 48 89 e9 mov %rbp,%rcx +ffffffff80001323: 48 8d 74 24 04 lea 0x4(%rsp),%rsi +ffffffff80001328: 48 89 df mov %rbx,%rdi +ffffffff8000132b: e8 a0 fd ff ff call ffffffff800010d0 + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff80001330: 48 83 c2 01 add $0x1,%rdx +ffffffff80001334: 49 39 d3 cmp %rdx,%r11 +ffffffff80001337: 75 e7 jne ffffffff80001320 + } +} +ffffffff80001339: 48 83 c4 10 add $0x10,%rsp +ffffffff8000133d: 5b pop %rbx +ffffffff8000133e: 5d pop %rbp +ffffffff8000133f: 41 5c pop %r12 +ffffffff80001341: 41 5d pop %r13 +ffffffff80001343: 41 5e pop %r14 +ffffffff80001345: c3 ret +ffffffff80001346: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000134d: 00 00 00 + +ffffffff80001350 : + +static void flanterm_fb_clear(struct flanterm_context *_ctx, bool move) { +ffffffff80001350: f3 0f 1e fa endbr64 +ffffffff80001354: 41 54 push %r12 +ffffffff80001356: 41 89 f4 mov %esi,%r12d +ffffffff80001359: 55 push %rbp +ffffffff8000135a: 53 push %rbx +ffffffff8000135b: 48 89 fb mov %rdi,%rbx +ffffffff8000135e: 48 83 ec 10 sub $0x10,%rsp + + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff80001362: 4c 8b 9f e8 00 00 00 mov 0xe8(%rdi),%r11 +ffffffff80001369: 48 8b af e0 00 00 00 mov 0xe0(%rdi),%rbp + empty.fg = ctx->text_fg; +ffffffff80001370: 48 8b 87 e0 02 00 00 mov 0x2e0(%rdi),%rax + empty.c = ' '; +ffffffff80001377: c7 44 24 04 20 00 00 movl $0x20,0x4(%rsp) +ffffffff8000137e: 00 + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff8000137f: 49 0f af eb imul %r11,%rbp + empty.fg = ctx->text_fg; +ffffffff80001383: 48 89 44 24 08 mov %rax,0x8(%rsp) + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff80001388: 48 85 ed test %rbp,%rbp +ffffffff8000138b: 74 24 je ffffffff800013b1 +ffffffff8000138d: 45 31 d2 xor %r10d,%r10d + push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols); +ffffffff80001390: 4c 89 d0 mov %r10,%rax +ffffffff80001393: 31 d2 xor %edx,%edx +ffffffff80001395: 48 8d 74 24 04 lea 0x4(%rsp),%rsi +ffffffff8000139a: 48 89 df mov %rbx,%rdi +ffffffff8000139d: 49 f7 f3 div %r11 + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff800013a0: 49 83 c2 01 add $0x1,%r10 +ffffffff800013a4: 48 89 c1 mov %rax,%rcx + push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols); +ffffffff800013a7: e8 24 fd ff ff call ffffffff800010d0 + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff800013ac: 49 39 ea cmp %rbp,%r10 +ffffffff800013af: 75 df jne ffffffff80001390 + } + + if (move) { +ffffffff800013b1: 45 84 e4 test %r12b,%r12b +ffffffff800013b4: 74 16 je ffffffff800013cc + ctx->cursor_x = 0; +ffffffff800013b6: 48 c7 83 e8 02 00 00 movq $0x0,0x2e8(%rbx) +ffffffff800013bd: 00 00 00 00 + ctx->cursor_y = 0; +ffffffff800013c1: 48 c7 83 f0 02 00 00 movq $0x0,0x2f0(%rbx) +ffffffff800013c8: 00 00 00 00 + } +} +ffffffff800013cc: 48 83 c4 10 add $0x10,%rsp +ffffffff800013d0: 5b pop %rbx +ffffffff800013d1: 5d pop %rbp +ffffffff800013d2: 41 5c pop %r12 +ffffffff800013d4: c3 ret +ffffffff800013d5: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800013dc: 00 00 00 +ffffffff800013df: 90 nop + +ffffffff800013e0 : + +static void flanterm_fb_set_cursor_pos(struct flanterm_context *_ctx, size_t x, size_t y) { +ffffffff800013e0: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols) { +ffffffff800013e4: 48 8b 87 e8 00 00 00 mov 0xe8(%rdi),%rax +ffffffff800013eb: 48 39 c6 cmp %rax,%rsi +ffffffff800013ee: 72 0f jb ffffffff800013ff + if ((int)x < 0) { + x = 0; + } else { + x = _ctx->cols - 1; +ffffffff800013f0: 48 83 e8 01 sub $0x1,%rax +ffffffff800013f4: 85 f6 test %esi,%esi +ffffffff800013f6: be 00 00 00 00 mov $0x0,%esi +ffffffff800013fb: 48 0f 49 f0 cmovns %rax,%rsi + } + } + if (y >= _ctx->rows) { +ffffffff800013ff: 48 8b 87 e0 00 00 00 mov 0xe0(%rdi),%rax +ffffffff80001406: 48 39 c2 cmp %rax,%rdx +ffffffff80001409: 72 0f jb ffffffff8000141a + if ((int)y < 0) { + y = 0; + } else { + y = _ctx->rows - 1; +ffffffff8000140b: 48 83 e8 01 sub $0x1,%rax +ffffffff8000140f: 85 d2 test %edx,%edx +ffffffff80001411: ba 00 00 00 00 mov $0x0,%edx +ffffffff80001416: 48 0f 49 d0 cmovns %rax,%rdx + } + } + ctx->cursor_x = x; +ffffffff8000141a: 48 89 b7 e8 02 00 00 mov %rsi,0x2e8(%rdi) + ctx->cursor_y = y; +ffffffff80001421: 48 89 97 f0 02 00 00 mov %rdx,0x2f0(%rdi) +} +ffffffff80001428: c3 ret +ffffffff80001429: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + +ffffffff80001430 : + +static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) { +ffffffff80001430: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x; +ffffffff80001434: 48 8b 87 e8 02 00 00 mov 0x2e8(%rdi),%rax +static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) { +ffffffff8000143b: 48 89 d1 mov %rdx,%rcx + *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x; +ffffffff8000143e: 48 8b 97 e8 00 00 00 mov 0xe8(%rdi),%rdx +ffffffff80001445: 48 39 d0 cmp %rdx,%rax +ffffffff80001448: 4c 8d 42 ff lea -0x1(%rdx),%r8 +ffffffff8000144c: 49 0f 43 c0 cmovae %r8,%rax +ffffffff80001450: 48 89 06 mov %rax,(%rsi) + *y = ctx->cursor_y >= _ctx->rows ? _ctx->rows - 1 : ctx->cursor_y; +ffffffff80001453: 48 8b 87 f0 02 00 00 mov 0x2f0(%rdi),%rax +ffffffff8000145a: 48 8b 97 e0 00 00 00 mov 0xe0(%rdi),%rdx +ffffffff80001461: 48 8d 72 ff lea -0x1(%rdx),%rsi +ffffffff80001465: 48 39 d0 cmp %rdx,%rax +ffffffff80001468: 48 0f 43 c6 cmovae %rsi,%rax +ffffffff8000146c: 48 89 01 mov %rax,(%rcx) +} +ffffffff8000146f: c3 ret + +ffffffff80001470 : + +static void flanterm_fb_move_character(struct flanterm_context *_ctx, size_t new_x, size_t new_y, size_t old_x, size_t old_y) { +ffffffff80001470: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (old_x >= _ctx->cols || old_y >= _ctx->rows +ffffffff80001474: 48 8b 87 e8 00 00 00 mov 0xe8(%rdi),%rax +ffffffff8000147b: 48 39 c1 cmp %rax,%rcx +ffffffff8000147e: 73 1f jae ffffffff8000149f +ffffffff80001480: 4c 8b 97 e0 00 00 00 mov 0xe0(%rdi),%r10 + || new_x >= _ctx->cols || new_y >= _ctx->rows) { +ffffffff80001487: 48 39 c6 cmp %rax,%rsi +ffffffff8000148a: 41 0f 93 c1 setae %r9b + if (old_x >= _ctx->cols || old_y >= _ctx->rows +ffffffff8000148e: 4d 39 d0 cmp %r10,%r8 +ffffffff80001491: 41 0f 93 c3 setae %r11b + || new_x >= _ctx->cols || new_y >= _ctx->rows) { +ffffffff80001495: 45 08 d9 or %r11b,%r9b +ffffffff80001498: 75 05 jne ffffffff8000149f +ffffffff8000149a: 4c 39 d2 cmp %r10,%rdx +ffffffff8000149d: 72 01 jb ffffffff800014a0 + } else { + c = &ctx->grid[i]; + } + + push_to_queue(_ctx, c, new_x, new_y); +} +ffffffff8000149f: c3 ret + size_t i = old_x + old_y * _ctx->cols; +ffffffff800014a0: 49 0f af c0 imul %r8,%rax +ffffffff800014a4: 48 01 c8 add %rcx,%rax + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800014a7: 48 8b 8f d8 02 00 00 mov 0x2d8(%rdi),%rcx +ffffffff800014ae: 48 8b 0c c1 mov (%rcx,%rax,8),%rcx + if (q != NULL) { +ffffffff800014b2: 48 85 c9 test %rcx,%rcx +ffffffff800014b5: 74 19 je ffffffff800014d0 + c = &q->c; +ffffffff800014b7: 48 8d 41 10 lea 0x10(%rcx),%rax + push_to_queue(_ctx, c, new_x, new_y); +ffffffff800014bb: 48 89 d1 mov %rdx,%rcx +ffffffff800014be: 48 89 f2 mov %rsi,%rdx +ffffffff800014c1: 48 89 c6 mov %rax,%rsi +ffffffff800014c4: e9 07 fc ff ff jmp ffffffff800010d0 +ffffffff800014c9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + c = &ctx->grid[i]; +ffffffff800014d0: 48 8d 0c 40 lea (%rax,%rax,2),%rcx +ffffffff800014d4: 48 8b 87 c0 02 00 00 mov 0x2c0(%rdi),%rax +ffffffff800014db: 48 8d 04 88 lea (%rax,%rcx,4),%rax +ffffffff800014df: eb da jmp ffffffff800014bb +ffffffff800014e1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800014e8: 00 00 00 +ffffffff800014eb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff800014f0 : + +static void flanterm_fb_set_text_fg(struct flanterm_context *_ctx, size_t fg) { +ffffffff800014f0: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->ansi_colours[fg]; +ffffffff800014f4: 8b 84 b7 48 02 00 00 mov 0x248(%rdi,%rsi,4),%eax +ffffffff800014fb: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) +} +ffffffff80001501: c3 ret +ffffffff80001502: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001509: 00 00 00 +ffffffff8000150c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001510 : + +static void flanterm_fb_set_text_bg(struct flanterm_context *_ctx, size_t bg) { +ffffffff80001510: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->ansi_colours[bg]; +ffffffff80001514: 8b 84 b7 48 02 00 00 mov 0x248(%rdi,%rsi,4),%eax +ffffffff8000151b: 89 87 e4 02 00 00 mov %eax,0x2e4(%rdi) +} +ffffffff80001521: c3 ret +ffffffff80001522: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001529: 00 00 00 +ffffffff8000152c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001530 : + +static void flanterm_fb_set_text_fg_bright(struct flanterm_context *_ctx, size_t fg) { +ffffffff80001530: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->ansi_bright_colours[fg]; +ffffffff80001534: 8b 84 b7 68 02 00 00 mov 0x268(%rdi,%rsi,4),%eax +ffffffff8000153b: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) +} +ffffffff80001541: c3 ret +ffffffff80001542: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001549: 00 00 00 +ffffffff8000154c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001550 : + +static void flanterm_fb_set_text_bg_bright(struct flanterm_context *_ctx, size_t bg) { +ffffffff80001550: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->ansi_bright_colours[bg]; +ffffffff80001554: 8b 84 b7 68 02 00 00 mov 0x268(%rdi,%rsi,4),%eax +ffffffff8000155b: 89 87 e4 02 00 00 mov %eax,0x2e4(%rdi) +} +ffffffff80001561: c3 ret +ffffffff80001562: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001569: 00 00 00 +ffffffff8000156c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001570 : + +static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) { +ffffffff80001570: f3 0f 1e fa endbr64 + uint32_t r = (colour >> 16) & 0xff; +ffffffff80001574: 89 f0 mov %esi,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80001576: 0f b6 8f 21 02 00 00 movzbl 0x221(%rdi),%ecx +static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) { +ffffffff8000157d: 89 f2 mov %esi,%edx + uint32_t r = (colour >> 16) & 0xff; +ffffffff8000157f: c1 e8 10 shr $0x10,%eax + uint32_t g = (colour >> 8) & 0xff; +ffffffff80001582: 0f b6 f6 movzbl %dh,%esi + uint32_t b = colour & 0xff; +ffffffff80001585: 0f b6 d2 movzbl %dl,%edx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80001588: 0f b6 c0 movzbl %al,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000158b: d3 e0 shl %cl,%eax +ffffffff8000158d: 0f b6 8f 23 02 00 00 movzbl 0x223(%rdi),%ecx +ffffffff80001594: d3 e6 shl %cl,%esi +ffffffff80001596: 0f b6 8f 25 02 00 00 movzbl 0x225(%rdi),%ecx +ffffffff8000159d: 09 f0 or %esi,%eax +ffffffff8000159f: d3 e2 shl %cl,%edx +ffffffff800015a1: 09 d0 or %edx,%eax +ffffffff800015a3: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = convert_colour(_ctx, fg); +} +ffffffff800015a9: c3 ret +ffffffff800015aa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff800015b0 : + +static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) { +ffffffff800015b0: f3 0f 1e fa endbr64 + uint32_t r = (colour >> 16) & 0xff; +ffffffff800015b4: 89 f0 mov %esi,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800015b6: 0f b6 8f 21 02 00 00 movzbl 0x221(%rdi),%ecx +static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) { +ffffffff800015bd: 89 f2 mov %esi,%edx + uint32_t r = (colour >> 16) & 0xff; +ffffffff800015bf: c1 e8 10 shr $0x10,%eax + uint32_t g = (colour >> 8) & 0xff; +ffffffff800015c2: 0f b6 f6 movzbl %dh,%esi + uint32_t b = colour & 0xff; +ffffffff800015c5: 0f b6 d2 movzbl %dl,%edx + uint32_t r = (colour >> 16) & 0xff; +ffffffff800015c8: 0f b6 c0 movzbl %al,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800015cb: d3 e0 shl %cl,%eax +ffffffff800015cd: 0f b6 8f 23 02 00 00 movzbl 0x223(%rdi),%ecx +ffffffff800015d4: d3 e6 shl %cl,%esi +ffffffff800015d6: 0f b6 8f 25 02 00 00 movzbl 0x225(%rdi),%ecx +ffffffff800015dd: 09 f0 or %esi,%eax +ffffffff800015df: d3 e2 shl %cl,%edx +ffffffff800015e1: 09 d0 or %edx,%eax +ffffffff800015e3: 89 87 e4 02 00 00 mov %eax,0x2e4(%rdi) + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = convert_colour(_ctx, bg); +} +ffffffff800015e9: c3 ret +ffffffff800015ea: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff800015f0 : + +static void flanterm_fb_set_text_fg_default(struct flanterm_context *_ctx) { +ffffffff800015f0: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->default_fg; +ffffffff800015f4: 8b 87 88 02 00 00 mov 0x288(%rdi),%eax +ffffffff800015fa: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) +} +ffffffff80001600: c3 ret +ffffffff80001601: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001608: 00 00 00 +ffffffff8000160b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001610 : + +static void flanterm_fb_set_text_bg_default(struct flanterm_context *_ctx) { +ffffffff80001610: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = 0xffffffff; +ffffffff80001614: c7 87 e4 02 00 00 ff movl $0xffffffff,0x2e4(%rdi) +ffffffff8000161b: ff ff ff +} +ffffffff8000161e: c3 ret +ffffffff8000161f: 90 nop + +ffffffff80001620 : + +static void flanterm_fb_set_text_fg_default_bright(struct flanterm_context *_ctx) { +ffffffff80001620: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->default_fg_bright; +ffffffff80001624: 8b 87 90 02 00 00 mov 0x290(%rdi),%eax +ffffffff8000162a: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) +} +ffffffff80001630: c3 ret +ffffffff80001631: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001638: 00 00 00 +ffffffff8000163b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001640 : + +static void flanterm_fb_set_text_bg_default_bright(struct flanterm_context *_ctx) { +ffffffff80001640: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->default_bg_bright; +ffffffff80001644: 8b 87 94 02 00 00 mov 0x294(%rdi),%eax +ffffffff8000164a: 89 87 e4 02 00 00 mov %eax,0x2e4(%rdi) +} +ffffffff80001650: c3 ret +ffffffff80001651: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001658: 00 00 00 +ffffffff8000165b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001660 : + +static void draw_cursor(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) { +ffffffff80001660: 48 8b 97 e8 02 00 00 mov 0x2e8(%rdi),%rdx +ffffffff80001667: 48 8b 87 e8 00 00 00 mov 0xe8(%rdi),%rax +ffffffff8000166e: 48 39 c2 cmp %rax,%rdx +ffffffff80001671: 0f 83 a1 00 00 00 jae ffffffff80001718 +static void draw_cursor(struct flanterm_context *_ctx) { +ffffffff80001677: 41 55 push %r13 +ffffffff80001679: 41 54 push %r12 +ffffffff8000167b: 55 push %rbp +ffffffff8000167c: 53 push %rbx +ffffffff8000167d: 48 89 fb mov %rdi,%rbx +ffffffff80001680: 48 83 ec 18 sub $0x18,%rsp + if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) { +ffffffff80001684: 48 8b 8f f0 02 00 00 mov 0x2f0(%rdi),%rcx +ffffffff8000168b: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80001692: 73 73 jae ffffffff80001707 + return; + } + + size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols; +ffffffff80001694: 48 0f af c1 imul %rcx,%rax + c = ctx->grid[i]; + } + uint32_t tmp = c.fg; + c.fg = c.bg; + c.bg = tmp; + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); +ffffffff80001698: 4c 8b 87 b0 01 00 00 mov 0x1b0(%rdi),%r8 + size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols; +ffffffff8000169f: 48 8d 2c 10 lea (%rax,%rdx,1),%rbp + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800016a3: 48 8b 87 d8 02 00 00 mov 0x2d8(%rdi),%rax + if (q != NULL) { + ctx->grid[i] = q->c; +ffffffff800016aa: 4c 8d 64 6d 00 lea 0x0(%rbp,%rbp,2),%r12 + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800016af: 4c 8b 2c e8 mov (%rax,%rbp,8),%r13 + ctx->grid[i] = q->c; +ffffffff800016b3: 49 c1 e4 02 shl $0x2,%r12 + if (q != NULL) { +ffffffff800016b7: 4d 85 ed test %r13,%r13 +ffffffff800016ba: 74 64 je ffffffff80001720 + c = q->c; +ffffffff800016bc: 49 8b 45 10 mov 0x10(%r13),%rax +ffffffff800016c0: 48 89 44 24 04 mov %rax,0x4(%rsp) +ffffffff800016c5: 48 89 c6 mov %rax,%rsi +ffffffff800016c8: 41 8b 45 18 mov 0x18(%r13),%eax +ffffffff800016cc: 48 c1 ee 20 shr $0x20,%rsi + c.fg = c.bg; +ffffffff800016d0: 89 44 24 08 mov %eax,0x8(%rsp) + c.bg = tmp; +ffffffff800016d4: 89 74 24 0c mov %esi,0xc(%rsp) + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); +ffffffff800016d8: 48 8d 74 24 04 lea 0x4(%rsp),%rsi +ffffffff800016dd: 41 ff d0 call *%r8 + ctx->grid[i] = q->c; +ffffffff800016e0: 48 8b 83 c0 02 00 00 mov 0x2c0(%rbx),%rax +ffffffff800016e7: 49 8b 55 10 mov 0x10(%r13),%rdx +ffffffff800016eb: 4a 89 14 20 mov %rdx,(%rax,%r12,1) +ffffffff800016ef: 41 8b 55 18 mov 0x18(%r13),%edx +ffffffff800016f3: 42 89 54 20 08 mov %edx,0x8(%rax,%r12,1) + ctx->map[i] = NULL; +ffffffff800016f8: 48 8b 83 d8 02 00 00 mov 0x2d8(%rbx),%rax +ffffffff800016ff: 48 c7 04 e8 00 00 00 movq $0x0,(%rax,%rbp,8) +ffffffff80001706: 00 + } +} +ffffffff80001707: 48 83 c4 18 add $0x18,%rsp +ffffffff8000170b: 5b pop %rbx +ffffffff8000170c: 5d pop %rbp +ffffffff8000170d: 41 5c pop %r12 +ffffffff8000170f: 41 5d pop %r13 +ffffffff80001711: c3 ret +ffffffff80001712: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80001718: c3 ret +ffffffff80001719: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + c = ctx->grid[i]; +ffffffff80001720: 48 8b 87 c0 02 00 00 mov 0x2c0(%rdi),%rax +ffffffff80001727: 4a 8b 34 20 mov (%rax,%r12,1),%rsi +ffffffff8000172b: 48 89 74 24 04 mov %rsi,0x4(%rsp) +ffffffff80001730: 42 8b 74 20 08 mov 0x8(%rax,%r12,1),%esi + uint32_t tmp = c.fg; +ffffffff80001735: 8b 44 24 08 mov 0x8(%rsp),%eax + c.fg = c.bg; +ffffffff80001739: 89 74 24 08 mov %esi,0x8(%rsp) + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); +ffffffff8000173d: 48 8d 74 24 04 lea 0x4(%rsp),%rsi + c.bg = tmp; +ffffffff80001742: 89 44 24 0c mov %eax,0xc(%rsp) + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); +ffffffff80001746: 41 ff d0 call *%r8 +} +ffffffff80001749: 48 83 c4 18 add $0x18,%rsp +ffffffff8000174d: 5b pop %rbx +ffffffff8000174e: 5d pop %rbp +ffffffff8000174f: 41 5c pop %r12 +ffffffff80001751: 41 5d pop %r13 +ffffffff80001753: c3 ret +ffffffff80001754: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000175b: 00 00 00 +ffffffff8000175e: 66 90 xchg %ax,%ax + +ffffffff80001760 : + +static void flanterm_fb_double_buffer_flush(struct flanterm_context *_ctx) { +ffffffff80001760: f3 0f 1e fa endbr64 +ffffffff80001764: 41 55 push %r13 +ffffffff80001766: 41 54 push %r12 +ffffffff80001768: 55 push %rbp +ffffffff80001769: 53 push %rbx +ffffffff8000176a: 48 89 fb mov %rdi,%rbx +ffffffff8000176d: 48 83 ec 08 sub $0x8,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (_ctx->cursor_enabled) { +ffffffff80001771: 80 7f 09 00 cmpb $0x0,0x9(%rdi) +ffffffff80001775: 0f 85 35 01 00 00 jne ffffffff800018b0 + draw_cursor(_ctx); + } + + for (size_t i = 0; i < ctx->queue_i; i++) { +ffffffff8000177b: 48 83 bb d0 02 00 00 cmpq $0x0,0x2d0(%rbx) +ffffffff80001782: 00 +ffffffff80001783: 74 7b je ffffffff80001800 +ffffffff80001785: 48 8b 83 d8 02 00 00 mov 0x2d8(%rbx),%rax +ffffffff8000178c: 45 31 ed xor %r13d,%r13d +ffffffff8000178f: 90 nop + struct flanterm_fb_queue_item *q = &ctx->queue[i]; +ffffffff80001790: 4c 89 ed mov %r13,%rbp + size_t offset = q->y * _ctx->cols + q->x; +ffffffff80001793: 4c 8b a3 e8 00 00 00 mov 0xe8(%rbx),%r12 + struct flanterm_fb_queue_item *q = &ctx->queue[i]; +ffffffff8000179a: 48 c1 e5 05 shl $0x5,%rbp +ffffffff8000179e: 48 03 ab c8 02 00 00 add 0x2c8(%rbx),%rbp + size_t offset = q->y * _ctx->cols + q->x; +ffffffff800017a5: 48 8b 4d 08 mov 0x8(%rbp),%rcx +ffffffff800017a9: 48 8b 55 00 mov 0x0(%rbp),%rdx +ffffffff800017ad: 4c 0f af e1 imul %rcx,%r12 +ffffffff800017b1: 49 01 d4 add %rdx,%r12 + if (ctx->map[offset] == NULL) { +ffffffff800017b4: 4a 83 3c e0 00 cmpq $0x0,(%rax,%r12,8) +ffffffff800017b9: 74 38 je ffffffff800017f3 + continue; + } + ctx->plot_char(_ctx, &q->c, q->x, q->y); +ffffffff800017bb: 48 8d 75 10 lea 0x10(%rbp),%rsi +ffffffff800017bf: 48 89 df mov %rbx,%rdi +ffffffff800017c2: ff 93 b0 01 00 00 call *0x1b0(%rbx) + ctx->grid[offset] = q->c; +ffffffff800017c8: 48 8b 93 c0 02 00 00 mov 0x2c0(%rbx),%rdx +ffffffff800017cf: 4b 8d 04 64 lea (%r12,%r12,2),%rax +ffffffff800017d3: 48 8d 04 82 lea (%rdx,%rax,4),%rax +ffffffff800017d7: 48 8b 55 10 mov 0x10(%rbp),%rdx +ffffffff800017db: 48 89 10 mov %rdx,(%rax) +ffffffff800017de: 8b 55 18 mov 0x18(%rbp),%edx +ffffffff800017e1: 89 50 08 mov %edx,0x8(%rax) + ctx->map[offset] = NULL; +ffffffff800017e4: 48 8b 83 d8 02 00 00 mov 0x2d8(%rbx),%rax +ffffffff800017eb: 4a c7 04 e0 00 00 00 movq $0x0,(%rax,%r12,8) +ffffffff800017f2: 00 + for (size_t i = 0; i < ctx->queue_i; i++) { +ffffffff800017f3: 49 83 c5 01 add $0x1,%r13 +ffffffff800017f7: 4c 3b ab d0 02 00 00 cmp 0x2d0(%rbx),%r13 +ffffffff800017fe: 72 90 jb ffffffff80001790 + } + + if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) { +ffffffff80001800: 48 8b 93 10 03 00 00 mov 0x310(%rbx),%rdx +ffffffff80001807: 48 8b 8b e8 02 00 00 mov 0x2e8(%rbx),%rcx +ffffffff8000180e: 48 39 ca cmp %rcx,%rdx +ffffffff80001811: 74 7d je ffffffff80001890 + if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) { +ffffffff80001813: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff8000181a: 48 39 c2 cmp %rax,%rdx +ffffffff8000181d: 73 3c jae ffffffff8000185b +ffffffff8000181f: 48 8b b3 18 03 00 00 mov 0x318(%rbx),%rsi +ffffffff80001826: 48 3b b3 e0 00 00 00 cmp 0xe0(%rbx),%rsi +ffffffff8000182d: 73 2c jae ffffffff8000185b + ctx->plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y); +ffffffff8000182f: 48 0f af c6 imul %rsi,%rax +ffffffff80001833: 48 89 df mov %rbx,%rdi +ffffffff80001836: 48 01 d0 add %rdx,%rax +ffffffff80001839: 48 8d 0c 40 lea (%rax,%rax,2),%rcx +ffffffff8000183d: 48 8b 83 c0 02 00 00 mov 0x2c0(%rbx),%rax +ffffffff80001844: 48 8d 04 88 lea (%rax,%rcx,4),%rax +ffffffff80001848: 48 89 f1 mov %rsi,%rcx +ffffffff8000184b: 48 89 c6 mov %rax,%rsi +ffffffff8000184e: ff 93 b0 01 00 00 call *0x1b0(%rbx) + } + } + + ctx->old_cursor_x = ctx->cursor_x; +ffffffff80001854: 48 8b 8b e8 02 00 00 mov 0x2e8(%rbx),%rcx + ctx->old_cursor_y = ctx->cursor_y; +ffffffff8000185b: 48 8b 83 f0 02 00 00 mov 0x2f0(%rbx),%rax + ctx->old_cursor_x = ctx->cursor_x; +ffffffff80001862: 48 89 8b 10 03 00 00 mov %rcx,0x310(%rbx) + ctx->old_cursor_y = ctx->cursor_y; +ffffffff80001869: 48 89 83 18 03 00 00 mov %rax,0x318(%rbx) + + ctx->queue_i = 0; +ffffffff80001870: 48 c7 83 d0 02 00 00 movq $0x0,0x2d0(%rbx) +ffffffff80001877: 00 00 00 00 +} +ffffffff8000187b: 48 83 c4 08 add $0x8,%rsp +ffffffff8000187f: 5b pop %rbx +ffffffff80001880: 5d pop %rbp +ffffffff80001881: 41 5c pop %r12 +ffffffff80001883: 41 5d pop %r13 +ffffffff80001885: c3 ret +ffffffff80001886: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000188d: 00 00 00 + if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) { +ffffffff80001890: 48 8b 83 f0 02 00 00 mov 0x2f0(%rbx),%rax +ffffffff80001897: 48 39 83 18 03 00 00 cmp %rax,0x318(%rbx) +ffffffff8000189e: 0f 85 6f ff ff ff jne ffffffff80001813 +ffffffff800018a4: 80 7b 09 00 cmpb $0x0,0x9(%rbx) +ffffffff800018a8: 75 b8 jne ffffffff80001862 +ffffffff800018aa: e9 64 ff ff ff jmp ffffffff80001813 +ffffffff800018af: 90 nop + draw_cursor(_ctx); +ffffffff800018b0: e8 ab fd ff ff call ffffffff80001660 +ffffffff800018b5: e9 c1 fe ff ff jmp ffffffff8000177b +ffffffff800018ba: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff800018c0 : + +static void flanterm_fb_raw_putchar(struct flanterm_context *_ctx, uint8_t c) { +ffffffff800018c0: f3 0f 1e fa endbr64 +ffffffff800018c4: 55 push %rbp +ffffffff800018c5: 53 push %rbx +ffffffff800018c6: 89 f3 mov %esi,%ebx +ffffffff800018c8: 48 83 ec 20 sub $0x20,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) { +ffffffff800018cc: 48 8b 97 e8 02 00 00 mov 0x2e8(%rdi),%rdx +ffffffff800018d3: 48 8b af e8 00 00 00 mov 0xe8(%rdi),%rbp +ffffffff800018da: 48 8b 8f f0 02 00 00 mov 0x2f0(%rdi),%rcx +ffffffff800018e1: 48 39 ea cmp %rbp,%rdx +ffffffff800018e4: 72 50 jb ffffffff80001936 +ffffffff800018e6: 48 8b 47 70 mov 0x70(%rdi),%rax +ffffffff800018ea: 48 8d 70 ff lea -0x1(%rax),%rsi +ffffffff800018ee: 48 39 f1 cmp %rsi,%rcx +ffffffff800018f1: 73 3d jae ffffffff80001930 + ctx->cursor_x = 0; +ffffffff800018f3: 48 c7 87 e8 02 00 00 movq $0x0,0x2e8(%rdi) +ffffffff800018fa: 00 00 00 00 + ctx->cursor_y++; +ffffffff800018fe: 48 8d 51 01 lea 0x1(%rcx),%rdx + if (ctx->cursor_y == _ctx->scroll_bottom_margin) { +ffffffff80001902: 48 39 d0 cmp %rdx,%rax +ffffffff80001905: 0f 84 7d 00 00 00 je ffffffff80001988 + ctx->cursor_y++; +ffffffff8000190b: 48 89 97 f0 02 00 00 mov %rdx,0x2f0(%rdi) +ffffffff80001912: 48 89 d1 mov %rdx,%rcx + ctx->cursor_y--; + flanterm_fb_scroll(_ctx); + } + if (ctx->cursor_y >= _ctx->cols) { +ffffffff80001915: 48 39 e9 cmp %rbp,%rcx +ffffffff80001918: 72 5e jb ffffffff80001978 + ctx->cursor_y = _ctx->cols - 1; +ffffffff8000191a: 48 8d 4d ff lea -0x1(%rbp),%rcx +ffffffff8000191e: be 01 00 00 00 mov $0x1,%esi +ffffffff80001923: 31 d2 xor %edx,%edx +ffffffff80001925: 48 89 8f f0 02 00 00 mov %rcx,0x2f0(%rdi) +ffffffff8000192c: eb 0c jmp ffffffff8000193a +ffffffff8000192e: 66 90 xchg %ax,%ax + if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) { +ffffffff80001930: 80 7f 0a 00 cmpb $0x0,0xa(%rdi) +ffffffff80001934: 75 bd jne ffffffff800018f3 + + struct flanterm_fb_char ch; + ch.c = c; + ch.fg = ctx->text_fg; + ch.bg = ctx->text_bg; + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +ffffffff80001936: 48 8d 72 01 lea 0x1(%rdx),%rsi + ch.c = c; +ffffffff8000193a: 8b 87 e0 02 00 00 mov 0x2e0(%rdi),%eax + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +ffffffff80001940: 48 89 b7 e8 02 00 00 mov %rsi,0x2e8(%rdi) + ch.c = c; +ffffffff80001947: 0f b6 db movzbl %bl,%ebx + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +ffffffff8000194a: 48 8d 74 24 10 lea 0x10(%rsp),%rsi + ch.c = c; +ffffffff8000194f: 48 c1 e0 20 shl $0x20,%rax +ffffffff80001953: 48 09 c3 or %rax,%rbx + ch.bg = ctx->text_bg; +ffffffff80001956: 8b 87 e4 02 00 00 mov 0x2e4(%rdi),%eax + ch.c = c; +ffffffff8000195c: 48 89 5c 24 10 mov %rbx,0x10(%rsp) + ch.bg = ctx->text_bg; +ffffffff80001961: 89 44 24 18 mov %eax,0x18(%rsp) + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +ffffffff80001965: e8 66 f7 ff ff call ffffffff800010d0 +} +ffffffff8000196a: 48 83 c4 20 add $0x20,%rsp +ffffffff8000196e: 5b pop %rbx +ffffffff8000196f: 5d pop %rbp +ffffffff80001970: c3 ret +ffffffff80001971: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) +ffffffff80001978: be 01 00 00 00 mov $0x1,%esi +ffffffff8000197d: 31 d2 xor %edx,%edx +ffffffff8000197f: eb b9 jmp ffffffff8000193a +ffffffff80001981: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) +ffffffff80001988: 48 89 4c 24 08 mov %rcx,0x8(%rsp) + flanterm_fb_scroll(_ctx); +ffffffff8000198d: 48 89 3c 24 mov %rdi,(%rsp) +ffffffff80001991: e8 ca f8 ff ff call ffffffff80001260 +ffffffff80001996: 48 8b 4c 24 08 mov 0x8(%rsp),%rcx +ffffffff8000199b: 48 8b 3c 24 mov (%rsp),%rdi +ffffffff8000199f: e9 71 ff ff ff jmp ffffffff80001915 +ffffffff800019a4: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800019ab: 00 00 00 +ffffffff800019ae: 66 90 xchg %ax,%ax + +ffffffff800019b0 : + +static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) { +ffffffff800019b0: f3 0f 1e fa endbr64 +ffffffff800019b4: 41 55 push %r13 +ffffffff800019b6: 41 54 push %r12 +ffffffff800019b8: 55 push %rbp +ffffffff800019b9: 53 push %rbx +ffffffff800019ba: 48 89 fb mov %rdi,%rbx +ffffffff800019bd: 48 83 ec 08 sub $0x8,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + uint32_t default_bg = ctx->default_bg; + + for (size_t y = 0; y < ctx->height; y++) { +ffffffff800019c1: 4c 8b a7 10 02 00 00 mov 0x210(%rdi),%r12 + uint32_t default_bg = ctx->default_bg; +ffffffff800019c8: 8b af 8c 02 00 00 mov 0x28c(%rdi),%ebp + for (size_t y = 0; y < ctx->height; y++) { +ffffffff800019ce: 4d 85 e4 test %r12,%r12 +ffffffff800019d1: 0f 84 7c 00 00 00 je ffffffff80001a53 + for (size_t x = 0; x < ctx->width; x++) { +ffffffff800019d7: 48 8b bf 08 02 00 00 mov 0x208(%rdi),%rdi +ffffffff800019de: 45 31 db xor %r11d,%r11d + for (size_t y = 0; y < ctx->height; y++) { +ffffffff800019e1: 45 31 d2 xor %r10d,%r10d +ffffffff800019e4: 4c 8d 2c bd 00 00 00 lea 0x0(,%rdi,4),%r13 +ffffffff800019eb: 00 +ffffffff800019ec: 0f 1f 40 00 nopl 0x0(%rax) + for (size_t x = 0; x < ctx->width; x++) { +ffffffff800019f0: 48 85 ff test %rdi,%rdi +ffffffff800019f3: 74 52 je ffffffff80001a47 + if (ctx->canvas != NULL) { + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff800019f5: 48 8b 8b 00 02 00 00 mov 0x200(%rbx),%rcx +ffffffff800019fc: 4c 8b 83 f8 01 00 00 mov 0x1f8(%rbx),%r8 +ffffffff80001a03: 31 c0 xor %eax,%eax + if (ctx->canvas != NULL) { +ffffffff80001a05: 48 8b b3 a0 02 00 00 mov 0x2a0(%rbx),%rsi + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff80001a0c: 48 c1 e9 02 shr $0x2,%rcx +ffffffff80001a10: 49 0f af ca imul %r10,%rcx +ffffffff80001a14: 49 8d 14 88 lea (%r8,%rcx,4),%rdx + if (ctx->canvas != NULL) { +ffffffff80001a18: 48 85 f6 test %rsi,%rsi +ffffffff80001a1b: 0f 84 a7 00 00 00 je ffffffff80001ac8 +ffffffff80001a21: 4e 8d 0c 1e lea (%rsi,%r11,1),%r9 +ffffffff80001a25: eb 11 jmp ffffffff80001a38 +ffffffff80001a27: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80001a2e: 00 00 + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff80001a30: 48 8d 14 08 lea (%rax,%rcx,1),%rdx +ffffffff80001a34: 49 8d 14 90 lea (%r8,%rdx,4),%rdx +ffffffff80001a38: 41 8b 34 81 mov (%r9,%rax,4),%esi + for (size_t x = 0; x < ctx->width; x++) { +ffffffff80001a3c: 48 83 c0 01 add $0x1,%rax + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff80001a40: 89 32 mov %esi,(%rdx) + for (size_t x = 0; x < ctx->width; x++) { +ffffffff80001a42: 48 39 c7 cmp %rax,%rdi +ffffffff80001a45: 75 e9 jne ffffffff80001a30 + for (size_t y = 0; y < ctx->height; y++) { +ffffffff80001a47: 49 83 c2 01 add $0x1,%r10 +ffffffff80001a4b: 4d 01 eb add %r13,%r11 +ffffffff80001a4e: 4d 39 e2 cmp %r12,%r10 +ffffffff80001a51: 75 9d jne ffffffff800019f0 + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg; + } + } + } + + for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) { +ffffffff80001a53: 48 8b 8b e8 00 00 00 mov 0xe8(%rbx),%rcx +ffffffff80001a5a: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff80001a61: 31 ed xor %ebp,%ebp +ffffffff80001a63: 48 0f af c1 imul %rcx,%rax +ffffffff80001a67: 48 85 c0 test %rax,%rax +ffffffff80001a6a: 74 43 je ffffffff80001aaf +ffffffff80001a6c: 0f 1f 40 00 nopl 0x0(%rax) + size_t x = i % _ctx->cols; +ffffffff80001a70: 48 89 e8 mov %rbp,%rax +ffffffff80001a73: 31 d2 xor %edx,%edx + size_t y = i / _ctx->cols; + + ctx->plot_char(_ctx, &ctx->grid[i], x, y); +ffffffff80001a75: 48 8d 74 6d 00 lea 0x0(%rbp,%rbp,2),%rsi +ffffffff80001a7a: 48 89 df mov %rbx,%rdi +ffffffff80001a7d: 48 f7 f1 div %rcx + for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) { +ffffffff80001a80: 48 83 c5 01 add $0x1,%rbp +ffffffff80001a84: 48 89 c1 mov %rax,%rcx + ctx->plot_char(_ctx, &ctx->grid[i], x, y); +ffffffff80001a87: 48 8b 83 c0 02 00 00 mov 0x2c0(%rbx),%rax +ffffffff80001a8e: 48 8d 34 b0 lea (%rax,%rsi,4),%rsi +ffffffff80001a92: ff 93 b0 01 00 00 call *0x1b0(%rbx) + for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) { +ffffffff80001a98: 48 8b 8b e8 00 00 00 mov 0xe8(%rbx),%rcx +ffffffff80001a9f: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff80001aa6: 48 0f af c1 imul %rcx,%rax +ffffffff80001aaa: 48 39 c5 cmp %rax,%rbp +ffffffff80001aad: 72 c1 jb ffffffff80001a70 + } + + if (_ctx->cursor_enabled) { +ffffffff80001aaf: 80 7b 09 00 cmpb $0x0,0x9(%rbx) +ffffffff80001ab3: 75 33 jne ffffffff80001ae8 + draw_cursor(_ctx); + } +} +ffffffff80001ab5: 48 83 c4 08 add $0x8,%rsp +ffffffff80001ab9: 5b pop %rbx +ffffffff80001aba: 5d pop %rbp +ffffffff80001abb: 41 5c pop %r12 +ffffffff80001abd: 41 5d pop %r13 +ffffffff80001abf: c3 ret + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff80001ac0: 48 8d 14 08 lea (%rax,%rcx,1),%rdx +ffffffff80001ac4: 49 8d 14 90 lea (%r8,%rdx,4),%rdx + for (size_t x = 0; x < ctx->width; x++) { +ffffffff80001ac8: 48 83 c0 01 add $0x1,%rax + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg; +ffffffff80001acc: 89 2a mov %ebp,(%rdx) + for (size_t x = 0; x < ctx->width; x++) { +ffffffff80001ace: 48 39 f8 cmp %rdi,%rax +ffffffff80001ad1: 75 ed jne ffffffff80001ac0 + for (size_t y = 0; y < ctx->height; y++) { +ffffffff80001ad3: 49 83 c2 01 add $0x1,%r10 +ffffffff80001ad7: 4d 01 eb add %r13,%r11 +ffffffff80001ada: 4d 39 e2 cmp %r12,%r10 +ffffffff80001add: 0f 85 0d ff ff ff jne ffffffff800019f0 +ffffffff80001ae3: e9 6b ff ff ff jmp ffffffff80001a53 +} +ffffffff80001ae8: 48 83 c4 08 add $0x8,%rsp + draw_cursor(_ctx); +ffffffff80001aec: 48 89 df mov %rbx,%rdi +} +ffffffff80001aef: 5b pop %rbx +ffffffff80001af0: 5d pop %rbp +ffffffff80001af1: 41 5c pop %r12 +ffffffff80001af3: 41 5d pop %r13 + draw_cursor(_ctx); +ffffffff80001af5: e9 66 fb ff ff jmp ffffffff80001660 +ffffffff80001afa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff80001b00 : + +static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) { +ffffffff80001b00: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (_free == NULL) { +ffffffff80001b04: 48 85 f6 test %rsi,%rsi +ffffffff80001b07: 0f 84 8b 00 00 00 je ffffffff80001b98 +static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) { +ffffffff80001b0d: 55 push %rbp +ffffffff80001b0e: 48 89 f5 mov %rsi,%rbp +ffffffff80001b11: 53 push %rbx +ffffffff80001b12: 48 89 fb mov %rdi,%rbx +ffffffff80001b15: 48 83 ec 08 sub $0x8,%rsp + } +#endif + return; + } + + _free(ctx->font_bits, ctx->font_bits_size); +ffffffff80001b19: 48 8b b7 28 02 00 00 mov 0x228(%rdi),%rsi +ffffffff80001b20: 48 8b bf 30 02 00 00 mov 0x230(%rdi),%rdi +ffffffff80001b27: ff d5 call *%rbp + _free(ctx->font_bool, ctx->font_bool_size); +ffffffff80001b29: 48 8b b3 38 02 00 00 mov 0x238(%rbx),%rsi +ffffffff80001b30: 48 8b bb 40 02 00 00 mov 0x240(%rbx),%rdi +ffffffff80001b37: ff d5 call *%rbp + _free(ctx->grid, ctx->grid_size); +ffffffff80001b39: 48 8b b3 a8 02 00 00 mov 0x2a8(%rbx),%rsi +ffffffff80001b40: 48 8b bb c0 02 00 00 mov 0x2c0(%rbx),%rdi +ffffffff80001b47: ff d5 call *%rbp + _free(ctx->queue, ctx->queue_size); +ffffffff80001b49: 48 8b b3 b0 02 00 00 mov 0x2b0(%rbx),%rsi +ffffffff80001b50: 48 8b bb c8 02 00 00 mov 0x2c8(%rbx),%rdi +ffffffff80001b57: ff d5 call *%rbp + _free(ctx->map, ctx->map_size); +ffffffff80001b59: 48 8b bb d8 02 00 00 mov 0x2d8(%rbx),%rdi +ffffffff80001b60: 48 8b b3 b8 02 00 00 mov 0x2b8(%rbx),%rsi +ffffffff80001b67: ff d5 call *%rbp + + if (ctx->canvas != NULL) { +ffffffff80001b69: 48 8b bb a0 02 00 00 mov 0x2a0(%rbx),%rdi +ffffffff80001b70: 48 85 ff test %rdi,%rdi +ffffffff80001b73: 74 09 je ffffffff80001b7e + _free(ctx->canvas, ctx->canvas_size); +ffffffff80001b75: 48 8b b3 98 02 00 00 mov 0x298(%rbx),%rsi +ffffffff80001b7c: ff d5 call *%rbp + } + + _free(ctx, sizeof(struct flanterm_fb_context)); +} +ffffffff80001b7e: 48 83 c4 08 add $0x8,%rsp + _free(ctx, sizeof(struct flanterm_fb_context)); +ffffffff80001b82: 48 89 df mov %rbx,%rdi +ffffffff80001b85: 48 89 e8 mov %rbp,%rax +ffffffff80001b88: be 20 03 00 00 mov $0x320,%esi +} +ffffffff80001b8d: 5b pop %rbx +ffffffff80001b8e: 5d pop %rbp + _free(ctx, sizeof(struct flanterm_fb_context)); +ffffffff80001b8f: ff e0 jmp *%rax +ffffffff80001b91: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + if (bump_allocated_instance == true) { +ffffffff80001b98: 80 3d 62 a5 00 00 00 cmpb $0x0,0xa562(%rip) # ffffffff8000c101 +ffffffff80001b9f: 74 17 je ffffffff80001bb8 + bump_alloc_ptr = 0; +ffffffff80001ba1: 48 c7 05 5c a5 00 00 movq $0x0,0xa55c(%rip) # ffffffff8000c108 +ffffffff80001ba8: 00 00 00 00 + bump_allocated_instance = false; +ffffffff80001bac: c6 05 4e a5 00 00 00 movb $0x0,0xa54e(%rip) # ffffffff8000c101 +ffffffff80001bb3: c3 ret +ffffffff80001bb4: 0f 1f 40 00 nopl 0x0(%rax) +ffffffff80001bb8: c3 ret +ffffffff80001bb9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + +ffffffff80001bc0 : +static void plot_char_scaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001bc0: f3 0f 1e fa endbr64 +ffffffff80001bc4: 41 57 push %r15 +ffffffff80001bc6: 41 56 push %r14 +ffffffff80001bc8: 41 55 push %r13 +ffffffff80001bca: 41 54 push %r12 +ffffffff80001bcc: 55 push %rbp +ffffffff80001bcd: 53 push %rbx +ffffffff80001bce: 48 89 fb mov %rdi,%rbx +ffffffff80001bd1: 48 83 ec 48 sub $0x48,%rsp + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80001bd5: 48 3b 97 e8 00 00 00 cmp 0xe8(%rdi),%rdx +ffffffff80001bdc: 0f 83 9b 01 00 00 jae ffffffff80001d7d +ffffffff80001be2: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80001be9: 0f 83 8e 01 00 00 jae ffffffff80001d7d +ffffffff80001bef: 48 89 f7 mov %rsi,%rdi + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001bf2: 48 8b b3 d0 01 00 00 mov 0x1d0(%rbx),%rsi + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001bf9: 48 0f af 93 c8 01 00 imul 0x1c8(%rbx),%rdx +ffffffff80001c00: 00 + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001c01: 48 8b ab b8 01 00 00 mov 0x1b8(%rbx),%rbp + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001c08: 48 03 93 e8 01 00 00 add 0x1e8(%rbx),%rdx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001c0f: 48 89 f0 mov %rsi,%rax +ffffffff80001c12: 48 89 74 24 10 mov %rsi,0x10(%rsp) +ffffffff80001c17: 48 0f af c1 imul %rcx,%rax + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001c1b: 48 8b 8b 40 02 00 00 mov 0x240(%rbx),%rcx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001c22: 48 03 83 f0 01 00 00 add 0x1f0(%rbx),%rax + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001c29: 48 89 4c 24 18 mov %rcx,0x18(%rsp) +ffffffff80001c2e: 8b 0f mov (%rdi),%ecx +ffffffff80001c30: 48 0f af 8b c0 01 00 imul 0x1c0(%rbx),%rcx +ffffffff80001c37: 00 +ffffffff80001c38: 48 89 4c 24 20 mov %rcx,0x20(%rsp) + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001c3d: 48 85 f6 test %rsi,%rsi +ffffffff80001c40: 0f 84 37 01 00 00 je ffffffff80001d7d + uint8_t fy = gy / ctx->font_scale_y; +ffffffff80001c46: 48 8b b3 e0 01 00 00 mov 0x1e0(%rbx),%rsi + uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width; +ffffffff80001c4d: 48 8b 8b 08 02 00 00 mov 0x208(%rbx),%rcx + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001c54: 45 31 c9 xor %r9d,%r9d + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001c57: 4c 8b 93 00 02 00 00 mov 0x200(%rbx),%r10 + uint8_t fy = gy / ctx->font_scale_y; +ffffffff80001c5e: 48 89 74 24 28 mov %rsi,0x28(%rsp) + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001c63: 48 8b b3 f8 01 00 00 mov 0x1f8(%rbx),%rsi +ffffffff80001c6a: 49 c1 ea 02 shr $0x2,%r10 +ffffffff80001c6e: 48 89 74 24 40 mov %rsi,0x40(%rsp) +ffffffff80001c73: 48 8d 34 8d 00 00 00 lea 0x0(,%rcx,4),%rsi +ffffffff80001c7a: 00 +ffffffff80001c7b: 48 0f af c8 imul %rax,%rcx +ffffffff80001c7f: 48 89 74 24 38 mov %rsi,0x38(%rsp) +ffffffff80001c84: 48 8b b3 a0 02 00 00 mov 0x2a0(%rbx),%rsi +ffffffff80001c8b: 49 0f af c2 imul %r10,%rax +ffffffff80001c8f: 4c 89 54 24 30 mov %r10,0x30(%rsp) + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001c94: 49 89 da mov %rbx,%r10 +ffffffff80001c97: 48 01 d1 add %rdx,%rcx +ffffffff80001c9a: 4c 8d 34 8e lea (%rsi,%rcx,4),%r14 +ffffffff80001c9e: 4c 8d 3c 10 lea (%rax,%rdx,1),%r15 +ffffffff80001ca2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + uint8_t fy = gy / ctx->font_scale_y; +ffffffff80001ca8: 4c 89 c8 mov %r9,%rax +ffffffff80001cab: 31 d2 xor %edx,%edx +ffffffff80001cad: 48 f7 74 24 28 divq 0x28(%rsp) + bool *glyph_pointer = glyph + (fy * ctx->font_width); +ffffffff80001cb2: 0f b6 c8 movzbl %al,%ecx +ffffffff80001cb5: 48 8b 44 24 20 mov 0x20(%rsp),%rax +ffffffff80001cba: 48 01 c1 add %rax,%rcx +ffffffff80001cbd: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80001cc2: 48 0f af cd imul %rbp,%rcx +ffffffff80001cc6: 48 01 c1 add %rax,%rcx + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001cc9: 48 85 ed test %rbp,%rbp +ffffffff80001ccc: 0f 84 8c 00 00 00 je ffffffff80001d5e + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80001cd2: 4d 8b a2 d8 01 00 00 mov 0x1d8(%r10),%r12 +ffffffff80001cd9: 48 8b 44 24 40 mov 0x40(%rsp),%rax +ffffffff80001cde: 4c 8d 2c 29 lea (%rcx,%rbp,1),%r13 +ffffffff80001ce2: 4c 89 ce mov %r9,%rsi +ffffffff80001ce5: 48 89 6c 24 08 mov %rbp,0x8(%rsp) +ffffffff80001cea: 4e 8d 1c a5 00 00 00 lea 0x0(,%r12,4),%r11 +ffffffff80001cf1: 00 +ffffffff80001cf2: 4a 8d 1c b8 lea (%rax,%r15,4),%rbx +ffffffff80001cf6: 4f 8d 04 33 lea (%r11,%r14,1),%r8 +ffffffff80001cfa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80001d00: 4d 85 e4 test %r12,%r12 +ffffffff80001d03: 74 42 je ffffffff80001d47 + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80001d05: 48 89 0c 24 mov %rcx,(%rsp) +ffffffff80001d09: 4c 89 c2 mov %r8,%rdx +ffffffff80001d0c: 0f b6 29 movzbl (%rcx),%ebp +ffffffff80001d0f: 49 89 d9 mov %rbx,%r9 +ffffffff80001d12: 4c 29 da sub %r11,%rdx +ffffffff80001d15: 0f 1f 00 nopl (%rax) + uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg; +ffffffff80001d18: 8b 47 08 mov 0x8(%rdi),%eax +ffffffff80001d1b: 83 f8 ff cmp $0xffffffff,%eax +ffffffff80001d1e: 75 02 jne ffffffff80001d22 +ffffffff80001d20: 8b 02 mov (%rdx),%eax + uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg; +ffffffff80001d22: 8b 4f 04 mov 0x4(%rdi),%ecx +ffffffff80001d25: 83 f9 ff cmp $0xffffffff,%ecx +ffffffff80001d28: 75 02 jne ffffffff80001d2c +ffffffff80001d2a: 8b 0a mov (%rdx),%ecx + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80001d2c: 40 84 ed test %bpl,%bpl +ffffffff80001d2f: 0f 45 c1 cmovne %ecx,%eax + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80001d32: 48 83 c2 04 add $0x4,%rdx +ffffffff80001d36: 49 83 c1 04 add $0x4,%r9 + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80001d3a: 41 89 41 fc mov %eax,-0x4(%r9) + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80001d3e: 49 39 d0 cmp %rdx,%r8 +ffffffff80001d41: 75 d5 jne ffffffff80001d18 +ffffffff80001d43: 48 8b 0c 24 mov (%rsp),%rcx + glyph_pointer++; +ffffffff80001d47: 48 83 c1 01 add $0x1,%rcx + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001d4b: 4d 01 d8 add %r11,%r8 +ffffffff80001d4e: 4c 01 db add %r11,%rbx +ffffffff80001d51: 4c 39 e9 cmp %r13,%rcx +ffffffff80001d54: 75 aa jne ffffffff80001d00 +ffffffff80001d56: 48 8b 6c 24 08 mov 0x8(%rsp),%rbp +ffffffff80001d5b: 49 89 f1 mov %rsi,%r9 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001d5e: 48 8b 44 24 38 mov 0x38(%rsp),%rax +ffffffff80001d63: 49 83 c1 01 add $0x1,%r9 +ffffffff80001d67: 49 01 c6 add %rax,%r14 +ffffffff80001d6a: 48 8b 44 24 30 mov 0x30(%rsp),%rax +ffffffff80001d6f: 49 01 c7 add %rax,%r15 +ffffffff80001d72: 4c 39 4c 24 10 cmp %r9,0x10(%rsp) +ffffffff80001d77: 0f 85 2b ff ff ff jne ffffffff80001ca8 +} +ffffffff80001d7d: 48 83 c4 48 add $0x48,%rsp +ffffffff80001d81: 5b pop %rbx +ffffffff80001d82: 5d pop %rbp +ffffffff80001d83: 41 5c pop %r12 +ffffffff80001d85: 41 5d pop %r13 +ffffffff80001d87: 41 5e pop %r14 +ffffffff80001d89: 41 5f pop %r15 +ffffffff80001d8b: c3 ret +ffffffff80001d8c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001d90 : +static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001d90: f3 0f 1e fa endbr64 +ffffffff80001d94: 48 89 f8 mov %rdi,%rax + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80001d97: 48 3b 97 e8 00 00 00 cmp 0xe8(%rdi),%rdx +ffffffff80001d9e: 0f 83 0c 01 00 00 jae ffffffff80001eb0 +ffffffff80001da4: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80001dab: 0f 83 ff 00 00 00 jae ffffffff80001eb0 +static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001db1: 41 56 push %r14 +ffffffff80001db3: 48 89 f7 mov %rsi,%rdi +ffffffff80001db6: 41 55 push %r13 +ffffffff80001db8: 41 54 push %r12 +ffffffff80001dba: 55 push %rbp +ffffffff80001dbb: 53 push %rbx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001dbc: 4c 8b a0 d0 01 00 00 mov 0x1d0(%rax),%r12 + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001dc3: 8b 1e mov (%rsi),%ebx +ffffffff80001dc5: 4c 8b 88 b8 01 00 00 mov 0x1b8(%rax),%r9 +ffffffff80001dcc: 48 8b b0 c0 01 00 00 mov 0x1c0(%rax),%rsi + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001dd3: 48 0f af 90 c8 01 00 imul 0x1c8(%rax),%rdx +ffffffff80001dda: 00 + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001ddb: 49 0f af cc imul %r12,%rcx + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001ddf: 4c 8b 80 40 02 00 00 mov 0x240(%rax),%r8 + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001de6: 48 03 90 e8 01 00 00 add 0x1e8(%rax),%rdx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001ded: 49 0f af f1 imul %r9,%rsi +ffffffff80001df1: 48 03 88 f0 01 00 00 add 0x1f0(%rax),%rcx + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001df8: 4d 85 e4 test %r12,%r12 +ffffffff80001dfb: 0f 84 a1 00 00 00 je ffffffff80001ea2 + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001e01: 48 8b a8 00 02 00 00 mov 0x200(%rax),%rbp + uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width; +ffffffff80001e08: 4c 8b 90 08 02 00 00 mov 0x208(%rax),%r10 +ffffffff80001e0f: 49 89 cb mov %rcx,%r11 +ffffffff80001e12: 48 0f af f3 imul %rbx,%rsi + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001e16: 4c 8b b0 f8 01 00 00 mov 0x1f8(%rax),%r14 +ffffffff80001e1d: 48 8b 80 a0 02 00 00 mov 0x2a0(%rax),%rax + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001e24: 31 db xor %ebx,%ebx + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001e26: 48 c1 ed 02 shr $0x2,%rbp +ffffffff80001e2a: 49 0f af ca imul %r10,%rcx +ffffffff80001e2e: 4e 8d 2c 95 00 00 00 lea 0x0(,%r10,4),%r13 +ffffffff80001e35: 00 +ffffffff80001e36: 4c 0f af dd imul %rbp,%r11 +ffffffff80001e3a: 49 01 f0 add %rsi,%r8 +ffffffff80001e3d: 49 01 d3 add %rdx,%r11 +ffffffff80001e40: 48 01 ca add %rcx,%rdx +ffffffff80001e43: 4c 8d 14 90 lea (%rax,%rdx,4),%r10 +ffffffff80001e47: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80001e4e: 00 00 + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001e50: 4d 85 c9 test %r9,%r9 +ffffffff80001e53: 74 3b je ffffffff80001e90 +ffffffff80001e55: 4b 8d 34 9e lea (%r14,%r11,4),%rsi +ffffffff80001e59: 31 d2 xor %edx,%edx +ffffffff80001e5b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + uint32_t bg = c->bg == 0xffffffff ? canvas_line[fx] : c->bg; +ffffffff80001e60: 8b 47 08 mov 0x8(%rdi),%eax +ffffffff80001e63: 83 f8 ff cmp $0xffffffff,%eax +ffffffff80001e66: 75 04 jne ffffffff80001e6c +ffffffff80001e68: 41 8b 04 92 mov (%r10,%rdx,4),%eax + uint32_t fg = c->fg == 0xffffffff ? canvas_line[fx] : c->fg; +ffffffff80001e6c: 8b 4f 04 mov 0x4(%rdi),%ecx +ffffffff80001e6f: 83 f9 ff cmp $0xffffffff,%ecx +ffffffff80001e72: 75 04 jne ffffffff80001e78 +ffffffff80001e74: 41 8b 0c 92 mov (%r10,%rdx,4),%ecx + fb_line[fx] = *(glyph_pointer++) ? fg : bg; +ffffffff80001e78: 41 80 3c 10 00 cmpb $0x0,(%r8,%rdx,1) +ffffffff80001e7d: 0f 45 c1 cmovne %ecx,%eax + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001e80: 48 83 c2 01 add $0x1,%rdx +ffffffff80001e84: 48 83 c6 04 add $0x4,%rsi + fb_line[fx] = *(glyph_pointer++) ? fg : bg; +ffffffff80001e88: 89 46 fc mov %eax,-0x4(%rsi) + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001e8b: 49 39 d1 cmp %rdx,%r9 +ffffffff80001e8e: 75 d0 jne ffffffff80001e60 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001e90: 48 83 c3 01 add $0x1,%rbx +ffffffff80001e94: 49 01 eb add %rbp,%r11 +ffffffff80001e97: 4d 01 c8 add %r9,%r8 +ffffffff80001e9a: 4d 01 ea add %r13,%r10 +ffffffff80001e9d: 49 39 dc cmp %rbx,%r12 +ffffffff80001ea0: 75 ae jne ffffffff80001e50 +} +ffffffff80001ea2: 5b pop %rbx +ffffffff80001ea3: 5d pop %rbp +ffffffff80001ea4: 41 5c pop %r12 +ffffffff80001ea6: 41 5d pop %r13 +ffffffff80001ea8: 41 5e pop %r14 +ffffffff80001eaa: c3 ret +ffffffff80001eab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80001eb0: c3 ret +ffffffff80001eb1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001eb8: 00 00 00 +ffffffff80001ebb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001ec0 : +static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001ec0: f3 0f 1e fa endbr64 + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80001ec4: 48 3b 97 e8 00 00 00 cmp 0xe8(%rdi),%rdx +ffffffff80001ecb: 0f 83 ff 00 00 00 jae ffffffff80001fd0 +ffffffff80001ed1: 48 89 f8 mov %rdi,%rax +ffffffff80001ed4: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80001edb: 0f 83 ef 00 00 00 jae ffffffff80001fd0 +static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001ee1: 41 57 push %r15 +ffffffff80001ee3: 41 56 push %r14 +ffffffff80001ee5: 41 55 push %r13 +ffffffff80001ee7: 41 54 push %r12 +ffffffff80001ee9: 55 push %rbp +ffffffff80001eea: 53 push %rbx +ffffffff80001eeb: 44 8b 46 08 mov 0x8(%rsi),%r8d + uint32_t default_bg = ctx->default_bg; +ffffffff80001eef: 44 8b 88 8c 02 00 00 mov 0x28c(%rax),%r9d + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; +ffffffff80001ef6: 8b 7e 04 mov 0x4(%rsi),%edi +ffffffff80001ef9: 41 83 f8 ff cmp $0xffffffff,%r8d + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001efd: 4c 8b a0 d0 01 00 00 mov 0x1d0(%rax),%r12 + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001f04: 44 8b 3e mov (%rsi),%r15d +ffffffff80001f07: 48 8b 98 b8 01 00 00 mov 0x1b8(%rax),%rbx +ffffffff80001f0e: 4c 8b 90 c0 01 00 00 mov 0x1c0(%rax),%r10 + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; +ffffffff80001f15: 45 0f 44 c1 cmove %r9d,%r8d + uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg; +ffffffff80001f19: 83 ff ff cmp $0xffffffff,%edi +ffffffff80001f1c: 41 0f 44 f9 cmove %r9d,%edi + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001f20: 4c 8b 88 40 02 00 00 mov 0x240(%rax),%r9 + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001f27: 48 0f af 90 c8 01 00 imul 0x1c8(%rax),%rdx +ffffffff80001f2e: 00 +ffffffff80001f2f: 48 03 90 e8 01 00 00 add 0x1e8(%rax),%rdx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001f36: 49 0f af cc imul %r12,%rcx +ffffffff80001f3a: 48 03 88 f0 01 00 00 add 0x1f0(%rax),%rcx + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001f41: 4c 0f af d3 imul %rbx,%r10 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001f45: 4d 85 e4 test %r12,%r12 +ffffffff80001f48: 74 7a je ffffffff80001fc4 + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001f4a: 48 8b a8 00 02 00 00 mov 0x200(%rax),%rbp +ffffffff80001f51: 4d 0f af d7 imul %r15,%r10 +ffffffff80001f55: 4c 8b b0 f8 01 00 00 mov 0x1f8(%rax),%r14 +ffffffff80001f5c: 48 8d 04 1a lea (%rdx,%rbx,1),%rax +ffffffff80001f60: 48 c1 ed 02 shr $0x2,%rbp +ffffffff80001f64: 48 0f af cd imul %rbp,%rcx +ffffffff80001f68: 4d 01 d1 add %r10,%r9 +ffffffff80001f6b: 4c 8d 2c ad 00 00 00 lea 0x0(,%rbp,4),%r13 +ffffffff80001f72: 00 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001f73: 45 31 d2 xor %r10d,%r10d +ffffffff80001f76: 48 01 c8 add %rcx,%rax +ffffffff80001f79: 4c 8d 1c 0a lea (%rdx,%rcx,1),%r11 +ffffffff80001f7d: 49 8d 34 86 lea (%r14,%rax,4),%rsi +ffffffff80001f81: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + bool *glyph_pointer = glyph + (gy * ctx->font_width); +ffffffff80001f88: 4c 89 ca mov %r9,%rdx + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001f8b: 48 85 db test %rbx,%rbx +ffffffff80001f8e: 74 22 je ffffffff80001fb2 +ffffffff80001f90: 4b 8d 04 9e lea (%r14,%r11,4),%rax +ffffffff80001f94: 0f 1f 40 00 nopl 0x0(%rax) + fb_line[fx] = *(glyph_pointer++) ? fg : bg; +ffffffff80001f98: 48 83 c2 01 add $0x1,%rdx +ffffffff80001f9c: 89 f9 mov %edi,%ecx +ffffffff80001f9e: 80 7a ff 00 cmpb $0x0,-0x1(%rdx) +ffffffff80001fa2: 41 0f 44 c8 cmove %r8d,%ecx + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001fa6: 48 83 c0 04 add $0x4,%rax + fb_line[fx] = *(glyph_pointer++) ? fg : bg; +ffffffff80001faa: 89 48 fc mov %ecx,-0x4(%rax) + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001fad: 48 39 f0 cmp %rsi,%rax +ffffffff80001fb0: 75 e6 jne ffffffff80001f98 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001fb2: 49 83 c2 01 add $0x1,%r10 +ffffffff80001fb6: 49 01 eb add %rbp,%r11 +ffffffff80001fb9: 4c 01 ee add %r13,%rsi +ffffffff80001fbc: 49 01 d9 add %rbx,%r9 +ffffffff80001fbf: 4d 39 d4 cmp %r10,%r12 +ffffffff80001fc2: 75 c4 jne ffffffff80001f88 +} +ffffffff80001fc4: 5b pop %rbx +ffffffff80001fc5: 5d pop %rbp +ffffffff80001fc6: 41 5c pop %r12 +ffffffff80001fc8: 41 5d pop %r13 +ffffffff80001fca: 41 5e pop %r14 +ffffffff80001fcc: 41 5f pop %r15 +ffffffff80001fce: c3 ret +ffffffff80001fcf: 90 nop +ffffffff80001fd0: c3 ret +ffffffff80001fd1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001fd8: 00 00 00 +ffffffff80001fdb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001fe0 : +static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001fe0: f3 0f 1e fa endbr64 + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80001fe4: 48 3b 97 e8 00 00 00 cmp 0xe8(%rdi),%rdx +ffffffff80001feb: 0f 83 69 01 00 00 jae ffffffff8000215a +static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001ff1: 41 57 push %r15 +ffffffff80001ff3: 41 56 push %r14 +ffffffff80001ff5: 41 55 push %r13 +ffffffff80001ff7: 41 54 push %r12 +ffffffff80001ff9: 55 push %rbp +ffffffff80001ffa: 48 89 fd mov %rdi,%rbp +ffffffff80001ffd: 53 push %rbx +ffffffff80001ffe: 48 83 ec 20 sub $0x20,%rsp + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80002002: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80002009: 0f 83 3c 01 00 00 jae ffffffff8000214b +ffffffff8000200f: 44 8b 7e 08 mov 0x8(%rsi),%r15d + uint32_t default_bg = ctx->default_bg; +ffffffff80002013: 8b 87 8c 02 00 00 mov 0x28c(%rdi),%eax + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; +ffffffff80002019: 44 8b 76 04 mov 0x4(%rsi),%r14d + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff8000201d: 48 8b 9d 40 02 00 00 mov 0x240(%rbp),%rbx + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; +ffffffff80002024: 41 83 ff ff cmp $0xffffffff,%r15d +ffffffff80002028: 44 0f 44 f8 cmove %eax,%r15d + uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg; +ffffffff8000202c: 41 83 fe ff cmp $0xffffffff,%r14d + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80002030: 48 89 5c 24 08 mov %rbx,0x8(%rsp) +ffffffff80002035: 48 8b 9d b8 01 00 00 mov 0x1b8(%rbp),%rbx + uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg; +ffffffff8000203c: 44 0f 44 f0 cmove %eax,%r14d + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80002040: 48 8b 87 c8 01 00 00 mov 0x1c8(%rdi),%rax +ffffffff80002047: 48 0f af c2 imul %rdx,%rax + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff8000204b: 8b 16 mov (%rsi),%edx + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff8000204d: 48 03 87 e8 01 00 00 add 0x1e8(%rdi),%rax + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80002054: 48 0f af 95 c0 01 00 imul 0x1c0(%rbp),%rdx +ffffffff8000205b: 00 + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff8000205c: 48 8b bf d0 01 00 00 mov 0x1d0(%rdi),%rdi +ffffffff80002063: 49 89 fb mov %rdi,%r11 +ffffffff80002066: 48 89 3c 24 mov %rdi,(%rsp) +ffffffff8000206a: 4c 0f af d9 imul %rcx,%r11 + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff8000206e: 48 89 54 24 10 mov %rdx,0x10(%rsp) + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80002073: 4c 03 9d f0 01 00 00 add 0x1f0(%rbp),%r11 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff8000207a: 48 85 ff test %rdi,%rdi +ffffffff8000207d: 0f 84 c8 00 00 00 je ffffffff8000214b + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80002083: 4c 8b ad 00 02 00 00 mov 0x200(%rbp),%r13 +ffffffff8000208a: 48 8b bd f8 01 00 00 mov 0x1f8(%rbp),%rdi + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80002091: 45 31 d2 xor %r10d,%r10d + uint8_t fy = gy / ctx->font_scale_y; +ffffffff80002094: 4c 8b a5 e0 01 00 00 mov 0x1e0(%rbp),%r12 + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff8000209b: 49 c1 ed 02 shr $0x2,%r13 +ffffffff8000209f: 48 89 7c 24 18 mov %rdi,0x18(%rsp) +ffffffff800020a4: 4d 0f af dd imul %r13,%r11 +ffffffff800020a8: 49 01 c3 add %rax,%r11 +ffffffff800020ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + uint8_t fy = gy / ctx->font_scale_y; +ffffffff800020b0: 4c 89 d0 mov %r10,%rax +ffffffff800020b3: 31 d2 xor %edx,%edx +ffffffff800020b5: 49 f7 f4 div %r12 + bool *glyph_pointer = glyph + (fy * ctx->font_width); +ffffffff800020b8: 0f b6 f0 movzbl %al,%esi +ffffffff800020bb: 48 8b 44 24 10 mov 0x10(%rsp),%rax +ffffffff800020c0: 48 01 c6 add %rax,%rsi +ffffffff800020c3: 48 8b 44 24 08 mov 0x8(%rsp),%rax +ffffffff800020c8: 48 0f af f3 imul %rbx,%rsi +ffffffff800020cc: 48 01 c6 add %rax,%rsi + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff800020cf: 48 85 db test %rbx,%rbx +ffffffff800020d2: 74 66 je ffffffff8000213a + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff800020d4: 4c 8b 85 d8 01 00 00 mov 0x1d8(%rbp),%r8 +ffffffff800020db: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx +ffffffff800020e0: 4c 8d 0c 1e lea (%rsi,%rbx,1),%r9 +ffffffff800020e4: 4b 8d 04 18 lea (%r8,%r11,1),%rax +ffffffff800020e8: 4a 8d 3c 85 00 00 00 lea 0x0(,%r8,4),%rdi +ffffffff800020ef: 00 +ffffffff800020f0: 48 8d 0c 81 lea (%rcx,%rax,4),%rcx +ffffffff800020f4: 0f 1f 40 00 nopl 0x0(%rax) +ffffffff800020f8: 4d 85 c0 test %r8,%r8 +ffffffff800020fb: 74 31 je ffffffff8000212e +ffffffff800020fd: 80 3e 00 cmpb $0x0,(%rsi) +ffffffff80002100: 44 89 fa mov %r15d,%edx +ffffffff80002103: 48 89 c8 mov %rcx,%rax +ffffffff80002106: 41 0f 45 d6 cmovne %r14d,%edx +ffffffff8000210a: 48 29 f8 sub %rdi,%rax +ffffffff8000210d: 40 f6 c7 04 test $0x4,%dil +ffffffff80002111: 74 0d je ffffffff80002120 + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80002113: 89 10 mov %edx,(%rax) + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80002115: 48 83 c0 04 add $0x4,%rax +ffffffff80002119: 48 39 c1 cmp %rax,%rcx +ffffffff8000211c: 74 10 je ffffffff8000212e +ffffffff8000211e: 66 90 xchg %ax,%ax + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80002120: 89 10 mov %edx,(%rax) + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80002122: 48 83 c0 08 add $0x8,%rax + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80002126: 89 50 fc mov %edx,-0x4(%rax) + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80002129: 48 39 c1 cmp %rax,%rcx +ffffffff8000212c: 75 f2 jne ffffffff80002120 + glyph_pointer++; +ffffffff8000212e: 48 83 c6 01 add $0x1,%rsi + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80002132: 48 01 f9 add %rdi,%rcx +ffffffff80002135: 4c 39 ce cmp %r9,%rsi +ffffffff80002138: 75 be jne ffffffff800020f8 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff8000213a: 49 83 c2 01 add $0x1,%r10 +ffffffff8000213e: 4d 01 eb add %r13,%r11 +ffffffff80002141: 4c 39 14 24 cmp %r10,(%rsp) +ffffffff80002145: 0f 85 65 ff ff ff jne ffffffff800020b0 +} +ffffffff8000214b: 48 83 c4 20 add $0x20,%rsp +ffffffff8000214f: 5b pop %rbx +ffffffff80002150: 5d pop %rbp +ffffffff80002151: 41 5c pop %r12 +ffffffff80002153: 41 5d pop %r13 +ffffffff80002155: 41 5e pop %r14 +ffffffff80002157: 41 5f pop %r15 +ffffffff80002159: c3 ret +ffffffff8000215a: c3 ret +ffffffff8000215b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80002160 : + uint32_t *default_bg, uint32_t *default_fg, + uint32_t *default_bg_bright, uint32_t *default_fg_bright, + void *font, size_t font_width, size_t font_height, size_t font_spacing, + size_t font_scale_x, size_t font_scale_y, + size_t margin +) { +ffffffff80002160: f3 0f 1e fa endbr64 +ffffffff80002164: 41 57 push %r15 +ffffffff80002166: 49 89 ff mov %rdi,%r15 +ffffffff80002169: 41 56 push %r14 +ffffffff8000216b: 41 55 push %r13 +ffffffff8000216d: 49 89 cd mov %rcx,%r13 +ffffffff80002170: 41 54 push %r12 +ffffffff80002172: 4d 89 c4 mov %r8,%r12 +ffffffff80002175: 55 push %rbp +ffffffff80002176: 53 push %rbx +ffffffff80002177: 48 83 ec 48 sub $0x48,%rsp +ffffffff8000217b: 8b 84 24 88 00 00 00 mov 0x88(%rsp),%eax +ffffffff80002182: 44 8b b4 24 80 00 00 mov 0x80(%rsp),%r14d +ffffffff80002189: 00 +ffffffff8000218a: 48 89 74 24 18 mov %rsi,0x18(%rsp) + if (font_scale_x == 0 || font_scale_y == 0) { +ffffffff8000218f: 48 83 bc 24 08 01 00 cmpq $0x0,0x108(%rsp) +ffffffff80002196: 00 00 +) { +ffffffff80002198: 48 89 54 24 08 mov %rdx,0x8(%rsp) +ffffffff8000219d: 89 44 24 34 mov %eax,0x34(%rsp) +ffffffff800021a1: 8b 84 24 90 00 00 00 mov 0x90(%rsp),%eax +ffffffff800021a8: 4c 89 4c 24 20 mov %r9,0x20(%rsp) +ffffffff800021ad: 48 8b ac 24 f8 00 00 mov 0xf8(%rsp),%rbp +ffffffff800021b4: 00 +ffffffff800021b5: 89 44 24 10 mov %eax,0x10(%rsp) +ffffffff800021b9: 8b 84 24 98 00 00 00 mov 0x98(%rsp),%eax +ffffffff800021c0: 44 88 74 24 33 mov %r14b,0x33(%rsp) +ffffffff800021c5: 89 44 24 38 mov %eax,0x38(%rsp) +ffffffff800021c9: 8b 84 24 a0 00 00 00 mov 0xa0(%rsp),%eax +ffffffff800021d0: 89 44 24 2c mov %eax,0x2c(%rsp) +ffffffff800021d4: 8b 84 24 a8 00 00 00 mov 0xa8(%rsp),%eax +ffffffff800021db: 89 44 24 3c mov %eax,0x3c(%rsp) + if (font_scale_x == 0 || font_scale_y == 0) { +ffffffff800021df: 0f 84 b4 07 00 00 je ffffffff80002999 +ffffffff800021e5: 48 83 bc 24 10 01 00 cmpq $0x0,0x110(%rsp) +ffffffff800021ec: 00 00 +ffffffff800021ee: 0f 84 a5 07 00 00 je ffffffff80002999 + font_scale_x = 4; + font_scale_y = 4; + } + } + + if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) { +ffffffff800021f4: 41 80 fe 07 cmp $0x7,%r14b +ffffffff800021f8: 0f 96 c0 setbe %al +ffffffff800021fb: 44 3a 74 24 10 cmp 0x10(%rsp),%r14b +ffffffff80002200: 0f 95 c2 setne %dl +ffffffff80002203: 08 d0 or %dl,%al +ffffffff80002205: 0f 85 d0 08 00 00 jne ffffffff80002adb +ffffffff8000220b: 44 3a 74 24 2c cmp 0x2c(%rsp),%r14b +ffffffff80002210: 0f 85 c5 08 00 00 jne ffffffff80002adb + return NULL; + } + + if (_malloc == NULL) { +ffffffff80002216: 4d 85 ff test %r15,%r15 +ffffffff80002219: 0f 84 c9 08 00 00 je ffffffff80002ae8 + return NULL; +#endif + } + + struct flanterm_fb_context *ctx = NULL; + ctx = _malloc(sizeof(struct flanterm_fb_context)); +ffffffff8000221f: bf 20 03 00 00 mov $0x320,%edi +ffffffff80002224: 41 ff d7 call *%r15 +ffffffff80002227: 48 89 c3 mov %rax,%rbx + if (ctx == NULL) { +ffffffff8000222a: 48 85 c0 test %rax,%rax +ffffffff8000222d: 0f 84 a8 08 00 00 je ffffffff80002adb + goto fail; + } + + struct flanterm_context *_ctx = (void *)ctx; + memset(ctx, 0, sizeof(struct flanterm_fb_context)); +ffffffff80002233: 31 f6 xor %esi,%esi +ffffffff80002235: ba 20 03 00 00 mov $0x320,%edx +ffffffff8000223a: 48 89 c7 mov %rax,%rdi +ffffffff8000223d: e8 2e 45 00 00 call ffffffff80006770 + + ctx->red_mask_size = red_mask_size; + ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8); + ctx->green_mask_size = green_mask_size; + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); +ffffffff80002242: 8b 74 24 10 mov 0x10(%rsp),%esi + ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8); +ffffffff80002246: 0f b6 44 24 34 movzbl 0x34(%rsp),%eax + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); +ffffffff8000224b: 0f b6 54 24 38 movzbl 0x38(%rsp),%edx + ctx->red_mask_size = red_mask_size; +ffffffff80002250: 0f b6 4c 24 33 movzbl 0x33(%rsp),%ecx + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); +ffffffff80002255: 89 f7 mov %esi,%edi + ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8); +ffffffff80002257: 42 8d 44 30 f8 lea -0x8(%rax,%r14,1),%eax + ctx->red_mask_size = red_mask_size; +ffffffff8000225c: 40 0f b6 f6 movzbl %sil,%esi + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); +ffffffff80002260: 8d 54 3a f8 lea -0x8(%rdx,%rdi,1),%edx + ctx->red_mask_size = red_mask_size; +ffffffff80002264: 88 c5 mov %al,%ch +ffffffff80002266: c1 e6 10 shl $0x10,%esi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002269: 44 0f b6 f0 movzbl %al,%r14d + ctx->red_mask_size = red_mask_size; +ffffffff8000226d: 0f b7 c9 movzwl %cx,%ecx +ffffffff80002270: 89 d7 mov %edx,%edi +ffffffff80002272: 44 0f b6 da movzbl %dl,%r11d +ffffffff80002276: c1 e7 18 shl $0x18,%edi +ffffffff80002279: 09 f1 or %esi,%ecx + ctx->blue_mask_size = blue_mask_size; +ffffffff8000227b: 8b 74 24 2c mov 0x2c(%rsp),%esi + ctx->red_mask_size = red_mask_size; +ffffffff8000227f: 09 f9 or %edi,%ecx + ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8); +ffffffff80002281: 0f b6 7c 24 3c movzbl 0x3c(%rsp),%edi + + if (ansi_colours != NULL) { +ffffffff80002286: 48 83 bc 24 b8 00 00 cmpq $0x0,0xb8(%rsp) +ffffffff8000228d: 00 00 + ctx->blue_mask_size = blue_mask_size; +ffffffff8000228f: 40 88 b3 24 02 00 00 mov %sil,0x224(%rbx) + ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8); +ffffffff80002296: 8d 74 37 f8 lea -0x8(%rdi,%rsi,1),%esi + ctx->red_mask_size = red_mask_size; +ffffffff8000229a: 89 8b 20 02 00 00 mov %ecx,0x220(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022a0: 40 0f b6 fe movzbl %sil,%edi + ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8); +ffffffff800022a4: 40 88 b3 25 02 00 00 mov %sil,0x225(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022ab: 89 7c 24 10 mov %edi,0x10(%rsp) + if (ansi_colours != NULL) { +ffffffff800022af: 0f 84 d6 08 00 00 je ffffffff80002b8b + for (size_t i = 0; i < 8; i++) { +ffffffff800022b5: 45 31 c9 xor %r9d,%r9d + ctx->ansi_colours[i] = convert_colour(_ctx, ansi_colours[i]); +ffffffff800022b8: 48 8b bc 24 b8 00 00 mov 0xb8(%rsp),%rdi +ffffffff800022bf: 00 +ffffffff800022c0: 46 8b 04 8f mov (%rdi,%r9,4),%r8d + uint32_t g = (colour >> 8) & 0xff; +ffffffff800022c4: 44 89 c1 mov %r8d,%ecx +ffffffff800022c7: 0f b6 fd movzbl %ch,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022ca: 44 89 d9 mov %r11d,%ecx + uint32_t g = (colour >> 8) & 0xff; +ffffffff800022cd: 41 89 fa mov %edi,%r10d + uint32_t r = (colour >> 16) & 0xff; +ffffffff800022d0: 44 89 c7 mov %r8d,%edi + uint32_t b = colour & 0xff; +ffffffff800022d3: 45 0f b6 c0 movzbl %r8b,%r8d + uint32_t r = (colour >> 16) & 0xff; +ffffffff800022d7: c1 ef 10 shr $0x10,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022da: 41 d3 e2 shl %cl,%r10d +ffffffff800022dd: 44 89 f1 mov %r14d,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff800022e0: 40 0f b6 ff movzbl %dil,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022e4: d3 e7 shl %cl,%edi +ffffffff800022e6: 0f b6 4c 24 10 movzbl 0x10(%rsp),%ecx +ffffffff800022eb: 44 09 d7 or %r10d,%edi +ffffffff800022ee: 41 d3 e0 shl %cl,%r8d +ffffffff800022f1: 44 09 c7 or %r8d,%edi +ffffffff800022f4: 42 89 bc 8b 48 02 00 mov %edi,0x248(%rbx,%r9,4) +ffffffff800022fb: 00 + for (size_t i = 0; i < 8; i++) { +ffffffff800022fc: 49 83 c1 01 add $0x1,%r9 +ffffffff80002300: 49 83 f9 08 cmp $0x8,%r9 +ffffffff80002304: 75 b2 jne ffffffff800022b8 + ctx->ansi_colours[5] = convert_colour(_ctx, 0x00aa00aa); // magenta + ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan + ctx->ansi_colours[7] = convert_colour(_ctx, 0x00aaaaaa); // grey + } + + if (ansi_bright_colours != NULL) { +ffffffff80002306: 48 83 bc 24 c0 00 00 cmpq $0x0,0xc0(%rsp) +ffffffff8000230d: 00 00 +ffffffff8000230f: 0f 84 ee 08 00 00 je ffffffff80002c03 + for (size_t i = 0; i < 8; i++) { +ffffffff80002315: 45 31 c9 xor %r9d,%r9d + ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]); +ffffffff80002318: 48 8b bc 24 c0 00 00 mov 0xc0(%rsp),%rdi +ffffffff8000231f: 00 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002320: 44 89 f1 mov %r14d,%ecx + ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]); +ffffffff80002323: 46 8b 04 8f mov (%rdi,%r9,4),%r8d + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002327: 45 89 c2 mov %r8d,%r10d +ffffffff8000232a: 41 c1 ea 10 shr $0x10,%r10d +ffffffff8000232e: 45 0f b6 d2 movzbl %r10b,%r10d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002332: 41 d3 e2 shl %cl,%r10d + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002335: 44 89 c1 mov %r8d,%ecx + uint32_t b = colour & 0xff; +ffffffff80002338: 45 0f b6 c0 movzbl %r8b,%r8d + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000233c: 0f b6 fd movzbl %ch,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000233f: 44 89 d9 mov %r11d,%ecx +ffffffff80002342: d3 e7 shl %cl,%edi +ffffffff80002344: 0f b6 4c 24 10 movzbl 0x10(%rsp),%ecx +ffffffff80002349: 44 09 d7 or %r10d,%edi +ffffffff8000234c: 41 d3 e0 shl %cl,%r8d +ffffffff8000234f: 44 09 c7 or %r8d,%edi +ffffffff80002352: 42 89 bc 8b 68 02 00 mov %edi,0x268(%rbx,%r9,4) +ffffffff80002359: 00 + for (size_t i = 0; i < 8; i++) { +ffffffff8000235a: 49 83 c1 01 add $0x1,%r9 +ffffffff8000235e: 49 83 f9 08 cmp $0x8,%r9 +ffffffff80002362: 75 b4 jne ffffffff80002318 + } + + if (default_bg != NULL) { + ctx->default_bg = convert_colour(_ctx, *default_bg); + } else { + ctx->default_bg = 0x00000000; // background (black) +ffffffff80002364: 45 31 c0 xor %r8d,%r8d + if (default_bg != NULL) { +ffffffff80002367: 48 83 bc 24 c8 00 00 cmpq $0x0,0xc8(%rsp) +ffffffff8000236e: 00 00 +ffffffff80002370: 74 31 je ffffffff800023a3 + ctx->default_bg = convert_colour(_ctx, *default_bg); +ffffffff80002372: 48 8b bc 24 c8 00 00 mov 0xc8(%rsp),%rdi +ffffffff80002379: 00 +ffffffff8000237a: 8b 3f mov (%rdi),%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000237c: 89 f9 mov %edi,%ecx + uint32_t b = colour & 0xff; +ffffffff8000237e: 44 0f b6 c7 movzbl %dil,%r8d + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002382: c1 ef 10 shr $0x10,%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002385: 0f b6 cd movzbl %ch,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002388: 40 0f b6 ff movzbl %dil,%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000238c: 41 89 c9 mov %ecx,%r9d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000238f: 89 d1 mov %edx,%ecx +ffffffff80002391: 41 d3 e1 shl %cl,%r9d +ffffffff80002394: 89 f1 mov %esi,%ecx +ffffffff80002396: 41 d3 e0 shl %cl,%r8d +ffffffff80002399: 89 c1 mov %eax,%ecx +ffffffff8000239b: 45 09 c8 or %r9d,%r8d +ffffffff8000239e: d3 e7 shl %cl,%edi +ffffffff800023a0: 41 09 f8 or %edi,%r8d + } + + if (default_fg != NULL) { +ffffffff800023a3: 48 83 bc 24 d0 00 00 cmpq $0x0,0xd0(%rsp) +ffffffff800023aa: 00 00 +ffffffff800023ac: 44 89 83 8c 02 00 00 mov %r8d,0x28c(%rbx) +ffffffff800023b3: 0f 84 a3 09 00 00 je ffffffff80002d5c + ctx->default_fg = convert_colour(_ctx, *default_fg); +ffffffff800023b9: 48 8b bc 24 d0 00 00 mov 0xd0(%rsp),%rdi +ffffffff800023c0: 00 +ffffffff800023c1: 8b 3f mov (%rdi),%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff800023c3: 89 f9 mov %edi,%ecx + uint32_t b = colour & 0xff; +ffffffff800023c5: 44 0f b6 c7 movzbl %dil,%r8d + uint32_t r = (colour >> 16) & 0xff; +ffffffff800023c9: c1 ef 10 shr $0x10,%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff800023cc: 0f b6 cd movzbl %ch,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff800023cf: 40 0f b6 ff movzbl %dil,%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff800023d3: 41 89 c9 mov %ecx,%r9d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800023d6: 89 d1 mov %edx,%ecx +ffffffff800023d8: 41 d3 e1 shl %cl,%r9d +ffffffff800023db: 89 f1 mov %esi,%ecx +ffffffff800023dd: 41 d3 e0 shl %cl,%r8d +ffffffff800023e0: 89 c1 mov %eax,%ecx +ffffffff800023e2: 45 09 c8 or %r9d,%r8d +ffffffff800023e5: d3 e7 shl %cl,%edi +ffffffff800023e7: 41 09 f8 or %edi,%r8d +ffffffff800023ea: 45 89 c2 mov %r8d,%r10d + } else { + ctx->default_fg = convert_colour(_ctx, 0x00aaaaaa); // foreground (grey) + } + + if (default_bg_bright != NULL) { +ffffffff800023ed: 48 83 bc 24 d8 00 00 cmpq $0x0,0xd8(%rsp) +ffffffff800023f4: 00 00 +ffffffff800023f6: 44 89 93 88 02 00 00 mov %r10d,0x288(%rbx) +ffffffff800023fd: 0f 84 cf 08 00 00 je ffffffff80002cd2 + ctx->default_bg_bright = convert_colour(_ctx, *default_bg_bright); +ffffffff80002403: 48 8b bc 24 d8 00 00 mov 0xd8(%rsp),%rdi +ffffffff8000240a: 00 +ffffffff8000240b: 44 8b 07 mov (%rdi),%r8d + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000240e: 44 89 c1 mov %r8d,%ecx +ffffffff80002411: 0f b6 fd movzbl %ch,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002414: 89 d1 mov %edx,%ecx + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002416: 41 89 f9 mov %edi,%r9d + uint32_t b = colour & 0xff; +ffffffff80002419: 41 0f b6 f8 movzbl %r8b,%edi + uint32_t r = (colour >> 16) & 0xff; +ffffffff8000241d: 41 c1 e8 10 shr $0x10,%r8d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002421: 41 d3 e1 shl %cl,%r9d +ffffffff80002424: 89 f1 mov %esi,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002426: 45 0f b6 c0 movzbl %r8b,%r8d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000242a: d3 e7 shl %cl,%edi +ffffffff8000242c: 89 c1 mov %eax,%ecx +ffffffff8000242e: 44 09 cf or %r9d,%edi +ffffffff80002431: 41 d3 e0 shl %cl,%r8d +ffffffff80002434: 44 09 c7 or %r8d,%edi + } else { + ctx->default_bg_bright = convert_colour(_ctx, 0x00555555); // background (black) + } + + if (default_fg_bright != NULL) { +ffffffff80002437: 48 83 bc 24 e0 00 00 cmpq $0x0,0xe0(%rsp) +ffffffff8000243e: 00 00 +ffffffff80002440: 89 bb 94 02 00 00 mov %edi,0x294(%rbx) +ffffffff80002446: 0f 84 60 08 00 00 je ffffffff80002cac + ctx->default_fg_bright = convert_colour(_ctx, *default_fg_bright); +ffffffff8000244c: 48 8b bc 24 e0 00 00 mov 0xe0(%rsp),%rdi +ffffffff80002453: 00 +ffffffff80002454: 8b 3f mov (%rdi),%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002456: 89 f9 mov %edi,%ecx +ffffffff80002458: 0f b6 cd movzbl %ch,%ecx +ffffffff8000245b: 41 89 c8 mov %ecx,%r8d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000245e: 89 d1 mov %edx,%ecx + uint32_t b = colour & 0xff; +ffffffff80002460: 40 0f b6 d7 movzbl %dil,%edx + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002464: 41 d3 e0 shl %cl,%r8d +ffffffff80002467: 89 f1 mov %esi,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002469: 89 fe mov %edi,%esi +ffffffff8000246b: c1 ee 10 shr $0x10,%esi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000246e: d3 e2 shl %cl,%edx +ffffffff80002470: 89 c1 mov %eax,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002472: 40 0f b6 f6 movzbl %sil,%esi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002476: 44 09 c2 or %r8d,%edx +ffffffff80002479: d3 e6 shl %cl,%esi +ffffffff8000247b: 09 f2 or %esi,%edx + } + + ctx->text_fg = ctx->default_fg; + ctx->text_bg = 0xffffffff; + + ctx->framebuffer = (void *)framebuffer; +ffffffff8000247d: 48 8b 44 24 08 mov 0x8(%rsp),%rax +ffffffff80002482: 89 93 90 02 00 00 mov %edx,0x290(%rbx) + ctx->height = height; + ctx->pitch = pitch; + +#define FONT_BYTES ((font_width * font_height * FLANTERM_FB_FONT_GLYPHS) / 8) + + if (font != NULL) { +ffffffff80002488: 48 83 bc 24 e8 00 00 cmpq $0x0,0xe8(%rsp) +ffffffff8000248f: 00 00 + ctx->text_fg = ctx->default_fg; +ffffffff80002491: 44 89 93 e0 02 00 00 mov %r10d,0x2e0(%rbx) + ctx->framebuffer = (void *)framebuffer; +ffffffff80002498: 48 89 83 f8 01 00 00 mov %rax,0x1f8(%rbx) + ctx->pitch = pitch; +ffffffff8000249f: 48 8b 44 24 20 mov 0x20(%rsp),%rax + ctx->text_bg = 0xffffffff; +ffffffff800024a4: c7 83 e4 02 00 00 ff movl $0xffffffff,0x2e4(%rbx) +ffffffff800024ab: ff ff ff + ctx->width = width; +ffffffff800024ae: 4c 89 ab 08 02 00 00 mov %r13,0x208(%rbx) + ctx->height = height; +ffffffff800024b5: 4c 89 a3 10 02 00 00 mov %r12,0x210(%rbx) + ctx->pitch = pitch; +ffffffff800024bc: 48 89 83 00 02 00 00 mov %rax,0x200(%rbx) + if (font != NULL) { +ffffffff800024c3: 0f 84 2e 08 00 00 je ffffffff80002cf7 + ctx->font_width = font_width; +ffffffff800024c9: 48 8b 84 24 f0 00 00 mov 0xf0(%rsp),%rax +ffffffff800024d0: 00 + ctx->font_height = font_height; + ctx->font_bits_size = FONT_BYTES; +ffffffff800024d1: 48 89 ef mov %rbp,%rdi + ctx->font_height = font_height; +ffffffff800024d4: 48 89 ab c0 01 00 00 mov %rbp,0x1c0(%rbx) + ctx->font_bits_size = FONT_BYTES; +ffffffff800024db: 48 0f af f8 imul %rax,%rdi + ctx->font_width = font_width; +ffffffff800024df: 48 89 83 b8 01 00 00 mov %rax,0x1b8(%rbx) + ctx->font_bits_size = FONT_BYTES; +ffffffff800024e6: 48 c1 e7 08 shl $0x8,%rdi +ffffffff800024ea: 48 c1 ef 03 shr $0x3,%rdi +ffffffff800024ee: 48 89 bb 28 02 00 00 mov %rdi,0x228(%rbx) + ctx->font_bits = _malloc(ctx->font_bits_size); +ffffffff800024f5: 41 ff d7 call *%r15 +ffffffff800024f8: 48 89 83 30 02 00 00 mov %rax,0x230(%rbx) +ffffffff800024ff: 48 89 c7 mov %rax,%rdi + if (ctx->font_bits == NULL) { +ffffffff80002502: 48 85 c0 test %rax,%rax +ffffffff80002505: 0f 84 0f 05 00 00 je ffffffff80002a1a + goto fail; + } + memcpy(ctx->font_bits, font, ctx->font_bits_size); +ffffffff8000250b: 48 8b 93 28 02 00 00 mov 0x228(%rbx),%rdx +ffffffff80002512: 48 8b b4 24 e8 00 00 mov 0xe8(%rsp),%rsi +ffffffff80002519: 00 +ffffffff8000251a: e8 21 42 00 00 call ffffffff80006740 + memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size); + } + +#undef FONT_BYTES + + ctx->font_width += font_spacing; +ffffffff8000251f: 48 8b 84 24 00 01 00 mov 0x100(%rsp),%rax +ffffffff80002526: 00 +ffffffff80002527: 48 03 83 b8 01 00 00 add 0x1b8(%rbx),%rax +ffffffff8000252e: 48 89 83 b8 01 00 00 mov %rax,0x1b8(%rbx) + + ctx->font_bool_size = FLANTERM_FB_FONT_GLYPHS * font_height * ctx->font_width * sizeof(bool); +ffffffff80002535: 48 0f af c5 imul %rbp,%rax +ffffffff80002539: 48 c1 e0 08 shl $0x8,%rax +ffffffff8000253d: 48 89 83 38 02 00 00 mov %rax,0x238(%rbx) +ffffffff80002544: 48 89 c7 mov %rax,%rdi + ctx->font_bool = _malloc(ctx->font_bool_size); +ffffffff80002547: 41 ff d7 call *%r15 +ffffffff8000254a: 48 89 83 40 02 00 00 mov %rax,0x240(%rbx) +ffffffff80002551: 48 89 c2 mov %rax,%rdx + if (ctx->font_bool == NULL) { +ffffffff80002554: 48 85 c0 test %rax,%rax +ffffffff80002557: 0f 84 bd 04 00 00 je ffffffff80002a1a + } + + ctx->font_scale_x = font_scale_x; + ctx->font_scale_y = font_scale_y; + + ctx->glyph_width = ctx->font_width * font_scale_x; +ffffffff8000255d: 4c 8b 93 b8 01 00 00 mov 0x1b8(%rbx),%r10 +ffffffff80002564: 49 89 ee mov %rbp,%r14 +ffffffff80002567: 45 31 e4 xor %r12d,%r12d + if ((glyph[y] & (0x80 >> x))) { +ffffffff8000256a: 48 89 de mov %rbx,%rsi +ffffffff8000256d: 4c 8b ab 30 02 00 00 mov 0x230(%rbx),%r13 + ctx->glyph_width = ctx->font_width * font_scale_x; +ffffffff80002574: 49 c7 c1 40 ff ff ff mov $0xffffffffffffff40,%r9 + if ((glyph[y] & (0x80 >> x))) { +ffffffff8000257b: 41 b8 80 00 00 00 mov $0x80,%r8d +ffffffff80002581: 4d 0f af f2 imul %r10,%r14 +ffffffff80002585: 4e 8d 5c 2d 00 lea 0x0(%rbp,%r13,1),%r11 +ffffffff8000258a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + for (size_t y = 0; y < font_height; y++) { +ffffffff80002590: 4a 8d 3c 12 lea (%rdx,%r10,1),%rdi +ffffffff80002594: 4b 8d 04 2c lea (%r12,%r13,1),%rax +ffffffff80002598: 48 89 d3 mov %rdx,%rbx +ffffffff8000259b: 48 85 ed test %rbp,%rbp +ffffffff8000259e: 74 64 je ffffffff80002604 +ffffffff800025a0: 4c 89 64 24 10 mov %r12,0x10(%rsp) +ffffffff800025a5: 0f 1f 00 nopl (%rax) + for (size_t x = 0; x < 8; x++) { +ffffffff800025a8: 4c 89 74 24 08 mov %r14,0x8(%rsp) +ffffffff800025ad: 31 c9 xor %ecx,%ecx +ffffffff800025af: 90 nop + if ((glyph[y] & (0x80 >> x))) { +ffffffff800025b0: 44 0f b6 20 movzbl (%rax),%r12d +ffffffff800025b4: 45 89 c6 mov %r8d,%r14d +ffffffff800025b7: 41 d3 fe sar %cl,%r14d +ffffffff800025ba: 45 85 e6 test %r12d,%r14d + ctx->font_bool[offset] = true; +ffffffff800025bd: 0f 95 04 0b setne (%rbx,%rcx,1) + for (size_t x = 0; x < 8; x++) { +ffffffff800025c1: 48 83 c1 01 add $0x1,%rcx +ffffffff800025c5: 48 83 f9 08 cmp $0x8,%rcx +ffffffff800025c9: 75 e5 jne ffffffff800025b0 +ffffffff800025cb: 4c 8b 74 24 08 mov 0x8(%rsp),%r14 + for (size_t x = 8; x < ctx->font_width; x++) { +ffffffff800025d0: 48 8d 4b 08 lea 0x8(%rbx),%rcx +ffffffff800025d4: 49 83 fa 08 cmp $0x8,%r10 +ffffffff800025d8: 76 16 jbe ffffffff800025f0 + if (i >= 0xc0 && i <= 0xdf) { +ffffffff800025da: 49 83 f9 1f cmp $0x1f,%r9 +ffffffff800025de: 0f 86 1c 04 00 00 jbe ffffffff80002a00 + ctx->font_bool[offset] = (glyph[y] & 1); +ffffffff800025e4: c6 01 00 movb $0x0,(%rcx) + for (size_t x = 8; x < ctx->font_width; x++) { +ffffffff800025e7: 48 83 c1 01 add $0x1,%rcx +ffffffff800025eb: 48 39 f9 cmp %rdi,%rcx +ffffffff800025ee: 75 ea jne ffffffff800025da + for (size_t y = 0; y < font_height; y++) { +ffffffff800025f0: 48 83 c0 01 add $0x1,%rax +ffffffff800025f4: 4c 01 d7 add %r10,%rdi +ffffffff800025f7: 4c 01 d3 add %r10,%rbx +ffffffff800025fa: 49 39 c3 cmp %rax,%r11 +ffffffff800025fd: 75 a9 jne ffffffff800025a8 +ffffffff800025ff: 4c 8b 64 24 10 mov 0x10(%rsp),%r12 + for (size_t i = 0; i < FLANTERM_FB_FONT_GLYPHS; i++) { +ffffffff80002604: 49 83 c1 01 add $0x1,%r9 +ffffffff80002608: 49 01 eb add %rbp,%r11 +ffffffff8000260b: 4c 01 f2 add %r14,%rdx +ffffffff8000260e: 49 01 ec add %rbp,%r12 +ffffffff80002611: 49 83 f9 40 cmp $0x40,%r9 +ffffffff80002615: 0f 85 75 ff ff ff jne ffffffff80002590 + ctx->font_scale_x = font_scale_x; +ffffffff8000261b: 48 8b 84 24 08 01 00 mov 0x108(%rsp),%rax +ffffffff80002622: 00 +ffffffff80002623: 31 d2 xor %edx,%edx +ffffffff80002625: 48 89 f3 mov %rsi,%rbx + ctx->glyph_width = ctx->font_width * font_scale_x; +ffffffff80002628: 4c 0f af 94 24 08 01 imul 0x108(%rsp),%r10 +ffffffff8000262f: 00 00 + ctx->font_scale_x = font_scale_x; +ffffffff80002631: 48 89 86 d8 01 00 00 mov %rax,0x1d8(%rsi) + ctx->font_scale_y = font_scale_y; +ffffffff80002638: 48 8b 84 24 10 01 00 mov 0x110(%rsp),%rax +ffffffff8000263f: 00 +ffffffff80002640: 48 89 86 e0 01 00 00 mov %rax,0x1e0(%rsi) + ctx->glyph_height = font_height * font_scale_y; +ffffffff80002647: 48 0f af e8 imul %rax,%rbp + + _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width; +ffffffff8000264b: 48 8b 84 24 18 01 00 mov 0x118(%rsp),%rax +ffffffff80002652: 00 + ctx->glyph_width = ctx->font_width * font_scale_x; +ffffffff80002653: 4c 89 96 c8 01 00 00 mov %r10,0x1c8(%rsi) + _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width; +ffffffff8000265a: 48 8d 3c 00 lea (%rax,%rax,1),%rdi +ffffffff8000265e: 48 8b 86 08 02 00 00 mov 0x208(%rsi),%rax + ctx->glyph_height = font_height * font_scale_y; +ffffffff80002665: 48 89 ae d0 01 00 00 mov %rbp,0x1d0(%rsi) + _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width; +ffffffff8000266c: 48 29 f8 sub %rdi,%rax +ffffffff8000266f: 49 f7 f2 div %r10 +ffffffff80002672: 48 89 83 e8 00 00 00 mov %rax,0xe8(%rbx) + _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height; +ffffffff80002679: 48 89 c1 mov %rax,%rcx +ffffffff8000267c: 48 89 d6 mov %rdx,%rsi +ffffffff8000267f: 31 d2 xor %edx,%edx +ffffffff80002681: 48 8b 83 10 02 00 00 mov 0x210(%rbx),%rax + + ctx->offset_x = margin + ((ctx->width - margin * 2) % ctx->glyph_width) / 2; +ffffffff80002688: 48 d1 ee shr $1,%rsi +ffffffff8000268b: 48 03 b4 24 18 01 00 add 0x118(%rsp),%rsi +ffffffff80002692: 00 +ffffffff80002693: 48 89 b3 e8 01 00 00 mov %rsi,0x1e8(%rbx) + _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height; +ffffffff8000269a: 48 29 f8 sub %rdi,%rax +ffffffff8000269d: 48 f7 f5 div %rbp + ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2; + + ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char); +ffffffff800026a0: 48 0f af c8 imul %rax,%rcx + ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2; +ffffffff800026a4: 48 d1 ea shr $1,%rdx +ffffffff800026a7: 48 03 94 24 18 01 00 add 0x118(%rsp),%rdx +ffffffff800026ae: 00 + _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height; +ffffffff800026af: 48 89 83 e0 00 00 00 mov %rax,0xe0(%rbx) + ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2; +ffffffff800026b6: 48 89 93 f0 01 00 00 mov %rdx,0x1f0(%rbx) + ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char); +ffffffff800026bd: 48 8d 3c 49 lea (%rcx,%rcx,2),%rdi +ffffffff800026c1: 48 c1 e7 02 shl $0x2,%rdi +ffffffff800026c5: 48 89 bb a8 02 00 00 mov %rdi,0x2a8(%rbx) + ctx->grid = _malloc(ctx->grid_size); +ffffffff800026cc: 41 ff d7 call *%r15 +ffffffff800026cf: 48 89 83 c0 02 00 00 mov %rax,0x2c0(%rbx) + if (ctx->grid == NULL) { +ffffffff800026d6: 48 85 c0 test %rax,%rax +ffffffff800026d9: 0f 84 3b 03 00 00 je ffffffff80002a1a + goto fail; + } + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff800026df: 48 8b bb e0 00 00 00 mov 0xe0(%rbx),%rdi +ffffffff800026e6: 48 0f af bb e8 00 00 imul 0xe8(%rbx),%rdi +ffffffff800026ed: 00 +ffffffff800026ee: 48 85 ff test %rdi,%rdi +ffffffff800026f1: 74 2d je ffffffff80002720 +ffffffff800026f3: 48 8d 14 7f lea (%rdi,%rdi,2),%rdx + ctx->grid[i].c = ' '; + ctx->grid[i].fg = ctx->text_fg; +ffffffff800026f7: 8b b3 e0 02 00 00 mov 0x2e0(%rbx),%esi + ctx->grid[i].bg = ctx->text_bg; +ffffffff800026fd: 8b 8b e4 02 00 00 mov 0x2e4(%rbx),%ecx +ffffffff80002703: 48 8d 14 90 lea (%rax,%rdx,4),%rdx + ctx->grid[i].c = ' '; +ffffffff80002707: c7 00 20 00 00 00 movl $0x20,(%rax) + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff8000270d: 48 83 c0 0c add $0xc,%rax + ctx->grid[i].fg = ctx->text_fg; +ffffffff80002711: 89 70 f8 mov %esi,-0x8(%rax) + ctx->grid[i].bg = ctx->text_bg; +ffffffff80002714: 89 48 fc mov %ecx,-0x4(%rax) + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff80002717: 48 39 c2 cmp %rax,%rdx +ffffffff8000271a: 75 eb jne ffffffff80002707 + } + + ctx->queue_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item); +ffffffff8000271c: 48 c1 e7 05 shl $0x5,%rdi +ffffffff80002720: 48 89 bb b0 02 00 00 mov %rdi,0x2b0(%rbx) + ctx->queue = _malloc(ctx->queue_size); +ffffffff80002727: 41 ff d7 call *%r15 +ffffffff8000272a: 48 89 83 c8 02 00 00 mov %rax,0x2c8(%rbx) +ffffffff80002731: 48 89 c7 mov %rax,%rdi + if (ctx->queue == NULL) { +ffffffff80002734: 48 85 c0 test %rax,%rax +ffffffff80002737: 0f 84 dd 02 00 00 je ffffffff80002a1a + goto fail; + } + ctx->queue_i = 0; +ffffffff8000273d: 48 c7 83 d0 02 00 00 movq $0x0,0x2d0(%rbx) +ffffffff80002744: 00 00 00 00 + memset(ctx->queue, 0, ctx->queue_size); +ffffffff80002748: 48 8b 93 b0 02 00 00 mov 0x2b0(%rbx),%rdx +ffffffff8000274f: 31 f6 xor %esi,%esi +ffffffff80002751: e8 1a 40 00 00 call ffffffff80006770 + + ctx->map_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item *); +ffffffff80002756: 48 8b bb e0 00 00 00 mov 0xe0(%rbx),%rdi +ffffffff8000275d: 48 0f af bb e8 00 00 imul 0xe8(%rbx),%rdi +ffffffff80002764: 00 +ffffffff80002765: 48 c1 e7 03 shl $0x3,%rdi +ffffffff80002769: 48 89 bb b8 02 00 00 mov %rdi,0x2b8(%rbx) + ctx->map = _malloc(ctx->map_size); +ffffffff80002770: 41 ff d7 call *%r15 +ffffffff80002773: 48 89 83 d8 02 00 00 mov %rax,0x2d8(%rbx) +ffffffff8000277a: 48 89 c7 mov %rax,%rdi + if (ctx->map == NULL) { +ffffffff8000277d: 48 85 c0 test %rax,%rax +ffffffff80002780: 0f 84 94 02 00 00 je ffffffff80002a1a + goto fail; + } + memset(ctx->map, 0, ctx->map_size); +ffffffff80002786: 48 8b 93 b8 02 00 00 mov 0x2b8(%rbx),%rdx +ffffffff8000278d: 31 f6 xor %esi,%esi +ffffffff8000278f: e8 dc 3f 00 00 call ffffffff80006770 + + if (canvas != NULL) { +ffffffff80002794: 48 83 bc 24 b0 00 00 cmpq $0x0,0xb0(%rsp) +ffffffff8000279b: 00 00 +ffffffff8000279d: 0f 84 e0 05 00 00 je ffffffff80002d83 + ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t); +ffffffff800027a3: 48 8b bb 08 02 00 00 mov 0x208(%rbx),%rdi +ffffffff800027aa: 48 0f af bb 10 02 00 imul 0x210(%rbx),%rdi +ffffffff800027b1: 00 +ffffffff800027b2: 48 c1 e7 02 shl $0x2,%rdi +ffffffff800027b6: 48 89 bb 98 02 00 00 mov %rdi,0x298(%rbx) + ctx->canvas = _malloc(ctx->canvas_size); +ffffffff800027bd: 41 ff d7 call *%r15 +ffffffff800027c0: 48 89 83 a0 02 00 00 mov %rax,0x2a0(%rbx) +ffffffff800027c7: 48 89 c7 mov %rax,%rdi + if (ctx->canvas == NULL) { +ffffffff800027ca: 48 85 c0 test %rax,%rax +ffffffff800027cd: 0f 84 47 02 00 00 je ffffffff80002a1a + goto fail; + } + for (size_t i = 0; i < ctx->width * ctx->height; i++) { +ffffffff800027d3: 4c 8b 9b 08 02 00 00 mov 0x208(%rbx),%r11 +ffffffff800027da: 4c 0f af 9b 10 02 00 imul 0x210(%rbx),%r11 +ffffffff800027e1: 00 +ffffffff800027e2: 4d 85 db test %r11,%r11 +ffffffff800027e5: 74 5a je ffffffff80002841 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800027e7: 44 0f b6 93 21 02 00 movzbl 0x221(%rbx),%r10d +ffffffff800027ee: 00 +ffffffff800027ef: 44 0f b6 8b 23 02 00 movzbl 0x223(%rbx),%r9d +ffffffff800027f6: 00 + for (size_t i = 0; i < ctx->width * ctx->height; i++) { +ffffffff800027f7: 31 f6 xor %esi,%esi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800027f9: 44 0f b6 83 25 02 00 movzbl 0x225(%rbx),%r8d +ffffffff80002800: 00 + for (size_t i = 0; i < ctx->width * ctx->height; i++) { +ffffffff80002801: 48 8b 94 24 b0 00 00 mov 0xb0(%rsp),%rdx +ffffffff80002808: 00 + ctx->canvas[i] = convert_colour(_ctx, canvas[i]); +ffffffff80002809: 8b 2c b2 mov (%rdx,%rsi,4),%ebp + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000280c: 44 89 d1 mov %r10d,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff8000280f: 89 e8 mov %ebp,%eax +ffffffff80002811: c1 e8 10 shr $0x10,%eax +ffffffff80002814: 0f b6 c0 movzbl %al,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002817: d3 e0 shl %cl,%eax + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002819: 89 e9 mov %ebp,%ecx + uint32_t b = colour & 0xff; +ffffffff8000281b: 40 0f b6 ed movzbl %bpl,%ebp + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000281f: 0f b6 cd movzbl %ch,%ecx +ffffffff80002822: 41 89 cc mov %ecx,%r12d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002825: 44 89 c9 mov %r9d,%ecx +ffffffff80002828: 41 d3 e4 shl %cl,%r12d +ffffffff8000282b: 44 89 c1 mov %r8d,%ecx +ffffffff8000282e: 44 09 e0 or %r12d,%eax +ffffffff80002831: d3 e5 shl %cl,%ebp +ffffffff80002833: 09 e8 or %ebp,%eax +ffffffff80002835: 89 04 b7 mov %eax,(%rdi,%rsi,4) + for (size_t i = 0; i < ctx->width * ctx->height; i++) { +ffffffff80002838: 48 83 c6 01 add $0x1,%rsi +ffffffff8000283c: 49 39 f3 cmp %rsi,%r11 +ffffffff8000283f: 75 c8 jne ffffffff80002809 + } + } + + if (font_scale_x == 1 && font_scale_y == 1) { +ffffffff80002841: 48 83 bc 24 08 01 00 cmpq $0x1,0x108(%rsp) +ffffffff80002848: 00 01 +ffffffff8000284a: 0f 85 6c 05 00 00 jne ffffffff80002dbc +ffffffff80002850: 48 83 bc 24 10 01 00 cmpq $0x1,0x110(%rsp) +ffffffff80002857: 00 01 +ffffffff80002859: 48 c7 c0 90 1d 00 80 mov $0xffffffff80001d90,%rax +ffffffff80002860: 0f 85 56 05 00 00 jne ffffffff80002dbc + if (canvas == NULL) { + ctx->plot_char = plot_char_unscaled_uncanvas; + } else { + ctx->plot_char = plot_char_unscaled_canvas; +ffffffff80002866: 48 89 83 b0 01 00 00 mov %rax,0x1b0(%rbx) + _ctx->restore_state = flanterm_fb_restore_state; + _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush; + _ctx->full_refresh = flanterm_fb_full_refresh; + _ctx->deinit = flanterm_fb_deinit; + + flanterm_context_reinit(_ctx); +ffffffff8000286d: 48 89 df mov %rbx,%rdi + _ctx->raw_putchar = flanterm_fb_raw_putchar; +ffffffff80002870: 48 c7 83 f0 00 00 00 movq $0xffffffff800018c0,0xf0(%rbx) +ffffffff80002877: c0 18 00 80 + _ctx->clear = flanterm_fb_clear; +ffffffff8000287b: 48 c7 83 f8 00 00 00 movq $0xffffffff80001350,0xf8(%rbx) +ffffffff80002882: 50 13 00 80 + _ctx->set_cursor_pos = flanterm_fb_set_cursor_pos; +ffffffff80002886: 48 c7 83 00 01 00 00 movq $0xffffffff800013e0,0x100(%rbx) +ffffffff8000288d: e0 13 00 80 + _ctx->get_cursor_pos = flanterm_fb_get_cursor_pos; +ffffffff80002891: 48 c7 83 08 01 00 00 movq $0xffffffff80001430,0x108(%rbx) +ffffffff80002898: 30 14 00 80 + _ctx->set_text_fg = flanterm_fb_set_text_fg; +ffffffff8000289c: 48 c7 83 10 01 00 00 movq $0xffffffff800014f0,0x110(%rbx) +ffffffff800028a3: f0 14 00 80 + _ctx->set_text_bg = flanterm_fb_set_text_bg; +ffffffff800028a7: 48 c7 83 18 01 00 00 movq $0xffffffff80001510,0x118(%rbx) +ffffffff800028ae: 10 15 00 80 + _ctx->set_text_fg_bright = flanterm_fb_set_text_fg_bright; +ffffffff800028b2: 48 c7 83 20 01 00 00 movq $0xffffffff80001530,0x120(%rbx) +ffffffff800028b9: 30 15 00 80 + _ctx->set_text_bg_bright = flanterm_fb_set_text_bg_bright; +ffffffff800028bd: 48 c7 83 28 01 00 00 movq $0xffffffff80001550,0x128(%rbx) +ffffffff800028c4: 50 15 00 80 + _ctx->set_text_fg_rgb = flanterm_fb_set_text_fg_rgb; +ffffffff800028c8: 48 c7 83 30 01 00 00 movq $0xffffffff80001570,0x130(%rbx) +ffffffff800028cf: 70 15 00 80 + _ctx->set_text_bg_rgb = flanterm_fb_set_text_bg_rgb; +ffffffff800028d3: 48 c7 83 38 01 00 00 movq $0xffffffff800015b0,0x138(%rbx) +ffffffff800028da: b0 15 00 80 + _ctx->set_text_fg_default = flanterm_fb_set_text_fg_default; +ffffffff800028de: 48 c7 83 40 01 00 00 movq $0xffffffff800015f0,0x140(%rbx) +ffffffff800028e5: f0 15 00 80 + _ctx->set_text_bg_default = flanterm_fb_set_text_bg_default; +ffffffff800028e9: 48 c7 83 48 01 00 00 movq $0xffffffff80001610,0x148(%rbx) +ffffffff800028f0: 10 16 00 80 + _ctx->set_text_fg_default_bright = flanterm_fb_set_text_fg_default_bright; +ffffffff800028f4: 48 c7 83 50 01 00 00 movq $0xffffffff80001620,0x150(%rbx) +ffffffff800028fb: 20 16 00 80 + _ctx->set_text_bg_default_bright = flanterm_fb_set_text_bg_default_bright; +ffffffff800028ff: 48 c7 83 58 01 00 00 movq $0xffffffff80001640,0x158(%rbx) +ffffffff80002906: 40 16 00 80 + _ctx->move_character = flanterm_fb_move_character; +ffffffff8000290a: 48 c7 83 60 01 00 00 movq $0xffffffff80001470,0x160(%rbx) +ffffffff80002911: 70 14 00 80 + _ctx->scroll = flanterm_fb_scroll; +ffffffff80002915: 48 c7 83 68 01 00 00 movq $0xffffffff80001260,0x168(%rbx) +ffffffff8000291c: 60 12 00 80 + _ctx->revscroll = flanterm_fb_revscroll; +ffffffff80002920: 48 c7 83 70 01 00 00 movq $0xffffffff80001180,0x170(%rbx) +ffffffff80002927: 80 11 00 80 + _ctx->swap_palette = flanterm_fb_swap_palette; +ffffffff8000292b: 48 c7 83 78 01 00 00 movq $0xffffffff800010b0,0x178(%rbx) +ffffffff80002932: b0 10 00 80 + _ctx->save_state = flanterm_fb_save_state; +ffffffff80002936: 48 c7 83 80 01 00 00 movq $0xffffffff80001050,0x180(%rbx) +ffffffff8000293d: 50 10 00 80 + _ctx->restore_state = flanterm_fb_restore_state; +ffffffff80002941: 48 c7 83 88 01 00 00 movq $0xffffffff80001080,0x188(%rbx) +ffffffff80002948: 80 10 00 80 + _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush; +ffffffff8000294c: 48 c7 83 90 01 00 00 movq $0xffffffff80001760,0x190(%rbx) +ffffffff80002953: 60 17 00 80 + _ctx->full_refresh = flanterm_fb_full_refresh; +ffffffff80002957: 48 c7 83 98 01 00 00 movq $0xffffffff800019b0,0x198(%rbx) +ffffffff8000295e: b0 19 00 80 + _ctx->deinit = flanterm_fb_deinit; +ffffffff80002962: 48 c7 83 a0 01 00 00 movq $0xffffffff80001b00,0x1a0(%rbx) +ffffffff80002969: 00 1b 00 80 + flanterm_context_reinit(_ctx); +ffffffff8000296d: e8 6e 04 00 00 call ffffffff80002de0 + flanterm_fb_full_refresh(_ctx); +ffffffff80002972: 48 89 df mov %rbx,%rdi +ffffffff80002975: e8 36 f0 ff ff call ffffffff800019b0 + +#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC + if (_malloc == bump_alloc) { +ffffffff8000297a: 49 81 ff 00 10 00 80 cmp $0xffffffff80001000,%r15 +ffffffff80002981: 0f 84 29 04 00 00 je ffffffff80002db0 + if (ctx != NULL) { + _free(ctx, sizeof(struct flanterm_fb_context)); + } + + return NULL; +} +ffffffff80002987: 48 83 c4 48 add $0x48,%rsp +ffffffff8000298b: 48 89 d8 mov %rbx,%rax +ffffffff8000298e: 5b pop %rbx +ffffffff8000298f: 5d pop %rbp +ffffffff80002990: 41 5c pop %r12 +ffffffff80002992: 41 5d pop %r13 +ffffffff80002994: 41 5e pop %r14 +ffffffff80002996: 41 5f pop %r15 +ffffffff80002998: c3 ret + if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) { +ffffffff80002999: 49 81 fd ff 13 00 00 cmp $0x13ff,%r13 +ffffffff800029a0: 76 25 jbe ffffffff800029c7 + font_scale_y = 4; +ffffffff800029a2: 48 c7 84 24 10 01 00 movq $0x4,0x110(%rsp) +ffffffff800029a9: 00 04 00 00 00 + font_scale_x = 4; +ffffffff800029ae: 48 c7 84 24 08 01 00 movq $0x4,0x108(%rsp) +ffffffff800029b5: 00 04 00 00 00 + if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) { +ffffffff800029ba: 49 81 fc 3f 0b 00 00 cmp $0xb3f,%r12 +ffffffff800029c1: 0f 87 2d f8 ff ff ja ffffffff800021f4 + if (width >= (1920 + 1920 / 3) && height >= (1080 + 1080 / 3)) { +ffffffff800029c7: 49 81 fd ff 09 00 00 cmp $0x9ff,%r13 +ffffffff800029ce: 0f 97 c2 seta %dl +ffffffff800029d1: 31 c0 xor %eax,%eax +ffffffff800029d3: 49 81 fc 9f 05 00 00 cmp $0x59f,%r12 +ffffffff800029da: 0f 97 c0 seta %al +ffffffff800029dd: 48 21 d0 and %rdx,%rax +ffffffff800029e0: 48 83 c0 01 add $0x1,%rax +ffffffff800029e4: 48 89 84 24 08 01 00 mov %rax,0x108(%rsp) +ffffffff800029eb: 00 +ffffffff800029ec: 48 89 84 24 10 01 00 mov %rax,0x110(%rsp) +ffffffff800029f3: 00 +ffffffff800029f4: e9 fb f7 ff ff jmp ffffffff800021f4 +ffffffff800029f9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + ctx->font_bool[offset] = (glyph[y] & 1); +ffffffff80002a00: 44 0f b6 20 movzbl (%rax),%r12d + for (size_t x = 8; x < ctx->font_width; x++) { +ffffffff80002a04: 48 83 c1 01 add $0x1,%rcx + ctx->font_bool[offset] = (glyph[y] & 1); +ffffffff80002a08: 41 83 e4 01 and $0x1,%r12d +ffffffff80002a0c: 44 88 61 ff mov %r12b,-0x1(%rcx) + for (size_t x = 8; x < ctx->font_width; x++) { +ffffffff80002a10: 48 39 f9 cmp %rdi,%rcx +ffffffff80002a13: 75 eb jne ffffffff80002a00 +ffffffff80002a15: e9 d6 fb ff ff jmp ffffffff800025f0 + if (_malloc == bump_alloc) { +ffffffff80002a1a: 49 81 ff 00 10 00 80 cmp $0xffffffff80001000,%r15 +ffffffff80002a21: 0f 84 a1 03 00 00 je ffffffff80002dc8 + if (_free == NULL) { +ffffffff80002a27: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002a2c: 48 85 c0 test %rax,%rax +ffffffff80002a2f: 0f 84 a6 00 00 00 je ffffffff80002adb + if (ctx->canvas != NULL) { +ffffffff80002a35: 48 8b bb a0 02 00 00 mov 0x2a0(%rbx),%rdi +ffffffff80002a3c: 48 85 ff test %rdi,%rdi +ffffffff80002a3f: 74 09 je ffffffff80002a4a + _free(ctx->canvas, ctx->canvas_size); +ffffffff80002a41: 48 8b b3 98 02 00 00 mov 0x298(%rbx),%rsi +ffffffff80002a48: ff d0 call *%rax + if (ctx->map != NULL) { +ffffffff80002a4a: 48 8b bb d8 02 00 00 mov 0x2d8(%rbx),%rdi +ffffffff80002a51: 48 85 ff test %rdi,%rdi +ffffffff80002a54: 74 0e je ffffffff80002a64 + _free(ctx->map, ctx->map_size); +ffffffff80002a56: 48 8b b3 b8 02 00 00 mov 0x2b8(%rbx),%rsi +ffffffff80002a5d: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002a62: ff d0 call *%rax + if (ctx->queue != NULL) { +ffffffff80002a64: 48 8b bb c8 02 00 00 mov 0x2c8(%rbx),%rdi +ffffffff80002a6b: 48 85 ff test %rdi,%rdi +ffffffff80002a6e: 74 0e je ffffffff80002a7e + _free(ctx->queue, ctx->queue_size); +ffffffff80002a70: 48 8b b3 b0 02 00 00 mov 0x2b0(%rbx),%rsi +ffffffff80002a77: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002a7c: ff d0 call *%rax + if (ctx->grid != NULL) { +ffffffff80002a7e: 48 8b bb c0 02 00 00 mov 0x2c0(%rbx),%rdi +ffffffff80002a85: 48 85 ff test %rdi,%rdi +ffffffff80002a88: 74 0e je ffffffff80002a98 + _free(ctx->grid, ctx->grid_size); +ffffffff80002a8a: 48 8b b3 a8 02 00 00 mov 0x2a8(%rbx),%rsi +ffffffff80002a91: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002a96: ff d0 call *%rax + if (ctx->font_bool != NULL) { +ffffffff80002a98: 48 8b bb 40 02 00 00 mov 0x240(%rbx),%rdi +ffffffff80002a9f: 48 85 ff test %rdi,%rdi +ffffffff80002aa2: 74 0e je ffffffff80002ab2 + _free(ctx->font_bool, ctx->font_bool_size); +ffffffff80002aa4: 48 8b b3 38 02 00 00 mov 0x238(%rbx),%rsi +ffffffff80002aab: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002ab0: ff d0 call *%rax + if (ctx->font_bits != NULL) { +ffffffff80002ab2: 48 8b bb 30 02 00 00 mov 0x230(%rbx),%rdi +ffffffff80002ab9: 48 85 ff test %rdi,%rdi +ffffffff80002abc: 74 0e je ffffffff80002acc + _free(ctx->font_bits, ctx->font_bits_size); +ffffffff80002abe: 48 8b b3 28 02 00 00 mov 0x228(%rbx),%rsi +ffffffff80002ac5: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002aca: ff d0 call *%rax + _free(ctx, sizeof(struct flanterm_fb_context)); +ffffffff80002acc: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002ad1: be 20 03 00 00 mov $0x320,%esi +ffffffff80002ad6: 48 89 df mov %rbx,%rdi +ffffffff80002ad9: ff d0 call *%rax + return NULL; +ffffffff80002adb: 31 db xor %ebx,%ebx +ffffffff80002add: e9 a5 fe ff ff jmp ffffffff80002987 +ffffffff80002ae2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + if (bump_allocated_instance == true) { +ffffffff80002ae8: 80 3d 12 96 00 00 00 cmpb $0x0,0x9612(%rip) # ffffffff8000c101 +ffffffff80002aef: 75 ea jne ffffffff80002adb + if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) { +ffffffff80002af1: 49 81 fd 80 07 00 00 cmp $0x780,%r13 +ffffffff80002af8: 77 20 ja ffffffff80002b1a + canvas = NULL; +ffffffff80002afa: 48 c7 84 24 b0 00 00 movq $0x0,0xb0(%rsp) +ffffffff80002b01: 00 00 00 00 00 + _malloc = bump_alloc; +ffffffff80002b06: 49 c7 c7 00 10 00 80 mov $0xffffffff80001000,%r15 + if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) { +ffffffff80002b0d: 49 81 fc b0 04 00 00 cmp $0x4b0,%r12 +ffffffff80002b14: 0f 86 05 f7 ff ff jbe ffffffff8000221f + size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width; +ffffffff80002b1a: ba 80 07 00 00 mov $0x780,%edx + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); +ffffffff80002b1f: 4c 89 e0 mov %r12,%rax + size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height; +ffffffff80002b22: be b0 04 00 00 mov $0x4b0,%esi + canvas = NULL; +ffffffff80002b27: 48 c7 84 24 b0 00 00 movq $0x0,0xb0(%rsp) +ffffffff80002b2e: 00 00 00 00 00 + size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width; +ffffffff80002b33: 49 39 d5 cmp %rdx,%r13 + _malloc = bump_alloc; +ffffffff80002b36: 49 c7 c7 00 10 00 80 mov $0xffffffff80001000,%r15 + size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width; +ffffffff80002b3d: 49 0f 46 d5 cmovbe %r13,%rdx + size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height; +ffffffff80002b41: 49 39 f4 cmp %rsi,%r12 +ffffffff80002b44: 49 0f 46 f4 cmovbe %r12,%rsi + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); +ffffffff80002b48: 48 d1 e8 shr $1,%rax +ffffffff80002b4b: 49 89 d0 mov %rdx,%r8 +ffffffff80002b4e: 48 89 f7 mov %rsi,%rdi +ffffffff80002b51: 49 d1 e8 shr $1,%r8 + height = height_limit; +ffffffff80002b54: 49 89 f4 mov %rsi,%r12 + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); +ffffffff80002b57: 48 d1 ef shr $1,%rdi +ffffffff80002b5a: 48 29 f8 sub %rdi,%rax +ffffffff80002b5d: 48 8b 7c 24 20 mov 0x20(%rsp),%rdi +ffffffff80002b62: 48 0f af c7 imul %rdi,%rax +ffffffff80002b66: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi +ffffffff80002b6b: 48 01 c7 add %rax,%rdi +ffffffff80002b6e: 48 89 f8 mov %rdi,%rax +ffffffff80002b71: 4c 89 ef mov %r13,%rdi + width = width_limit; +ffffffff80002b74: 49 89 d5 mov %rdx,%r13 + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); +ffffffff80002b77: 48 d1 ef shr $1,%rdi +ffffffff80002b7a: 4c 29 c7 sub %r8,%rdi +ffffffff80002b7d: 48 8d 04 b8 lea (%rax,%rdi,4),%rax +ffffffff80002b81: 48 89 44 24 08 mov %rax,0x8(%rsp) + height = height_limit; +ffffffff80002b86: e9 94 f6 ff ff jmp ffffffff8000221f + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002b8b: bf aa 00 00 00 mov $0xaa,%edi +ffffffff80002b90: 89 c1 mov %eax,%ecx +ffffffff80002b92: 41 b8 55 00 00 00 mov $0x55,%r8d + ctx->ansi_colours[0] = convert_colour(_ctx, 0x00000000); // black +ffffffff80002b98: c7 83 48 02 00 00 00 movl $0x0,0x248(%rbx) +ffffffff80002b9f: 00 00 00 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002ba2: 41 89 f9 mov %edi,%r9d +ffffffff80002ba5: 41 89 fa mov %edi,%r10d +ffffffff80002ba8: 41 d3 e1 shl %cl,%r9d +ffffffff80002bab: 89 d1 mov %edx,%ecx +ffffffff80002bad: 41 d3 e0 shl %cl,%r8d +ffffffff80002bb0: 41 d3 e2 shl %cl,%r10d + ctx->ansi_colours[1] = convert_colour(_ctx, 0x00aa0000); // red +ffffffff80002bb3: 44 89 8b 4c 02 00 00 mov %r9d,0x24c(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002bba: 44 89 c1 mov %r8d,%ecx + ctx->ansi_colours[2] = convert_colour(_ctx, 0x0000aa00); // green +ffffffff80002bbd: 44 89 93 50 02 00 00 mov %r10d,0x250(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002bc4: 44 09 c9 or %r9d,%ecx +ffffffff80002bc7: 89 8b 54 02 00 00 mov %ecx,0x254(%rbx) +ffffffff80002bcd: 89 f1 mov %esi,%ecx +ffffffff80002bcf: d3 e7 shl %cl,%edi +ffffffff80002bd1: 89 f9 mov %edi,%ecx + ctx->ansi_colours[4] = convert_colour(_ctx, 0x000000aa); // blue +ffffffff80002bd3: 89 bb 58 02 00 00 mov %edi,0x258(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002bd9: 44 09 d7 or %r10d,%edi +ffffffff80002bdc: 44 09 c9 or %r9d,%ecx + ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan +ffffffff80002bdf: 89 bb 60 02 00 00 mov %edi,0x260(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002be5: 44 09 cf or %r9d,%edi + if (ansi_bright_colours != NULL) { +ffffffff80002be8: 48 83 bc 24 c0 00 00 cmpq $0x0,0xc0(%rsp) +ffffffff80002bef: 00 00 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002bf1: 89 8b 5c 02 00 00 mov %ecx,0x25c(%rbx) +ffffffff80002bf7: 89 bb 64 02 00 00 mov %edi,0x264(%rbx) + if (ansi_bright_colours != NULL) { +ffffffff80002bfd: 0f 85 12 f7 ff ff jne ffffffff80002315 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002c03: bf 55 00 00 00 mov $0x55,%edi +ffffffff80002c08: 41 b8 ff 00 00 00 mov $0xff,%r8d +ffffffff80002c0e: 89 c1 mov %eax,%ecx +ffffffff80002c10: 45 89 c1 mov %r8d,%r9d +ffffffff80002c13: 41 89 fb mov %edi,%r11d +ffffffff80002c16: 41 d3 e1 shl %cl,%r9d +ffffffff80002c19: 41 d3 e3 shl %cl,%r11d +ffffffff80002c1c: 49 c1 e1 20 shl $0x20,%r9 +ffffffff80002c20: 4c 89 d9 mov %r11,%rcx +ffffffff80002c23: 41 89 fb mov %edi,%r11d +ffffffff80002c26: 4c 09 c9 or %r9,%rcx +ffffffff80002c29: 49 89 ca mov %rcx,%r10 +ffffffff80002c2c: 89 d1 mov %edx,%ecx +ffffffff80002c2e: 41 d3 e3 shl %cl,%r11d +ffffffff80002c31: 4d 89 d9 mov %r11,%r9 +ffffffff80002c34: 4c 89 d9 mov %r11,%rcx +ffffffff80002c37: 49 c1 e1 20 shl $0x20,%r9 +ffffffff80002c3b: 4c 09 c9 or %r9,%rcx +ffffffff80002c3e: 45 89 c1 mov %r8d,%r9d +ffffffff80002c41: 4c 09 d1 or %r10,%rcx +ffffffff80002c44: 49 89 cb mov %rcx,%r11 +ffffffff80002c47: 89 d1 mov %edx,%ecx +ffffffff80002c49: 41 d3 e1 shl %cl,%r9d +ffffffff80002c4c: 4c 89 c9 mov %r9,%rcx +ffffffff80002c4f: 49 c1 e1 20 shl $0x20,%r9 +ffffffff80002c53: 4c 09 c9 or %r9,%rcx +ffffffff80002c56: 4c 09 d1 or %r10,%rcx +ffffffff80002c59: 49 89 c9 mov %rcx,%r9 +ffffffff80002c5c: 89 f1 mov %esi,%ecx +ffffffff80002c5e: d3 e7 shl %cl,%edi +ffffffff80002c60: 48 89 f9 mov %rdi,%rcx +ffffffff80002c63: 48 c1 e1 20 shl $0x20,%rcx +ffffffff80002c67: 48 09 cf or %rcx,%rdi +ffffffff80002c6a: 89 f1 mov %esi,%ecx +ffffffff80002c6c: 41 d3 e0 shl %cl,%r8d +ffffffff80002c6f: 4c 89 c1 mov %r8,%rcx +ffffffff80002c72: 48 c1 e1 20 shl $0x20,%rcx +ffffffff80002c76: 4c 09 c1 or %r8,%rcx +ffffffff80002c79: 4d 89 d8 mov %r11,%r8 +ffffffff80002c7c: 49 09 f8 or %rdi,%r8 +ffffffff80002c7f: 4c 09 cf or %r9,%rdi + ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black +ffffffff80002c82: 48 89 bb 70 02 00 00 mov %rdi,0x270(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002c89: 4c 89 df mov %r11,%rdi +ffffffff80002c8c: 48 09 cf or %rcx,%rdi +ffffffff80002c8f: 4c 09 c9 or %r9,%rcx + ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black +ffffffff80002c92: 4c 89 83 68 02 00 00 mov %r8,0x268(%rbx) +ffffffff80002c99: 48 89 bb 78 02 00 00 mov %rdi,0x278(%rbx) +ffffffff80002ca0: 48 89 8b 80 02 00 00 mov %rcx,0x280(%rbx) +ffffffff80002ca7: e9 b8 f6 ff ff jmp ffffffff80002364 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002cac: bf ff 00 00 00 mov $0xff,%edi +ffffffff80002cb1: 89 d1 mov %edx,%ecx +ffffffff80002cb3: 41 89 f8 mov %edi,%r8d +ffffffff80002cb6: 41 d3 e0 shl %cl,%r8d +ffffffff80002cb9: 89 f1 mov %esi,%ecx +ffffffff80002cbb: 44 89 c2 mov %r8d,%edx +ffffffff80002cbe: 41 89 f8 mov %edi,%r8d +ffffffff80002cc1: 41 d3 e0 shl %cl,%r8d +ffffffff80002cc4: 89 c1 mov %eax,%ecx +ffffffff80002cc6: 44 09 c2 or %r8d,%edx +ffffffff80002cc9: d3 e7 shl %cl,%edi +ffffffff80002ccb: 09 fa or %edi,%edx +ffffffff80002ccd: e9 ab f7 ff ff jmp ffffffff8000247d +ffffffff80002cd2: 41 b8 55 00 00 00 mov $0x55,%r8d +ffffffff80002cd8: 89 d1 mov %edx,%ecx +ffffffff80002cda: 45 89 c1 mov %r8d,%r9d +ffffffff80002cdd: 44 89 c7 mov %r8d,%edi +ffffffff80002ce0: 41 d3 e1 shl %cl,%r9d +ffffffff80002ce3: 89 f1 mov %esi,%ecx +ffffffff80002ce5: d3 e7 shl %cl,%edi +ffffffff80002ce7: 89 c1 mov %eax,%ecx +ffffffff80002ce9: 44 09 cf or %r9d,%edi +ffffffff80002cec: 41 d3 e0 shl %cl,%r8d +ffffffff80002cef: 44 09 c7 or %r8d,%edi +ffffffff80002cf2: e9 40 f7 ff ff jmp ffffffff80002437 + ctx->font_width = font_width = 8; +ffffffff80002cf7: 48 c7 83 b8 01 00 00 movq $0x8,0x1b8(%rbx) +ffffffff80002cfe: 08 00 00 00 + ctx->font_bits = _malloc(ctx->font_bits_size); +ffffffff80002d02: bf 00 10 00 00 mov $0x1000,%edi + ctx->font_height = font_height = 16; +ffffffff80002d07: 48 c7 83 c0 01 00 00 movq $0x10,0x1c0(%rbx) +ffffffff80002d0e: 10 00 00 00 + ctx->font_bits_size = FONT_BYTES; +ffffffff80002d12: 48 c7 83 28 02 00 00 movq $0x1000,0x228(%rbx) +ffffffff80002d19: 00 10 00 00 + ctx->font_bits = _malloc(ctx->font_bits_size); +ffffffff80002d1d: 41 ff d7 call *%r15 +ffffffff80002d20: 48 89 83 30 02 00 00 mov %rax,0x230(%rbx) +ffffffff80002d27: 48 89 c7 mov %rax,%rdi + if (ctx->font_bits == NULL) { +ffffffff80002d2a: 48 85 c0 test %rax,%rax +ffffffff80002d2d: 0f 84 e7 fc ff ff je ffffffff80002a1a + memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size); +ffffffff80002d33: 48 8b 93 28 02 00 00 mov 0x228(%rbx),%rdx +ffffffff80002d3a: 48 c7 c6 00 80 00 80 mov $0xffffffff80008000,%rsi + ctx->font_height = font_height = 16; +ffffffff80002d41: bd 10 00 00 00 mov $0x10,%ebp + memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size); +ffffffff80002d46: e8 f5 39 00 00 call ffffffff80006740 + font_spacing = 1; +ffffffff80002d4b: 48 c7 84 24 00 01 00 movq $0x1,0x100(%rsp) +ffffffff80002d52: 00 01 00 00 00 +ffffffff80002d57: e9 c3 f7 ff ff jmp ffffffff8000251f + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002d5c: bf aa 00 00 00 mov $0xaa,%edi +ffffffff80002d61: 89 d1 mov %edx,%ecx +ffffffff80002d63: 41 89 f9 mov %edi,%r9d +ffffffff80002d66: 41 89 f8 mov %edi,%r8d +ffffffff80002d69: 41 d3 e1 shl %cl,%r9d +ffffffff80002d6c: 89 f1 mov %esi,%ecx +ffffffff80002d6e: 41 d3 e0 shl %cl,%r8d +ffffffff80002d71: 89 c1 mov %eax,%ecx +ffffffff80002d73: 45 09 c8 or %r9d,%r8d +ffffffff80002d76: d3 e7 shl %cl,%edi +ffffffff80002d78: 41 09 f8 or %edi,%r8d +ffffffff80002d7b: 45 89 c2 mov %r8d,%r10d +ffffffff80002d7e: e9 6a f6 ff ff jmp ffffffff800023ed + if (font_scale_x == 1 && font_scale_y == 1) { +ffffffff80002d83: 48 83 bc 24 10 01 00 cmpq $0x1,0x110(%rsp) +ffffffff80002d8a: 00 01 +ffffffff80002d8c: 75 16 jne ffffffff80002da4 +ffffffff80002d8e: 48 83 bc 24 08 01 00 cmpq $0x1,0x108(%rsp) +ffffffff80002d95: 00 01 +ffffffff80002d97: 48 c7 c0 c0 1e 00 80 mov $0xffffffff80001ec0,%rax +ffffffff80002d9e: 0f 84 c2 fa ff ff je ffffffff80002866 +ffffffff80002da4: 48 c7 c0 e0 1f 00 80 mov $0xffffffff80001fe0,%rax +ffffffff80002dab: e9 b6 fa ff ff jmp ffffffff80002866 + bump_allocated_instance = true; +ffffffff80002db0: c6 05 4a 93 00 00 01 movb $0x1,0x934a(%rip) # ffffffff8000c101 +ffffffff80002db7: e9 cb fb ff ff jmp ffffffff80002987 + if (font_scale_x == 1 && font_scale_y == 1) { +ffffffff80002dbc: 48 c7 c0 c0 1b 00 80 mov $0xffffffff80001bc0,%rax +ffffffff80002dc3: e9 9e fa ff ff jmp ffffffff80002866 + bump_alloc_ptr = 0; +ffffffff80002dc8: 48 c7 05 35 93 00 00 movq $0x0,0x9335(%rip) # ffffffff8000c108 +ffffffff80002dcf: 00 00 00 00 + return NULL; +ffffffff80002dd3: 31 db xor %ebx,%ebx +ffffffff80002dd5: e9 ad fb ff ff jmp ffffffff80002987 +ffffffff80002dda: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff80002de0 : +}; + +#define CHARSET_DEFAULT 0 +#define CHARSET_DEC_SPECIAL 1 + +void flanterm_context_reinit(struct flanterm_context *ctx) { +ffffffff80002de0: f3 0f 1e fa endbr64 + ctx->rrr = false; + ctx->discard_next = false; + ctx->bold = false; + ctx->bg_bold = false; + ctx->reverse_video = false; + ctx->dec_private = false; +ffffffff80002de4: 0f b7 05 b5 8b 00 00 movzwl 0x8bb5(%rip),%eax # ffffffff8000b9a0 + ctx->tab_size = 8; +ffffffff80002deb: 48 c7 07 08 00 00 00 movq $0x8,(%rdi) + ctx->autoflush = true; +ffffffff80002df2: 48 c7 47 08 01 01 01 movq $0x10101,0x8(%rdi) +ffffffff80002df9: 00 + ctx->dec_private = false; +ffffffff80002dfa: 66 89 47 14 mov %ax,0x14(%rdi) + ctx->insert_mode = false; + ctx->unicode_remaining = 0; + ctx->g_select = 0; +ffffffff80002dfe: 66 89 47 28 mov %ax,0x28(%rdi) + ctx->saved_cursor_x = 0; + ctx->saved_cursor_y = 0; + ctx->current_primary = (size_t)-1; + ctx->current_bg = (size_t)-1; + ctx->scroll_top_margin = 0; + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80002e02: 48 8b 87 e0 00 00 00 mov 0xe0(%rdi),%rax + ctx->discard_next = false; +ffffffff80002e09: c7 47 10 00 00 00 00 movl $0x0,0x10(%rdi) + ctx->unicode_remaining = 0; +ffffffff80002e10: 48 c7 47 20 00 00 00 movq $0x0,0x20(%rdi) +ffffffff80002e17: 00 + ctx->charsets[1] = CHARSET_DEC_SPECIAL; +ffffffff80002e18: c6 47 2a 01 movb $0x1,0x2a(%rdi) + ctx->current_charset = 0; +ffffffff80002e1c: 48 c7 47 30 00 00 00 movq $0x0,0x30(%rdi) +ffffffff80002e23: 00 + ctx->escape_offset = 0; +ffffffff80002e24: 48 c7 47 38 00 00 00 movq $0x0,0x38(%rdi) +ffffffff80002e2b: 00 + ctx->esc_values_i = 0; +ffffffff80002e2c: 48 c7 47 40 00 00 00 movq $0x0,0x40(%rdi) +ffffffff80002e33: 00 + ctx->saved_cursor_x = 0; +ffffffff80002e34: 48 c7 47 48 00 00 00 movq $0x0,0x48(%rdi) +ffffffff80002e3b: 00 + ctx->saved_cursor_y = 0; +ffffffff80002e3c: 48 c7 47 50 00 00 00 movq $0x0,0x50(%rdi) +ffffffff80002e43: 00 + ctx->current_primary = (size_t)-1; +ffffffff80002e44: 48 c7 47 58 ff ff ff movq $0xffffffffffffffff,0x58(%rdi) +ffffffff80002e4b: ff + ctx->current_bg = (size_t)-1; +ffffffff80002e4c: 48 c7 47 60 ff ff ff movq $0xffffffffffffffff,0x60(%rdi) +ffffffff80002e53: ff + ctx->scroll_top_margin = 0; +ffffffff80002e54: 48 c7 47 68 00 00 00 movq $0x0,0x68(%rdi) +ffffffff80002e5b: 00 + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80002e5c: 48 89 47 70 mov %rax,0x70(%rdi) + ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR; +ffffffff80002e60: 48 c7 87 b8 00 00 00 movq $0x10,0xb8(%rdi) +ffffffff80002e67: 10 00 00 00 +} +ffffffff80002e6b: c3 ret +ffffffff80002e6c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80002e70 : + } + + return 0; +} + +int mk_wcwidth(uint32_t ucs) { +ffffffff80002e70: f3 0f 1e fa endbr64 +ffffffff80002e74: 89 fa mov %edi,%edx + { 0xE0100, 0xE01EF } + }; + + /* test for 8-bit control characters */ + if (ucs == 0) + return 0; +ffffffff80002e76: 31 c0 xor %eax,%eax + if (ucs == 0) +ffffffff80002e78: 85 ff test %edi,%edi +ffffffff80002e7a: 74 71 je ffffffff80002eed + if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) +ffffffff80002e7c: 8d 47 81 lea -0x7f(%rdi),%eax +ffffffff80002e7f: 83 f8 20 cmp $0x20,%eax + return 1; +ffffffff80002e82: b8 01 00 00 00 mov $0x1,%eax + if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) +ffffffff80002e87: 76 67 jbe ffffffff80002ef0 +ffffffff80002e89: 83 ff 1f cmp $0x1f,%edi +ffffffff80002e8c: 76 62 jbe ffffffff80002ef0 + if (ucs < table[0].first || ucs > table[max].last) +ffffffff80002e8e: 81 ff ff 02 00 00 cmp $0x2ff,%edi +ffffffff80002e94: 76 57 jbe ffffffff80002eed +ffffffff80002e96: 81 ff ef 01 0e 00 cmp $0xe01ef,%edi +ffffffff80002e9c: 0f 87 be 00 00 00 ja ffffffff80002f60 + int min = 0; +ffffffff80002ea2: 31 f6 xor %esi,%esi +ffffffff80002ea4: bf 8d 00 00 00 mov $0x8d,%edi +ffffffff80002ea9: eb 0c jmp ffffffff80002eb7 +ffffffff80002eab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + min = mid + 1; +ffffffff80002eb0: 8d 70 01 lea 0x1(%rax),%esi + while (max >= min) { +ffffffff80002eb3: 39 f7 cmp %esi,%edi +ffffffff80002eb5: 7c 41 jl ffffffff80002ef8 + mid = (min + max) / 2; +ffffffff80002eb7: 8d 0c 37 lea (%rdi,%rsi,1),%ecx +ffffffff80002eba: 89 c8 mov %ecx,%eax +ffffffff80002ebc: c1 e8 1f shr $0x1f,%eax +ffffffff80002ebf: 01 c8 add %ecx,%eax +ffffffff80002ec1: d1 f8 sar $1,%eax + if (ucs > table[mid].last) +ffffffff80002ec3: 48 63 c8 movslq %eax,%rcx +ffffffff80002ec6: 39 14 cd 64 b1 00 80 cmp %edx,-0x7fff4e9c(,%rcx,8) +ffffffff80002ecd: 72 e1 jb ffffffff80002eb0 + else if (ucs < table[mid].first) +ffffffff80002ecf: 3b 14 cd 60 b1 00 80 cmp -0x7fff4ea0(,%rcx,8),%edx +ffffffff80002ed6: 0f 83 d4 00 00 00 jae ffffffff80002fb0 + max = mid - 1; +ffffffff80002edc: 8d 78 ff lea -0x1(%rax),%edi +ffffffff80002edf: eb d2 jmp ffffffff80002eb3 +ffffffff80002ee1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) +ffffffff80002ee8: b8 01 00 00 00 mov $0x1,%eax + (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ + (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */ + (ucs >= 0xffe0 && ucs <= 0xffe6) || + (ucs >= 0x20000 && ucs <= 0x2fffd) || + (ucs >= 0x30000 && ucs <= 0x3fffd))); +} +ffffffff80002eed: c3 ret +ffffffff80002eee: 66 90 xchg %ax,%ax +ffffffff80002ef0: c3 ret +ffffffff80002ef1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + (ucs >= 0x1100 && +ffffffff80002ef8: 81 fa ff 10 00 00 cmp $0x10ff,%edx +ffffffff80002efe: 76 e8 jbe ffffffff80002ee8 + ucs == 0x2329 || ucs == 0x232a || +ffffffff80002f00: 8d 82 d7 dc ff ff lea -0x2329(%rdx),%eax +ffffffff80002f06: 83 f8 01 cmp $0x1,%eax +ffffffff80002f09: 76 08 jbe ffffffff80002f13 +ffffffff80002f0b: 81 fa 5f 11 00 00 cmp $0x115f,%edx +ffffffff80002f11: 77 06 ja ffffffff80002f19 +ffffffff80002f13: b8 02 00 00 00 mov $0x2,%eax +ffffffff80002f18: c3 ret + (ucs >= 0x2e80 && ucs <= 0xa4cf && +ffffffff80002f19: 8d 82 80 d1 ff ff lea -0x2e80(%rdx),%eax + ucs == 0x2329 || ucs == 0x232a || +ffffffff80002f1f: 3d 4f 76 00 00 cmp $0x764f,%eax +ffffffff80002f24: 77 08 ja ffffffff80002f2e +ffffffff80002f26: 81 fa 3f 30 00 00 cmp $0x303f,%edx +ffffffff80002f2c: 75 e5 jne ffffffff80002f13 + (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */ +ffffffff80002f2e: 8d 8a 00 54 ff ff lea -0xac00(%rdx),%ecx +ffffffff80002f34: b8 02 00 00 00 mov $0x2,%eax + ucs != 0x303f) || /* CJK ... Yi */ +ffffffff80002f39: 81 f9 a3 2b 00 00 cmp $0x2ba3,%ecx +ffffffff80002f3f: 76 ac jbe ffffffff80002eed + (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */ +ffffffff80002f41: 8d 8a 00 07 ff ff lea -0xf900(%rdx),%ecx + (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */ +ffffffff80002f47: 81 f9 ff 01 00 00 cmp $0x1ff,%ecx +ffffffff80002f4d: 76 9e jbe ffffffff80002eed + (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */ +ffffffff80002f4f: 8d 8a f0 01 ff ff lea -0xfe10(%rdx),%ecx + (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */ +ffffffff80002f55: 83 f9 09 cmp $0x9,%ecx +ffffffff80002f58: 76 93 jbe ffffffff80002eed +ffffffff80002f5a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ +ffffffff80002f60: 8d 8a d0 01 ff ff lea -0xfe30(%rdx),%ecx +ffffffff80002f66: b8 02 00 00 00 mov $0x2,%eax + (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */ +ffffffff80002f6b: 83 f9 3f cmp $0x3f,%ecx +ffffffff80002f6e: 0f 86 79 ff ff ff jbe ffffffff80002eed + (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */ +ffffffff80002f74: 8d 8a 00 01 ff ff lea -0xff00(%rdx),%ecx + (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ +ffffffff80002f7a: 83 f9 60 cmp $0x60,%ecx +ffffffff80002f7d: 0f 86 6a ff ff ff jbe ffffffff80002eed + (ucs >= 0xffe0 && ucs <= 0xffe6) || +ffffffff80002f83: 8d 8a 20 00 ff ff lea -0xffe0(%rdx),%ecx + (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */ +ffffffff80002f89: 83 f9 06 cmp $0x6,%ecx +ffffffff80002f8c: 0f 86 5b ff ff ff jbe ffffffff80002eed + (ucs >= 0xffe0 && ucs <= 0xffe6) || +ffffffff80002f92: 89 d0 mov %edx,%eax +ffffffff80002f94: 25 ff ff fe ff and $0xfffeffff,%eax +ffffffff80002f99: 2d 00 00 02 00 sub $0x20000,%eax +ffffffff80002f9e: 3d fd ff 00 00 cmp $0xfffd,%eax +ffffffff80002fa3: 0f 96 c0 setbe %al +ffffffff80002fa6: 0f b6 c0 movzbl %al,%eax + return 1 + +ffffffff80002fa9: 83 c0 01 add $0x1,%eax +ffffffff80002fac: c3 ret +ffffffff80002fad: 0f 1f 00 nopl (%rax) + return 0; +ffffffff80002fb0: 31 c0 xor %eax,%eax +ffffffff80002fb2: c3 ret +ffffffff80002fb3: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80002fba: 00 00 00 +ffffffff80002fbd: 0f 1f 00 nopl (%rax) + +ffffffff80002fc0 : +void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count) { +ffffffff80002fc0: f3 0f 1e fa endbr64 +ffffffff80002fc4: 41 57 push %r15 +ffffffff80002fc6: 41 56 push %r14 +ffffffff80002fc8: 41 55 push %r13 +ffffffff80002fca: 4c 8d 2c 16 lea (%rsi,%rdx,1),%r13 +ffffffff80002fce: 41 54 push %r12 +ffffffff80002fd0: 55 push %rbp +ffffffff80002fd1: 48 89 f5 mov %rsi,%rbp +ffffffff80002fd4: 53 push %rbx +ffffffff80002fd5: 48 89 fb mov %rdi,%rbx +ffffffff80002fd8: 48 83 ec 28 sub $0x28,%rsp + for (size_t i = 0; i < count; i++) { +ffffffff80002fdc: 48 85 d2 test %rdx,%rdx +ffffffff80002fdf: 0f 84 bf 00 00 00 je ffffffff800030a4 +ffffffff80002fe5: 0f 1f 00 nopl (%rax) + + return -1; +} + +static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c) { + if (ctx->discard_next || (c == 0x18 || c == 0x1a)) { +ffffffff80002fe8: 80 7b 10 00 cmpb $0x0,0x10(%rbx) + flanterm_putchar(ctx, buf[i]); +ffffffff80002fec: 44 0f b6 65 00 movzbl 0x0(%rbp),%r12d + if (ctx->discard_next || (c == 0x18 || c == 0x1a)) { +ffffffff80002ff1: 0f 85 89 00 00 00 jne ffffffff80003080 +ffffffff80002ff7: 44 89 e0 mov %r12d,%eax +ffffffff80002ffa: 83 e0 fd and $0xfffffffd,%eax +ffffffff80002ffd: 3c 18 cmp $0x18,%al +ffffffff80002fff: 74 7f je ffffffff80003080 + ctx->osc_escape = false; + ctx->g_select = 0; + return; + } + + if (ctx->unicode_remaining != 0) { +ffffffff80003001: 48 8b 43 20 mov 0x20(%rbx),%rax +ffffffff80003005: 48 85 c0 test %rax,%rax +ffffffff80003008: 74 17 je ffffffff80003021 + if ((c & 0xc0) != 0x80) { +ffffffff8000300a: 44 89 e2 mov %r12d,%edx +ffffffff8000300d: 83 e2 c0 and $0xffffffc0,%edx +ffffffff80003010: 80 fa 80 cmp $0x80,%dl +ffffffff80003013: 0f 84 f7 00 00 00 je ffffffff80003110 + ctx->unicode_remaining = 0; +ffffffff80003019: 48 c7 43 20 00 00 00 movq $0x0,0x20(%rbx) +ffffffff80003020: 00 + } + return; + } + +unicode_error: + if (c >= 0xc0 && c <= 0xf7) { +ffffffff80003021: 41 8d 44 24 40 lea 0x40(%r12),%eax +ffffffff80003026: 3c 37 cmp $0x37,%al +ffffffff80003028: 0f 86 a2 00 00 00 jbe ffffffff800030d0 + ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3); + } + return; + } + + if (ctx->escape == true) { +ffffffff8000302e: 80 7b 0c 00 cmpb $0x0,0xc(%rbx) +ffffffff80003032: 0f 85 c8 01 00 00 jne ffffffff80003200 + escape_parse(ctx, c); + return; + } + + if (ctx->g_select) { +ffffffff80003038: 0f b6 43 28 movzbl 0x28(%rbx),%eax +ffffffff8000303c: 84 c0 test %al,%al +ffffffff8000303e: 0f 85 8c 01 00 00 jne ffffffff800031d0 + ctx->g_select = 0; + return; + } + + size_t x, y; + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80003044: 48 8d 54 24 18 lea 0x18(%rsp),%rdx +ffffffff80003049: 48 8d 74 24 10 lea 0x10(%rsp),%rsi +ffffffff8000304e: 48 89 df mov %rbx,%rdi +ffffffff80003051: ff 93 08 01 00 00 call *0x108(%rbx) + + switch (c) { +ffffffff80003057: 41 80 fc 1b cmp $0x1b,%r12b +ffffffff8000305b: 0f 8f 5f 02 00 00 jg ffffffff800032c0 +ffffffff80003061: 45 84 e4 test %r12b,%r12b +ffffffff80003064: 0f 88 66 02 00 00 js ffffffff800032d0 +ffffffff8000306a: 41 80 fc 1b cmp $0x1b,%r12b +ffffffff8000306e: 0f 87 5c 02 00 00 ja ffffffff800032d0 +ffffffff80003074: 41 0f b6 c4 movzbl %r12b,%eax +ffffffff80003078: 3e ff 24 c5 00 90 00 notrack jmp *-0x7fff7000(,%rax,8) +ffffffff8000307f: 80 + ctx->discard_next = false; +ffffffff80003080: c6 43 10 00 movb $0x0,0x10(%rbx) + ctx->unicode_remaining = 0; +ffffffff80003084: 48 c7 43 20 00 00 00 movq $0x0,0x20(%rbx) +ffffffff8000308b: 00 + ctx->control_sequence = false; +ffffffff8000308c: c7 43 0b 00 00 00 00 movl $0x0,0xb(%rbx) + ctx->g_select = 0; +ffffffff80003093: c6 43 28 00 movb $0x0,0x28(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff80003097: 48 83 c5 01 add $0x1,%rbp +ffffffff8000309b: 49 39 ed cmp %rbp,%r13 +ffffffff8000309e: 0f 85 44 ff ff ff jne ffffffff80002fe8 + if (ctx->autoflush) { +ffffffff800030a4: 80 7b 08 00 cmpb $0x0,0x8(%rbx) +ffffffff800030a8: 0f 84 da 00 00 00 je ffffffff80003188 + ctx->double_buffer_flush(ctx); +ffffffff800030ae: 48 8b 83 90 01 00 00 mov 0x190(%rbx),%rax +} +ffffffff800030b5: 48 83 c4 28 add $0x28,%rsp + ctx->double_buffer_flush(ctx); +ffffffff800030b9: 48 89 df mov %rbx,%rdi +} +ffffffff800030bc: 5b pop %rbx +ffffffff800030bd: 5d pop %rbp +ffffffff800030be: 41 5c pop %r12 +ffffffff800030c0: 41 5d pop %r13 +ffffffff800030c2: 41 5e pop %r14 +ffffffff800030c4: 41 5f pop %r15 + ctx->double_buffer_flush(ctx); +ffffffff800030c6: ff e0 jmp *%rax +ffffffff800030c8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800030cf: 00 + ctx->code_point = (uint64_t)(c & 0x1f) << 6; +ffffffff800030d0: 41 0f b6 d4 movzbl %r12b,%edx + if (c >= 0xc0 && c <= 0xdf) { +ffffffff800030d4: 3c 1f cmp $0x1f,%al +ffffffff800030d6: 0f 86 c4 00 00 00 jbe ffffffff800031a0 + } else if (c >= 0xe0 && c <= 0xef) { +ffffffff800030dc: 41 83 c4 20 add $0x20,%r12d +ffffffff800030e0: 41 80 fc 0f cmp $0xf,%r12b +ffffffff800030e4: 0f 87 66 01 00 00 ja ffffffff80003250 + ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2); +ffffffff800030ea: 48 c1 e2 0c shl $0xc,%rdx + for (size_t i = 0; i < count; i++) { +ffffffff800030ee: 48 83 c5 01 add $0x1,%rbp + ctx->unicode_remaining = 2; +ffffffff800030f2: 48 c7 43 20 02 00 00 movq $0x2,0x20(%rbx) +ffffffff800030f9: 00 + ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2); +ffffffff800030fa: 81 e2 ff ff 00 00 and $0xffff,%edx +ffffffff80003100: 48 89 53 18 mov %rdx,0x18(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff80003104: 49 39 ed cmp %rbp,%r13 +ffffffff80003107: 0f 85 db fe ff ff jne ffffffff80002fe8 +ffffffff8000310d: eb 95 jmp ffffffff800030a4 +ffffffff8000310f: 90 nop + ctx->unicode_remaining--; +ffffffff80003110: 48 83 e8 01 sub $0x1,%rax + ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining); +ffffffff80003114: 41 83 e4 3f and $0x3f,%r12d +ffffffff80003118: 8d 0c 40 lea (%rax,%rax,2),%ecx + ctx->unicode_remaining--; +ffffffff8000311b: 48 89 43 20 mov %rax,0x20(%rbx) + ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining); +ffffffff8000311f: 01 c9 add %ecx,%ecx +ffffffff80003121: 49 d3 e4 shl %cl,%r12 +ffffffff80003124: 4c 0b 63 18 or 0x18(%rbx),%r12 +ffffffff80003128: 4c 89 63 18 mov %r12,0x18(%rbx) + if (ctx->unicode_remaining != 0) { +ffffffff8000312c: 48 85 c0 test %rax,%rax +ffffffff8000312f: 0f 85 62 ff ff ff jne ffffffff80003097 + switch (code_point) { +ffffffff80003135: 49 81 fc 48 22 00 00 cmp $0x2248,%r12 +ffffffff8000313c: 0f 87 3e 01 00 00 ja ffffffff80003280 +ffffffff80003142: 49 81 fc 18 22 00 00 cmp $0x2218,%r12 +ffffffff80003149: 0f 87 38 0e 00 00 ja ffffffff80003f87 +ffffffff8000314f: 49 81 fc 92 01 00 00 cmp $0x192,%r12 +ffffffff80003156: 0f 87 12 03 00 00 ja ffffffff8000346e +ffffffff8000315c: 49 81 fc a0 00 00 00 cmp $0xa0,%r12 +ffffffff80003163: 0f 86 57 02 00 00 jbe ffffffff800033c0 +ffffffff80003169: 49 8d 84 24 5f ff ff lea -0xa1(%r12),%rax +ffffffff80003170: ff +ffffffff80003171: 48 3d f1 00 00 00 cmp $0xf1,%rax +ffffffff80003177: 0f 87 43 02 00 00 ja ffffffff800033c0 +ffffffff8000317d: 3e ff 24 c5 e0 90 00 notrack jmp *-0x7fff6f20(,%rax,8) +ffffffff80003184: 80 +ffffffff80003185: 0f 1f 00 nopl (%rax) +} +ffffffff80003188: 48 83 c4 28 add $0x28,%rsp +ffffffff8000318c: 5b pop %rbx +ffffffff8000318d: 5d pop %rbp +ffffffff8000318e: 41 5c pop %r12 +ffffffff80003190: 41 5d pop %r13 +ffffffff80003192: 41 5e pop %r14 +ffffffff80003194: 41 5f pop %r15 +ffffffff80003196: c3 ret +ffffffff80003197: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000319e: 00 00 + ctx->code_point = (uint64_t)(c & 0x1f) << 6; +ffffffff800031a0: 48 c1 e2 06 shl $0x6,%rdx + for (size_t i = 0; i < count; i++) { +ffffffff800031a4: 48 83 c5 01 add $0x1,%rbp + ctx->unicode_remaining = 1; +ffffffff800031a8: 48 c7 43 20 01 00 00 movq $0x1,0x20(%rbx) +ffffffff800031af: 00 + ctx->code_point = (uint64_t)(c & 0x1f) << 6; +ffffffff800031b0: 81 e2 c0 07 00 00 and $0x7c0,%edx +ffffffff800031b6: 48 89 53 18 mov %rdx,0x18(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff800031ba: 49 39 ed cmp %rbp,%r13 +ffffffff800031bd: 0f 85 25 fe ff ff jne ffffffff80002fe8 +ffffffff800031c3: e9 dc fe ff ff jmp ffffffff800030a4 +ffffffff800031c8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800031cf: 00 + ctx->g_select--; +ffffffff800031d0: 83 e8 01 sub $0x1,%eax + switch (c) { +ffffffff800031d3: 41 80 fc 30 cmp $0x30,%r12b +ffffffff800031d7: 0f 84 8b 03 00 00 je ffffffff80003568 +ffffffff800031dd: 41 80 fc 42 cmp $0x42,%r12b +ffffffff800031e1: 0f 84 59 01 00 00 je ffffffff80003340 + ctx->g_select = 0; +ffffffff800031e7: c6 43 28 00 movb $0x0,0x28(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff800031eb: 48 83 c5 01 add $0x1,%rbp +ffffffff800031ef: 49 39 ed cmp %rbp,%r13 +ffffffff800031f2: 0f 85 f0 fd ff ff jne ffffffff80002fe8 +ffffffff800031f8: e9 a7 fe ff ff jmp ffffffff800030a4 +ffffffff800031fd: 0f 1f 00 nopl (%rax) + ctx->escape_offset++; +ffffffff80003200: 48 8b 43 38 mov 0x38(%rbx),%rax +ffffffff80003204: 48 83 c0 01 add $0x1,%rax + if (ctx->osc == true) { +ffffffff80003208: 80 7b 0d 00 cmpb $0x0,0xd(%rbx) + ctx->escape_offset++; +ffffffff8000320c: 48 89 43 38 mov %rax,0x38(%rbx) + if (ctx->osc == true) { +ffffffff80003210: 0f 85 6a 03 00 00 jne ffffffff80003580 + if (ctx->control_sequence == true) { +ffffffff80003216: 80 7b 0b 00 cmpb $0x0,0xb(%rbx) +ffffffff8000321a: 0f 85 87 03 00 00 jne ffffffff800035a7 + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80003220: 48 8d 54 24 18 lea 0x18(%rsp),%rdx +ffffffff80003225: 48 8d 74 24 10 lea 0x10(%rsp),%rsi +ffffffff8000322a: 48 89 df mov %rbx,%rdi +ffffffff8000322d: ff 93 08 01 00 00 call *0x108(%rbx) + switch (c) { +ffffffff80003233: 41 8d 44 24 d8 lea -0x28(%r12),%eax +ffffffff80003238: 3c 3b cmp $0x3b,%al +ffffffff8000323a: 0f 87 18 02 00 00 ja ffffffff80003458 +ffffffff80003240: 0f b6 c0 movzbl %al,%eax +ffffffff80003243: 3e ff 24 c5 70 98 00 notrack jmp *-0x7fff6790(,%rax,8) +ffffffff8000324a: 80 +ffffffff8000324b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3); +ffffffff80003250: 48 c1 e2 12 shl $0x12,%rdx + for (size_t i = 0; i < count; i++) { +ffffffff80003254: 48 83 c5 01 add $0x1,%rbp + ctx->unicode_remaining = 3; +ffffffff80003258: 48 c7 43 20 03 00 00 movq $0x3,0x20(%rbx) +ffffffff8000325f: 00 + ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3); +ffffffff80003260: 81 e2 00 00 1c 00 and $0x1c0000,%edx +ffffffff80003266: 48 89 53 18 mov %rdx,0x18(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff8000326a: 49 39 ed cmp %rbp,%r13 +ffffffff8000326d: 0f 85 75 fd ff ff jne ffffffff80002fe8 +ffffffff80003273: e9 2c fe ff ff jmp ffffffff800030a4 +ffffffff80003278: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff8000327f: 00 + switch (code_point) { +ffffffff80003280: 49 81 fc 6b 26 00 00 cmp $0x266b,%r12 +ffffffff80003287: 0f 87 33 01 00 00 ja ffffffff800033c0 +ffffffff8000328d: 49 81 fc ff 24 00 00 cmp $0x24ff,%r12 +ffffffff80003294: 0f 86 95 03 00 00 jbe ffffffff8000362f +ffffffff8000329a: 49 8d 84 24 00 db ff lea -0x2500(%r12),%rax +ffffffff800032a1: ff +ffffffff800032a2: 48 3d 6b 01 00 00 cmp $0x16b,%rax +ffffffff800032a8: 0f 87 12 01 00 00 ja ffffffff800033c0 +ffffffff800032ae: 3e ff 24 c5 50 9a 00 notrack jmp *-0x7fff65b0(,%rax,8) +ffffffff800032b5: 80 +ffffffff800032b6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800032bd: 00 00 00 + switch (c) { +ffffffff800032c0: 41 80 fc 7f cmp $0x7f,%r12b +ffffffff800032c4: 0f 84 cd fd ff ff je ffffffff80003097 +ffffffff800032ca: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + // Move to G0 set + ctx->current_charset = 0; + return; + } + + if (ctx->insert_mode == true) { +ffffffff800032d0: 80 7b 15 00 cmpb $0x0,0x15(%rbx) +ffffffff800032d4: 74 35 je ffffffff8000330b + for (size_t i = ctx->cols - 1; ; i--) { +ffffffff800032d6: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff800032dd: 4c 8d 70 ff lea -0x1(%rax),%r14 +ffffffff800032e1: eb 09 jmp ffffffff800032ec +ffffffff800032e3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800032e8: 49 83 ee 01 sub $0x1,%r14 + ctx->move_character(ctx, i + 1, y, i, y); +ffffffff800032ec: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800032f1: 49 8d 76 01 lea 0x1(%r14),%rsi +ffffffff800032f5: 4c 89 f1 mov %r14,%rcx +ffffffff800032f8: 48 89 df mov %rbx,%rdi +ffffffff800032fb: 49 89 d0 mov %rdx,%r8 +ffffffff800032fe: ff 93 60 01 00 00 call *0x160(%rbx) + if (i == x) { +ffffffff80003304: 4c 3b 74 24 10 cmp 0x10(%rsp),%r14 +ffffffff80003309: 75 dd jne ffffffff800032e8 + } + } + } + + // Translate character set + switch (ctx->charsets[ctx->current_charset]) { +ffffffff8000330b: 48 8b 53 30 mov 0x30(%rbx),%rdx + case '`': FLANTERM_DEC_SPCL_PRN(0x04) +ffffffff8000330f: 48 8b 83 f0 00 00 00 mov 0xf0(%rbx),%rax + switch (ctx->charsets[ctx->current_charset]) { +ffffffff80003316: 80 7c 13 29 01 cmpb $0x1,0x29(%rbx,%rdx,1) +ffffffff8000331b: 0f 84 12 0b 00 00 je ffffffff80003e33 + return; + } + break; + } + + if (c >= 0x20 && c <= 0x7e) { +ffffffff80003321: 41 8d 54 24 e0 lea -0x20(%r12),%edx +ffffffff80003326: 80 fa 5e cmp $0x5e,%dl +ffffffff80003329: 0f 86 be 02 00 00 jbe ffffffff800035ed + ctx->raw_putchar(ctx, c); + } else { + ctx->raw_putchar(ctx, 0xfe); +ffffffff8000332f: be fe 00 00 00 mov $0xfe,%esi +ffffffff80003334: 48 89 df mov %rbx,%rdi +ffffffff80003337: ff d0 call *%rax +ffffffff80003339: e9 59 fd ff ff jmp ffffffff80003097 +ffffffff8000333e: 66 90 xchg %ax,%ax + ctx->charsets[ctx->g_select] = CHARSET_DEFAULT; break; +ffffffff80003340: 0f b6 c0 movzbl %al,%eax +ffffffff80003343: c6 44 03 29 00 movb $0x0,0x29(%rbx,%rax,1) + ctx->g_select = 0; +ffffffff80003348: c6 43 28 00 movb $0x0,0x28(%rbx) + return; +ffffffff8000334c: e9 9a fe ff ff jmp ffffffff800031eb + if (y == ctx->scroll_bottom_margin - 1) { +ffffffff80003351: 48 8b 43 70 mov 0x70(%rbx),%rax +ffffffff80003355: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000335a: 48 83 e8 01 sub $0x1,%rax +ffffffff8000335e: 48 39 d0 cmp %rdx,%rax +ffffffff80003361: 0f 84 92 0a 00 00 je ffffffff80003df9 + ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y + 1); +ffffffff80003367: 48 8b 83 00 01 00 00 mov 0x100(%rbx),%rax +ffffffff8000336e: 48 83 c2 01 add $0x1,%rdx +ffffffff80003372: 31 f6 xor %esi,%esi +ffffffff80003374: f6 83 b8 00 00 00 10 testb $0x10,0xb8(%rbx) +ffffffff8000337b: 75 05 jne ffffffff80003382 +ffffffff8000337d: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff80003382: 48 89 df mov %rbx,%rdi +ffffffff80003385: ff d0 call *%rax +ffffffff80003387: e9 0b fd ff ff jmp ffffffff80003097 + switch (code_point) { +ffffffff8000338c: 49 81 fc 20 23 00 00 cmp $0x2320,%r12 +ffffffff80003393: 0f 84 59 0e 00 00 je ffffffff800041f2 +ffffffff80003399: 49 81 fc 21 23 00 00 cmp $0x2321,%r12 +ffffffff800033a0: 0f 84 42 0e 00 00 je ffffffff800041e8 + case 0x2310: return 169; +ffffffff800033a6: be a9 00 00 00 mov $0xa9,%esi + switch (code_point) { +ffffffff800033ab: 49 81 fc 10 23 00 00 cmp $0x2310,%r12 +ffffffff800033b2: 0f 84 b8 02 00 00 je ffffffff80003670 +ffffffff800033b8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800033bf: 00 + size_t replacement_width = (size_t)mk_wcwidth(ctx->code_point); +ffffffff800033c0: 44 89 e7 mov %r12d,%edi +ffffffff800033c3: e8 a8 fa ff ff call ffffffff80002e70 +ffffffff800033c8: 4c 63 f0 movslq %eax,%r14 + if (replacement_width > 0) { +ffffffff800033cb: 4d 85 f6 test %r14,%r14 +ffffffff800033ce: 0f 84 c3 fc ff ff je ffffffff80003097 + ctx->raw_putchar(ctx, 0xfe); +ffffffff800033d4: be fe 00 00 00 mov $0xfe,%esi +ffffffff800033d9: 48 89 df mov %rbx,%rdi +ffffffff800033dc: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 1; i < replacement_width; i++) { +ffffffff800033e2: 49 83 fe 01 cmp $0x1,%r14 +ffffffff800033e6: 0f 84 ab fc ff ff je ffffffff80003097 +ffffffff800033ec: 41 bc 01 00 00 00 mov $0x1,%r12d +ffffffff800033f2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) +ffffffff800033f8: 49 83 c4 01 add $0x1,%r12 + ctx->raw_putchar(ctx, ' '); +ffffffff800033fc: be 20 00 00 00 mov $0x20,%esi +ffffffff80003401: 48 89 df mov %rbx,%rdi +ffffffff80003404: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 1; i < replacement_width; i++) { +ffffffff8000340a: 4d 39 e6 cmp %r12,%r14 +ffffffff8000340d: 75 e9 jne ffffffff800033f8 +ffffffff8000340f: e9 83 fc ff ff jmp ffffffff80003097 + ctx->save_state(ctx); +ffffffff80003414: 48 89 df mov %rbx,%rdi +ffffffff80003417: ff 93 80 01 00 00 call *0x180(%rbx) + ctx->saved_state_bold = ctx->bold; +ffffffff8000341d: 0f b7 43 11 movzwl 0x11(%rbx),%eax + ctx->saved_state_current_charset = ctx->current_charset; +ffffffff80003421: 48 8b 53 58 mov 0x58(%rbx),%rdx +ffffffff80003425: 48 8b 4b 30 mov 0x30(%rbx),%rcx + ctx->saved_state_bold = ctx->bold; +ffffffff80003429: 66 89 83 c0 00 00 00 mov %ax,0xc0(%rbx) + ctx->saved_state_reverse_video = ctx->reverse_video; +ffffffff80003430: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->saved_state_current_charset = ctx->current_charset; +ffffffff80003434: 48 89 8b c8 00 00 00 mov %rcx,0xc8(%rbx) + ctx->saved_state_reverse_video = ctx->reverse_video; +ffffffff8000343b: 88 83 c2 00 00 00 mov %al,0xc2(%rbx) + ctx->saved_state_current_charset = ctx->current_charset; +ffffffff80003441: 48 8b 43 60 mov 0x60(%rbx),%rax +ffffffff80003445: 48 89 93 d0 00 00 00 mov %rdx,0xd0(%rbx) +ffffffff8000344c: 48 89 83 d8 00 00 00 mov %rax,0xd8(%rbx) + break; +ffffffff80003453: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + for (size_t i = 0; i < count; i++) { +ffffffff80003458: 48 83 c5 01 add $0x1,%rbp + ctx->escape = false; +ffffffff8000345c: c6 43 0c 00 movb $0x0,0xc(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff80003460: 49 39 ed cmp %rbp,%r13 +ffffffff80003463: 0f 85 7f fb ff ff jne ffffffff80002fe8 +ffffffff80003469: e9 36 fc ff ff jmp ffffffff800030a4 + switch (code_point) { +ffffffff8000346e: 49 81 fc c6 03 00 00 cmp $0x3c6,%r12 +ffffffff80003475: 0f 87 80 01 00 00 ja ffffffff800035fb +ffffffff8000347b: 49 81 fc 92 03 00 00 cmp $0x392,%r12 +ffffffff80003482: 0f 86 38 ff ff ff jbe ffffffff800033c0 +ffffffff80003488: 49 8d 84 24 6d fc ff lea -0x393(%r12),%rax +ffffffff8000348f: ff +ffffffff80003490: 48 83 f8 33 cmp $0x33,%rax +ffffffff80003494: 0f 87 26 ff ff ff ja ffffffff800033c0 +ffffffff8000349a: 3e ff 24 c5 b0 a5 00 notrack jmp *-0x7fff5a50(,%rax,8) +ffffffff800034a1: 80 + ctx->set_cursor_pos(ctx, 0, y); +ffffffff800034a2: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800034a7: 31 f6 xor %esi,%esi +ffffffff800034a9: 48 89 df mov %rbx,%rdi +ffffffff800034ac: ff 93 00 01 00 00 call *0x100(%rbx) + return; +ffffffff800034b2: e9 e0 fb ff ff jmp ffffffff80003097 + ctx->set_cursor_pos(ctx, x - 1, y); +ffffffff800034b7: 48 8b 44 24 10 mov 0x10(%rsp),%rax +ffffffff800034bc: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800034c1: 48 89 df mov %rbx,%rdi +ffffffff800034c4: 48 8d 70 ff lea -0x1(%rax),%rsi +ffffffff800034c8: ff 93 00 01 00 00 call *0x100(%rbx) + return; +ffffffff800034ce: e9 c4 fb ff ff jmp ffffffff80003097 + if ((x / ctx->tab_size + 1) >= ctx->cols) { +ffffffff800034d3: 48 8b 33 mov (%rbx),%rsi +ffffffff800034d6: 48 8b 44 24 10 mov 0x10(%rsp),%rax +ffffffff800034db: 31 d2 xor %edx,%edx + ctx->set_cursor_pos(ctx, ctx->cols - 1, y); +ffffffff800034dd: 48 8b 8b 00 01 00 00 mov 0x100(%rbx),%rcx +ffffffff800034e4: 48 8b 7c 24 18 mov 0x18(%rsp),%rdi + if ((x / ctx->tab_size + 1) >= ctx->cols) { +ffffffff800034e9: 48 f7 f6 div %rsi +ffffffff800034ec: 48 8b 93 e8 00 00 00 mov 0xe8(%rbx),%rdx +ffffffff800034f3: 48 83 c0 01 add $0x1,%rax +ffffffff800034f7: 48 39 d0 cmp %rdx,%rax +ffffffff800034fa: 0f 83 22 09 00 00 jae ffffffff80003e22 + ctx->set_cursor_pos(ctx, (x / ctx->tab_size + 1) * ctx->tab_size, y); +ffffffff80003500: 48 89 fa mov %rdi,%rdx +ffffffff80003503: 48 0f af f0 imul %rax,%rsi +ffffffff80003507: 48 89 df mov %rbx,%rdi +ffffffff8000350a: ff d1 call *%rcx + return; +ffffffff8000350c: e9 86 fb ff ff jmp ffffffff80003097 + if (ctx->callback != NULL) { +ffffffff80003511: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff80003518: 48 85 c0 test %rax,%rax +ffffffff8000351b: 0f 84 76 fb ff ff je ffffffff80003097 + ctx->callback(ctx, FLANTERM_CB_BELL, 0, 0, 0); +ffffffff80003521: 45 31 c0 xor %r8d,%r8d +ffffffff80003524: 31 c9 xor %ecx,%ecx +ffffffff80003526: 31 d2 xor %edx,%edx +ffffffff80003528: be 14 00 00 00 mov $0x14,%esi +ffffffff8000352d: 48 89 df mov %rbx,%rdi +ffffffff80003530: ff d0 call *%rax +ffffffff80003532: e9 60 fb ff ff jmp ffffffff80003097 + ctx->escape_offset = 0; +ffffffff80003537: 48 c7 43 38 00 00 00 movq $0x0,0x38(%rbx) +ffffffff8000353e: 00 + ctx->escape = true; +ffffffff8000353f: c6 43 0c 01 movb $0x1,0xc(%rbx) + return; +ffffffff80003543: e9 4f fb ff ff jmp ffffffff80003097 + ctx->current_charset = 1; +ffffffff80003548: 48 c7 43 30 01 00 00 movq $0x1,0x30(%rbx) +ffffffff8000354f: 00 + return; +ffffffff80003550: e9 42 fb ff ff jmp ffffffff80003097 + ctx->current_charset = 0; +ffffffff80003555: 48 c7 43 30 00 00 00 movq $0x0,0x30(%rbx) +ffffffff8000355c: 00 + return; +ffffffff8000355d: e9 35 fb ff ff jmp ffffffff80003097 +ffffffff80003562: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + ctx->charsets[ctx->g_select] = CHARSET_DEC_SPECIAL; break; +ffffffff80003568: 0f b6 c0 movzbl %al,%eax +ffffffff8000356b: c6 44 03 29 01 movb $0x1,0x29(%rbx,%rax,1) + ctx->g_select = 0; +ffffffff80003570: c6 43 28 00 movb $0x0,0x28(%rbx) + return; +ffffffff80003574: e9 72 fc ff ff jmp ffffffff800031eb +ffffffff80003579: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + if (ctx->osc_escape && c == '\\') { +ffffffff80003580: 41 80 fc 5c cmp $0x5c,%r12b +ffffffff80003584: 75 06 jne ffffffff8000358c +ffffffff80003586: 80 7b 0e 00 cmpb $0x0,0xe(%rbx) +ffffffff8000358a: 75 0a jne ffffffff80003596 + switch (c) { +ffffffff8000358c: 41 80 fc 1b cmp $0x1b,%r12b +ffffffff80003590: 0f 84 5a 08 00 00 je ffffffff80003df0 + ctx->escape = false; +ffffffff80003596: 45 31 c9 xor %r9d,%r9d + ctx->osc_escape = false; +ffffffff80003599: c6 43 0e 00 movb $0x0,0xe(%rbx) + ctx->escape = false; +ffffffff8000359d: 66 44 89 4b 0c mov %r9w,0xc(%rbx) +ffffffff800035a2: e9 f0 fa ff ff jmp ffffffff80003097 + if (ctx->escape_offset == 2) { +ffffffff800035a7: 48 83 f8 02 cmp $0x2,%rax +ffffffff800035ab: 0f 84 bc 09 00 00 je ffffffff80003f6d + if (c >= '0' && c <= '9') { +ffffffff800035b1: 41 8d 44 24 d0 lea -0x30(%r12),%eax + if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) { +ffffffff800035b6: 48 8b 53 40 mov 0x40(%rbx),%rdx + if (c >= '0' && c <= '9') { +ffffffff800035ba: 3c 09 cmp $0x9,%al +ffffffff800035bc: 0f 87 8a 08 00 00 ja ffffffff80003e4c + if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) { +ffffffff800035c2: 48 83 fa 10 cmp $0x10,%rdx +ffffffff800035c6: 0f 84 cb fa ff ff je ffffffff80003097 + ctx->esc_values[ctx->esc_values_i] += c - '0'; +ffffffff800035cc: 48 83 c2 1c add $0x1c,%rdx +ffffffff800035d0: 45 0f be e4 movsbl %r12b,%r12d + ctx->rrr = true; +ffffffff800035d4: c6 43 0f 01 movb $0x1,0xf(%rbx) + ctx->esc_values[ctx->esc_values_i] *= 10; +ffffffff800035d8: 8b 44 93 08 mov 0x8(%rbx,%rdx,4),%eax +ffffffff800035dc: 8d 04 80 lea (%rax,%rax,4),%eax + ctx->esc_values[ctx->esc_values_i] += c - '0'; +ffffffff800035df: 41 8d 44 44 d0 lea -0x30(%r12,%rax,2),%eax +ffffffff800035e4: 89 44 93 08 mov %eax,0x8(%rbx,%rdx,4) + return; +ffffffff800035e8: e9 aa fa ff ff jmp ffffffff80003097 + ctx->raw_putchar(ctx, c); +ffffffff800035ed: 41 0f be f4 movsbl %r12b,%esi +ffffffff800035f1: 48 89 df mov %rbx,%rdi +ffffffff800035f4: ff d0 call *%rax +ffffffff800035f6: e9 9c fa ff ff jmp ffffffff80003097 + switch (code_point) { +ffffffff800035fb: 49 81 fc a8 21 00 00 cmp $0x21a8,%r12 +ffffffff80003602: 0f 87 b8 fd ff ff ja ffffffff800033c0 +ffffffff80003608: 49 81 fc 8f 21 00 00 cmp $0x218f,%r12 +ffffffff8000360f: 0f 86 8c 09 00 00 jbe ffffffff80003fa1 +ffffffff80003615: 49 8d 84 24 70 de ff lea -0x2190(%r12),%rax +ffffffff8000361c: ff +ffffffff8000361d: 48 83 f8 18 cmp $0x18,%rax +ffffffff80003621: 0f 87 99 fd ff ff ja ffffffff800033c0 +ffffffff80003627: 3e ff 24 c5 50 a7 00 notrack jmp *-0x7fff58b0(,%rax,8) +ffffffff8000362e: 80 +ffffffff8000362f: 49 81 fc 02 23 00 00 cmp $0x2302,%r12 +ffffffff80003636: 0f 84 0e 0b 00 00 je ffffffff8000414a +ffffffff8000363c: 0f 87 4a fd ff ff ja ffffffff8000338c +ffffffff80003642: 49 81 fc 64 22 00 00 cmp $0x2264,%r12 +ffffffff80003649: 0f 84 2d 0b 00 00 je ffffffff8000417c +ffffffff8000364f: 49 81 fc 65 22 00 00 cmp $0x2265,%r12 +ffffffff80003656: 0f 84 16 0b 00 00 je ffffffff80004172 + case 0x2261: return 240; +ffffffff8000365c: be f0 00 00 00 mov $0xf0,%esi + switch (code_point) { +ffffffff80003661: 49 81 fc 61 22 00 00 cmp $0x2261,%r12 +ffffffff80003668: 0f 85 52 fd ff ff jne ffffffff800033c0 +ffffffff8000366e: 66 90 xchg %ax,%ax + for (size_t i = 0; i < count; i++) { +ffffffff80003670: 48 83 c5 01 add $0x1,%rbp + ctx->raw_putchar(ctx, cc); +ffffffff80003674: 48 89 df mov %rbx,%rdi +ffffffff80003677: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff8000367d: 49 39 ed cmp %rbp,%r13 +ffffffff80003680: 0f 85 62 f9 ff ff jne ffffffff80002fe8 +ffffffff80003686: e9 19 fa ff ff jmp ffffffff800030a4 + ctx->g_select = c - '\''; +ffffffff8000368b: 41 83 ec 27 sub $0x27,%r12d +ffffffff8000368f: 44 88 63 28 mov %r12b,0x28(%rbx) + break; +ffffffff80003693: e9 c0 fd ff ff jmp ffffffff80003458 + if (y == ctx->scroll_bottom_margin - 1) { +ffffffff80003698: 48 8b 4b 70 mov 0x70(%rbx),%rcx +ffffffff8000369c: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff800036a1: 48 8d 51 ff lea -0x1(%rcx),%rdx +ffffffff800036a5: 48 39 c2 cmp %rax,%rdx +ffffffff800036a8: 0f 84 e9 09 00 00 je ffffffff80004097 + ctx->set_cursor_pos(ctx, x, y + 1); +ffffffff800036ae: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff800036b3: 48 8d 50 01 lea 0x1(%rax),%rdx +ffffffff800036b7: 48 89 df mov %rbx,%rdi +ffffffff800036ba: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff800036c0: e9 93 fd ff ff jmp ffffffff80003458 + ctx->bold = ctx->saved_state_bold; +ffffffff800036c5: 0f b7 83 c0 00 00 00 movzwl 0xc0(%rbx),%eax + ctx->current_primary = ctx->saved_state_current_primary; +ffffffff800036cc: 48 8b 93 d0 00 00 00 mov 0xd0(%rbx),%rdx + ctx->restore_state(ctx); +ffffffff800036d3: 48 89 df mov %rbx,%rdi + ctx->bold = ctx->saved_state_bold; +ffffffff800036d6: 66 89 43 11 mov %ax,0x11(%rbx) + ctx->reverse_video = ctx->saved_state_reverse_video; +ffffffff800036da: 0f b6 83 c2 00 00 00 movzbl 0xc2(%rbx),%eax + ctx->current_primary = ctx->saved_state_current_primary; +ffffffff800036e1: 48 89 53 58 mov %rdx,0x58(%rbx) + ctx->reverse_video = ctx->saved_state_reverse_video; +ffffffff800036e5: 88 43 13 mov %al,0x13(%rbx) + ctx->current_charset = ctx->saved_state_current_charset; +ffffffff800036e8: 48 8b 83 c8 00 00 00 mov 0xc8(%rbx),%rax +ffffffff800036ef: 48 89 43 30 mov %rax,0x30(%rbx) + ctx->current_primary = ctx->saved_state_current_primary; +ffffffff800036f3: 48 8b 83 d8 00 00 00 mov 0xd8(%rbx),%rax +ffffffff800036fa: 48 89 43 60 mov %rax,0x60(%rbx) + ctx->restore_state(ctx); +ffffffff800036fe: ff 93 88 01 00 00 call *0x188(%rbx) +} +ffffffff80003704: e9 4f fd ff ff jmp ffffffff80003458 + ctx->tab_size = 8; +ffffffff80003709: 48 c7 03 08 00 00 00 movq $0x8,(%rbx) + ctx->clear(ctx, true); +ffffffff80003710: be 01 00 00 00 mov $0x1,%esi +ffffffff80003715: 48 89 df mov %rbx,%rdi + ctx->dec_private = false; +ffffffff80003718: 0f b7 05 81 82 00 00 movzwl 0x8281(%rip),%eax # ffffffff8000b9a0 + ctx->autoflush = true; +ffffffff8000371f: 48 c7 43 08 01 01 01 movq $0x10101,0x8(%rbx) +ffffffff80003726: 00 + ctx->dec_private = false; +ffffffff80003727: 66 89 43 14 mov %ax,0x14(%rbx) + ctx->g_select = 0; +ffffffff8000372b: 66 89 43 28 mov %ax,0x28(%rbx) + ctx->scroll_bottom_margin = ctx->rows; +ffffffff8000372f: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax + ctx->discard_next = false; +ffffffff80003736: c7 43 10 00 00 00 00 movl $0x0,0x10(%rbx) + ctx->unicode_remaining = 0; +ffffffff8000373d: 48 c7 43 20 00 00 00 movq $0x0,0x20(%rbx) +ffffffff80003744: 00 + ctx->charsets[1] = CHARSET_DEC_SPECIAL; +ffffffff80003745: c6 43 2a 01 movb $0x1,0x2a(%rbx) + ctx->current_charset = 0; +ffffffff80003749: 48 c7 43 30 00 00 00 movq $0x0,0x30(%rbx) +ffffffff80003750: 00 + ctx->escape_offset = 0; +ffffffff80003751: 48 c7 43 38 00 00 00 movq $0x0,0x38(%rbx) +ffffffff80003758: 00 + ctx->esc_values_i = 0; +ffffffff80003759: 48 c7 43 40 00 00 00 movq $0x0,0x40(%rbx) +ffffffff80003760: 00 + ctx->saved_cursor_x = 0; +ffffffff80003761: 48 c7 43 48 00 00 00 movq $0x0,0x48(%rbx) +ffffffff80003768: 00 + ctx->saved_cursor_y = 0; +ffffffff80003769: 48 c7 43 50 00 00 00 movq $0x0,0x50(%rbx) +ffffffff80003770: 00 + ctx->current_primary = (size_t)-1; +ffffffff80003771: 48 c7 43 58 ff ff ff movq $0xffffffffffffffff,0x58(%rbx) +ffffffff80003778: ff + ctx->current_bg = (size_t)-1; +ffffffff80003779: 48 c7 43 60 ff ff ff movq $0xffffffffffffffff,0x60(%rbx) +ffffffff80003780: ff + ctx->scroll_top_margin = 0; +ffffffff80003781: 48 c7 43 68 00 00 00 movq $0x0,0x68(%rbx) +ffffffff80003788: 00 + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80003789: 48 89 43 70 mov %rax,0x70(%rbx) + ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR; +ffffffff8000378d: 48 c7 83 b8 00 00 00 movq $0x10,0xb8(%rbx) +ffffffff80003794: 10 00 00 00 + ctx->clear(ctx, true); +ffffffff80003798: ff 93 f8 00 00 00 call *0xf8(%rbx) + break; +ffffffff8000379e: e9 b5 fc ff ff jmp ffffffff80003458 + ctx->osc = true; +ffffffff800037a3: b8 01 00 00 00 mov $0x1,%eax +ffffffff800037a8: 66 89 43 0d mov %ax,0xd(%rbx) + return; +ffffffff800037ac: e9 e6 f8 ff ff jmp ffffffff80003097 +ffffffff800037b1: 48 8d 43 78 lea 0x78(%rbx),%rax +ffffffff800037b5: 48 8d 93 b8 00 00 00 lea 0xb8(%rbx),%rdx + ctx->esc_values[i] = 0; +ffffffff800037bc: 48 c7 00 00 00 00 00 movq $0x0,(%rax) +ffffffff800037c3: 48 83 c0 10 add $0x10,%rax +ffffffff800037c7: 48 c7 40 f8 00 00 00 movq $0x0,-0x8(%rax) +ffffffff800037ce: 00 + for (size_t i = 0; i < FLANTERM_MAX_ESC_VALUES; i++) +ffffffff800037cf: 48 39 c2 cmp %rax,%rdx +ffffffff800037d2: 75 e8 jne ffffffff800037bc + ctx->esc_values_i = 0; +ffffffff800037d4: 48 c7 43 40 00 00 00 movq $0x0,0x40(%rbx) +ffffffff800037db: 00 + ctx->rrr = false; +ffffffff800037dc: c6 43 0f 00 movb $0x0,0xf(%rbx) + ctx->control_sequence = true; +ffffffff800037e0: c6 43 0b 01 movb $0x1,0xb(%rbx) + return; +ffffffff800037e4: e9 ae f8 ff ff jmp ffffffff80003097 + if (ctx->callback != NULL) { +ffffffff800037e9: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff800037f0: 48 85 c0 test %rax,%rax +ffffffff800037f3: 0f 84 5f fc ff ff je ffffffff80003458 + ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0); +ffffffff800037f9: 45 31 c0 xor %r8d,%r8d +ffffffff800037fc: 31 c9 xor %ecx,%ecx +ffffffff800037fe: 31 d2 xor %edx,%edx +ffffffff80003800: be 1e 00 00 00 mov $0x1e,%esi +ffffffff80003805: 48 89 df mov %rbx,%rdi +ffffffff80003808: ff d0 call *%rax +ffffffff8000380a: e9 49 fc ff ff jmp ffffffff80003458 + if (y == ctx->scroll_top_margin) { +ffffffff8000380f: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80003814: 48 39 43 68 cmp %rax,0x68(%rbx) +ffffffff80003818: 0f 84 9a 08 00 00 je ffffffff800040b8 + ctx->set_cursor_pos(ctx, 0, y - 1); +ffffffff8000381e: 48 8d 50 ff lea -0x1(%rax),%rdx +ffffffff80003822: 31 f6 xor %esi,%esi +ffffffff80003824: 48 89 df mov %rbx,%rdi +ffffffff80003827: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff8000382d: e9 26 fc ff ff jmp ffffffff80003458 + if (y == ctx->scroll_bottom_margin - 1) { +ffffffff80003832: 48 8b 4b 70 mov 0x70(%rbx),%rcx +ffffffff80003836: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff8000383b: 48 8d 51 ff lea -0x1(%rcx),%rdx +ffffffff8000383f: 48 39 c2 cmp %rax,%rdx +ffffffff80003842: 0f 84 28 08 00 00 je ffffffff80004070 + ctx->set_cursor_pos(ctx, 0, y + 1); +ffffffff80003848: 48 8d 50 01 lea 0x1(%rax),%rdx +ffffffff8000384c: 31 f6 xor %esi,%esi +ffffffff8000384e: 48 89 df mov %rbx,%rdi +ffffffff80003851: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff80003857: e9 fc fb ff ff jmp ffffffff80003458 + case 0x00a2: return 155; +ffffffff8000385c: be 9b 00 00 00 mov $0x9b,%esi +ffffffff80003861: e9 0a fe ff ff jmp ffffffff80003670 + case 0x00a1: return 173; +ffffffff80003866: be ad 00 00 00 mov $0xad,%esi +ffffffff8000386b: e9 00 fe ff ff jmp ffffffff80003670 + case 0x00b1: return 241; +ffffffff80003870: be f1 00 00 00 mov $0xf1,%esi +ffffffff80003875: e9 f6 fd ff ff jmp ffffffff80003670 + case 0x00b0: return 248; +ffffffff8000387a: be f8 00 00 00 mov $0xf8,%esi +ffffffff8000387f: e9 ec fd ff ff jmp ffffffff80003670 + case 0x00ac: return 170; +ffffffff80003884: be aa 00 00 00 mov $0xaa,%esi +ffffffff80003889: e9 e2 fd ff ff jmp ffffffff80003670 + case 0x00ab: return 174; +ffffffff8000388e: be ae 00 00 00 mov $0xae,%esi +ffffffff80003893: e9 d8 fd ff ff jmp ffffffff80003670 + case 0x00aa: return 166; +ffffffff80003898: be a6 00 00 00 mov $0xa6,%esi +ffffffff8000389d: e9 ce fd ff ff jmp ffffffff80003670 + case 0x00a5: return 157; +ffffffff800038a2: be 9d 00 00 00 mov $0x9d,%esi +ffffffff800038a7: e9 c4 fd ff ff jmp ffffffff80003670 + case 0x00a3: return 156; +ffffffff800038ac: be 9c 00 00 00 mov $0x9c,%esi +ffffffff800038b1: e9 ba fd ff ff jmp ffffffff80003670 + case 0x2663: return 5; +ffffffff800038b6: be 05 00 00 00 mov $0x5,%esi +ffffffff800038bb: e9 b0 fd ff ff jmp ffffffff80003670 + case 0x2660: return 6; +ffffffff800038c0: be 06 00 00 00 mov $0x6,%esi +ffffffff800038c5: e9 a6 fd ff ff jmp ffffffff80003670 + case 0x2642: return 11; +ffffffff800038ca: be 0b 00 00 00 mov $0xb,%esi +ffffffff800038cf: e9 9c fd ff ff jmp ffffffff80003670 + case 0x2640: return 12; +ffffffff800038d4: be 0c 00 00 00 mov $0xc,%esi +ffffffff800038d9: e9 92 fd ff ff jmp ffffffff80003670 + case 0x263c: return 15; +ffffffff800038de: be 0f 00 00 00 mov $0xf,%esi +ffffffff800038e3: e9 88 fd ff ff jmp ffffffff80003670 + case 0x263b: return 2; +ffffffff800038e8: be 02 00 00 00 mov $0x2,%esi +ffffffff800038ed: e9 7e fd ff ff jmp ffffffff80003670 + case 0x25d9: return 10; +ffffffff800038f2: be 0a 00 00 00 mov $0xa,%esi +ffffffff800038f7: e9 74 fd ff ff jmp ffffffff80003670 + case 0x266b: return 14; +ffffffff800038fc: be 0e 00 00 00 mov $0xe,%esi +ffffffff80003901: e9 6a fd ff ff jmp ffffffff80003670 + case 0x266a: return 13; +ffffffff80003906: be 0d 00 00 00 mov $0xd,%esi +ffffffff8000390b: e9 60 fd ff ff jmp ffffffff80003670 + case 0x2524: return 180; +ffffffff80003910: be b4 00 00 00 mov $0xb4,%esi +ffffffff80003915: e9 56 fd ff ff jmp ffffffff80003670 + case 0x251c: return 195; +ffffffff8000391a: be c3 00 00 00 mov $0xc3,%esi +ffffffff8000391f: e9 4c fd ff ff jmp ffffffff80003670 + case 0x2518: return 217; +ffffffff80003924: be d9 00 00 00 mov $0xd9,%esi +ffffffff80003929: e9 42 fd ff ff jmp ffffffff80003670 + case 0x2514: return 192; +ffffffff8000392e: be c0 00 00 00 mov $0xc0,%esi +ffffffff80003933: e9 38 fd ff ff jmp ffffffff80003670 + case 0x2510: return 191; +ffffffff80003938: be bf 00 00 00 mov $0xbf,%esi +ffffffff8000393d: e9 2e fd ff ff jmp ffffffff80003670 + case 0x250c: return 218; +ffffffff80003942: be da 00 00 00 mov $0xda,%esi +ffffffff80003947: e9 24 fd ff ff jmp ffffffff80003670 + case 0x2502: return 179; +ffffffff8000394c: be b3 00 00 00 mov $0xb3,%esi +ffffffff80003951: e9 1a fd ff ff jmp ffffffff80003670 + case 0x2500: return 196; +ffffffff80003956: be c4 00 00 00 mov $0xc4,%esi +ffffffff8000395b: e9 10 fd ff ff jmp ffffffff80003670 + case 0x0192: return 159; +ffffffff80003960: be 9f 00 00 00 mov $0x9f,%esi +ffffffff80003965: e9 06 fd ff ff jmp ffffffff80003670 + case 0x00ff: return 152; +ffffffff8000396a: be 98 00 00 00 mov $0x98,%esi +ffffffff8000396f: e9 fc fc ff ff jmp ffffffff80003670 + case 0x00fc: return 129; +ffffffff80003974: be 81 00 00 00 mov $0x81,%esi +ffffffff80003979: e9 f2 fc ff ff jmp ffffffff80003670 + case 0x00fb: return 150; +ffffffff8000397e: be 96 00 00 00 mov $0x96,%esi +ffffffff80003983: e9 e8 fc ff ff jmp ffffffff80003670 + case 0x00fa: return 163; +ffffffff80003988: be a3 00 00 00 mov $0xa3,%esi +ffffffff8000398d: e9 de fc ff ff jmp ffffffff80003670 + case 0x00f9: return 151; +ffffffff80003992: be 97 00 00 00 mov $0x97,%esi +ffffffff80003997: e9 d4 fc ff ff jmp ffffffff80003670 + case 0x00f7: return 246; +ffffffff8000399c: be f6 00 00 00 mov $0xf6,%esi +ffffffff800039a1: e9 ca fc ff ff jmp ffffffff80003670 + case 0x00f6: return 148; +ffffffff800039a6: be 94 00 00 00 mov $0x94,%esi +ffffffff800039ab: e9 c0 fc ff ff jmp ffffffff80003670 + case 0x00f4: return 147; +ffffffff800039b0: be 93 00 00 00 mov $0x93,%esi +ffffffff800039b5: e9 b6 fc ff ff jmp ffffffff80003670 + case 0x00f3: return 162; +ffffffff800039ba: be a2 00 00 00 mov $0xa2,%esi +ffffffff800039bf: e9 ac fc ff ff jmp ffffffff80003670 + case 0x00f2: return 149; +ffffffff800039c4: be 95 00 00 00 mov $0x95,%esi +ffffffff800039c9: e9 a2 fc ff ff jmp ffffffff80003670 + case 0x00f1: return 164; +ffffffff800039ce: be a4 00 00 00 mov $0xa4,%esi +ffffffff800039d3: e9 98 fc ff ff jmp ffffffff80003670 + case 0x00ef: return 139; +ffffffff800039d8: be 8b 00 00 00 mov $0x8b,%esi +ffffffff800039dd: e9 8e fc ff ff jmp ffffffff80003670 + case 0x2194: return 29; +ffffffff800039e2: be 1d 00 00 00 mov $0x1d,%esi +ffffffff800039e7: e9 84 fc ff ff jmp ffffffff80003670 + case 0x2193: return 25; +ffffffff800039ec: be 19 00 00 00 mov $0x19,%esi +ffffffff800039f1: e9 7a fc ff ff jmp ffffffff80003670 + case 0x2192: return 26; +ffffffff800039f6: be 1a 00 00 00 mov $0x1a,%esi +ffffffff800039fb: e9 70 fc ff ff jmp ffffffff80003670 + case 0x2191: return 24; +ffffffff80003a00: be 18 00 00 00 mov $0x18,%esi +ffffffff80003a05: e9 66 fc ff ff jmp ffffffff80003670 + case 0x2190: return 27; +ffffffff80003a0a: be 1b 00 00 00 mov $0x1b,%esi +ffffffff80003a0f: e9 5c fc ff ff jmp ffffffff80003670 + case 0x00ee: return 140; +ffffffff80003a14: be 8c 00 00 00 mov $0x8c,%esi +ffffffff80003a19: e9 52 fc ff ff jmp ffffffff80003670 + case 0x00ed: return 161; +ffffffff80003a1e: be a1 00 00 00 mov $0xa1,%esi +ffffffff80003a23: e9 48 fc ff ff jmp ffffffff80003670 + case 0x00ec: return 141; +ffffffff80003a28: be 8d 00 00 00 mov $0x8d,%esi +ffffffff80003a2d: e9 3e fc ff ff jmp ffffffff80003670 + case 0x00eb: return 137; +ffffffff80003a32: be 89 00 00 00 mov $0x89,%esi +ffffffff80003a37: e9 34 fc ff ff jmp ffffffff80003670 + case 0x00ea: return 136; +ffffffff80003a3c: be 88 00 00 00 mov $0x88,%esi +ffffffff80003a41: e9 2a fc ff ff jmp ffffffff80003670 + case 0x00e9: return 130; +ffffffff80003a46: be 82 00 00 00 mov $0x82,%esi +ffffffff80003a4b: e9 20 fc ff ff jmp ffffffff80003670 + case 0x00e8: return 138; +ffffffff80003a50: be 8a 00 00 00 mov $0x8a,%esi +ffffffff80003a55: e9 16 fc ff ff jmp ffffffff80003670 + case 0x00e7: return 135; +ffffffff80003a5a: be 87 00 00 00 mov $0x87,%esi +ffffffff80003a5f: e9 0c fc ff ff jmp ffffffff80003670 + case 0x00e6: return 145; +ffffffff80003a64: be 91 00 00 00 mov $0x91,%esi +ffffffff80003a69: e9 02 fc ff ff jmp ffffffff80003670 + case 0x00e5: return 134; +ffffffff80003a6e: be 86 00 00 00 mov $0x86,%esi +ffffffff80003a73: e9 f8 fb ff ff jmp ffffffff80003670 + case 0x00e4: return 132; +ffffffff80003a78: be 84 00 00 00 mov $0x84,%esi +ffffffff80003a7d: e9 ee fb ff ff jmp ffffffff80003670 + case 0x00e2: return 131; +ffffffff80003a82: be 83 00 00 00 mov $0x83,%esi +ffffffff80003a87: e9 e4 fb ff ff jmp ffffffff80003670 + case 0x00e1: return 160; +ffffffff80003a8c: be a0 00 00 00 mov $0xa0,%esi +ffffffff80003a91: e9 da fb ff ff jmp ffffffff80003670 + case 0x00e0: return 133; +ffffffff80003a96: be 85 00 00 00 mov $0x85,%esi +ffffffff80003a9b: e9 d0 fb ff ff jmp ffffffff80003670 + case 0x00df: return 225; +ffffffff80003aa0: be e1 00 00 00 mov $0xe1,%esi +ffffffff80003aa5: e9 c6 fb ff ff jmp ffffffff80003670 + case 0x00dc: return 154; +ffffffff80003aaa: be 9a 00 00 00 mov $0x9a,%esi +ffffffff80003aaf: e9 bc fb ff ff jmp ffffffff80003670 + case 0x00d6: return 153; +ffffffff80003ab4: be 99 00 00 00 mov $0x99,%esi +ffffffff80003ab9: e9 b2 fb ff ff jmp ffffffff80003670 + case 0x00d1: return 165; +ffffffff80003abe: be a5 00 00 00 mov $0xa5,%esi +ffffffff80003ac3: e9 a8 fb ff ff jmp ffffffff80003670 + case 0x00c9: return 144; +ffffffff80003ac8: be 90 00 00 00 mov $0x90,%esi +ffffffff80003acd: e9 9e fb ff ff jmp ffffffff80003670 + case 0x00c7: return 128; +ffffffff80003ad2: be 80 00 00 00 mov $0x80,%esi +ffffffff80003ad7: e9 94 fb ff ff jmp ffffffff80003670 + case 0x00c6: return 146; +ffffffff80003adc: be 92 00 00 00 mov $0x92,%esi +ffffffff80003ae1: e9 8a fb ff ff jmp ffffffff80003670 + case 0x00c5: return 143; +ffffffff80003ae6: be 8f 00 00 00 mov $0x8f,%esi +ffffffff80003aeb: e9 80 fb ff ff jmp ffffffff80003670 + case 0x00c4: return 142; +ffffffff80003af0: be 8e 00 00 00 mov $0x8e,%esi +ffffffff80003af5: e9 76 fb ff ff jmp ffffffff80003670 + case 0x00bf: return 168; +ffffffff80003afa: be a8 00 00 00 mov $0xa8,%esi +ffffffff80003aff: e9 6c fb ff ff jmp ffffffff80003670 + case 0x00bd: return 171; +ffffffff80003b04: be ab 00 00 00 mov $0xab,%esi +ffffffff80003b09: e9 62 fb ff ff jmp ffffffff80003670 + case 0x00bc: return 172; +ffffffff80003b0e: be ac 00 00 00 mov $0xac,%esi +ffffffff80003b13: e9 58 fb ff ff jmp ffffffff80003670 + case 0x00bb: return 175; +ffffffff80003b18: be af 00 00 00 mov $0xaf,%esi +ffffffff80003b1d: e9 4e fb ff ff jmp ffffffff80003670 + case 0x00ba: return 167; +ffffffff80003b22: be a7 00 00 00 mov $0xa7,%esi +ffffffff80003b27: e9 44 fb ff ff jmp ffffffff80003670 + case 0x00b7: return 250; +ffffffff80003b2c: be fa 00 00 00 mov $0xfa,%esi +ffffffff80003b31: e9 3a fb ff ff jmp ffffffff80003670 + case 0x00b5: return 230; +ffffffff80003b36: be e6 00 00 00 mov $0xe6,%esi +ffffffff80003b3b: e9 30 fb ff ff jmp ffffffff80003670 + case 0x00b2: return 253; +ffffffff80003b40: be fd 00 00 00 mov $0xfd,%esi +ffffffff80003b45: e9 26 fb ff ff jmp ffffffff80003670 + case 0x03c6: return 237; +ffffffff80003b4a: be ed 00 00 00 mov $0xed,%esi +ffffffff80003b4f: e9 1c fb ff ff jmp ffffffff80003670 + case 0x03c4: return 231; +ffffffff80003b54: be e7 00 00 00 mov $0xe7,%esi +ffffffff80003b59: e9 12 fb ff ff jmp ffffffff80003670 + case 0x03c3: return 229; +ffffffff80003b5e: be e5 00 00 00 mov $0xe5,%esi +ffffffff80003b63: e9 08 fb ff ff jmp ffffffff80003670 + case 0x03c0: return 227; +ffffffff80003b68: be e3 00 00 00 mov $0xe3,%esi +ffffffff80003b6d: e9 fe fa ff ff jmp ffffffff80003670 + case 0x03b5: return 238; +ffffffff80003b72: be ee 00 00 00 mov $0xee,%esi +ffffffff80003b77: e9 f4 fa ff ff jmp ffffffff80003670 + case 0x03b4: return 235; +ffffffff80003b7c: be eb 00 00 00 mov $0xeb,%esi +ffffffff80003b81: e9 ea fa ff ff jmp ffffffff80003670 + case 0x03a9: return 234; +ffffffff80003b86: be ea 00 00 00 mov $0xea,%esi +ffffffff80003b8b: e9 e0 fa ff ff jmp ffffffff80003670 + case 0x03a6: return 232; +ffffffff80003b90: be e8 00 00 00 mov $0xe8,%esi +ffffffff80003b95: e9 d6 fa ff ff jmp ffffffff80003670 + case 0x03a3: return 228; +ffffffff80003b9a: be e4 00 00 00 mov $0xe4,%esi +ffffffff80003b9f: e9 cc fa ff ff jmp ffffffff80003670 + case 0x0398: return 233; +ffffffff80003ba4: be e9 00 00 00 mov $0xe9,%esi +ffffffff80003ba9: e9 c2 fa ff ff jmp ffffffff80003670 + case 0x255c: return 189; +ffffffff80003bae: be bd 00 00 00 mov $0xbd,%esi +ffffffff80003bb3: e9 b8 fa ff ff jmp ffffffff80003670 + case 0x255b: return 190; +ffffffff80003bb8: be be 00 00 00 mov $0xbe,%esi +ffffffff80003bbd: e9 ae fa ff ff jmp ffffffff80003670 + case 0x255a: return 200; +ffffffff80003bc2: be c8 00 00 00 mov $0xc8,%esi +ffffffff80003bc7: e9 a4 fa ff ff jmp ffffffff80003670 + case 0x2559: return 211; +ffffffff80003bcc: be d3 00 00 00 mov $0xd3,%esi +ffffffff80003bd1: e9 9a fa ff ff jmp ffffffff80003670 + case 0x2558: return 212; +ffffffff80003bd6: be d4 00 00 00 mov $0xd4,%esi +ffffffff80003bdb: e9 90 fa ff ff jmp ffffffff80003670 + case 0x2557: return 187; +ffffffff80003be0: be bb 00 00 00 mov $0xbb,%esi +ffffffff80003be5: e9 86 fa ff ff jmp ffffffff80003670 + case 0x2556: return 183; +ffffffff80003bea: be b7 00 00 00 mov $0xb7,%esi +ffffffff80003bef: e9 7c fa ff ff jmp ffffffff80003670 + case 0x2555: return 184; +ffffffff80003bf4: be b8 00 00 00 mov $0xb8,%esi +ffffffff80003bf9: e9 72 fa ff ff jmp ffffffff80003670 + case 0x2554: return 201; +ffffffff80003bfe: be c9 00 00 00 mov $0xc9,%esi +ffffffff80003c03: e9 68 fa ff ff jmp ffffffff80003670 + case 0x2553: return 214; +ffffffff80003c08: be d6 00 00 00 mov $0xd6,%esi +ffffffff80003c0d: e9 5e fa ff ff jmp ffffffff80003670 + case 0x2552: return 213; +ffffffff80003c12: be d5 00 00 00 mov $0xd5,%esi +ffffffff80003c17: e9 54 fa ff ff jmp ffffffff80003670 + case 0x2551: return 186; +ffffffff80003c1c: be ba 00 00 00 mov $0xba,%esi +ffffffff80003c21: e9 4a fa ff ff jmp ffffffff80003670 + case 0x2550: return 205; +ffffffff80003c26: be cd 00 00 00 mov $0xcd,%esi +ffffffff80003c2b: e9 40 fa ff ff jmp ffffffff80003670 + case 0x253c: return 197; +ffffffff80003c30: be c5 00 00 00 mov $0xc5,%esi +ffffffff80003c35: e9 36 fa ff ff jmp ffffffff80003670 + case 0x2534: return 193; +ffffffff80003c3a: be c1 00 00 00 mov $0xc1,%esi +ffffffff80003c3f: e9 2c fa ff ff jmp ffffffff80003670 + case 0x252c: return 194; +ffffffff80003c44: be c2 00 00 00 mov $0xc2,%esi +ffffffff80003c49: e9 22 fa ff ff jmp ffffffff80003670 + case 0x25d8: return 8; +ffffffff80003c4e: be 08 00 00 00 mov $0x8,%esi +ffffffff80003c53: e9 18 fa ff ff jmp ffffffff80003670 + case 0x25cb: return 9; +ffffffff80003c58: be 09 00 00 00 mov $0x9,%esi +ffffffff80003c5d: e9 0e fa ff ff jmp ffffffff80003670 + case 0x25c4: return 17; +ffffffff80003c62: be 11 00 00 00 mov $0x11,%esi +ffffffff80003c67: e9 04 fa ff ff jmp ffffffff80003670 + case 0x25bc: return 31; +ffffffff80003c6c: be 1f 00 00 00 mov $0x1f,%esi +ffffffff80003c71: e9 fa f9 ff ff jmp ffffffff80003670 + case 0x25ba: return 16; +ffffffff80003c76: be 10 00 00 00 mov $0x10,%esi +ffffffff80003c7b: e9 f0 f9 ff ff jmp ffffffff80003670 + case 0x25b2: return 30; +ffffffff80003c80: be 1e 00 00 00 mov $0x1e,%esi +ffffffff80003c85: e9 e6 f9 ff ff jmp ffffffff80003670 + case 0x25ac: return 22; +ffffffff80003c8a: be 16 00 00 00 mov $0x16,%esi +ffffffff80003c8f: e9 dc f9 ff ff jmp ffffffff80003670 + case 0x25a0: return 254; +ffffffff80003c94: be fe 00 00 00 mov $0xfe,%esi +ffffffff80003c99: e9 d2 f9 ff ff jmp ffffffff80003670 + case 0x2593: return 178; +ffffffff80003c9e: be b2 00 00 00 mov $0xb2,%esi +ffffffff80003ca3: e9 c8 f9 ff ff jmp ffffffff80003670 + case 0x2592: return 177; +ffffffff80003ca8: be b1 00 00 00 mov $0xb1,%esi +ffffffff80003cad: e9 be f9 ff ff jmp ffffffff80003670 + case 0x2591: return 176; +ffffffff80003cb2: be b0 00 00 00 mov $0xb0,%esi +ffffffff80003cb7: e9 b4 f9 ff ff jmp ffffffff80003670 + case 0x2590: return 222; +ffffffff80003cbc: be de 00 00 00 mov $0xde,%esi +ffffffff80003cc1: e9 aa f9 ff ff jmp ffffffff80003670 + case 0x258c: return 221; +ffffffff80003cc6: be dd 00 00 00 mov $0xdd,%esi +ffffffff80003ccb: e9 a0 f9 ff ff jmp ffffffff80003670 + case 0x2588: return 219; +ffffffff80003cd0: be db 00 00 00 mov $0xdb,%esi +ffffffff80003cd5: e9 96 f9 ff ff jmp ffffffff80003670 + case 0x2584: return 220; +ffffffff80003cda: be dc 00 00 00 mov $0xdc,%esi +ffffffff80003cdf: e9 8c f9 ff ff jmp ffffffff80003670 + case 0x2580: return 223; +ffffffff80003ce4: be df 00 00 00 mov $0xdf,%esi +ffffffff80003ce9: e9 82 f9 ff ff jmp ffffffff80003670 + case 0x256c: return 206; +ffffffff80003cee: be ce 00 00 00 mov $0xce,%esi +ffffffff80003cf3: e9 78 f9 ff ff jmp ffffffff80003670 + case 0x256b: return 215; +ffffffff80003cf8: be d7 00 00 00 mov $0xd7,%esi +ffffffff80003cfd: e9 6e f9 ff ff jmp ffffffff80003670 + case 0x256a: return 216; +ffffffff80003d02: be d8 00 00 00 mov $0xd8,%esi +ffffffff80003d07: e9 64 f9 ff ff jmp ffffffff80003670 + case 0x2569: return 202; +ffffffff80003d0c: be ca 00 00 00 mov $0xca,%esi +ffffffff80003d11: e9 5a f9 ff ff jmp ffffffff80003670 + case 0x2568: return 208; +ffffffff80003d16: be d0 00 00 00 mov $0xd0,%esi +ffffffff80003d1b: e9 50 f9 ff ff jmp ffffffff80003670 + case 0x2567: return 207; +ffffffff80003d20: be cf 00 00 00 mov $0xcf,%esi +ffffffff80003d25: e9 46 f9 ff ff jmp ffffffff80003670 + case 0x2566: return 203; +ffffffff80003d2a: be cb 00 00 00 mov $0xcb,%esi +ffffffff80003d2f: e9 3c f9 ff ff jmp ffffffff80003670 + case 0x2565: return 210; +ffffffff80003d34: be d2 00 00 00 mov $0xd2,%esi +ffffffff80003d39: e9 32 f9 ff ff jmp ffffffff80003670 + case 0x2564: return 209; +ffffffff80003d3e: be d1 00 00 00 mov $0xd1,%esi +ffffffff80003d43: e9 28 f9 ff ff jmp ffffffff80003670 + case 0x2563: return 185; +ffffffff80003d48: be b9 00 00 00 mov $0xb9,%esi +ffffffff80003d4d: e9 1e f9 ff ff jmp ffffffff80003670 + case 0x2562: return 182; +ffffffff80003d52: be b6 00 00 00 mov $0xb6,%esi +ffffffff80003d57: e9 14 f9 ff ff jmp ffffffff80003670 + case 0x2561: return 181; +ffffffff80003d5c: be b5 00 00 00 mov $0xb5,%esi +ffffffff80003d61: e9 0a f9 ff ff jmp ffffffff80003670 + case 0x2560: return 204; +ffffffff80003d66: be cc 00 00 00 mov $0xcc,%esi +ffffffff80003d6b: e9 00 f9 ff ff jmp ffffffff80003670 + case 0x255f: return 199; +ffffffff80003d70: be c7 00 00 00 mov $0xc7,%esi +ffffffff80003d75: e9 f6 f8 ff ff jmp ffffffff80003670 + case 0x255e: return 198; +ffffffff80003d7a: be c6 00 00 00 mov $0xc6,%esi +ffffffff80003d7f: e9 ec f8 ff ff jmp ffffffff80003670 + case 0x255d: return 188; +ffffffff80003d84: be bc 00 00 00 mov $0xbc,%esi +ffffffff80003d89: e9 e2 f8 ff ff jmp ffffffff80003670 + case 0x03b1: return 224; +ffffffff80003d8e: be e0 00 00 00 mov $0xe0,%esi +ffffffff80003d93: e9 d8 f8 ff ff jmp ffffffff80003670 + case 0x0393: return 226; +ffffffff80003d98: be e2 00 00 00 mov $0xe2,%esi +ffffffff80003d9d: e9 ce f8 ff ff jmp ffffffff80003670 + case 0x00b6: return 20; +ffffffff80003da2: be 14 00 00 00 mov $0x14,%esi +ffffffff80003da7: e9 c4 f8 ff ff jmp ffffffff80003670 + switch (code_point) { +ffffffff80003dac: be 01 00 00 00 mov $0x1,%esi +ffffffff80003db1: e9 ba f8 ff ff jmp ffffffff80003670 + case 0x2666: return 4; +ffffffff80003db6: be 04 00 00 00 mov $0x4,%esi +ffffffff80003dbb: e9 b0 f8 ff ff jmp ffffffff80003670 + switch (code_point) { +ffffffff80003dc0: be 03 00 00 00 mov $0x3,%esi +ffffffff80003dc5: e9 a6 f8 ff ff jmp ffffffff80003670 + case 0x21a8: return 23; +ffffffff80003dca: be 17 00 00 00 mov $0x17,%esi +ffffffff80003dcf: e9 9c f8 ff ff jmp ffffffff80003670 + case 0x2195: return 18; +ffffffff80003dd4: be 12 00 00 00 mov $0x12,%esi +ffffffff80003dd9: e9 92 f8 ff ff jmp ffffffff80003670 + case 0x00a7: return 21; +ffffffff80003dde: be 15 00 00 00 mov $0x15,%esi +ffffffff80003de3: e9 88 f8 ff ff jmp ffffffff80003670 +ffffffff80003de8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80003def: 00 + ctx->osc_escape = true; +ffffffff80003df0: c6 43 0e 01 movb $0x1,0xe(%rbx) + return; +ffffffff80003df4: e9 9e f2 ff ff jmp ffffffff80003097 + ctx->scroll(ctx); +ffffffff80003df9: 48 89 df mov %rbx,%rdi +ffffffff80003dfc: ff 93 68 01 00 00 call *0x168(%rbx) + ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y); +ffffffff80003e02: 48 8b 83 00 01 00 00 mov 0x100(%rbx),%rax +ffffffff80003e09: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff80003e0e: 31 f6 xor %esi,%esi +ffffffff80003e10: f6 83 b8 00 00 00 10 testb $0x10,0xb8(%rbx) +ffffffff80003e17: 0f 85 65 f5 ff ff jne ffffffff80003382 +ffffffff80003e1d: e9 5b f5 ff ff jmp ffffffff8000337d + ctx->set_cursor_pos(ctx, ctx->cols - 1, y); +ffffffff80003e22: 48 8d 72 ff lea -0x1(%rdx),%rsi +ffffffff80003e26: 48 89 fa mov %rdi,%rdx +ffffffff80003e29: 48 89 df mov %rbx,%rdi +ffffffff80003e2c: ff d1 call *%rcx + return; +ffffffff80003e2e: e9 64 f2 ff ff jmp ffffffff80003097 + switch (c) { +ffffffff80003e33: 41 8d 54 24 d5 lea -0x2b(%r12),%edx +ffffffff80003e38: 80 fa 53 cmp $0x53,%dl +ffffffff80003e3b: 0f 87 e0 f4 ff ff ja ffffffff80003321 +ffffffff80003e41: 0f b6 d2 movzbl %dl,%edx +ffffffff80003e44: 3e ff 24 d5 18 a8 00 notrack jmp *-0x7fff57e8(,%rdx,8) +ffffffff80003e4b: 80 + if (ctx->rrr == true) { +ffffffff80003e4c: 80 7b 0f 00 cmpb $0x0,0xf(%rbx) +ffffffff80003e50: 0f 84 8a 01 00 00 je ffffffff80003fe0 + ctx->esc_values_i++; +ffffffff80003e56: 48 83 c2 01 add $0x1,%rdx + ctx->rrr = false; +ffffffff80003e5a: c6 43 0f 00 movb $0x0,0xf(%rbx) + ctx->esc_values_i++; +ffffffff80003e5e: 48 89 53 40 mov %rdx,0x40(%rbx) + if (c == ';') +ffffffff80003e62: 41 80 fc 3b cmp $0x3b,%r12b +ffffffff80003e66: 0f 84 2b f2 ff ff je ffffffff80003097 + if (ctx->dec_private == true) { +ffffffff80003e6c: 0f b6 73 14 movzbl 0x14(%rbx),%esi + switch (c) { +ffffffff80003e70: 41 80 fc 4b cmp $0x4b,%r12b +ffffffff80003e74: 0f 8f 8f 01 00 00 jg ffffffff80004009 +ffffffff80003e7a: 41 80 fc 49 cmp $0x49,%r12b +ffffffff80003e7e: 0f 8f 67 02 00 00 jg ffffffff800040eb + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80003e84: 41 b8 01 00 00 00 mov $0x1,%r8d +ffffffff80003e8a: 48 83 fa 0f cmp $0xf,%rdx +ffffffff80003e8e: 0f 87 d2 09 00 00 ja ffffffff80004866 +ffffffff80003e94: 48 8d bb b8 00 00 00 lea 0xb8(%rbx),%rdi +ffffffff80003e9b: 48 8d 44 93 78 lea 0x78(%rbx,%rdx,4),%rax + ctx->esc_values[i] = esc_default; +ffffffff80003ea0: 44 89 c1 mov %r8d,%ecx +ffffffff80003ea3: 49 89 f9 mov %rdi,%r9 +ffffffff80003ea6: 49 29 c1 sub %rax,%r9 +ffffffff80003ea9: 41 83 e1 04 and $0x4,%r9d +ffffffff80003ead: 74 0c je ffffffff80003ebb +ffffffff80003eaf: 44 89 00 mov %r8d,(%rax) + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80003eb2: 48 83 c0 04 add $0x4,%rax +ffffffff80003eb6: 48 39 c7 cmp %rax,%rdi +ffffffff80003eb9: 74 0e je ffffffff80003ec9 + ctx->esc_values[i] = esc_default; +ffffffff80003ebb: 89 08 mov %ecx,(%rax) + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80003ebd: 48 83 c0 08 add $0x8,%rax + ctx->esc_values[i] = esc_default; +ffffffff80003ec1: 89 48 fc mov %ecx,-0x4(%rax) + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80003ec4: 48 39 c7 cmp %rax,%rdi +ffffffff80003ec7: 75 f2 jne ffffffff80003ebb + if (ctx->dec_private == true) { +ffffffff80003ec9: 40 84 f6 test %sil,%sil +ffffffff80003ecc: 0f 85 e8 02 00 00 jne ffffffff800041ba + bool r = ctx->scroll_enabled; +ffffffff80003ed2: 44 0f b6 73 0a movzbl 0xa(%rbx),%r14d + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80003ed7: 48 8d 54 24 18 lea 0x18(%rsp),%rdx + ctx->scroll_enabled = false; +ffffffff80003edc: c6 43 0a 00 movb $0x0,0xa(%rbx) + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80003ee0: 48 89 df mov %rbx,%rdi +ffffffff80003ee3: 48 8d 74 24 10 lea 0x10(%rsp),%rsi +ffffffff80003ee8: ff 93 08 01 00 00 call *0x108(%rbx) + switch (c) { +ffffffff80003eee: 41 8d 44 24 c0 lea -0x40(%r12),%eax +ffffffff80003ef3: 3c 35 cmp $0x35,%al +ffffffff80003ef5: 77 67 ja ffffffff80003f5e +ffffffff80003ef7: 0f b6 c0 movzbl %al,%eax +ffffffff80003efa: 3e ff 24 c5 b8 aa 00 notrack jmp *-0x7fff5548(,%rax,8) +ffffffff80003f01: 80 + x = 0; +ffffffff80003f02: 31 ff xor %edi,%edi +ffffffff80003f04: 48 89 7c 24 10 mov %rdi,0x10(%rsp) + if (y + ctx->esc_values[0] > ctx->rows - 1) +ffffffff80003f09: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx +ffffffff80003f0e: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff80003f15: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80003f18: 48 8d 78 ff lea -0x1(%rax),%rdi +ffffffff80003f1c: 48 8d 34 0a lea (%rdx,%rcx,1),%rsi +ffffffff80003f20: 48 39 f7 cmp %rsi,%rdi +ffffffff80003f23: 73 08 jae ffffffff80003f2d + ctx->esc_values[0] = (ctx->rows - 1) - y; +ffffffff80003f25: 29 c8 sub %ecx,%eax +ffffffff80003f27: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80003f2a: 89 53 78 mov %edx,0x78(%rbx) + if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y) +ffffffff80003f2d: 48 8b 73 68 mov 0x68(%rbx),%rsi + || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) { +ffffffff80003f31: 48 8b 43 70 mov 0x70(%rbx),%rax + size_t dest_y = y + ctx->esc_values[0]; +ffffffff80003f35: 48 01 ca add %rcx,%rdx + if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y) +ffffffff80003f38: 48 39 ce cmp %rcx,%rsi +ffffffff80003f3b: 72 05 jb ffffffff80003f42 +ffffffff80003f3d: 48 39 f2 cmp %rsi,%rdx +ffffffff80003f40: 73 05 jae ffffffff80003f47 + || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) { +ffffffff80003f42: 48 39 c8 cmp %rcx,%rax +ffffffff80003f45: 72 09 jb ffffffff80003f50 + if (will_be_in_scroll_region && dest_y >= ctx->scroll_bottom_margin) { +ffffffff80003f47: 48 39 c2 cmp %rax,%rdx +ffffffff80003f4a: 0f 83 dc 07 00 00 jae ffffffff8000472c + ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]); +ffffffff80003f50: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff80003f55: 48 89 df mov %rbx,%rdi +ffffffff80003f58: ff 93 00 01 00 00 call *0x100(%rbx) + ctx->scroll_enabled = r; +ffffffff80003f5e: 44 88 73 0a mov %r14b,0xa(%rbx) + ctx->control_sequence = false; +ffffffff80003f62: 31 d2 xor %edx,%edx +ffffffff80003f64: 66 89 53 0b mov %dx,0xb(%rbx) +ffffffff80003f68: e9 2a f1 ff ff jmp ffffffff80003097 + switch (c) { +ffffffff80003f6d: 41 80 fc 3f cmp $0x3f,%r12b +ffffffff80003f71: 0f 84 17 01 00 00 je ffffffff8000408e +ffffffff80003f77: 41 80 fc 5b cmp $0x5b,%r12b +ffffffff80003f7b: 0f 85 30 f6 ff ff jne ffffffff800035b1 + ctx->discard_next = true; +ffffffff80003f81: c6 43 10 01 movb $0x1,0x10(%rbx) + goto cleanup; +ffffffff80003f85: eb db jmp ffffffff80003f62 + switch (code_point) { +ffffffff80003f87: 49 8d 84 24 e7 dd ff lea -0x2219(%r12),%rax +ffffffff80003f8e: ff +ffffffff80003f8f: 48 83 f8 2f cmp $0x2f,%rax +ffffffff80003f93: 0f 87 27 f4 ff ff ja ffffffff800033c0 +ffffffff80003f99: 3e ff 24 c5 68 ac 00 notrack jmp *-0x7fff5398(,%rax,8) +ffffffff80003fa0: 80 +ffffffff80003fa1: 49 81 fc 7f 20 00 00 cmp $0x207f,%r12 +ffffffff80003fa8: 0f 84 02 02 00 00 je ffffffff800041b0 +ffffffff80003fae: 0f 87 dc 01 00 00 ja ffffffff80004190 +ffffffff80003fb4: 49 81 fc 22 20 00 00 cmp $0x2022,%r12 +ffffffff80003fbb: 0f 84 c5 01 00 00 je ffffffff80004186 + case 0x203c: return 19; +ffffffff80003fc1: be 13 00 00 00 mov $0x13,%esi + switch (code_point) { +ffffffff80003fc6: 49 81 fc 3c 20 00 00 cmp $0x203c,%r12 +ffffffff80003fcd: 0f 84 9d f6 ff ff je ffffffff80003670 +ffffffff80003fd3: e9 e8 f3 ff ff jmp ffffffff800033c0 +ffffffff80003fd8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80003fdf: 00 + } else if (c == ';') { +ffffffff80003fe0: 41 80 fc 3b cmp $0x3b,%r12b +ffffffff80003fe4: 0f 85 82 fe ff ff jne ffffffff80003e6c + if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) { +ffffffff80003fea: 48 83 fa 10 cmp $0x10,%rdx +ffffffff80003fee: 0f 84 a3 f0 ff ff je ffffffff80003097 + ctx->esc_values[ctx->esc_values_i] = 0; +ffffffff80003ff4: c7 44 93 78 00 00 00 movl $0x0,0x78(%rbx,%rdx,4) +ffffffff80003ffb: 00 + ctx->esc_values_i++; +ffffffff80003ffc: 48 83 c2 01 add $0x1,%rdx +ffffffff80004000: 48 89 53 40 mov %rdx,0x40(%rbx) + return; +ffffffff80004004: e9 8e f0 ff ff jmp ffffffff80003097 + switch (c) { +ffffffff80004009: 41 80 fc 71 cmp $0x71,%r12b +ffffffff8000400d: 0f 85 c3 00 00 00 jne ffffffff800040d6 + esc_default = 0; break; +ffffffff80004013: 45 31 c0 xor %r8d,%r8d + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80004016: 48 83 fa 0f cmp $0xf,%rdx +ffffffff8000401a: 0f 86 74 fe ff ff jbe ffffffff80003e94 + if (ctx->dec_private == true) { +ffffffff80004020: 40 84 f6 test %sil,%sil +ffffffff80004023: 0f 85 46 08 00 00 jne ffffffff8000486f + bool r = ctx->scroll_enabled; +ffffffff80004029: 44 0f b6 73 0a movzbl 0xa(%rbx),%r14d + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff8000402e: 48 8d 54 24 18 lea 0x18(%rsp),%rdx + ctx->scroll_enabled = false; +ffffffff80004033: c6 43 0a 00 movb $0x0,0xa(%rbx) + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80004037: 48 89 df mov %rbx,%rdi +ffffffff8000403a: 48 8d 74 24 10 lea 0x10(%rsp),%rsi +ffffffff8000403f: ff 93 08 01 00 00 call *0x108(%rbx) + if (ctx->callback != NULL) { +ffffffff80004045: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff8000404c: 48 85 c0 test %rax,%rax +ffffffff8000404f: 0f 84 09 ff ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_KBD_LEDS, ctx->esc_values[0], 0, 0); +ffffffff80004055: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80004058: 45 31 c0 xor %r8d,%r8d +ffffffff8000405b: 31 c9 xor %ecx,%ecx +ffffffff8000405d: be 3c 00 00 00 mov $0x3c,%esi +ffffffff80004062: 48 89 df mov %rbx,%rdi +ffffffff80004065: ff d0 call *%rax +ffffffff80004067: e9 f2 fe ff ff jmp ffffffff80003f5e +ffffffff8000406c: 0f 1f 40 00 nopl 0x0(%rax) + ctx->scroll(ctx); +ffffffff80004070: 48 89 df mov %rbx,%rdi +ffffffff80004073: ff 93 68 01 00 00 call *0x168(%rbx) + ctx->set_cursor_pos(ctx, 0, y); +ffffffff80004079: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000407e: 31 f6 xor %esi,%esi +ffffffff80004080: 48 89 df mov %rbx,%rdi +ffffffff80004083: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff80004089: e9 ca f3 ff ff jmp ffffffff80003458 + ctx->dec_private = true; +ffffffff8000408e: c6 43 14 01 movb $0x1,0x14(%rbx) + return; +ffffffff80004092: e9 00 f0 ff ff jmp ffffffff80003097 + ctx->scroll(ctx); +ffffffff80004097: 48 89 df mov %rbx,%rdi +ffffffff8000409a: ff 93 68 01 00 00 call *0x168(%rbx) + ctx->set_cursor_pos(ctx, x, y); +ffffffff800040a0: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800040a5: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff800040aa: 48 89 df mov %rbx,%rdi +ffffffff800040ad: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff800040b3: e9 a0 f3 ff ff jmp ffffffff80003458 + ctx->revscroll(ctx); +ffffffff800040b8: 48 89 df mov %rbx,%rdi +ffffffff800040bb: ff 93 70 01 00 00 call *0x170(%rbx) + ctx->set_cursor_pos(ctx, 0, y); +ffffffff800040c1: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800040c6: 31 f6 xor %esi,%esi +ffffffff800040c8: 48 89 df mov %rbx,%rdi +ffffffff800040cb: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff800040d1: e9 82 f3 ff ff jmp ffffffff80003458 + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff800040d6: 48 83 fa 0f cmp $0xf,%rdx +ffffffff800040da: 0f 87 31 06 00 00 ja ffffffff80004711 +ffffffff800040e0: 41 b8 01 00 00 00 mov $0x1,%r8d +ffffffff800040e6: e9 a9 fd ff ff jmp ffffffff80003e94 + esc_default = 0; break; +ffffffff800040eb: 45 31 c0 xor %r8d,%r8d + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff800040ee: 48 83 fa 0f cmp $0xf,%rdx +ffffffff800040f2: 0f 86 9c fd ff ff jbe ffffffff80003e94 + if (ctx->dec_private == true) { +ffffffff800040f8: 40 84 f6 test %sil,%sil +ffffffff800040fb: 0f 84 d1 fd ff ff je ffffffff80003ed2 + ctx->dec_private = false; +ffffffff80004101: c6 43 14 00 movb $0x0,0x14(%rbx) + switch (c) { +ffffffff80004105: 41 80 fc 6c cmp $0x6c,%r12b +ffffffff80004109: 0f 85 53 fe ff ff jne ffffffff80003f62 + switch (ctx->esc_values[0]) { +ffffffff8000410f: 83 7b 78 19 cmpl $0x19,0x78(%rbx) +ffffffff80004113: 0f 84 0a 06 00 00 je ffffffff80004723 + if (ctx->callback != NULL) { +ffffffff80004119: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff80004120: 48 85 c0 test %rax,%rax +ffffffff80004123: 0f 84 39 fe ff ff je ffffffff80003f62 + ctx->callback(ctx, FLANTERM_CB_DEC, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c); +ffffffff80004129: 48 8d 4b 78 lea 0x78(%rbx),%rcx +ffffffff8000412d: 4d 0f be c4 movsbq %r12b,%r8 +ffffffff80004131: be 0a 00 00 00 mov $0xa,%esi +ffffffff80004136: 48 89 df mov %rbx,%rdi +ffffffff80004139: ff d0 call *%rax +ffffffff8000413b: e9 22 fe ff ff jmp ffffffff80003f62 + case 0x2248: return 247; +ffffffff80004140: be f7 00 00 00 mov $0xf7,%esi +ffffffff80004145: e9 26 f5 ff ff jmp ffffffff80003670 + case 0x2302: return 127; +ffffffff8000414a: be 7f 00 00 00 mov $0x7f,%esi +ffffffff8000414f: e9 1c f5 ff ff jmp ffffffff80003670 + case 0x2229: return 239; +ffffffff80004154: be ef 00 00 00 mov $0xef,%esi +ffffffff80004159: e9 12 f5 ff ff jmp ffffffff80003670 + case 0x221a: return 251; +ffffffff8000415e: be fb 00 00 00 mov $0xfb,%esi +ffffffff80004163: e9 08 f5 ff ff jmp ffffffff80003670 + case 0x2219: return 249; +ffffffff80004168: be f9 00 00 00 mov $0xf9,%esi +ffffffff8000416d: e9 fe f4 ff ff jmp ffffffff80003670 + case 0x2265: return 242; +ffffffff80004172: be f2 00 00 00 mov $0xf2,%esi +ffffffff80004177: e9 f4 f4 ff ff jmp ffffffff80003670 + case 0x2264: return 243; +ffffffff8000417c: be f3 00 00 00 mov $0xf3,%esi +ffffffff80004181: e9 ea f4 ff ff jmp ffffffff80003670 + case 0x2022: return 7; +ffffffff80004186: be 07 00 00 00 mov $0x7,%esi +ffffffff8000418b: e9 e0 f4 ff ff jmp ffffffff80003670 + case 0x20a7: return 158; +ffffffff80004190: be 9e 00 00 00 mov $0x9e,%esi + switch (code_point) { +ffffffff80004195: 49 81 fc a7 20 00 00 cmp $0x20a7,%r12 +ffffffff8000419c: 0f 84 ce f4 ff ff je ffffffff80003670 +ffffffff800041a2: e9 19 f2 ff ff jmp ffffffff800033c0 +ffffffff800041a7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff800041ae: 00 00 + case 0x207f: return 252; +ffffffff800041b0: be fc 00 00 00 mov $0xfc,%esi +ffffffff800041b5: e9 b6 f4 ff ff jmp ffffffff80003670 + ctx->dec_private = false; +ffffffff800041ba: c6 43 14 00 movb $0x0,0x14(%rbx) + if (ctx->esc_values_i == 0) { +ffffffff800041be: 48 85 d2 test %rdx,%rdx +ffffffff800041c1: 0f 84 9b fd ff ff je ffffffff80003f62 + switch (c) { +ffffffff800041c7: 41 80 fc 68 cmp $0x68,%r12b +ffffffff800041cb: 0f 85 34 ff ff ff jne ffffffff80004105 + switch (ctx->esc_values[0]) { +ffffffff800041d1: 83 7b 78 19 cmpl $0x19,0x78(%rbx) +ffffffff800041d5: 0f 85 3e ff ff ff jne ffffffff80004119 + ctx->cursor_enabled = true; +ffffffff800041db: c6 43 09 01 movb $0x1,0x9(%rbx) +ffffffff800041df: e9 7e fd ff ff jmp ffffffff80003f62 +ffffffff800041e4: 0f 1f 40 00 nopl 0x0(%rax) + case 0x2321: return 245; +ffffffff800041e8: be f5 00 00 00 mov $0xf5,%esi +ffffffff800041ed: e9 7e f4 ff ff jmp ffffffff80003670 + case 0x2320: return 244; +ffffffff800041f2: be f4 00 00 00 mov $0xf4,%esi +ffffffff800041f7: e9 74 f4 ff ff jmp ffffffff80003670 + for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++) +ffffffff800041fc: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff800041ff: 4c 8b 64 24 10 mov 0x10(%rsp),%r12 +ffffffff80004204: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff8000420b: 49 01 d4 add %rdx,%r12 +ffffffff8000420e: 49 39 c4 cmp %rax,%r12 +ffffffff80004211: 73 2d jae ffffffff80004240 + ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y); +ffffffff80004213: 4c 8b 44 24 18 mov 0x18(%rsp),%r8 +ffffffff80004218: 4c 89 e6 mov %r12,%rsi +ffffffff8000421b: 4c 89 e1 mov %r12,%rcx +ffffffff8000421e: 48 89 df mov %rbx,%rdi +ffffffff80004221: 48 29 d6 sub %rdx,%rsi + for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++) +ffffffff80004224: 49 83 c4 01 add $0x1,%r12 + ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y); +ffffffff80004228: 4c 89 c2 mov %r8,%rdx +ffffffff8000422b: ff 93 60 01 00 00 call *0x160(%rbx) + for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++) +ffffffff80004231: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff80004238: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff8000423b: 49 39 c4 cmp %rax,%r12 +ffffffff8000423e: 72 d3 jb ffffffff80004213 + ctx->set_cursor_pos(ctx, ctx->cols - ctx->esc_values[0], y); +ffffffff80004240: 48 29 d0 sub %rdx,%rax +ffffffff80004243: 48 89 df mov %rbx,%rdi +ffffffff80004246: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000424b: 48 89 c6 mov %rax,%rsi +ffffffff8000424e: ff 93 00 01 00 00 call *0x100(%rbx) + size_t count = ctx->esc_values[0] > ctx->cols ? ctx->cols : ctx->esc_values[0]; +ffffffff80004254: 44 8b 63 78 mov 0x78(%rbx),%r12d +ffffffff80004258: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff8000425f: 49 39 c4 cmp %rax,%r12 +ffffffff80004262: 4c 0f 47 e0 cmova %rax,%r12 + for (size_t i = 0; i < count; i++) +ffffffff80004266: 45 31 ff xor %r15d,%r15d +ffffffff80004269: 4d 85 e4 test %r12,%r12 +ffffffff8000426c: 74 17 je ffffffff80004285 +ffffffff8000426e: 49 83 c7 01 add $0x1,%r15 + ctx->raw_putchar(ctx, ' '); +ffffffff80004272: be 20 00 00 00 mov $0x20,%esi +ffffffff80004277: 48 89 df mov %rbx,%rdi +ffffffff8000427a: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < count; i++) +ffffffff80004280: 4d 39 fc cmp %r15,%r12 +ffffffff80004283: 75 e9 jne ffffffff8000426e + ctx->set_cursor_pos(ctx, x, y); +ffffffff80004285: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000428a: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff8000428f: 48 89 df mov %rbx,%rdi +ffffffff80004292: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004298: e9 c1 fc ff ff jmp ffffffff80003f5e + x = 0; +ffffffff8000429d: 45 31 c0 xor %r8d,%r8d +ffffffff800042a0: 4c 89 44 24 10 mov %r8,0x10(%rsp) + if (ctx->esc_values[0] > y) +ffffffff800042a5: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx +ffffffff800042aa: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff800042ad: 48 39 d1 cmp %rdx,%rcx +ffffffff800042b0: 73 05 jae ffffffff800042b7 + ctx->esc_values[0] = y; +ffffffff800042b2: 89 4b 78 mov %ecx,0x78(%rbx) +ffffffff800042b5: 89 ca mov %ecx,%edx + size_t dest_y = y - ctx->esc_values[0]; +ffffffff800042b7: 48 89 c8 mov %rcx,%rax +ffffffff800042ba: 48 29 d0 sub %rdx,%rax + if ((ctx->scroll_top_margin >= dest_y && ctx->scroll_top_margin <= orig_y) +ffffffff800042bd: 48 8b 53 68 mov 0x68(%rbx),%rdx +ffffffff800042c1: 48 39 c2 cmp %rax,%rdx +ffffffff800042c4: 72 09 jb ffffffff800042cf +ffffffff800042c6: 48 39 d1 cmp %rdx,%rcx +ffffffff800042c9: 0f 83 2c 04 00 00 jae ffffffff800046fb + || (ctx->scroll_bottom_margin >= dest_y && ctx->scroll_bottom_margin <= orig_y)) { +ffffffff800042cf: 48 8b 73 70 mov 0x70(%rbx),%rsi +ffffffff800042d3: 48 39 c6 cmp %rax,%rsi +ffffffff800042d6: 72 09 jb ffffffff800042e1 +ffffffff800042d8: 48 39 f1 cmp %rsi,%rcx +ffffffff800042db: 0f 83 1a 04 00 00 jae ffffffff800046fb + ctx->set_cursor_pos(ctx, x, dest_y); +ffffffff800042e1: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff800042e6: 48 89 c2 mov %rax,%rdx +ffffffff800042e9: 48 89 df mov %rbx,%rdi +ffffffff800042ec: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff800042f2: e9 67 fc ff ff jmp ffffffff80003f5e + case 0x221f: return 28; +ffffffff800042f7: be 1c 00 00 00 mov $0x1c,%esi +ffffffff800042fc: e9 6f f3 ff ff jmp ffffffff80003670 + case '~': FLANTERM_DEC_SPCL_PRN(0xfa) +ffffffff80004301: be fa 00 00 00 mov $0xfa,%esi +ffffffff80004306: 48 89 df mov %rbx,%rdi +ffffffff80004309: ff d0 call *%rax +ffffffff8000430b: e9 87 ed ff ff jmp ffffffff80003097 + case '}': FLANTERM_DEC_SPCL_PRN(0x9c) +ffffffff80004310: be 9c 00 00 00 mov $0x9c,%esi +ffffffff80004315: 48 89 df mov %rbx,%rdi +ffffffff80004318: ff d0 call *%rax +ffffffff8000431a: e9 78 ed ff ff jmp ffffffff80003097 + case '{': FLANTERM_DEC_SPCL_PRN(0xe3) +ffffffff8000431f: be e3 00 00 00 mov $0xe3,%esi +ffffffff80004324: 48 89 df mov %rbx,%rdi +ffffffff80004327: ff d0 call *%rax +ffffffff80004329: e9 69 ed ff ff jmp ffffffff80003097 + case 'z': FLANTERM_DEC_SPCL_PRN(0xf2) +ffffffff8000432e: be f2 00 00 00 mov $0xf2,%esi +ffffffff80004333: 48 89 df mov %rbx,%rdi +ffffffff80004336: ff d0 call *%rax +ffffffff80004338: e9 5a ed ff ff jmp ffffffff80003097 + case 'y': FLANTERM_DEC_SPCL_PRN(0xf3) +ffffffff8000433d: be f3 00 00 00 mov $0xf3,%esi +ffffffff80004342: 48 89 df mov %rbx,%rdi +ffffffff80004345: ff d0 call *%rax +ffffffff80004347: e9 4b ed ff ff jmp ffffffff80003097 + case 'x': FLANTERM_DEC_SPCL_PRN(0xb3) +ffffffff8000434c: be b3 00 00 00 mov $0xb3,%esi +ffffffff80004351: 48 89 df mov %rbx,%rdi +ffffffff80004354: ff d0 call *%rax +ffffffff80004356: e9 3c ed ff ff jmp ffffffff80003097 + case 'w': FLANTERM_DEC_SPCL_PRN(0xc2) +ffffffff8000435b: be c2 00 00 00 mov $0xc2,%esi +ffffffff80004360: 48 89 df mov %rbx,%rdi +ffffffff80004363: ff d0 call *%rax +ffffffff80004365: e9 2d ed ff ff jmp ffffffff80003097 + case 'v': FLANTERM_DEC_SPCL_PRN(0xc1) +ffffffff8000436a: be c1 00 00 00 mov $0xc1,%esi +ffffffff8000436f: 48 89 df mov %rbx,%rdi +ffffffff80004372: ff d0 call *%rax +ffffffff80004374: e9 1e ed ff ff jmp ffffffff80003097 + case 'u': FLANTERM_DEC_SPCL_PRN(0xb4) +ffffffff80004379: be b4 00 00 00 mov $0xb4,%esi +ffffffff8000437e: 48 89 df mov %rbx,%rdi +ffffffff80004381: ff d0 call *%rax +ffffffff80004383: e9 0f ed ff ff jmp ffffffff80003097 + case 't': FLANTERM_DEC_SPCL_PRN(0xc3) +ffffffff80004388: be c3 00 00 00 mov $0xc3,%esi +ffffffff8000438d: 48 89 df mov %rbx,%rdi +ffffffff80004390: ff d0 call *%rax +ffffffff80004392: e9 00 ed ff ff jmp ffffffff80003097 + case 's': FLANTERM_DEC_SPCL_PRN(0x5f) +ffffffff80004397: be 5f 00 00 00 mov $0x5f,%esi +ffffffff8000439c: 48 89 df mov %rbx,%rdi +ffffffff8000439f: ff d0 call *%rax +ffffffff800043a1: e9 f1 ec ff ff jmp ffffffff80003097 + case 'q': FLANTERM_DEC_SPCL_PRN(0xc4) +ffffffff800043a6: be c4 00 00 00 mov $0xc4,%esi +ffffffff800043ab: 48 89 df mov %rbx,%rdi +ffffffff800043ae: ff d0 call *%rax +ffffffff800043b0: e9 e2 ec ff ff jmp ffffffff80003097 + case 'n': FLANTERM_DEC_SPCL_PRN(0xc5) +ffffffff800043b5: be c5 00 00 00 mov $0xc5,%esi +ffffffff800043ba: 48 89 df mov %rbx,%rdi +ffffffff800043bd: ff d0 call *%rax +ffffffff800043bf: e9 d3 ec ff ff jmp ffffffff80003097 + case 'm': FLANTERM_DEC_SPCL_PRN(0xc0) +ffffffff800043c4: be c0 00 00 00 mov $0xc0,%esi +ffffffff800043c9: 48 89 df mov %rbx,%rdi +ffffffff800043cc: ff d0 call *%rax +ffffffff800043ce: e9 c4 ec ff ff jmp ffffffff80003097 + case 'l': FLANTERM_DEC_SPCL_PRN(0xda) +ffffffff800043d3: be da 00 00 00 mov $0xda,%esi +ffffffff800043d8: 48 89 df mov %rbx,%rdi +ffffffff800043db: ff d0 call *%rax +ffffffff800043dd: e9 b5 ec ff ff jmp ffffffff80003097 + case 'k': FLANTERM_DEC_SPCL_PRN(0xbf) +ffffffff800043e2: be bf 00 00 00 mov $0xbf,%esi +ffffffff800043e7: 48 89 df mov %rbx,%rdi +ffffffff800043ea: ff d0 call *%rax +ffffffff800043ec: e9 a6 ec ff ff jmp ffffffff80003097 + case 'j': FLANTERM_DEC_SPCL_PRN(0xd9) +ffffffff800043f1: be d9 00 00 00 mov $0xd9,%esi +ffffffff800043f6: 48 89 df mov %rbx,%rdi +ffffffff800043f9: ff d0 call *%rax +ffffffff800043fb: e9 97 ec ff ff jmp ffffffff80003097 + case 'h': FLANTERM_DEC_SPCL_PRN(0xb0) +ffffffff80004400: be b0 00 00 00 mov $0xb0,%esi +ffffffff80004405: 48 89 df mov %rbx,%rdi +ffffffff80004408: ff d0 call *%rax +ffffffff8000440a: e9 88 ec ff ff jmp ffffffff80003097 + case 'g': FLANTERM_DEC_SPCL_PRN(0xf1) +ffffffff8000440f: be f1 00 00 00 mov $0xf1,%esi +ffffffff80004414: 48 89 df mov %rbx,%rdi +ffffffff80004417: ff d0 call *%rax +ffffffff80004419: e9 79 ec ff ff jmp ffffffff80003097 + case 'f': FLANTERM_DEC_SPCL_PRN(0xf8) +ffffffff8000441e: be f8 00 00 00 mov $0xf8,%esi +ffffffff80004423: 48 89 df mov %rbx,%rdi +ffffffff80004426: ff d0 call *%rax +ffffffff80004428: e9 6a ec ff ff jmp ffffffff80003097 + case 'a': FLANTERM_DEC_SPCL_PRN(0xb1) +ffffffff8000442d: be b1 00 00 00 mov $0xb1,%esi +ffffffff80004432: 48 89 df mov %rbx,%rdi +ffffffff80004435: ff d0 call *%rax +ffffffff80004437: e9 5b ec ff ff jmp ffffffff80003097 + case '`': FLANTERM_DEC_SPCL_PRN(0x04) +ffffffff8000443c: be 04 00 00 00 mov $0x4,%esi +ffffffff80004441: 48 89 df mov %rbx,%rdi +ffffffff80004444: ff d0 call *%rax +ffffffff80004446: e9 4c ec ff ff jmp ffffffff80003097 + case '_': FLANTERM_DEC_SPCL_PRN(0xff) +ffffffff8000444b: be ff 00 00 00 mov $0xff,%esi +ffffffff80004450: 48 89 df mov %rbx,%rdi +ffffffff80004453: ff d0 call *%rax +ffffffff80004455: e9 3d ec ff ff jmp ffffffff80003097 + case '0': FLANTERM_DEC_SPCL_PRN(0xdb) +ffffffff8000445a: be db 00 00 00 mov $0xdb,%esi +ffffffff8000445f: 48 89 df mov %rbx,%rdi +ffffffff80004462: ff d0 call *%rax +ffffffff80004464: e9 2e ec ff ff jmp ffffffff80003097 + case '.': FLANTERM_DEC_SPCL_PRN(0x19) +ffffffff80004469: be 19 00 00 00 mov $0x19,%esi +ffffffff8000446e: 48 89 df mov %rbx,%rdi +ffffffff80004471: ff d0 call *%rax +ffffffff80004473: e9 1f ec ff ff jmp ffffffff80003097 + case '-': FLANTERM_DEC_SPCL_PRN(0x18) +ffffffff80004478: be 18 00 00 00 mov $0x18,%esi +ffffffff8000447d: 48 89 df mov %rbx,%rdi +ffffffff80004480: ff d0 call *%rax +ffffffff80004482: e9 10 ec ff ff jmp ffffffff80003097 + case ',': FLANTERM_DEC_SPCL_PRN(0x1b) +ffffffff80004487: be 1b 00 00 00 mov $0x1b,%esi +ffffffff8000448c: 48 89 df mov %rbx,%rdi +ffffffff8000448f: ff d0 call *%rax +ffffffff80004491: e9 01 ec ff ff jmp ffffffff80003097 + case '+': FLANTERM_DEC_SPCL_PRN(0x1a) +ffffffff80004496: be 1a 00 00 00 mov $0x1a,%esi +ffffffff8000449b: 48 89 df mov %rbx,%rdi +ffffffff8000449e: ff d0 call *%rax +ffffffff800044a0: e9 f2 eb ff ff jmp ffffffff80003097 + size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0]; +ffffffff800044a5: 44 8b 63 78 mov 0x78(%rbx),%r12d +ffffffff800044a9: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff800044b0: 49 39 c4 cmp %rax,%r12 +ffffffff800044b3: 4c 0f 47 e0 cmova %rax,%r12 + for (size_t i = 0; i < count; i++) { +ffffffff800044b7: 4d 85 e4 test %r12,%r12 +ffffffff800044ba: 0f 84 9e fa ff ff je ffffffff80003f5e +ffffffff800044c0: 45 31 ff xor %r15d,%r15d +ffffffff800044c3: 49 83 c7 01 add $0x1,%r15 + ctx->scroll(ctx); +ffffffff800044c7: 48 89 df mov %rbx,%rdi +ffffffff800044ca: ff 93 68 01 00 00 call *0x168(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff800044d0: 4d 39 fc cmp %r15,%r12 +ffffffff800044d3: 75 ee jne ffffffff800044c3 +ffffffff800044d5: e9 84 fa ff ff jmp ffffffff80003f5e + ctx->scroll_top_margin = y; +ffffffff800044da: 48 8b 44 24 18 mov 0x18(%rsp),%rax + size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0]; +ffffffff800044df: 44 8b 63 78 mov 0x78(%rbx),%r12d + size_t old_scroll_top_margin = ctx->scroll_top_margin; +ffffffff800044e3: 48 8b 53 68 mov 0x68(%rbx),%rdx + ctx->scroll_top_margin = y; +ffffffff800044e7: 48 89 43 68 mov %rax,0x68(%rbx) + size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0]; +ffffffff800044eb: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff800044f2: 49 39 c4 cmp %rax,%r12 +ffffffff800044f5: 4c 0f 47 e0 cmova %rax,%r12 + for (size_t i = 0; i < count; i++) { +ffffffff800044f9: 45 31 ff xor %r15d,%r15d +ffffffff800044fc: 4d 85 e4 test %r12,%r12 +ffffffff800044ff: 74 1c je ffffffff8000451d +ffffffff80004501: 49 83 c7 01 add $0x1,%r15 +ffffffff80004505: 48 89 54 24 08 mov %rdx,0x8(%rsp) + ctx->revscroll(ctx); +ffffffff8000450a: 48 89 df mov %rbx,%rdi +ffffffff8000450d: ff 93 70 01 00 00 call *0x170(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff80004513: 4d 39 fc cmp %r15,%r12 +ffffffff80004516: 48 8b 54 24 08 mov 0x8(%rsp),%rdx +ffffffff8000451b: 75 e4 jne ffffffff80004501 + ctx->scroll_top_margin = old_scroll_top_margin; +ffffffff8000451d: 48 89 53 68 mov %rdx,0x68(%rbx) + break; +ffffffff80004521: e9 38 fa ff ff jmp ffffffff80003f5e + switch (ctx->esc_values[0]) { +ffffffff80004526: 8b 43 78 mov 0x78(%rbx),%eax +ffffffff80004529: 83 f8 01 cmp $0x1,%eax +ffffffff8000452c: 74 69 je ffffffff80004597 +ffffffff8000452e: 83 f8 02 cmp $0x2,%eax +ffffffff80004531: 74 2f je ffffffff80004562 +ffffffff80004533: 85 c0 test %eax,%eax +ffffffff80004535: 0f 85 23 fa ff ff jne ffffffff80003f5e + for (size_t i = x; i < ctx->cols; i++) +ffffffff8000453b: 4c 8b 64 24 10 mov 0x10(%rsp),%r12 +ffffffff80004540: eb 12 jmp ffffffff80004554 + ctx->raw_putchar(ctx, ' '); +ffffffff80004542: be 20 00 00 00 mov $0x20,%esi +ffffffff80004547: 48 89 df mov %rbx,%rdi + for (size_t i = x; i < ctx->cols; i++) +ffffffff8000454a: 49 83 c4 01 add $0x1,%r12 + ctx->raw_putchar(ctx, ' '); +ffffffff8000454e: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = x; i < ctx->cols; i++) +ffffffff80004554: 4c 3b a3 e8 00 00 00 cmp 0xe8(%rbx),%r12 +ffffffff8000455b: 72 e5 jb ffffffff80004542 +ffffffff8000455d: e9 23 fd ff ff jmp ffffffff80004285 + ctx->set_cursor_pos(ctx, 0, y); +ffffffff80004562: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff80004567: 31 f6 xor %esi,%esi +ffffffff80004569: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < ctx->cols; i++) +ffffffff8000456c: 45 31 e4 xor %r12d,%r12d + ctx->set_cursor_pos(ctx, 0, y); +ffffffff8000456f: ff 93 00 01 00 00 call *0x100(%rbx) + for (size_t i = 0; i < ctx->cols; i++) +ffffffff80004575: eb 12 jmp ffffffff80004589 + ctx->raw_putchar(ctx, ' '); +ffffffff80004577: be 20 00 00 00 mov $0x20,%esi +ffffffff8000457c: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < ctx->cols; i++) +ffffffff8000457f: 49 83 c4 01 add $0x1,%r12 + ctx->raw_putchar(ctx, ' '); +ffffffff80004583: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < ctx->cols; i++) +ffffffff80004589: 4c 3b a3 e8 00 00 00 cmp 0xe8(%rbx),%r12 +ffffffff80004590: 72 e5 jb ffffffff80004577 +ffffffff80004592: e9 ee fc ff ff jmp ffffffff80004285 + ctx->set_cursor_pos(ctx, 0, y); +ffffffff80004597: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000459c: 31 f6 xor %esi,%esi +ffffffff8000459e: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < x; i++) +ffffffff800045a1: 45 31 e4 xor %r12d,%r12d + ctx->set_cursor_pos(ctx, 0, y); +ffffffff800045a4: ff 93 00 01 00 00 call *0x100(%rbx) + for (size_t i = 0; i < x; i++) +ffffffff800045aa: eb 12 jmp ffffffff800045be + ctx->raw_putchar(ctx, ' '); +ffffffff800045ac: be 20 00 00 00 mov $0x20,%esi +ffffffff800045b1: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < x; i++) +ffffffff800045b4: 49 83 c4 01 add $0x1,%r12 + ctx->raw_putchar(ctx, ' '); +ffffffff800045b8: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < x; i++) +ffffffff800045be: 4c 3b 64 24 10 cmp 0x10(%rsp),%r12 +ffffffff800045c3: 72 e7 jb ffffffff800045ac +ffffffff800045c5: e9 94 f9 ff ff jmp ffffffff80003f5e + switch (ctx->esc_values[0]) { +ffffffff800045ca: 8b 43 78 mov 0x78(%rbx),%eax +ffffffff800045cd: 83 f8 01 cmp $0x1,%eax +ffffffff800045d0: 0f 84 b3 00 00 00 je ffffffff80004689 +ffffffff800045d6: 0f 87 91 00 00 00 ja ffffffff8000466d + size_t cols_diff = ctx->cols - (x + 1); +ffffffff800045dc: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax + size_t rows_remaining = ctx->rows - (y + 1); +ffffffff800045e3: 4c 8b a3 e0 00 00 00 mov 0xe0(%rbx),%r12 + for (size_t i = 0; i < to_clear; i++) { +ffffffff800045ea: 45 31 ff xor %r15d,%r15d + size_t rows_remaining = ctx->rows - (y + 1); +ffffffff800045ed: 4c 2b 64 24 18 sub 0x18(%rsp),%r12 +ffffffff800045f2: 49 83 ec 01 sub $0x1,%r12 + size_t to_clear = rows_remaining * ctx->cols + cols_diff + 1; +ffffffff800045f6: 4c 0f af e0 imul %rax,%r12 +ffffffff800045fa: 48 2b 44 24 10 sub 0x10(%rsp),%rax +ffffffff800045ff: 49 01 c4 add %rax,%r12 + for (size_t i = 0; i < to_clear; i++) { +ffffffff80004602: eb 12 jmp ffffffff80004616 + ctx->raw_putchar(ctx, ' '); +ffffffff80004604: be 20 00 00 00 mov $0x20,%esi +ffffffff80004609: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < to_clear; i++) { +ffffffff8000460c: 49 83 c7 01 add $0x1,%r15 + ctx->raw_putchar(ctx, ' '); +ffffffff80004610: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < to_clear; i++) { +ffffffff80004616: 4d 39 fc cmp %r15,%r12 +ffffffff80004619: 75 e9 jne ffffffff80004604 +ffffffff8000461b: e9 65 fc ff ff jmp ffffffff80004285 + if (ctx->esc_values[0] != 0) { +ffffffff80004620: 8b 43 78 mov 0x78(%rbx),%eax +ffffffff80004623: 85 c0 test %eax,%eax +ffffffff80004625: 74 06 je ffffffff8000462d + ctx->esc_values[0]--; +ffffffff80004627: 83 e8 01 sub $0x1,%eax +ffffffff8000462a: 89 43 78 mov %eax,0x78(%rbx) + if (ctx->esc_values[1] != 0) { +ffffffff8000462d: 8b 43 7c mov 0x7c(%rbx),%eax +ffffffff80004630: 85 c0 test %eax,%eax +ffffffff80004632: 74 06 je ffffffff8000463a + ctx->esc_values[1]--; +ffffffff80004634: 83 e8 01 sub $0x1,%eax +ffffffff80004637: 89 43 7c mov %eax,0x7c(%rbx) + if (ctx->esc_values[1] >= ctx->cols) +ffffffff8000463a: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff80004641: 8b 73 7c mov 0x7c(%rbx),%esi +ffffffff80004644: 48 39 c6 cmp %rax,%rsi +ffffffff80004647: 72 06 jb ffffffff8000464f + ctx->esc_values[1] = ctx->cols - 1; +ffffffff80004649: 8d 70 ff lea -0x1(%rax),%esi +ffffffff8000464c: 89 73 7c mov %esi,0x7c(%rbx) + if (ctx->esc_values[0] >= ctx->rows) +ffffffff8000464f: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff80004656: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80004659: 48 39 c2 cmp %rax,%rdx +ffffffff8000465c: 0f 82 f3 f8 ff ff jb ffffffff80003f55 + ctx->esc_values[0] = ctx->rows - 1; +ffffffff80004662: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80004665: 89 53 78 mov %edx,0x78(%rbx) + ctx->set_cursor_pos(ctx, ctx->esc_values[1], ctx->esc_values[0]); +ffffffff80004668: e9 e8 f8 ff ff jmp ffffffff80003f55 + switch (ctx->esc_values[0]) { +ffffffff8000466d: 83 e8 02 sub $0x2,%eax +ffffffff80004670: 83 f8 01 cmp $0x1,%eax +ffffffff80004673: 0f 87 e5 f8 ff ff ja ffffffff80003f5e + ctx->clear(ctx, false); +ffffffff80004679: 31 f6 xor %esi,%esi +ffffffff8000467b: 48 89 df mov %rbx,%rdi +ffffffff8000467e: ff 93 f8 00 00 00 call *0xf8(%rbx) + break; +ffffffff80004684: e9 d5 f8 ff ff jmp ffffffff80003f5e + ctx->set_cursor_pos(ctx, 0, 0); +ffffffff80004689: 31 d2 xor %edx,%edx +ffffffff8000468b: 31 f6 xor %esi,%esi +ffffffff8000468d: 48 89 df mov %rbx,%rdi + for (size_t yc = 0; yc < ctx->rows; yc++) { +ffffffff80004690: 45 31 ff xor %r15d,%r15d + ctx->set_cursor_pos(ctx, 0, 0); +ffffffff80004693: ff 93 00 01 00 00 call *0x100(%rbx) + for (size_t yc = 0; yc < ctx->rows; yc++) { +ffffffff80004699: 4c 3b bb e0 00 00 00 cmp 0xe0(%rbx),%r15 +ffffffff800046a0: 0f 83 b8 f8 ff ff jae ffffffff80003f5e + for (size_t xc = 0; xc < ctx->cols; xc++) { +ffffffff800046a6: 45 31 e4 xor %r12d,%r12d +ffffffff800046a9: 48 83 bb e8 00 00 00 cmpq $0x0,0xe8(%rbx) +ffffffff800046b0: 00 +ffffffff800046b1: 75 12 jne ffffffff800046c5 +ffffffff800046b3: eb 40 jmp ffffffff800046f5 +ffffffff800046b5: 0f 1f 00 nopl (%rax) +ffffffff800046b8: 49 83 c4 01 add $0x1,%r12 +ffffffff800046bc: 4c 3b a3 e8 00 00 00 cmp 0xe8(%rbx),%r12 +ffffffff800046c3: 73 30 jae ffffffff800046f5 + ctx->raw_putchar(ctx, ' '); +ffffffff800046c5: be 20 00 00 00 mov $0x20,%esi +ffffffff800046ca: 48 89 df mov %rbx,%rdi +ffffffff800046cd: ff 93 f0 00 00 00 call *0xf0(%rbx) + if (xc == x && yc == y) { +ffffffff800046d3: 4c 39 64 24 10 cmp %r12,0x10(%rsp) +ffffffff800046d8: 75 de jne ffffffff800046b8 +ffffffff800046da: 4c 39 7c 24 18 cmp %r15,0x18(%rsp) +ffffffff800046df: 75 d7 jne ffffffff800046b8 + ctx->set_cursor_pos(ctx, x, y); +ffffffff800046e1: 4c 89 fa mov %r15,%rdx +ffffffff800046e4: 4c 89 e6 mov %r12,%rsi +ffffffff800046e7: 48 89 df mov %rbx,%rdi +ffffffff800046ea: ff 93 00 01 00 00 call *0x100(%rbx) + if (b == true) +ffffffff800046f0: e9 69 f8 ff ff jmp ffffffff80003f5e + for (size_t yc = 0; yc < ctx->rows; yc++) { +ffffffff800046f5: 49 83 c7 01 add $0x1,%r15 +ffffffff800046f9: eb 9e jmp ffffffff80004699 + if (will_be_in_scroll_region && dest_y < ctx->scroll_top_margin) { +ffffffff800046fb: 48 39 d0 cmp %rdx,%rax +ffffffff800046fe: 48 0f 42 c2 cmovb %rdx,%rax +ffffffff80004702: e9 da fb ff ff jmp ffffffff800042e1 + case 0x221e: return 236; +ffffffff80004707: be ec 00 00 00 mov $0xec,%esi +ffffffff8000470c: e9 5f ef ff ff jmp ffffffff80003670 + if (ctx->dec_private == true) { +ffffffff80004711: 40 84 f6 test %sil,%sil +ffffffff80004714: 0f 84 b8 f7 ff ff je ffffffff80003ed2 + ctx->dec_private = false; +ffffffff8000471a: c6 43 14 00 movb $0x0,0x14(%rbx) + if (ctx->esc_values_i == 0) { +ffffffff8000471e: e9 a4 fa ff ff jmp ffffffff800041c7 + ctx->cursor_enabled = false; +ffffffff80004723: c6 43 09 00 movb $0x0,0x9(%rbx) +ffffffff80004727: e9 36 f8 ff ff jmp ffffffff80003f62 + dest_y = ctx->scroll_bottom_margin - 1; +ffffffff8000472c: 48 8d 50 ff lea -0x1(%rax),%rdx + ctx->set_cursor_pos(ctx, x, dest_y); +ffffffff80004730: e9 1b f8 ff ff jmp ffffffff80003f50 + for (size_t i = ctx->cols - 1; ; i--) { +ffffffff80004735: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff8000473c: 4c 8d 60 ff lea -0x1(%rax),%r12 +ffffffff80004740: eb 04 jmp ffffffff80004746 +ffffffff80004742: 49 83 ec 01 sub $0x1,%r12 + ctx->move_character(ctx, i + ctx->esc_values[0], y, i, y); +ffffffff80004746: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000474b: 8b 73 78 mov 0x78(%rbx),%esi +ffffffff8000474e: 4c 89 e1 mov %r12,%rcx +ffffffff80004751: 48 89 df mov %rbx,%rdi +ffffffff80004754: 4c 01 e6 add %r12,%rsi +ffffffff80004757: 49 89 d0 mov %rdx,%r8 +ffffffff8000475a: ff 93 60 01 00 00 call *0x160(%rbx) + ctx->set_cursor_pos(ctx, i, y); +ffffffff80004760: 4c 89 e6 mov %r12,%rsi +ffffffff80004763: 48 89 df mov %rbx,%rdi +ffffffff80004766: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000476b: ff 93 00 01 00 00 call *0x100(%rbx) + ctx->raw_putchar(ctx, ' '); +ffffffff80004771: be 20 00 00 00 mov $0x20,%esi +ffffffff80004776: 48 89 df mov %rbx,%rdi +ffffffff80004779: ff 93 f0 00 00 00 call *0xf0(%rbx) + if (i == x) { +ffffffff8000477f: 4c 3b 64 24 10 cmp 0x10(%rsp),%r12 +ffffffff80004784: 75 bc jne ffffffff80004742 + ctx->set_cursor_pos(ctx, x, y); +ffffffff80004786: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000478b: 4c 89 e6 mov %r12,%rsi +ffffffff8000478e: 48 89 df mov %rbx,%rdi +ffffffff80004791: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004797: e9 c2 f7 ff ff jmp ffffffff80003f5e + if (ctx->esc_values_i == 0) { +ffffffff8000479c: 48 8b 53 40 mov 0x40(%rbx),%rdx +ffffffff800047a0: 48 85 d2 test %rdx,%rdx +ffffffff800047a3: 0f 84 b5 f7 ff ff je ffffffff80003f5e + if (ctx->callback != NULL) { +ffffffff800047a9: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff800047b0: 48 85 c0 test %rax,%rax +ffffffff800047b3: 0f 84 a5 f7 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_LINUX, ctx->esc_values_i, (uintptr_t)ctx->esc_values, 0); +ffffffff800047b9: 48 8d 4b 78 lea 0x78(%rbx),%rcx +ffffffff800047bd: 45 31 c0 xor %r8d,%r8d +ffffffff800047c0: be 50 00 00 00 mov $0x50,%esi +ffffffff800047c5: 48 89 df mov %rbx,%rdi +ffffffff800047c8: ff d0 call *%rax +ffffffff800047ca: e9 8f f7 ff ff jmp ffffffff80003f5e + if (x + ctx->esc_values[0] > ctx->cols - 1) +ffffffff800047cf: 48 8b 4c 24 10 mov 0x10(%rsp),%rcx +ffffffff800047d4: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff800047db: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff800047de: 48 8d 78 ff lea -0x1(%rax),%rdi +ffffffff800047e2: 48 8d 34 0a lea (%rdx,%rcx,1),%rsi +ffffffff800047e6: 48 39 f7 cmp %rsi,%rdi +ffffffff800047e9: 73 08 jae ffffffff800047f3 + ctx->esc_values[0] = (ctx->cols - 1) - x; +ffffffff800047eb: 29 c8 sub %ecx,%eax +ffffffff800047ed: 8d 50 ff lea -0x1(%rax),%edx +ffffffff800047f0: 89 53 78 mov %edx,0x78(%rbx) + ctx->set_cursor_pos(ctx, x + ctx->esc_values[0], y); +ffffffff800047f3: 48 8d 34 0a lea (%rdx,%rcx,1),%rsi +ffffffff800047f7: 48 89 df mov %rbx,%rdi +ffffffff800047fa: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800047ff: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004805: e9 54 f7 ff ff jmp ffffffff80003f5e + ctx->esc_values[0] -= 1; +ffffffff8000480a: 8b 43 78 mov 0x78(%rbx),%eax + if (ctx->esc_values[0] >= ctx->cols) +ffffffff8000480d: 48 8b 93 e8 00 00 00 mov 0xe8(%rbx),%rdx + ctx->esc_values[0] -= 1; +ffffffff80004814: 83 e8 01 sub $0x1,%eax +ffffffff80004817: 89 43 78 mov %eax,0x78(%rbx) + if (ctx->esc_values[0] >= ctx->cols) +ffffffff8000481a: 48 39 d0 cmp %rdx,%rax +ffffffff8000481d: 72 06 jb ffffffff80004825 + ctx->esc_values[0] = ctx->cols - 1; +ffffffff8000481f: 83 ea 01 sub $0x1,%edx +ffffffff80004822: 89 53 78 mov %edx,0x78(%rbx) + ctx->set_cursor_pos(ctx, ctx->esc_values[0], y); +ffffffff80004825: 8b 73 78 mov 0x78(%rbx),%esi +ffffffff80004828: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000482d: 48 89 df mov %rbx,%rdi +ffffffff80004830: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004836: e9 23 f7 ff ff jmp ffffffff80003f5e + if (ctx->esc_values[0] > x) +ffffffff8000483b: 48 8b 44 24 10 mov 0x10(%rsp),%rax +ffffffff80004840: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80004843: 48 39 d0 cmp %rdx,%rax +ffffffff80004846: 73 05 jae ffffffff8000484d + ctx->esc_values[0] = x; +ffffffff80004848: 89 43 78 mov %eax,0x78(%rbx) +ffffffff8000484b: 89 c2 mov %eax,%edx + ctx->set_cursor_pos(ctx, x - ctx->esc_values[0], y); +ffffffff8000484d: 48 29 d0 sub %rdx,%rax +ffffffff80004850: 48 89 df mov %rbx,%rdi +ffffffff80004853: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff80004858: 48 89 c6 mov %rax,%rsi +ffffffff8000485b: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004861: e9 f8 f6 ff ff jmp ffffffff80003f5e + if (ctx->dec_private == true) { +ffffffff80004866: 40 84 f6 test %sil,%sil +ffffffff80004869: 0f 84 63 f6 ff ff je ffffffff80003ed2 + ctx->dec_private = false; +ffffffff8000486f: c6 43 14 00 movb $0x0,0x14(%rbx) +ffffffff80004873: e9 ea f6 ff ff jmp ffffffff80003f62 + switch (ctx->esc_values[0]) { +ffffffff80004878: 8b 43 78 mov 0x78(%rbx),%eax +ffffffff8000487b: 83 f8 05 cmp $0x5,%eax +ffffffff8000487e: 74 53 je ffffffff800048d3 +ffffffff80004880: 83 f8 06 cmp $0x6,%eax +ffffffff80004883: 0f 85 d5 f6 ff ff jne ffffffff80003f5e + if (ctx->callback != NULL) { +ffffffff80004889: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff80004890: 48 85 c0 test %rax,%rax +ffffffff80004893: 0f 84 c5 f6 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_POS_REPORT, x + 1, y + 1, 0); +ffffffff80004899: 48 8b 7c 24 10 mov 0x10(%rsp),%rdi +ffffffff8000489e: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx +ffffffff800048a3: 45 31 c0 xor %r8d,%r8d +ffffffff800048a6: be 32 00 00 00 mov $0x32,%esi +ffffffff800048ab: 48 8d 57 01 lea 0x1(%rdi),%rdx +ffffffff800048af: 48 83 c1 01 add $0x1,%rcx +ffffffff800048b3: 48 89 df mov %rbx,%rdi +ffffffff800048b6: ff d0 call *%rax +ffffffff800048b8: e9 a1 f6 ff ff jmp ffffffff80003f5e + ctx->set_cursor_pos(ctx, ctx->saved_cursor_x, ctx->saved_cursor_y); +ffffffff800048bd: 48 8b 53 50 mov 0x50(%rbx),%rdx +ffffffff800048c1: 48 8b 73 48 mov 0x48(%rbx),%rsi +ffffffff800048c5: 48 89 df mov %rbx,%rdi +ffffffff800048c8: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff800048ce: e9 8b f6 ff ff jmp ffffffff80003f5e + if (ctx->callback != NULL) { +ffffffff800048d3: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff800048da: 48 85 c0 test %rax,%rax +ffffffff800048dd: 0f 84 7b f6 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_STATUS_REPORT, 0, 0, 0); +ffffffff800048e3: 45 31 c0 xor %r8d,%r8d +ffffffff800048e6: 31 c9 xor %ecx,%ecx +ffffffff800048e8: 31 d2 xor %edx,%edx +ffffffff800048ea: be 28 00 00 00 mov $0x28,%esi +ffffffff800048ef: 48 89 df mov %rbx,%rdi +ffffffff800048f2: ff d0 call *%rax +ffffffff800048f4: e9 65 f6 ff ff jmp ffffffff80003f5e + ctx->get_cursor_pos(ctx, &ctx->saved_cursor_x, &ctx->saved_cursor_y); +ffffffff800048f9: 48 8d 53 50 lea 0x50(%rbx),%rdx +ffffffff800048fd: 48 8d 73 48 lea 0x48(%rbx),%rsi +ffffffff80004901: 48 89 df mov %rbx,%rdi +ffffffff80004904: ff 93 08 01 00 00 call *0x108(%rbx) + break; +ffffffff8000490a: e9 4f f6 ff ff jmp ffffffff80003f5e + if (ctx->esc_values[0] == 0) { +ffffffff8000490f: 83 7b 78 00 cmpl $0x0,0x78(%rbx) +ffffffff80004913: 75 07 jne ffffffff8000491c + ctx->esc_values[0] = 1; +ffffffff80004915: c7 43 78 01 00 00 00 movl $0x1,0x78(%rbx) + if (ctx->esc_values[1] == 0) { +ffffffff8000491c: 83 7b 7c 00 cmpl $0x0,0x7c(%rbx) +ffffffff80004920: 75 07 jne ffffffff80004929 + ctx->esc_values[1] = 1; +ffffffff80004922: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%rbx) + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80004929: 48 8b 93 e0 00 00 00 mov 0xe0(%rbx),%rdx + if (ctx->esc_values_i > 0) { +ffffffff80004930: 48 8b 43 40 mov 0x40(%rbx),%rax + ctx->scroll_top_margin = 0; +ffffffff80004934: 31 f6 xor %esi,%esi +ffffffff80004936: 48 89 73 68 mov %rsi,0x68(%rbx) + ctx->scroll_bottom_margin = ctx->rows; +ffffffff8000493a: 48 89 53 70 mov %rdx,0x70(%rbx) + if (ctx->esc_values_i > 0) { +ffffffff8000493e: 48 85 c0 test %rax,%rax +ffffffff80004941: 74 3d je ffffffff80004980 + ctx->scroll_top_margin = ctx->esc_values[0] - 1; +ffffffff80004943: 8b 4b 78 mov 0x78(%rbx),%ecx +ffffffff80004946: 83 e9 01 sub $0x1,%ecx + if (ctx->esc_values_i > 1) { +ffffffff80004949: 48 83 e8 01 sub $0x1,%rax + ctx->scroll_top_margin = ctx->esc_values[0] - 1; +ffffffff8000494d: 48 89 4b 68 mov %rcx,0x68(%rbx) + if (ctx->esc_values_i > 1) { +ffffffff80004951: 74 2d je ffffffff80004980 + ctx->scroll_bottom_margin = ctx->esc_values[1]; +ffffffff80004953: 8b 43 7c mov 0x7c(%rbx),%eax +ffffffff80004956: 48 89 43 70 mov %rax,0x70(%rbx) + if (ctx->scroll_top_margin >= ctx->rows +ffffffff8000495a: 48 39 d1 cmp %rdx,%rcx +ffffffff8000495d: 73 05 jae ffffffff80004964 + || ctx->scroll_bottom_margin > ctx->rows +ffffffff8000495f: 48 39 c2 cmp %rax,%rdx +ffffffff80004962: 73 28 jae ffffffff8000498c + ctx->scroll_top_margin = 0; +ffffffff80004964: 31 c9 xor %ecx,%ecx + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80004966: 48 89 53 70 mov %rdx,0x70(%rbx) + ctx->scroll_top_margin = 0; +ffffffff8000496a: 48 89 4b 68 mov %rcx,0x68(%rbx) + ctx->set_cursor_pos(ctx, 0, 0); +ffffffff8000496e: 31 d2 xor %edx,%edx +ffffffff80004970: 31 f6 xor %esi,%esi +ffffffff80004972: 48 89 df mov %rbx,%rdi +ffffffff80004975: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff8000497b: e9 de f5 ff ff jmp ffffffff80003f5e + if (ctx->scroll_top_margin >= ctx->rows +ffffffff80004980: 48 8b 4b 68 mov 0x68(%rbx),%rcx + || ctx->scroll_bottom_margin > ctx->rows +ffffffff80004984: 48 89 d0 mov %rdx,%rax + if (ctx->scroll_top_margin >= ctx->rows +ffffffff80004987: 48 39 d1 cmp %rdx,%rcx +ffffffff8000498a: 73 d8 jae ffffffff80004964 + || ctx->scroll_top_margin >= (ctx->scroll_bottom_margin - 1)) { +ffffffff8000498c: 48 83 e8 01 sub $0x1,%rax +ffffffff80004990: 48 39 c1 cmp %rax,%rcx +ffffffff80004993: 73 cf jae ffffffff80004964 +ffffffff80004995: eb d7 jmp ffffffff8000496e + if (!ctx->esc_values_i) +ffffffff80004997: 4c 8b 63 40 mov 0x40(%rbx),%r12 +ffffffff8000499b: 4d 85 e4 test %r12,%r12 +ffffffff8000499e: 0f 84 c8 00 00 00 je ffffffff80004a6c + for (; i < ctx->esc_values_i; i++) { +ffffffff800049a4: 4c 89 e6 mov %r12,%rsi + size_t i = 0; +ffffffff800049a7: 45 31 e4 xor %r12d,%r12d + if (ctx->esc_values[i] == 0) { +ffffffff800049aa: 4a 8d 0c a3 lea (%rbx,%r12,4),%rcx +ffffffff800049ae: 8b 51 78 mov 0x78(%rcx),%edx +ffffffff800049b1: 83 fa 6b cmp $0x6b,%edx +ffffffff800049b4: 77 71 ja ffffffff80004a27 +ffffffff800049b6: 89 d0 mov %edx,%eax +ffffffff800049b8: 3e ff 24 c5 e8 ad 00 notrack jmp *-0x7fff5218(,%rax,8) +ffffffff800049bf: 80 + if (ctx->esc_values_i == 0) { +ffffffff800049c0: 48 8b 53 40 mov 0x40(%rbx),%rdx +ffffffff800049c4: 48 85 d2 test %rdx,%rdx +ffffffff800049c7: 0f 84 91 f5 ff ff je ffffffff80003f5e + switch (c) { +ffffffff800049cd: 41 80 fc 68 cmp $0x68,%r12b +ffffffff800049d1: 0f 94 c0 sete %al + switch (ctx->esc_values[0]) { +ffffffff800049d4: 83 7b 78 04 cmpl $0x4,0x78(%rbx) +ffffffff800049d8: 0f 84 86 00 00 00 je ffffffff80004a64 + if (ctx->callback != NULL) { +ffffffff800049de: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff800049e5: 48 85 c0 test %rax,%rax +ffffffff800049e8: 0f 84 70 f5 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_MODE, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c); +ffffffff800049ee: 48 8d 4b 78 lea 0x78(%rbx),%rcx +ffffffff800049f2: 4d 0f be c4 movsbq %r12b,%r8 +ffffffff800049f6: be 46 00 00 00 mov $0x46,%esi +ffffffff800049fb: 48 89 df mov %rbx,%rdi +ffffffff800049fe: ff d0 call *%rax +ffffffff80004a00: e9 59 f5 ff ff jmp ffffffff80003f5e + ctx->current_bg = ctx->esc_values[i] - offset; +ffffffff80004a05: 48 8d 50 9c lea -0x64(%rax),%rdx + if (ctx->reverse_video) { +ffffffff80004a09: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_bg = ctx->esc_values[i] - offset; +ffffffff80004a0d: 48 89 53 60 mov %rdx,0x60(%rbx) + offset = 100; +ffffffff80004a11: ba 64 00 00 00 mov $0x64,%edx + if (ctx->reverse_video) { +ffffffff80004a16: 75 3b jne ffffffff80004a53 + ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset); +ffffffff80004a18: 48 29 d0 sub %rdx,%rax +ffffffff80004a1b: 48 89 df mov %rbx,%rdi +ffffffff80004a1e: 48 89 c6 mov %rax,%rsi +ffffffff80004a21: ff 93 28 01 00 00 call *0x128(%rbx) + continue; +ffffffff80004a27: 4d 89 e7 mov %r12,%r15 + for (; i < ctx->esc_values_i; i++) { +ffffffff80004a2a: 48 8b 73 40 mov 0x40(%rbx),%rsi +ffffffff80004a2e: 4d 8d 67 01 lea 0x1(%r15),%r12 +ffffffff80004a32: 49 39 f4 cmp %rsi,%r12 +ffffffff80004a35: 0f 83 23 f5 ff ff jae ffffffff80003f5e +ffffffff80004a3b: e9 6a ff ff ff jmp ffffffff800049aa + ctx->current_primary = ctx->esc_values[i] - offset; +ffffffff80004a40: 48 8d 50 a6 lea -0x5a(%rax),%rdx + if (ctx->reverse_video) { +ffffffff80004a44: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_primary = ctx->esc_values[i] - offset; +ffffffff80004a48: 48 89 53 58 mov %rdx,0x58(%rbx) + offset = 90; +ffffffff80004a4c: ba 5a 00 00 00 mov $0x5a,%edx + if (ctx->reverse_video) { +ffffffff80004a51: 75 c5 jne ffffffff80004a18 + ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset); +ffffffff80004a53: 48 29 d0 sub %rdx,%rax +ffffffff80004a56: 48 89 df mov %rbx,%rdi +ffffffff80004a59: 48 89 c6 mov %rax,%rsi +ffffffff80004a5c: ff 93 20 01 00 00 call *0x120(%rbx) + continue; +ffffffff80004a62: eb c3 jmp ffffffff80004a27 + ctx->insert_mode = set; return; +ffffffff80004a64: 88 43 15 mov %al,0x15(%rbx) +ffffffff80004a67: e9 f2 f4 ff ff jmp ffffffff80003f5e + if (ctx->reverse_video) { +ffffffff80004a6c: 80 7b 13 00 cmpb $0x0,0x13(%rbx) +ffffffff80004a70: 74 0d je ffffffff80004a7f + ctx->reverse_video = false; +ffffffff80004a72: c6 43 13 00 movb $0x0,0x13(%rbx) + ctx->swap_palette(ctx); +ffffffff80004a76: 48 89 df mov %rbx,%rdi +ffffffff80004a79: ff 93 78 01 00 00 call *0x178(%rbx) + ctx->set_text_bg_default(ctx); +ffffffff80004a7f: 48 89 df mov %rbx,%rdi + ctx->bold = false; +ffffffff80004a82: 66 c7 43 11 00 00 movw $0x0,0x11(%rbx) + continue; +ffffffff80004a88: 4d 89 e7 mov %r12,%r15 + ctx->current_primary = (size_t)-1; +ffffffff80004a8b: 48 c7 43 58 ff ff ff movq $0xffffffffffffffff,0x58(%rbx) +ffffffff80004a92: ff + ctx->current_bg = (size_t)-1; +ffffffff80004a93: 48 c7 43 60 ff ff ff movq $0xffffffffffffffff,0x60(%rbx) +ffffffff80004a9a: ff + ctx->set_text_bg_default(ctx); +ffffffff80004a9b: ff 93 48 01 00 00 call *0x148(%rbx) + ctx->set_text_fg_default(ctx); +ffffffff80004aa1: 48 89 df mov %rbx,%rdi +ffffffff80004aa4: ff 93 40 01 00 00 call *0x140(%rbx) + continue; +ffffffff80004aaa: e9 7b ff ff ff jmp ffffffff80004a2a + ctx->esc_values[0] -= 1; +ffffffff80004aaf: 8b 43 78 mov 0x78(%rbx),%eax + if (ctx->esc_values[0] >= ctx->rows) +ffffffff80004ab2: 48 8b 93 e0 00 00 00 mov 0xe0(%rbx),%rdx + ctx->esc_values[0] -= 1; +ffffffff80004ab9: 83 e8 01 sub $0x1,%eax +ffffffff80004abc: 89 43 78 mov %eax,0x78(%rbx) + if (ctx->esc_values[0] >= ctx->rows) +ffffffff80004abf: 48 39 d0 cmp %rdx,%rax +ffffffff80004ac2: 72 06 jb ffffffff80004aca + ctx->esc_values[0] = ctx->rows - 1; +ffffffff80004ac4: 83 ea 01 sub $0x1,%edx +ffffffff80004ac7: 89 53 78 mov %edx,0x78(%rbx) + ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]); +ffffffff80004aca: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80004acd: e9 7e f4 ff ff jmp ffffffff80003f50 + if (ctx->callback != NULL) { +ffffffff80004ad2: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff80004ad9: 48 85 c0 test %rax,%rax +ffffffff80004adc: 0f 84 7c f4 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0); +ffffffff80004ae2: 45 31 c0 xor %r8d,%r8d +ffffffff80004ae5: 31 c9 xor %ecx,%ecx +ffffffff80004ae7: 31 d2 xor %edx,%edx +ffffffff80004ae9: be 1e 00 00 00 mov $0x1e,%esi +ffffffff80004aee: 48 89 df mov %rbx,%rdi +ffffffff80004af1: ff d0 call *%rax +ffffffff80004af3: e9 66 f4 ff ff jmp ffffffff80003f5e + if (ctx->reverse_video) { +ffffffff80004af8: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_bg = (size_t)-1; +ffffffff80004afc: 48 c7 43 60 ff ff ff movq $0xffffffffffffffff,0x60(%rbx) +ffffffff80004b03: ff + if (ctx->reverse_video) { +ffffffff80004b04: 74 09 je ffffffff80004b0f + ctx->swap_palette(ctx); +ffffffff80004b06: 48 89 df mov %rbx,%rdi +ffffffff80004b09: ff 93 78 01 00 00 call *0x178(%rbx) + if (!ctx->bg_bold) { +ffffffff80004b0f: 80 7b 12 00 cmpb $0x0,0x12(%rbx) + ctx->set_text_bg_default(ctx); +ffffffff80004b13: 48 89 df mov %rbx,%rdi + if (!ctx->bg_bold) { +ffffffff80004b16: 75 77 jne ffffffff80004b8f + ctx->set_text_bg_default(ctx); +ffffffff80004b18: ff 93 48 01 00 00 call *0x148(%rbx) + if (ctx->reverse_video) { +ffffffff80004b1e: 80 7b 13 00 cmpb $0x0,0x13(%rbx) +ffffffff80004b22: 0f 84 ff fe ff ff je ffffffff80004a27 + ctx->swap_palette(ctx); +ffffffff80004b28: 48 89 df mov %rbx,%rdi +ffffffff80004b2b: ff 93 78 01 00 00 call *0x178(%rbx) +ffffffff80004b31: e9 f1 fe ff ff jmp ffffffff80004a27 + ctx->current_bg = ctx->esc_values[i] - offset; +ffffffff80004b36: 48 8d 50 d8 lea -0x28(%rax),%rdx + if (ctx->reverse_video) { +ffffffff80004b3a: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_bg = ctx->esc_values[i] - offset; +ffffffff80004b3e: 48 89 53 60 mov %rdx,0x60(%rbx) + if (ctx->reverse_video) { +ffffffff80004b42: 75 53 jne ffffffff80004b97 + || (ctx->bg_bold && !ctx->reverse_video)) { +ffffffff80004b44: 80 7b 12 00 cmpb $0x0,0x12(%rbx) +ffffffff80004b48: ba 28 00 00 00 mov $0x28,%edx +ffffffff80004b4d: 0f 85 c5 fe ff ff jne ffffffff80004a18 + ctx->set_text_bg(ctx, ctx->esc_values[i] - offset); +ffffffff80004b53: 48 29 d0 sub %rdx,%rax +ffffffff80004b56: 48 89 df mov %rbx,%rdi +ffffffff80004b59: 48 89 c6 mov %rax,%rsi +ffffffff80004b5c: ff 93 18 01 00 00 call *0x118(%rbx) +ffffffff80004b62: e9 c0 fe ff ff jmp ffffffff80004a27 + if (ctx->reverse_video) { +ffffffff80004b67: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_primary = (size_t)-1; +ffffffff80004b6b: 48 c7 43 58 ff ff ff movq $0xffffffffffffffff,0x58(%rbx) +ffffffff80004b72: ff + if (ctx->reverse_video) { +ffffffff80004b73: 74 09 je ffffffff80004b7e + ctx->swap_palette(ctx); +ffffffff80004b75: 48 89 df mov %rbx,%rdi +ffffffff80004b78: ff 93 78 01 00 00 call *0x178(%rbx) + if (!ctx->bold) { +ffffffff80004b7e: 80 7b 11 00 cmpb $0x0,0x11(%rbx) + ctx->set_text_fg_default(ctx); +ffffffff80004b82: 48 89 df mov %rbx,%rdi + if (!ctx->bold) { +ffffffff80004b85: 75 33 jne ffffffff80004bba + ctx->set_text_fg_default(ctx); +ffffffff80004b87: ff 93 40 01 00 00 call *0x140(%rbx) +ffffffff80004b8d: eb 8f jmp ffffffff80004b1e + ctx->set_text_bg_default_bright(ctx); +ffffffff80004b8f: ff 93 58 01 00 00 call *0x158(%rbx) +ffffffff80004b95: eb 87 jmp ffffffff80004b1e + || (ctx->bg_bold && ctx->reverse_video)) { +ffffffff80004b97: 80 7b 12 00 cmpb $0x0,0x12(%rbx) +ffffffff80004b9b: ba 28 00 00 00 mov $0x28,%edx +ffffffff80004ba0: 0f 85 ad fe ff ff jne ffffffff80004a53 + ctx->set_text_fg(ctx, ctx->esc_values[i] - offset); +ffffffff80004ba6: 48 29 d0 sub %rdx,%rax +ffffffff80004ba9: 48 89 df mov %rbx,%rdi +ffffffff80004bac: 48 89 c6 mov %rax,%rsi +ffffffff80004baf: ff 93 10 01 00 00 call *0x110(%rbx) +ffffffff80004bb5: e9 6d fe ff ff jmp ffffffff80004a27 + ctx->set_text_fg_default_bright(ctx); +ffffffff80004bba: ff 93 50 01 00 00 call *0x150(%rbx) + if (ctx->reverse_video) { +ffffffff80004bc0: e9 59 ff ff ff jmp ffffffff80004b1e + if (ctx->current_primary != (size_t)-1) { +ffffffff80004bc5: 48 8b 73 58 mov 0x58(%rbx),%rsi + if (!ctx->reverse_video) { +ffffffff80004bc9: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->bold = false; +ffffffff80004bcd: c6 43 11 00 movb $0x0,0x11(%rbx) + ctx->set_text_fg(ctx, ctx->current_primary); +ffffffff80004bd1: 48 89 df mov %rbx,%rdi + if (ctx->current_primary != (size_t)-1) { +ffffffff80004bd4: 48 83 fe ff cmp $0xffffffffffffffff,%rsi +ffffffff80004bd8: 74 26 je ffffffff80004c00 + if (!ctx->reverse_video) { +ffffffff80004bda: 84 c0 test %al,%al +ffffffff80004bdc: 0f 85 7a ff ff ff jne ffffffff80004b5c +ffffffff80004be2: eb cb jmp ffffffff80004baf + if (!ctx->reverse_video) { +ffffffff80004be4: 80 7b 13 00 cmpb $0x0,0x13(%rbx) +ffffffff80004be8: 0f 85 39 fe ff ff jne ffffffff80004a27 + ctx->reverse_video = true; +ffffffff80004bee: c6 43 13 01 movb $0x1,0x13(%rbx) + ctx->swap_palette(ctx); +ffffffff80004bf2: 48 89 df mov %rbx,%rdi +ffffffff80004bf5: ff 93 78 01 00 00 call *0x178(%rbx) +ffffffff80004bfb: e9 27 fe ff ff jmp ffffffff80004a27 + if (!ctx->reverse_video) { +ffffffff80004c00: 84 c0 test %al,%al +ffffffff80004c02: 75 53 jne ffffffff80004c57 + ctx->set_text_fg_default(ctx); +ffffffff80004c04: ff 93 40 01 00 00 call *0x140(%rbx) +ffffffff80004c0a: e9 18 fe ff ff jmp ffffffff80004a27 + if (ctx->current_bg != (size_t)-1) { +ffffffff80004c0f: 48 8b 73 60 mov 0x60(%rbx),%rsi + if (!ctx->reverse_video) { +ffffffff80004c13: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->bg_bold = true; +ffffffff80004c17: c6 43 12 01 movb $0x1,0x12(%rbx) + ctx->set_text_bg_bright(ctx, ctx->current_bg); +ffffffff80004c1b: 48 89 df mov %rbx,%rdi + if (ctx->current_bg != (size_t)-1) { +ffffffff80004c1e: 48 83 fe ff cmp $0xffffffffffffffff,%rsi +ffffffff80004c22: 74 3e je ffffffff80004c62 + if (!ctx->reverse_video) { +ffffffff80004c24: 84 c0 test %al,%al +ffffffff80004c26: 0f 85 30 fe ff ff jne ffffffff80004a5c +ffffffff80004c2c: e9 f0 fd ff ff jmp ffffffff80004a21 + if (ctx->current_primary != (size_t)-1) { +ffffffff80004c31: 48 8b 73 58 mov 0x58(%rbx),%rsi + if (!ctx->reverse_video) { +ffffffff80004c35: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->bold = true; +ffffffff80004c39: c6 43 11 01 movb $0x1,0x11(%rbx) + ctx->set_text_fg_bright(ctx, ctx->current_primary); +ffffffff80004c3d: 48 89 df mov %rbx,%rdi + if (ctx->current_primary != (size_t)-1) { +ffffffff80004c40: 48 83 fe ff cmp $0xffffffffffffffff,%rsi +ffffffff80004c44: 74 2b je ffffffff80004c71 + if (!ctx->reverse_video) { +ffffffff80004c46: 84 c0 test %al,%al +ffffffff80004c48: 0f 85 d3 fd ff ff jne ffffffff80004a21 +ffffffff80004c4e: e9 09 fe ff ff jmp ffffffff80004a5c + if (!ctx->reverse_video) { +ffffffff80004c53: 84 c0 test %al,%al +ffffffff80004c55: 75 ad jne ffffffff80004c04 + ctx->set_text_bg_default(ctx); +ffffffff80004c57: ff 93 48 01 00 00 call *0x148(%rbx) +ffffffff80004c5d: e9 c5 fd ff ff jmp ffffffff80004a27 + if (!ctx->reverse_video) { +ffffffff80004c62: 84 c0 test %al,%al +ffffffff80004c64: 75 0f jne ffffffff80004c75 + ctx->set_text_bg_default_bright(ctx); +ffffffff80004c66: ff 93 58 01 00 00 call *0x158(%rbx) +ffffffff80004c6c: e9 b6 fd ff ff jmp ffffffff80004a27 + if (!ctx->reverse_video) { +ffffffff80004c71: 84 c0 test %al,%al +ffffffff80004c73: 75 f1 jne ffffffff80004c66 + ctx->set_text_fg_default_bright(ctx); +ffffffff80004c75: ff 93 50 01 00 00 call *0x150(%rbx) +ffffffff80004c7b: e9 a7 fd ff ff jmp ffffffff80004a27 + i++; +ffffffff80004c80: 4d 8d 7c 24 01 lea 0x1(%r12),%r15 + if (i >= ctx->esc_values_i) { +ffffffff80004c85: 49 39 f7 cmp %rsi,%r15 +ffffffff80004c88: 0f 83 d0 f2 ff ff jae ffffffff80003f5e + switch (ctx->esc_values[i]) { +ffffffff80004c8e: 8b 41 7c mov 0x7c(%rcx),%eax +ffffffff80004c91: 83 f8 02 cmp $0x2,%eax +ffffffff80004c94: 0f 84 a3 00 00 00 je ffffffff80004d3d +ffffffff80004c9a: 83 f8 05 cmp $0x5,%eax +ffffffff80004c9d: 0f 85 87 fd ff ff jne ffffffff80004a2a + if (i + 1 >= ctx->esc_values_i) { +ffffffff80004ca3: 4d 8d 7c 24 02 lea 0x2(%r12),%r15 +ffffffff80004ca8: 49 39 f7 cmp %rsi,%r15 +ffffffff80004cab: 0f 83 ad f2 ff ff jae ffffffff80003f5e + uint32_t col = ctx->esc_values[i + 1]; +ffffffff80004cb1: 8b 81 80 00 00 00 mov 0x80(%rcx),%eax + if (col < 8) { +ffffffff80004cb7: 83 f8 07 cmp $0x7,%eax +ffffffff80004cba: 77 46 ja ffffffff80004d02 + (fg ? ctx->set_text_fg : ctx->set_text_bg)(ctx, col); +ffffffff80004cbc: 48 8b 8b 18 01 00 00 mov 0x118(%rbx),%rcx +ffffffff80004cc3: 83 fa 26 cmp $0x26,%edx +ffffffff80004cc6: 89 c6 mov %eax,%esi +ffffffff80004cc8: 48 89 df mov %rbx,%rdi +ffffffff80004ccb: 48 0f 44 8b 10 01 00 cmove 0x110(%rbx),%rcx +ffffffff80004cd2: 00 +ffffffff80004cd3: ff d1 call *%rcx +ffffffff80004cd5: e9 50 fd ff ff jmp ffffffff80004a2a + ctx->current_primary = ctx->esc_values[i] - offset; +ffffffff80004cda: 48 8d 50 e2 lea -0x1e(%rax),%rdx + if (ctx->reverse_video) { +ffffffff80004cde: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + if ((ctx->bold && ctx->reverse_video) +ffffffff80004ce2: 0f b6 4b 11 movzbl 0x11(%rbx),%ecx + ctx->current_primary = ctx->esc_values[i] - offset; +ffffffff80004ce6: 48 89 53 58 mov %rdx,0x58(%rbx) + if (ctx->reverse_video) { +ffffffff80004cea: 0f 85 91 00 00 00 jne ffffffff80004d81 + offset = 30; +ffffffff80004cf0: ba 1e 00 00 00 mov $0x1e,%edx + if ((ctx->bold && !ctx->reverse_video) +ffffffff80004cf5: 84 c9 test %cl,%cl +ffffffff80004cf7: 0f 84 a9 fe ff ff je ffffffff80004ba6 +ffffffff80004cfd: e9 51 fd ff ff jmp ffffffff80004a53 + } else if (col < 16) { +ffffffff80004d02: 83 f8 0f cmp $0xf,%eax +ffffffff80004d05: 0f 87 ae 00 00 00 ja ffffffff80004db9 + (fg ? ctx->set_text_fg_bright : ctx->set_text_bg_bright)(ctx, col - 8); +ffffffff80004d0b: 48 8b 8b 28 01 00 00 mov 0x128(%rbx),%rcx +ffffffff80004d12: 83 fa 26 cmp $0x26,%edx +ffffffff80004d15: 8d 70 f8 lea -0x8(%rax),%esi +ffffffff80004d18: 48 89 df mov %rbx,%rdi +ffffffff80004d1b: 48 0f 44 8b 20 01 00 cmove 0x120(%rbx),%rcx +ffffffff80004d22: 00 +ffffffff80004d23: ff d1 call *%rcx +ffffffff80004d25: e9 00 fd ff ff jmp ffffffff80004a2a + if (ctx->reverse_video) { +ffffffff80004d2a: 80 7b 13 00 cmpb $0x0,0x13(%rbx) +ffffffff80004d2e: 0f 84 f3 fc ff ff je ffffffff80004a27 + ctx->reverse_video = false; +ffffffff80004d34: c6 43 13 00 movb $0x0,0x13(%rbx) +ffffffff80004d38: e9 eb fd ff ff jmp ffffffff80004b28 + if (i + 3 >= ctx->esc_values_i) { +ffffffff80004d3d: 4d 8d 7c 24 04 lea 0x4(%r12),%r15 +ffffffff80004d42: 49 39 f7 cmp %rsi,%r15 +ffffffff80004d45: 0f 83 13 f2 ff ff jae ffffffff80003f5e + rgb_value |= ctx->esc_values[i + 1] << 16; +ffffffff80004d4b: 8b b1 80 00 00 00 mov 0x80(%rcx),%esi + rgb_value |= ctx->esc_values[i + 2] << 8; +ffffffff80004d51: 8b 81 84 00 00 00 mov 0x84(%rcx),%eax + rgb_value |= ctx->esc_values[i + 1] << 16; +ffffffff80004d57: c1 e6 10 shl $0x10,%esi + rgb_value |= ctx->esc_values[i + 2] << 8; +ffffffff80004d5a: c1 e0 08 shl $0x8,%eax +ffffffff80004d5d: 09 c6 or %eax,%esi + rgb_value |= ctx->esc_values[i + 3]; +ffffffff80004d5f: 0b b1 88 00 00 00 or 0x88(%rcx),%esi + (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value); +ffffffff80004d65: 48 8b 83 38 01 00 00 mov 0x138(%rbx),%rax +ffffffff80004d6c: 83 fa 26 cmp $0x26,%edx +ffffffff80004d6f: 48 89 df mov %rbx,%rdi +ffffffff80004d72: 48 0f 44 83 30 01 00 cmove 0x130(%rbx),%rax +ffffffff80004d79: 00 +ffffffff80004d7a: ff d0 call *%rax +ffffffff80004d7c: e9 a9 fc ff ff jmp ffffffff80004a2a + offset = 30; +ffffffff80004d81: ba 1e 00 00 00 mov $0x1e,%edx + if ((ctx->bold && ctx->reverse_video) +ffffffff80004d86: 84 c9 test %cl,%cl +ffffffff80004d88: 0f 85 8a fc ff ff jne ffffffff80004a18 +ffffffff80004d8e: e9 c0 fd ff ff jmp ffffffff80004b53 + if (ctx->current_bg != (size_t)-1) { +ffffffff80004d93: 48 8b 73 60 mov 0x60(%rbx),%rsi + if (!ctx->reverse_video) { +ffffffff80004d97: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->bg_bold = false; +ffffffff80004d9b: c6 43 12 00 movb $0x0,0x12(%rbx) + ctx->set_text_bg(ctx, ctx->current_bg); +ffffffff80004d9f: 48 89 df mov %rbx,%rdi + if (ctx->current_bg != (size_t)-1) { +ffffffff80004da2: 48 83 fe ff cmp $0xffffffffffffffff,%rsi +ffffffff80004da6: 0f 84 a7 fe ff ff je ffffffff80004c53 + if (!ctx->reverse_video) { +ffffffff80004dac: 84 c0 test %al,%al +ffffffff80004dae: 0f 85 fb fd ff ff jne ffffffff80004baf +ffffffff80004db4: e9 a3 fd ff ff jmp ffffffff80004b5c + } else if (col < 256) { +ffffffff80004db9: 3d ff 00 00 00 cmp $0xff,%eax +ffffffff80004dbe: 0f 87 66 fc ff ff ja ffffffff80004a2a + uint32_t rgb_value = col256[col - 16]; +ffffffff80004dc4: 83 e8 10 sub $0x10,%eax +ffffffff80004dc7: 8b 34 85 e0 b5 00 80 mov -0x7fff4a20(,%rax,4),%esi +ffffffff80004dce: eb 95 jmp ffffffff80004d65 + +ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>: +ffffffff80004dd0: f3 0f 1e fa endbr64 +ffffffff80004dd4: 55 push %rbp +ffffffff80004dd5: 48 89 f5 mov %rsi,%rbp +ffffffff80004dd8: 53 push %rbx +ffffffff80004dd9: 48 89 fb mov %rdi,%rbx + #if defined (__x86_64__) +ffffffff80004ddc: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80004de3: 48 83 ec 08 sub $0x8,%rsp + #if defined (__x86_64__) +ffffffff80004de7: e8 b4 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004dec: 48 89 ef mov %rbp,%rdi +ffffffff80004def: e8 ac 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004df4: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi +ffffffff80004dfb: e8 a0 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004e00: 48 83 c4 08 add $0x8,%rsp +ffffffff80004e04: 48 89 d8 mov %rbx,%rax +ffffffff80004e07: 5b pop %rbx +ffffffff80004e08: 5d pop %rbp +ffffffff80004e09: c3 ret +ffffffff80004e0a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>: +ffffffff80004e10: f3 0f 1e fa endbr64 +ffffffff80004e14: 55 push %rbp +ffffffff80004e15: 48 89 fd mov %rdi,%rbp + #if defined (__x86_64__) +ffffffff80004e18: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80004e1f: 53 push %rbx +ffffffff80004e20: 89 f3 mov %esi,%ebx +ffffffff80004e22: 48 83 ec 08 sub $0x8,%rsp + #if defined (__x86_64__) +ffffffff80004e26: e8 75 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004e2b: 8b 35 c7 72 00 00 mov 0x72c7(%rip),%esi # ffffffff8000c0f8 +ffffffff80004e31: 0f b6 fb movzbl %bl,%edi +ffffffff80004e34: e8 67 1a 00 00 call ffffffff800068a0 <_ZN3Lib11int2basestrEim> +ffffffff80004e39: 48 89 c7 mov %rax,%rdi +ffffffff80004e3c: e8 5f 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + #if defined (__x86_64__) +ffffffff80004e41: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi +ffffffff80004e48: e8 53 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004e4d: 48 83 c4 08 add $0x8,%rsp +ffffffff80004e51: 48 89 e8 mov %rbp,%rax +ffffffff80004e54: 5b pop %rbx +ffffffff80004e55: 5d pop %rbp +ffffffff80004e56: c3 ret +ffffffff80004e57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80004e5e: 00 00 + +ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>: +ffffffff80004e60: f3 0f 1e fa endbr64 +ffffffff80004e64: 55 push %rbp +ffffffff80004e65: 48 89 f5 mov %rsi,%rbp +ffffffff80004e68: 53 push %rbx +ffffffff80004e69: 48 89 fb mov %rdi,%rbx + #if defined (__x86_64__) +ffffffff80004e6c: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80004e73: 48 83 ec 08 sub $0x8,%rsp + #if defined (__x86_64__) +ffffffff80004e77: e8 24 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004e7c: 8b 35 76 72 00 00 mov 0x7276(%rip),%esi # ffffffff8000c0f8 +ffffffff80004e82: 48 89 ef mov %rbp,%rdi +ffffffff80004e85: e8 26 1b 00 00 call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80004e8a: 48 89 c7 mov %rax,%rdi +ffffffff80004e8d: e8 0e 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + #if defined (__x86_64__) +ffffffff80004e92: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi +ffffffff80004e99: e8 02 21 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004e9e: 48 83 c4 08 add $0x8,%rsp +ffffffff80004ea2: 48 89 d8 mov %rbx,%rax +ffffffff80004ea5: 5b pop %rbx +ffffffff80004ea6: 5d pop %rbp +ffffffff80004ea7: c3 ret +ffffffff80004ea8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80004eaf: 00 + +ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>: +void Panic(const char *meditationString, System::PanicFrame* frame) { +ffffffff80004eb0: f3 0f 1e fa endbr64 +ffffffff80004eb4: 41 54 push %r12 +ffffffff80004eb6: 55 push %rbp +ffffffff80004eb7: 48 89 fd mov %rdi,%rbp + kerr << "\nGuru Meditation" << "\n" << "\n"; +ffffffff80004eba: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +void Panic(const char *meditationString, System::PanicFrame* frame) { +ffffffff80004ec1: 53 push %rbx +ffffffff80004ec2: 48 89 f3 mov %rsi,%rbx + kerr << "\nGuru Meditation" << "\n" << "\n"; +ffffffff80004ec5: 48 c7 c6 af b9 00 80 mov $0xffffffff8000b9af,%rsi +ffffffff80004ecc: e8 ff fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004ed1: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80004ed8: 48 89 c7 mov %rax,%rdi +ffffffff80004edb: e8 f0 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004ee0: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80004ee7: 48 89 c7 mov %rax,%rdi +ffffffff80004eea: e8 e1 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "MeditationString: " << meditationString << Kt::newline; +ffffffff80004eef: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80004ef6: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff80004efd: e8 ce fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f02: 48 c7 c6 c4 b9 00 80 mov $0xffffffff8000b9c4,%rsi +ffffffff80004f09: 48 89 c7 mov %rax,%rdi +ffffffff80004f0c: e8 bf fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f11: 48 89 ee mov %rbp,%rsi +ffffffff80004f14: 48 89 c7 mov %rax,%rdi +ffffffff80004f17: e8 b4 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + base streamBaseType = base::dec; + + // C++ streaming operator like cout + friend KernelOutStream &operator<<(KernelOutStream &t, const char *string) + { + Print(string); +ffffffff80004f1c: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80004f23: e8 78 20 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + } + + // C++ streaming operator like cout + friend KernelOutStream &operator<<(KernelOutStream &t, const char chr) + { + Putchar(chr); +ffffffff80004f28: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80004f2d: e8 3e 20 00 00 call ffffffff80006f70 <_ZN2Kt7PutcharEc> + Print(string); +ffffffff80004f32: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi +ffffffff80004f39: e8 62 20 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + if (frame != nullptr) { +ffffffff80004f3e: 48 85 db test %rbx,%rbx +ffffffff80004f41: 0f 84 b9 02 00 00 je ffffffff80005200 <_Z5PanicPKcPN6System10PanicFrameE+0x350> + kerr << "\t" << "InterruptVector: " << "0x" << base::hex << frame->InterruptVector << "\n"; +ffffffff80004f47: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80004f4e: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff80004f55: e8 76 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f5a: 48 c7 c6 d7 b9 00 80 mov $0xffffffff8000b9d7,%rsi +ffffffff80004f61: 48 89 c7 mov %rax,%rdi +ffffffff80004f64: e8 67 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f69: 48 c7 c6 10 bd 00 80 mov $0xffffffff8000bd10,%rsi +ffffffff80004f70: 48 89 c7 mov %rax,%rdi +ffffffff80004f73: e8 58 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f78: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80004f7f: 48 89 c5 mov %rax,%rbp +ffffffff80004f82: e8 19 20 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004f87: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + return t; + } + + friend KernelOutStream &operator<<(KernelOutStream &t, base newBase) + { + t.streamBaseType = newBase; +ffffffff80004f8e: c7 05 60 71 00 00 10 movl $0x10,0x7160(%rip) # ffffffff8000c0f8 +ffffffff80004f95: 00 00 00 + Print(string); +ffffffff80004f98: e8 03 20 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80004f9d: 0f b6 73 28 movzbl 0x28(%rbx),%esi +ffffffff80004fa1: 48 89 ef mov %rbp,%rdi +ffffffff80004fa4: e8 67 fe ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff80004fa9: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80004fb0: 48 89 c7 mov %rax,%rdi +ffffffff80004fb3: e8 18 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + if (frame->InterruptVector == 0xE) { // In case of #PF the CPU pushes an error code to the frame +ffffffff80004fb8: 0f b6 43 28 movzbl 0x28(%rbx),%eax +ffffffff80004fbc: 3c 0e cmp $0xe,%al +ffffffff80004fbe: 0f 84 40 02 00 00 je ffffffff80005204 <_Z5PanicPKcPN6System10PanicFrameE+0x354> + else if (frame->InterruptVector == 0xD) { +ffffffff80004fc4: 3c 0d cmp $0xd,%al +ffffffff80004fc6: 0f 84 7f 05 00 00 je ffffffff8000554b <_Z5PanicPKcPN6System10PanicFrameE+0x69b> + kerr << "\t" << "InstructionPointer: " << "0x" << base::hex << frame->IP << "\n"; +ffffffff80004fcc: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80004fd3: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff80004fda: e8 f1 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004fdf: 48 c7 c6 9d ba 00 80 mov $0xffffffff8000ba9d,%rsi +ffffffff80004fe6: 48 89 c7 mov %rax,%rdi +ffffffff80004fe9: e8 e2 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004fee: 48 c7 c6 10 bd 00 80 mov $0xffffffff8000bd10,%rsi +ffffffff80004ff5: 48 89 c7 mov %rax,%rdi +ffffffff80004ff8: e8 d3 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004ffd: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005004: 48 89 c5 mov %rax,%rbp +ffffffff80005007: e8 94 1f 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000500c: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005013: c7 05 db 70 00 00 10 movl $0x10,0x70db(%rip) # ffffffff8000c0f8 +ffffffff8000501a: 00 00 00 + Print(string); +ffffffff8000501d: e8 7e 1f 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005022: 48 8b 33 mov (%rbx),%rsi +ffffffff80005025: 48 89 ef mov %rbp,%rdi +ffffffff80005028: e8 33 fe ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff8000502d: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80005034: 48 89 c7 mov %rax,%rdi +ffffffff80005037: e8 94 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "CodeSegment: " << "0x" << base::hex << frame->CS << "\n"; +ffffffff8000503c: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80005043: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff8000504a: e8 81 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000504f: 48 c7 c6 b2 ba 00 80 mov $0xffffffff8000bab2,%rsi +ffffffff80005056: 48 89 c7 mov %rax,%rdi +ffffffff80005059: e8 72 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000505e: 48 c7 c6 10 bd 00 80 mov $0xffffffff8000bd10,%rsi +ffffffff80005065: 48 89 c7 mov %rax,%rdi +ffffffff80005068: e8 63 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000506d: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005074: 48 89 c5 mov %rax,%rbp +ffffffff80005077: e8 24 1f 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000507c: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005083: c7 05 6b 70 00 00 10 movl $0x10,0x706b(%rip) # ffffffff8000c0f8 +ffffffff8000508a: 00 00 00 + Print(string); +ffffffff8000508d: e8 0e 1f 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005092: 48 8b 73 08 mov 0x8(%rbx),%rsi +ffffffff80005096: 48 89 ef mov %rbp,%rdi +ffffffff80005099: e8 c2 fd ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff8000509e: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff800050a5: 48 89 c7 mov %rax,%rdi +ffffffff800050a8: e8 23 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "Flags: " << "0x" << base::hex << frame->Flags << "\n"; +ffffffff800050ad: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff800050b4: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff800050bb: e8 10 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800050c0: 48 c7 c6 c0 ba 00 80 mov $0xffffffff8000bac0,%rsi +ffffffff800050c7: 48 89 c7 mov %rax,%rdi +ffffffff800050ca: e8 01 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800050cf: 48 c7 c6 10 bd 00 80 mov $0xffffffff8000bd10,%rsi +ffffffff800050d6: 48 89 c7 mov %rax,%rdi +ffffffff800050d9: e8 f2 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800050de: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff800050e5: 48 89 c5 mov %rax,%rbp +ffffffff800050e8: e8 b3 1e 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800050ed: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff800050f4: c7 05 fa 6f 00 00 10 movl $0x10,0x6ffa(%rip) # ffffffff8000c0f8 +ffffffff800050fb: 00 00 00 + Print(string); +ffffffff800050fe: e8 9d 1e 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005103: 48 8b 73 10 mov 0x10(%rbx),%rsi +ffffffff80005107: 48 89 ef mov %rbp,%rdi +ffffffff8000510a: e8 51 fd ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff8000510f: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80005116: 48 89 c7 mov %rax,%rdi +ffffffff80005119: e8 b2 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "StackPointer: " << "0x" << base::hex << frame->SP << "\n"; +ffffffff8000511e: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80005125: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff8000512c: e8 9f fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005131: 48 c7 c6 c8 ba 00 80 mov $0xffffffff8000bac8,%rsi +ffffffff80005138: 48 89 c7 mov %rax,%rdi +ffffffff8000513b: e8 90 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005140: 48 c7 c6 10 bd 00 80 mov $0xffffffff8000bd10,%rsi +ffffffff80005147: 48 89 c7 mov %rax,%rdi +ffffffff8000514a: e8 81 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000514f: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005156: 48 89 c5 mov %rax,%rbp +ffffffff80005159: e8 42 1e 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000515e: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005165: c7 05 89 6f 00 00 10 movl $0x10,0x6f89(%rip) # ffffffff8000c0f8 +ffffffff8000516c: 00 00 00 + Print(string); +ffffffff8000516f: e8 2c 1e 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005174: 48 8b 73 18 mov 0x18(%rbx),%rsi +ffffffff80005178: 48 89 ef mov %rbp,%rdi +ffffffff8000517b: e8 e0 fc ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff80005180: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80005187: 48 89 c7 mov %rax,%rdi +ffffffff8000518a: e8 41 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "StackSegment: " << "0x" << base::hex << frame->SS << "\n"; +ffffffff8000518f: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80005196: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff8000519d: e8 2e fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800051a2: 48 c7 c6 d7 ba 00 80 mov $0xffffffff8000bad7,%rsi +ffffffff800051a9: 48 89 c7 mov %rax,%rdi +ffffffff800051ac: e8 1f fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800051b1: 48 c7 c6 10 bd 00 80 mov $0xffffffff8000bd10,%rsi +ffffffff800051b8: 48 89 c7 mov %rax,%rdi +ffffffff800051bb: e8 10 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800051c0: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff800051c7: 48 89 c5 mov %rax,%rbp +ffffffff800051ca: e8 d1 1d 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800051cf: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff800051d6: c7 05 18 6f 00 00 10 movl $0x10,0x6f18(%rip) # ffffffff8000c0f8 +ffffffff800051dd: 00 00 00 + Print(string); +ffffffff800051e0: e8 bb 1d 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800051e5: 48 8b 73 20 mov 0x20(%rbx),%rsi +ffffffff800051e9: 48 89 ef mov %rbp,%rdi +ffffffff800051ec: e8 6f fc ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff800051f1: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff800051f8: 48 89 c7 mov %rax,%rdi +ffffffff800051fb: e8 d0 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + asm ("cli"); +ffffffff80005200: fa cli + asm ("hlt"); +ffffffff80005201: f4 hlt + while (true) { +ffffffff80005202: eb fc jmp ffffffff80005200 <_Z5PanicPKcPN6System10PanicFrameE+0x350> + kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n"; +ffffffff80005204: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff8000520b: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi + frame = (System::PanicFrame*)&pf_frame->IP; +ffffffff80005212: 48 8d 6b 08 lea 0x8(%rbx),%rbp + kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n"; +ffffffff80005216: e8 b5 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000521b: 48 c7 c6 e9 b9 00 80 mov $0xffffffff8000b9e9,%rsi +ffffffff80005222: 48 89 c7 mov %rax,%rdi +ffffffff80005225: e8 a6 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000522a: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005231: 49 89 c4 mov %rax,%r12 +ffffffff80005234: e8 67 1d 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005239: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005240: c7 05 ae 6e 00 00 0a movl $0xa,0x6eae(%rip) # ffffffff8000c0f8 +ffffffff80005247: 00 00 00 + Print(string); +ffffffff8000524a: e8 51 1d 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000524f: 0f b6 33 movzbl (%rbx),%esi +ffffffff80005252: 4c 89 e7 mov %r12,%rdi +ffffffff80005255: 83 e6 01 and $0x1,%esi +ffffffff80005258: e8 b3 fb ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff8000525d: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80005264: 48 89 c7 mov %rax,%rdi +ffffffff80005267: e8 64 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultWrite: " << base::dec << pf_frame->PageFaultError.Write << "\n"; +ffffffff8000526c: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80005273: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff8000527a: e8 51 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000527f: 48 c7 c6 fc b9 00 80 mov $0xffffffff8000b9fc,%rsi +ffffffff80005286: 48 89 c7 mov %rax,%rdi +ffffffff80005289: e8 42 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000528e: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005295: 49 89 c4 mov %rax,%r12 +ffffffff80005298: e8 03 1d 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000529d: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff800052a4: c7 05 4a 6e 00 00 0a movl $0xa,0x6e4a(%rip) # ffffffff8000c0f8 +ffffffff800052ab: 00 00 00 + Print(string); +ffffffff800052ae: e8 ed 1c 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800052b3: 0f b6 33 movzbl (%rbx),%esi +ffffffff800052b6: 4c 89 e7 mov %r12,%rdi +ffffffff800052b9: 40 d0 ee shr $1,%sil +ffffffff800052bc: 83 e6 01 and $0x1,%esi +ffffffff800052bf: e8 4c fb ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff800052c4: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff800052cb: 48 89 c7 mov %rax,%rdi +ffffffff800052ce: e8 fd fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultUser: " << base::dec << pf_frame->PageFaultError.User << "\n"; +ffffffff800052d3: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff800052da: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff800052e1: e8 ea fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800052e6: 48 c7 c6 0d ba 00 80 mov $0xffffffff8000ba0d,%rsi +ffffffff800052ed: 48 89 c7 mov %rax,%rdi +ffffffff800052f0: e8 db fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800052f5: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff800052fc: 49 89 c4 mov %rax,%r12 +ffffffff800052ff: e8 9c 1c 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005304: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff8000530b: c7 05 e3 6d 00 00 0a movl $0xa,0x6de3(%rip) # ffffffff8000c0f8 +ffffffff80005312: 00 00 00 + Print(string); +ffffffff80005315: e8 86 1c 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000531a: 0f b6 33 movzbl (%rbx),%esi +ffffffff8000531d: 4c 89 e7 mov %r12,%rdi +ffffffff80005320: 40 c0 ee 02 shr $0x2,%sil +ffffffff80005324: 83 e6 01 and $0x1,%esi +ffffffff80005327: e8 e4 fa ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff8000532c: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80005333: 48 89 c7 mov %rax,%rdi +ffffffff80005336: e8 95 fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultReservedWrite: " << base::dec << pf_frame->PageFaultError.ReservedWrite << "\n"; +ffffffff8000533b: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80005342: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff80005349: e8 82 fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000534e: 48 c7 c6 1d ba 00 80 mov $0xffffffff8000ba1d,%rsi +ffffffff80005355: 48 89 c7 mov %rax,%rdi +ffffffff80005358: e8 73 fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000535d: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005364: 49 89 c4 mov %rax,%r12 +ffffffff80005367: e8 34 1c 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000536c: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005373: c7 05 7b 6d 00 00 0a movl $0xa,0x6d7b(%rip) # ffffffff8000c0f8 +ffffffff8000537a: 00 00 00 + Print(string); +ffffffff8000537d: e8 1e 1c 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005382: 0f b6 33 movzbl (%rbx),%esi +ffffffff80005385: 4c 89 e7 mov %r12,%rdi +ffffffff80005388: 40 c0 ee 03 shr $0x3,%sil +ffffffff8000538c: 83 e6 01 and $0x1,%esi +ffffffff8000538f: e8 7c fa ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff80005394: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff8000539b: 48 89 c7 mov %rax,%rdi +ffffffff8000539e: e8 2d fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultInstructionFetch: " << base::dec << pf_frame->PageFaultError.InstructionFetch << "\n"; +ffffffff800053a3: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff800053aa: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff800053b1: e8 1a fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800053b6: 48 c7 c6 36 ba 00 80 mov $0xffffffff8000ba36,%rsi +ffffffff800053bd: 48 89 c7 mov %rax,%rdi +ffffffff800053c0: e8 0b fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800053c5: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff800053cc: 49 89 c4 mov %rax,%r12 +ffffffff800053cf: e8 cc 1b 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800053d4: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff800053db: c7 05 13 6d 00 00 0a movl $0xa,0x6d13(%rip) # ffffffff8000c0f8 +ffffffff800053e2: 00 00 00 + Print(string); +ffffffff800053e5: e8 b6 1b 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800053ea: 0f b6 33 movzbl (%rbx),%esi +ffffffff800053ed: 4c 89 e7 mov %r12,%rdi +ffffffff800053f0: 40 c0 ee 04 shr $0x4,%sil +ffffffff800053f4: 83 e6 01 and $0x1,%esi +ffffffff800053f7: e8 14 fa ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff800053fc: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff80005403: 48 89 c7 mov %rax,%rdi +ffffffff80005406: e8 c5 f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultProtectionKey: " << base::dec << pf_frame->PageFaultError.ProtectionKey << "\n"; +ffffffff8000540b: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80005412: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff80005419: e8 b2 f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000541e: 48 c7 c6 52 ba 00 80 mov $0xffffffff8000ba52,%rsi +ffffffff80005425: 48 89 c7 mov %rax,%rdi +ffffffff80005428: e8 a3 f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000542d: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005434: 49 89 c4 mov %rax,%r12 +ffffffff80005437: e8 64 1b 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000543c: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005443: c7 05 ab 6c 00 00 0a movl $0xa,0x6cab(%rip) # ffffffff8000c0f8 +ffffffff8000544a: 00 00 00 + Print(string); +ffffffff8000544d: e8 4e 1b 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005452: 0f b6 33 movzbl (%rbx),%esi +ffffffff80005455: 4c 89 e7 mov %r12,%rdi +ffffffff80005458: 40 c0 ee 05 shr $0x5,%sil +ffffffff8000545c: 83 e6 01 and $0x1,%esi +ffffffff8000545f: e8 ac f9 ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff80005464: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff8000546b: 48 89 c7 mov %rax,%rdi +ffffffff8000546e: e8 5d f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultShadowStack: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n"; +ffffffff80005473: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff8000547a: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff80005481: e8 4a f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005486: 48 c7 c6 6b ba 00 80 mov $0xffffffff8000ba6b,%rsi +ffffffff8000548d: 48 89 c7 mov %rax,%rdi +ffffffff80005490: e8 3b f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005495: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff8000549c: 49 89 c4 mov %rax,%r12 +ffffffff8000549f: e8 fc 1a 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800054a4: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff800054ab: c7 05 43 6c 00 00 0a movl $0xa,0x6c43(%rip) # ffffffff8000c0f8 +ffffffff800054b2: 00 00 00 + Print(string); +ffffffff800054b5: e8 e6 1a 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800054ba: 0f b6 33 movzbl (%rbx),%esi +ffffffff800054bd: 4c 89 e7 mov %r12,%rdi +ffffffff800054c0: 40 c0 ee 06 shr $0x6,%sil +ffffffff800054c4: 83 e6 01 and $0x1,%esi +ffffffff800054c7: e8 44 f9 ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff800054cc: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff800054d3: 48 89 c7 mov %rax,%rdi +ffffffff800054d6: e8 f5 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n"; +ffffffff800054db: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff800054e2: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff800054e9: e8 e2 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800054ee: 48 c7 c6 82 ba 00 80 mov $0xffffffff8000ba82,%rsi +ffffffff800054f5: 48 89 c7 mov %rax,%rdi +ffffffff800054f8: e8 d3 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800054fd: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005504: 49 89 c4 mov %rax,%r12 +ffffffff80005507: e8 94 1a 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000550c: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005513: c7 05 db 6b 00 00 0a movl $0xa,0x6bdb(%rip) # ffffffff8000c0f8 +ffffffff8000551a: 00 00 00 + Print(string); +ffffffff8000551d: e8 7e 1a 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005522: 0f b6 33 movzbl (%rbx),%esi +ffffffff80005525: 4c 89 e7 mov %r12,%rdi + frame = (System::PanicFrame*)&pf_frame->IP; +ffffffff80005528: 48 89 eb mov %rbp,%rbx + kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n"; +ffffffff8000552b: 40 c0 ee 06 shr $0x6,%sil +ffffffff8000552f: 83 e6 01 and $0x1,%esi +ffffffff80005532: e8 d9 f8 ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff80005537: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff8000553e: 48 89 c7 mov %rax,%rdi +ffffffff80005541: e8 8a f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005546: e9 81 fa ff ff jmp ffffffff80004fcc <_Z5PanicPKcPN6System10PanicFrameE+0x11c> + kerr << "\t" << "ErrorCode: " << base::dec << gpf_frame->GeneralProtectionFaultError << "\n"; +ffffffff8000554b: 48 c7 c6 c2 b9 00 80 mov $0xffffffff8000b9c2,%rsi +ffffffff80005552: 48 c7 c7 c0 17 0e 80 mov $0xffffffff800e17c0,%rdi +ffffffff80005559: e8 72 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000555e: 48 c7 c6 91 ba 00 80 mov $0xffffffff8000ba91,%rsi +ffffffff80005565: 48 89 c7 mov %rax,%rdi +ffffffff80005568: e8 63 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000556d: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff80005574: 48 89 c5 mov %rax,%rbp +ffffffff80005577: e8 24 1a 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000557c: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005583: c7 05 6b 6b 00 00 0a movl $0xa,0x6b6b(%rip) # ffffffff8000c0f8 +ffffffff8000558a: 00 00 00 + Print(string); +ffffffff8000558d: e8 0e 1a 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff80005592: 48 8b 33 mov (%rbx),%rsi +ffffffff80005595: 48 89 ef mov %rbp,%rdi +ffffffff80005598: e8 c3 f8 ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff8000559d: 48 c7 c6 c0 b9 00 80 mov $0xffffffff8000b9c0,%rsi +ffffffff800055a4: 48 89 c7 mov %rax,%rdi +ffffffff800055a7: e8 24 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800055ac: e9 1b fa ff ff jmp ffffffff80004fcc <_Z5PanicPKcPN6System10PanicFrameE+0x11c> +ffffffff800055b1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800055b8: 00 00 00 +ffffffff800055bb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff800055c0 <_ZdlPvm>: +{ + Memory::g_heap->Free(block); +} + +void operator delete(void* block, long unsigned int) +{ +ffffffff800055c0: f3 0f 1e fa endbr64 +ffffffff800055c4: 48 89 fe mov %rdi,%rsi + Memory::g_heap->Free(block); +ffffffff800055c7: 48 8b 3d 02 c2 0d 00 mov 0xdc202(%rip),%rdi # ffffffff800e17d0 <_ZN6Memory6g_heapE> +ffffffff800055ce: e9 ed 16 00 00 jmp ffffffff80006cc0 <_ZN6Memory13HeapAllocator4FreeEPv> +ffffffff800055d3: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800055da: 00 00 00 +ffffffff800055dd: 0f 1f 00 nopl (%rax) + +ffffffff800055e0 <_ZN3kcp13cstringstreamC1Ev>: +#include "Stream.hpp" +#include +#include +#include + +kcp::cstringstream::cstringstream() +ffffffff800055e0: f3 0f 1e fa endbr64 +ffffffff800055e4: c7 47 10 0a 00 00 00 movl $0xa,0x10(%rdi) +{ + this->string = nullptr; +ffffffff800055eb: 48 c7 07 00 00 00 00 movq $0x0,(%rdi) + this->size = 0; +ffffffff800055f2: 48 c7 47 08 00 00 00 movq $0x0,0x8(%rdi) +ffffffff800055f9: 00 +} +ffffffff800055fa: c3 ret +ffffffff800055fb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80005600 <_ZN3kcp13cstringstreamD1Ev>: + +kcp::cstringstream::~cstringstream() +ffffffff80005600: f3 0f 1e fa endbr64 +{ + delete this->string; +ffffffff80005604: 48 8b 3f mov (%rdi),%rdi +ffffffff80005607: 48 85 ff test %rdi,%rdi +ffffffff8000560a: 74 14 je ffffffff80005620 <_ZN3kcp13cstringstreamD1Ev+0x20> +ffffffff8000560c: be 01 00 00 00 mov $0x1,%esi +ffffffff80005611: e9 aa ff ff ff jmp ffffffff800055c0 <_ZdlPvm> +ffffffff80005616: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000561d: 00 00 00 +} +ffffffff80005620: c3 ret +ffffffff80005621: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80005628: 00 00 00 +ffffffff8000562b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80005630 <_ZN3kcp13cstringstreamlsEPKc>: + } + + return *this; +} + +kcp::cstringstream& kcp::cstringstream::operator<<(const char* str) { +ffffffff80005630: f3 0f 1e fa endbr64 +ffffffff80005634: 41 54 push %r12 +ffffffff80005636: 55 push %rbp +ffffffff80005637: 53 push %rbx + while (*str != '\0') +ffffffff80005638: 44 0f b6 26 movzbl (%rsi),%r12d +kcp::cstringstream& kcp::cstringstream::operator<<(const char* str) { +ffffffff8000563c: 48 89 fb mov %rdi,%rbx + while (*str != '\0') +ffffffff8000563f: 45 84 e4 test %r12b,%r12b +ffffffff80005642: 74 49 je ffffffff8000568d <_ZN3kcp13cstringstreamlsEPKc+0x5d> +ffffffff80005644: 48 89 f5 mov %rsi,%rbp +ffffffff80005647: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000564e: 00 00 + this->string = (char *)Memory::g_heap->Realloc((void *)this->string, this->size + 2); +ffffffff80005650: 48 8b 43 08 mov 0x8(%rbx),%rax +ffffffff80005654: 48 8b 33 mov (%rbx),%rsi +ffffffff80005657: 48 8b 3d 72 c1 0d 00 mov 0xdc172(%rip),%rdi # ffffffff800e17d0 <_ZN6Memory6g_heapE> +ffffffff8000565e: 48 8d 50 02 lea 0x2(%rax),%rdx +ffffffff80005662: e8 e9 15 00 00 call ffffffff80006c50 <_ZN6Memory13HeapAllocator7ReallocEPvm> +ffffffff80005667: 48 89 03 mov %rax,(%rbx) + if (!this->string) +ffffffff8000566a: 48 85 c0 test %rax,%rax +ffffffff8000566d: 74 29 je ffffffff80005698 <_ZN3kcp13cstringstreamlsEPKc+0x68> + char* ref = (char *)&string[size]; +ffffffff8000566f: 48 03 43 08 add 0x8(%rbx),%rax + *ref = c; +ffffffff80005673: 44 88 20 mov %r12b,(%rax) + *ref = '\0'; +ffffffff80005676: c6 40 01 00 movb $0x0,0x1(%rax) + this->size++; +ffffffff8000567a: 48 83 43 08 01 addq $0x1,0x8(%rbx) + while (*str != '\0') +ffffffff8000567f: 44 0f b6 65 01 movzbl 0x1(%rbp),%r12d + str++; +ffffffff80005684: 48 83 c5 01 add $0x1,%rbp + while (*str != '\0') +ffffffff80005688: 45 84 e4 test %r12b,%r12b +ffffffff8000568b: 75 c3 jne ffffffff80005650 <_ZN3kcp13cstringstreamlsEPKc+0x20> + *this << (char*)str; + + return *this; +} +ffffffff8000568d: 48 89 d8 mov %rbx,%rax +ffffffff80005690: 5b pop %rbx +ffffffff80005691: 5d pop %rbp +ffffffff80005692: 41 5c pop %r12 +ffffffff80005694: c3 ret +ffffffff80005695: 0f 1f 00 nopl (%rax) +ffffffff80005698: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff8000569f: e8 fc 18 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800056a4: 48 c7 c7 18 bd 00 80 mov $0xffffffff8000bd18,%rdi +ffffffff800056ab: e8 f0 18 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800056b0: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi +ffffffff800056b7: e8 e4 18 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff800056bc: 48 c7 c7 a2 b9 00 80 mov $0xffffffff8000b9a2,%rdi +ffffffff800056c3: e8 d8 18 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff800056c8: bf 0a 00 00 00 mov $0xa,%edi +ffffffff800056cd: e8 9e 18 00 00 call ffffffff80006f70 <_ZN2Kt7PutcharEc> + Print(string); +ffffffff800056d2: 48 c7 c7 aa b9 00 80 mov $0xffffffff8000b9aa,%rdi +ffffffff800056d9: e8 c2 18 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + return *this; +ffffffff800056de: eb 9f jmp ffffffff8000567f <_ZN3kcp13cstringstreamlsEPKc+0x4f> + +ffffffff800056e0 <_ZN3Hal10PrepareGDTEv>: + using namespace Kt; + + GDTPointer gdtPointer{}; + BasicGDT kernelGDT{}; + + void PrepareGDT() { +ffffffff800056e0: f3 0f 1e fa endbr64 +ffffffff800056e4: 48 83 ec 08 sub $0x8,%rsp + base streamBaseType = base::dec; + + // C++ streaming operator like cout + friend KernelOutStream &operator<<(KernelOutStream &t, const char *string) + { + Print(string); +ffffffff800056e8: 48 c7 c7 e6 ba 00 80 mov $0xffffffff8000bae6,%rdi +ffffffff800056ef: e8 ac 18 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + return t; + } + + friend KernelOutStream &operator<<(KernelOutStream &t, std::uint64_t number) + { + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff800056f4: be 10 00 00 00 mov $0x10,%esi +ffffffff800056f9: 48 c7 c7 60 13 0e 80 mov $0xffffffff800e1360,%rdi + return t; + } + + friend KernelOutStream &operator<<(KernelOutStream &t, base newBase) + { + t.streamBaseType = newBase; +ffffffff80005700: c7 05 ee 69 00 00 10 movl $0x10,0x69ee(%rip) # ffffffff8000c0f8 +ffffffff80005707: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff8000570a: e8 a1 12 00 00 call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff8000570f: 48 89 c7 mov %rax,%rdi +ffffffff80005712: e8 89 18 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80005717: 48 c7 c7 c0 b9 00 80 mov $0xffffffff8000b9c0,%rdi +ffffffff8000571e: e8 7d 18 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + kout << "HardwareAbstraction: GDT at " << base::hex << (uint64_t)&kernelGDT << "\n"; + kernelGDT = { +ffffffff80005723: 48 b8 ff ff 00 00 00 movabs $0xa092000000ffff,%rax +ffffffff8000572a: 92 a0 00 +ffffffff8000572d: 48 ba ff ff 00 00 00 movabs $0xa09a000000ffff,%rdx +ffffffff80005734: 9a a0 00 +ffffffff80005737: 48 c7 05 1e bc 0d 00 movq $0xffff,0xdbc1e(%rip) # ffffffff800e1360 <_ZN3Hal9kernelGDTE> +ffffffff8000573e: ff ff 00 00 +ffffffff80005742: 48 89 05 27 bc 0d 00 mov %rax,0xdbc27(%rip) # ffffffff800e1370 <_ZN3Hal9kernelGDTE+0x10> +ffffffff80005749: 48 89 05 30 bc 0d 00 mov %rax,0xdbc30(%rip) # ffffffff800e1380 <_ZN3Hal9kernelGDTE+0x20> +ffffffff80005750: 48 b8 00 00 00 00 00 movabs $0xfa0000000000,%rax +ffffffff80005757: fa 00 00 +ffffffff8000575a: 48 89 05 27 bc 0d 00 mov %rax,0xdbc27(%rip) # ffffffff800e1388 <_ZN3Hal9kernelGDTE+0x28> + + 0x0 + } + }; + + gdtPointer = GDTPointer{ +ffffffff80005761: b8 2f 00 00 00 mov $0x2f,%eax + kernelGDT = { +ffffffff80005766: 48 89 15 fb bb 0d 00 mov %rdx,0xdbbfb(%rip) # ffffffff800e1368 <_ZN3Hal9kernelGDTE+0x8> +ffffffff8000576d: 48 89 15 04 bc 0d 00 mov %rdx,0xdbc04(%rip) # ffffffff800e1378 <_ZN3Hal9kernelGDTE+0x18> + gdtPointer = GDTPointer{ +ffffffff80005774: 66 89 05 15 bc 0d 00 mov %ax,0xdbc15(%rip) # ffffffff800e1390 <_ZN3Hal10gdtPointerE> +ffffffff8000577b: 48 c7 05 0c bc 0d 00 movq $0xffffffff800e1360,0xdbc0c(%rip) # ffffffff800e1392 <_ZN3Hal10gdtPointerE+0x2> +ffffffff80005782: 60 13 0e 80 + .Size = sizeof(kernelGDT) - 1, + .GDTAddress = (uint64_t)&kernelGDT + }; + } +ffffffff80005786: 48 83 c4 08 add $0x8,%rsp +ffffffff8000578a: c3 ret +ffffffff8000578b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80005790 <_ZN3Hal13BridgeLoadGDTEv>: + + // Helpers implemented in gdt.asm + extern "C" void LoadGDT(GDTPointer *gdtPointer); + extern "C" void ReloadSegments(); + + void BridgeLoadGDT() { +ffffffff80005790: f3 0f 1e fa endbr64 +ffffffff80005794: 48 83 ec 08 sub $0x8,%rsp +ffffffff80005798: 48 c7 c7 48 bd 00 80 mov $0xffffffff8000bd48,%rdi +ffffffff8000579f: e8 fc 17 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff800057a4: bf 0a 00 00 00 mov $0xa,%edi +ffffffff800057a9: e8 c2 17 00 00 call ffffffff80006f70 <_ZN2Kt7PutcharEc> + // Puts the GDT pointer structure into the GDTR + kout << "HardwareAbstraction: Setting GDTR" << Kt::newline; + LoadGDT(&gdtPointer); +ffffffff800057ae: 48 c7 c7 90 13 0e 80 mov $0xffffffff800e1390,%rdi +ffffffff800057b5: e8 36 18 00 00 call ffffffff80006ff0 + Print(string); +ffffffff800057ba: 48 c7 c7 70 bd 00 80 mov $0xffffffff8000bd70,%rdi +ffffffff800057c1: e8 da 17 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff800057c6: bf 0a 00 00 00 mov $0xa,%edi +ffffffff800057cb: e8 a0 17 00 00 call ffffffff80006f70 <_ZN2Kt7PutcharEc> + + kout << "HardwareAbstraction: Reloading segments" << Kt::newline; + ReloadSegments(); + } +ffffffff800057d0: 48 83 c4 08 add $0x8,%rsp + ReloadSegments(); +ffffffff800057d4: e9 1b 18 00 00 jmp ffffffff80006ff4 +ffffffff800057d9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + +ffffffff800057e0 <_ZN3Hal16ExceptionHandlerILm0EEEvPN6System10PanicFrameE>: + "Security Exception", + "Reserved" + }; + + template + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800057e0: f3 0f 1e fa endbr64 +ffffffff800057e4: 41 53 push %r11 +ffffffff800057e6: 41 52 push %r10 +ffffffff800057e8: 41 51 push %r9 +ffffffff800057ea: 41 50 push %r8 +ffffffff800057ec: 57 push %rdi + // kcp::cstringstream stream; + // stream << "Caught " << base::hex << "0x" << i << " " << ExceptionStrings[i] << " in kernel"; + + frame->InterruptVector = i; + + Panic(ExceptionStrings[i], frame); +ffffffff800057ed: 48 8b 3d 0c 68 00 00 mov 0x680c(%rip),%rdi # ffffffff8000c000 <_ZN3Hal16ExceptionStringsE> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800057f4: 56 push %rsi +ffffffff800057f5: 51 push %rcx +ffffffff800057f6: 52 push %rdx +ffffffff800057f7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800057f8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800057fd: c6 44 24 70 00 movb $0x0,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005802: fc cld +ffffffff80005803: e8 a8 f6 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005808: 58 pop %rax +ffffffff80005809: 5a pop %rdx +ffffffff8000580a: 59 pop %rcx +ffffffff8000580b: 5e pop %rsi +ffffffff8000580c: 5f pop %rdi +ffffffff8000580d: 41 58 pop %r8 +ffffffff8000580f: 41 59 pop %r9 +ffffffff80005811: 41 5a pop %r10 +ffffffff80005813: 41 5b pop %r11 +ffffffff80005815: 48 cf iretq +ffffffff80005817: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000581e: 00 00 + +ffffffff80005820 <_ZN3Hal16ExceptionHandlerILm1EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005820: f3 0f 1e fa endbr64 +ffffffff80005824: 41 53 push %r11 +ffffffff80005826: 41 52 push %r10 +ffffffff80005828: 41 51 push %r9 +ffffffff8000582a: 41 50 push %r8 +ffffffff8000582c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff8000582d: 48 8b 3d d4 67 00 00 mov 0x67d4(%rip),%rdi # ffffffff8000c008 <_ZN3Hal16ExceptionStringsE+0x8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005834: 56 push %rsi +ffffffff80005835: 51 push %rcx +ffffffff80005836: 52 push %rdx +ffffffff80005837: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005838: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff8000583d: c6 44 24 70 01 movb $0x1,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005842: fc cld +ffffffff80005843: e8 68 f6 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005848: 58 pop %rax +ffffffff80005849: 5a pop %rdx +ffffffff8000584a: 59 pop %rcx +ffffffff8000584b: 5e pop %rsi +ffffffff8000584c: 5f pop %rdi +ffffffff8000584d: 41 58 pop %r8 +ffffffff8000584f: 41 59 pop %r9 +ffffffff80005851: 41 5a pop %r10 +ffffffff80005853: 41 5b pop %r11 +ffffffff80005855: 48 cf iretq +ffffffff80005857: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000585e: 00 00 + +ffffffff80005860 <_ZN3Hal16ExceptionHandlerILm2EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005860: f3 0f 1e fa endbr64 +ffffffff80005864: 41 53 push %r11 +ffffffff80005866: 41 52 push %r10 +ffffffff80005868: 41 51 push %r9 +ffffffff8000586a: 41 50 push %r8 +ffffffff8000586c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff8000586d: 48 8b 3d 9c 67 00 00 mov 0x679c(%rip),%rdi # ffffffff8000c010 <_ZN3Hal16ExceptionStringsE+0x10> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005874: 56 push %rsi +ffffffff80005875: 51 push %rcx +ffffffff80005876: 52 push %rdx +ffffffff80005877: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005878: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff8000587d: c6 44 24 70 02 movb $0x2,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005882: fc cld +ffffffff80005883: e8 28 f6 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005888: 58 pop %rax +ffffffff80005889: 5a pop %rdx +ffffffff8000588a: 59 pop %rcx +ffffffff8000588b: 5e pop %rsi +ffffffff8000588c: 5f pop %rdi +ffffffff8000588d: 41 58 pop %r8 +ffffffff8000588f: 41 59 pop %r9 +ffffffff80005891: 41 5a pop %r10 +ffffffff80005893: 41 5b pop %r11 +ffffffff80005895: 48 cf iretq +ffffffff80005897: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000589e: 00 00 + +ffffffff800058a0 <_ZN3Hal16ExceptionHandlerILm3EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800058a0: f3 0f 1e fa endbr64 +ffffffff800058a4: 41 53 push %r11 +ffffffff800058a6: 41 52 push %r10 +ffffffff800058a8: 41 51 push %r9 +ffffffff800058aa: 41 50 push %r8 +ffffffff800058ac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff800058ad: 48 8b 3d 64 67 00 00 mov 0x6764(%rip),%rdi # ffffffff8000c018 <_ZN3Hal16ExceptionStringsE+0x18> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800058b4: 56 push %rsi +ffffffff800058b5: 51 push %rcx +ffffffff800058b6: 52 push %rdx +ffffffff800058b7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800058b8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800058bd: c6 44 24 70 03 movb $0x3,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff800058c2: fc cld +ffffffff800058c3: e8 e8 f5 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff800058c8: 58 pop %rax +ffffffff800058c9: 5a pop %rdx +ffffffff800058ca: 59 pop %rcx +ffffffff800058cb: 5e pop %rsi +ffffffff800058cc: 5f pop %rdi +ffffffff800058cd: 41 58 pop %r8 +ffffffff800058cf: 41 59 pop %r9 +ffffffff800058d1: 41 5a pop %r10 +ffffffff800058d3: 41 5b pop %r11 +ffffffff800058d5: 48 cf iretq +ffffffff800058d7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff800058de: 00 00 + +ffffffff800058e0 <_ZN3Hal16ExceptionHandlerILm4EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800058e0: f3 0f 1e fa endbr64 +ffffffff800058e4: 41 53 push %r11 +ffffffff800058e6: 41 52 push %r10 +ffffffff800058e8: 41 51 push %r9 +ffffffff800058ea: 41 50 push %r8 +ffffffff800058ec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff800058ed: 48 8b 3d 2c 67 00 00 mov 0x672c(%rip),%rdi # ffffffff8000c020 <_ZN3Hal16ExceptionStringsE+0x20> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800058f4: 56 push %rsi +ffffffff800058f5: 51 push %rcx +ffffffff800058f6: 52 push %rdx +ffffffff800058f7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800058f8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800058fd: c6 44 24 70 04 movb $0x4,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005902: fc cld +ffffffff80005903: e8 a8 f5 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005908: 58 pop %rax +ffffffff80005909: 5a pop %rdx +ffffffff8000590a: 59 pop %rcx +ffffffff8000590b: 5e pop %rsi +ffffffff8000590c: 5f pop %rdi +ffffffff8000590d: 41 58 pop %r8 +ffffffff8000590f: 41 59 pop %r9 +ffffffff80005911: 41 5a pop %r10 +ffffffff80005913: 41 5b pop %r11 +ffffffff80005915: 48 cf iretq +ffffffff80005917: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000591e: 00 00 + +ffffffff80005920 <_ZN3Hal16ExceptionHandlerILm5EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005920: f3 0f 1e fa endbr64 +ffffffff80005924: 41 53 push %r11 +ffffffff80005926: 41 52 push %r10 +ffffffff80005928: 41 51 push %r9 +ffffffff8000592a: 41 50 push %r8 +ffffffff8000592c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff8000592d: 48 8b 3d f4 66 00 00 mov 0x66f4(%rip),%rdi # ffffffff8000c028 <_ZN3Hal16ExceptionStringsE+0x28> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005934: 56 push %rsi +ffffffff80005935: 51 push %rcx +ffffffff80005936: 52 push %rdx +ffffffff80005937: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005938: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff8000593d: c6 44 24 70 05 movb $0x5,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005942: fc cld +ffffffff80005943: e8 68 f5 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005948: 58 pop %rax +ffffffff80005949: 5a pop %rdx +ffffffff8000594a: 59 pop %rcx +ffffffff8000594b: 5e pop %rsi +ffffffff8000594c: 5f pop %rdi +ffffffff8000594d: 41 58 pop %r8 +ffffffff8000594f: 41 59 pop %r9 +ffffffff80005951: 41 5a pop %r10 +ffffffff80005953: 41 5b pop %r11 +ffffffff80005955: 48 cf iretq +ffffffff80005957: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000595e: 00 00 + +ffffffff80005960 <_ZN3Hal16ExceptionHandlerILm6EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005960: f3 0f 1e fa endbr64 +ffffffff80005964: 41 53 push %r11 +ffffffff80005966: 41 52 push %r10 +ffffffff80005968: 41 51 push %r9 +ffffffff8000596a: 41 50 push %r8 +ffffffff8000596c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff8000596d: 48 8b 3d bc 66 00 00 mov 0x66bc(%rip),%rdi # ffffffff8000c030 <_ZN3Hal16ExceptionStringsE+0x30> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005974: 56 push %rsi +ffffffff80005975: 51 push %rcx +ffffffff80005976: 52 push %rdx +ffffffff80005977: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005978: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff8000597d: c6 44 24 70 06 movb $0x6,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005982: fc cld +ffffffff80005983: e8 28 f5 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005988: 58 pop %rax +ffffffff80005989: 5a pop %rdx +ffffffff8000598a: 59 pop %rcx +ffffffff8000598b: 5e pop %rsi +ffffffff8000598c: 5f pop %rdi +ffffffff8000598d: 41 58 pop %r8 +ffffffff8000598f: 41 59 pop %r9 +ffffffff80005991: 41 5a pop %r10 +ffffffff80005993: 41 5b pop %r11 +ffffffff80005995: 48 cf iretq +ffffffff80005997: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000599e: 00 00 + +ffffffff800059a0 <_ZN3Hal16ExceptionHandlerILm7EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800059a0: f3 0f 1e fa endbr64 +ffffffff800059a4: 41 53 push %r11 +ffffffff800059a6: 41 52 push %r10 +ffffffff800059a8: 41 51 push %r9 +ffffffff800059aa: 41 50 push %r8 +ffffffff800059ac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff800059ad: 48 8b 3d 84 66 00 00 mov 0x6684(%rip),%rdi # ffffffff8000c038 <_ZN3Hal16ExceptionStringsE+0x38> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800059b4: 56 push %rsi +ffffffff800059b5: 51 push %rcx +ffffffff800059b6: 52 push %rdx +ffffffff800059b7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800059b8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800059bd: c6 44 24 70 07 movb $0x7,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff800059c2: fc cld +ffffffff800059c3: e8 e8 f4 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff800059c8: 58 pop %rax +ffffffff800059c9: 5a pop %rdx +ffffffff800059ca: 59 pop %rcx +ffffffff800059cb: 5e pop %rsi +ffffffff800059cc: 5f pop %rdi +ffffffff800059cd: 41 58 pop %r8 +ffffffff800059cf: 41 59 pop %r9 +ffffffff800059d1: 41 5a pop %r10 +ffffffff800059d3: 41 5b pop %r11 +ffffffff800059d5: 48 cf iretq +ffffffff800059d7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff800059de: 00 00 + +ffffffff800059e0 <_ZN3Hal16ExceptionHandlerILm8EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800059e0: f3 0f 1e fa endbr64 +ffffffff800059e4: 41 53 push %r11 +ffffffff800059e6: 41 52 push %r10 +ffffffff800059e8: 41 51 push %r9 +ffffffff800059ea: 41 50 push %r8 +ffffffff800059ec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff800059ed: 48 8b 3d 4c 66 00 00 mov 0x664c(%rip),%rdi # ffffffff8000c040 <_ZN3Hal16ExceptionStringsE+0x40> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800059f4: 56 push %rsi +ffffffff800059f5: 51 push %rcx +ffffffff800059f6: 52 push %rdx +ffffffff800059f7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800059f8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800059fd: c6 44 24 70 08 movb $0x8,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005a02: fc cld +ffffffff80005a03: e8 a8 f4 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005a08: 58 pop %rax +ffffffff80005a09: 5a pop %rdx +ffffffff80005a0a: 59 pop %rcx +ffffffff80005a0b: 5e pop %rsi +ffffffff80005a0c: 5f pop %rdi +ffffffff80005a0d: 41 58 pop %r8 +ffffffff80005a0f: 41 59 pop %r9 +ffffffff80005a11: 41 5a pop %r10 +ffffffff80005a13: 41 5b pop %r11 +ffffffff80005a15: 48 cf iretq +ffffffff80005a17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005a1e: 00 00 + +ffffffff80005a20 <_ZN3Hal16ExceptionHandlerILm9EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005a20: f3 0f 1e fa endbr64 +ffffffff80005a24: 41 53 push %r11 +ffffffff80005a26: 41 52 push %r10 +ffffffff80005a28: 41 51 push %r9 +ffffffff80005a2a: 41 50 push %r8 +ffffffff80005a2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005a2d: 48 8b 3d 14 66 00 00 mov 0x6614(%rip),%rdi # ffffffff8000c048 <_ZN3Hal16ExceptionStringsE+0x48> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005a34: 56 push %rsi +ffffffff80005a35: 51 push %rcx +ffffffff80005a36: 52 push %rdx +ffffffff80005a37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005a38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005a3d: c6 44 24 70 09 movb $0x9,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005a42: fc cld +ffffffff80005a43: e8 68 f4 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005a48: 58 pop %rax +ffffffff80005a49: 5a pop %rdx +ffffffff80005a4a: 59 pop %rcx +ffffffff80005a4b: 5e pop %rsi +ffffffff80005a4c: 5f pop %rdi +ffffffff80005a4d: 41 58 pop %r8 +ffffffff80005a4f: 41 59 pop %r9 +ffffffff80005a51: 41 5a pop %r10 +ffffffff80005a53: 41 5b pop %r11 +ffffffff80005a55: 48 cf iretq +ffffffff80005a57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005a5e: 00 00 + +ffffffff80005a60 <_ZN3Hal16ExceptionHandlerILm10EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005a60: f3 0f 1e fa endbr64 +ffffffff80005a64: 41 53 push %r11 +ffffffff80005a66: 41 52 push %r10 +ffffffff80005a68: 41 51 push %r9 +ffffffff80005a6a: 41 50 push %r8 +ffffffff80005a6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005a6d: 48 8b 3d dc 65 00 00 mov 0x65dc(%rip),%rdi # ffffffff8000c050 <_ZN3Hal16ExceptionStringsE+0x50> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005a74: 56 push %rsi +ffffffff80005a75: 51 push %rcx +ffffffff80005a76: 52 push %rdx +ffffffff80005a77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005a78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005a7d: c6 44 24 70 0a movb $0xa,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005a82: fc cld +ffffffff80005a83: e8 28 f4 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005a88: 58 pop %rax +ffffffff80005a89: 5a pop %rdx +ffffffff80005a8a: 59 pop %rcx +ffffffff80005a8b: 5e pop %rsi +ffffffff80005a8c: 5f pop %rdi +ffffffff80005a8d: 41 58 pop %r8 +ffffffff80005a8f: 41 59 pop %r9 +ffffffff80005a91: 41 5a pop %r10 +ffffffff80005a93: 41 5b pop %r11 +ffffffff80005a95: 48 cf iretq +ffffffff80005a97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005a9e: 00 00 + +ffffffff80005aa0 <_ZN3Hal16ExceptionHandlerILm11EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005aa0: f3 0f 1e fa endbr64 +ffffffff80005aa4: 41 53 push %r11 +ffffffff80005aa6: 41 52 push %r10 +ffffffff80005aa8: 41 51 push %r9 +ffffffff80005aaa: 41 50 push %r8 +ffffffff80005aac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005aad: 48 8b 3d a4 65 00 00 mov 0x65a4(%rip),%rdi # ffffffff8000c058 <_ZN3Hal16ExceptionStringsE+0x58> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ab4: 56 push %rsi +ffffffff80005ab5: 51 push %rcx +ffffffff80005ab6: 52 push %rdx +ffffffff80005ab7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005ab8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005abd: c6 44 24 70 0b movb $0xb,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005ac2: fc cld +ffffffff80005ac3: e8 e8 f3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005ac8: 58 pop %rax +ffffffff80005ac9: 5a pop %rdx +ffffffff80005aca: 59 pop %rcx +ffffffff80005acb: 5e pop %rsi +ffffffff80005acc: 5f pop %rdi +ffffffff80005acd: 41 58 pop %r8 +ffffffff80005acf: 41 59 pop %r9 +ffffffff80005ad1: 41 5a pop %r10 +ffffffff80005ad3: 41 5b pop %r11 +ffffffff80005ad5: 48 cf iretq +ffffffff80005ad7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005ade: 00 00 + +ffffffff80005ae0 <_ZN3Hal16ExceptionHandlerILm12EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ae0: f3 0f 1e fa endbr64 +ffffffff80005ae4: 41 53 push %r11 +ffffffff80005ae6: 41 52 push %r10 +ffffffff80005ae8: 41 51 push %r9 +ffffffff80005aea: 41 50 push %r8 +ffffffff80005aec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005aed: 48 8b 3d 6c 65 00 00 mov 0x656c(%rip),%rdi # ffffffff8000c060 <_ZN3Hal16ExceptionStringsE+0x60> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005af4: 56 push %rsi +ffffffff80005af5: 51 push %rcx +ffffffff80005af6: 52 push %rdx +ffffffff80005af7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005af8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005afd: c6 44 24 70 0c movb $0xc,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005b02: fc cld +ffffffff80005b03: e8 a8 f3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005b08: 58 pop %rax +ffffffff80005b09: 5a pop %rdx +ffffffff80005b0a: 59 pop %rcx +ffffffff80005b0b: 5e pop %rsi +ffffffff80005b0c: 5f pop %rdi +ffffffff80005b0d: 41 58 pop %r8 +ffffffff80005b0f: 41 59 pop %r9 +ffffffff80005b11: 41 5a pop %r10 +ffffffff80005b13: 41 5b pop %r11 +ffffffff80005b15: 48 cf iretq +ffffffff80005b17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005b1e: 00 00 + +ffffffff80005b20 <_ZN3Hal16ExceptionHandlerILm13EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005b20: f3 0f 1e fa endbr64 +ffffffff80005b24: 41 53 push %r11 +ffffffff80005b26: 41 52 push %r10 +ffffffff80005b28: 41 51 push %r9 +ffffffff80005b2a: 41 50 push %r8 +ffffffff80005b2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005b2d: 48 8b 3d 34 65 00 00 mov 0x6534(%rip),%rdi # ffffffff8000c068 <_ZN3Hal16ExceptionStringsE+0x68> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005b34: 56 push %rsi +ffffffff80005b35: 51 push %rcx +ffffffff80005b36: 52 push %rdx +ffffffff80005b37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005b38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005b3d: c6 44 24 70 0d movb $0xd,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005b42: fc cld +ffffffff80005b43: e8 68 f3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005b48: 58 pop %rax +ffffffff80005b49: 5a pop %rdx +ffffffff80005b4a: 59 pop %rcx +ffffffff80005b4b: 5e pop %rsi +ffffffff80005b4c: 5f pop %rdi +ffffffff80005b4d: 41 58 pop %r8 +ffffffff80005b4f: 41 59 pop %r9 +ffffffff80005b51: 41 5a pop %r10 +ffffffff80005b53: 41 5b pop %r11 +ffffffff80005b55: 48 cf iretq +ffffffff80005b57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005b5e: 00 00 + +ffffffff80005b60 <_ZN3Hal16ExceptionHandlerILm14EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005b60: f3 0f 1e fa endbr64 +ffffffff80005b64: 41 53 push %r11 +ffffffff80005b66: 41 52 push %r10 +ffffffff80005b68: 41 51 push %r9 +ffffffff80005b6a: 41 50 push %r8 +ffffffff80005b6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005b6d: 48 8b 3d fc 64 00 00 mov 0x64fc(%rip),%rdi # ffffffff8000c070 <_ZN3Hal16ExceptionStringsE+0x70> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005b74: 56 push %rsi +ffffffff80005b75: 51 push %rcx +ffffffff80005b76: 52 push %rdx +ffffffff80005b77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005b78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005b7d: c6 44 24 70 0e movb $0xe,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005b82: fc cld +ffffffff80005b83: e8 28 f3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005b88: 58 pop %rax +ffffffff80005b89: 5a pop %rdx +ffffffff80005b8a: 59 pop %rcx +ffffffff80005b8b: 5e pop %rsi +ffffffff80005b8c: 5f pop %rdi +ffffffff80005b8d: 41 58 pop %r8 +ffffffff80005b8f: 41 59 pop %r9 +ffffffff80005b91: 41 5a pop %r10 +ffffffff80005b93: 41 5b pop %r11 +ffffffff80005b95: 48 cf iretq +ffffffff80005b97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005b9e: 00 00 + +ffffffff80005ba0 <_ZN3Hal16ExceptionHandlerILm15EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ba0: f3 0f 1e fa endbr64 +ffffffff80005ba4: 41 53 push %r11 +ffffffff80005ba6: 41 52 push %r10 +ffffffff80005ba8: 41 51 push %r9 +ffffffff80005baa: 41 50 push %r8 +ffffffff80005bac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005bad: 48 8b 3d c4 64 00 00 mov 0x64c4(%rip),%rdi # ffffffff8000c078 <_ZN3Hal16ExceptionStringsE+0x78> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005bb4: 56 push %rsi +ffffffff80005bb5: 51 push %rcx +ffffffff80005bb6: 52 push %rdx +ffffffff80005bb7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005bb8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005bbd: c6 44 24 70 0f movb $0xf,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005bc2: fc cld +ffffffff80005bc3: e8 e8 f2 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005bc8: 58 pop %rax +ffffffff80005bc9: 5a pop %rdx +ffffffff80005bca: 59 pop %rcx +ffffffff80005bcb: 5e pop %rsi +ffffffff80005bcc: 5f pop %rdi +ffffffff80005bcd: 41 58 pop %r8 +ffffffff80005bcf: 41 59 pop %r9 +ffffffff80005bd1: 41 5a pop %r10 +ffffffff80005bd3: 41 5b pop %r11 +ffffffff80005bd5: 48 cf iretq +ffffffff80005bd7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005bde: 00 00 + +ffffffff80005be0 <_ZN3Hal16ExceptionHandlerILm16EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005be0: f3 0f 1e fa endbr64 +ffffffff80005be4: 41 53 push %r11 +ffffffff80005be6: 41 52 push %r10 +ffffffff80005be8: 41 51 push %r9 +ffffffff80005bea: 41 50 push %r8 +ffffffff80005bec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005bed: 48 8b 3d 8c 64 00 00 mov 0x648c(%rip),%rdi # ffffffff8000c080 <_ZN3Hal16ExceptionStringsE+0x80> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005bf4: 56 push %rsi +ffffffff80005bf5: 51 push %rcx +ffffffff80005bf6: 52 push %rdx +ffffffff80005bf7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005bf8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005bfd: c6 44 24 70 10 movb $0x10,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005c02: fc cld +ffffffff80005c03: e8 a8 f2 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005c08: 58 pop %rax +ffffffff80005c09: 5a pop %rdx +ffffffff80005c0a: 59 pop %rcx +ffffffff80005c0b: 5e pop %rsi +ffffffff80005c0c: 5f pop %rdi +ffffffff80005c0d: 41 58 pop %r8 +ffffffff80005c0f: 41 59 pop %r9 +ffffffff80005c11: 41 5a pop %r10 +ffffffff80005c13: 41 5b pop %r11 +ffffffff80005c15: 48 cf iretq +ffffffff80005c17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005c1e: 00 00 + +ffffffff80005c20 <_ZN3Hal16ExceptionHandlerILm17EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005c20: f3 0f 1e fa endbr64 +ffffffff80005c24: 41 53 push %r11 +ffffffff80005c26: 41 52 push %r10 +ffffffff80005c28: 41 51 push %r9 +ffffffff80005c2a: 41 50 push %r8 +ffffffff80005c2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005c2d: 48 8b 3d 54 64 00 00 mov 0x6454(%rip),%rdi # ffffffff8000c088 <_ZN3Hal16ExceptionStringsE+0x88> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005c34: 56 push %rsi +ffffffff80005c35: 51 push %rcx +ffffffff80005c36: 52 push %rdx +ffffffff80005c37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005c38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005c3d: c6 44 24 70 11 movb $0x11,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005c42: fc cld +ffffffff80005c43: e8 68 f2 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005c48: 58 pop %rax +ffffffff80005c49: 5a pop %rdx +ffffffff80005c4a: 59 pop %rcx +ffffffff80005c4b: 5e pop %rsi +ffffffff80005c4c: 5f pop %rdi +ffffffff80005c4d: 41 58 pop %r8 +ffffffff80005c4f: 41 59 pop %r9 +ffffffff80005c51: 41 5a pop %r10 +ffffffff80005c53: 41 5b pop %r11 +ffffffff80005c55: 48 cf iretq +ffffffff80005c57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005c5e: 00 00 + +ffffffff80005c60 <_ZN3Hal16ExceptionHandlerILm18EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005c60: f3 0f 1e fa endbr64 +ffffffff80005c64: 41 53 push %r11 +ffffffff80005c66: 41 52 push %r10 +ffffffff80005c68: 41 51 push %r9 +ffffffff80005c6a: 41 50 push %r8 +ffffffff80005c6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005c6d: 48 8b 3d 1c 64 00 00 mov 0x641c(%rip),%rdi # ffffffff8000c090 <_ZN3Hal16ExceptionStringsE+0x90> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005c74: 56 push %rsi +ffffffff80005c75: 51 push %rcx +ffffffff80005c76: 52 push %rdx +ffffffff80005c77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005c78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005c7d: c6 44 24 70 12 movb $0x12,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005c82: fc cld +ffffffff80005c83: e8 28 f2 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005c88: 58 pop %rax +ffffffff80005c89: 5a pop %rdx +ffffffff80005c8a: 59 pop %rcx +ffffffff80005c8b: 5e pop %rsi +ffffffff80005c8c: 5f pop %rdi +ffffffff80005c8d: 41 58 pop %r8 +ffffffff80005c8f: 41 59 pop %r9 +ffffffff80005c91: 41 5a pop %r10 +ffffffff80005c93: 41 5b pop %r11 +ffffffff80005c95: 48 cf iretq +ffffffff80005c97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005c9e: 00 00 + +ffffffff80005ca0 <_ZN3Hal16ExceptionHandlerILm19EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ca0: f3 0f 1e fa endbr64 +ffffffff80005ca4: 41 53 push %r11 +ffffffff80005ca6: 41 52 push %r10 +ffffffff80005ca8: 41 51 push %r9 +ffffffff80005caa: 41 50 push %r8 +ffffffff80005cac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005cad: 48 8b 3d e4 63 00 00 mov 0x63e4(%rip),%rdi # ffffffff8000c098 <_ZN3Hal16ExceptionStringsE+0x98> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005cb4: 56 push %rsi +ffffffff80005cb5: 51 push %rcx +ffffffff80005cb6: 52 push %rdx +ffffffff80005cb7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005cb8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005cbd: c6 44 24 70 13 movb $0x13,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005cc2: fc cld +ffffffff80005cc3: e8 e8 f1 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005cc8: 58 pop %rax +ffffffff80005cc9: 5a pop %rdx +ffffffff80005cca: 59 pop %rcx +ffffffff80005ccb: 5e pop %rsi +ffffffff80005ccc: 5f pop %rdi +ffffffff80005ccd: 41 58 pop %r8 +ffffffff80005ccf: 41 59 pop %r9 +ffffffff80005cd1: 41 5a pop %r10 +ffffffff80005cd3: 41 5b pop %r11 +ffffffff80005cd5: 48 cf iretq +ffffffff80005cd7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005cde: 00 00 + +ffffffff80005ce0 <_ZN3Hal16ExceptionHandlerILm20EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ce0: f3 0f 1e fa endbr64 +ffffffff80005ce4: 41 53 push %r11 +ffffffff80005ce6: 41 52 push %r10 +ffffffff80005ce8: 41 51 push %r9 +ffffffff80005cea: 41 50 push %r8 +ffffffff80005cec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005ced: 48 8b 3d ac 63 00 00 mov 0x63ac(%rip),%rdi # ffffffff8000c0a0 <_ZN3Hal16ExceptionStringsE+0xa0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005cf4: 56 push %rsi +ffffffff80005cf5: 51 push %rcx +ffffffff80005cf6: 52 push %rdx +ffffffff80005cf7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005cf8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005cfd: c6 44 24 70 14 movb $0x14,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005d02: fc cld +ffffffff80005d03: e8 a8 f1 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005d08: 58 pop %rax +ffffffff80005d09: 5a pop %rdx +ffffffff80005d0a: 59 pop %rcx +ffffffff80005d0b: 5e pop %rsi +ffffffff80005d0c: 5f pop %rdi +ffffffff80005d0d: 41 58 pop %r8 +ffffffff80005d0f: 41 59 pop %r9 +ffffffff80005d11: 41 5a pop %r10 +ffffffff80005d13: 41 5b pop %r11 +ffffffff80005d15: 48 cf iretq +ffffffff80005d17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005d1e: 00 00 + +ffffffff80005d20 <_ZN3Hal16ExceptionHandlerILm21EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005d20: f3 0f 1e fa endbr64 +ffffffff80005d24: 41 53 push %r11 +ffffffff80005d26: 41 52 push %r10 +ffffffff80005d28: 41 51 push %r9 +ffffffff80005d2a: 41 50 push %r8 +ffffffff80005d2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005d2d: 48 8b 3d 74 63 00 00 mov 0x6374(%rip),%rdi # ffffffff8000c0a8 <_ZN3Hal16ExceptionStringsE+0xa8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005d34: 56 push %rsi +ffffffff80005d35: 51 push %rcx +ffffffff80005d36: 52 push %rdx +ffffffff80005d37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005d38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005d3d: c6 44 24 70 15 movb $0x15,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005d42: fc cld +ffffffff80005d43: e8 68 f1 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005d48: 58 pop %rax +ffffffff80005d49: 5a pop %rdx +ffffffff80005d4a: 59 pop %rcx +ffffffff80005d4b: 5e pop %rsi +ffffffff80005d4c: 5f pop %rdi +ffffffff80005d4d: 41 58 pop %r8 +ffffffff80005d4f: 41 59 pop %r9 +ffffffff80005d51: 41 5a pop %r10 +ffffffff80005d53: 41 5b pop %r11 +ffffffff80005d55: 48 cf iretq +ffffffff80005d57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005d5e: 00 00 + +ffffffff80005d60 <_ZN3Hal16ExceptionHandlerILm22EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005d60: f3 0f 1e fa endbr64 +ffffffff80005d64: 41 53 push %r11 +ffffffff80005d66: 41 52 push %r10 +ffffffff80005d68: 41 51 push %r9 +ffffffff80005d6a: 41 50 push %r8 +ffffffff80005d6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005d6d: 48 8b 3d 3c 63 00 00 mov 0x633c(%rip),%rdi # ffffffff8000c0b0 <_ZN3Hal16ExceptionStringsE+0xb0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005d74: 56 push %rsi +ffffffff80005d75: 51 push %rcx +ffffffff80005d76: 52 push %rdx +ffffffff80005d77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005d78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005d7d: c6 44 24 70 16 movb $0x16,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005d82: fc cld +ffffffff80005d83: e8 28 f1 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005d88: 58 pop %rax +ffffffff80005d89: 5a pop %rdx +ffffffff80005d8a: 59 pop %rcx +ffffffff80005d8b: 5e pop %rsi +ffffffff80005d8c: 5f pop %rdi +ffffffff80005d8d: 41 58 pop %r8 +ffffffff80005d8f: 41 59 pop %r9 +ffffffff80005d91: 41 5a pop %r10 +ffffffff80005d93: 41 5b pop %r11 +ffffffff80005d95: 48 cf iretq +ffffffff80005d97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005d9e: 00 00 + +ffffffff80005da0 <_ZN3Hal16ExceptionHandlerILm23EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005da0: f3 0f 1e fa endbr64 +ffffffff80005da4: 41 53 push %r11 +ffffffff80005da6: 41 52 push %r10 +ffffffff80005da8: 41 51 push %r9 +ffffffff80005daa: 41 50 push %r8 +ffffffff80005dac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005dad: 48 8b 3d 04 63 00 00 mov 0x6304(%rip),%rdi # ffffffff8000c0b8 <_ZN3Hal16ExceptionStringsE+0xb8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005db4: 56 push %rsi +ffffffff80005db5: 51 push %rcx +ffffffff80005db6: 52 push %rdx +ffffffff80005db7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005db8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005dbd: c6 44 24 70 17 movb $0x17,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005dc2: fc cld +ffffffff80005dc3: e8 e8 f0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005dc8: 58 pop %rax +ffffffff80005dc9: 5a pop %rdx +ffffffff80005dca: 59 pop %rcx +ffffffff80005dcb: 5e pop %rsi +ffffffff80005dcc: 5f pop %rdi +ffffffff80005dcd: 41 58 pop %r8 +ffffffff80005dcf: 41 59 pop %r9 +ffffffff80005dd1: 41 5a pop %r10 +ffffffff80005dd3: 41 5b pop %r11 +ffffffff80005dd5: 48 cf iretq +ffffffff80005dd7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005dde: 00 00 + +ffffffff80005de0 <_ZN3Hal16ExceptionHandlerILm24EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005de0: f3 0f 1e fa endbr64 +ffffffff80005de4: 41 53 push %r11 +ffffffff80005de6: 41 52 push %r10 +ffffffff80005de8: 41 51 push %r9 +ffffffff80005dea: 41 50 push %r8 +ffffffff80005dec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005ded: 48 8b 3d cc 62 00 00 mov 0x62cc(%rip),%rdi # ffffffff8000c0c0 <_ZN3Hal16ExceptionStringsE+0xc0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005df4: 56 push %rsi +ffffffff80005df5: 51 push %rcx +ffffffff80005df6: 52 push %rdx +ffffffff80005df7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005df8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005dfd: c6 44 24 70 18 movb $0x18,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005e02: fc cld +ffffffff80005e03: e8 a8 f0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005e08: 58 pop %rax +ffffffff80005e09: 5a pop %rdx +ffffffff80005e0a: 59 pop %rcx +ffffffff80005e0b: 5e pop %rsi +ffffffff80005e0c: 5f pop %rdi +ffffffff80005e0d: 41 58 pop %r8 +ffffffff80005e0f: 41 59 pop %r9 +ffffffff80005e11: 41 5a pop %r10 +ffffffff80005e13: 41 5b pop %r11 +ffffffff80005e15: 48 cf iretq +ffffffff80005e17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005e1e: 00 00 + +ffffffff80005e20 <_ZN3Hal16ExceptionHandlerILm25EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005e20: f3 0f 1e fa endbr64 +ffffffff80005e24: 41 53 push %r11 +ffffffff80005e26: 41 52 push %r10 +ffffffff80005e28: 41 51 push %r9 +ffffffff80005e2a: 41 50 push %r8 +ffffffff80005e2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005e2d: 48 8b 3d 94 62 00 00 mov 0x6294(%rip),%rdi # ffffffff8000c0c8 <_ZN3Hal16ExceptionStringsE+0xc8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005e34: 56 push %rsi +ffffffff80005e35: 51 push %rcx +ffffffff80005e36: 52 push %rdx +ffffffff80005e37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005e38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005e3d: c6 44 24 70 19 movb $0x19,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005e42: fc cld +ffffffff80005e43: e8 68 f0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005e48: 58 pop %rax +ffffffff80005e49: 5a pop %rdx +ffffffff80005e4a: 59 pop %rcx +ffffffff80005e4b: 5e pop %rsi +ffffffff80005e4c: 5f pop %rdi +ffffffff80005e4d: 41 58 pop %r8 +ffffffff80005e4f: 41 59 pop %r9 +ffffffff80005e51: 41 5a pop %r10 +ffffffff80005e53: 41 5b pop %r11 +ffffffff80005e55: 48 cf iretq +ffffffff80005e57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005e5e: 00 00 + +ffffffff80005e60 <_ZN3Hal16ExceptionHandlerILm26EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005e60: f3 0f 1e fa endbr64 +ffffffff80005e64: 41 53 push %r11 +ffffffff80005e66: 41 52 push %r10 +ffffffff80005e68: 41 51 push %r9 +ffffffff80005e6a: 41 50 push %r8 +ffffffff80005e6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005e6d: 48 8b 3d 5c 62 00 00 mov 0x625c(%rip),%rdi # ffffffff8000c0d0 <_ZN3Hal16ExceptionStringsE+0xd0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005e74: 56 push %rsi +ffffffff80005e75: 51 push %rcx +ffffffff80005e76: 52 push %rdx +ffffffff80005e77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005e78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005e7d: c6 44 24 70 1a movb $0x1a,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005e82: fc cld +ffffffff80005e83: e8 28 f0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005e88: 58 pop %rax +ffffffff80005e89: 5a pop %rdx +ffffffff80005e8a: 59 pop %rcx +ffffffff80005e8b: 5e pop %rsi +ffffffff80005e8c: 5f pop %rdi +ffffffff80005e8d: 41 58 pop %r8 +ffffffff80005e8f: 41 59 pop %r9 +ffffffff80005e91: 41 5a pop %r10 +ffffffff80005e93: 41 5b pop %r11 +ffffffff80005e95: 48 cf iretq +ffffffff80005e97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005e9e: 00 00 + +ffffffff80005ea0 <_ZN3Hal16ExceptionHandlerILm27EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ea0: f3 0f 1e fa endbr64 +ffffffff80005ea4: 41 53 push %r11 +ffffffff80005ea6: 41 52 push %r10 +ffffffff80005ea8: 41 51 push %r9 +ffffffff80005eaa: 41 50 push %r8 +ffffffff80005eac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005ead: 48 8b 3d 24 62 00 00 mov 0x6224(%rip),%rdi # ffffffff8000c0d8 <_ZN3Hal16ExceptionStringsE+0xd8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005eb4: 56 push %rsi +ffffffff80005eb5: 51 push %rcx +ffffffff80005eb6: 52 push %rdx +ffffffff80005eb7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005eb8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005ebd: c6 44 24 70 1b movb $0x1b,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005ec2: fc cld +ffffffff80005ec3: e8 e8 ef ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005ec8: 58 pop %rax +ffffffff80005ec9: 5a pop %rdx +ffffffff80005eca: 59 pop %rcx +ffffffff80005ecb: 5e pop %rsi +ffffffff80005ecc: 5f pop %rdi +ffffffff80005ecd: 41 58 pop %r8 +ffffffff80005ecf: 41 59 pop %r9 +ffffffff80005ed1: 41 5a pop %r10 +ffffffff80005ed3: 41 5b pop %r11 +ffffffff80005ed5: 48 cf iretq +ffffffff80005ed7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005ede: 00 00 + +ffffffff80005ee0 <_ZN3Hal16ExceptionHandlerILm28EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ee0: f3 0f 1e fa endbr64 +ffffffff80005ee4: 41 53 push %r11 +ffffffff80005ee6: 41 52 push %r10 +ffffffff80005ee8: 41 51 push %r9 +ffffffff80005eea: 41 50 push %r8 +ffffffff80005eec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005eed: 48 8b 3d ec 61 00 00 mov 0x61ec(%rip),%rdi # ffffffff8000c0e0 <_ZN3Hal16ExceptionStringsE+0xe0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ef4: 56 push %rsi +ffffffff80005ef5: 51 push %rcx +ffffffff80005ef6: 52 push %rdx +ffffffff80005ef7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005ef8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005efd: c6 44 24 70 1c movb $0x1c,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005f02: fc cld +ffffffff80005f03: e8 a8 ef ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005f08: 58 pop %rax +ffffffff80005f09: 5a pop %rdx +ffffffff80005f0a: 59 pop %rcx +ffffffff80005f0b: 5e pop %rsi +ffffffff80005f0c: 5f pop %rdi +ffffffff80005f0d: 41 58 pop %r8 +ffffffff80005f0f: 41 59 pop %r9 +ffffffff80005f11: 41 5a pop %r10 +ffffffff80005f13: 41 5b pop %r11 +ffffffff80005f15: 48 cf iretq +ffffffff80005f17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005f1e: 00 00 + +ffffffff80005f20 <_ZN3Hal16ExceptionHandlerILm29EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005f20: f3 0f 1e fa endbr64 +ffffffff80005f24: 41 53 push %r11 +ffffffff80005f26: 41 52 push %r10 +ffffffff80005f28: 41 51 push %r9 +ffffffff80005f2a: 41 50 push %r8 +ffffffff80005f2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005f2d: 48 8b 3d b4 61 00 00 mov 0x61b4(%rip),%rdi # ffffffff8000c0e8 <_ZN3Hal16ExceptionStringsE+0xe8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005f34: 56 push %rsi +ffffffff80005f35: 51 push %rcx +ffffffff80005f36: 52 push %rdx +ffffffff80005f37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005f38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005f3d: c6 44 24 70 1d movb $0x1d,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005f42: fc cld +ffffffff80005f43: e8 68 ef ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005f48: 58 pop %rax +ffffffff80005f49: 5a pop %rdx +ffffffff80005f4a: 59 pop %rcx +ffffffff80005f4b: 5e pop %rsi +ffffffff80005f4c: 5f pop %rdi +ffffffff80005f4d: 41 58 pop %r8 +ffffffff80005f4f: 41 59 pop %r9 +ffffffff80005f51: 41 5a pop %r10 +ffffffff80005f53: 41 5b pop %r11 +ffffffff80005f55: 48 cf iretq +ffffffff80005f57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005f5e: 00 00 + +ffffffff80005f60 <_ZN3Hal16ExceptionHandlerILm30EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005f60: f3 0f 1e fa endbr64 +ffffffff80005f64: 41 53 push %r11 +ffffffff80005f66: 41 52 push %r10 +ffffffff80005f68: 41 51 push %r9 +ffffffff80005f6a: 41 50 push %r8 +ffffffff80005f6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005f6d: 48 8b 3d 7c 61 00 00 mov 0x617c(%rip),%rdi # ffffffff8000c0f0 <_ZN3Hal16ExceptionStringsE+0xf0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005f74: 56 push %rsi +ffffffff80005f75: 51 push %rcx +ffffffff80005f76: 52 push %rdx +ffffffff80005f77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005f78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005f7d: c6 44 24 70 1e movb $0x1e,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005f82: fc cld +ffffffff80005f83: e8 28 ef ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005f88: 58 pop %rax +ffffffff80005f89: 5a pop %rdx +ffffffff80005f8a: 59 pop %rcx +ffffffff80005f8b: 5e pop %rsi +ffffffff80005f8c: 5f pop %rdi +ffffffff80005f8d: 41 58 pop %r8 +ffffffff80005f8f: 41 59 pop %r9 +ffffffff80005f91: 41 5a pop %r10 +ffffffff80005f93: 41 5b pop %r11 +ffffffff80005f95: 48 cf iretq +ffffffff80005f97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005f9e: 00 00 + +ffffffff80005fa0 <_ZN3Hal10SetHandlerILi23ELi31EE3runEv>: + }; + } + + template + struct SetHandler { + static void run() { +ffffffff80005fa0: f3 0f 1e fa endbr64 + InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor)); +ffffffff80005fa4: 48 8b 05 f7 b3 0d 00 mov 0xdb3f7(%rip),%rax # ffffffff800e13a2 <_ZN3Hal4IDTRE+0x2> + uint64_t offset = (uint64_t)handler; +ffffffff80005fab: 48 c7 c2 a0 5d 00 80 mov $0xffffffff80005da0,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80005fb2: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80005fb5: 66 89 90 70 01 00 00 mov %dx,0x170(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80005fbc: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80005fc0: 48 c1 ee 10 shr $0x10,%rsi + InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor)); +ffffffff80005fc4: 48 8d 88 e0 01 00 00 lea 0x1e0(%rax),%rcx + *ptr = InterruptDescriptor { +ffffffff80005fcb: 89 90 78 01 00 00 mov %edx,0x178(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80005fd1: 48 c7 c2 e0 5d 00 80 mov $0xffffffff80005de0,%rdx + *ptr = InterruptDescriptor { +ffffffff80005fd8: 66 89 b0 76 01 00 00 mov %si,0x176(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80005fdf: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80005fe2: 66 89 90 80 01 00 00 mov %dx,0x180(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80005fe9: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80005fed: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80005ff1: 89 90 88 01 00 00 mov %edx,0x188(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80005ff7: 48 c7 c2 20 5e 00 80 mov $0xffffffff80005e20,%rdx + *ptr = InterruptDescriptor { +ffffffff80005ffe: 66 89 b0 86 01 00 00 mov %si,0x186(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006005: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006008: 66 89 90 90 01 00 00 mov %dx,0x190(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000600f: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006013: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006017: 89 90 98 01 00 00 mov %edx,0x198(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff8000601d: 48 c7 c2 60 5e 00 80 mov $0xffffffff80005e60,%rdx + *ptr = InterruptDescriptor { +ffffffff80006024: 66 89 b0 96 01 00 00 mov %si,0x196(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000602b: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000602e: 66 89 90 a0 01 00 00 mov %dx,0x1a0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006035: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006039: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff8000603d: 89 90 a8 01 00 00 mov %edx,0x1a8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006043: 48 c7 c2 a0 5e 00 80 mov $0xffffffff80005ea0,%rdx + *ptr = InterruptDescriptor { +ffffffff8000604a: 66 89 b0 a6 01 00 00 mov %si,0x1a6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006051: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006054: 66 89 90 b0 01 00 00 mov %dx,0x1b0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000605b: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000605f: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006063: 89 90 b8 01 00 00 mov %edx,0x1b8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006069: 48 c7 c2 e0 5e 00 80 mov $0xffffffff80005ee0,%rdx + *ptr = InterruptDescriptor { +ffffffff80006070: 66 89 b0 b6 01 00 00 mov %si,0x1b6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006077: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000607a: 66 89 90 c0 01 00 00 mov %dx,0x1c0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006081: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006085: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006089: 89 90 c8 01 00 00 mov %edx,0x1c8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff8000608f: 48 c7 c2 20 5f 00 80 mov $0xffffffff80005f20,%rdx + *ptr = InterruptDescriptor { +ffffffff80006096: 66 89 b0 c6 01 00 00 mov %si,0x1c6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000609d: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff800060a0: 66 89 90 d0 01 00 00 mov %dx,0x1d0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800060a7: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800060ab: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff800060af: c7 80 72 01 00 00 08 movl $0x8f000008,0x172(%rax) +ffffffff800060b6: 00 00 8f +ffffffff800060b9: c7 80 7c 01 00 00 00 movl $0x0,0x17c(%rax) +ffffffff800060c0: 00 00 00 +ffffffff800060c3: c7 80 82 01 00 00 08 movl $0x8f000008,0x182(%rax) +ffffffff800060ca: 00 00 8f +ffffffff800060cd: c7 80 8c 01 00 00 00 movl $0x0,0x18c(%rax) +ffffffff800060d4: 00 00 00 +ffffffff800060d7: c7 80 92 01 00 00 08 movl $0x8f000008,0x192(%rax) +ffffffff800060de: 00 00 8f +ffffffff800060e1: c7 80 9c 01 00 00 00 movl $0x0,0x19c(%rax) +ffffffff800060e8: 00 00 00 +ffffffff800060eb: c7 80 a2 01 00 00 08 movl $0x8f000008,0x1a2(%rax) +ffffffff800060f2: 00 00 8f +ffffffff800060f5: c7 80 ac 01 00 00 00 movl $0x0,0x1ac(%rax) +ffffffff800060fc: 00 00 00 +ffffffff800060ff: c7 80 b2 01 00 00 08 movl $0x8f000008,0x1b2(%rax) +ffffffff80006106: 00 00 8f +ffffffff80006109: c7 80 bc 01 00 00 00 movl $0x0,0x1bc(%rax) +ffffffff80006110: 00 00 00 +ffffffff80006113: c7 80 c2 01 00 00 08 movl $0x8f000008,0x1c2(%rax) +ffffffff8000611a: 00 00 8f +ffffffff8000611d: c7 80 cc 01 00 00 00 movl $0x0,0x1cc(%rax) +ffffffff80006124: 00 00 00 +ffffffff80006127: c7 80 d2 01 00 00 08 movl $0x8f000008,0x1d2(%rax) +ffffffff8000612e: 00 00 8f +ffffffff80006131: 89 90 d8 01 00 00 mov %edx,0x1d8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006137: 48 c7 c2 60 5f 00 80 mov $0xffffffff80005f60,%rdx + *ptr = InterruptDescriptor { +ffffffff8000613e: 66 89 90 e0 01 00 00 mov %dx,0x1e0(%rax) +ffffffff80006145: 66 89 b0 d6 01 00 00 mov %si,0x1d6(%rax) +ffffffff8000614c: c7 80 dc 01 00 00 00 movl $0x0,0x1dc(%rax) +ffffffff80006153: 00 00 00 +ffffffff80006156: c7 80 e2 01 00 00 08 movl $0x8f000008,0x1e2(%rax) +ffffffff8000615d: 00 00 8f + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006160: 48 89 d0 mov %rdx,%rax + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006163: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006167: 48 c1 e8 10 shr $0x10,%rax + *ptr = InterruptDescriptor { +ffffffff8000616b: 89 51 08 mov %edx,0x8(%rcx) +ffffffff8000616e: 66 89 41 06 mov %ax,0x6(%rcx) +ffffffff80006172: c7 41 0c 00 00 00 00 movl $0x0,0xc(%rcx) + IDTEncodeInterrupt(I, (void*)&ExceptionHandler, TrapGate); + SetHandler::run(); + } +ffffffff80006179: c3 ret +ffffffff8000617a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff80006180 <_ZN3Hal10SetHandlerILi11ELi31EE3runEv>: + static void run() { +ffffffff80006180: f3 0f 1e fa endbr64 + InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor)); +ffffffff80006184: 48 8b 05 17 b2 0d 00 mov 0xdb217(%rip),%rax # ffffffff800e13a2 <_ZN3Hal4IDTRE+0x2> + uint64_t offset = (uint64_t)handler; +ffffffff8000618b: 48 c7 c2 a0 5a 00 80 mov $0xffffffff80005aa0,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006192: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006195: 66 89 90 b0 00 00 00 mov %dx,0xb0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000619c: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061a0: 48 c1 ee 10 shr $0x10,%rsi + InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor)); +ffffffff800061a4: 48 8d 88 60 01 00 00 lea 0x160(%rax),%rcx + *ptr = InterruptDescriptor { +ffffffff800061ab: 89 90 b8 00 00 00 mov %edx,0xb8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff800061b1: 48 c7 c2 e0 5a 00 80 mov $0xffffffff80005ae0,%rdx + *ptr = InterruptDescriptor { +ffffffff800061b8: 66 89 b0 b6 00 00 00 mov %si,0xb6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061bf: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff800061c2: 66 89 90 c0 00 00 00 mov %dx,0xc0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800061c9: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061cd: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff800061d1: 89 90 c8 00 00 00 mov %edx,0xc8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff800061d7: 48 c7 c2 20 5b 00 80 mov $0xffffffff80005b20,%rdx + *ptr = InterruptDescriptor { +ffffffff800061de: 66 89 b0 c6 00 00 00 mov %si,0xc6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061e5: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff800061e8: 66 89 90 d0 00 00 00 mov %dx,0xd0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800061ef: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061f3: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff800061f7: 89 90 d8 00 00 00 mov %edx,0xd8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff800061fd: 48 c7 c2 60 5b 00 80 mov $0xffffffff80005b60,%rdx + *ptr = InterruptDescriptor { +ffffffff80006204: 66 89 b0 d6 00 00 00 mov %si,0xd6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000620b: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000620e: 66 89 90 e0 00 00 00 mov %dx,0xe0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006215: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006219: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff8000621d: 89 90 e8 00 00 00 mov %edx,0xe8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006223: 48 c7 c2 a0 5b 00 80 mov $0xffffffff80005ba0,%rdx + *ptr = InterruptDescriptor { +ffffffff8000622a: 66 89 b0 e6 00 00 00 mov %si,0xe6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006231: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006234: 66 89 90 f0 00 00 00 mov %dx,0xf0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000623b: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000623f: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006243: 89 90 f8 00 00 00 mov %edx,0xf8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006249: 48 c7 c2 e0 5b 00 80 mov $0xffffffff80005be0,%rdx + *ptr = InterruptDescriptor { +ffffffff80006250: 66 89 b0 f6 00 00 00 mov %si,0xf6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006257: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000625a: 66 89 90 00 01 00 00 mov %dx,0x100(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006261: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006265: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006269: 89 90 08 01 00 00 mov %edx,0x108(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff8000626f: 48 c7 c2 20 5c 00 80 mov $0xffffffff80005c20,%rdx + *ptr = InterruptDescriptor { +ffffffff80006276: 66 89 b0 06 01 00 00 mov %si,0x106(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000627d: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006280: 66 89 90 10 01 00 00 mov %dx,0x110(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006287: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000628b: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff8000628f: c7 80 b2 00 00 00 08 movl $0x8f000008,0xb2(%rax) +ffffffff80006296: 00 00 8f +ffffffff80006299: c7 80 bc 00 00 00 00 movl $0x0,0xbc(%rax) +ffffffff800062a0: 00 00 00 +ffffffff800062a3: c7 80 c2 00 00 00 08 movl $0x8f000008,0xc2(%rax) +ffffffff800062aa: 00 00 8f +ffffffff800062ad: c7 80 cc 00 00 00 00 movl $0x0,0xcc(%rax) +ffffffff800062b4: 00 00 00 +ffffffff800062b7: c7 80 d2 00 00 00 08 movl $0x8f000008,0xd2(%rax) +ffffffff800062be: 00 00 8f +ffffffff800062c1: c7 80 dc 00 00 00 00 movl $0x0,0xdc(%rax) +ffffffff800062c8: 00 00 00 +ffffffff800062cb: c7 80 e2 00 00 00 08 movl $0x8f000008,0xe2(%rax) +ffffffff800062d2: 00 00 8f +ffffffff800062d5: c7 80 ec 00 00 00 00 movl $0x0,0xec(%rax) +ffffffff800062dc: 00 00 00 +ffffffff800062df: c7 80 f2 00 00 00 08 movl $0x8f000008,0xf2(%rax) +ffffffff800062e6: 00 00 8f +ffffffff800062e9: c7 80 fc 00 00 00 00 movl $0x0,0xfc(%rax) +ffffffff800062f0: 00 00 00 +ffffffff800062f3: c7 80 02 01 00 00 08 movl $0x8f000008,0x102(%rax) +ffffffff800062fa: 00 00 8f +ffffffff800062fd: c7 80 0c 01 00 00 00 movl $0x0,0x10c(%rax) +ffffffff80006304: 00 00 00 +ffffffff80006307: c7 80 12 01 00 00 08 movl $0x8f000008,0x112(%rax) +ffffffff8000630e: 00 00 8f +ffffffff80006311: 89 90 18 01 00 00 mov %edx,0x118(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006317: 48 c7 c2 60 5c 00 80 mov $0xffffffff80005c60,%rdx + *ptr = InterruptDescriptor { +ffffffff8000631e: 66 89 b0 16 01 00 00 mov %si,0x116(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006325: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006328: 66 89 90 20 01 00 00 mov %dx,0x120(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000632f: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006333: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006337: 89 90 28 01 00 00 mov %edx,0x128(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff8000633d: 48 c7 c2 a0 5c 00 80 mov $0xffffffff80005ca0,%rdx + *ptr = InterruptDescriptor { +ffffffff80006344: 66 89 b0 26 01 00 00 mov %si,0x126(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000634b: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000634e: 66 89 90 30 01 00 00 mov %dx,0x130(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006355: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006359: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff8000635d: 89 90 38 01 00 00 mov %edx,0x138(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006363: 48 c7 c2 e0 5c 00 80 mov $0xffffffff80005ce0,%rdx + *ptr = InterruptDescriptor { +ffffffff8000636a: 66 89 b0 36 01 00 00 mov %si,0x136(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006371: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006374: 66 89 90 40 01 00 00 mov %dx,0x140(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000637b: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000637f: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006383: 89 90 48 01 00 00 mov %edx,0x148(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006389: 48 c7 c2 20 5d 00 80 mov $0xffffffff80005d20,%rdx + *ptr = InterruptDescriptor { +ffffffff80006390: 66 89 b0 46 01 00 00 mov %si,0x146(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006397: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000639a: 66 89 90 50 01 00 00 mov %dx,0x150(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800063a1: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800063a5: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff800063a9: 89 90 58 01 00 00 mov %edx,0x158(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff800063af: 48 c7 c2 60 5d 00 80 mov $0xffffffff80005d60,%rdx + *ptr = InterruptDescriptor { +ffffffff800063b6: 66 89 90 60 01 00 00 mov %dx,0x160(%rax) +ffffffff800063bd: c7 80 1c 01 00 00 00 movl $0x0,0x11c(%rax) +ffffffff800063c4: 00 00 00 +ffffffff800063c7: c7 80 22 01 00 00 08 movl $0x8f000008,0x122(%rax) +ffffffff800063ce: 00 00 8f +ffffffff800063d1: c7 80 2c 01 00 00 00 movl $0x0,0x12c(%rax) +ffffffff800063d8: 00 00 00 +ffffffff800063db: c7 80 32 01 00 00 08 movl $0x8f000008,0x132(%rax) +ffffffff800063e2: 00 00 8f +ffffffff800063e5: c7 80 3c 01 00 00 00 movl $0x0,0x13c(%rax) +ffffffff800063ec: 00 00 00 +ffffffff800063ef: c7 80 42 01 00 00 08 movl $0x8f000008,0x142(%rax) +ffffffff800063f6: 00 00 8f +ffffffff800063f9: c7 80 4c 01 00 00 00 movl $0x0,0x14c(%rax) +ffffffff80006400: 00 00 00 +ffffffff80006403: c7 80 52 01 00 00 08 movl $0x8f000008,0x152(%rax) +ffffffff8000640a: 00 00 8f +ffffffff8000640d: 66 89 b0 56 01 00 00 mov %si,0x156(%rax) +ffffffff80006414: c7 80 5c 01 00 00 00 movl $0x0,0x15c(%rax) +ffffffff8000641b: 00 00 00 +ffffffff8000641e: c7 80 62 01 00 00 08 movl $0x8f000008,0x162(%rax) +ffffffff80006425: 00 00 8f + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006428: 48 89 d0 mov %rdx,%rax + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000642b: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000642f: 48 c1 e8 10 shr $0x10,%rax + *ptr = InterruptDescriptor { +ffffffff80006433: 89 51 08 mov %edx,0x8(%rcx) +ffffffff80006436: 66 89 41 06 mov %ax,0x6(%rcx) +ffffffff8000643a: c7 41 0c 00 00 00 00 movl $0x0,0xc(%rcx) + SetHandler::run(); +ffffffff80006441: e9 5a fb ff ff jmp ffffffff80005fa0 <_ZN3Hal10SetHandlerILi23ELi31EE3runEv> +ffffffff80006446: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000644d: 00 00 00 + +ffffffff80006450 <_ZN3Hal13IDTInitializeEv>: + }; + + template + struct SetHandler {static void run() {}}; + + void IDTInitialize() { +ffffffff80006450: f3 0f 1e fa endbr64 +ffffffff80006454: 48 83 ec 08 sub $0x8,%rsp + IDT = (InterruptDescriptor*)Memory::g_heap->Request(4096); +ffffffff80006458: 48 8b 3d 71 b3 0d 00 mov 0xdb371(%rip),%rdi # ffffffff800e17d0 <_ZN6Memory6g_heapE> +ffffffff8000645f: be 00 10 00 00 mov $0x1000,%esi +ffffffff80006464: e8 57 07 00 00 call ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm> + IDTR.Limit = 0x0FF; +ffffffff80006469: b8 ff 00 00 00 mov $0xff,%eax + IDTR.Base = (uint64_t)&IDT; +ffffffff8000646e: 48 c7 05 29 af 0d 00 movq $0xffffffff800e13b0,0xdaf29(%rip) # ffffffff800e13a2 <_ZN3Hal4IDTRE+0x2> +ffffffff80006475: b0 13 0e 80 + IDTR.Limit = 0x0FF; +ffffffff80006479: 66 89 05 20 af 0d 00 mov %ax,0xdaf20(%rip) # ffffffff800e13a0 <_ZN3Hal4IDTRE> + uint64_t offset = (uint64_t)handler; +ffffffff80006480: 48 c7 c0 e0 57 00 80 mov $0xffffffff800057e0,%rax + *ptr = InterruptDescriptor { +ffffffff80006487: 66 89 05 22 af 0d 00 mov %ax,0xdaf22(%rip) # ffffffff800e13b0 <_ZN3Hal3IDTE> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000648e: 48 89 c2 mov %rax,%rdx + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006491: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006495: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006499: 89 05 19 af 0d 00 mov %eax,0xdaf19(%rip) # ffffffff800e13b8 <_ZN3Hal3IDTE+0x8> + uint64_t offset = (uint64_t)handler; +ffffffff8000649f: 48 c7 c0 20 58 00 80 mov $0xffffffff80005820,%rax + *ptr = InterruptDescriptor { +ffffffff800064a6: 66 89 15 09 af 0d 00 mov %dx,0xdaf09(%rip) # ffffffff800e13b6 <_ZN3Hal3IDTE+0x6> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064ad: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff800064b0: 66 89 05 09 af 0d 00 mov %ax,0xdaf09(%rip) # ffffffff800e13c0 <_ZN3Lib6outputE> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800064b7: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064bb: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff800064bf: 89 05 03 af 0d 00 mov %eax,0xdaf03(%rip) # ffffffff800e13c8 <_ZN3Lib6outputE+0x8> + uint64_t offset = (uint64_t)handler; +ffffffff800064c5: 48 c7 c0 60 58 00 80 mov $0xffffffff80005860,%rax + *ptr = InterruptDescriptor { +ffffffff800064cc: 66 89 15 f3 ae 0d 00 mov %dx,0xdaef3(%rip) # ffffffff800e13c6 <_ZN3Lib6outputE+0x6> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064d3: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff800064d6: 66 89 05 f3 ae 0d 00 mov %ax,0xdaef3(%rip) # ffffffff800e13d0 <_ZN3Lib6outputE+0x10> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800064dd: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064e1: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff800064e5: 89 05 ed ae 0d 00 mov %eax,0xdaeed(%rip) # ffffffff800e13d8 <_ZN3Lib6outputE+0x18> + uint64_t offset = (uint64_t)handler; +ffffffff800064eb: 48 c7 c0 a0 58 00 80 mov $0xffffffff800058a0,%rax + *ptr = InterruptDescriptor { +ffffffff800064f2: 66 89 15 dd ae 0d 00 mov %dx,0xdaedd(%rip) # ffffffff800e13d6 <_ZN3Lib6outputE+0x16> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064f9: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff800064fc: 66 89 05 dd ae 0d 00 mov %ax,0xdaedd(%rip) # ffffffff800e13e0 <_ZN3Lib6outputE+0x20> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006503: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006507: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff8000650b: 89 05 d7 ae 0d 00 mov %eax,0xdaed7(%rip) # ffffffff800e13e8 <_ZN3Lib6outputE+0x28> + uint64_t offset = (uint64_t)handler; +ffffffff80006511: 48 c7 c0 e0 58 00 80 mov $0xffffffff800058e0,%rax + *ptr = InterruptDescriptor { +ffffffff80006518: 66 89 15 c7 ae 0d 00 mov %dx,0xdaec7(%rip) # ffffffff800e13e6 <_ZN3Lib6outputE+0x26> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000651f: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff80006522: 66 89 05 c7 ae 0d 00 mov %ax,0xdaec7(%rip) # ffffffff800e13f0 <_ZN3Lib6outputE+0x30> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006529: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000652d: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006531: 89 05 c1 ae 0d 00 mov %eax,0xdaec1(%rip) # ffffffff800e13f8 <_ZN3Lib6outputE+0x38> + uint64_t offset = (uint64_t)handler; +ffffffff80006537: 48 c7 c0 20 59 00 80 mov $0xffffffff80005920,%rax + *ptr = InterruptDescriptor { +ffffffff8000653e: 66 89 15 b1 ae 0d 00 mov %dx,0xdaeb1(%rip) # ffffffff800e13f6 <_ZN3Lib6outputE+0x36> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006545: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff80006548: 66 89 05 b1 ae 0d 00 mov %ax,0xdaeb1(%rip) # ffffffff800e1400 <_ZN3Lib6outputE+0x40> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000654f: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006553: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006557: 89 05 ab ae 0d 00 mov %eax,0xdaeab(%rip) # ffffffff800e1408 <_ZN3Lib6outputE+0x48> + uint64_t offset = (uint64_t)handler; +ffffffff8000655d: 48 c7 c0 60 59 00 80 mov $0xffffffff80005960,%rax + *ptr = InterruptDescriptor { +ffffffff80006564: 66 89 15 9b ae 0d 00 mov %dx,0xdae9b(%rip) # ffffffff800e1406 <_ZN3Lib6outputE+0x46> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000656b: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff8000656e: c7 05 3a ae 0d 00 08 movl $0x8f000008,0xdae3a(%rip) # ffffffff800e13b2 <_ZN3Hal3IDTE+0x2> +ffffffff80006575: 00 00 8f + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006578: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff8000657c: c7 05 36 ae 0d 00 00 movl $0x0,0xdae36(%rip) # ffffffff800e13bc <_ZN3Hal3IDTE+0xc> +ffffffff80006583: 00 00 00 +ffffffff80006586: c7 05 32 ae 0d 00 08 movl $0x8f000008,0xdae32(%rip) # ffffffff800e13c2 <_ZN3Lib6outputE+0x2> +ffffffff8000658d: 00 00 8f +ffffffff80006590: c7 05 32 ae 0d 00 00 movl $0x0,0xdae32(%rip) # ffffffff800e13cc <_ZN3Lib6outputE+0xc> +ffffffff80006597: 00 00 00 +ffffffff8000659a: c7 05 2e ae 0d 00 08 movl $0x8f000008,0xdae2e(%rip) # ffffffff800e13d2 <_ZN3Lib6outputE+0x12> +ffffffff800065a1: 00 00 8f +ffffffff800065a4: c7 05 2e ae 0d 00 00 movl $0x0,0xdae2e(%rip) # ffffffff800e13dc <_ZN3Lib6outputE+0x1c> +ffffffff800065ab: 00 00 00 +ffffffff800065ae: c7 05 2a ae 0d 00 08 movl $0x8f000008,0xdae2a(%rip) # ffffffff800e13e2 <_ZN3Lib6outputE+0x22> +ffffffff800065b5: 00 00 8f +ffffffff800065b8: c7 05 2a ae 0d 00 00 movl $0x0,0xdae2a(%rip) # ffffffff800e13ec <_ZN3Lib6outputE+0x2c> +ffffffff800065bf: 00 00 00 +ffffffff800065c2: c7 05 26 ae 0d 00 08 movl $0x8f000008,0xdae26(%rip) # ffffffff800e13f2 <_ZN3Lib6outputE+0x32> +ffffffff800065c9: 00 00 8f +ffffffff800065cc: c7 05 26 ae 0d 00 00 movl $0x0,0xdae26(%rip) # ffffffff800e13fc <_ZN3Lib6outputE+0x3c> +ffffffff800065d3: 00 00 00 +ffffffff800065d6: c7 05 22 ae 0d 00 08 movl $0x8f000008,0xdae22(%rip) # ffffffff800e1402 <_ZN3Lib6outputE+0x42> +ffffffff800065dd: 00 00 8f +ffffffff800065e0: c7 05 22 ae 0d 00 00 movl $0x0,0xdae22(%rip) # ffffffff800e140c <_ZN3Lib6outputE+0x4c> +ffffffff800065e7: 00 00 00 +ffffffff800065ea: 66 89 05 1f ae 0d 00 mov %ax,0xdae1f(%rip) # ffffffff800e1410 <_ZN3Lib6outputE+0x50> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800065f1: 48 c1 e8 20 shr $0x20,%rax + *ptr = InterruptDescriptor { +ffffffff800065f5: 89 05 1d ae 0d 00 mov %eax,0xdae1d(%rip) # ffffffff800e1418 <_ZN3Lib6outputE+0x58> + uint64_t offset = (uint64_t)handler; +ffffffff800065fb: 48 c7 c0 a0 59 00 80 mov $0xffffffff800059a0,%rax + *ptr = InterruptDescriptor { +ffffffff80006602: 66 89 15 0d ae 0d 00 mov %dx,0xdae0d(%rip) # ffffffff800e1416 <_ZN3Lib6outputE+0x56> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006609: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff8000660c: 66 89 05 0d ae 0d 00 mov %ax,0xdae0d(%rip) # ffffffff800e1420 <_ZN3Lib6outputE+0x60> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006613: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006617: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff8000661b: 89 05 07 ae 0d 00 mov %eax,0xdae07(%rip) # ffffffff800e1428 <_ZN3Lib6outputE+0x68> + uint64_t offset = (uint64_t)handler; +ffffffff80006621: 48 c7 c0 e0 59 00 80 mov $0xffffffff800059e0,%rax + *ptr = InterruptDescriptor { +ffffffff80006628: 66 89 15 f7 ad 0d 00 mov %dx,0xdadf7(%rip) # ffffffff800e1426 <_ZN3Lib6outputE+0x66> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000662f: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff80006632: 66 89 05 f7 ad 0d 00 mov %ax,0xdadf7(%rip) # ffffffff800e1430 <_ZN3Lib6outputE+0x70> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006639: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000663d: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006641: 89 05 f1 ad 0d 00 mov %eax,0xdadf1(%rip) # ffffffff800e1438 <_ZN3Lib6outputE+0x78> + uint64_t offset = (uint64_t)handler; +ffffffff80006647: 48 c7 c0 20 5a 00 80 mov $0xffffffff80005a20,%rax + *ptr = InterruptDescriptor { +ffffffff8000664e: 66 89 15 e1 ad 0d 00 mov %dx,0xdade1(%rip) # ffffffff800e1436 <_ZN3Lib6outputE+0x76> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006655: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff80006658: 66 89 05 e1 ad 0d 00 mov %ax,0xdade1(%rip) # ffffffff800e1440 <_ZN3Lib6outputE+0x80> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000665f: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006663: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006667: 89 05 db ad 0d 00 mov %eax,0xdaddb(%rip) # ffffffff800e1448 <_ZN3Lib6outputE+0x88> + uint64_t offset = (uint64_t)handler; +ffffffff8000666d: 48 c7 c0 60 5a 00 80 mov $0xffffffff80005a60,%rax + *ptr = InterruptDescriptor { +ffffffff80006674: 66 89 15 cb ad 0d 00 mov %dx,0xdadcb(%rip) # ffffffff800e1446 <_ZN3Lib6outputE+0x86> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000667b: 48 89 c2 mov %rax,%rdx +ffffffff8000667e: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006682: 66 89 05 c7 ad 0d 00 mov %ax,0xdadc7(%rip) # ffffffff800e1450 <_ZN3Lib6outputE+0x90> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006689: 48 c1 e8 20 shr $0x20,%rax + *ptr = InterruptDescriptor { +ffffffff8000668d: 66 89 15 c2 ad 0d 00 mov %dx,0xdadc2(%rip) # ffffffff800e1456 <_ZN3Lib6outputE+0x96> +ffffffff80006694: 89 05 be ad 0d 00 mov %eax,0xdadbe(%rip) # ffffffff800e1458 <_ZN3Lib6outputE+0x98> +ffffffff8000669a: c7 05 6e ad 0d 00 08 movl $0x8f000008,0xdad6e(%rip) # ffffffff800e1412 <_ZN3Lib6outputE+0x52> +ffffffff800066a1: 00 00 8f +ffffffff800066a4: c7 05 6e ad 0d 00 00 movl $0x0,0xdad6e(%rip) # ffffffff800e141c <_ZN3Lib6outputE+0x5c> +ffffffff800066ab: 00 00 00 +ffffffff800066ae: c7 05 6a ad 0d 00 08 movl $0x8f000008,0xdad6a(%rip) # ffffffff800e1422 <_ZN3Lib6outputE+0x62> +ffffffff800066b5: 00 00 8f +ffffffff800066b8: c7 05 6a ad 0d 00 00 movl $0x0,0xdad6a(%rip) # ffffffff800e142c <_ZN3Lib6outputE+0x6c> +ffffffff800066bf: 00 00 00 +ffffffff800066c2: c7 05 66 ad 0d 00 08 movl $0x8f000008,0xdad66(%rip) # ffffffff800e1432 <_ZN3Lib6outputE+0x72> +ffffffff800066c9: 00 00 8f +ffffffff800066cc: c7 05 66 ad 0d 00 00 movl $0x0,0xdad66(%rip) # ffffffff800e143c <_ZN3Lib6outputE+0x7c> +ffffffff800066d3: 00 00 00 +ffffffff800066d6: c7 05 62 ad 0d 00 08 movl $0x8f000008,0xdad62(%rip) # ffffffff800e1442 <_ZN3Lib6outputE+0x82> +ffffffff800066dd: 00 00 8f +ffffffff800066e0: c7 05 62 ad 0d 00 00 movl $0x0,0xdad62(%rip) # ffffffff800e144c <_ZN3Lib6outputE+0x8c> +ffffffff800066e7: 00 00 00 +ffffffff800066ea: c7 05 5e ad 0d 00 08 movl $0x8f000008,0xdad5e(%rip) # ffffffff800e1452 <_ZN3Lib6outputE+0x92> +ffffffff800066f1: 00 00 8f +ffffffff800066f4: c7 05 5e ad 0d 00 00 movl $0x0,0xdad5e(%rip) # ffffffff800e145c <_ZN3Lib6outputE+0x9c> +ffffffff800066fb: 00 00 00 + SetHandler::run(); +ffffffff800066fe: e8 7d fa ff ff call ffffffff80006180 <_ZN3Hal10SetHandlerILi11ELi31EE3runEv> +ffffffff80006703: 48 c7 c7 98 bd 00 80 mov $0xffffffff8000bd98,%rdi +ffffffff8000670a: e8 91 08 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000670f: 48 c7 c7 c0 b9 00 80 mov $0xffffffff8000b9c0,%rdi +ffffffff80006716: e8 85 08 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + asm("lidt %0" : : "m"(idtr)); +ffffffff8000671b: 0f 01 1d 7e ac 0d 00 lidt 0xdac7e(%rip) # ffffffff800e13a0 <_ZN3Hal4IDTRE> +ffffffff80006722: 48 c7 c7 d8 bd 00 80 mov $0xffffffff8000bdd8,%rdi +ffffffff80006729: e8 72 08 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000672e: 48 c7 c7 c0 b9 00 80 mov $0xffffffff8000b9c0,%rdi + kout << "HardwareAbstraction: Created exception interrupt vectors" << "\n"; + + LoadIDT(IDTR); + + kout << "HardwareAbstraction: Loaded new IDT" << "\n"; + } +ffffffff80006735: 48 83 c4 08 add $0x8,%rsp +ffffffff80006739: e9 62 08 00 00 jmp ffffffff80006fa0 <_ZN2Kt5PrintEPKc> +ffffffff8000673e: 66 90 xchg %ax,%ax + +ffffffff80006740 : +// They CAN be moved to a different .cpp file. +#include + +extern "C" { + + void *memcpy(void *dest, const void *src, std::size_t n) { +ffffffff80006740: f3 0f 1e fa endbr64 +ffffffff80006744: 48 89 f8 mov %rdi,%rax + std::uint8_t *pdest = static_cast(dest); + const std::uint8_t *psrc = static_cast(src); + + for (std::size_t i = 0; i < n; i++) { +ffffffff80006747: 48 85 d2 test %rdx,%rdx +ffffffff8000674a: 74 16 je ffffffff80006762 +ffffffff8000674c: 31 c9 xor %ecx,%ecx +ffffffff8000674e: 66 90 xchg %ax,%ax + pdest[i] = psrc[i]; +ffffffff80006750: 44 0f b6 04 0e movzbl (%rsi,%rcx,1),%r8d +ffffffff80006755: 44 88 04 08 mov %r8b,(%rax,%rcx,1) + for (std::size_t i = 0; i < n; i++) { +ffffffff80006759: 48 83 c1 01 add $0x1,%rcx +ffffffff8000675d: 48 39 ca cmp %rcx,%rdx +ffffffff80006760: 75 ee jne ffffffff80006750 + } + + return dest; + } +ffffffff80006762: c3 ret +ffffffff80006763: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000676a: 00 00 00 +ffffffff8000676d: 0f 1f 00 nopl (%rax) + +ffffffff80006770 : + + void *memset(void *s, int c, std::size_t n) { +ffffffff80006770: f3 0f 1e fa endbr64 +ffffffff80006774: 48 89 f8 mov %rdi,%rax +ffffffff80006777: 48 89 f9 mov %rdi,%rcx +ffffffff8000677a: 48 8d 3c 3a lea (%rdx,%rdi,1),%rdi + std::uint8_t *p = static_cast(s); + + for (std::size_t i = 0; i < n; i++) { + p[i] = static_cast(c); +ffffffff8000677e: 41 89 f0 mov %esi,%r8d + for (std::size_t i = 0; i < n; i++) { +ffffffff80006781: 48 85 d2 test %rdx,%rdx +ffffffff80006784: 74 2a je ffffffff800067b0 +ffffffff80006786: 48 89 fa mov %rdi,%rdx +ffffffff80006789: 48 29 c2 sub %rax,%rdx +ffffffff8000678c: 83 e2 01 and $0x1,%edx +ffffffff8000678f: 74 0f je ffffffff800067a0 +ffffffff80006791: 48 8d 48 01 lea 0x1(%rax),%rcx + p[i] = static_cast(c); +ffffffff80006795: 40 88 30 mov %sil,(%rax) + for (std::size_t i = 0; i < n; i++) { +ffffffff80006798: 48 39 f9 cmp %rdi,%rcx +ffffffff8000679b: 74 14 je ffffffff800067b1 +ffffffff8000679d: 0f 1f 00 nopl (%rax) + p[i] = static_cast(c); +ffffffff800067a0: 44 88 01 mov %r8b,(%rcx) + for (std::size_t i = 0; i < n; i++) { +ffffffff800067a3: 48 83 c1 02 add $0x2,%rcx + p[i] = static_cast(c); +ffffffff800067a7: 44 88 41 ff mov %r8b,-0x1(%rcx) + for (std::size_t i = 0; i < n; i++) { +ffffffff800067ab: 48 39 f9 cmp %rdi,%rcx +ffffffff800067ae: 75 f0 jne ffffffff800067a0 + } + + return s; + } +ffffffff800067b0: c3 ret +ffffffff800067b1: c3 ret +ffffffff800067b2: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800067b9: 00 00 00 +ffffffff800067bc: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff800067c0 <_ZN3Lib13u64_2_basestrEmm.part.0>: + str[si++] = tmp[rdi--]; + str[si] = '\0'; + return str; + } + + char *u64_2_basestr(uint64_t num, size_t radix) +ffffffff800067c0: 48 81 ec 20 01 00 00 sub $0x120,%rsp + + if (!num) { + return (char *)"0"; + } + + char base[] = "0123456789ABCDEFGH"; // IJKLMN .... +ffffffff800067c7: 48 b8 30 31 32 33 34 movabs $0x3736353433323130,%rax +ffffffff800067ce: 35 36 37 +ffffffff800067d1: 48 89 44 24 0d mov %rax,0xd(%rsp) +ffffffff800067d6: 48 b8 38 39 41 42 43 movabs $0x4645444342413938,%rax +ffffffff800067dd: 44 45 46 +ffffffff800067e0: 48 89 44 24 15 mov %rax,0x15(%rsp) + + if (radix < 2 || radix > (sizeof(base) - 1)) +ffffffff800067e5: 48 8d 46 fe lea -0x2(%rsi),%rax + char base[] = "0123456789ABCDEFGH"; // IJKLMN .... +ffffffff800067e9: c7 44 24 1c 46 47 48 movl $0x484746,0x1c(%rsp) +ffffffff800067f0: 00 + if (radix < 2 || radix > (sizeof(base) - 1)) +ffffffff800067f1: 48 83 f8 10 cmp $0x10,%rax +ffffffff800067f5: 0f 87 8d 00 00 00 ja ffffffff80006888 <_ZN3Lib13u64_2_basestrEmm.part.0+0xc8> + + int si = 0; + + char tmp[256]; + int rdi = -1; + while (num) +ffffffff800067fb: 45 31 c0 xor %r8d,%r8d +ffffffff800067fe: 48 c7 c1 c0 13 0e 80 mov $0xffffffff800e13c0,%rcx +ffffffff80006805: 48 85 ff test %rdi,%rdi +ffffffff80006808: 74 65 je ffffffff8000686f <_ZN3Lib13u64_2_basestrEmm.part.0+0xaf> +ffffffff8000680a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + { + tmp[++rdi] = base[num % radix]; +ffffffff80006810: 48 89 f8 mov %rdi,%rax +ffffffff80006813: 31 d2 xor %edx,%edx +ffffffff80006815: 4c 89 c1 mov %r8,%rcx +ffffffff80006818: 48 f7 f6 div %rsi +ffffffff8000681b: 0f b6 54 14 0d movzbl 0xd(%rsp,%rdx,1),%edx +ffffffff80006820: 42 88 54 04 20 mov %dl,0x20(%rsp,%r8,1) + num /= radix; +ffffffff80006825: 48 89 fa mov %rdi,%rdx + while (num) +ffffffff80006828: 4d 8d 40 01 lea 0x1(%r8),%r8 + num /= radix; +ffffffff8000682c: 48 89 c7 mov %rax,%rdi + while (num) +ffffffff8000682f: 48 39 f2 cmp %rsi,%rdx +ffffffff80006832: 73 dc jae ffffffff80006810 <_ZN3Lib13u64_2_basestrEmm.part.0+0x50> +ffffffff80006834: 48 63 c1 movslq %ecx,%rax +ffffffff80006837: 48 8d 7c 24 20 lea 0x20(%rsp),%rdi + tmp[++rdi] = base[num % radix]; +ffffffff8000683c: 31 d2 xor %edx,%edx +ffffffff8000683e: 48 01 f8 add %rdi,%rax +ffffffff80006841: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + } + while (rdi >= 0) + str[si++] = tmp[rdi--]; +ffffffff80006848: 0f b6 30 movzbl (%rax),%esi + while (rdi >= 0) +ffffffff8000684b: 48 83 e8 01 sub $0x1,%rax + str[si++] = tmp[rdi--]; +ffffffff8000684f: 40 88 b2 c0 13 0e 80 mov %sil,-0x7ff1ec40(%rdx) + while (rdi >= 0) +ffffffff80006856: 48 89 d6 mov %rdx,%rsi +ffffffff80006859: 48 83 c2 01 add $0x1,%rdx +ffffffff8000685d: 48 39 ce cmp %rcx,%rsi +ffffffff80006860: 75 e6 jne ffffffff80006848 <_ZN3Lib13u64_2_basestrEmm.part.0+0x88> + str[si] = '\0'; +ffffffff80006862: 83 c1 01 add $0x1,%ecx +ffffffff80006865: 48 63 c9 movslq %ecx,%rcx +ffffffff80006868: 48 81 c1 c0 13 0e 80 add $0xffffffff800e13c0,%rcx +ffffffff8000686f: c6 01 00 movb $0x0,(%rcx) + return str; + } +ffffffff80006872: 48 c7 c0 c0 13 0e 80 mov $0xffffffff800e13c0,%rax +ffffffff80006879: 48 81 c4 20 01 00 00 add $0x120,%rsp +ffffffff80006880: c3 ret +ffffffff80006881: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + str[0] = '\0'; +ffffffff80006888: c6 05 31 ab 0d 00 00 movb $0x0,0xdab31(%rip) # ffffffff800e13c0 <_ZN3Lib6outputE> + } +ffffffff8000688f: 48 c7 c0 c0 13 0e 80 mov $0xffffffff800e13c0,%rax +ffffffff80006896: 48 81 c4 20 01 00 00 add $0x120,%rsp +ffffffff8000689d: c3 ret +ffffffff8000689e: 66 90 xchg %ax,%ax + +ffffffff800068a0 <_ZN3Lib11int2basestrEim>: + { +ffffffff800068a0: f3 0f 1e fa endbr64 + if (!num) { +ffffffff800068a4: 85 ff test %edi,%edi +ffffffff800068a6: 0f 84 d4 00 00 00 je ffffffff80006980 <_ZN3Lib11int2basestrEim+0xe0> + { +ffffffff800068ac: 48 81 ec 20 01 00 00 sub $0x120,%rsp + char base[] = "0123456789ABCDEFGH"; // IJKLMN .... +ffffffff800068b3: 48 b8 30 31 32 33 34 movabs $0x3736353433323130,%rax +ffffffff800068ba: 35 36 37 +ffffffff800068bd: 48 89 44 24 0d mov %rax,0xd(%rsp) +ffffffff800068c2: 48 b8 38 39 41 42 43 movabs $0x4645444342413938,%rax +ffffffff800068c9: 44 45 46 +ffffffff800068cc: 48 89 44 24 15 mov %rax,0x15(%rsp) + if (radix < 2 || radix > (sizeof(base) - 1)) +ffffffff800068d1: 48 8d 46 fe lea -0x2(%rsi),%rax + char base[] = "0123456789ABCDEFGH"; // IJKLMN .... +ffffffff800068d5: c7 44 24 1c 46 47 48 movl $0x484746,0x1c(%rsp) +ffffffff800068dc: 00 + if (radix < 2 || radix > (sizeof(base) - 1)) +ffffffff800068dd: 48 83 f8 10 cmp $0x10,%rax +ffffffff800068e1: 77 7d ja ffffffff80006960 <_ZN3Lib11int2basestrEim+0xc0> + if (num < 0) +ffffffff800068e3: 45 31 c9 xor %r9d,%r9d +ffffffff800068e6: 85 ff test %edi,%edi +ffffffff800068e8: 0f 88 a2 00 00 00 js ffffffff80006990 <_ZN3Lib11int2basestrEim+0xf0> + str[si++] = '-'; +ffffffff800068ee: 31 c9 xor %ecx,%ecx + tmp[++rdi] = base[num % radix]; +ffffffff800068f0: 48 63 c7 movslq %edi,%rax +ffffffff800068f3: 31 d2 xor %edx,%edx +ffffffff800068f5: 49 89 c8 mov %rcx,%r8 +ffffffff800068f8: 48 f7 f6 div %rsi +ffffffff800068fb: 0f b6 54 14 0d movzbl 0xd(%rsp,%rdx,1),%edx + num /= radix; +ffffffff80006900: 89 c7 mov %eax,%edi + tmp[++rdi] = base[num % radix]; +ffffffff80006902: 88 54 0c 20 mov %dl,0x20(%rsp,%rcx,1) + while (num) +ffffffff80006906: 48 8d 49 01 lea 0x1(%rcx),%rcx +ffffffff8000690a: 85 c0 test %eax,%eax +ffffffff8000690c: 75 e2 jne ffffffff800068f0 <_ZN3Lib11int2basestrEim+0x50> +ffffffff8000690e: 48 8d 74 24 20 lea 0x20(%rsp),%rsi +ffffffff80006913: 49 63 c9 movslq %r9d,%rcx +ffffffff80006916: 49 63 c0 movslq %r8d,%rax +ffffffff80006919: 48 01 f0 add %rsi,%rax +ffffffff8000691c: 48 8d 91 c0 13 0e 80 lea -0x7ff1ec40(%rcx),%rdx +ffffffff80006923: 4a 8d b4 01 c1 13 0e lea -0x7ff1ec3f(%rcx,%r8,1),%rsi +ffffffff8000692a: 80 +ffffffff8000692b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + str[si++] = tmp[rdi--]; +ffffffff80006930: 0f b6 08 movzbl (%rax),%ecx + while (rdi >= 0) +ffffffff80006933: 48 83 c2 01 add $0x1,%rdx +ffffffff80006937: 48 83 e8 01 sub $0x1,%rax + str[si++] = tmp[rdi--]; +ffffffff8000693b: 88 4a ff mov %cl,-0x1(%rdx) + while (rdi >= 0) +ffffffff8000693e: 48 39 f2 cmp %rsi,%rdx +ffffffff80006941: 75 ed jne ffffffff80006930 <_ZN3Lib11int2basestrEim+0x90> + str[si] = '\0'; +ffffffff80006943: 43 8d 44 01 01 lea 0x1(%r9,%r8,1),%eax +ffffffff80006948: 48 98 cltq +ffffffff8000694a: c6 80 c0 13 0e 80 00 movb $0x0,-0x7ff1ec40(%rax) + return str; +ffffffff80006951: 48 c7 c0 c0 13 0e 80 mov $0xffffffff800e13c0,%rax + } +ffffffff80006958: 48 81 c4 20 01 00 00 add $0x120,%rsp +ffffffff8000695f: c3 ret + str[0] = '\0'; +ffffffff80006960: c6 05 59 aa 0d 00 00 movb $0x0,0xdaa59(%rip) # ffffffff800e13c0 <_ZN3Lib6outputE> + return str; +ffffffff80006967: 48 c7 c0 c0 13 0e 80 mov $0xffffffff800e13c0,%rax + } +ffffffff8000696e: 48 81 c4 20 01 00 00 add $0x120,%rsp +ffffffff80006975: c3 ret +ffffffff80006976: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000697d: 00 00 00 +ffffffff80006980: 48 c7 c0 c3 bc 00 80 mov $0xffffffff8000bcc3,%rax +ffffffff80006987: c3 ret +ffffffff80006988: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff8000698f: 00 + str[si++] = '-'; +ffffffff80006990: c6 05 29 aa 0d 00 2d movb $0x2d,0xdaa29(%rip) # ffffffff800e13c0 <_ZN3Lib6outputE> + num = -num; +ffffffff80006997: f7 df neg %edi + str[si++] = '-'; +ffffffff80006999: 41 b9 01 00 00 00 mov $0x1,%r9d +ffffffff8000699f: e9 4a ff ff ff jmp ffffffff800068ee <_ZN3Lib11int2basestrEim+0x4e> +ffffffff800069a4: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800069ab: 00 00 00 +ffffffff800069ae: 66 90 xchg %ax,%ax + +ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>: + { +ffffffff800069b0: f3 0f 1e fa endbr64 + if (!num) { +ffffffff800069b4: 48 85 ff test %rdi,%rdi +ffffffff800069b7: 74 07 je ffffffff800069c0 <_ZN3Lib13u64_2_basestrEmm+0x10> +ffffffff800069b9: e9 02 fe ff ff jmp ffffffff800067c0 <_ZN3Lib13u64_2_basestrEmm.part.0> +ffffffff800069be: 66 90 xchg %ax,%ax + } +ffffffff800069c0: 48 c7 c0 c3 bc 00 80 mov $0xffffffff8000bcc3,%rax +ffffffff800069c7: c3 ret +ffffffff800069c8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800069cf: 00 + +ffffffff800069d0 : + +// Extern declarations for global constructors array. +extern void (*__init_array[])(); +extern void (*__init_array_end[])(); + +extern "C" void kmain() { +ffffffff800069d0: f3 0f 1e fa endbr64 +ffffffff800069d4: 53 push %rbx +ffffffff800069d5: 48 83 ec 20 sub $0x20,%rsp + if (LIMINE_BASE_REVISION_SUPPORTED == false) { +ffffffff800069d9: 48 8b 05 40 97 ff ff mov -0x68c0(%rip),%rax # ffffffff80000120 <_ZN12_GLOBAL__N_120limine_base_revisionE+0x10> +ffffffff800069e0: 48 85 c0 test %rax,%rax +ffffffff800069e3: 0f 85 47 01 00 00 jne ffffffff80006b30 + hcf(); + } + + // Call global constructors. + for (std::size_t i = 0; &__init_array[i] != __init_array_end; i++) { +ffffffff800069e9: 48 c7 c0 17 bf 00 80 mov $0xffffffff8000bf17,%rax +ffffffff800069f0: 48 3d 17 bf 00 80 cmp $0xffffffff8000bf17,%rax +ffffffff800069f6: 74 17 je ffffffff80006a0f +ffffffff800069f8: 48 89 c3 mov %rax,%rbx +ffffffff800069fb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + __init_array[i](); +ffffffff80006a00: ff 13 call *(%rbx) + for (std::size_t i = 0; &__init_array[i] != __init_array_end; i++) { +ffffffff80006a02: 48 83 c3 08 add $0x8,%rbx +ffffffff80006a06: 48 81 fb 17 bf 00 80 cmp $0xffffffff8000bf17,%rbx +ffffffff80006a0d: 75 f1 jne ffffffff80006a00 + } + + if (framebuffer_request.response == nullptr +ffffffff80006a0f: 48 8b 05 f2 96 ff ff mov -0x690e(%rip),%rax # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28> + || framebuffer_request.response->framebuffer_count < 1) { +ffffffff80006a16: 48 85 c0 test %rax,%rax +ffffffff80006a19: 0f 84 01 01 00 00 je ffffffff80006b20 +ffffffff80006a1f: 48 8b 05 e2 96 ff ff mov -0x691e(%rip),%rax # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28> +ffffffff80006a26: 48 83 78 08 00 cmpq $0x0,0x8(%rax) +ffffffff80006a2b: 0f 84 ef 00 00 00 je ffffffff80006b20 + hcf(); + } + + limine_framebuffer *framebuffer{framebuffer_request.response->framebuffers[0]}; +ffffffff80006a31: 48 8b 05 d0 96 ff ff mov -0x6930(%rip),%rax # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28> +ffffffff80006a38: 48 8b 40 10 mov 0x10(%rax),%rax +ffffffff80006a3c: 48 8b 00 mov (%rax),%rax + + Kt::Initialize( +ffffffff80006a3f: 44 0f b6 50 28 movzbl 0x28(%rax),%r10d +ffffffff80006a44: 44 0f b6 48 24 movzbl 0x24(%rax),%r9d +ffffffff80006a49: 44 0f b6 40 23 movzbl 0x23(%rax),%r8d +ffffffff80006a4e: 48 8b 48 18 mov 0x18(%rax),%rcx +ffffffff80006a52: 48 8b 50 10 mov 0x10(%rax),%rdx +ffffffff80006a56: 48 8b 70 08 mov 0x8(%rax),%rsi +ffffffff80006a5a: 48 8b 38 mov (%rax),%rdi +ffffffff80006a5d: 41 52 push %r10 +ffffffff80006a5f: 44 0f b6 50 27 movzbl 0x27(%rax),%r10d +ffffffff80006a64: 41 52 push %r10 +ffffffff80006a66: 44 0f b6 50 26 movzbl 0x26(%rax),%r10d +ffffffff80006a6b: 41 52 push %r10 +ffffffff80006a6d: 0f b6 40 25 movzbl 0x25(%rax),%eax +ffffffff80006a71: 50 push %rax +ffffffff80006a72: e8 79 04 00 00 call ffffffff80006ef0 <_ZN2Kt10InitializeEPjmmmhhhhhh> + framebuffer->blue_mask_size, + framebuffer->blue_mask_shift + ); + +#if defined (__x86_64__) + Hal::PrepareGDT(); +ffffffff80006a77: 48 83 c4 20 add $0x20,%rsp +ffffffff80006a7b: e8 60 ec ff ff call ffffffff800056e0 <_ZN3Hal10PrepareGDTEv> + Hal::BridgeLoadGDT(); +ffffffff80006a80: e8 0b ed ff ff call ffffffff80005790 <_ZN3Hal13BridgeLoadGDTEv> +#endif + + uint64_t hhdm_offset = hhdm_request.response->offset; +ffffffff80006a85: 48 8b 05 fc 95 ff ff mov -0x6a04(%rip),%rax # ffffffff80000088 <_ZN12_GLOBAL__N_112hhdm_requestE+0x28> + Memory::HHDMBase = hhdm_offset; +ffffffff80006a8c: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff80006a90: 48 89 05 31 ad 0d 00 mov %rax,0xdad31(%rip) # ffffffff800e17c8 <_ZN6Memory8HHDMBaseE> + + if (memmap_request.response != nullptr) { +ffffffff80006a97: 48 8b 05 aa 95 ff ff mov -0x6a56(%rip),%rax # ffffffff80000048 <_ZN12_GLOBAL__N_114memmap_requestE+0x28> +ffffffff80006a9e: 48 85 c0 test %rax,%rax +ffffffff80006aa1: 0f 84 99 00 00 00 je ffffffff80006b40 +ffffffff80006aa7: 48 c7 c7 20 be 00 80 mov $0xffffffff8000be20,%rdi + kout << "MemoryManagement: Creating global HeapAllocator" << newline; + + auto result = Memory::Scan(memmap_request.response); + auto allocator = Memory::HeapAllocator(result); +ffffffff80006aae: 48 89 e3 mov %rsp,%rbx +ffffffff80006ab1: e8 ea 04 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff80006ab6: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80006abb: e8 b0 04 00 00 call ffffffff80006f70 <_ZN2Kt7PutcharEc> + auto result = Memory::Scan(memmap_request.response); +ffffffff80006ac0: 48 8b 3d 81 95 ff ff mov -0x6a7f(%rip),%rdi # ffffffff80000048 <_ZN12_GLOBAL__N_114memmap_requestE+0x28> +ffffffff80006ac7: e8 e4 02 00 00 call ffffffff80006db0 <_ZN6Memory4ScanEP22limine_memmap_response> + auto allocator = Memory::HeapAllocator(result); +ffffffff80006acc: 48 89 df mov %rbx,%rdi + auto result = Memory::Scan(memmap_request.response); +ffffffff80006acf: 48 89 c6 mov %rax,%rsi + auto allocator = Memory::HeapAllocator(result); +ffffffff80006ad2: e8 89 00 00 00 call ffffffff80006b60 <_ZN6Memory13HeapAllocatorC1ENS_14LargestSectionE> + + Memory::g_heap = &allocator; +ffffffff80006ad7: 48 89 1d f2 ac 0d 00 mov %rbx,0xdacf2(%rip) # ffffffff800e17d0 <_ZN6Memory6g_heapE> + } else { + Panic("Guru Meditation Error: System memory map missing!", nullptr); + } + +#if defined (__x86_64__) + Hal::IDTInitialize(); +ffffffff80006ade: e8 6d f9 ff ff call ffffffff80006450 <_ZN3Hal13IDTInitializeEv> +#endif + + kcp::cstringstream stream; +ffffffff80006ae3: 48 89 df mov %rbx,%rdi +ffffffff80006ae6: e8 f5 ea ff ff call ffffffff800055e0 <_ZN3kcp13cstringstreamC1Ev> + stream<<"Hello, World"; +ffffffff80006aeb: 48 c7 c6 c5 bc 00 80 mov $0xffffffff8000bcc5,%rsi +ffffffff80006af2: 48 89 df mov %rbx,%rdi +ffffffff80006af5: e8 36 eb ff ff call ffffffff80005630 <_ZN3kcp13cstringstreamlsEPKc> + + Memory::g_heap->Walk(); +ffffffff80006afa: 48 8b 3d cf ac 0d 00 mov 0xdaccf(%rip),%rdi # ffffffff800e17d0 <_ZN6Memory6g_heapE> +ffffffff80006b01: e8 da 01 00 00 call ffffffff80006ce0 <_ZN6Memory13HeapAllocator4WalkEv> + + hcf(); +ffffffff80006b06: e8 d5 03 00 00 call ffffffff80006ee0 <_Z3hcfv> +} +ffffffff80006b0b: 48 89 df mov %rbx,%rdi +ffffffff80006b0e: e8 ed ea ff ff call ffffffff80005600 <_ZN3kcp13cstringstreamD1Ev> +ffffffff80006b13: 48 83 c4 20 add $0x20,%rsp +ffffffff80006b17: 5b pop %rbx +ffffffff80006b18: c3 ret +ffffffff80006b19: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + hcf(); +ffffffff80006b20: e8 bb 03 00 00 call ffffffff80006ee0 <_Z3hcfv> +ffffffff80006b25: e9 07 ff ff ff jmp ffffffff80006a31 +ffffffff80006b2a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + hcf(); +ffffffff80006b30: e8 ab 03 00 00 call ffffffff80006ee0 <_Z3hcfv> +ffffffff80006b35: e9 af fe ff ff jmp ffffffff800069e9 +ffffffff80006b3a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + Panic("Guru Meditation Error: System memory map missing!", nullptr); +ffffffff80006b40: 31 f6 xor %esi,%esi +ffffffff80006b42: 48 c7 c7 50 be 00 80 mov $0xffffffff8000be50,%rdi +ffffffff80006b49: 48 89 e3 mov %rsp,%rbx +ffffffff80006b4c: e8 5f e3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> +ffffffff80006b51: eb 8b jmp ffffffff80006ade +ffffffff80006b53: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006b5a: 00 00 00 +ffffffff80006b5d: 0f 1f 00 nopl (%rax) + +ffffffff80006b60 <_ZN6Memory13HeapAllocatorC1ENS_14LargestSectionE>: + +namespace Memory +{ + constexpr size_t metadata_size = 8; // 8 bytes + + HeapAllocator::HeapAllocator(LargestSection section) +ffffffff80006b60: f3 0f 1e fa endbr64 +ffffffff80006b64: 41 54 push %r12 +ffffffff80006b66: 49 89 d4 mov %rdx,%r12 +ffffffff80006b69: 55 push %rbp +ffffffff80006b6a: 48 89 f5 mov %rsi,%rbp +ffffffff80006b6d: 53 push %rbx +ffffffff80006b6e: 48 89 fb mov %rdi,%rbx +ffffffff80006b71: 48 c7 47 10 00 00 00 movq $0x0,0x10(%rdi) +ffffffff80006b78: 00 +ffffffff80006b79: 48 c7 47 18 00 00 00 movq $0x0,0x18(%rdi) +ffffffff80006b80: 00 + Print(string); +ffffffff80006b81: 48 c7 c7 88 be 00 80 mov $0xffffffff8000be88,%rdi +ffffffff80006b88: e8 13 04 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff80006b8d: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80006b92: e8 d9 03 00 00 call ffffffff80006f70 <_ZN2Kt7PutcharEc> + +namespace Memory { + extern std::uint64_t HHDMBase; + + inline uint64_t HHDM(uint64_t address) { + return HHDMBase + address; +ffffffff80006b97: 48 8b 35 2a ac 0d 00 mov 0xdac2a(%rip),%rsi # ffffffff800e17c8 <_ZN6Memory8HHDMBaseE> + { + kout << "HeapAllocator: constructor called" << Kt::newline; + + // section contains the physical address, we need the virtual address, so we call the helper + g_section = LargestSection { +ffffffff80006b9e: 4c 89 63 08 mov %r12,0x8(%rbx) + .address = HHDM(section.address), + .size = section.size + }; + + head = Node { +ffffffff80006ba2: 48 c7 43 10 00 00 00 movq $0x0,0x10(%rbx) +ffffffff80006ba9: 00 +ffffffff80006baa: 48 01 ee add %rbp,%rsi + g_section = LargestSection { +ffffffff80006bad: 48 89 33 mov %rsi,(%rbx) + head = Node { +ffffffff80006bb0: 48 89 73 18 mov %rsi,0x18(%rbx) + .size = 0, + .next = (Node*)g_section.address + }; + + head.next->size = g_section.size; +ffffffff80006bb4: 4c 89 26 mov %r12,(%rsi) + head.size = 0;//!!!!!! + } +ffffffff80006bb7: 5b pop %rbx +ffffffff80006bb8: 5d pop %rbp +ffffffff80006bb9: 41 5c pop %r12 +ffffffff80006bbb: c3 ret +ffffffff80006bbc: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm>: + + void* HeapAllocator::Request(size_t size) { +ffffffff80006bc0: f3 0f 1e fa endbr64 +ffffffff80006bc4: 55 push %rbp + Node* current = &head; + Node* prev = nullptr; +ffffffff80006bc5: 31 c9 xor %ecx,%ecx + void* HeapAllocator::Request(size_t size) { +ffffffff80006bc7: 48 89 fd mov %rdi,%rbp +ffffffff80006bca: 53 push %rbx + Node* current = &head; +ffffffff80006bcb: 48 8d 5f 10 lea 0x10(%rdi),%rbx + void* HeapAllocator::Request(size_t size) { +ffffffff80006bcf: 48 83 ec 08 sub $0x8,%rsp +ffffffff80006bd3: eb 0e jmp ffffffff80006be3 <_ZN6Memory13HeapAllocator7RequestEm+0x23> +ffffffff80006bd5: 0f 1f 00 nopl (%rax) + + while (current != nullptr) { +ffffffff80006bd8: 48 89 d9 mov %rbx,%rcx +ffffffff80006bdb: 48 85 c0 test %rax,%rax +ffffffff80006bde: 74 62 je ffffffff80006c42 <_ZN6Memory13HeapAllocator7RequestEm+0x82> +ffffffff80006be0: 48 89 c3 mov %rax,%rbx + if (current->size >= size) { +ffffffff80006be3: 48 8b 13 mov (%rbx),%rdx + Node copy = *current; +ffffffff80006be6: 48 8b 43 08 mov 0x8(%rbx),%rax + if (current->size >= size) { +ffffffff80006bea: 48 39 f2 cmp %rsi,%rdx +ffffffff80006bed: 72 e9 jb ffffffff80006bd8 <_ZN6Memory13HeapAllocator7RequestEm+0x18> + size_t total_size_needed = size + sizeof(Metadata); + + Metadata* meta = (Metadata*)current; + + meta->size = size; +ffffffff80006bef: 48 89 33 mov %rsi,(%rbx) + + prev->next = (Node*)((uint64_t)current + total_size_needed); +ffffffff80006bf2: 48 8d 74 33 08 lea 0x8(%rbx,%rsi,1),%rsi + Print(string); +ffffffff80006bf7: 48 c7 c7 d2 bc 00 80 mov $0xffffffff8000bcd2,%rdi +ffffffff80006bfe: 48 89 71 08 mov %rsi,0x8(%rcx) + prev->next->next = copy.next; +ffffffff80006c02: 48 89 46 08 mov %rax,0x8(%rsi) + prev->next->size = copy.size; +ffffffff80006c06: 48 8b 41 08 mov 0x8(%rcx),%rax +ffffffff80006c0a: 48 89 10 mov %rdx,(%rax) +ffffffff80006c0d: e8 8e 03 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006c12: 48 8b 7d 10 mov 0x10(%rbp),%rdi +ffffffff80006c16: be 0a 00 00 00 mov $0xa,%esi + t.streamBaseType = newBase; +ffffffff80006c1b: c7 05 d3 54 00 00 0a movl $0xa,0x54d3(%rip) # ffffffff8000c0f8 +ffffffff80006c22: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006c25: e8 86 fd ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006c2a: 48 89 c7 mov %rax,%rdi +ffffffff80006c2d: e8 6e 03 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006c32: 48 c7 c7 c0 b9 00 80 mov $0xffffffff8000b9c0,%rdi +ffffffff80006c39: e8 62 03 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + + kout << "head.size: " << base::dec << head.size << "\n"; + + return (void*)((uint64_t)meta + sizeof(Metadata)); +ffffffff80006c3e: 48 8d 43 08 lea 0x8(%rbx),%rax + prev = current; + current = current->next; + } + + return nullptr; + } +ffffffff80006c42: 48 83 c4 08 add $0x8,%rsp +ffffffff80006c46: 5b pop %rbx +ffffffff80006c47: 5d pop %rbp +ffffffff80006c48: c3 ret +ffffffff80006c49: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + +ffffffff80006c50 <_ZN6Memory13HeapAllocator7ReallocEPvm>: + + void* HeapAllocator::Realloc(void* ptr, size_t size) { +ffffffff80006c50: f3 0f 1e fa endbr64 +ffffffff80006c54: 41 55 push %r13 +ffffffff80006c56: 49 89 d5 mov %rdx,%r13 +ffffffff80006c59: 41 54 push %r12 +ffffffff80006c5b: 55 push %rbp +ffffffff80006c5c: 48 89 f5 mov %rsi,%rbp + auto new_ptr = Request(size); +ffffffff80006c5f: 48 89 d6 mov %rdx,%rsi + void* HeapAllocator::Realloc(void* ptr, size_t size) { +ffffffff80006c62: 53 push %rbx +ffffffff80006c63: 48 89 fb mov %rdi,%rbx +ffffffff80006c66: 48 83 ec 08 sub $0x8,%rsp + auto new_ptr = Request(size); +ffffffff80006c6a: e8 51 ff ff ff call ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm> +ffffffff80006c6f: 49 89 c4 mov %rax,%r12 + + if (new_ptr == nullptr) { +ffffffff80006c72: 48 85 c0 test %rax,%rax +ffffffff80006c75: 74 2e je ffffffff80006ca5 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x55> + return nullptr; + } + + if (ptr == nullptr) { +ffffffff80006c77: 48 85 ed test %rbp,%rbp +ffffffff80006c7a: 74 29 je ffffffff80006ca5 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x55> + return new_ptr; + } + + memcpy(new_ptr, ptr, size); +ffffffff80006c7c: 4c 89 ea mov %r13,%rdx +ffffffff80006c7f: 48 89 ee mov %rbp,%rsi +ffffffff80006c82: 48 89 c7 mov %rax,%rdi +ffffffff80006c85: e8 b6 fa ff ff call ffffffff80006740 + + void HeapAllocator::Free(void* ptr) { + Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata)); + size_t size = meta->size; + + auto prev_next = head.next; +ffffffff80006c8a: 48 8b 4b 18 mov 0x18(%rbx),%rcx + Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata)); +ffffffff80006c8e: 48 8d 45 f8 lea -0x8(%rbp),%rax + size_t size = meta->size; +ffffffff80006c92: 48 8b 55 f8 mov -0x8(%rbp),%rdx + + head.next = (Node*)meta; +ffffffff80006c96: 48 89 43 18 mov %rax,0x18(%rbx) + head.next->next = prev_next; +ffffffff80006c9a: 48 89 4d 00 mov %rcx,0x0(%rbp) + head.next->size = size; +ffffffff80006c9e: 48 8b 43 18 mov 0x18(%rbx),%rax +ffffffff80006ca2: 48 89 10 mov %rdx,(%rax) + } +ffffffff80006ca5: 48 83 c4 08 add $0x8,%rsp +ffffffff80006ca9: 4c 89 e0 mov %r12,%rax +ffffffff80006cac: 5b pop %rbx +ffffffff80006cad: 5d pop %rbp +ffffffff80006cae: 41 5c pop %r12 +ffffffff80006cb0: 41 5d pop %r13 +ffffffff80006cb2: c3 ret +ffffffff80006cb3: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006cba: 00 00 00 +ffffffff80006cbd: 0f 1f 00 nopl (%rax) + +ffffffff80006cc0 <_ZN6Memory13HeapAllocator4FreeEPv>: + void HeapAllocator::Free(void* ptr) { +ffffffff80006cc0: f3 0f 1e fa endbr64 + auto prev_next = head.next; +ffffffff80006cc4: 48 8b 4f 18 mov 0x18(%rdi),%rcx + Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata)); +ffffffff80006cc8: 48 8d 46 f8 lea -0x8(%rsi),%rax + size_t size = meta->size; +ffffffff80006ccc: 48 8b 56 f8 mov -0x8(%rsi),%rdx + head.next = (Node*)meta; +ffffffff80006cd0: 48 89 47 18 mov %rax,0x18(%rdi) + head.next->next = prev_next; +ffffffff80006cd4: 48 89 0e mov %rcx,(%rsi) + head.next->size = size; +ffffffff80006cd7: 48 8b 47 18 mov 0x18(%rdi),%rax +ffffffff80006cdb: 48 89 10 mov %rdx,(%rax) + } +ffffffff80006cde: c3 ret +ffffffff80006cdf: 90 nop + +ffffffff80006ce0 <_ZN6Memory13HeapAllocator4WalkEv>: + + // Traverses the Allocator's linked list for debugging + void HeapAllocator::Walk() { +ffffffff80006ce0: f3 0f 1e fa endbr64 +ffffffff80006ce4: 55 push %rbp +ffffffff80006ce5: 53 push %rbx +ffffffff80006ce6: 48 83 ec 08 sub $0x8,%rsp + Node* current = {head.next}; +ffffffff80006cea: 48 8b 5f 18 mov 0x18(%rdi),%rbx + size_t i{0}; + + while (current != nullptr) { +ffffffff80006cee: 48 85 db test %rbx,%rbx +ffffffff80006cf1: 0f 84 a8 00 00 00 je ffffffff80006d9f <_ZN6Memory13HeapAllocator4WalkEv+0xbf> + size_t i{0}; +ffffffff80006cf7: 31 ed xor %ebp,%ebp +ffffffff80006cf9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) +ffffffff80006d00: 48 c7 c7 de bc 00 80 mov $0xffffffff8000bcde,%rdi +ffffffff80006d07: e8 94 02 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006d0c: be 0a 00 00 00 mov $0xa,%esi +ffffffff80006d11: 48 89 ef mov %rbp,%rdi + t.streamBaseType = newBase; +ffffffff80006d14: c7 05 da 53 00 00 0a movl $0xa,0x53da(%rip) # ffffffff8000c0f8 +ffffffff80006d1b: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006d1e: e8 8d fc ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> + kout << "Block " << base::dec << i << " {" << current->size << " bytes & address 0x" << base::hex << (uint64_t)current << "}" << Kt::newline; + current = current->next; + i++; +ffffffff80006d23: 48 83 c5 01 add $0x1,%rbp +ffffffff80006d27: 48 89 c7 mov %rax,%rdi +ffffffff80006d2a: e8 71 02 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006d2f: 48 c7 c7 e5 bc 00 80 mov $0xffffffff8000bce5,%rdi +ffffffff80006d36: e8 65 02 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006d3b: 8b 35 b7 53 00 00 mov 0x53b7(%rip),%esi # ffffffff8000c0f8 +ffffffff80006d41: 48 8b 3b mov (%rbx),%rdi +ffffffff80006d44: e8 67 fc ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006d49: 48 89 c7 mov %rax,%rdi +ffffffff80006d4c: e8 4f 02 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006d51: 48 c7 c7 e8 bc 00 80 mov $0xffffffff8000bce8,%rdi +ffffffff80006d58: e8 43 02 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006d5d: be 10 00 00 00 mov $0x10,%esi +ffffffff80006d62: 48 89 df mov %rbx,%rdi + t.streamBaseType = newBase; +ffffffff80006d65: c7 05 89 53 00 00 10 movl $0x10,0x5389(%rip) # ffffffff8000c0f8 +ffffffff80006d6c: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006d6f: e8 3c fc ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006d74: 48 89 c7 mov %rax,%rdi +ffffffff80006d77: e8 24 02 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006d7c: 48 c7 c7 fc bc 00 80 mov $0xffffffff8000bcfc,%rdi +ffffffff80006d83: e8 18 02 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff80006d88: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80006d8d: e8 de 01 00 00 call ffffffff80006f70 <_ZN2Kt7PutcharEc> + current = current->next; +ffffffff80006d92: 48 8b 5b 08 mov 0x8(%rbx),%rbx + while (current != nullptr) { +ffffffff80006d96: 48 85 db test %rbx,%rbx +ffffffff80006d99: 0f 85 61 ff ff ff jne ffffffff80006d00 <_ZN6Memory13HeapAllocator4WalkEv+0x20> + } + } +ffffffff80006d9f: 48 83 c4 08 add $0x8,%rsp +ffffffff80006da3: 5b pop %rbx +ffffffff80006da4: 5d pop %rbp +ffffffff80006da5: c3 ret +ffffffff80006da6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006dad: 00 00 00 + +ffffffff80006db0 <_ZN6Memory4ScanEP22limine_memmap_response>: +#include "Heap.hpp" + +using namespace Kt; + +namespace Memory { + LargestSection Scan(limine_memmap_response* mmap) { +ffffffff80006db0: f3 0f 1e fa endbr64 +ffffffff80006db4: 41 56 push %r14 +ffffffff80006db6: 41 55 push %r13 +ffffffff80006db8: 41 54 push %r12 +ffffffff80006dba: 55 push %rbp +ffffffff80006dbb: 53 push %rbx + LargestSection currentLargestSection{}; + + for (size_t i = 0; i < mmap->entry_count; i++) { +ffffffff80006dbc: 4c 8b 6f 08 mov 0x8(%rdi),%r13 +ffffffff80006dc0: 4d 85 ed test %r13,%r13 +ffffffff80006dc3: 0f 84 ef 00 00 00 je ffffffff80006eb8 <_ZN6Memory4ScanEP22limine_memmap_response+0x108> +ffffffff80006dc9: 49 89 fc mov %rdi,%r12 + LargestSection currentLargestSection{}; +ffffffff80006dcc: 45 31 ed xor %r13d,%r13d +ffffffff80006dcf: 45 31 f6 xor %r14d,%r14d + for (size_t i = 0; i < mmap->entry_count; i++) { +ffffffff80006dd2: 31 db xor %ebx,%ebx +ffffffff80006dd4: eb 19 jmp ffffffff80006def <_ZN6Memory4ScanEP22limine_memmap_response+0x3f> +ffffffff80006dd6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006ddd: 00 00 00 +ffffffff80006de0: 48 83 c3 01 add $0x1,%rbx +ffffffff80006de4: 49 3b 5c 24 08 cmp 0x8(%r12),%rbx +ffffffff80006de9: 0f 83 b1 00 00 00 jae ffffffff80006ea0 <_ZN6Memory4ScanEP22limine_memmap_response+0xf0> + auto entry = mmap->entries[i]; +ffffffff80006def: 49 8b 44 24 10 mov 0x10(%r12),%rax +ffffffff80006df4: 48 8b 2c d8 mov (%rax,%rbx,8),%rbp + + if (entry->base == 0) { +ffffffff80006df8: 48 83 7d 00 00 cmpq $0x0,0x0(%rbp) +ffffffff80006dfd: 74 e1 je ffffffff80006de0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30> + continue; + } + + if (entry->type == LIMINE_MEMMAP_USABLE) { +ffffffff80006dff: 48 83 7d 10 00 cmpq $0x0,0x10(%rbp) +ffffffff80006e04: 75 da jne ffffffff80006de0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30> + Print(string); +ffffffff80006e06: 48 c7 c7 b0 be 00 80 mov $0xffffffff8000beb0,%rdi +ffffffff80006e0d: e8 8e 01 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006e12: 48 8b 7d 08 mov 0x8(%rbp),%rdi +ffffffff80006e16: be 0a 00 00 00 mov $0xa,%esi + t.streamBaseType = newBase; +ffffffff80006e1b: c7 05 d3 52 00 00 0a movl $0xa,0x52d3(%rip) # ffffffff8000c0f8 +ffffffff80006e22: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006e25: e8 86 fb ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006e2a: 48 89 c7 mov %rax,%rdi +ffffffff80006e2d: e8 6e 01 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006e32: 48 c7 c7 fe bc 00 80 mov $0xffffffff8000bcfe,%rdi +ffffffff80006e39: e8 62 01 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006e3e: 48 8b 7d 00 mov 0x0(%rbp),%rdi +ffffffff80006e42: be 10 00 00 00 mov $0x10,%esi + t.streamBaseType = newBase; +ffffffff80006e47: c7 05 a7 52 00 00 10 movl $0x10,0x52a7(%rip) # ffffffff8000c0f8 +ffffffff80006e4e: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006e51: e8 5a fb ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006e56: 48 89 c7 mov %rax,%rdi +ffffffff80006e59: e8 42 01 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006e5e: 48 c7 c7 13 bd 00 80 mov $0xffffffff8000bd13,%rdi +ffffffff80006e65: e8 36 01 00 00 call ffffffff80006fa0 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff80006e6a: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80006e6f: e8 fc 00 00 00 call ffffffff80006f70 <_ZN2Kt7PutcharEc> + kout << "MemoryManagement: Found conventional memory section (size = " << base::dec << entry->length << " bytes, address = 0x" << base::hex << (uint64_t)entry->base << ")" << newline; + + if (entry->length > currentLargestSection.size) { +ffffffff80006e74: 48 8b 45 08 mov 0x8(%rbp),%rax +ffffffff80006e78: 49 39 c5 cmp %rax,%r13 +ffffffff80006e7b: 0f 83 5f ff ff ff jae ffffffff80006de0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30> + currentLargestSection = { + .address = (uint64_t)entry->base, +ffffffff80006e81: 4c 8b 75 00 mov 0x0(%rbp),%r14 + currentLargestSection = { +ffffffff80006e85: 49 89 c5 mov %rax,%r13 + for (size_t i = 0; i < mmap->entry_count; i++) { +ffffffff80006e88: 48 83 c3 01 add $0x1,%rbx +ffffffff80006e8c: 49 3b 5c 24 08 cmp 0x8(%r12),%rbx +ffffffff80006e91: 0f 82 58 ff ff ff jb ffffffff80006def <_ZN6Memory4ScanEP22limine_memmap_response+0x3f> +ffffffff80006e97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80006e9e: 00 00 + }; + } + } + } + + [[unlikely]] if (currentLargestSection.address == 0) { +ffffffff80006ea0: 4d 85 f6 test %r14,%r14 +ffffffff80006ea3: 74 13 je ffffffff80006eb8 <_ZN6Memory4ScanEP22limine_memmap_response+0x108> + Panic("Couldn't find a usable memory section.", nullptr); + } + + return currentLargestSection; + } +ffffffff80006ea5: 5b pop %rbx +ffffffff80006ea6: 4c 89 f0 mov %r14,%rax +ffffffff80006ea9: 5d pop %rbp +ffffffff80006eaa: 4c 89 ea mov %r13,%rdx +ffffffff80006ead: 41 5c pop %r12 +ffffffff80006eaf: 41 5d pop %r13 +ffffffff80006eb1: 41 5e pop %r14 +ffffffff80006eb3: c3 ret +ffffffff80006eb4: 0f 1f 40 00 nopl 0x0(%rax) + Panic("Couldn't find a usable memory section.", nullptr); +ffffffff80006eb8: 45 31 f6 xor %r14d,%r14d +ffffffff80006ebb: 31 f6 xor %esi,%esi +ffffffff80006ebd: 48 c7 c7 f0 be 00 80 mov $0xffffffff8000bef0,%rdi +ffffffff80006ec4: e8 e7 df ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80006ec9: 5b pop %rbx +ffffffff80006eca: 4c 89 f0 mov %r14,%rax +ffffffff80006ecd: 5d pop %rbp +ffffffff80006ece: 4c 89 ea mov %r13,%rdx +ffffffff80006ed1: 41 5c pop %r12 +ffffffff80006ed3: 41 5d pop %r13 +ffffffff80006ed5: 41 5e pop %r14 +ffffffff80006ed7: c3 ret +ffffffff80006ed8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80006edf: 00 + +ffffffff80006ee0 <_Z3hcfv>: + * Copyright (c) Daniel Hammer, Limine Contributors (via Limine C++ example) +*/ + +// Halt and catch fire function. +void hcf() +{ +ffffffff80006ee0: f3 0f 1e fa endbr64 +ffffffff80006ee4: 0f 1f 40 00 nopl 0x0(%rax) + for (;;) + { +#if defined(__x86_64__) + asm("hlt"); +ffffffff80006ee8: f4 hlt + for (;;) +ffffffff80006ee9: eb fd jmp ffffffff80006ee8 <_Z3hcfv+0x8> +ffffffff80006eeb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80006ef0 <_ZN2Kt10InitializeEPjmmmhhhhhh>: + void Initialize(std::uint32_t *framebuffer, std::size_t width, std::size_t height, std::size_t pitch, + std::uint8_t red_mask_size, std::uint8_t red_mask_shift, + std::uint8_t green_mask_size, std::uint8_t green_mask_shift, + std::uint8_t blue_mask_size, std::uint8_t blue_mask_shift + ) + { +ffffffff80006ef0: f3 0f 1e fa endbr64 +ffffffff80006ef4: 48 83 ec 08 sub $0x8,%rsp +ffffffff80006ef8: 48 89 f8 mov %rdi,%rax + ctx = flanterm_fb_init( +ffffffff80006efb: 45 0f b6 c9 movzbl %r9b,%r9d +ffffffff80006eff: 45 0f b6 c0 movzbl %r8b,%r8d +ffffffff80006f03: 6a 00 push $0x0 +ffffffff80006f05: 6a 00 push $0x0 +ffffffff80006f07: 6a 00 push $0x0 +ffffffff80006f09: 6a 01 push $0x1 +ffffffff80006f0b: 6a 00 push $0x0 +ffffffff80006f0d: 6a 00 push $0x0 +ffffffff80006f0f: 6a 00 push $0x0 +ffffffff80006f11: 6a 00 push $0x0 +ffffffff80006f13: 6a 00 push $0x0 +ffffffff80006f15: 6a 00 push $0x0 +ffffffff80006f17: 6a 00 push $0x0 +ffffffff80006f19: 6a 00 push $0x0 +ffffffff80006f1b: 6a 00 push $0x0 +ffffffff80006f1d: 6a 00 push $0x0 +ffffffff80006f1f: 0f b6 bc 24 98 00 00 movzbl 0x98(%rsp),%edi +ffffffff80006f26: 00 +ffffffff80006f27: 57 push %rdi +ffffffff80006f28: 0f b6 bc 24 98 00 00 movzbl 0x98(%rsp),%edi +ffffffff80006f2f: 00 +ffffffff80006f30: 57 push %rdi +ffffffff80006f31: 0f b6 bc 24 98 00 00 movzbl 0x98(%rsp),%edi +ffffffff80006f38: 00 +ffffffff80006f39: 57 push %rdi +ffffffff80006f3a: 0f b6 bc 24 98 00 00 movzbl 0x98(%rsp),%edi +ffffffff80006f41: 00 +ffffffff80006f42: 57 push %rdi +ffffffff80006f43: 31 ff xor %edi,%edi +ffffffff80006f45: 41 51 push %r9 +ffffffff80006f47: 49 89 c9 mov %rcx,%r9 +ffffffff80006f4a: 48 89 f1 mov %rsi,%rcx +ffffffff80006f4d: 31 f6 xor %esi,%esi +ffffffff80006f4f: 41 50 push %r8 +ffffffff80006f51: 49 89 d0 mov %rdx,%r8 +ffffffff80006f54: 48 89 c2 mov %rax,%rdx +ffffffff80006f57: e8 04 b2 ff ff call ffffffff80002160 +ffffffff80006f5c: 48 89 05 75 a8 0d 00 mov %rax,0xda875(%rip) # ffffffff800e17d8 <_ZN2Kt3ctxE> + NULL, NULL, + NULL, 0, 0, 1, + 0, 0, + 0 + ); + } +ffffffff80006f63: 48 81 c4 a8 00 00 00 add $0xa8,%rsp +ffffffff80006f6a: c3 ret +ffffffff80006f6b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80006f70 <_ZN2Kt7PutcharEc>: + + void Putchar(char c) { +ffffffff80006f70: f3 0f 1e fa endbr64 +ffffffff80006f74: 48 83 ec 18 sub $0x18,%rsp + flanterm_write(ctx, &c, 1); +ffffffff80006f78: ba 01 00 00 00 mov $0x1,%edx + void Putchar(char c) { +ffffffff80006f7d: 40 88 7c 24 0c mov %dil,0xc(%rsp) + flanterm_write(ctx, &c, 1); +ffffffff80006f82: 48 8b 3d 4f a8 0d 00 mov 0xda84f(%rip),%rdi # ffffffff800e17d8 <_ZN2Kt3ctxE> +ffffffff80006f89: 48 8d 74 24 0c lea 0xc(%rsp),%rsi +ffffffff80006f8e: e8 2d c0 ff ff call ffffffff80002fc0 + } +ffffffff80006f93: 48 83 c4 18 add $0x18,%rsp +ffffffff80006f97: c3 ret +ffffffff80006f98: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80006f9f: 00 + +ffffffff80006fa0 <_ZN2Kt5PrintEPKc>: + + void Print(const char *text) { +ffffffff80006fa0: f3 0f 1e fa endbr64 + +namespace Lib { + inline int strlen(const char *string) { + int c = 0; + + while (*string != '\0') { +ffffffff80006fa4: 80 3f 00 cmpb $0x0,(%rdi) +ffffffff80006fa7: 48 89 fe mov %rdi,%rsi +ffffffff80006faa: 74 2c je ffffffff80006fd8 <_ZN2Kt5PrintEPKc+0x38> +ffffffff80006fac: 48 89 f8 mov %rdi,%rax + int c = 0; +ffffffff80006faf: 31 d2 xor %edx,%edx +ffffffff80006fb1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + string++; +ffffffff80006fb8: 48 83 c0 01 add $0x1,%rax + c++; +ffffffff80006fbc: 83 c2 01 add $0x1,%edx + while (*string != '\0') { +ffffffff80006fbf: 80 38 00 cmpb $0x0,(%rax) +ffffffff80006fc2: 75 f4 jne ffffffff80006fb8 <_ZN2Kt5PrintEPKc+0x18> + flanterm_write(ctx, text, Lib::strlen(text)); +ffffffff80006fc4: 48 8b 3d 0d a8 0d 00 mov 0xda80d(%rip),%rdi # ffffffff800e17d8 <_ZN2Kt3ctxE> +ffffffff80006fcb: 48 63 d2 movslq %edx,%rdx +ffffffff80006fce: e9 ed bf ff ff jmp ffffffff80002fc0 +ffffffff80006fd3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80006fd8: 48 8b 3d f9 a7 0d 00 mov 0xda7f9(%rip),%rdi # ffffffff800e17d8 <_ZN2Kt3ctxE> +ffffffff80006fdf: 31 d2 xor %edx,%edx +ffffffff80006fe1: e9 da bf ff ff jmp ffffffff80002fc0 +ffffffff80006fe6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006fed: 00 00 00 + +ffffffff80006ff0 : +ffffffff80006ff0: 0f 01 17 lgdt (%rdi) +ffffffff80006ff3: c3 ret + +ffffffff80006ff4 : +ffffffff80006ff4: 6a 08 push $0x8 +ffffffff80006ff6: 48 8d 05 03 00 00 00 lea 0x3(%rip),%rax # ffffffff80007000 +ffffffff80006ffd: 50 push %rax +ffffffff80006ffe: 48 cb lretq + +ffffffff80007000 : +ffffffff80007000: 66 b8 10 00 mov $0x10,%ax +ffffffff80007004: 8e d8 mov %eax,%ds +ffffffff80007006: 8e c0 mov %eax,%es +ffffffff80007008: 8e e0 mov %eax,%fs +ffffffff8000700a: 8e e8 mov %eax,%gs +ffffffff8000700c: 8e d0 mov %eax,%ss +ffffffff8000700e: c3 ret + +kernel/bin-x86_64/kernel: file format elf64-x86-64 + + +Disassembly of section .text: + +ffffffff80001000 : +#endif + +static uint8_t bump_alloc_pool[FLANTERM_FB_BUMP_ALLOC_POOL_SIZE]; +static size_t bump_alloc_ptr = 0; + +static void *bump_alloc(size_t s) { +ffffffff80001000: f3 0f 1e fa endbr64 + static bool base_offset_added = false; + if (!base_offset_added) { +ffffffff80001004: 80 3d f5 a0 00 00 00 cmpb $0x0,0xa0f5(%rip) # ffffffff8000b100 +ffffffff8000100b: 75 07 jne ffffffff80001014 + if ((uintptr_t)bump_alloc_pool & 0xf) { + bump_alloc_ptr += 0x10 - ((uintptr_t)bump_alloc_pool & 0xf); + } + base_offset_added = true; +ffffffff8000100d: c6 05 ec a0 00 00 01 movb $0x1,0xa0ec(%rip) # ffffffff8000b100 + } + + if ((s & 0xf) != 0) { + s += 0x10; + s &= ~(size_t)0xf; +ffffffff80001014: 48 8d 47 10 lea 0x10(%rdi),%rax +ffffffff80001018: 48 83 e0 f0 and $0xfffffffffffffff0,%rax +ffffffff8000101c: 40 f6 c7 0f test $0xf,%dil +ffffffff80001020: 48 0f 45 f8 cmovne %rax,%rdi + } + + size_t next_ptr = bump_alloc_ptr + s; +ffffffff80001024: 48 8b 05 dd a0 00 00 mov 0xa0dd(%rip),%rax # ffffffff8000b108 +ffffffff8000102b: 48 01 c7 add %rax,%rdi + if (next_ptr > FLANTERM_FB_BUMP_ALLOC_POOL_SIZE) { +ffffffff8000102e: 48 81 ff 28 52 0d 00 cmp $0xd5228,%rdi +ffffffff80001035: 77 11 ja ffffffff80001048 + return NULL; + } + void *ret = &bump_alloc_pool[bump_alloc_ptr]; + bump_alloc_ptr = next_ptr; +ffffffff80001037: 48 89 3d ca a0 00 00 mov %rdi,0xa0ca(%rip) # ffffffff8000b108 + void *ret = &bump_alloc_pool[bump_alloc_ptr]; +ffffffff8000103e: 48 05 20 b1 00 80 add $0xffffffff8000b120,%rax + return ret; +ffffffff80001044: c3 ret +ffffffff80001045: 0f 1f 00 nopl (%rax) + return NULL; +ffffffff80001048: 31 c0 xor %eax,%eax +} +ffffffff8000104a: c3 ret +ffffffff8000104b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001050 : + uint32_t g = (colour >> 8) & 0xff; + uint32_t b = colour & 0xff; + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +} + +static void flanterm_fb_save_state(struct flanterm_context *_ctx) { +ffffffff80001050: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + ctx->saved_state_text_fg = ctx->text_fg; +ffffffff80001054: 48 8b 87 e0 02 00 00 mov 0x2e0(%rdi),%rax + ctx->saved_state_text_bg = ctx->text_bg; + ctx->saved_state_cursor_x = ctx->cursor_x; +ffffffff8000105b: 48 8b 97 e8 02 00 00 mov 0x2e8(%rdi),%rdx + ctx->saved_state_text_fg = ctx->text_fg; +ffffffff80001062: 48 89 87 f8 02 00 00 mov %rax,0x2f8(%rdi) + ctx->saved_state_cursor_x = ctx->cursor_x; +ffffffff80001069: 48 8b 87 f0 02 00 00 mov 0x2f0(%rdi),%rax +ffffffff80001070: 48 89 97 00 03 00 00 mov %rdx,0x300(%rdi) +ffffffff80001077: 48 89 87 08 03 00 00 mov %rax,0x308(%rdi) + ctx->saved_state_cursor_y = ctx->cursor_y; +} +ffffffff8000107e: c3 ret +ffffffff8000107f: 90 nop + +ffffffff80001080 : + +static void flanterm_fb_restore_state(struct flanterm_context *_ctx) { +ffffffff80001080: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + ctx->text_fg = ctx->saved_state_text_fg; +ffffffff80001084: 48 8b 87 f8 02 00 00 mov 0x2f8(%rdi),%rax + ctx->text_bg = ctx->saved_state_text_bg; + ctx->cursor_x = ctx->saved_state_cursor_x; +ffffffff8000108b: 48 8b 97 00 03 00 00 mov 0x300(%rdi),%rdx + ctx->text_fg = ctx->saved_state_text_fg; +ffffffff80001092: 48 89 87 e0 02 00 00 mov %rax,0x2e0(%rdi) + ctx->cursor_x = ctx->saved_state_cursor_x; +ffffffff80001099: 48 8b 87 08 03 00 00 mov 0x308(%rdi),%rax +ffffffff800010a0: 48 89 97 e8 02 00 00 mov %rdx,0x2e8(%rdi) +ffffffff800010a7: 48 89 87 f0 02 00 00 mov %rax,0x2f0(%rdi) + ctx->cursor_y = ctx->saved_state_cursor_y; +} +ffffffff800010ae: c3 ret +ffffffff800010af: 90 nop + +ffffffff800010b0 : + +static void flanterm_fb_swap_palette(struct flanterm_context *_ctx) { +ffffffff800010b0: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + uint32_t tmp = ctx->text_bg; + ctx->text_bg = ctx->text_fg; + ctx->text_fg = tmp; +ffffffff800010b4: 8b 97 e0 02 00 00 mov 0x2e0(%rdi),%edx +ffffffff800010ba: 8b 87 e4 02 00 00 mov 0x2e4(%rdi),%eax +ffffffff800010c0: 48 c1 e2 20 shl $0x20,%rdx +ffffffff800010c4: 48 09 d0 or %rdx,%rax +ffffffff800010c7: 48 89 87 e0 02 00 00 mov %rax,0x2e0(%rdi) +} +ffffffff800010ce: c3 ret +ffffffff800010cf: 90 nop + +ffffffff800010d0 : + +static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) { + return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg); +} + +static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff800010d0: 49 89 f0 mov %rsi,%r8 +ffffffff800010d3: 48 89 ce mov %rcx,%rsi + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff800010d6: 48 8b 8f e8 00 00 00 mov 0xe8(%rdi),%rcx +static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff800010dd: 48 89 f8 mov %rdi,%rax + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff800010e0: 48 39 ca cmp %rcx,%rdx +ffffffff800010e3: 73 31 jae ffffffff80001116 +ffffffff800010e5: 48 3b b7 e0 00 00 00 cmp 0xe0(%rdi),%rsi +ffffffff800010ec: 73 28 jae ffffffff80001116 + return; + } + + size_t i = y * _ctx->cols + x; +ffffffff800010ee: 48 0f af ce imul %rsi,%rcx + + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800010f2: 48 8b bf d8 02 00 00 mov 0x2d8(%rdi),%rdi + size_t i = y * _ctx->cols + x; +ffffffff800010f9: 48 01 d1 add %rdx,%rcx + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800010fc: 4c 8d 0c cf lea (%rdi,%rcx,8),%r9 +ffffffff80001100: 49 8b 39 mov (%r9),%rdi + + if (q == NULL) { +ffffffff80001103: 48 85 ff test %rdi,%rdi +ffffffff80001106: 74 18 je ffffffff80001120 + q->x = x; + q->y = y; + ctx->map[i] = q; + } + + q->c = *c; +ffffffff80001108: 49 8b 00 mov (%r8),%rax +ffffffff8000110b: 48 89 47 10 mov %rax,0x10(%rdi) +ffffffff8000110f: 41 8b 40 08 mov 0x8(%r8),%eax +ffffffff80001113: 89 47 18 mov %eax,0x18(%rdi) +} +ffffffff80001116: c3 ret +ffffffff80001117: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000111e: 00 00 + if (compare_char(&ctx->grid[i], c)) { +ffffffff80001120: 48 8d 3c 49 lea (%rcx,%rcx,2),%rdi +ffffffff80001124: 48 8b 88 c0 02 00 00 mov 0x2c0(%rax),%rcx +ffffffff8000112b: 48 8d 0c b9 lea (%rcx,%rdi,4),%rcx + return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg); +ffffffff8000112f: 41 8b 38 mov (%r8),%edi +ffffffff80001132: 39 39 cmp %edi,(%rcx) +ffffffff80001134: 74 2a je ffffffff80001160 + q = &ctx->queue[ctx->queue_i++]; +ffffffff80001136: 48 8b b8 d0 02 00 00 mov 0x2d0(%rax),%rdi +ffffffff8000113d: 48 8d 4f 01 lea 0x1(%rdi),%rcx +ffffffff80001141: 48 c1 e7 05 shl $0x5,%rdi +ffffffff80001145: 48 03 b8 c8 02 00 00 add 0x2c8(%rax),%rdi +ffffffff8000114c: 48 89 88 d0 02 00 00 mov %rcx,0x2d0(%rax) + q->x = x; +ffffffff80001153: 48 89 17 mov %rdx,(%rdi) + q->y = y; +ffffffff80001156: 48 89 77 08 mov %rsi,0x8(%rdi) + ctx->map[i] = q; +ffffffff8000115a: 49 89 39 mov %rdi,(%r9) +ffffffff8000115d: eb a9 jmp ffffffff80001108 +ffffffff8000115f: 90 nop + return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg); +ffffffff80001160: 41 8b 78 08 mov 0x8(%r8),%edi +ffffffff80001164: 39 79 08 cmp %edi,0x8(%rcx) +ffffffff80001167: 75 cd jne ffffffff80001136 +ffffffff80001169: 41 8b 78 04 mov 0x4(%r8),%edi +ffffffff8000116d: 39 79 04 cmp %edi,0x4(%rcx) +ffffffff80001170: 75 c4 jne ffffffff80001136 +} +ffffffff80001172: c3 ret +ffffffff80001173: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000117a: 00 00 00 +ffffffff8000117d: 0f 1f 00 nopl (%rax) + +ffffffff80001180 : + +static void flanterm_fb_revscroll(struct flanterm_context *_ctx) { +ffffffff80001180: f3 0f 1e fa endbr64 +ffffffff80001184: 41 55 push %r13 +ffffffff80001186: 41 54 push %r12 +ffffffff80001188: 55 push %rbp +ffffffff80001189: 53 push %rbx +ffffffff8000118a: 48 89 fb mov %rdi,%rbx +ffffffff8000118d: 48 83 ec 10 sub $0x10,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1; +ffffffff80001191: 48 8b 47 70 mov 0x70(%rdi),%rax +ffffffff80001195: 4c 8b 9f e8 00 00 00 mov 0xe8(%rdi),%r11 + i >= _ctx->scroll_top_margin * _ctx->cols; i--) { +ffffffff8000119c: 48 8b 6f 68 mov 0x68(%rdi),%rbp + for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1; +ffffffff800011a0: 48 83 e8 01 sub $0x1,%rax + i >= _ctx->scroll_top_margin * _ctx->cols; i--) { +ffffffff800011a4: 4d 89 dc mov %r11,%r12 + for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1; +ffffffff800011a7: 49 0f af c3 imul %r11,%rax + i >= _ctx->scroll_top_margin * _ctx->cols; i--) { +ffffffff800011ab: 4c 0f af e5 imul %rbp,%r12 + if (i == (size_t)-1) { +ffffffff800011af: 48 85 c0 test %rax,%rax +ffffffff800011b2: 74 5c je ffffffff80001210 +ffffffff800011b4: 4c 8d 50 ff lea -0x1(%rax),%r10 +ffffffff800011b8: 4d 39 e2 cmp %r12,%r10 +ffffffff800011bb: 72 53 jb ffffffff80001210 + break; + } + struct flanterm_fb_char *c; + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800011bd: 4c 8b af d8 02 00 00 mov 0x2d8(%rdi),%r13 +ffffffff800011c4: eb 2d jmp ffffffff800011f3 +ffffffff800011c6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800011cd: 00 00 00 + if (q != NULL) { + c = &q->c; +ffffffff800011d0: 48 83 c6 10 add $0x10,%rsi + } else { + c = &ctx->grid[i]; + } + push_to_queue(_ctx, c, (i + _ctx->cols) % _ctx->cols, (i + _ctx->cols) / _ctx->cols); +ffffffff800011d4: 4b 8d 04 13 lea (%r11,%r10,1),%rax +ffffffff800011d8: 31 d2 xor %edx,%edx +ffffffff800011da: 48 89 df mov %rbx,%rdi +ffffffff800011dd: 49 f7 f3 div %r11 +ffffffff800011e0: 48 89 c1 mov %rax,%rcx +ffffffff800011e3: e8 e8 fe ff ff call ffffffff800010d0 + if (i == (size_t)-1) { +ffffffff800011e8: 49 83 ea 01 sub $0x1,%r10 +ffffffff800011ec: 72 22 jb ffffffff80001210 +ffffffff800011ee: 4d 39 e2 cmp %r12,%r10 +ffffffff800011f1: 72 1d jb ffffffff80001210 + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800011f3: 4b 8b 74 d5 00 mov 0x0(%r13,%r10,8),%rsi + if (q != NULL) { +ffffffff800011f8: 48 85 f6 test %rsi,%rsi +ffffffff800011fb: 75 d3 jne ffffffff800011d0 + c = &ctx->grid[i]; +ffffffff800011fd: 48 8b 93 c0 02 00 00 mov 0x2c0(%rbx),%rdx +ffffffff80001204: 4b 8d 04 52 lea (%r10,%r10,2),%rax +ffffffff80001208: 48 8d 34 82 lea (%rdx,%rax,4),%rsi +ffffffff8000120c: eb c6 jmp ffffffff800011d4 +ffffffff8000120e: 66 90 xchg %ax,%ax + } + + // Clear the first line of the screen. + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; +ffffffff80001210: 48 8b 83 e0 02 00 00 mov 0x2e0(%rbx),%rax + empty.c = ' '; +ffffffff80001217: c7 44 24 04 20 00 00 movl $0x20,0x4(%rsp) +ffffffff8000121e: 00 + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff8000121f: 31 d2 xor %edx,%edx + empty.fg = ctx->text_fg; +ffffffff80001221: 48 89 44 24 08 mov %rax,0x8(%rsp) + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff80001226: 4d 85 db test %r11,%r11 +ffffffff80001229: 74 1e je ffffffff80001249 +ffffffff8000122b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + push_to_queue(_ctx, &empty, i, _ctx->scroll_top_margin); +ffffffff80001230: 48 89 e9 mov %rbp,%rcx +ffffffff80001233: 48 8d 74 24 04 lea 0x4(%rsp),%rsi +ffffffff80001238: 48 89 df mov %rbx,%rdi +ffffffff8000123b: e8 90 fe ff ff call ffffffff800010d0 + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff80001240: 48 83 c2 01 add $0x1,%rdx +ffffffff80001244: 49 39 d3 cmp %rdx,%r11 +ffffffff80001247: 75 e7 jne ffffffff80001230 + } +} +ffffffff80001249: 48 83 c4 10 add $0x10,%rsp +ffffffff8000124d: 5b pop %rbx +ffffffff8000124e: 5d pop %rbp +ffffffff8000124f: 41 5c pop %r12 +ffffffff80001251: 41 5d pop %r13 +ffffffff80001253: c3 ret +ffffffff80001254: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000125b: 00 00 00 +ffffffff8000125e: 66 90 xchg %ax,%ax + +ffffffff80001260 : + +static void flanterm_fb_scroll(struct flanterm_context *_ctx) { +ffffffff80001260: f3 0f 1e fa endbr64 +ffffffff80001264: 41 56 push %r14 +ffffffff80001266: 41 55 push %r13 +ffffffff80001268: 41 54 push %r12 +ffffffff8000126a: 55 push %rbp +ffffffff8000126b: 53 push %rbx +ffffffff8000126c: 48 89 fb mov %rdi,%rbx +ffffffff8000126f: 48 83 ec 10 sub $0x10,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols; +ffffffff80001273: 4c 8b 9f e8 00 00 00 mov 0xe8(%rdi),%r11 +ffffffff8000127a: 48 8b 47 68 mov 0x68(%rdi),%rax + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff8000127e: 48 8b 6f 70 mov 0x70(%rdi),%rbp + for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols; +ffffffff80001282: 48 83 c0 01 add $0x1,%rax + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff80001286: 4d 89 dc mov %r11,%r12 + for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols; +ffffffff80001289: 49 0f af c3 imul %r11,%rax + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff8000128d: 4c 0f af e5 imul %rbp,%r12 +ffffffff80001291: 4c 39 e0 cmp %r12,%rax +ffffffff80001294: 73 62 jae ffffffff800012f8 +ffffffff80001296: 49 89 c2 mov %rax,%r10 +ffffffff80001299: 4c 8d 34 40 lea (%rax,%rax,2),%r14 +ffffffff8000129d: 48 8b 87 d8 02 00 00 mov 0x2d8(%rdi),%rax +ffffffff800012a4: 4d 29 dc sub %r11,%r12 +ffffffff800012a7: 4d 29 da sub %r11,%r10 +ffffffff800012aa: 49 c1 e6 02 shl $0x2,%r14 +ffffffff800012ae: 4e 8d 2c d8 lea (%rax,%r11,8),%r13 +ffffffff800012b2: eb 28 jmp ffffffff800012dc +ffffffff800012b4: 0f 1f 40 00 nopl 0x0(%rax) + struct flanterm_fb_char *c; + struct flanterm_fb_queue_item *q = ctx->map[i]; + if (q != NULL) { + c = &q->c; +ffffffff800012b8: 48 83 c6 10 add $0x10,%rsi + } else { + c = &ctx->grid[i]; + } + push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols); +ffffffff800012bc: 4c 89 d0 mov %r10,%rax +ffffffff800012bf: 31 d2 xor %edx,%edx +ffffffff800012c1: 48 89 df mov %rbx,%rdi + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff800012c4: 49 83 c2 01 add $0x1,%r10 +ffffffff800012c8: 49 f7 f3 div %r11 +ffffffff800012cb: 49 83 c6 0c add $0xc,%r14 +ffffffff800012cf: 48 89 c1 mov %rax,%rcx + push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols); +ffffffff800012d2: e8 f9 fd ff ff call ffffffff800010d0 + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { +ffffffff800012d7: 4d 39 d4 cmp %r10,%r12 +ffffffff800012da: 74 1c je ffffffff800012f8 + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800012dc: 4b 8b 74 d5 00 mov 0x0(%r13,%r10,8),%rsi + if (q != NULL) { +ffffffff800012e1: 48 85 f6 test %rsi,%rsi +ffffffff800012e4: 75 d2 jne ffffffff800012b8 + c = &ctx->grid[i]; +ffffffff800012e6: 48 8b b3 c0 02 00 00 mov 0x2c0(%rbx),%rsi +ffffffff800012ed: 4c 01 f6 add %r14,%rsi +ffffffff800012f0: eb ca jmp ffffffff800012bc +ffffffff800012f2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + } + + // Clear the last line of the screen. + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; +ffffffff800012f8: 48 8b 83 e0 02 00 00 mov 0x2e0(%rbx),%rax + empty.c = ' '; +ffffffff800012ff: c7 44 24 04 20 00 00 movl $0x20,0x4(%rsp) +ffffffff80001306: 00 + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->cols; i++) { + push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1); +ffffffff80001307: 48 83 ed 01 sub $0x1,%rbp + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff8000130b: 31 d2 xor %edx,%edx + empty.fg = ctx->text_fg; +ffffffff8000130d: 48 89 44 24 08 mov %rax,0x8(%rsp) + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff80001312: 4d 85 db test %r11,%r11 +ffffffff80001315: 74 22 je ffffffff80001339 +ffffffff80001317: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000131e: 00 00 + push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1); +ffffffff80001320: 48 89 e9 mov %rbp,%rcx +ffffffff80001323: 48 8d 74 24 04 lea 0x4(%rsp),%rsi +ffffffff80001328: 48 89 df mov %rbx,%rdi +ffffffff8000132b: e8 a0 fd ff ff call ffffffff800010d0 + for (size_t i = 0; i < _ctx->cols; i++) { +ffffffff80001330: 48 83 c2 01 add $0x1,%rdx +ffffffff80001334: 49 39 d3 cmp %rdx,%r11 +ffffffff80001337: 75 e7 jne ffffffff80001320 + } +} +ffffffff80001339: 48 83 c4 10 add $0x10,%rsp +ffffffff8000133d: 5b pop %rbx +ffffffff8000133e: 5d pop %rbp +ffffffff8000133f: 41 5c pop %r12 +ffffffff80001341: 41 5d pop %r13 +ffffffff80001343: 41 5e pop %r14 +ffffffff80001345: c3 ret +ffffffff80001346: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000134d: 00 00 00 + +ffffffff80001350 : + +static void flanterm_fb_clear(struct flanterm_context *_ctx, bool move) { +ffffffff80001350: f3 0f 1e fa endbr64 +ffffffff80001354: 41 54 push %r12 +ffffffff80001356: 41 89 f4 mov %esi,%r12d +ffffffff80001359: 55 push %rbp +ffffffff8000135a: 53 push %rbx +ffffffff8000135b: 48 89 fb mov %rdi,%rbx +ffffffff8000135e: 48 83 ec 10 sub $0x10,%rsp + + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff80001362: 4c 8b 9f e8 00 00 00 mov 0xe8(%rdi),%r11 +ffffffff80001369: 48 8b af e0 00 00 00 mov 0xe0(%rdi),%rbp + empty.fg = ctx->text_fg; +ffffffff80001370: 48 8b 87 e0 02 00 00 mov 0x2e0(%rdi),%rax + empty.c = ' '; +ffffffff80001377: c7 44 24 04 20 00 00 movl $0x20,0x4(%rsp) +ffffffff8000137e: 00 + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff8000137f: 49 0f af eb imul %r11,%rbp + empty.fg = ctx->text_fg; +ffffffff80001383: 48 89 44 24 08 mov %rax,0x8(%rsp) + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff80001388: 48 85 ed test %rbp,%rbp +ffffffff8000138b: 74 24 je ffffffff800013b1 +ffffffff8000138d: 45 31 d2 xor %r10d,%r10d + push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols); +ffffffff80001390: 4c 89 d0 mov %r10,%rax +ffffffff80001393: 31 d2 xor %edx,%edx +ffffffff80001395: 48 8d 74 24 04 lea 0x4(%rsp),%rsi +ffffffff8000139a: 48 89 df mov %rbx,%rdi +ffffffff8000139d: 49 f7 f3 div %r11 + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff800013a0: 49 83 c2 01 add $0x1,%r10 +ffffffff800013a4: 48 89 c1 mov %rax,%rcx + push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols); +ffffffff800013a7: e8 24 fd ff ff call ffffffff800010d0 + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff800013ac: 49 39 ea cmp %rbp,%r10 +ffffffff800013af: 75 df jne ffffffff80001390 + } + + if (move) { +ffffffff800013b1: 45 84 e4 test %r12b,%r12b +ffffffff800013b4: 74 16 je ffffffff800013cc + ctx->cursor_x = 0; +ffffffff800013b6: 48 c7 83 e8 02 00 00 movq $0x0,0x2e8(%rbx) +ffffffff800013bd: 00 00 00 00 + ctx->cursor_y = 0; +ffffffff800013c1: 48 c7 83 f0 02 00 00 movq $0x0,0x2f0(%rbx) +ffffffff800013c8: 00 00 00 00 + } +} +ffffffff800013cc: 48 83 c4 10 add $0x10,%rsp +ffffffff800013d0: 5b pop %rbx +ffffffff800013d1: 5d pop %rbp +ffffffff800013d2: 41 5c pop %r12 +ffffffff800013d4: c3 ret +ffffffff800013d5: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800013dc: 00 00 00 +ffffffff800013df: 90 nop + +ffffffff800013e0 : + +static void flanterm_fb_set_cursor_pos(struct flanterm_context *_ctx, size_t x, size_t y) { +ffffffff800013e0: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols) { +ffffffff800013e4: 48 8b 87 e8 00 00 00 mov 0xe8(%rdi),%rax +ffffffff800013eb: 48 39 c6 cmp %rax,%rsi +ffffffff800013ee: 72 0f jb ffffffff800013ff + if ((int)x < 0) { + x = 0; + } else { + x = _ctx->cols - 1; +ffffffff800013f0: 48 83 e8 01 sub $0x1,%rax +ffffffff800013f4: 85 f6 test %esi,%esi +ffffffff800013f6: be 00 00 00 00 mov $0x0,%esi +ffffffff800013fb: 48 0f 49 f0 cmovns %rax,%rsi + } + } + if (y >= _ctx->rows) { +ffffffff800013ff: 48 8b 87 e0 00 00 00 mov 0xe0(%rdi),%rax +ffffffff80001406: 48 39 c2 cmp %rax,%rdx +ffffffff80001409: 72 0f jb ffffffff8000141a + if ((int)y < 0) { + y = 0; + } else { + y = _ctx->rows - 1; +ffffffff8000140b: 48 83 e8 01 sub $0x1,%rax +ffffffff8000140f: 85 d2 test %edx,%edx +ffffffff80001411: ba 00 00 00 00 mov $0x0,%edx +ffffffff80001416: 48 0f 49 d0 cmovns %rax,%rdx + } + } + ctx->cursor_x = x; +ffffffff8000141a: 48 89 b7 e8 02 00 00 mov %rsi,0x2e8(%rdi) + ctx->cursor_y = y; +ffffffff80001421: 48 89 97 f0 02 00 00 mov %rdx,0x2f0(%rdi) +} +ffffffff80001428: c3 ret +ffffffff80001429: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + +ffffffff80001430 : + +static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) { +ffffffff80001430: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x; +ffffffff80001434: 48 8b 87 e8 02 00 00 mov 0x2e8(%rdi),%rax +static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) { +ffffffff8000143b: 48 89 d1 mov %rdx,%rcx + *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x; +ffffffff8000143e: 48 8b 97 e8 00 00 00 mov 0xe8(%rdi),%rdx +ffffffff80001445: 48 39 d0 cmp %rdx,%rax +ffffffff80001448: 4c 8d 42 ff lea -0x1(%rdx),%r8 +ffffffff8000144c: 49 0f 43 c0 cmovae %r8,%rax +ffffffff80001450: 48 89 06 mov %rax,(%rsi) + *y = ctx->cursor_y >= _ctx->rows ? _ctx->rows - 1 : ctx->cursor_y; +ffffffff80001453: 48 8b 87 f0 02 00 00 mov 0x2f0(%rdi),%rax +ffffffff8000145a: 48 8b 97 e0 00 00 00 mov 0xe0(%rdi),%rdx +ffffffff80001461: 48 8d 72 ff lea -0x1(%rdx),%rsi +ffffffff80001465: 48 39 d0 cmp %rdx,%rax +ffffffff80001468: 48 0f 43 c6 cmovae %rsi,%rax +ffffffff8000146c: 48 89 01 mov %rax,(%rcx) +} +ffffffff8000146f: c3 ret + +ffffffff80001470 : + +static void flanterm_fb_move_character(struct flanterm_context *_ctx, size_t new_x, size_t new_y, size_t old_x, size_t old_y) { +ffffffff80001470: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (old_x >= _ctx->cols || old_y >= _ctx->rows +ffffffff80001474: 48 8b 87 e8 00 00 00 mov 0xe8(%rdi),%rax +ffffffff8000147b: 48 39 c1 cmp %rax,%rcx +ffffffff8000147e: 73 1f jae ffffffff8000149f +ffffffff80001480: 4c 8b 97 e0 00 00 00 mov 0xe0(%rdi),%r10 + || new_x >= _ctx->cols || new_y >= _ctx->rows) { +ffffffff80001487: 48 39 c6 cmp %rax,%rsi +ffffffff8000148a: 41 0f 93 c1 setae %r9b + if (old_x >= _ctx->cols || old_y >= _ctx->rows +ffffffff8000148e: 4d 39 d0 cmp %r10,%r8 +ffffffff80001491: 41 0f 93 c3 setae %r11b + || new_x >= _ctx->cols || new_y >= _ctx->rows) { +ffffffff80001495: 45 08 d9 or %r11b,%r9b +ffffffff80001498: 75 05 jne ffffffff8000149f +ffffffff8000149a: 4c 39 d2 cmp %r10,%rdx +ffffffff8000149d: 72 01 jb ffffffff800014a0 + } else { + c = &ctx->grid[i]; + } + + push_to_queue(_ctx, c, new_x, new_y); +} +ffffffff8000149f: c3 ret + size_t i = old_x + old_y * _ctx->cols; +ffffffff800014a0: 49 0f af c0 imul %r8,%rax +ffffffff800014a4: 48 01 c8 add %rcx,%rax + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800014a7: 48 8b 8f d8 02 00 00 mov 0x2d8(%rdi),%rcx +ffffffff800014ae: 48 8b 0c c1 mov (%rcx,%rax,8),%rcx + if (q != NULL) { +ffffffff800014b2: 48 85 c9 test %rcx,%rcx +ffffffff800014b5: 74 19 je ffffffff800014d0 + c = &q->c; +ffffffff800014b7: 48 8d 41 10 lea 0x10(%rcx),%rax + push_to_queue(_ctx, c, new_x, new_y); +ffffffff800014bb: 48 89 d1 mov %rdx,%rcx +ffffffff800014be: 48 89 f2 mov %rsi,%rdx +ffffffff800014c1: 48 89 c6 mov %rax,%rsi +ffffffff800014c4: e9 07 fc ff ff jmp ffffffff800010d0 +ffffffff800014c9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + c = &ctx->grid[i]; +ffffffff800014d0: 48 8d 0c 40 lea (%rax,%rax,2),%rcx +ffffffff800014d4: 48 8b 87 c0 02 00 00 mov 0x2c0(%rdi),%rax +ffffffff800014db: 48 8d 04 88 lea (%rax,%rcx,4),%rax +ffffffff800014df: eb da jmp ffffffff800014bb +ffffffff800014e1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800014e8: 00 00 00 +ffffffff800014eb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff800014f0 : + +static void flanterm_fb_set_text_fg(struct flanterm_context *_ctx, size_t fg) { +ffffffff800014f0: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->ansi_colours[fg]; +ffffffff800014f4: 8b 84 b7 48 02 00 00 mov 0x248(%rdi,%rsi,4),%eax +ffffffff800014fb: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) +} +ffffffff80001501: c3 ret +ffffffff80001502: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001509: 00 00 00 +ffffffff8000150c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001510 : + +static void flanterm_fb_set_text_bg(struct flanterm_context *_ctx, size_t bg) { +ffffffff80001510: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->ansi_colours[bg]; +ffffffff80001514: 8b 84 b7 48 02 00 00 mov 0x248(%rdi,%rsi,4),%eax +ffffffff8000151b: 89 87 e4 02 00 00 mov %eax,0x2e4(%rdi) +} +ffffffff80001521: c3 ret +ffffffff80001522: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001529: 00 00 00 +ffffffff8000152c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001530 : + +static void flanterm_fb_set_text_fg_bright(struct flanterm_context *_ctx, size_t fg) { +ffffffff80001530: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->ansi_bright_colours[fg]; +ffffffff80001534: 8b 84 b7 68 02 00 00 mov 0x268(%rdi,%rsi,4),%eax +ffffffff8000153b: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) +} +ffffffff80001541: c3 ret +ffffffff80001542: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001549: 00 00 00 +ffffffff8000154c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001550 : + +static void flanterm_fb_set_text_bg_bright(struct flanterm_context *_ctx, size_t bg) { +ffffffff80001550: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->ansi_bright_colours[bg]; +ffffffff80001554: 8b 84 b7 68 02 00 00 mov 0x268(%rdi,%rsi,4),%eax +ffffffff8000155b: 89 87 e4 02 00 00 mov %eax,0x2e4(%rdi) +} +ffffffff80001561: c3 ret +ffffffff80001562: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001569: 00 00 00 +ffffffff8000156c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001570 : + +static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) { +ffffffff80001570: f3 0f 1e fa endbr64 + uint32_t r = (colour >> 16) & 0xff; +ffffffff80001574: 89 f0 mov %esi,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80001576: 0f b6 8f 21 02 00 00 movzbl 0x221(%rdi),%ecx +static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) { +ffffffff8000157d: 89 f2 mov %esi,%edx + uint32_t r = (colour >> 16) & 0xff; +ffffffff8000157f: c1 e8 10 shr $0x10,%eax + uint32_t g = (colour >> 8) & 0xff; +ffffffff80001582: 0f b6 f6 movzbl %dh,%esi + uint32_t b = colour & 0xff; +ffffffff80001585: 0f b6 d2 movzbl %dl,%edx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80001588: 0f b6 c0 movzbl %al,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000158b: d3 e0 shl %cl,%eax +ffffffff8000158d: 0f b6 8f 23 02 00 00 movzbl 0x223(%rdi),%ecx +ffffffff80001594: d3 e6 shl %cl,%esi +ffffffff80001596: 0f b6 8f 25 02 00 00 movzbl 0x225(%rdi),%ecx +ffffffff8000159d: 09 f0 or %esi,%eax +ffffffff8000159f: d3 e2 shl %cl,%edx +ffffffff800015a1: 09 d0 or %edx,%eax +ffffffff800015a3: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = convert_colour(_ctx, fg); +} +ffffffff800015a9: c3 ret +ffffffff800015aa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff800015b0 : + +static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) { +ffffffff800015b0: f3 0f 1e fa endbr64 + uint32_t r = (colour >> 16) & 0xff; +ffffffff800015b4: 89 f0 mov %esi,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800015b6: 0f b6 8f 21 02 00 00 movzbl 0x221(%rdi),%ecx +static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) { +ffffffff800015bd: 89 f2 mov %esi,%edx + uint32_t r = (colour >> 16) & 0xff; +ffffffff800015bf: c1 e8 10 shr $0x10,%eax + uint32_t g = (colour >> 8) & 0xff; +ffffffff800015c2: 0f b6 f6 movzbl %dh,%esi + uint32_t b = colour & 0xff; +ffffffff800015c5: 0f b6 d2 movzbl %dl,%edx + uint32_t r = (colour >> 16) & 0xff; +ffffffff800015c8: 0f b6 c0 movzbl %al,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800015cb: d3 e0 shl %cl,%eax +ffffffff800015cd: 0f b6 8f 23 02 00 00 movzbl 0x223(%rdi),%ecx +ffffffff800015d4: d3 e6 shl %cl,%esi +ffffffff800015d6: 0f b6 8f 25 02 00 00 movzbl 0x225(%rdi),%ecx +ffffffff800015dd: 09 f0 or %esi,%eax +ffffffff800015df: d3 e2 shl %cl,%edx +ffffffff800015e1: 09 d0 or %edx,%eax +ffffffff800015e3: 89 87 e4 02 00 00 mov %eax,0x2e4(%rdi) + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = convert_colour(_ctx, bg); +} +ffffffff800015e9: c3 ret +ffffffff800015ea: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff800015f0 : + +static void flanterm_fb_set_text_fg_default(struct flanterm_context *_ctx) { +ffffffff800015f0: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->default_fg; +ffffffff800015f4: 8b 87 88 02 00 00 mov 0x288(%rdi),%eax +ffffffff800015fa: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) +} +ffffffff80001600: c3 ret +ffffffff80001601: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001608: 00 00 00 +ffffffff8000160b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001610 : + +static void flanterm_fb_set_text_bg_default(struct flanterm_context *_ctx) { +ffffffff80001610: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = 0xffffffff; +ffffffff80001614: c7 87 e4 02 00 00 ff movl $0xffffffff,0x2e4(%rdi) +ffffffff8000161b: ff ff ff +} +ffffffff8000161e: c3 ret +ffffffff8000161f: 90 nop + +ffffffff80001620 : + +static void flanterm_fb_set_text_fg_default_bright(struct flanterm_context *_ctx) { +ffffffff80001620: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->default_fg_bright; +ffffffff80001624: 8b 87 90 02 00 00 mov 0x290(%rdi),%eax +ffffffff8000162a: 89 87 e0 02 00 00 mov %eax,0x2e0(%rdi) +} +ffffffff80001630: c3 ret +ffffffff80001631: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001638: 00 00 00 +ffffffff8000163b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001640 : + +static void flanterm_fb_set_text_bg_default_bright(struct flanterm_context *_ctx) { +ffffffff80001640: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->default_bg_bright; +ffffffff80001644: 8b 87 94 02 00 00 mov 0x294(%rdi),%eax +ffffffff8000164a: 89 87 e4 02 00 00 mov %eax,0x2e4(%rdi) +} +ffffffff80001650: c3 ret +ffffffff80001651: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001658: 00 00 00 +ffffffff8000165b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001660 : + +static void draw_cursor(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) { +ffffffff80001660: 48 8b 97 e8 02 00 00 mov 0x2e8(%rdi),%rdx +ffffffff80001667: 48 8b 87 e8 00 00 00 mov 0xe8(%rdi),%rax +ffffffff8000166e: 48 39 c2 cmp %rax,%rdx +ffffffff80001671: 0f 83 a1 00 00 00 jae ffffffff80001718 +static void draw_cursor(struct flanterm_context *_ctx) { +ffffffff80001677: 41 55 push %r13 +ffffffff80001679: 41 54 push %r12 +ffffffff8000167b: 55 push %rbp +ffffffff8000167c: 53 push %rbx +ffffffff8000167d: 48 89 fb mov %rdi,%rbx +ffffffff80001680: 48 83 ec 18 sub $0x18,%rsp + if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) { +ffffffff80001684: 48 8b 8f f0 02 00 00 mov 0x2f0(%rdi),%rcx +ffffffff8000168b: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80001692: 73 73 jae ffffffff80001707 + return; + } + + size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols; +ffffffff80001694: 48 0f af c1 imul %rcx,%rax + c = ctx->grid[i]; + } + uint32_t tmp = c.fg; + c.fg = c.bg; + c.bg = tmp; + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); +ffffffff80001698: 4c 8b 87 b0 01 00 00 mov 0x1b0(%rdi),%r8 + size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols; +ffffffff8000169f: 48 8d 2c 10 lea (%rax,%rdx,1),%rbp + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800016a3: 48 8b 87 d8 02 00 00 mov 0x2d8(%rdi),%rax + if (q != NULL) { + ctx->grid[i] = q->c; +ffffffff800016aa: 4c 8d 64 6d 00 lea 0x0(%rbp,%rbp,2),%r12 + struct flanterm_fb_queue_item *q = ctx->map[i]; +ffffffff800016af: 4c 8b 2c e8 mov (%rax,%rbp,8),%r13 + ctx->grid[i] = q->c; +ffffffff800016b3: 49 c1 e4 02 shl $0x2,%r12 + if (q != NULL) { +ffffffff800016b7: 4d 85 ed test %r13,%r13 +ffffffff800016ba: 74 64 je ffffffff80001720 + c = q->c; +ffffffff800016bc: 49 8b 45 10 mov 0x10(%r13),%rax +ffffffff800016c0: 48 89 44 24 04 mov %rax,0x4(%rsp) +ffffffff800016c5: 48 89 c6 mov %rax,%rsi +ffffffff800016c8: 41 8b 45 18 mov 0x18(%r13),%eax +ffffffff800016cc: 48 c1 ee 20 shr $0x20,%rsi + c.fg = c.bg; +ffffffff800016d0: 89 44 24 08 mov %eax,0x8(%rsp) + c.bg = tmp; +ffffffff800016d4: 89 74 24 0c mov %esi,0xc(%rsp) + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); +ffffffff800016d8: 48 8d 74 24 04 lea 0x4(%rsp),%rsi +ffffffff800016dd: 41 ff d0 call *%r8 + ctx->grid[i] = q->c; +ffffffff800016e0: 48 8b 83 c0 02 00 00 mov 0x2c0(%rbx),%rax +ffffffff800016e7: 49 8b 55 10 mov 0x10(%r13),%rdx +ffffffff800016eb: 4a 89 14 20 mov %rdx,(%rax,%r12,1) +ffffffff800016ef: 41 8b 55 18 mov 0x18(%r13),%edx +ffffffff800016f3: 42 89 54 20 08 mov %edx,0x8(%rax,%r12,1) + ctx->map[i] = NULL; +ffffffff800016f8: 48 8b 83 d8 02 00 00 mov 0x2d8(%rbx),%rax +ffffffff800016ff: 48 c7 04 e8 00 00 00 movq $0x0,(%rax,%rbp,8) +ffffffff80001706: 00 + } +} +ffffffff80001707: 48 83 c4 18 add $0x18,%rsp +ffffffff8000170b: 5b pop %rbx +ffffffff8000170c: 5d pop %rbp +ffffffff8000170d: 41 5c pop %r12 +ffffffff8000170f: 41 5d pop %r13 +ffffffff80001711: c3 ret +ffffffff80001712: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80001718: c3 ret +ffffffff80001719: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + c = ctx->grid[i]; +ffffffff80001720: 48 8b 87 c0 02 00 00 mov 0x2c0(%rdi),%rax +ffffffff80001727: 4a 8b 34 20 mov (%rax,%r12,1),%rsi +ffffffff8000172b: 48 89 74 24 04 mov %rsi,0x4(%rsp) +ffffffff80001730: 42 8b 74 20 08 mov 0x8(%rax,%r12,1),%esi + uint32_t tmp = c.fg; +ffffffff80001735: 8b 44 24 08 mov 0x8(%rsp),%eax + c.fg = c.bg; +ffffffff80001739: 89 74 24 08 mov %esi,0x8(%rsp) + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); +ffffffff8000173d: 48 8d 74 24 04 lea 0x4(%rsp),%rsi + c.bg = tmp; +ffffffff80001742: 89 44 24 0c mov %eax,0xc(%rsp) + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); +ffffffff80001746: 41 ff d0 call *%r8 +} +ffffffff80001749: 48 83 c4 18 add $0x18,%rsp +ffffffff8000174d: 5b pop %rbx +ffffffff8000174e: 5d pop %rbp +ffffffff8000174f: 41 5c pop %r12 +ffffffff80001751: 41 5d pop %r13 +ffffffff80001753: c3 ret +ffffffff80001754: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000175b: 00 00 00 +ffffffff8000175e: 66 90 xchg %ax,%ax + +ffffffff80001760 : + +static void flanterm_fb_double_buffer_flush(struct flanterm_context *_ctx) { +ffffffff80001760: f3 0f 1e fa endbr64 +ffffffff80001764: 41 55 push %r13 +ffffffff80001766: 41 54 push %r12 +ffffffff80001768: 55 push %rbp +ffffffff80001769: 53 push %rbx +ffffffff8000176a: 48 89 fb mov %rdi,%rbx +ffffffff8000176d: 48 83 ec 08 sub $0x8,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (_ctx->cursor_enabled) { +ffffffff80001771: 80 7f 09 00 cmpb $0x0,0x9(%rdi) +ffffffff80001775: 0f 85 35 01 00 00 jne ffffffff800018b0 + draw_cursor(_ctx); + } + + for (size_t i = 0; i < ctx->queue_i; i++) { +ffffffff8000177b: 48 83 bb d0 02 00 00 cmpq $0x0,0x2d0(%rbx) +ffffffff80001782: 00 +ffffffff80001783: 74 7b je ffffffff80001800 +ffffffff80001785: 48 8b 83 d8 02 00 00 mov 0x2d8(%rbx),%rax +ffffffff8000178c: 45 31 ed xor %r13d,%r13d +ffffffff8000178f: 90 nop + struct flanterm_fb_queue_item *q = &ctx->queue[i]; +ffffffff80001790: 4c 89 ed mov %r13,%rbp + size_t offset = q->y * _ctx->cols + q->x; +ffffffff80001793: 4c 8b a3 e8 00 00 00 mov 0xe8(%rbx),%r12 + struct flanterm_fb_queue_item *q = &ctx->queue[i]; +ffffffff8000179a: 48 c1 e5 05 shl $0x5,%rbp +ffffffff8000179e: 48 03 ab c8 02 00 00 add 0x2c8(%rbx),%rbp + size_t offset = q->y * _ctx->cols + q->x; +ffffffff800017a5: 48 8b 4d 08 mov 0x8(%rbp),%rcx +ffffffff800017a9: 48 8b 55 00 mov 0x0(%rbp),%rdx +ffffffff800017ad: 4c 0f af e1 imul %rcx,%r12 +ffffffff800017b1: 49 01 d4 add %rdx,%r12 + if (ctx->map[offset] == NULL) { +ffffffff800017b4: 4a 83 3c e0 00 cmpq $0x0,(%rax,%r12,8) +ffffffff800017b9: 74 38 je ffffffff800017f3 + continue; + } + ctx->plot_char(_ctx, &q->c, q->x, q->y); +ffffffff800017bb: 48 8d 75 10 lea 0x10(%rbp),%rsi +ffffffff800017bf: 48 89 df mov %rbx,%rdi +ffffffff800017c2: ff 93 b0 01 00 00 call *0x1b0(%rbx) + ctx->grid[offset] = q->c; +ffffffff800017c8: 48 8b 93 c0 02 00 00 mov 0x2c0(%rbx),%rdx +ffffffff800017cf: 4b 8d 04 64 lea (%r12,%r12,2),%rax +ffffffff800017d3: 48 8d 04 82 lea (%rdx,%rax,4),%rax +ffffffff800017d7: 48 8b 55 10 mov 0x10(%rbp),%rdx +ffffffff800017db: 48 89 10 mov %rdx,(%rax) +ffffffff800017de: 8b 55 18 mov 0x18(%rbp),%edx +ffffffff800017e1: 89 50 08 mov %edx,0x8(%rax) + ctx->map[offset] = NULL; +ffffffff800017e4: 48 8b 83 d8 02 00 00 mov 0x2d8(%rbx),%rax +ffffffff800017eb: 4a c7 04 e0 00 00 00 movq $0x0,(%rax,%r12,8) +ffffffff800017f2: 00 + for (size_t i = 0; i < ctx->queue_i; i++) { +ffffffff800017f3: 49 83 c5 01 add $0x1,%r13 +ffffffff800017f7: 4c 3b ab d0 02 00 00 cmp 0x2d0(%rbx),%r13 +ffffffff800017fe: 72 90 jb ffffffff80001790 + } + + if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) { +ffffffff80001800: 48 8b 93 10 03 00 00 mov 0x310(%rbx),%rdx +ffffffff80001807: 48 8b 8b e8 02 00 00 mov 0x2e8(%rbx),%rcx +ffffffff8000180e: 48 39 ca cmp %rcx,%rdx +ffffffff80001811: 74 7d je ffffffff80001890 + if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) { +ffffffff80001813: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff8000181a: 48 39 c2 cmp %rax,%rdx +ffffffff8000181d: 73 3c jae ffffffff8000185b +ffffffff8000181f: 48 8b b3 18 03 00 00 mov 0x318(%rbx),%rsi +ffffffff80001826: 48 3b b3 e0 00 00 00 cmp 0xe0(%rbx),%rsi +ffffffff8000182d: 73 2c jae ffffffff8000185b + ctx->plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y); +ffffffff8000182f: 48 0f af c6 imul %rsi,%rax +ffffffff80001833: 48 89 df mov %rbx,%rdi +ffffffff80001836: 48 01 d0 add %rdx,%rax +ffffffff80001839: 48 8d 0c 40 lea (%rax,%rax,2),%rcx +ffffffff8000183d: 48 8b 83 c0 02 00 00 mov 0x2c0(%rbx),%rax +ffffffff80001844: 48 8d 04 88 lea (%rax,%rcx,4),%rax +ffffffff80001848: 48 89 f1 mov %rsi,%rcx +ffffffff8000184b: 48 89 c6 mov %rax,%rsi +ffffffff8000184e: ff 93 b0 01 00 00 call *0x1b0(%rbx) + } + } + + ctx->old_cursor_x = ctx->cursor_x; +ffffffff80001854: 48 8b 8b e8 02 00 00 mov 0x2e8(%rbx),%rcx + ctx->old_cursor_y = ctx->cursor_y; +ffffffff8000185b: 48 8b 83 f0 02 00 00 mov 0x2f0(%rbx),%rax + ctx->old_cursor_x = ctx->cursor_x; +ffffffff80001862: 48 89 8b 10 03 00 00 mov %rcx,0x310(%rbx) + ctx->old_cursor_y = ctx->cursor_y; +ffffffff80001869: 48 89 83 18 03 00 00 mov %rax,0x318(%rbx) + + ctx->queue_i = 0; +ffffffff80001870: 48 c7 83 d0 02 00 00 movq $0x0,0x2d0(%rbx) +ffffffff80001877: 00 00 00 00 +} +ffffffff8000187b: 48 83 c4 08 add $0x8,%rsp +ffffffff8000187f: 5b pop %rbx +ffffffff80001880: 5d pop %rbp +ffffffff80001881: 41 5c pop %r12 +ffffffff80001883: 41 5d pop %r13 +ffffffff80001885: c3 ret +ffffffff80001886: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000188d: 00 00 00 + if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) { +ffffffff80001890: 48 8b 83 f0 02 00 00 mov 0x2f0(%rbx),%rax +ffffffff80001897: 48 39 83 18 03 00 00 cmp %rax,0x318(%rbx) +ffffffff8000189e: 0f 85 6f ff ff ff jne ffffffff80001813 +ffffffff800018a4: 80 7b 09 00 cmpb $0x0,0x9(%rbx) +ffffffff800018a8: 75 b8 jne ffffffff80001862 +ffffffff800018aa: e9 64 ff ff ff jmp ffffffff80001813 +ffffffff800018af: 90 nop + draw_cursor(_ctx); +ffffffff800018b0: e8 ab fd ff ff call ffffffff80001660 +ffffffff800018b5: e9 c1 fe ff ff jmp ffffffff8000177b +ffffffff800018ba: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff800018c0 : + +static void flanterm_fb_raw_putchar(struct flanterm_context *_ctx, uint8_t c) { +ffffffff800018c0: f3 0f 1e fa endbr64 +ffffffff800018c4: 55 push %rbp +ffffffff800018c5: 53 push %rbx +ffffffff800018c6: 89 f3 mov %esi,%ebx +ffffffff800018c8: 48 83 ec 20 sub $0x20,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) { +ffffffff800018cc: 48 8b 97 e8 02 00 00 mov 0x2e8(%rdi),%rdx +ffffffff800018d3: 48 8b af e8 00 00 00 mov 0xe8(%rdi),%rbp +ffffffff800018da: 48 8b 8f f0 02 00 00 mov 0x2f0(%rdi),%rcx +ffffffff800018e1: 48 39 ea cmp %rbp,%rdx +ffffffff800018e4: 72 50 jb ffffffff80001936 +ffffffff800018e6: 48 8b 47 70 mov 0x70(%rdi),%rax +ffffffff800018ea: 48 8d 70 ff lea -0x1(%rax),%rsi +ffffffff800018ee: 48 39 f1 cmp %rsi,%rcx +ffffffff800018f1: 73 3d jae ffffffff80001930 + ctx->cursor_x = 0; +ffffffff800018f3: 48 c7 87 e8 02 00 00 movq $0x0,0x2e8(%rdi) +ffffffff800018fa: 00 00 00 00 + ctx->cursor_y++; +ffffffff800018fe: 48 8d 51 01 lea 0x1(%rcx),%rdx + if (ctx->cursor_y == _ctx->scroll_bottom_margin) { +ffffffff80001902: 48 39 d0 cmp %rdx,%rax +ffffffff80001905: 0f 84 7d 00 00 00 je ffffffff80001988 + ctx->cursor_y++; +ffffffff8000190b: 48 89 97 f0 02 00 00 mov %rdx,0x2f0(%rdi) +ffffffff80001912: 48 89 d1 mov %rdx,%rcx + ctx->cursor_y--; + flanterm_fb_scroll(_ctx); + } + if (ctx->cursor_y >= _ctx->cols) { +ffffffff80001915: 48 39 e9 cmp %rbp,%rcx +ffffffff80001918: 72 5e jb ffffffff80001978 + ctx->cursor_y = _ctx->cols - 1; +ffffffff8000191a: 48 8d 4d ff lea -0x1(%rbp),%rcx +ffffffff8000191e: be 01 00 00 00 mov $0x1,%esi +ffffffff80001923: 31 d2 xor %edx,%edx +ffffffff80001925: 48 89 8f f0 02 00 00 mov %rcx,0x2f0(%rdi) +ffffffff8000192c: eb 0c jmp ffffffff8000193a +ffffffff8000192e: 66 90 xchg %ax,%ax + if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) { +ffffffff80001930: 80 7f 0a 00 cmpb $0x0,0xa(%rdi) +ffffffff80001934: 75 bd jne ffffffff800018f3 + + struct flanterm_fb_char ch; + ch.c = c; + ch.fg = ctx->text_fg; + ch.bg = ctx->text_bg; + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +ffffffff80001936: 48 8d 72 01 lea 0x1(%rdx),%rsi + ch.c = c; +ffffffff8000193a: 8b 87 e0 02 00 00 mov 0x2e0(%rdi),%eax + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +ffffffff80001940: 48 89 b7 e8 02 00 00 mov %rsi,0x2e8(%rdi) + ch.c = c; +ffffffff80001947: 0f b6 db movzbl %bl,%ebx + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +ffffffff8000194a: 48 8d 74 24 10 lea 0x10(%rsp),%rsi + ch.c = c; +ffffffff8000194f: 48 c1 e0 20 shl $0x20,%rax +ffffffff80001953: 48 09 c3 or %rax,%rbx + ch.bg = ctx->text_bg; +ffffffff80001956: 8b 87 e4 02 00 00 mov 0x2e4(%rdi),%eax + ch.c = c; +ffffffff8000195c: 48 89 5c 24 10 mov %rbx,0x10(%rsp) + ch.bg = ctx->text_bg; +ffffffff80001961: 89 44 24 18 mov %eax,0x18(%rsp) + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +ffffffff80001965: e8 66 f7 ff ff call ffffffff800010d0 +} +ffffffff8000196a: 48 83 c4 20 add $0x20,%rsp +ffffffff8000196e: 5b pop %rbx +ffffffff8000196f: 5d pop %rbp +ffffffff80001970: c3 ret +ffffffff80001971: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) +ffffffff80001978: be 01 00 00 00 mov $0x1,%esi +ffffffff8000197d: 31 d2 xor %edx,%edx +ffffffff8000197f: eb b9 jmp ffffffff8000193a +ffffffff80001981: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) +ffffffff80001988: 48 89 4c 24 08 mov %rcx,0x8(%rsp) + flanterm_fb_scroll(_ctx); +ffffffff8000198d: 48 89 3c 24 mov %rdi,(%rsp) +ffffffff80001991: e8 ca f8 ff ff call ffffffff80001260 +ffffffff80001996: 48 8b 4c 24 08 mov 0x8(%rsp),%rcx +ffffffff8000199b: 48 8b 3c 24 mov (%rsp),%rdi +ffffffff8000199f: e9 71 ff ff ff jmp ffffffff80001915 +ffffffff800019a4: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800019ab: 00 00 00 +ffffffff800019ae: 66 90 xchg %ax,%ax + +ffffffff800019b0 : + +static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) { +ffffffff800019b0: f3 0f 1e fa endbr64 +ffffffff800019b4: 41 55 push %r13 +ffffffff800019b6: 41 54 push %r12 +ffffffff800019b8: 55 push %rbp +ffffffff800019b9: 53 push %rbx +ffffffff800019ba: 48 89 fb mov %rdi,%rbx +ffffffff800019bd: 48 83 ec 08 sub $0x8,%rsp + struct flanterm_fb_context *ctx = (void *)_ctx; + + uint32_t default_bg = ctx->default_bg; + + for (size_t y = 0; y < ctx->height; y++) { +ffffffff800019c1: 4c 8b a7 10 02 00 00 mov 0x210(%rdi),%r12 + uint32_t default_bg = ctx->default_bg; +ffffffff800019c8: 8b af 8c 02 00 00 mov 0x28c(%rdi),%ebp + for (size_t y = 0; y < ctx->height; y++) { +ffffffff800019ce: 4d 85 e4 test %r12,%r12 +ffffffff800019d1: 0f 84 7c 00 00 00 je ffffffff80001a53 + for (size_t x = 0; x < ctx->width; x++) { +ffffffff800019d7: 48 8b bf 08 02 00 00 mov 0x208(%rdi),%rdi +ffffffff800019de: 45 31 db xor %r11d,%r11d + for (size_t y = 0; y < ctx->height; y++) { +ffffffff800019e1: 45 31 d2 xor %r10d,%r10d +ffffffff800019e4: 4c 8d 2c bd 00 00 00 lea 0x0(,%rdi,4),%r13 +ffffffff800019eb: 00 +ffffffff800019ec: 0f 1f 40 00 nopl 0x0(%rax) + for (size_t x = 0; x < ctx->width; x++) { +ffffffff800019f0: 48 85 ff test %rdi,%rdi +ffffffff800019f3: 74 52 je ffffffff80001a47 + if (ctx->canvas != NULL) { + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff800019f5: 48 8b 8b 00 02 00 00 mov 0x200(%rbx),%rcx +ffffffff800019fc: 4c 8b 83 f8 01 00 00 mov 0x1f8(%rbx),%r8 +ffffffff80001a03: 31 c0 xor %eax,%eax + if (ctx->canvas != NULL) { +ffffffff80001a05: 48 8b b3 a0 02 00 00 mov 0x2a0(%rbx),%rsi + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff80001a0c: 48 c1 e9 02 shr $0x2,%rcx +ffffffff80001a10: 49 0f af ca imul %r10,%rcx +ffffffff80001a14: 49 8d 14 88 lea (%r8,%rcx,4),%rdx + if (ctx->canvas != NULL) { +ffffffff80001a18: 48 85 f6 test %rsi,%rsi +ffffffff80001a1b: 0f 84 a7 00 00 00 je ffffffff80001ac8 +ffffffff80001a21: 4e 8d 0c 1e lea (%rsi,%r11,1),%r9 +ffffffff80001a25: eb 11 jmp ffffffff80001a38 +ffffffff80001a27: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80001a2e: 00 00 + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff80001a30: 48 8d 14 08 lea (%rax,%rcx,1),%rdx +ffffffff80001a34: 49 8d 14 90 lea (%r8,%rdx,4),%rdx +ffffffff80001a38: 41 8b 34 81 mov (%r9,%rax,4),%esi + for (size_t x = 0; x < ctx->width; x++) { +ffffffff80001a3c: 48 83 c0 01 add $0x1,%rax + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff80001a40: 89 32 mov %esi,(%rdx) + for (size_t x = 0; x < ctx->width; x++) { +ffffffff80001a42: 48 39 c7 cmp %rax,%rdi +ffffffff80001a45: 75 e9 jne ffffffff80001a30 + for (size_t y = 0; y < ctx->height; y++) { +ffffffff80001a47: 49 83 c2 01 add $0x1,%r10 +ffffffff80001a4b: 4d 01 eb add %r13,%r11 +ffffffff80001a4e: 4d 39 e2 cmp %r12,%r10 +ffffffff80001a51: 75 9d jne ffffffff800019f0 + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg; + } + } + } + + for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) { +ffffffff80001a53: 48 8b 8b e8 00 00 00 mov 0xe8(%rbx),%rcx +ffffffff80001a5a: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff80001a61: 31 ed xor %ebp,%ebp +ffffffff80001a63: 48 0f af c1 imul %rcx,%rax +ffffffff80001a67: 48 85 c0 test %rax,%rax +ffffffff80001a6a: 74 43 je ffffffff80001aaf +ffffffff80001a6c: 0f 1f 40 00 nopl 0x0(%rax) + size_t x = i % _ctx->cols; +ffffffff80001a70: 48 89 e8 mov %rbp,%rax +ffffffff80001a73: 31 d2 xor %edx,%edx + size_t y = i / _ctx->cols; + + ctx->plot_char(_ctx, &ctx->grid[i], x, y); +ffffffff80001a75: 48 8d 74 6d 00 lea 0x0(%rbp,%rbp,2),%rsi +ffffffff80001a7a: 48 89 df mov %rbx,%rdi +ffffffff80001a7d: 48 f7 f1 div %rcx + for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) { +ffffffff80001a80: 48 83 c5 01 add $0x1,%rbp +ffffffff80001a84: 48 89 c1 mov %rax,%rcx + ctx->plot_char(_ctx, &ctx->grid[i], x, y); +ffffffff80001a87: 48 8b 83 c0 02 00 00 mov 0x2c0(%rbx),%rax +ffffffff80001a8e: 48 8d 34 b0 lea (%rax,%rsi,4),%rsi +ffffffff80001a92: ff 93 b0 01 00 00 call *0x1b0(%rbx) + for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) { +ffffffff80001a98: 48 8b 8b e8 00 00 00 mov 0xe8(%rbx),%rcx +ffffffff80001a9f: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff80001aa6: 48 0f af c1 imul %rcx,%rax +ffffffff80001aaa: 48 39 c5 cmp %rax,%rbp +ffffffff80001aad: 72 c1 jb ffffffff80001a70 + } + + if (_ctx->cursor_enabled) { +ffffffff80001aaf: 80 7b 09 00 cmpb $0x0,0x9(%rbx) +ffffffff80001ab3: 75 33 jne ffffffff80001ae8 + draw_cursor(_ctx); + } +} +ffffffff80001ab5: 48 83 c4 08 add $0x8,%rsp +ffffffff80001ab9: 5b pop %rbx +ffffffff80001aba: 5d pop %rbp +ffffffff80001abb: 41 5c pop %r12 +ffffffff80001abd: 41 5d pop %r13 +ffffffff80001abf: c3 ret + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x]; +ffffffff80001ac0: 48 8d 14 08 lea (%rax,%rcx,1),%rdx +ffffffff80001ac4: 49 8d 14 90 lea (%r8,%rdx,4),%rdx + for (size_t x = 0; x < ctx->width; x++) { +ffffffff80001ac8: 48 83 c0 01 add $0x1,%rax + ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg; +ffffffff80001acc: 89 2a mov %ebp,(%rdx) + for (size_t x = 0; x < ctx->width; x++) { +ffffffff80001ace: 48 39 f8 cmp %rdi,%rax +ffffffff80001ad1: 75 ed jne ffffffff80001ac0 + for (size_t y = 0; y < ctx->height; y++) { +ffffffff80001ad3: 49 83 c2 01 add $0x1,%r10 +ffffffff80001ad7: 4d 01 eb add %r13,%r11 +ffffffff80001ada: 4d 39 e2 cmp %r12,%r10 +ffffffff80001add: 0f 85 0d ff ff ff jne ffffffff800019f0 +ffffffff80001ae3: e9 6b ff ff ff jmp ffffffff80001a53 +} +ffffffff80001ae8: 48 83 c4 08 add $0x8,%rsp + draw_cursor(_ctx); +ffffffff80001aec: 48 89 df mov %rbx,%rdi +} +ffffffff80001aef: 5b pop %rbx +ffffffff80001af0: 5d pop %rbp +ffffffff80001af1: 41 5c pop %r12 +ffffffff80001af3: 41 5d pop %r13 + draw_cursor(_ctx); +ffffffff80001af5: e9 66 fb ff ff jmp ffffffff80001660 +ffffffff80001afa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff80001b00 : + +static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) { +ffffffff80001b00: f3 0f 1e fa endbr64 + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (_free == NULL) { +ffffffff80001b04: 48 85 f6 test %rsi,%rsi +ffffffff80001b07: 0f 84 8b 00 00 00 je ffffffff80001b98 +static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) { +ffffffff80001b0d: 55 push %rbp +ffffffff80001b0e: 48 89 f5 mov %rsi,%rbp +ffffffff80001b11: 53 push %rbx +ffffffff80001b12: 48 89 fb mov %rdi,%rbx +ffffffff80001b15: 48 83 ec 08 sub $0x8,%rsp + } +#endif + return; + } + + _free(ctx->font_bits, ctx->font_bits_size); +ffffffff80001b19: 48 8b b7 28 02 00 00 mov 0x228(%rdi),%rsi +ffffffff80001b20: 48 8b bf 30 02 00 00 mov 0x230(%rdi),%rdi +ffffffff80001b27: ff d5 call *%rbp + _free(ctx->font_bool, ctx->font_bool_size); +ffffffff80001b29: 48 8b b3 38 02 00 00 mov 0x238(%rbx),%rsi +ffffffff80001b30: 48 8b bb 40 02 00 00 mov 0x240(%rbx),%rdi +ffffffff80001b37: ff d5 call *%rbp + _free(ctx->grid, ctx->grid_size); +ffffffff80001b39: 48 8b b3 a8 02 00 00 mov 0x2a8(%rbx),%rsi +ffffffff80001b40: 48 8b bb c0 02 00 00 mov 0x2c0(%rbx),%rdi +ffffffff80001b47: ff d5 call *%rbp + _free(ctx->queue, ctx->queue_size); +ffffffff80001b49: 48 8b b3 b0 02 00 00 mov 0x2b0(%rbx),%rsi +ffffffff80001b50: 48 8b bb c8 02 00 00 mov 0x2c8(%rbx),%rdi +ffffffff80001b57: ff d5 call *%rbp + _free(ctx->map, ctx->map_size); +ffffffff80001b59: 48 8b bb d8 02 00 00 mov 0x2d8(%rbx),%rdi +ffffffff80001b60: 48 8b b3 b8 02 00 00 mov 0x2b8(%rbx),%rsi +ffffffff80001b67: ff d5 call *%rbp + + if (ctx->canvas != NULL) { +ffffffff80001b69: 48 8b bb a0 02 00 00 mov 0x2a0(%rbx),%rdi +ffffffff80001b70: 48 85 ff test %rdi,%rdi +ffffffff80001b73: 74 09 je ffffffff80001b7e + _free(ctx->canvas, ctx->canvas_size); +ffffffff80001b75: 48 8b b3 98 02 00 00 mov 0x298(%rbx),%rsi +ffffffff80001b7c: ff d5 call *%rbp + } + + _free(ctx, sizeof(struct flanterm_fb_context)); +} +ffffffff80001b7e: 48 83 c4 08 add $0x8,%rsp + _free(ctx, sizeof(struct flanterm_fb_context)); +ffffffff80001b82: 48 89 df mov %rbx,%rdi +ffffffff80001b85: 48 89 e8 mov %rbp,%rax +ffffffff80001b88: be 20 03 00 00 mov $0x320,%esi +} +ffffffff80001b8d: 5b pop %rbx +ffffffff80001b8e: 5d pop %rbp + _free(ctx, sizeof(struct flanterm_fb_context)); +ffffffff80001b8f: ff e0 jmp *%rax +ffffffff80001b91: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + if (bump_allocated_instance == true) { +ffffffff80001b98: 80 3d 62 95 00 00 00 cmpb $0x0,0x9562(%rip) # ffffffff8000b101 +ffffffff80001b9f: 74 17 je ffffffff80001bb8 + bump_alloc_ptr = 0; +ffffffff80001ba1: 48 c7 05 5c 95 00 00 movq $0x0,0x955c(%rip) # ffffffff8000b108 +ffffffff80001ba8: 00 00 00 00 + bump_allocated_instance = false; +ffffffff80001bac: c6 05 4e 95 00 00 00 movb $0x0,0x954e(%rip) # ffffffff8000b101 +ffffffff80001bb3: c3 ret +ffffffff80001bb4: 0f 1f 40 00 nopl 0x0(%rax) +ffffffff80001bb8: c3 ret +ffffffff80001bb9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + +ffffffff80001bc0 : +static void plot_char_scaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001bc0: f3 0f 1e fa endbr64 +ffffffff80001bc4: 41 57 push %r15 +ffffffff80001bc6: 41 56 push %r14 +ffffffff80001bc8: 41 55 push %r13 +ffffffff80001bca: 41 54 push %r12 +ffffffff80001bcc: 55 push %rbp +ffffffff80001bcd: 53 push %rbx +ffffffff80001bce: 48 89 fb mov %rdi,%rbx +ffffffff80001bd1: 48 83 ec 48 sub $0x48,%rsp + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80001bd5: 48 3b 97 e8 00 00 00 cmp 0xe8(%rdi),%rdx +ffffffff80001bdc: 0f 83 9b 01 00 00 jae ffffffff80001d7d +ffffffff80001be2: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80001be9: 0f 83 8e 01 00 00 jae ffffffff80001d7d +ffffffff80001bef: 48 89 f7 mov %rsi,%rdi + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001bf2: 48 8b b3 d0 01 00 00 mov 0x1d0(%rbx),%rsi + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001bf9: 48 0f af 93 c8 01 00 imul 0x1c8(%rbx),%rdx +ffffffff80001c00: 00 + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001c01: 48 8b ab b8 01 00 00 mov 0x1b8(%rbx),%rbp + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001c08: 48 03 93 e8 01 00 00 add 0x1e8(%rbx),%rdx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001c0f: 48 89 f0 mov %rsi,%rax +ffffffff80001c12: 48 89 74 24 10 mov %rsi,0x10(%rsp) +ffffffff80001c17: 48 0f af c1 imul %rcx,%rax + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001c1b: 48 8b 8b 40 02 00 00 mov 0x240(%rbx),%rcx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001c22: 48 03 83 f0 01 00 00 add 0x1f0(%rbx),%rax + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001c29: 48 89 4c 24 18 mov %rcx,0x18(%rsp) +ffffffff80001c2e: 8b 0f mov (%rdi),%ecx +ffffffff80001c30: 48 0f af 8b c0 01 00 imul 0x1c0(%rbx),%rcx +ffffffff80001c37: 00 +ffffffff80001c38: 48 89 4c 24 20 mov %rcx,0x20(%rsp) + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001c3d: 48 85 f6 test %rsi,%rsi +ffffffff80001c40: 0f 84 37 01 00 00 je ffffffff80001d7d + uint8_t fy = gy / ctx->font_scale_y; +ffffffff80001c46: 48 8b b3 e0 01 00 00 mov 0x1e0(%rbx),%rsi + uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width; +ffffffff80001c4d: 48 8b 8b 08 02 00 00 mov 0x208(%rbx),%rcx + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001c54: 45 31 c9 xor %r9d,%r9d + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001c57: 4c 8b 93 00 02 00 00 mov 0x200(%rbx),%r10 + uint8_t fy = gy / ctx->font_scale_y; +ffffffff80001c5e: 48 89 74 24 28 mov %rsi,0x28(%rsp) + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001c63: 48 8b b3 f8 01 00 00 mov 0x1f8(%rbx),%rsi +ffffffff80001c6a: 49 c1 ea 02 shr $0x2,%r10 +ffffffff80001c6e: 48 89 74 24 40 mov %rsi,0x40(%rsp) +ffffffff80001c73: 48 8d 34 8d 00 00 00 lea 0x0(,%rcx,4),%rsi +ffffffff80001c7a: 00 +ffffffff80001c7b: 48 0f af c8 imul %rax,%rcx +ffffffff80001c7f: 48 89 74 24 38 mov %rsi,0x38(%rsp) +ffffffff80001c84: 48 8b b3 a0 02 00 00 mov 0x2a0(%rbx),%rsi +ffffffff80001c8b: 49 0f af c2 imul %r10,%rax +ffffffff80001c8f: 4c 89 54 24 30 mov %r10,0x30(%rsp) + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001c94: 49 89 da mov %rbx,%r10 +ffffffff80001c97: 48 01 d1 add %rdx,%rcx +ffffffff80001c9a: 4c 8d 34 8e lea (%rsi,%rcx,4),%r14 +ffffffff80001c9e: 4c 8d 3c 10 lea (%rax,%rdx,1),%r15 +ffffffff80001ca2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + uint8_t fy = gy / ctx->font_scale_y; +ffffffff80001ca8: 4c 89 c8 mov %r9,%rax +ffffffff80001cab: 31 d2 xor %edx,%edx +ffffffff80001cad: 48 f7 74 24 28 divq 0x28(%rsp) + bool *glyph_pointer = glyph + (fy * ctx->font_width); +ffffffff80001cb2: 0f b6 c8 movzbl %al,%ecx +ffffffff80001cb5: 48 8b 44 24 20 mov 0x20(%rsp),%rax +ffffffff80001cba: 48 01 c1 add %rax,%rcx +ffffffff80001cbd: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80001cc2: 48 0f af cd imul %rbp,%rcx +ffffffff80001cc6: 48 01 c1 add %rax,%rcx + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001cc9: 48 85 ed test %rbp,%rbp +ffffffff80001ccc: 0f 84 8c 00 00 00 je ffffffff80001d5e + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80001cd2: 4d 8b a2 d8 01 00 00 mov 0x1d8(%r10),%r12 +ffffffff80001cd9: 48 8b 44 24 40 mov 0x40(%rsp),%rax +ffffffff80001cde: 4c 8d 2c 29 lea (%rcx,%rbp,1),%r13 +ffffffff80001ce2: 4c 89 ce mov %r9,%rsi +ffffffff80001ce5: 48 89 6c 24 08 mov %rbp,0x8(%rsp) +ffffffff80001cea: 4e 8d 1c a5 00 00 00 lea 0x0(,%r12,4),%r11 +ffffffff80001cf1: 00 +ffffffff80001cf2: 4a 8d 1c b8 lea (%rax,%r15,4),%rbx +ffffffff80001cf6: 4f 8d 04 33 lea (%r11,%r14,1),%r8 +ffffffff80001cfa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80001d00: 4d 85 e4 test %r12,%r12 +ffffffff80001d03: 74 42 je ffffffff80001d47 + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80001d05: 48 89 0c 24 mov %rcx,(%rsp) +ffffffff80001d09: 4c 89 c2 mov %r8,%rdx +ffffffff80001d0c: 0f b6 29 movzbl (%rcx),%ebp +ffffffff80001d0f: 49 89 d9 mov %rbx,%r9 +ffffffff80001d12: 4c 29 da sub %r11,%rdx +ffffffff80001d15: 0f 1f 00 nopl (%rax) + uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg; +ffffffff80001d18: 8b 47 08 mov 0x8(%rdi),%eax +ffffffff80001d1b: 83 f8 ff cmp $0xffffffff,%eax +ffffffff80001d1e: 75 02 jne ffffffff80001d22 +ffffffff80001d20: 8b 02 mov (%rdx),%eax + uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg; +ffffffff80001d22: 8b 4f 04 mov 0x4(%rdi),%ecx +ffffffff80001d25: 83 f9 ff cmp $0xffffffff,%ecx +ffffffff80001d28: 75 02 jne ffffffff80001d2c +ffffffff80001d2a: 8b 0a mov (%rdx),%ecx + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80001d2c: 40 84 ed test %bpl,%bpl +ffffffff80001d2f: 0f 45 c1 cmovne %ecx,%eax + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80001d32: 48 83 c2 04 add $0x4,%rdx +ffffffff80001d36: 49 83 c1 04 add $0x4,%r9 + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80001d3a: 41 89 41 fc mov %eax,-0x4(%r9) + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80001d3e: 49 39 d0 cmp %rdx,%r8 +ffffffff80001d41: 75 d5 jne ffffffff80001d18 +ffffffff80001d43: 48 8b 0c 24 mov (%rsp),%rcx + glyph_pointer++; +ffffffff80001d47: 48 83 c1 01 add $0x1,%rcx + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001d4b: 4d 01 d8 add %r11,%r8 +ffffffff80001d4e: 4c 01 db add %r11,%rbx +ffffffff80001d51: 4c 39 e9 cmp %r13,%rcx +ffffffff80001d54: 75 aa jne ffffffff80001d00 +ffffffff80001d56: 48 8b 6c 24 08 mov 0x8(%rsp),%rbp +ffffffff80001d5b: 49 89 f1 mov %rsi,%r9 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001d5e: 48 8b 44 24 38 mov 0x38(%rsp),%rax +ffffffff80001d63: 49 83 c1 01 add $0x1,%r9 +ffffffff80001d67: 49 01 c6 add %rax,%r14 +ffffffff80001d6a: 48 8b 44 24 30 mov 0x30(%rsp),%rax +ffffffff80001d6f: 49 01 c7 add %rax,%r15 +ffffffff80001d72: 4c 39 4c 24 10 cmp %r9,0x10(%rsp) +ffffffff80001d77: 0f 85 2b ff ff ff jne ffffffff80001ca8 +} +ffffffff80001d7d: 48 83 c4 48 add $0x48,%rsp +ffffffff80001d81: 5b pop %rbx +ffffffff80001d82: 5d pop %rbp +ffffffff80001d83: 41 5c pop %r12 +ffffffff80001d85: 41 5d pop %r13 +ffffffff80001d87: 41 5e pop %r14 +ffffffff80001d89: 41 5f pop %r15 +ffffffff80001d8b: c3 ret +ffffffff80001d8c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80001d90 : +static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001d90: f3 0f 1e fa endbr64 +ffffffff80001d94: 48 89 f8 mov %rdi,%rax + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80001d97: 48 3b 97 e8 00 00 00 cmp 0xe8(%rdi),%rdx +ffffffff80001d9e: 0f 83 0c 01 00 00 jae ffffffff80001eb0 +ffffffff80001da4: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80001dab: 0f 83 ff 00 00 00 jae ffffffff80001eb0 +static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001db1: 41 56 push %r14 +ffffffff80001db3: 48 89 f7 mov %rsi,%rdi +ffffffff80001db6: 41 55 push %r13 +ffffffff80001db8: 41 54 push %r12 +ffffffff80001dba: 55 push %rbp +ffffffff80001dbb: 53 push %rbx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001dbc: 4c 8b a0 d0 01 00 00 mov 0x1d0(%rax),%r12 + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001dc3: 8b 1e mov (%rsi),%ebx +ffffffff80001dc5: 4c 8b 88 b8 01 00 00 mov 0x1b8(%rax),%r9 +ffffffff80001dcc: 48 8b b0 c0 01 00 00 mov 0x1c0(%rax),%rsi + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001dd3: 48 0f af 90 c8 01 00 imul 0x1c8(%rax),%rdx +ffffffff80001dda: 00 + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001ddb: 49 0f af cc imul %r12,%rcx + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001ddf: 4c 8b 80 40 02 00 00 mov 0x240(%rax),%r8 + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001de6: 48 03 90 e8 01 00 00 add 0x1e8(%rax),%rdx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001ded: 49 0f af f1 imul %r9,%rsi +ffffffff80001df1: 48 03 88 f0 01 00 00 add 0x1f0(%rax),%rcx + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001df8: 4d 85 e4 test %r12,%r12 +ffffffff80001dfb: 0f 84 a1 00 00 00 je ffffffff80001ea2 + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001e01: 48 8b a8 00 02 00 00 mov 0x200(%rax),%rbp + uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width; +ffffffff80001e08: 4c 8b 90 08 02 00 00 mov 0x208(%rax),%r10 +ffffffff80001e0f: 49 89 cb mov %rcx,%r11 +ffffffff80001e12: 48 0f af f3 imul %rbx,%rsi + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001e16: 4c 8b b0 f8 01 00 00 mov 0x1f8(%rax),%r14 +ffffffff80001e1d: 48 8b 80 a0 02 00 00 mov 0x2a0(%rax),%rax + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001e24: 31 db xor %ebx,%ebx + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001e26: 48 c1 ed 02 shr $0x2,%rbp +ffffffff80001e2a: 49 0f af ca imul %r10,%rcx +ffffffff80001e2e: 4e 8d 2c 95 00 00 00 lea 0x0(,%r10,4),%r13 +ffffffff80001e35: 00 +ffffffff80001e36: 4c 0f af dd imul %rbp,%r11 +ffffffff80001e3a: 49 01 f0 add %rsi,%r8 +ffffffff80001e3d: 49 01 d3 add %rdx,%r11 +ffffffff80001e40: 48 01 ca add %rcx,%rdx +ffffffff80001e43: 4c 8d 14 90 lea (%rax,%rdx,4),%r10 +ffffffff80001e47: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80001e4e: 00 00 + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001e50: 4d 85 c9 test %r9,%r9 +ffffffff80001e53: 74 3b je ffffffff80001e90 +ffffffff80001e55: 4b 8d 34 9e lea (%r14,%r11,4),%rsi +ffffffff80001e59: 31 d2 xor %edx,%edx +ffffffff80001e5b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + uint32_t bg = c->bg == 0xffffffff ? canvas_line[fx] : c->bg; +ffffffff80001e60: 8b 47 08 mov 0x8(%rdi),%eax +ffffffff80001e63: 83 f8 ff cmp $0xffffffff,%eax +ffffffff80001e66: 75 04 jne ffffffff80001e6c +ffffffff80001e68: 41 8b 04 92 mov (%r10,%rdx,4),%eax + uint32_t fg = c->fg == 0xffffffff ? canvas_line[fx] : c->fg; +ffffffff80001e6c: 8b 4f 04 mov 0x4(%rdi),%ecx +ffffffff80001e6f: 83 f9 ff cmp $0xffffffff,%ecx +ffffffff80001e72: 75 04 jne ffffffff80001e78 +ffffffff80001e74: 41 8b 0c 92 mov (%r10,%rdx,4),%ecx + fb_line[fx] = *(glyph_pointer++) ? fg : bg; +ffffffff80001e78: 41 80 3c 10 00 cmpb $0x0,(%r8,%rdx,1) +ffffffff80001e7d: 0f 45 c1 cmovne %ecx,%eax + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001e80: 48 83 c2 01 add $0x1,%rdx +ffffffff80001e84: 48 83 c6 04 add $0x4,%rsi + fb_line[fx] = *(glyph_pointer++) ? fg : bg; +ffffffff80001e88: 89 46 fc mov %eax,-0x4(%rsi) + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001e8b: 49 39 d1 cmp %rdx,%r9 +ffffffff80001e8e: 75 d0 jne ffffffff80001e60 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001e90: 48 83 c3 01 add $0x1,%rbx +ffffffff80001e94: 49 01 eb add %rbp,%r11 +ffffffff80001e97: 4d 01 c8 add %r9,%r8 +ffffffff80001e9a: 4d 01 ea add %r13,%r10 +ffffffff80001e9d: 49 39 dc cmp %rbx,%r12 +ffffffff80001ea0: 75 ae jne ffffffff80001e50 +} +ffffffff80001ea2: 5b pop %rbx +ffffffff80001ea3: 5d pop %rbp +ffffffff80001ea4: 41 5c pop %r12 +ffffffff80001ea6: 41 5d pop %r13 +ffffffff80001ea8: 41 5e pop %r14 +ffffffff80001eaa: c3 ret +ffffffff80001eab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80001eb0: c3 ret +ffffffff80001eb1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001eb8: 00 00 00 +ffffffff80001ebb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001ec0 : +static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001ec0: f3 0f 1e fa endbr64 + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80001ec4: 48 3b 97 e8 00 00 00 cmp 0xe8(%rdi),%rdx +ffffffff80001ecb: 0f 83 ff 00 00 00 jae ffffffff80001fd0 +ffffffff80001ed1: 48 89 f8 mov %rdi,%rax +ffffffff80001ed4: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80001edb: 0f 83 ef 00 00 00 jae ffffffff80001fd0 +static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001ee1: 41 57 push %r15 +ffffffff80001ee3: 41 56 push %r14 +ffffffff80001ee5: 41 55 push %r13 +ffffffff80001ee7: 41 54 push %r12 +ffffffff80001ee9: 55 push %rbp +ffffffff80001eea: 53 push %rbx +ffffffff80001eeb: 44 8b 46 08 mov 0x8(%rsi),%r8d + uint32_t default_bg = ctx->default_bg; +ffffffff80001eef: 44 8b 88 8c 02 00 00 mov 0x28c(%rax),%r9d + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; +ffffffff80001ef6: 8b 7e 04 mov 0x4(%rsi),%edi +ffffffff80001ef9: 41 83 f8 ff cmp $0xffffffff,%r8d + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001efd: 4c 8b a0 d0 01 00 00 mov 0x1d0(%rax),%r12 + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001f04: 44 8b 3e mov (%rsi),%r15d +ffffffff80001f07: 48 8b 98 b8 01 00 00 mov 0x1b8(%rax),%rbx +ffffffff80001f0e: 4c 8b 90 c0 01 00 00 mov 0x1c0(%rax),%r10 + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; +ffffffff80001f15: 45 0f 44 c1 cmove %r9d,%r8d + uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg; +ffffffff80001f19: 83 ff ff cmp $0xffffffff,%edi +ffffffff80001f1c: 41 0f 44 f9 cmove %r9d,%edi + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001f20: 4c 8b 88 40 02 00 00 mov 0x240(%rax),%r9 + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80001f27: 48 0f af 90 c8 01 00 imul 0x1c8(%rax),%rdx +ffffffff80001f2e: 00 +ffffffff80001f2f: 48 03 90 e8 01 00 00 add 0x1e8(%rax),%rdx + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80001f36: 49 0f af cc imul %r12,%rcx +ffffffff80001f3a: 48 03 88 f0 01 00 00 add 0x1f0(%rax),%rcx + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80001f41: 4c 0f af d3 imul %rbx,%r10 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001f45: 4d 85 e4 test %r12,%r12 +ffffffff80001f48: 74 7a je ffffffff80001fc4 + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80001f4a: 48 8b a8 00 02 00 00 mov 0x200(%rax),%rbp +ffffffff80001f51: 4d 0f af d7 imul %r15,%r10 +ffffffff80001f55: 4c 8b b0 f8 01 00 00 mov 0x1f8(%rax),%r14 +ffffffff80001f5c: 48 8d 04 1a lea (%rdx,%rbx,1),%rax +ffffffff80001f60: 48 c1 ed 02 shr $0x2,%rbp +ffffffff80001f64: 48 0f af cd imul %rbp,%rcx +ffffffff80001f68: 4d 01 d1 add %r10,%r9 +ffffffff80001f6b: 4c 8d 2c ad 00 00 00 lea 0x0(,%rbp,4),%r13 +ffffffff80001f72: 00 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001f73: 45 31 d2 xor %r10d,%r10d +ffffffff80001f76: 48 01 c8 add %rcx,%rax +ffffffff80001f79: 4c 8d 1c 0a lea (%rdx,%rcx,1),%r11 +ffffffff80001f7d: 49 8d 34 86 lea (%r14,%rax,4),%rsi +ffffffff80001f81: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + bool *glyph_pointer = glyph + (gy * ctx->font_width); +ffffffff80001f88: 4c 89 ca mov %r9,%rdx + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001f8b: 48 85 db test %rbx,%rbx +ffffffff80001f8e: 74 22 je ffffffff80001fb2 +ffffffff80001f90: 4b 8d 04 9e lea (%r14,%r11,4),%rax +ffffffff80001f94: 0f 1f 40 00 nopl 0x0(%rax) + fb_line[fx] = *(glyph_pointer++) ? fg : bg; +ffffffff80001f98: 48 83 c2 01 add $0x1,%rdx +ffffffff80001f9c: 89 f9 mov %edi,%ecx +ffffffff80001f9e: 80 7a ff 00 cmpb $0x0,-0x1(%rdx) +ffffffff80001fa2: 41 0f 44 c8 cmove %r8d,%ecx + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001fa6: 48 83 c0 04 add $0x4,%rax + fb_line[fx] = *(glyph_pointer++) ? fg : bg; +ffffffff80001faa: 89 48 fc mov %ecx,-0x4(%rax) + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80001fad: 48 39 f0 cmp %rsi,%rax +ffffffff80001fb0: 75 e6 jne ffffffff80001f98 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80001fb2: 49 83 c2 01 add $0x1,%r10 +ffffffff80001fb6: 49 01 eb add %rbp,%r11 +ffffffff80001fb9: 4c 01 ee add %r13,%rsi +ffffffff80001fbc: 49 01 d9 add %rbx,%r9 +ffffffff80001fbf: 4d 39 d4 cmp %r10,%r12 +ffffffff80001fc2: 75 c4 jne ffffffff80001f88 +} +ffffffff80001fc4: 5b pop %rbx +ffffffff80001fc5: 5d pop %rbp +ffffffff80001fc6: 41 5c pop %r12 +ffffffff80001fc8: 41 5d pop %r13 +ffffffff80001fca: 41 5e pop %r14 +ffffffff80001fcc: 41 5f pop %r15 +ffffffff80001fce: c3 ret +ffffffff80001fcf: 90 nop +ffffffff80001fd0: c3 ret +ffffffff80001fd1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80001fd8: 00 00 00 +ffffffff80001fdb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80001fe0 : +static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001fe0: f3 0f 1e fa endbr64 + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80001fe4: 48 3b 97 e8 00 00 00 cmp 0xe8(%rdi),%rdx +ffffffff80001feb: 0f 83 69 01 00 00 jae ffffffff8000215a +static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { +ffffffff80001ff1: 41 57 push %r15 +ffffffff80001ff3: 41 56 push %r14 +ffffffff80001ff5: 41 55 push %r13 +ffffffff80001ff7: 41 54 push %r12 +ffffffff80001ff9: 55 push %rbp +ffffffff80001ffa: 48 89 fd mov %rdi,%rbp +ffffffff80001ffd: 53 push %rbx +ffffffff80001ffe: 48 83 ec 20 sub $0x20,%rsp + if (x >= _ctx->cols || y >= _ctx->rows) { +ffffffff80002002: 48 3b 8f e0 00 00 00 cmp 0xe0(%rdi),%rcx +ffffffff80002009: 0f 83 3c 01 00 00 jae ffffffff8000214b +ffffffff8000200f: 44 8b 7e 08 mov 0x8(%rsi),%r15d + uint32_t default_bg = ctx->default_bg; +ffffffff80002013: 8b 87 8c 02 00 00 mov 0x28c(%rdi),%eax + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; +ffffffff80002019: 44 8b 76 04 mov 0x4(%rsi),%r14d + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff8000201d: 48 8b 9d 40 02 00 00 mov 0x240(%rbp),%rbx + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; +ffffffff80002024: 41 83 ff ff cmp $0xffffffff,%r15d +ffffffff80002028: 44 0f 44 f8 cmove %eax,%r15d + uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg; +ffffffff8000202c: 41 83 fe ff cmp $0xffffffff,%r14d + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80002030: 48 89 5c 24 08 mov %rbx,0x8(%rsp) +ffffffff80002035: 48 8b 9d b8 01 00 00 mov 0x1b8(%rbp),%rbx + uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg; +ffffffff8000203c: 44 0f 44 f0 cmove %eax,%r14d + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff80002040: 48 8b 87 c8 01 00 00 mov 0x1c8(%rdi),%rax +ffffffff80002047: 48 0f af c2 imul %rdx,%rax + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff8000204b: 8b 16 mov (%rsi),%edx + x = ctx->offset_x + x * ctx->glyph_width; +ffffffff8000204d: 48 03 87 e8 01 00 00 add 0x1e8(%rdi),%rax + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff80002054: 48 0f af 95 c0 01 00 imul 0x1c0(%rbp),%rdx +ffffffff8000205b: 00 + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff8000205c: 48 8b bf d0 01 00 00 mov 0x1d0(%rdi),%rdi +ffffffff80002063: 49 89 fb mov %rdi,%r11 +ffffffff80002066: 48 89 3c 24 mov %rdi,(%rsp) +ffffffff8000206a: 4c 0f af d9 imul %rcx,%r11 + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; +ffffffff8000206e: 48 89 54 24 10 mov %rdx,0x10(%rsp) + y = ctx->offset_y + y * ctx->glyph_height; +ffffffff80002073: 4c 03 9d f0 01 00 00 add 0x1f0(%rbp),%r11 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff8000207a: 48 85 ff test %rdi,%rdi +ffffffff8000207d: 0f 84 c8 00 00 00 je ffffffff8000214b + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff80002083: 4c 8b ad 00 02 00 00 mov 0x200(%rbp),%r13 +ffffffff8000208a: 48 8b bd f8 01 00 00 mov 0x1f8(%rbp),%rdi + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff80002091: 45 31 d2 xor %r10d,%r10d + uint8_t fy = gy / ctx->font_scale_y; +ffffffff80002094: 4c 8b a5 e0 01 00 00 mov 0x1e0(%rbp),%r12 + volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4); +ffffffff8000209b: 49 c1 ed 02 shr $0x2,%r13 +ffffffff8000209f: 48 89 7c 24 18 mov %rdi,0x18(%rsp) +ffffffff800020a4: 4d 0f af dd imul %r13,%r11 +ffffffff800020a8: 49 01 c3 add %rax,%r11 +ffffffff800020ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + uint8_t fy = gy / ctx->font_scale_y; +ffffffff800020b0: 4c 89 d0 mov %r10,%rax +ffffffff800020b3: 31 d2 xor %edx,%edx +ffffffff800020b5: 49 f7 f4 div %r12 + bool *glyph_pointer = glyph + (fy * ctx->font_width); +ffffffff800020b8: 0f b6 f0 movzbl %al,%esi +ffffffff800020bb: 48 8b 44 24 10 mov 0x10(%rsp),%rax +ffffffff800020c0: 48 01 c6 add %rax,%rsi +ffffffff800020c3: 48 8b 44 24 08 mov 0x8(%rsp),%rax +ffffffff800020c8: 48 0f af f3 imul %rbx,%rsi +ffffffff800020cc: 48 01 c6 add %rax,%rsi + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff800020cf: 48 85 db test %rbx,%rbx +ffffffff800020d2: 74 66 je ffffffff8000213a + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff800020d4: 4c 8b 85 d8 01 00 00 mov 0x1d8(%rbp),%r8 +ffffffff800020db: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx +ffffffff800020e0: 4c 8d 0c 1e lea (%rsi,%rbx,1),%r9 +ffffffff800020e4: 4b 8d 04 18 lea (%r8,%r11,1),%rax +ffffffff800020e8: 4a 8d 3c 85 00 00 00 lea 0x0(,%r8,4),%rdi +ffffffff800020ef: 00 +ffffffff800020f0: 48 8d 0c 81 lea (%rcx,%rax,4),%rcx +ffffffff800020f4: 0f 1f 40 00 nopl 0x0(%rax) +ffffffff800020f8: 4d 85 c0 test %r8,%r8 +ffffffff800020fb: 74 31 je ffffffff8000212e +ffffffff800020fd: 80 3e 00 cmpb $0x0,(%rsi) +ffffffff80002100: 44 89 fa mov %r15d,%edx +ffffffff80002103: 48 89 c8 mov %rcx,%rax +ffffffff80002106: 41 0f 45 d6 cmovne %r14d,%edx +ffffffff8000210a: 48 29 f8 sub %rdi,%rax +ffffffff8000210d: 40 f6 c7 04 test $0x4,%dil +ffffffff80002111: 74 0d je ffffffff80002120 + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80002113: 89 10 mov %edx,(%rax) + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80002115: 48 83 c0 04 add $0x4,%rax +ffffffff80002119: 48 39 c1 cmp %rax,%rcx +ffffffff8000211c: 74 10 je ffffffff8000212e +ffffffff8000211e: 66 90 xchg %ax,%ax + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80002120: 89 10 mov %edx,(%rax) + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80002122: 48 83 c0 08 add $0x8,%rax + fb_line[gx] = *glyph_pointer ? fg : bg; +ffffffff80002126: 89 50 fc mov %edx,-0x4(%rax) + for (size_t i = 0; i < ctx->font_scale_x; i++) { +ffffffff80002129: 48 39 c1 cmp %rax,%rcx +ffffffff8000212c: 75 f2 jne ffffffff80002120 + glyph_pointer++; +ffffffff8000212e: 48 83 c6 01 add $0x1,%rsi + for (size_t fx = 0; fx < ctx->font_width; fx++) { +ffffffff80002132: 48 01 f9 add %rdi,%rcx +ffffffff80002135: 4c 39 ce cmp %r9,%rsi +ffffffff80002138: 75 be jne ffffffff800020f8 + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { +ffffffff8000213a: 49 83 c2 01 add $0x1,%r10 +ffffffff8000213e: 4d 01 eb add %r13,%r11 +ffffffff80002141: 4c 39 14 24 cmp %r10,(%rsp) +ffffffff80002145: 0f 85 65 ff ff ff jne ffffffff800020b0 +} +ffffffff8000214b: 48 83 c4 20 add $0x20,%rsp +ffffffff8000214f: 5b pop %rbx +ffffffff80002150: 5d pop %rbp +ffffffff80002151: 41 5c pop %r12 +ffffffff80002153: 41 5d pop %r13 +ffffffff80002155: 41 5e pop %r14 +ffffffff80002157: 41 5f pop %r15 +ffffffff80002159: c3 ret +ffffffff8000215a: c3 ret +ffffffff8000215b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80002160 : + uint32_t *default_bg, uint32_t *default_fg, + uint32_t *default_bg_bright, uint32_t *default_fg_bright, + void *font, size_t font_width, size_t font_height, size_t font_spacing, + size_t font_scale_x, size_t font_scale_y, + size_t margin +) { +ffffffff80002160: f3 0f 1e fa endbr64 +ffffffff80002164: 41 57 push %r15 +ffffffff80002166: 49 89 ff mov %rdi,%r15 +ffffffff80002169: 41 56 push %r14 +ffffffff8000216b: 41 55 push %r13 +ffffffff8000216d: 49 89 cd mov %rcx,%r13 +ffffffff80002170: 41 54 push %r12 +ffffffff80002172: 4d 89 c4 mov %r8,%r12 +ffffffff80002175: 55 push %rbp +ffffffff80002176: 53 push %rbx +ffffffff80002177: 48 83 ec 48 sub $0x48,%rsp +ffffffff8000217b: 8b 84 24 88 00 00 00 mov 0x88(%rsp),%eax +ffffffff80002182: 44 8b b4 24 80 00 00 mov 0x80(%rsp),%r14d +ffffffff80002189: 00 +ffffffff8000218a: 48 89 74 24 18 mov %rsi,0x18(%rsp) + if (font_scale_x == 0 || font_scale_y == 0) { +ffffffff8000218f: 48 83 bc 24 08 01 00 cmpq $0x0,0x108(%rsp) +ffffffff80002196: 00 00 +) { +ffffffff80002198: 48 89 54 24 08 mov %rdx,0x8(%rsp) +ffffffff8000219d: 89 44 24 34 mov %eax,0x34(%rsp) +ffffffff800021a1: 8b 84 24 90 00 00 00 mov 0x90(%rsp),%eax +ffffffff800021a8: 4c 89 4c 24 20 mov %r9,0x20(%rsp) +ffffffff800021ad: 48 8b ac 24 f8 00 00 mov 0xf8(%rsp),%rbp +ffffffff800021b4: 00 +ffffffff800021b5: 89 44 24 10 mov %eax,0x10(%rsp) +ffffffff800021b9: 8b 84 24 98 00 00 00 mov 0x98(%rsp),%eax +ffffffff800021c0: 44 88 74 24 33 mov %r14b,0x33(%rsp) +ffffffff800021c5: 89 44 24 38 mov %eax,0x38(%rsp) +ffffffff800021c9: 8b 84 24 a0 00 00 00 mov 0xa0(%rsp),%eax +ffffffff800021d0: 89 44 24 2c mov %eax,0x2c(%rsp) +ffffffff800021d4: 8b 84 24 a8 00 00 00 mov 0xa8(%rsp),%eax +ffffffff800021db: 89 44 24 3c mov %eax,0x3c(%rsp) + if (font_scale_x == 0 || font_scale_y == 0) { +ffffffff800021df: 0f 84 b4 07 00 00 je ffffffff80002999 +ffffffff800021e5: 48 83 bc 24 10 01 00 cmpq $0x0,0x110(%rsp) +ffffffff800021ec: 00 00 +ffffffff800021ee: 0f 84 a5 07 00 00 je ffffffff80002999 + font_scale_x = 4; + font_scale_y = 4; + } + } + + if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) { +ffffffff800021f4: 41 80 fe 07 cmp $0x7,%r14b +ffffffff800021f8: 0f 96 c0 setbe %al +ffffffff800021fb: 44 3a 74 24 10 cmp 0x10(%rsp),%r14b +ffffffff80002200: 0f 95 c2 setne %dl +ffffffff80002203: 08 d0 or %dl,%al +ffffffff80002205: 0f 85 d0 08 00 00 jne ffffffff80002adb +ffffffff8000220b: 44 3a 74 24 2c cmp 0x2c(%rsp),%r14b +ffffffff80002210: 0f 85 c5 08 00 00 jne ffffffff80002adb + return NULL; + } + + if (_malloc == NULL) { +ffffffff80002216: 4d 85 ff test %r15,%r15 +ffffffff80002219: 0f 84 c9 08 00 00 je ffffffff80002ae8 + return NULL; +#endif + } + + struct flanterm_fb_context *ctx = NULL; + ctx = _malloc(sizeof(struct flanterm_fb_context)); +ffffffff8000221f: bf 20 03 00 00 mov $0x320,%edi +ffffffff80002224: 41 ff d7 call *%r15 +ffffffff80002227: 48 89 c3 mov %rax,%rbx + if (ctx == NULL) { +ffffffff8000222a: 48 85 c0 test %rax,%rax +ffffffff8000222d: 0f 84 a8 08 00 00 je ffffffff80002adb + goto fail; + } + + struct flanterm_context *_ctx = (void *)ctx; + memset(ctx, 0, sizeof(struct flanterm_fb_context)); +ffffffff80002233: 31 f6 xor %esi,%esi +ffffffff80002235: ba 20 03 00 00 mov $0x320,%edx +ffffffff8000223a: 48 89 c7 mov %rax,%rdi +ffffffff8000223d: e8 2e 45 00 00 call ffffffff80006770 + + ctx->red_mask_size = red_mask_size; + ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8); + ctx->green_mask_size = green_mask_size; + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); +ffffffff80002242: 8b 74 24 10 mov 0x10(%rsp),%esi + ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8); +ffffffff80002246: 0f b6 44 24 34 movzbl 0x34(%rsp),%eax + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); +ffffffff8000224b: 0f b6 54 24 38 movzbl 0x38(%rsp),%edx + ctx->red_mask_size = red_mask_size; +ffffffff80002250: 0f b6 4c 24 33 movzbl 0x33(%rsp),%ecx + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); +ffffffff80002255: 89 f7 mov %esi,%edi + ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8); +ffffffff80002257: 42 8d 44 30 f8 lea -0x8(%rax,%r14,1),%eax + ctx->red_mask_size = red_mask_size; +ffffffff8000225c: 40 0f b6 f6 movzbl %sil,%esi + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); +ffffffff80002260: 8d 54 3a f8 lea -0x8(%rdx,%rdi,1),%edx + ctx->red_mask_size = red_mask_size; +ffffffff80002264: 88 c5 mov %al,%ch +ffffffff80002266: c1 e6 10 shl $0x10,%esi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002269: 44 0f b6 f0 movzbl %al,%r14d + ctx->red_mask_size = red_mask_size; +ffffffff8000226d: 0f b7 c9 movzwl %cx,%ecx +ffffffff80002270: 89 d7 mov %edx,%edi +ffffffff80002272: 44 0f b6 da movzbl %dl,%r11d +ffffffff80002276: c1 e7 18 shl $0x18,%edi +ffffffff80002279: 09 f1 or %esi,%ecx + ctx->blue_mask_size = blue_mask_size; +ffffffff8000227b: 8b 74 24 2c mov 0x2c(%rsp),%esi + ctx->red_mask_size = red_mask_size; +ffffffff8000227f: 09 f9 or %edi,%ecx + ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8); +ffffffff80002281: 0f b6 7c 24 3c movzbl 0x3c(%rsp),%edi + + if (ansi_colours != NULL) { +ffffffff80002286: 48 83 bc 24 b8 00 00 cmpq $0x0,0xb8(%rsp) +ffffffff8000228d: 00 00 + ctx->blue_mask_size = blue_mask_size; +ffffffff8000228f: 40 88 b3 24 02 00 00 mov %sil,0x224(%rbx) + ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8); +ffffffff80002296: 8d 74 37 f8 lea -0x8(%rdi,%rsi,1),%esi + ctx->red_mask_size = red_mask_size; +ffffffff8000229a: 89 8b 20 02 00 00 mov %ecx,0x220(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022a0: 40 0f b6 fe movzbl %sil,%edi + ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8); +ffffffff800022a4: 40 88 b3 25 02 00 00 mov %sil,0x225(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022ab: 89 7c 24 10 mov %edi,0x10(%rsp) + if (ansi_colours != NULL) { +ffffffff800022af: 0f 84 d6 08 00 00 je ffffffff80002b8b + for (size_t i = 0; i < 8; i++) { +ffffffff800022b5: 45 31 c9 xor %r9d,%r9d + ctx->ansi_colours[i] = convert_colour(_ctx, ansi_colours[i]); +ffffffff800022b8: 48 8b bc 24 b8 00 00 mov 0xb8(%rsp),%rdi +ffffffff800022bf: 00 +ffffffff800022c0: 46 8b 04 8f mov (%rdi,%r9,4),%r8d + uint32_t g = (colour >> 8) & 0xff; +ffffffff800022c4: 44 89 c1 mov %r8d,%ecx +ffffffff800022c7: 0f b6 fd movzbl %ch,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022ca: 44 89 d9 mov %r11d,%ecx + uint32_t g = (colour >> 8) & 0xff; +ffffffff800022cd: 41 89 fa mov %edi,%r10d + uint32_t r = (colour >> 16) & 0xff; +ffffffff800022d0: 44 89 c7 mov %r8d,%edi + uint32_t b = colour & 0xff; +ffffffff800022d3: 45 0f b6 c0 movzbl %r8b,%r8d + uint32_t r = (colour >> 16) & 0xff; +ffffffff800022d7: c1 ef 10 shr $0x10,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022da: 41 d3 e2 shl %cl,%r10d +ffffffff800022dd: 44 89 f1 mov %r14d,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff800022e0: 40 0f b6 ff movzbl %dil,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800022e4: d3 e7 shl %cl,%edi +ffffffff800022e6: 0f b6 4c 24 10 movzbl 0x10(%rsp),%ecx +ffffffff800022eb: 44 09 d7 or %r10d,%edi +ffffffff800022ee: 41 d3 e0 shl %cl,%r8d +ffffffff800022f1: 44 09 c7 or %r8d,%edi +ffffffff800022f4: 42 89 bc 8b 48 02 00 mov %edi,0x248(%rbx,%r9,4) +ffffffff800022fb: 00 + for (size_t i = 0; i < 8; i++) { +ffffffff800022fc: 49 83 c1 01 add $0x1,%r9 +ffffffff80002300: 49 83 f9 08 cmp $0x8,%r9 +ffffffff80002304: 75 b2 jne ffffffff800022b8 + ctx->ansi_colours[5] = convert_colour(_ctx, 0x00aa00aa); // magenta + ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan + ctx->ansi_colours[7] = convert_colour(_ctx, 0x00aaaaaa); // grey + } + + if (ansi_bright_colours != NULL) { +ffffffff80002306: 48 83 bc 24 c0 00 00 cmpq $0x0,0xc0(%rsp) +ffffffff8000230d: 00 00 +ffffffff8000230f: 0f 84 ee 08 00 00 je ffffffff80002c03 + for (size_t i = 0; i < 8; i++) { +ffffffff80002315: 45 31 c9 xor %r9d,%r9d + ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]); +ffffffff80002318: 48 8b bc 24 c0 00 00 mov 0xc0(%rsp),%rdi +ffffffff8000231f: 00 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002320: 44 89 f1 mov %r14d,%ecx + ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]); +ffffffff80002323: 46 8b 04 8f mov (%rdi,%r9,4),%r8d + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002327: 45 89 c2 mov %r8d,%r10d +ffffffff8000232a: 41 c1 ea 10 shr $0x10,%r10d +ffffffff8000232e: 45 0f b6 d2 movzbl %r10b,%r10d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002332: 41 d3 e2 shl %cl,%r10d + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002335: 44 89 c1 mov %r8d,%ecx + uint32_t b = colour & 0xff; +ffffffff80002338: 45 0f b6 c0 movzbl %r8b,%r8d + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000233c: 0f b6 fd movzbl %ch,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000233f: 44 89 d9 mov %r11d,%ecx +ffffffff80002342: d3 e7 shl %cl,%edi +ffffffff80002344: 0f b6 4c 24 10 movzbl 0x10(%rsp),%ecx +ffffffff80002349: 44 09 d7 or %r10d,%edi +ffffffff8000234c: 41 d3 e0 shl %cl,%r8d +ffffffff8000234f: 44 09 c7 or %r8d,%edi +ffffffff80002352: 42 89 bc 8b 68 02 00 mov %edi,0x268(%rbx,%r9,4) +ffffffff80002359: 00 + for (size_t i = 0; i < 8; i++) { +ffffffff8000235a: 49 83 c1 01 add $0x1,%r9 +ffffffff8000235e: 49 83 f9 08 cmp $0x8,%r9 +ffffffff80002362: 75 b4 jne ffffffff80002318 + } + + if (default_bg != NULL) { + ctx->default_bg = convert_colour(_ctx, *default_bg); + } else { + ctx->default_bg = 0x00000000; // background (black) +ffffffff80002364: 45 31 c0 xor %r8d,%r8d + if (default_bg != NULL) { +ffffffff80002367: 48 83 bc 24 c8 00 00 cmpq $0x0,0xc8(%rsp) +ffffffff8000236e: 00 00 +ffffffff80002370: 74 31 je ffffffff800023a3 + ctx->default_bg = convert_colour(_ctx, *default_bg); +ffffffff80002372: 48 8b bc 24 c8 00 00 mov 0xc8(%rsp),%rdi +ffffffff80002379: 00 +ffffffff8000237a: 8b 3f mov (%rdi),%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000237c: 89 f9 mov %edi,%ecx + uint32_t b = colour & 0xff; +ffffffff8000237e: 44 0f b6 c7 movzbl %dil,%r8d + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002382: c1 ef 10 shr $0x10,%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002385: 0f b6 cd movzbl %ch,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002388: 40 0f b6 ff movzbl %dil,%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000238c: 41 89 c9 mov %ecx,%r9d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000238f: 89 d1 mov %edx,%ecx +ffffffff80002391: 41 d3 e1 shl %cl,%r9d +ffffffff80002394: 89 f1 mov %esi,%ecx +ffffffff80002396: 41 d3 e0 shl %cl,%r8d +ffffffff80002399: 89 c1 mov %eax,%ecx +ffffffff8000239b: 45 09 c8 or %r9d,%r8d +ffffffff8000239e: d3 e7 shl %cl,%edi +ffffffff800023a0: 41 09 f8 or %edi,%r8d + } + + if (default_fg != NULL) { +ffffffff800023a3: 48 83 bc 24 d0 00 00 cmpq $0x0,0xd0(%rsp) +ffffffff800023aa: 00 00 +ffffffff800023ac: 44 89 83 8c 02 00 00 mov %r8d,0x28c(%rbx) +ffffffff800023b3: 0f 84 a3 09 00 00 je ffffffff80002d5c + ctx->default_fg = convert_colour(_ctx, *default_fg); +ffffffff800023b9: 48 8b bc 24 d0 00 00 mov 0xd0(%rsp),%rdi +ffffffff800023c0: 00 +ffffffff800023c1: 8b 3f mov (%rdi),%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff800023c3: 89 f9 mov %edi,%ecx + uint32_t b = colour & 0xff; +ffffffff800023c5: 44 0f b6 c7 movzbl %dil,%r8d + uint32_t r = (colour >> 16) & 0xff; +ffffffff800023c9: c1 ef 10 shr $0x10,%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff800023cc: 0f b6 cd movzbl %ch,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff800023cf: 40 0f b6 ff movzbl %dil,%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff800023d3: 41 89 c9 mov %ecx,%r9d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800023d6: 89 d1 mov %edx,%ecx +ffffffff800023d8: 41 d3 e1 shl %cl,%r9d +ffffffff800023db: 89 f1 mov %esi,%ecx +ffffffff800023dd: 41 d3 e0 shl %cl,%r8d +ffffffff800023e0: 89 c1 mov %eax,%ecx +ffffffff800023e2: 45 09 c8 or %r9d,%r8d +ffffffff800023e5: d3 e7 shl %cl,%edi +ffffffff800023e7: 41 09 f8 or %edi,%r8d +ffffffff800023ea: 45 89 c2 mov %r8d,%r10d + } else { + ctx->default_fg = convert_colour(_ctx, 0x00aaaaaa); // foreground (grey) + } + + if (default_bg_bright != NULL) { +ffffffff800023ed: 48 83 bc 24 d8 00 00 cmpq $0x0,0xd8(%rsp) +ffffffff800023f4: 00 00 +ffffffff800023f6: 44 89 93 88 02 00 00 mov %r10d,0x288(%rbx) +ffffffff800023fd: 0f 84 cf 08 00 00 je ffffffff80002cd2 + ctx->default_bg_bright = convert_colour(_ctx, *default_bg_bright); +ffffffff80002403: 48 8b bc 24 d8 00 00 mov 0xd8(%rsp),%rdi +ffffffff8000240a: 00 +ffffffff8000240b: 44 8b 07 mov (%rdi),%r8d + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000240e: 44 89 c1 mov %r8d,%ecx +ffffffff80002411: 0f b6 fd movzbl %ch,%edi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002414: 89 d1 mov %edx,%ecx + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002416: 41 89 f9 mov %edi,%r9d + uint32_t b = colour & 0xff; +ffffffff80002419: 41 0f b6 f8 movzbl %r8b,%edi + uint32_t r = (colour >> 16) & 0xff; +ffffffff8000241d: 41 c1 e8 10 shr $0x10,%r8d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002421: 41 d3 e1 shl %cl,%r9d +ffffffff80002424: 89 f1 mov %esi,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002426: 45 0f b6 c0 movzbl %r8b,%r8d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000242a: d3 e7 shl %cl,%edi +ffffffff8000242c: 89 c1 mov %eax,%ecx +ffffffff8000242e: 44 09 cf or %r9d,%edi +ffffffff80002431: 41 d3 e0 shl %cl,%r8d +ffffffff80002434: 44 09 c7 or %r8d,%edi + } else { + ctx->default_bg_bright = convert_colour(_ctx, 0x00555555); // background (black) + } + + if (default_fg_bright != NULL) { +ffffffff80002437: 48 83 bc 24 e0 00 00 cmpq $0x0,0xe0(%rsp) +ffffffff8000243e: 00 00 +ffffffff80002440: 89 bb 94 02 00 00 mov %edi,0x294(%rbx) +ffffffff80002446: 0f 84 60 08 00 00 je ffffffff80002cac + ctx->default_fg_bright = convert_colour(_ctx, *default_fg_bright); +ffffffff8000244c: 48 8b bc 24 e0 00 00 mov 0xe0(%rsp),%rdi +ffffffff80002453: 00 +ffffffff80002454: 8b 3f mov (%rdi),%edi + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002456: 89 f9 mov %edi,%ecx +ffffffff80002458: 0f b6 cd movzbl %ch,%ecx +ffffffff8000245b: 41 89 c8 mov %ecx,%r8d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000245e: 89 d1 mov %edx,%ecx + uint32_t b = colour & 0xff; +ffffffff80002460: 40 0f b6 d7 movzbl %dil,%edx + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002464: 41 d3 e0 shl %cl,%r8d +ffffffff80002467: 89 f1 mov %esi,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002469: 89 fe mov %edi,%esi +ffffffff8000246b: c1 ee 10 shr $0x10,%esi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000246e: d3 e2 shl %cl,%edx +ffffffff80002470: 89 c1 mov %eax,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff80002472: 40 0f b6 f6 movzbl %sil,%esi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002476: 44 09 c2 or %r8d,%edx +ffffffff80002479: d3 e6 shl %cl,%esi +ffffffff8000247b: 09 f2 or %esi,%edx + } + + ctx->text_fg = ctx->default_fg; + ctx->text_bg = 0xffffffff; + + ctx->framebuffer = (void *)framebuffer; +ffffffff8000247d: 48 8b 44 24 08 mov 0x8(%rsp),%rax +ffffffff80002482: 89 93 90 02 00 00 mov %edx,0x290(%rbx) + ctx->height = height; + ctx->pitch = pitch; + +#define FONT_BYTES ((font_width * font_height * FLANTERM_FB_FONT_GLYPHS) / 8) + + if (font != NULL) { +ffffffff80002488: 48 83 bc 24 e8 00 00 cmpq $0x0,0xe8(%rsp) +ffffffff8000248f: 00 00 + ctx->text_fg = ctx->default_fg; +ffffffff80002491: 44 89 93 e0 02 00 00 mov %r10d,0x2e0(%rbx) + ctx->framebuffer = (void *)framebuffer; +ffffffff80002498: 48 89 83 f8 01 00 00 mov %rax,0x1f8(%rbx) + ctx->pitch = pitch; +ffffffff8000249f: 48 8b 44 24 20 mov 0x20(%rsp),%rax + ctx->text_bg = 0xffffffff; +ffffffff800024a4: c7 83 e4 02 00 00 ff movl $0xffffffff,0x2e4(%rbx) +ffffffff800024ab: ff ff ff + ctx->width = width; +ffffffff800024ae: 4c 89 ab 08 02 00 00 mov %r13,0x208(%rbx) + ctx->height = height; +ffffffff800024b5: 4c 89 a3 10 02 00 00 mov %r12,0x210(%rbx) + ctx->pitch = pitch; +ffffffff800024bc: 48 89 83 00 02 00 00 mov %rax,0x200(%rbx) + if (font != NULL) { +ffffffff800024c3: 0f 84 2e 08 00 00 je ffffffff80002cf7 + ctx->font_width = font_width; +ffffffff800024c9: 48 8b 84 24 f0 00 00 mov 0xf0(%rsp),%rax +ffffffff800024d0: 00 + ctx->font_height = font_height; + ctx->font_bits_size = FONT_BYTES; +ffffffff800024d1: 48 89 ef mov %rbp,%rdi + ctx->font_height = font_height; +ffffffff800024d4: 48 89 ab c0 01 00 00 mov %rbp,0x1c0(%rbx) + ctx->font_bits_size = FONT_BYTES; +ffffffff800024db: 48 0f af f8 imul %rax,%rdi + ctx->font_width = font_width; +ffffffff800024df: 48 89 83 b8 01 00 00 mov %rax,0x1b8(%rbx) + ctx->font_bits_size = FONT_BYTES; +ffffffff800024e6: 48 c1 e7 08 shl $0x8,%rdi +ffffffff800024ea: 48 c1 ef 03 shr $0x3,%rdi +ffffffff800024ee: 48 89 bb 28 02 00 00 mov %rdi,0x228(%rbx) + ctx->font_bits = _malloc(ctx->font_bits_size); +ffffffff800024f5: 41 ff d7 call *%r15 +ffffffff800024f8: 48 89 83 30 02 00 00 mov %rax,0x230(%rbx) +ffffffff800024ff: 48 89 c7 mov %rax,%rdi + if (ctx->font_bits == NULL) { +ffffffff80002502: 48 85 c0 test %rax,%rax +ffffffff80002505: 0f 84 0f 05 00 00 je ffffffff80002a1a + goto fail; + } + memcpy(ctx->font_bits, font, ctx->font_bits_size); +ffffffff8000250b: 48 8b 93 28 02 00 00 mov 0x228(%rbx),%rdx +ffffffff80002512: 48 8b b4 24 e8 00 00 mov 0xe8(%rsp),%rsi +ffffffff80002519: 00 +ffffffff8000251a: e8 21 42 00 00 call ffffffff80006740 + memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size); + } + +#undef FONT_BYTES + + ctx->font_width += font_spacing; +ffffffff8000251f: 48 8b 84 24 00 01 00 mov 0x100(%rsp),%rax +ffffffff80002526: 00 +ffffffff80002527: 48 03 83 b8 01 00 00 add 0x1b8(%rbx),%rax +ffffffff8000252e: 48 89 83 b8 01 00 00 mov %rax,0x1b8(%rbx) + + ctx->font_bool_size = FLANTERM_FB_FONT_GLYPHS * font_height * ctx->font_width * sizeof(bool); +ffffffff80002535: 48 0f af c5 imul %rbp,%rax +ffffffff80002539: 48 c1 e0 08 shl $0x8,%rax +ffffffff8000253d: 48 89 83 38 02 00 00 mov %rax,0x238(%rbx) +ffffffff80002544: 48 89 c7 mov %rax,%rdi + ctx->font_bool = _malloc(ctx->font_bool_size); +ffffffff80002547: 41 ff d7 call *%r15 +ffffffff8000254a: 48 89 83 40 02 00 00 mov %rax,0x240(%rbx) +ffffffff80002551: 48 89 c2 mov %rax,%rdx + if (ctx->font_bool == NULL) { +ffffffff80002554: 48 85 c0 test %rax,%rax +ffffffff80002557: 0f 84 bd 04 00 00 je ffffffff80002a1a + } + + ctx->font_scale_x = font_scale_x; + ctx->font_scale_y = font_scale_y; + + ctx->glyph_width = ctx->font_width * font_scale_x; +ffffffff8000255d: 4c 8b 93 b8 01 00 00 mov 0x1b8(%rbx),%r10 +ffffffff80002564: 49 89 ee mov %rbp,%r14 +ffffffff80002567: 45 31 e4 xor %r12d,%r12d + if ((glyph[y] & (0x80 >> x))) { +ffffffff8000256a: 48 89 de mov %rbx,%rsi +ffffffff8000256d: 4c 8b ab 30 02 00 00 mov 0x230(%rbx),%r13 + ctx->glyph_width = ctx->font_width * font_scale_x; +ffffffff80002574: 49 c7 c1 40 ff ff ff mov $0xffffffffffffff40,%r9 + if ((glyph[y] & (0x80 >> x))) { +ffffffff8000257b: 41 b8 80 00 00 00 mov $0x80,%r8d +ffffffff80002581: 4d 0f af f2 imul %r10,%r14 +ffffffff80002585: 4e 8d 5c 2d 00 lea 0x0(%rbp,%r13,1),%r11 +ffffffff8000258a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + for (size_t y = 0; y < font_height; y++) { +ffffffff80002590: 4a 8d 3c 12 lea (%rdx,%r10,1),%rdi +ffffffff80002594: 4b 8d 04 2c lea (%r12,%r13,1),%rax +ffffffff80002598: 48 89 d3 mov %rdx,%rbx +ffffffff8000259b: 48 85 ed test %rbp,%rbp +ffffffff8000259e: 74 64 je ffffffff80002604 +ffffffff800025a0: 4c 89 64 24 10 mov %r12,0x10(%rsp) +ffffffff800025a5: 0f 1f 00 nopl (%rax) + for (size_t x = 0; x < 8; x++) { +ffffffff800025a8: 4c 89 74 24 08 mov %r14,0x8(%rsp) +ffffffff800025ad: 31 c9 xor %ecx,%ecx +ffffffff800025af: 90 nop + if ((glyph[y] & (0x80 >> x))) { +ffffffff800025b0: 44 0f b6 20 movzbl (%rax),%r12d +ffffffff800025b4: 45 89 c6 mov %r8d,%r14d +ffffffff800025b7: 41 d3 fe sar %cl,%r14d +ffffffff800025ba: 45 85 e6 test %r12d,%r14d + ctx->font_bool[offset] = true; +ffffffff800025bd: 0f 95 04 0b setne (%rbx,%rcx,1) + for (size_t x = 0; x < 8; x++) { +ffffffff800025c1: 48 83 c1 01 add $0x1,%rcx +ffffffff800025c5: 48 83 f9 08 cmp $0x8,%rcx +ffffffff800025c9: 75 e5 jne ffffffff800025b0 +ffffffff800025cb: 4c 8b 74 24 08 mov 0x8(%rsp),%r14 + for (size_t x = 8; x < ctx->font_width; x++) { +ffffffff800025d0: 48 8d 4b 08 lea 0x8(%rbx),%rcx +ffffffff800025d4: 49 83 fa 08 cmp $0x8,%r10 +ffffffff800025d8: 76 16 jbe ffffffff800025f0 + if (i >= 0xc0 && i <= 0xdf) { +ffffffff800025da: 49 83 f9 1f cmp $0x1f,%r9 +ffffffff800025de: 0f 86 1c 04 00 00 jbe ffffffff80002a00 + ctx->font_bool[offset] = (glyph[y] & 1); +ffffffff800025e4: c6 01 00 movb $0x0,(%rcx) + for (size_t x = 8; x < ctx->font_width; x++) { +ffffffff800025e7: 48 83 c1 01 add $0x1,%rcx +ffffffff800025eb: 48 39 f9 cmp %rdi,%rcx +ffffffff800025ee: 75 ea jne ffffffff800025da + for (size_t y = 0; y < font_height; y++) { +ffffffff800025f0: 48 83 c0 01 add $0x1,%rax +ffffffff800025f4: 4c 01 d7 add %r10,%rdi +ffffffff800025f7: 4c 01 d3 add %r10,%rbx +ffffffff800025fa: 49 39 c3 cmp %rax,%r11 +ffffffff800025fd: 75 a9 jne ffffffff800025a8 +ffffffff800025ff: 4c 8b 64 24 10 mov 0x10(%rsp),%r12 + for (size_t i = 0; i < FLANTERM_FB_FONT_GLYPHS; i++) { +ffffffff80002604: 49 83 c1 01 add $0x1,%r9 +ffffffff80002608: 49 01 eb add %rbp,%r11 +ffffffff8000260b: 4c 01 f2 add %r14,%rdx +ffffffff8000260e: 49 01 ec add %rbp,%r12 +ffffffff80002611: 49 83 f9 40 cmp $0x40,%r9 +ffffffff80002615: 0f 85 75 ff ff ff jne ffffffff80002590 + ctx->font_scale_x = font_scale_x; +ffffffff8000261b: 48 8b 84 24 08 01 00 mov 0x108(%rsp),%rax +ffffffff80002622: 00 +ffffffff80002623: 31 d2 xor %edx,%edx +ffffffff80002625: 48 89 f3 mov %rsi,%rbx + ctx->glyph_width = ctx->font_width * font_scale_x; +ffffffff80002628: 4c 0f af 94 24 08 01 imul 0x108(%rsp),%r10 +ffffffff8000262f: 00 00 + ctx->font_scale_x = font_scale_x; +ffffffff80002631: 48 89 86 d8 01 00 00 mov %rax,0x1d8(%rsi) + ctx->font_scale_y = font_scale_y; +ffffffff80002638: 48 8b 84 24 10 01 00 mov 0x110(%rsp),%rax +ffffffff8000263f: 00 +ffffffff80002640: 48 89 86 e0 01 00 00 mov %rax,0x1e0(%rsi) + ctx->glyph_height = font_height * font_scale_y; +ffffffff80002647: 48 0f af e8 imul %rax,%rbp + + _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width; +ffffffff8000264b: 48 8b 84 24 18 01 00 mov 0x118(%rsp),%rax +ffffffff80002652: 00 + ctx->glyph_width = ctx->font_width * font_scale_x; +ffffffff80002653: 4c 89 96 c8 01 00 00 mov %r10,0x1c8(%rsi) + _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width; +ffffffff8000265a: 48 8d 3c 00 lea (%rax,%rax,1),%rdi +ffffffff8000265e: 48 8b 86 08 02 00 00 mov 0x208(%rsi),%rax + ctx->glyph_height = font_height * font_scale_y; +ffffffff80002665: 48 89 ae d0 01 00 00 mov %rbp,0x1d0(%rsi) + _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width; +ffffffff8000266c: 48 29 f8 sub %rdi,%rax +ffffffff8000266f: 49 f7 f2 div %r10 +ffffffff80002672: 48 89 83 e8 00 00 00 mov %rax,0xe8(%rbx) + _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height; +ffffffff80002679: 48 89 c1 mov %rax,%rcx +ffffffff8000267c: 48 89 d6 mov %rdx,%rsi +ffffffff8000267f: 31 d2 xor %edx,%edx +ffffffff80002681: 48 8b 83 10 02 00 00 mov 0x210(%rbx),%rax + + ctx->offset_x = margin + ((ctx->width - margin * 2) % ctx->glyph_width) / 2; +ffffffff80002688: 48 d1 ee shr $1,%rsi +ffffffff8000268b: 48 03 b4 24 18 01 00 add 0x118(%rsp),%rsi +ffffffff80002692: 00 +ffffffff80002693: 48 89 b3 e8 01 00 00 mov %rsi,0x1e8(%rbx) + _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height; +ffffffff8000269a: 48 29 f8 sub %rdi,%rax +ffffffff8000269d: 48 f7 f5 div %rbp + ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2; + + ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char); +ffffffff800026a0: 48 0f af c8 imul %rax,%rcx + ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2; +ffffffff800026a4: 48 d1 ea shr $1,%rdx +ffffffff800026a7: 48 03 94 24 18 01 00 add 0x118(%rsp),%rdx +ffffffff800026ae: 00 + _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height; +ffffffff800026af: 48 89 83 e0 00 00 00 mov %rax,0xe0(%rbx) + ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2; +ffffffff800026b6: 48 89 93 f0 01 00 00 mov %rdx,0x1f0(%rbx) + ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char); +ffffffff800026bd: 48 8d 3c 49 lea (%rcx,%rcx,2),%rdi +ffffffff800026c1: 48 c1 e7 02 shl $0x2,%rdi +ffffffff800026c5: 48 89 bb a8 02 00 00 mov %rdi,0x2a8(%rbx) + ctx->grid = _malloc(ctx->grid_size); +ffffffff800026cc: 41 ff d7 call *%r15 +ffffffff800026cf: 48 89 83 c0 02 00 00 mov %rax,0x2c0(%rbx) + if (ctx->grid == NULL) { +ffffffff800026d6: 48 85 c0 test %rax,%rax +ffffffff800026d9: 0f 84 3b 03 00 00 je ffffffff80002a1a + goto fail; + } + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff800026df: 48 8b bb e0 00 00 00 mov 0xe0(%rbx),%rdi +ffffffff800026e6: 48 0f af bb e8 00 00 imul 0xe8(%rbx),%rdi +ffffffff800026ed: 00 +ffffffff800026ee: 48 85 ff test %rdi,%rdi +ffffffff800026f1: 74 2d je ffffffff80002720 +ffffffff800026f3: 48 8d 14 7f lea (%rdi,%rdi,2),%rdx + ctx->grid[i].c = ' '; + ctx->grid[i].fg = ctx->text_fg; +ffffffff800026f7: 8b b3 e0 02 00 00 mov 0x2e0(%rbx),%esi + ctx->grid[i].bg = ctx->text_bg; +ffffffff800026fd: 8b 8b e4 02 00 00 mov 0x2e4(%rbx),%ecx +ffffffff80002703: 48 8d 14 90 lea (%rax,%rdx,4),%rdx + ctx->grid[i].c = ' '; +ffffffff80002707: c7 00 20 00 00 00 movl $0x20,(%rax) + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff8000270d: 48 83 c0 0c add $0xc,%rax + ctx->grid[i].fg = ctx->text_fg; +ffffffff80002711: 89 70 f8 mov %esi,-0x8(%rax) + ctx->grid[i].bg = ctx->text_bg; +ffffffff80002714: 89 48 fc mov %ecx,-0x4(%rax) + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { +ffffffff80002717: 48 39 c2 cmp %rax,%rdx +ffffffff8000271a: 75 eb jne ffffffff80002707 + } + + ctx->queue_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item); +ffffffff8000271c: 48 c1 e7 05 shl $0x5,%rdi +ffffffff80002720: 48 89 bb b0 02 00 00 mov %rdi,0x2b0(%rbx) + ctx->queue = _malloc(ctx->queue_size); +ffffffff80002727: 41 ff d7 call *%r15 +ffffffff8000272a: 48 89 83 c8 02 00 00 mov %rax,0x2c8(%rbx) +ffffffff80002731: 48 89 c7 mov %rax,%rdi + if (ctx->queue == NULL) { +ffffffff80002734: 48 85 c0 test %rax,%rax +ffffffff80002737: 0f 84 dd 02 00 00 je ffffffff80002a1a + goto fail; + } + ctx->queue_i = 0; +ffffffff8000273d: 48 c7 83 d0 02 00 00 movq $0x0,0x2d0(%rbx) +ffffffff80002744: 00 00 00 00 + memset(ctx->queue, 0, ctx->queue_size); +ffffffff80002748: 48 8b 93 b0 02 00 00 mov 0x2b0(%rbx),%rdx +ffffffff8000274f: 31 f6 xor %esi,%esi +ffffffff80002751: e8 1a 40 00 00 call ffffffff80006770 + + ctx->map_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item *); +ffffffff80002756: 48 8b bb e0 00 00 00 mov 0xe0(%rbx),%rdi +ffffffff8000275d: 48 0f af bb e8 00 00 imul 0xe8(%rbx),%rdi +ffffffff80002764: 00 +ffffffff80002765: 48 c1 e7 03 shl $0x3,%rdi +ffffffff80002769: 48 89 bb b8 02 00 00 mov %rdi,0x2b8(%rbx) + ctx->map = _malloc(ctx->map_size); +ffffffff80002770: 41 ff d7 call *%r15 +ffffffff80002773: 48 89 83 d8 02 00 00 mov %rax,0x2d8(%rbx) +ffffffff8000277a: 48 89 c7 mov %rax,%rdi + if (ctx->map == NULL) { +ffffffff8000277d: 48 85 c0 test %rax,%rax +ffffffff80002780: 0f 84 94 02 00 00 je ffffffff80002a1a + goto fail; + } + memset(ctx->map, 0, ctx->map_size); +ffffffff80002786: 48 8b 93 b8 02 00 00 mov 0x2b8(%rbx),%rdx +ffffffff8000278d: 31 f6 xor %esi,%esi +ffffffff8000278f: e8 dc 3f 00 00 call ffffffff80006770 + + if (canvas != NULL) { +ffffffff80002794: 48 83 bc 24 b0 00 00 cmpq $0x0,0xb0(%rsp) +ffffffff8000279b: 00 00 +ffffffff8000279d: 0f 84 e0 05 00 00 je ffffffff80002d83 + ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t); +ffffffff800027a3: 48 8b bb 08 02 00 00 mov 0x208(%rbx),%rdi +ffffffff800027aa: 48 0f af bb 10 02 00 imul 0x210(%rbx),%rdi +ffffffff800027b1: 00 +ffffffff800027b2: 48 c1 e7 02 shl $0x2,%rdi +ffffffff800027b6: 48 89 bb 98 02 00 00 mov %rdi,0x298(%rbx) + ctx->canvas = _malloc(ctx->canvas_size); +ffffffff800027bd: 41 ff d7 call *%r15 +ffffffff800027c0: 48 89 83 a0 02 00 00 mov %rax,0x2a0(%rbx) +ffffffff800027c7: 48 89 c7 mov %rax,%rdi + if (ctx->canvas == NULL) { +ffffffff800027ca: 48 85 c0 test %rax,%rax +ffffffff800027cd: 0f 84 47 02 00 00 je ffffffff80002a1a + goto fail; + } + for (size_t i = 0; i < ctx->width * ctx->height; i++) { +ffffffff800027d3: 4c 8b 9b 08 02 00 00 mov 0x208(%rbx),%r11 +ffffffff800027da: 4c 0f af 9b 10 02 00 imul 0x210(%rbx),%r11 +ffffffff800027e1: 00 +ffffffff800027e2: 4d 85 db test %r11,%r11 +ffffffff800027e5: 74 5a je ffffffff80002841 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800027e7: 44 0f b6 93 21 02 00 movzbl 0x221(%rbx),%r10d +ffffffff800027ee: 00 +ffffffff800027ef: 44 0f b6 8b 23 02 00 movzbl 0x223(%rbx),%r9d +ffffffff800027f6: 00 + for (size_t i = 0; i < ctx->width * ctx->height; i++) { +ffffffff800027f7: 31 f6 xor %esi,%esi + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff800027f9: 44 0f b6 83 25 02 00 movzbl 0x225(%rbx),%r8d +ffffffff80002800: 00 + for (size_t i = 0; i < ctx->width * ctx->height; i++) { +ffffffff80002801: 48 8b 94 24 b0 00 00 mov 0xb0(%rsp),%rdx +ffffffff80002808: 00 + ctx->canvas[i] = convert_colour(_ctx, canvas[i]); +ffffffff80002809: 8b 2c b2 mov (%rdx,%rsi,4),%ebp + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff8000280c: 44 89 d1 mov %r10d,%ecx + uint32_t r = (colour >> 16) & 0xff; +ffffffff8000280f: 89 e8 mov %ebp,%eax +ffffffff80002811: c1 e8 10 shr $0x10,%eax +ffffffff80002814: 0f b6 c0 movzbl %al,%eax + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002817: d3 e0 shl %cl,%eax + uint32_t g = (colour >> 8) & 0xff; +ffffffff80002819: 89 e9 mov %ebp,%ecx + uint32_t b = colour & 0xff; +ffffffff8000281b: 40 0f b6 ed movzbl %bpl,%ebp + uint32_t g = (colour >> 8) & 0xff; +ffffffff8000281f: 0f b6 cd movzbl %ch,%ecx +ffffffff80002822: 41 89 cc mov %ecx,%r12d + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002825: 44 89 c9 mov %r9d,%ecx +ffffffff80002828: 41 d3 e4 shl %cl,%r12d +ffffffff8000282b: 44 89 c1 mov %r8d,%ecx +ffffffff8000282e: 44 09 e0 or %r12d,%eax +ffffffff80002831: d3 e5 shl %cl,%ebp +ffffffff80002833: 09 e8 or %ebp,%eax +ffffffff80002835: 89 04 b7 mov %eax,(%rdi,%rsi,4) + for (size_t i = 0; i < ctx->width * ctx->height; i++) { +ffffffff80002838: 48 83 c6 01 add $0x1,%rsi +ffffffff8000283c: 49 39 f3 cmp %rsi,%r11 +ffffffff8000283f: 75 c8 jne ffffffff80002809 + } + } + + if (font_scale_x == 1 && font_scale_y == 1) { +ffffffff80002841: 48 83 bc 24 08 01 00 cmpq $0x1,0x108(%rsp) +ffffffff80002848: 00 01 +ffffffff8000284a: 0f 85 6c 05 00 00 jne ffffffff80002dbc +ffffffff80002850: 48 83 bc 24 10 01 00 cmpq $0x1,0x110(%rsp) +ffffffff80002857: 00 01 +ffffffff80002859: 48 c7 c0 90 1d 00 80 mov $0xffffffff80001d90,%rax +ffffffff80002860: 0f 85 56 05 00 00 jne ffffffff80002dbc + if (canvas == NULL) { + ctx->plot_char = plot_char_unscaled_uncanvas; + } else { + ctx->plot_char = plot_char_unscaled_canvas; +ffffffff80002866: 48 89 83 b0 01 00 00 mov %rax,0x1b0(%rbx) + _ctx->restore_state = flanterm_fb_restore_state; + _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush; + _ctx->full_refresh = flanterm_fb_full_refresh; + _ctx->deinit = flanterm_fb_deinit; + + flanterm_context_reinit(_ctx); +ffffffff8000286d: 48 89 df mov %rbx,%rdi + _ctx->raw_putchar = flanterm_fb_raw_putchar; +ffffffff80002870: 48 c7 83 f0 00 00 00 movq $0xffffffff800018c0,0xf0(%rbx) +ffffffff80002877: c0 18 00 80 + _ctx->clear = flanterm_fb_clear; +ffffffff8000287b: 48 c7 83 f8 00 00 00 movq $0xffffffff80001350,0xf8(%rbx) +ffffffff80002882: 50 13 00 80 + _ctx->set_cursor_pos = flanterm_fb_set_cursor_pos; +ffffffff80002886: 48 c7 83 00 01 00 00 movq $0xffffffff800013e0,0x100(%rbx) +ffffffff8000288d: e0 13 00 80 + _ctx->get_cursor_pos = flanterm_fb_get_cursor_pos; +ffffffff80002891: 48 c7 83 08 01 00 00 movq $0xffffffff80001430,0x108(%rbx) +ffffffff80002898: 30 14 00 80 + _ctx->set_text_fg = flanterm_fb_set_text_fg; +ffffffff8000289c: 48 c7 83 10 01 00 00 movq $0xffffffff800014f0,0x110(%rbx) +ffffffff800028a3: f0 14 00 80 + _ctx->set_text_bg = flanterm_fb_set_text_bg; +ffffffff800028a7: 48 c7 83 18 01 00 00 movq $0xffffffff80001510,0x118(%rbx) +ffffffff800028ae: 10 15 00 80 + _ctx->set_text_fg_bright = flanterm_fb_set_text_fg_bright; +ffffffff800028b2: 48 c7 83 20 01 00 00 movq $0xffffffff80001530,0x120(%rbx) +ffffffff800028b9: 30 15 00 80 + _ctx->set_text_bg_bright = flanterm_fb_set_text_bg_bright; +ffffffff800028bd: 48 c7 83 28 01 00 00 movq $0xffffffff80001550,0x128(%rbx) +ffffffff800028c4: 50 15 00 80 + _ctx->set_text_fg_rgb = flanterm_fb_set_text_fg_rgb; +ffffffff800028c8: 48 c7 83 30 01 00 00 movq $0xffffffff80001570,0x130(%rbx) +ffffffff800028cf: 70 15 00 80 + _ctx->set_text_bg_rgb = flanterm_fb_set_text_bg_rgb; +ffffffff800028d3: 48 c7 83 38 01 00 00 movq $0xffffffff800015b0,0x138(%rbx) +ffffffff800028da: b0 15 00 80 + _ctx->set_text_fg_default = flanterm_fb_set_text_fg_default; +ffffffff800028de: 48 c7 83 40 01 00 00 movq $0xffffffff800015f0,0x140(%rbx) +ffffffff800028e5: f0 15 00 80 + _ctx->set_text_bg_default = flanterm_fb_set_text_bg_default; +ffffffff800028e9: 48 c7 83 48 01 00 00 movq $0xffffffff80001610,0x148(%rbx) +ffffffff800028f0: 10 16 00 80 + _ctx->set_text_fg_default_bright = flanterm_fb_set_text_fg_default_bright; +ffffffff800028f4: 48 c7 83 50 01 00 00 movq $0xffffffff80001620,0x150(%rbx) +ffffffff800028fb: 20 16 00 80 + _ctx->set_text_bg_default_bright = flanterm_fb_set_text_bg_default_bright; +ffffffff800028ff: 48 c7 83 58 01 00 00 movq $0xffffffff80001640,0x158(%rbx) +ffffffff80002906: 40 16 00 80 + _ctx->move_character = flanterm_fb_move_character; +ffffffff8000290a: 48 c7 83 60 01 00 00 movq $0xffffffff80001470,0x160(%rbx) +ffffffff80002911: 70 14 00 80 + _ctx->scroll = flanterm_fb_scroll; +ffffffff80002915: 48 c7 83 68 01 00 00 movq $0xffffffff80001260,0x168(%rbx) +ffffffff8000291c: 60 12 00 80 + _ctx->revscroll = flanterm_fb_revscroll; +ffffffff80002920: 48 c7 83 70 01 00 00 movq $0xffffffff80001180,0x170(%rbx) +ffffffff80002927: 80 11 00 80 + _ctx->swap_palette = flanterm_fb_swap_palette; +ffffffff8000292b: 48 c7 83 78 01 00 00 movq $0xffffffff800010b0,0x178(%rbx) +ffffffff80002932: b0 10 00 80 + _ctx->save_state = flanterm_fb_save_state; +ffffffff80002936: 48 c7 83 80 01 00 00 movq $0xffffffff80001050,0x180(%rbx) +ffffffff8000293d: 50 10 00 80 + _ctx->restore_state = flanterm_fb_restore_state; +ffffffff80002941: 48 c7 83 88 01 00 00 movq $0xffffffff80001080,0x188(%rbx) +ffffffff80002948: 80 10 00 80 + _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush; +ffffffff8000294c: 48 c7 83 90 01 00 00 movq $0xffffffff80001760,0x190(%rbx) +ffffffff80002953: 60 17 00 80 + _ctx->full_refresh = flanterm_fb_full_refresh; +ffffffff80002957: 48 c7 83 98 01 00 00 movq $0xffffffff800019b0,0x198(%rbx) +ffffffff8000295e: b0 19 00 80 + _ctx->deinit = flanterm_fb_deinit; +ffffffff80002962: 48 c7 83 a0 01 00 00 movq $0xffffffff80001b00,0x1a0(%rbx) +ffffffff80002969: 00 1b 00 80 + flanterm_context_reinit(_ctx); +ffffffff8000296d: e8 6e 04 00 00 call ffffffff80002de0 + flanterm_fb_full_refresh(_ctx); +ffffffff80002972: 48 89 df mov %rbx,%rdi +ffffffff80002975: e8 36 f0 ff ff call ffffffff800019b0 + +#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC + if (_malloc == bump_alloc) { +ffffffff8000297a: 49 81 ff 00 10 00 80 cmp $0xffffffff80001000,%r15 +ffffffff80002981: 0f 84 29 04 00 00 je ffffffff80002db0 + if (ctx != NULL) { + _free(ctx, sizeof(struct flanterm_fb_context)); + } + + return NULL; +} +ffffffff80002987: 48 83 c4 48 add $0x48,%rsp +ffffffff8000298b: 48 89 d8 mov %rbx,%rax +ffffffff8000298e: 5b pop %rbx +ffffffff8000298f: 5d pop %rbp +ffffffff80002990: 41 5c pop %r12 +ffffffff80002992: 41 5d pop %r13 +ffffffff80002994: 41 5e pop %r14 +ffffffff80002996: 41 5f pop %r15 +ffffffff80002998: c3 ret + if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) { +ffffffff80002999: 49 81 fd ff 13 00 00 cmp $0x13ff,%r13 +ffffffff800029a0: 76 25 jbe ffffffff800029c7 + font_scale_y = 4; +ffffffff800029a2: 48 c7 84 24 10 01 00 movq $0x4,0x110(%rsp) +ffffffff800029a9: 00 04 00 00 00 + font_scale_x = 4; +ffffffff800029ae: 48 c7 84 24 08 01 00 movq $0x4,0x108(%rsp) +ffffffff800029b5: 00 04 00 00 00 + if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) { +ffffffff800029ba: 49 81 fc 3f 0b 00 00 cmp $0xb3f,%r12 +ffffffff800029c1: 0f 87 2d f8 ff ff ja ffffffff800021f4 + if (width >= (1920 + 1920 / 3) && height >= (1080 + 1080 / 3)) { +ffffffff800029c7: 49 81 fd ff 09 00 00 cmp $0x9ff,%r13 +ffffffff800029ce: 0f 97 c2 seta %dl +ffffffff800029d1: 31 c0 xor %eax,%eax +ffffffff800029d3: 49 81 fc 9f 05 00 00 cmp $0x59f,%r12 +ffffffff800029da: 0f 97 c0 seta %al +ffffffff800029dd: 48 21 d0 and %rdx,%rax +ffffffff800029e0: 48 83 c0 01 add $0x1,%rax +ffffffff800029e4: 48 89 84 24 08 01 00 mov %rax,0x108(%rsp) +ffffffff800029eb: 00 +ffffffff800029ec: 48 89 84 24 10 01 00 mov %rax,0x110(%rsp) +ffffffff800029f3: 00 +ffffffff800029f4: e9 fb f7 ff ff jmp ffffffff800021f4 +ffffffff800029f9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + ctx->font_bool[offset] = (glyph[y] & 1); +ffffffff80002a00: 44 0f b6 20 movzbl (%rax),%r12d + for (size_t x = 8; x < ctx->font_width; x++) { +ffffffff80002a04: 48 83 c1 01 add $0x1,%rcx + ctx->font_bool[offset] = (glyph[y] & 1); +ffffffff80002a08: 41 83 e4 01 and $0x1,%r12d +ffffffff80002a0c: 44 88 61 ff mov %r12b,-0x1(%rcx) + for (size_t x = 8; x < ctx->font_width; x++) { +ffffffff80002a10: 48 39 f9 cmp %rdi,%rcx +ffffffff80002a13: 75 eb jne ffffffff80002a00 +ffffffff80002a15: e9 d6 fb ff ff jmp ffffffff800025f0 + if (_malloc == bump_alloc) { +ffffffff80002a1a: 49 81 ff 00 10 00 80 cmp $0xffffffff80001000,%r15 +ffffffff80002a21: 0f 84 a1 03 00 00 je ffffffff80002dc8 + if (_free == NULL) { +ffffffff80002a27: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002a2c: 48 85 c0 test %rax,%rax +ffffffff80002a2f: 0f 84 a6 00 00 00 je ffffffff80002adb + if (ctx->canvas != NULL) { +ffffffff80002a35: 48 8b bb a0 02 00 00 mov 0x2a0(%rbx),%rdi +ffffffff80002a3c: 48 85 ff test %rdi,%rdi +ffffffff80002a3f: 74 09 je ffffffff80002a4a + _free(ctx->canvas, ctx->canvas_size); +ffffffff80002a41: 48 8b b3 98 02 00 00 mov 0x298(%rbx),%rsi +ffffffff80002a48: ff d0 call *%rax + if (ctx->map != NULL) { +ffffffff80002a4a: 48 8b bb d8 02 00 00 mov 0x2d8(%rbx),%rdi +ffffffff80002a51: 48 85 ff test %rdi,%rdi +ffffffff80002a54: 74 0e je ffffffff80002a64 + _free(ctx->map, ctx->map_size); +ffffffff80002a56: 48 8b b3 b8 02 00 00 mov 0x2b8(%rbx),%rsi +ffffffff80002a5d: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002a62: ff d0 call *%rax + if (ctx->queue != NULL) { +ffffffff80002a64: 48 8b bb c8 02 00 00 mov 0x2c8(%rbx),%rdi +ffffffff80002a6b: 48 85 ff test %rdi,%rdi +ffffffff80002a6e: 74 0e je ffffffff80002a7e + _free(ctx->queue, ctx->queue_size); +ffffffff80002a70: 48 8b b3 b0 02 00 00 mov 0x2b0(%rbx),%rsi +ffffffff80002a77: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002a7c: ff d0 call *%rax + if (ctx->grid != NULL) { +ffffffff80002a7e: 48 8b bb c0 02 00 00 mov 0x2c0(%rbx),%rdi +ffffffff80002a85: 48 85 ff test %rdi,%rdi +ffffffff80002a88: 74 0e je ffffffff80002a98 + _free(ctx->grid, ctx->grid_size); +ffffffff80002a8a: 48 8b b3 a8 02 00 00 mov 0x2a8(%rbx),%rsi +ffffffff80002a91: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002a96: ff d0 call *%rax + if (ctx->font_bool != NULL) { +ffffffff80002a98: 48 8b bb 40 02 00 00 mov 0x240(%rbx),%rdi +ffffffff80002a9f: 48 85 ff test %rdi,%rdi +ffffffff80002aa2: 74 0e je ffffffff80002ab2 + _free(ctx->font_bool, ctx->font_bool_size); +ffffffff80002aa4: 48 8b b3 38 02 00 00 mov 0x238(%rbx),%rsi +ffffffff80002aab: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002ab0: ff d0 call *%rax + if (ctx->font_bits != NULL) { +ffffffff80002ab2: 48 8b bb 30 02 00 00 mov 0x230(%rbx),%rdi +ffffffff80002ab9: 48 85 ff test %rdi,%rdi +ffffffff80002abc: 74 0e je ffffffff80002acc + _free(ctx->font_bits, ctx->font_bits_size); +ffffffff80002abe: 48 8b b3 28 02 00 00 mov 0x228(%rbx),%rsi +ffffffff80002ac5: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002aca: ff d0 call *%rax + _free(ctx, sizeof(struct flanterm_fb_context)); +ffffffff80002acc: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80002ad1: be 20 03 00 00 mov $0x320,%esi +ffffffff80002ad6: 48 89 df mov %rbx,%rdi +ffffffff80002ad9: ff d0 call *%rax + return NULL; +ffffffff80002adb: 31 db xor %ebx,%ebx +ffffffff80002add: e9 a5 fe ff ff jmp ffffffff80002987 +ffffffff80002ae2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + if (bump_allocated_instance == true) { +ffffffff80002ae8: 80 3d 12 86 00 00 00 cmpb $0x0,0x8612(%rip) # ffffffff8000b101 +ffffffff80002aef: 75 ea jne ffffffff80002adb + if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) { +ffffffff80002af1: 49 81 fd 80 07 00 00 cmp $0x780,%r13 +ffffffff80002af8: 77 20 ja ffffffff80002b1a + canvas = NULL; +ffffffff80002afa: 48 c7 84 24 b0 00 00 movq $0x0,0xb0(%rsp) +ffffffff80002b01: 00 00 00 00 00 + _malloc = bump_alloc; +ffffffff80002b06: 49 c7 c7 00 10 00 80 mov $0xffffffff80001000,%r15 + if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) { +ffffffff80002b0d: 49 81 fc b0 04 00 00 cmp $0x4b0,%r12 +ffffffff80002b14: 0f 86 05 f7 ff ff jbe ffffffff8000221f + size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width; +ffffffff80002b1a: ba 80 07 00 00 mov $0x780,%edx + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); +ffffffff80002b1f: 4c 89 e0 mov %r12,%rax + size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height; +ffffffff80002b22: be b0 04 00 00 mov $0x4b0,%esi + canvas = NULL; +ffffffff80002b27: 48 c7 84 24 b0 00 00 movq $0x0,0xb0(%rsp) +ffffffff80002b2e: 00 00 00 00 00 + size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width; +ffffffff80002b33: 49 39 d5 cmp %rdx,%r13 + _malloc = bump_alloc; +ffffffff80002b36: 49 c7 c7 00 10 00 80 mov $0xffffffff80001000,%r15 + size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width; +ffffffff80002b3d: 49 0f 46 d5 cmovbe %r13,%rdx + size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height; +ffffffff80002b41: 49 39 f4 cmp %rsi,%r12 +ffffffff80002b44: 49 0f 46 f4 cmovbe %r12,%rsi + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); +ffffffff80002b48: 48 d1 e8 shr $1,%rax +ffffffff80002b4b: 49 89 d0 mov %rdx,%r8 +ffffffff80002b4e: 48 89 f7 mov %rsi,%rdi +ffffffff80002b51: 49 d1 e8 shr $1,%r8 + height = height_limit; +ffffffff80002b54: 49 89 f4 mov %rsi,%r12 + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); +ffffffff80002b57: 48 d1 ef shr $1,%rdi +ffffffff80002b5a: 48 29 f8 sub %rdi,%rax +ffffffff80002b5d: 48 8b 7c 24 20 mov 0x20(%rsp),%rdi +ffffffff80002b62: 48 0f af c7 imul %rdi,%rax +ffffffff80002b66: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi +ffffffff80002b6b: 48 01 c7 add %rax,%rdi +ffffffff80002b6e: 48 89 f8 mov %rdi,%rax +ffffffff80002b71: 4c 89 ef mov %r13,%rdi + width = width_limit; +ffffffff80002b74: 49 89 d5 mov %rdx,%r13 + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); +ffffffff80002b77: 48 d1 ef shr $1,%rdi +ffffffff80002b7a: 4c 29 c7 sub %r8,%rdi +ffffffff80002b7d: 48 8d 04 b8 lea (%rax,%rdi,4),%rax +ffffffff80002b81: 48 89 44 24 08 mov %rax,0x8(%rsp) + height = height_limit; +ffffffff80002b86: e9 94 f6 ff ff jmp ffffffff8000221f + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002b8b: bf aa 00 00 00 mov $0xaa,%edi +ffffffff80002b90: 89 c1 mov %eax,%ecx +ffffffff80002b92: 41 b8 55 00 00 00 mov $0x55,%r8d + ctx->ansi_colours[0] = convert_colour(_ctx, 0x00000000); // black +ffffffff80002b98: c7 83 48 02 00 00 00 movl $0x0,0x248(%rbx) +ffffffff80002b9f: 00 00 00 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002ba2: 41 89 f9 mov %edi,%r9d +ffffffff80002ba5: 41 89 fa mov %edi,%r10d +ffffffff80002ba8: 41 d3 e1 shl %cl,%r9d +ffffffff80002bab: 89 d1 mov %edx,%ecx +ffffffff80002bad: 41 d3 e0 shl %cl,%r8d +ffffffff80002bb0: 41 d3 e2 shl %cl,%r10d + ctx->ansi_colours[1] = convert_colour(_ctx, 0x00aa0000); // red +ffffffff80002bb3: 44 89 8b 4c 02 00 00 mov %r9d,0x24c(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002bba: 44 89 c1 mov %r8d,%ecx + ctx->ansi_colours[2] = convert_colour(_ctx, 0x0000aa00); // green +ffffffff80002bbd: 44 89 93 50 02 00 00 mov %r10d,0x250(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002bc4: 44 09 c9 or %r9d,%ecx +ffffffff80002bc7: 89 8b 54 02 00 00 mov %ecx,0x254(%rbx) +ffffffff80002bcd: 89 f1 mov %esi,%ecx +ffffffff80002bcf: d3 e7 shl %cl,%edi +ffffffff80002bd1: 89 f9 mov %edi,%ecx + ctx->ansi_colours[4] = convert_colour(_ctx, 0x000000aa); // blue +ffffffff80002bd3: 89 bb 58 02 00 00 mov %edi,0x258(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002bd9: 44 09 d7 or %r10d,%edi +ffffffff80002bdc: 44 09 c9 or %r9d,%ecx + ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan +ffffffff80002bdf: 89 bb 60 02 00 00 mov %edi,0x260(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002be5: 44 09 cf or %r9d,%edi + if (ansi_bright_colours != NULL) { +ffffffff80002be8: 48 83 bc 24 c0 00 00 cmpq $0x0,0xc0(%rsp) +ffffffff80002bef: 00 00 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002bf1: 89 8b 5c 02 00 00 mov %ecx,0x25c(%rbx) +ffffffff80002bf7: 89 bb 64 02 00 00 mov %edi,0x264(%rbx) + if (ansi_bright_colours != NULL) { +ffffffff80002bfd: 0f 85 12 f7 ff ff jne ffffffff80002315 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002c03: bf 55 00 00 00 mov $0x55,%edi +ffffffff80002c08: 41 b8 ff 00 00 00 mov $0xff,%r8d +ffffffff80002c0e: 89 c1 mov %eax,%ecx +ffffffff80002c10: 45 89 c1 mov %r8d,%r9d +ffffffff80002c13: 41 89 fb mov %edi,%r11d +ffffffff80002c16: 41 d3 e1 shl %cl,%r9d +ffffffff80002c19: 41 d3 e3 shl %cl,%r11d +ffffffff80002c1c: 49 c1 e1 20 shl $0x20,%r9 +ffffffff80002c20: 4c 89 d9 mov %r11,%rcx +ffffffff80002c23: 41 89 fb mov %edi,%r11d +ffffffff80002c26: 4c 09 c9 or %r9,%rcx +ffffffff80002c29: 49 89 ca mov %rcx,%r10 +ffffffff80002c2c: 89 d1 mov %edx,%ecx +ffffffff80002c2e: 41 d3 e3 shl %cl,%r11d +ffffffff80002c31: 4d 89 d9 mov %r11,%r9 +ffffffff80002c34: 4c 89 d9 mov %r11,%rcx +ffffffff80002c37: 49 c1 e1 20 shl $0x20,%r9 +ffffffff80002c3b: 4c 09 c9 or %r9,%rcx +ffffffff80002c3e: 45 89 c1 mov %r8d,%r9d +ffffffff80002c41: 4c 09 d1 or %r10,%rcx +ffffffff80002c44: 49 89 cb mov %rcx,%r11 +ffffffff80002c47: 89 d1 mov %edx,%ecx +ffffffff80002c49: 41 d3 e1 shl %cl,%r9d +ffffffff80002c4c: 4c 89 c9 mov %r9,%rcx +ffffffff80002c4f: 49 c1 e1 20 shl $0x20,%r9 +ffffffff80002c53: 4c 09 c9 or %r9,%rcx +ffffffff80002c56: 4c 09 d1 or %r10,%rcx +ffffffff80002c59: 49 89 c9 mov %rcx,%r9 +ffffffff80002c5c: 89 f1 mov %esi,%ecx +ffffffff80002c5e: d3 e7 shl %cl,%edi +ffffffff80002c60: 48 89 f9 mov %rdi,%rcx +ffffffff80002c63: 48 c1 e1 20 shl $0x20,%rcx +ffffffff80002c67: 48 09 cf or %rcx,%rdi +ffffffff80002c6a: 89 f1 mov %esi,%ecx +ffffffff80002c6c: 41 d3 e0 shl %cl,%r8d +ffffffff80002c6f: 4c 89 c1 mov %r8,%rcx +ffffffff80002c72: 48 c1 e1 20 shl $0x20,%rcx +ffffffff80002c76: 4c 09 c1 or %r8,%rcx +ffffffff80002c79: 4d 89 d8 mov %r11,%r8 +ffffffff80002c7c: 49 09 f8 or %rdi,%r8 +ffffffff80002c7f: 4c 09 cf or %r9,%rdi + ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black +ffffffff80002c82: 48 89 bb 70 02 00 00 mov %rdi,0x270(%rbx) + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002c89: 4c 89 df mov %r11,%rdi +ffffffff80002c8c: 48 09 cf or %rcx,%rdi +ffffffff80002c8f: 4c 09 c9 or %r9,%rcx + ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black +ffffffff80002c92: 4c 89 83 68 02 00 00 mov %r8,0x268(%rbx) +ffffffff80002c99: 48 89 bb 78 02 00 00 mov %rdi,0x278(%rbx) +ffffffff80002ca0: 48 89 8b 80 02 00 00 mov %rcx,0x280(%rbx) +ffffffff80002ca7: e9 b8 f6 ff ff jmp ffffffff80002364 + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002cac: bf ff 00 00 00 mov $0xff,%edi +ffffffff80002cb1: 89 d1 mov %edx,%ecx +ffffffff80002cb3: 41 89 f8 mov %edi,%r8d +ffffffff80002cb6: 41 d3 e0 shl %cl,%r8d +ffffffff80002cb9: 89 f1 mov %esi,%ecx +ffffffff80002cbb: 44 89 c2 mov %r8d,%edx +ffffffff80002cbe: 41 89 f8 mov %edi,%r8d +ffffffff80002cc1: 41 d3 e0 shl %cl,%r8d +ffffffff80002cc4: 89 c1 mov %eax,%ecx +ffffffff80002cc6: 44 09 c2 or %r8d,%edx +ffffffff80002cc9: d3 e7 shl %cl,%edi +ffffffff80002ccb: 09 fa or %edi,%edx +ffffffff80002ccd: e9 ab f7 ff ff jmp ffffffff8000247d +ffffffff80002cd2: 41 b8 55 00 00 00 mov $0x55,%r8d +ffffffff80002cd8: 89 d1 mov %edx,%ecx +ffffffff80002cda: 45 89 c1 mov %r8d,%r9d +ffffffff80002cdd: 44 89 c7 mov %r8d,%edi +ffffffff80002ce0: 41 d3 e1 shl %cl,%r9d +ffffffff80002ce3: 89 f1 mov %esi,%ecx +ffffffff80002ce5: d3 e7 shl %cl,%edi +ffffffff80002ce7: 89 c1 mov %eax,%ecx +ffffffff80002ce9: 44 09 cf or %r9d,%edi +ffffffff80002cec: 41 d3 e0 shl %cl,%r8d +ffffffff80002cef: 44 09 c7 or %r8d,%edi +ffffffff80002cf2: e9 40 f7 ff ff jmp ffffffff80002437 + ctx->font_width = font_width = 8; +ffffffff80002cf7: 48 c7 83 b8 01 00 00 movq $0x8,0x1b8(%rbx) +ffffffff80002cfe: 08 00 00 00 + ctx->font_bits = _malloc(ctx->font_bits_size); +ffffffff80002d02: bf 00 10 00 00 mov $0x1000,%edi + ctx->font_height = font_height = 16; +ffffffff80002d07: 48 c7 83 c0 01 00 00 movq $0x10,0x1c0(%rbx) +ffffffff80002d0e: 10 00 00 00 + ctx->font_bits_size = FONT_BYTES; +ffffffff80002d12: 48 c7 83 28 02 00 00 movq $0x1000,0x228(%rbx) +ffffffff80002d19: 00 10 00 00 + ctx->font_bits = _malloc(ctx->font_bits_size); +ffffffff80002d1d: 41 ff d7 call *%r15 +ffffffff80002d20: 48 89 83 30 02 00 00 mov %rax,0x230(%rbx) +ffffffff80002d27: 48 89 c7 mov %rax,%rdi + if (ctx->font_bits == NULL) { +ffffffff80002d2a: 48 85 c0 test %rax,%rax +ffffffff80002d2d: 0f 84 e7 fc ff ff je ffffffff80002a1a + memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size); +ffffffff80002d33: 48 8b 93 28 02 00 00 mov 0x228(%rbx),%rdx +ffffffff80002d3a: 48 c7 c6 00 70 00 80 mov $0xffffffff80007000,%rsi + ctx->font_height = font_height = 16; +ffffffff80002d41: bd 10 00 00 00 mov $0x10,%ebp + memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size); +ffffffff80002d46: e8 f5 39 00 00 call ffffffff80006740 + font_spacing = 1; +ffffffff80002d4b: 48 c7 84 24 00 01 00 movq $0x1,0x100(%rsp) +ffffffff80002d52: 00 01 00 00 00 +ffffffff80002d57: e9 c3 f7 ff ff jmp ffffffff8000251f + return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); +ffffffff80002d5c: bf aa 00 00 00 mov $0xaa,%edi +ffffffff80002d61: 89 d1 mov %edx,%ecx +ffffffff80002d63: 41 89 f9 mov %edi,%r9d +ffffffff80002d66: 41 89 f8 mov %edi,%r8d +ffffffff80002d69: 41 d3 e1 shl %cl,%r9d +ffffffff80002d6c: 89 f1 mov %esi,%ecx +ffffffff80002d6e: 41 d3 e0 shl %cl,%r8d +ffffffff80002d71: 89 c1 mov %eax,%ecx +ffffffff80002d73: 45 09 c8 or %r9d,%r8d +ffffffff80002d76: d3 e7 shl %cl,%edi +ffffffff80002d78: 41 09 f8 or %edi,%r8d +ffffffff80002d7b: 45 89 c2 mov %r8d,%r10d +ffffffff80002d7e: e9 6a f6 ff ff jmp ffffffff800023ed + if (font_scale_x == 1 && font_scale_y == 1) { +ffffffff80002d83: 48 83 bc 24 10 01 00 cmpq $0x1,0x110(%rsp) +ffffffff80002d8a: 00 01 +ffffffff80002d8c: 75 16 jne ffffffff80002da4 +ffffffff80002d8e: 48 83 bc 24 08 01 00 cmpq $0x1,0x108(%rsp) +ffffffff80002d95: 00 01 +ffffffff80002d97: 48 c7 c0 c0 1e 00 80 mov $0xffffffff80001ec0,%rax +ffffffff80002d9e: 0f 84 c2 fa ff ff je ffffffff80002866 +ffffffff80002da4: 48 c7 c0 e0 1f 00 80 mov $0xffffffff80001fe0,%rax +ffffffff80002dab: e9 b6 fa ff ff jmp ffffffff80002866 + bump_allocated_instance = true; +ffffffff80002db0: c6 05 4a 83 00 00 01 movb $0x1,0x834a(%rip) # ffffffff8000b101 +ffffffff80002db7: e9 cb fb ff ff jmp ffffffff80002987 + if (font_scale_x == 1 && font_scale_y == 1) { +ffffffff80002dbc: 48 c7 c0 c0 1b 00 80 mov $0xffffffff80001bc0,%rax +ffffffff80002dc3: e9 9e fa ff ff jmp ffffffff80002866 + bump_alloc_ptr = 0; +ffffffff80002dc8: 48 c7 05 35 83 00 00 movq $0x0,0x8335(%rip) # ffffffff8000b108 +ffffffff80002dcf: 00 00 00 00 + return NULL; +ffffffff80002dd3: 31 db xor %ebx,%ebx +ffffffff80002dd5: e9 ad fb ff ff jmp ffffffff80002987 +ffffffff80002dda: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff80002de0 : +}; + +#define CHARSET_DEFAULT 0 +#define CHARSET_DEC_SPECIAL 1 + +void flanterm_context_reinit(struct flanterm_context *ctx) { +ffffffff80002de0: f3 0f 1e fa endbr64 + ctx->rrr = false; + ctx->discard_next = false; + ctx->bold = false; + ctx->bg_bold = false; + ctx->reverse_video = false; + ctx->dec_private = false; +ffffffff80002de4: 0f b7 05 b5 7b 00 00 movzwl 0x7bb5(%rip),%eax # ffffffff8000a9a0 + ctx->tab_size = 8; +ffffffff80002deb: 48 c7 07 08 00 00 00 movq $0x8,(%rdi) + ctx->autoflush = true; +ffffffff80002df2: 48 c7 47 08 01 01 01 movq $0x10101,0x8(%rdi) +ffffffff80002df9: 00 + ctx->dec_private = false; +ffffffff80002dfa: 66 89 47 14 mov %ax,0x14(%rdi) + ctx->insert_mode = false; + ctx->unicode_remaining = 0; + ctx->g_select = 0; +ffffffff80002dfe: 66 89 47 28 mov %ax,0x28(%rdi) + ctx->saved_cursor_x = 0; + ctx->saved_cursor_y = 0; + ctx->current_primary = (size_t)-1; + ctx->current_bg = (size_t)-1; + ctx->scroll_top_margin = 0; + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80002e02: 48 8b 87 e0 00 00 00 mov 0xe0(%rdi),%rax + ctx->discard_next = false; +ffffffff80002e09: c7 47 10 00 00 00 00 movl $0x0,0x10(%rdi) + ctx->unicode_remaining = 0; +ffffffff80002e10: 48 c7 47 20 00 00 00 movq $0x0,0x20(%rdi) +ffffffff80002e17: 00 + ctx->charsets[1] = CHARSET_DEC_SPECIAL; +ffffffff80002e18: c6 47 2a 01 movb $0x1,0x2a(%rdi) + ctx->current_charset = 0; +ffffffff80002e1c: 48 c7 47 30 00 00 00 movq $0x0,0x30(%rdi) +ffffffff80002e23: 00 + ctx->escape_offset = 0; +ffffffff80002e24: 48 c7 47 38 00 00 00 movq $0x0,0x38(%rdi) +ffffffff80002e2b: 00 + ctx->esc_values_i = 0; +ffffffff80002e2c: 48 c7 47 40 00 00 00 movq $0x0,0x40(%rdi) +ffffffff80002e33: 00 + ctx->saved_cursor_x = 0; +ffffffff80002e34: 48 c7 47 48 00 00 00 movq $0x0,0x48(%rdi) +ffffffff80002e3b: 00 + ctx->saved_cursor_y = 0; +ffffffff80002e3c: 48 c7 47 50 00 00 00 movq $0x0,0x50(%rdi) +ffffffff80002e43: 00 + ctx->current_primary = (size_t)-1; +ffffffff80002e44: 48 c7 47 58 ff ff ff movq $0xffffffffffffffff,0x58(%rdi) +ffffffff80002e4b: ff + ctx->current_bg = (size_t)-1; +ffffffff80002e4c: 48 c7 47 60 ff ff ff movq $0xffffffffffffffff,0x60(%rdi) +ffffffff80002e53: ff + ctx->scroll_top_margin = 0; +ffffffff80002e54: 48 c7 47 68 00 00 00 movq $0x0,0x68(%rdi) +ffffffff80002e5b: 00 + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80002e5c: 48 89 47 70 mov %rax,0x70(%rdi) + ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR; +ffffffff80002e60: 48 c7 87 b8 00 00 00 movq $0x10,0xb8(%rdi) +ffffffff80002e67: 10 00 00 00 +} +ffffffff80002e6b: c3 ret +ffffffff80002e6c: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80002e70 : + } + + return 0; +} + +int mk_wcwidth(uint32_t ucs) { +ffffffff80002e70: f3 0f 1e fa endbr64 +ffffffff80002e74: 89 fa mov %edi,%edx + { 0xE0100, 0xE01EF } + }; + + /* test for 8-bit control characters */ + if (ucs == 0) + return 0; +ffffffff80002e76: 31 c0 xor %eax,%eax + if (ucs == 0) +ffffffff80002e78: 85 ff test %edi,%edi +ffffffff80002e7a: 74 71 je ffffffff80002eed + if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) +ffffffff80002e7c: 8d 47 81 lea -0x7f(%rdi),%eax +ffffffff80002e7f: 83 f8 20 cmp $0x20,%eax + return 1; +ffffffff80002e82: b8 01 00 00 00 mov $0x1,%eax + if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) +ffffffff80002e87: 76 67 jbe ffffffff80002ef0 +ffffffff80002e89: 83 ff 1f cmp $0x1f,%edi +ffffffff80002e8c: 76 62 jbe ffffffff80002ef0 + if (ucs < table[0].first || ucs > table[max].last) +ffffffff80002e8e: 81 ff ff 02 00 00 cmp $0x2ff,%edi +ffffffff80002e94: 76 57 jbe ffffffff80002eed +ffffffff80002e96: 81 ff ef 01 0e 00 cmp $0xe01ef,%edi +ffffffff80002e9c: 0f 87 be 00 00 00 ja ffffffff80002f60 + int min = 0; +ffffffff80002ea2: 31 f6 xor %esi,%esi +ffffffff80002ea4: bf 8d 00 00 00 mov $0x8d,%edi +ffffffff80002ea9: eb 0c jmp ffffffff80002eb7 +ffffffff80002eab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + min = mid + 1; +ffffffff80002eb0: 8d 70 01 lea 0x1(%rax),%esi + while (max >= min) { +ffffffff80002eb3: 39 f7 cmp %esi,%edi +ffffffff80002eb5: 7c 41 jl ffffffff80002ef8 + mid = (min + max) / 2; +ffffffff80002eb7: 8d 0c 37 lea (%rdi,%rsi,1),%ecx +ffffffff80002eba: 89 c8 mov %ecx,%eax +ffffffff80002ebc: c1 e8 1f shr $0x1f,%eax +ffffffff80002ebf: 01 c8 add %ecx,%eax +ffffffff80002ec1: d1 f8 sar $1,%eax + if (ucs > table[mid].last) +ffffffff80002ec3: 48 63 c8 movslq %eax,%rcx +ffffffff80002ec6: 39 14 cd 64 a1 00 80 cmp %edx,-0x7fff5e9c(,%rcx,8) +ffffffff80002ecd: 72 e1 jb ffffffff80002eb0 + else if (ucs < table[mid].first) +ffffffff80002ecf: 3b 14 cd 60 a1 00 80 cmp -0x7fff5ea0(,%rcx,8),%edx +ffffffff80002ed6: 0f 83 d4 00 00 00 jae ffffffff80002fb0 + max = mid - 1; +ffffffff80002edc: 8d 78 ff lea -0x1(%rax),%edi +ffffffff80002edf: eb d2 jmp ffffffff80002eb3 +ffffffff80002ee1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) +ffffffff80002ee8: b8 01 00 00 00 mov $0x1,%eax + (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ + (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */ + (ucs >= 0xffe0 && ucs <= 0xffe6) || + (ucs >= 0x20000 && ucs <= 0x2fffd) || + (ucs >= 0x30000 && ucs <= 0x3fffd))); +} +ffffffff80002eed: c3 ret +ffffffff80002eee: 66 90 xchg %ax,%ax +ffffffff80002ef0: c3 ret +ffffffff80002ef1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + (ucs >= 0x1100 && +ffffffff80002ef8: 81 fa ff 10 00 00 cmp $0x10ff,%edx +ffffffff80002efe: 76 e8 jbe ffffffff80002ee8 + ucs == 0x2329 || ucs == 0x232a || +ffffffff80002f00: 8d 82 d7 dc ff ff lea -0x2329(%rdx),%eax +ffffffff80002f06: 83 f8 01 cmp $0x1,%eax +ffffffff80002f09: 76 08 jbe ffffffff80002f13 +ffffffff80002f0b: 81 fa 5f 11 00 00 cmp $0x115f,%edx +ffffffff80002f11: 77 06 ja ffffffff80002f19 +ffffffff80002f13: b8 02 00 00 00 mov $0x2,%eax +ffffffff80002f18: c3 ret + (ucs >= 0x2e80 && ucs <= 0xa4cf && +ffffffff80002f19: 8d 82 80 d1 ff ff lea -0x2e80(%rdx),%eax + ucs == 0x2329 || ucs == 0x232a || +ffffffff80002f1f: 3d 4f 76 00 00 cmp $0x764f,%eax +ffffffff80002f24: 77 08 ja ffffffff80002f2e +ffffffff80002f26: 81 fa 3f 30 00 00 cmp $0x303f,%edx +ffffffff80002f2c: 75 e5 jne ffffffff80002f13 + (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */ +ffffffff80002f2e: 8d 8a 00 54 ff ff lea -0xac00(%rdx),%ecx +ffffffff80002f34: b8 02 00 00 00 mov $0x2,%eax + ucs != 0x303f) || /* CJK ... Yi */ +ffffffff80002f39: 81 f9 a3 2b 00 00 cmp $0x2ba3,%ecx +ffffffff80002f3f: 76 ac jbe ffffffff80002eed + (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */ +ffffffff80002f41: 8d 8a 00 07 ff ff lea -0xf900(%rdx),%ecx + (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */ +ffffffff80002f47: 81 f9 ff 01 00 00 cmp $0x1ff,%ecx +ffffffff80002f4d: 76 9e jbe ffffffff80002eed + (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */ +ffffffff80002f4f: 8d 8a f0 01 ff ff lea -0xfe10(%rdx),%ecx + (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */ +ffffffff80002f55: 83 f9 09 cmp $0x9,%ecx +ffffffff80002f58: 76 93 jbe ffffffff80002eed +ffffffff80002f5a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ +ffffffff80002f60: 8d 8a d0 01 ff ff lea -0xfe30(%rdx),%ecx +ffffffff80002f66: b8 02 00 00 00 mov $0x2,%eax + (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */ +ffffffff80002f6b: 83 f9 3f cmp $0x3f,%ecx +ffffffff80002f6e: 0f 86 79 ff ff ff jbe ffffffff80002eed + (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */ +ffffffff80002f74: 8d 8a 00 01 ff ff lea -0xff00(%rdx),%ecx + (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ +ffffffff80002f7a: 83 f9 60 cmp $0x60,%ecx +ffffffff80002f7d: 0f 86 6a ff ff ff jbe ffffffff80002eed + (ucs >= 0xffe0 && ucs <= 0xffe6) || +ffffffff80002f83: 8d 8a 20 00 ff ff lea -0xffe0(%rdx),%ecx + (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */ +ffffffff80002f89: 83 f9 06 cmp $0x6,%ecx +ffffffff80002f8c: 0f 86 5b ff ff ff jbe ffffffff80002eed + (ucs >= 0xffe0 && ucs <= 0xffe6) || +ffffffff80002f92: 89 d0 mov %edx,%eax +ffffffff80002f94: 25 ff ff fe ff and $0xfffeffff,%eax +ffffffff80002f99: 2d 00 00 02 00 sub $0x20000,%eax +ffffffff80002f9e: 3d fd ff 00 00 cmp $0xfffd,%eax +ffffffff80002fa3: 0f 96 c0 setbe %al +ffffffff80002fa6: 0f b6 c0 movzbl %al,%eax + return 1 + +ffffffff80002fa9: 83 c0 01 add $0x1,%eax +ffffffff80002fac: c3 ret +ffffffff80002fad: 0f 1f 00 nopl (%rax) + return 0; +ffffffff80002fb0: 31 c0 xor %eax,%eax +ffffffff80002fb2: c3 ret +ffffffff80002fb3: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80002fba: 00 00 00 +ffffffff80002fbd: 0f 1f 00 nopl (%rax) + +ffffffff80002fc0 : +void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count) { +ffffffff80002fc0: f3 0f 1e fa endbr64 +ffffffff80002fc4: 41 57 push %r15 +ffffffff80002fc6: 41 56 push %r14 +ffffffff80002fc8: 41 55 push %r13 +ffffffff80002fca: 4c 8d 2c 16 lea (%rsi,%rdx,1),%r13 +ffffffff80002fce: 41 54 push %r12 +ffffffff80002fd0: 55 push %rbp +ffffffff80002fd1: 48 89 f5 mov %rsi,%rbp +ffffffff80002fd4: 53 push %rbx +ffffffff80002fd5: 48 89 fb mov %rdi,%rbx +ffffffff80002fd8: 48 83 ec 28 sub $0x28,%rsp + for (size_t i = 0; i < count; i++) { +ffffffff80002fdc: 48 85 d2 test %rdx,%rdx +ffffffff80002fdf: 0f 84 bf 00 00 00 je ffffffff800030a4 +ffffffff80002fe5: 0f 1f 00 nopl (%rax) + + return -1; +} + +static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c) { + if (ctx->discard_next || (c == 0x18 || c == 0x1a)) { +ffffffff80002fe8: 80 7b 10 00 cmpb $0x0,0x10(%rbx) + flanterm_putchar(ctx, buf[i]); +ffffffff80002fec: 44 0f b6 65 00 movzbl 0x0(%rbp),%r12d + if (ctx->discard_next || (c == 0x18 || c == 0x1a)) { +ffffffff80002ff1: 0f 85 89 00 00 00 jne ffffffff80003080 +ffffffff80002ff7: 44 89 e0 mov %r12d,%eax +ffffffff80002ffa: 83 e0 fd and $0xfffffffd,%eax +ffffffff80002ffd: 3c 18 cmp $0x18,%al +ffffffff80002fff: 74 7f je ffffffff80003080 + ctx->osc_escape = false; + ctx->g_select = 0; + return; + } + + if (ctx->unicode_remaining != 0) { +ffffffff80003001: 48 8b 43 20 mov 0x20(%rbx),%rax +ffffffff80003005: 48 85 c0 test %rax,%rax +ffffffff80003008: 74 17 je ffffffff80003021 + if ((c & 0xc0) != 0x80) { +ffffffff8000300a: 44 89 e2 mov %r12d,%edx +ffffffff8000300d: 83 e2 c0 and $0xffffffc0,%edx +ffffffff80003010: 80 fa 80 cmp $0x80,%dl +ffffffff80003013: 0f 84 f7 00 00 00 je ffffffff80003110 + ctx->unicode_remaining = 0; +ffffffff80003019: 48 c7 43 20 00 00 00 movq $0x0,0x20(%rbx) +ffffffff80003020: 00 + } + return; + } + +unicode_error: + if (c >= 0xc0 && c <= 0xf7) { +ffffffff80003021: 41 8d 44 24 40 lea 0x40(%r12),%eax +ffffffff80003026: 3c 37 cmp $0x37,%al +ffffffff80003028: 0f 86 a2 00 00 00 jbe ffffffff800030d0 + ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3); + } + return; + } + + if (ctx->escape == true) { +ffffffff8000302e: 80 7b 0c 00 cmpb $0x0,0xc(%rbx) +ffffffff80003032: 0f 85 c8 01 00 00 jne ffffffff80003200 + escape_parse(ctx, c); + return; + } + + if (ctx->g_select) { +ffffffff80003038: 0f b6 43 28 movzbl 0x28(%rbx),%eax +ffffffff8000303c: 84 c0 test %al,%al +ffffffff8000303e: 0f 85 8c 01 00 00 jne ffffffff800031d0 + ctx->g_select = 0; + return; + } + + size_t x, y; + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80003044: 48 8d 54 24 18 lea 0x18(%rsp),%rdx +ffffffff80003049: 48 8d 74 24 10 lea 0x10(%rsp),%rsi +ffffffff8000304e: 48 89 df mov %rbx,%rdi +ffffffff80003051: ff 93 08 01 00 00 call *0x108(%rbx) + + switch (c) { +ffffffff80003057: 41 80 fc 1b cmp $0x1b,%r12b +ffffffff8000305b: 0f 8f 5f 02 00 00 jg ffffffff800032c0 +ffffffff80003061: 45 84 e4 test %r12b,%r12b +ffffffff80003064: 0f 88 66 02 00 00 js ffffffff800032d0 +ffffffff8000306a: 41 80 fc 1b cmp $0x1b,%r12b +ffffffff8000306e: 0f 87 5c 02 00 00 ja ffffffff800032d0 +ffffffff80003074: 41 0f b6 c4 movzbl %r12b,%eax +ffffffff80003078: 3e ff 24 c5 00 80 00 notrack jmp *-0x7fff8000(,%rax,8) +ffffffff8000307f: 80 + ctx->discard_next = false; +ffffffff80003080: c6 43 10 00 movb $0x0,0x10(%rbx) + ctx->unicode_remaining = 0; +ffffffff80003084: 48 c7 43 20 00 00 00 movq $0x0,0x20(%rbx) +ffffffff8000308b: 00 + ctx->control_sequence = false; +ffffffff8000308c: c7 43 0b 00 00 00 00 movl $0x0,0xb(%rbx) + ctx->g_select = 0; +ffffffff80003093: c6 43 28 00 movb $0x0,0x28(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff80003097: 48 83 c5 01 add $0x1,%rbp +ffffffff8000309b: 49 39 ed cmp %rbp,%r13 +ffffffff8000309e: 0f 85 44 ff ff ff jne ffffffff80002fe8 + if (ctx->autoflush) { +ffffffff800030a4: 80 7b 08 00 cmpb $0x0,0x8(%rbx) +ffffffff800030a8: 0f 84 da 00 00 00 je ffffffff80003188 + ctx->double_buffer_flush(ctx); +ffffffff800030ae: 48 8b 83 90 01 00 00 mov 0x190(%rbx),%rax +} +ffffffff800030b5: 48 83 c4 28 add $0x28,%rsp + ctx->double_buffer_flush(ctx); +ffffffff800030b9: 48 89 df mov %rbx,%rdi +} +ffffffff800030bc: 5b pop %rbx +ffffffff800030bd: 5d pop %rbp +ffffffff800030be: 41 5c pop %r12 +ffffffff800030c0: 41 5d pop %r13 +ffffffff800030c2: 41 5e pop %r14 +ffffffff800030c4: 41 5f pop %r15 + ctx->double_buffer_flush(ctx); +ffffffff800030c6: ff e0 jmp *%rax +ffffffff800030c8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800030cf: 00 + ctx->code_point = (uint64_t)(c & 0x1f) << 6; +ffffffff800030d0: 41 0f b6 d4 movzbl %r12b,%edx + if (c >= 0xc0 && c <= 0xdf) { +ffffffff800030d4: 3c 1f cmp $0x1f,%al +ffffffff800030d6: 0f 86 c4 00 00 00 jbe ffffffff800031a0 + } else if (c >= 0xe0 && c <= 0xef) { +ffffffff800030dc: 41 83 c4 20 add $0x20,%r12d +ffffffff800030e0: 41 80 fc 0f cmp $0xf,%r12b +ffffffff800030e4: 0f 87 66 01 00 00 ja ffffffff80003250 + ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2); +ffffffff800030ea: 48 c1 e2 0c shl $0xc,%rdx + for (size_t i = 0; i < count; i++) { +ffffffff800030ee: 48 83 c5 01 add $0x1,%rbp + ctx->unicode_remaining = 2; +ffffffff800030f2: 48 c7 43 20 02 00 00 movq $0x2,0x20(%rbx) +ffffffff800030f9: 00 + ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2); +ffffffff800030fa: 81 e2 ff ff 00 00 and $0xffff,%edx +ffffffff80003100: 48 89 53 18 mov %rdx,0x18(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff80003104: 49 39 ed cmp %rbp,%r13 +ffffffff80003107: 0f 85 db fe ff ff jne ffffffff80002fe8 +ffffffff8000310d: eb 95 jmp ffffffff800030a4 +ffffffff8000310f: 90 nop + ctx->unicode_remaining--; +ffffffff80003110: 48 83 e8 01 sub $0x1,%rax + ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining); +ffffffff80003114: 41 83 e4 3f and $0x3f,%r12d +ffffffff80003118: 8d 0c 40 lea (%rax,%rax,2),%ecx + ctx->unicode_remaining--; +ffffffff8000311b: 48 89 43 20 mov %rax,0x20(%rbx) + ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining); +ffffffff8000311f: 01 c9 add %ecx,%ecx +ffffffff80003121: 49 d3 e4 shl %cl,%r12 +ffffffff80003124: 4c 0b 63 18 or 0x18(%rbx),%r12 +ffffffff80003128: 4c 89 63 18 mov %r12,0x18(%rbx) + if (ctx->unicode_remaining != 0) { +ffffffff8000312c: 48 85 c0 test %rax,%rax +ffffffff8000312f: 0f 85 62 ff ff ff jne ffffffff80003097 + switch (code_point) { +ffffffff80003135: 49 81 fc 48 22 00 00 cmp $0x2248,%r12 +ffffffff8000313c: 0f 87 3e 01 00 00 ja ffffffff80003280 +ffffffff80003142: 49 81 fc 18 22 00 00 cmp $0x2218,%r12 +ffffffff80003149: 0f 87 38 0e 00 00 ja ffffffff80003f87 +ffffffff8000314f: 49 81 fc 92 01 00 00 cmp $0x192,%r12 +ffffffff80003156: 0f 87 12 03 00 00 ja ffffffff8000346e +ffffffff8000315c: 49 81 fc a0 00 00 00 cmp $0xa0,%r12 +ffffffff80003163: 0f 86 57 02 00 00 jbe ffffffff800033c0 +ffffffff80003169: 49 8d 84 24 5f ff ff lea -0xa1(%r12),%rax +ffffffff80003170: ff +ffffffff80003171: 48 3d f1 00 00 00 cmp $0xf1,%rax +ffffffff80003177: 0f 87 43 02 00 00 ja ffffffff800033c0 +ffffffff8000317d: 3e ff 24 c5 e0 80 00 notrack jmp *-0x7fff7f20(,%rax,8) +ffffffff80003184: 80 +ffffffff80003185: 0f 1f 00 nopl (%rax) +} +ffffffff80003188: 48 83 c4 28 add $0x28,%rsp +ffffffff8000318c: 5b pop %rbx +ffffffff8000318d: 5d pop %rbp +ffffffff8000318e: 41 5c pop %r12 +ffffffff80003190: 41 5d pop %r13 +ffffffff80003192: 41 5e pop %r14 +ffffffff80003194: 41 5f pop %r15 +ffffffff80003196: c3 ret +ffffffff80003197: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000319e: 00 00 + ctx->code_point = (uint64_t)(c & 0x1f) << 6; +ffffffff800031a0: 48 c1 e2 06 shl $0x6,%rdx + for (size_t i = 0; i < count; i++) { +ffffffff800031a4: 48 83 c5 01 add $0x1,%rbp + ctx->unicode_remaining = 1; +ffffffff800031a8: 48 c7 43 20 01 00 00 movq $0x1,0x20(%rbx) +ffffffff800031af: 00 + ctx->code_point = (uint64_t)(c & 0x1f) << 6; +ffffffff800031b0: 81 e2 c0 07 00 00 and $0x7c0,%edx +ffffffff800031b6: 48 89 53 18 mov %rdx,0x18(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff800031ba: 49 39 ed cmp %rbp,%r13 +ffffffff800031bd: 0f 85 25 fe ff ff jne ffffffff80002fe8 +ffffffff800031c3: e9 dc fe ff ff jmp ffffffff800030a4 +ffffffff800031c8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800031cf: 00 + ctx->g_select--; +ffffffff800031d0: 83 e8 01 sub $0x1,%eax + switch (c) { +ffffffff800031d3: 41 80 fc 30 cmp $0x30,%r12b +ffffffff800031d7: 0f 84 8b 03 00 00 je ffffffff80003568 +ffffffff800031dd: 41 80 fc 42 cmp $0x42,%r12b +ffffffff800031e1: 0f 84 59 01 00 00 je ffffffff80003340 + ctx->g_select = 0; +ffffffff800031e7: c6 43 28 00 movb $0x0,0x28(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff800031eb: 48 83 c5 01 add $0x1,%rbp +ffffffff800031ef: 49 39 ed cmp %rbp,%r13 +ffffffff800031f2: 0f 85 f0 fd ff ff jne ffffffff80002fe8 +ffffffff800031f8: e9 a7 fe ff ff jmp ffffffff800030a4 +ffffffff800031fd: 0f 1f 00 nopl (%rax) + ctx->escape_offset++; +ffffffff80003200: 48 8b 43 38 mov 0x38(%rbx),%rax +ffffffff80003204: 48 83 c0 01 add $0x1,%rax + if (ctx->osc == true) { +ffffffff80003208: 80 7b 0d 00 cmpb $0x0,0xd(%rbx) + ctx->escape_offset++; +ffffffff8000320c: 48 89 43 38 mov %rax,0x38(%rbx) + if (ctx->osc == true) { +ffffffff80003210: 0f 85 6a 03 00 00 jne ffffffff80003580 + if (ctx->control_sequence == true) { +ffffffff80003216: 80 7b 0b 00 cmpb $0x0,0xb(%rbx) +ffffffff8000321a: 0f 85 87 03 00 00 jne ffffffff800035a7 + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80003220: 48 8d 54 24 18 lea 0x18(%rsp),%rdx +ffffffff80003225: 48 8d 74 24 10 lea 0x10(%rsp),%rsi +ffffffff8000322a: 48 89 df mov %rbx,%rdi +ffffffff8000322d: ff 93 08 01 00 00 call *0x108(%rbx) + switch (c) { +ffffffff80003233: 41 8d 44 24 d8 lea -0x28(%r12),%eax +ffffffff80003238: 3c 3b cmp $0x3b,%al +ffffffff8000323a: 0f 87 18 02 00 00 ja ffffffff80003458 +ffffffff80003240: 0f b6 c0 movzbl %al,%eax +ffffffff80003243: 3e ff 24 c5 70 88 00 notrack jmp *-0x7fff7790(,%rax,8) +ffffffff8000324a: 80 +ffffffff8000324b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3); +ffffffff80003250: 48 c1 e2 12 shl $0x12,%rdx + for (size_t i = 0; i < count; i++) { +ffffffff80003254: 48 83 c5 01 add $0x1,%rbp + ctx->unicode_remaining = 3; +ffffffff80003258: 48 c7 43 20 03 00 00 movq $0x3,0x20(%rbx) +ffffffff8000325f: 00 + ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3); +ffffffff80003260: 81 e2 00 00 1c 00 and $0x1c0000,%edx +ffffffff80003266: 48 89 53 18 mov %rdx,0x18(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff8000326a: 49 39 ed cmp %rbp,%r13 +ffffffff8000326d: 0f 85 75 fd ff ff jne ffffffff80002fe8 +ffffffff80003273: e9 2c fe ff ff jmp ffffffff800030a4 +ffffffff80003278: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff8000327f: 00 + switch (code_point) { +ffffffff80003280: 49 81 fc 6b 26 00 00 cmp $0x266b,%r12 +ffffffff80003287: 0f 87 33 01 00 00 ja ffffffff800033c0 +ffffffff8000328d: 49 81 fc ff 24 00 00 cmp $0x24ff,%r12 +ffffffff80003294: 0f 86 95 03 00 00 jbe ffffffff8000362f +ffffffff8000329a: 49 8d 84 24 00 db ff lea -0x2500(%r12),%rax +ffffffff800032a1: ff +ffffffff800032a2: 48 3d 6b 01 00 00 cmp $0x16b,%rax +ffffffff800032a8: 0f 87 12 01 00 00 ja ffffffff800033c0 +ffffffff800032ae: 3e ff 24 c5 50 8a 00 notrack jmp *-0x7fff75b0(,%rax,8) +ffffffff800032b5: 80 +ffffffff800032b6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800032bd: 00 00 00 + switch (c) { +ffffffff800032c0: 41 80 fc 7f cmp $0x7f,%r12b +ffffffff800032c4: 0f 84 cd fd ff ff je ffffffff80003097 +ffffffff800032ca: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + // Move to G0 set + ctx->current_charset = 0; + return; + } + + if (ctx->insert_mode == true) { +ffffffff800032d0: 80 7b 15 00 cmpb $0x0,0x15(%rbx) +ffffffff800032d4: 74 35 je ffffffff8000330b + for (size_t i = ctx->cols - 1; ; i--) { +ffffffff800032d6: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff800032dd: 4c 8d 70 ff lea -0x1(%rax),%r14 +ffffffff800032e1: eb 09 jmp ffffffff800032ec +ffffffff800032e3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800032e8: 49 83 ee 01 sub $0x1,%r14 + ctx->move_character(ctx, i + 1, y, i, y); +ffffffff800032ec: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800032f1: 49 8d 76 01 lea 0x1(%r14),%rsi +ffffffff800032f5: 4c 89 f1 mov %r14,%rcx +ffffffff800032f8: 48 89 df mov %rbx,%rdi +ffffffff800032fb: 49 89 d0 mov %rdx,%r8 +ffffffff800032fe: ff 93 60 01 00 00 call *0x160(%rbx) + if (i == x) { +ffffffff80003304: 4c 3b 74 24 10 cmp 0x10(%rsp),%r14 +ffffffff80003309: 75 dd jne ffffffff800032e8 + } + } + } + + // Translate character set + switch (ctx->charsets[ctx->current_charset]) { +ffffffff8000330b: 48 8b 53 30 mov 0x30(%rbx),%rdx + case '`': FLANTERM_DEC_SPCL_PRN(0x04) +ffffffff8000330f: 48 8b 83 f0 00 00 00 mov 0xf0(%rbx),%rax + switch (ctx->charsets[ctx->current_charset]) { +ffffffff80003316: 80 7c 13 29 01 cmpb $0x1,0x29(%rbx,%rdx,1) +ffffffff8000331b: 0f 84 12 0b 00 00 je ffffffff80003e33 + return; + } + break; + } + + if (c >= 0x20 && c <= 0x7e) { +ffffffff80003321: 41 8d 54 24 e0 lea -0x20(%r12),%edx +ffffffff80003326: 80 fa 5e cmp $0x5e,%dl +ffffffff80003329: 0f 86 be 02 00 00 jbe ffffffff800035ed + ctx->raw_putchar(ctx, c); + } else { + ctx->raw_putchar(ctx, 0xfe); +ffffffff8000332f: be fe 00 00 00 mov $0xfe,%esi +ffffffff80003334: 48 89 df mov %rbx,%rdi +ffffffff80003337: ff d0 call *%rax +ffffffff80003339: e9 59 fd ff ff jmp ffffffff80003097 +ffffffff8000333e: 66 90 xchg %ax,%ax + ctx->charsets[ctx->g_select] = CHARSET_DEFAULT; break; +ffffffff80003340: 0f b6 c0 movzbl %al,%eax +ffffffff80003343: c6 44 03 29 00 movb $0x0,0x29(%rbx,%rax,1) + ctx->g_select = 0; +ffffffff80003348: c6 43 28 00 movb $0x0,0x28(%rbx) + return; +ffffffff8000334c: e9 9a fe ff ff jmp ffffffff800031eb + if (y == ctx->scroll_bottom_margin - 1) { +ffffffff80003351: 48 8b 43 70 mov 0x70(%rbx),%rax +ffffffff80003355: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000335a: 48 83 e8 01 sub $0x1,%rax +ffffffff8000335e: 48 39 d0 cmp %rdx,%rax +ffffffff80003361: 0f 84 92 0a 00 00 je ffffffff80003df9 + ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y + 1); +ffffffff80003367: 48 8b 83 00 01 00 00 mov 0x100(%rbx),%rax +ffffffff8000336e: 48 83 c2 01 add $0x1,%rdx +ffffffff80003372: 31 f6 xor %esi,%esi +ffffffff80003374: f6 83 b8 00 00 00 10 testb $0x10,0xb8(%rbx) +ffffffff8000337b: 75 05 jne ffffffff80003382 +ffffffff8000337d: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff80003382: 48 89 df mov %rbx,%rdi +ffffffff80003385: ff d0 call *%rax +ffffffff80003387: e9 0b fd ff ff jmp ffffffff80003097 + switch (code_point) { +ffffffff8000338c: 49 81 fc 20 23 00 00 cmp $0x2320,%r12 +ffffffff80003393: 0f 84 59 0e 00 00 je ffffffff800041f2 +ffffffff80003399: 49 81 fc 21 23 00 00 cmp $0x2321,%r12 +ffffffff800033a0: 0f 84 42 0e 00 00 je ffffffff800041e8 + case 0x2310: return 169; +ffffffff800033a6: be a9 00 00 00 mov $0xa9,%esi + switch (code_point) { +ffffffff800033ab: 49 81 fc 10 23 00 00 cmp $0x2310,%r12 +ffffffff800033b2: 0f 84 b8 02 00 00 je ffffffff80003670 +ffffffff800033b8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800033bf: 00 + size_t replacement_width = (size_t)mk_wcwidth(ctx->code_point); +ffffffff800033c0: 44 89 e7 mov %r12d,%edi +ffffffff800033c3: e8 a8 fa ff ff call ffffffff80002e70 +ffffffff800033c8: 4c 63 f0 movslq %eax,%r14 + if (replacement_width > 0) { +ffffffff800033cb: 4d 85 f6 test %r14,%r14 +ffffffff800033ce: 0f 84 c3 fc ff ff je ffffffff80003097 + ctx->raw_putchar(ctx, 0xfe); +ffffffff800033d4: be fe 00 00 00 mov $0xfe,%esi +ffffffff800033d9: 48 89 df mov %rbx,%rdi +ffffffff800033dc: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 1; i < replacement_width; i++) { +ffffffff800033e2: 49 83 fe 01 cmp $0x1,%r14 +ffffffff800033e6: 0f 84 ab fc ff ff je ffffffff80003097 +ffffffff800033ec: 41 bc 01 00 00 00 mov $0x1,%r12d +ffffffff800033f2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) +ffffffff800033f8: 49 83 c4 01 add $0x1,%r12 + ctx->raw_putchar(ctx, ' '); +ffffffff800033fc: be 20 00 00 00 mov $0x20,%esi +ffffffff80003401: 48 89 df mov %rbx,%rdi +ffffffff80003404: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 1; i < replacement_width; i++) { +ffffffff8000340a: 4d 39 e6 cmp %r12,%r14 +ffffffff8000340d: 75 e9 jne ffffffff800033f8 +ffffffff8000340f: e9 83 fc ff ff jmp ffffffff80003097 + ctx->save_state(ctx); +ffffffff80003414: 48 89 df mov %rbx,%rdi +ffffffff80003417: ff 93 80 01 00 00 call *0x180(%rbx) + ctx->saved_state_bold = ctx->bold; +ffffffff8000341d: 0f b7 43 11 movzwl 0x11(%rbx),%eax + ctx->saved_state_current_charset = ctx->current_charset; +ffffffff80003421: 48 8b 53 58 mov 0x58(%rbx),%rdx +ffffffff80003425: 48 8b 4b 30 mov 0x30(%rbx),%rcx + ctx->saved_state_bold = ctx->bold; +ffffffff80003429: 66 89 83 c0 00 00 00 mov %ax,0xc0(%rbx) + ctx->saved_state_reverse_video = ctx->reverse_video; +ffffffff80003430: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->saved_state_current_charset = ctx->current_charset; +ffffffff80003434: 48 89 8b c8 00 00 00 mov %rcx,0xc8(%rbx) + ctx->saved_state_reverse_video = ctx->reverse_video; +ffffffff8000343b: 88 83 c2 00 00 00 mov %al,0xc2(%rbx) + ctx->saved_state_current_charset = ctx->current_charset; +ffffffff80003441: 48 8b 43 60 mov 0x60(%rbx),%rax +ffffffff80003445: 48 89 93 d0 00 00 00 mov %rdx,0xd0(%rbx) +ffffffff8000344c: 48 89 83 d8 00 00 00 mov %rax,0xd8(%rbx) + break; +ffffffff80003453: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + for (size_t i = 0; i < count; i++) { +ffffffff80003458: 48 83 c5 01 add $0x1,%rbp + ctx->escape = false; +ffffffff8000345c: c6 43 0c 00 movb $0x0,0xc(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff80003460: 49 39 ed cmp %rbp,%r13 +ffffffff80003463: 0f 85 7f fb ff ff jne ffffffff80002fe8 +ffffffff80003469: e9 36 fc ff ff jmp ffffffff800030a4 + switch (code_point) { +ffffffff8000346e: 49 81 fc c6 03 00 00 cmp $0x3c6,%r12 +ffffffff80003475: 0f 87 80 01 00 00 ja ffffffff800035fb +ffffffff8000347b: 49 81 fc 92 03 00 00 cmp $0x392,%r12 +ffffffff80003482: 0f 86 38 ff ff ff jbe ffffffff800033c0 +ffffffff80003488: 49 8d 84 24 6d fc ff lea -0x393(%r12),%rax +ffffffff8000348f: ff +ffffffff80003490: 48 83 f8 33 cmp $0x33,%rax +ffffffff80003494: 0f 87 26 ff ff ff ja ffffffff800033c0 +ffffffff8000349a: 3e ff 24 c5 b0 95 00 notrack jmp *-0x7fff6a50(,%rax,8) +ffffffff800034a1: 80 + ctx->set_cursor_pos(ctx, 0, y); +ffffffff800034a2: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800034a7: 31 f6 xor %esi,%esi +ffffffff800034a9: 48 89 df mov %rbx,%rdi +ffffffff800034ac: ff 93 00 01 00 00 call *0x100(%rbx) + return; +ffffffff800034b2: e9 e0 fb ff ff jmp ffffffff80003097 + ctx->set_cursor_pos(ctx, x - 1, y); +ffffffff800034b7: 48 8b 44 24 10 mov 0x10(%rsp),%rax +ffffffff800034bc: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800034c1: 48 89 df mov %rbx,%rdi +ffffffff800034c4: 48 8d 70 ff lea -0x1(%rax),%rsi +ffffffff800034c8: ff 93 00 01 00 00 call *0x100(%rbx) + return; +ffffffff800034ce: e9 c4 fb ff ff jmp ffffffff80003097 + if ((x / ctx->tab_size + 1) >= ctx->cols) { +ffffffff800034d3: 48 8b 33 mov (%rbx),%rsi +ffffffff800034d6: 48 8b 44 24 10 mov 0x10(%rsp),%rax +ffffffff800034db: 31 d2 xor %edx,%edx + ctx->set_cursor_pos(ctx, ctx->cols - 1, y); +ffffffff800034dd: 48 8b 8b 00 01 00 00 mov 0x100(%rbx),%rcx +ffffffff800034e4: 48 8b 7c 24 18 mov 0x18(%rsp),%rdi + if ((x / ctx->tab_size + 1) >= ctx->cols) { +ffffffff800034e9: 48 f7 f6 div %rsi +ffffffff800034ec: 48 8b 93 e8 00 00 00 mov 0xe8(%rbx),%rdx +ffffffff800034f3: 48 83 c0 01 add $0x1,%rax +ffffffff800034f7: 48 39 d0 cmp %rdx,%rax +ffffffff800034fa: 0f 83 22 09 00 00 jae ffffffff80003e22 + ctx->set_cursor_pos(ctx, (x / ctx->tab_size + 1) * ctx->tab_size, y); +ffffffff80003500: 48 89 fa mov %rdi,%rdx +ffffffff80003503: 48 0f af f0 imul %rax,%rsi +ffffffff80003507: 48 89 df mov %rbx,%rdi +ffffffff8000350a: ff d1 call *%rcx + return; +ffffffff8000350c: e9 86 fb ff ff jmp ffffffff80003097 + if (ctx->callback != NULL) { +ffffffff80003511: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff80003518: 48 85 c0 test %rax,%rax +ffffffff8000351b: 0f 84 76 fb ff ff je ffffffff80003097 + ctx->callback(ctx, FLANTERM_CB_BELL, 0, 0, 0); +ffffffff80003521: 45 31 c0 xor %r8d,%r8d +ffffffff80003524: 31 c9 xor %ecx,%ecx +ffffffff80003526: 31 d2 xor %edx,%edx +ffffffff80003528: be 14 00 00 00 mov $0x14,%esi +ffffffff8000352d: 48 89 df mov %rbx,%rdi +ffffffff80003530: ff d0 call *%rax +ffffffff80003532: e9 60 fb ff ff jmp ffffffff80003097 + ctx->escape_offset = 0; +ffffffff80003537: 48 c7 43 38 00 00 00 movq $0x0,0x38(%rbx) +ffffffff8000353e: 00 + ctx->escape = true; +ffffffff8000353f: c6 43 0c 01 movb $0x1,0xc(%rbx) + return; +ffffffff80003543: e9 4f fb ff ff jmp ffffffff80003097 + ctx->current_charset = 1; +ffffffff80003548: 48 c7 43 30 01 00 00 movq $0x1,0x30(%rbx) +ffffffff8000354f: 00 + return; +ffffffff80003550: e9 42 fb ff ff jmp ffffffff80003097 + ctx->current_charset = 0; +ffffffff80003555: 48 c7 43 30 00 00 00 movq $0x0,0x30(%rbx) +ffffffff8000355c: 00 + return; +ffffffff8000355d: e9 35 fb ff ff jmp ffffffff80003097 +ffffffff80003562: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + ctx->charsets[ctx->g_select] = CHARSET_DEC_SPECIAL; break; +ffffffff80003568: 0f b6 c0 movzbl %al,%eax +ffffffff8000356b: c6 44 03 29 01 movb $0x1,0x29(%rbx,%rax,1) + ctx->g_select = 0; +ffffffff80003570: c6 43 28 00 movb $0x0,0x28(%rbx) + return; +ffffffff80003574: e9 72 fc ff ff jmp ffffffff800031eb +ffffffff80003579: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + if (ctx->osc_escape && c == '\\') { +ffffffff80003580: 41 80 fc 5c cmp $0x5c,%r12b +ffffffff80003584: 75 06 jne ffffffff8000358c +ffffffff80003586: 80 7b 0e 00 cmpb $0x0,0xe(%rbx) +ffffffff8000358a: 75 0a jne ffffffff80003596 + switch (c) { +ffffffff8000358c: 41 80 fc 1b cmp $0x1b,%r12b +ffffffff80003590: 0f 84 5a 08 00 00 je ffffffff80003df0 + ctx->escape = false; +ffffffff80003596: 45 31 c9 xor %r9d,%r9d + ctx->osc_escape = false; +ffffffff80003599: c6 43 0e 00 movb $0x0,0xe(%rbx) + ctx->escape = false; +ffffffff8000359d: 66 44 89 4b 0c mov %r9w,0xc(%rbx) +ffffffff800035a2: e9 f0 fa ff ff jmp ffffffff80003097 + if (ctx->escape_offset == 2) { +ffffffff800035a7: 48 83 f8 02 cmp $0x2,%rax +ffffffff800035ab: 0f 84 bc 09 00 00 je ffffffff80003f6d + if (c >= '0' && c <= '9') { +ffffffff800035b1: 41 8d 44 24 d0 lea -0x30(%r12),%eax + if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) { +ffffffff800035b6: 48 8b 53 40 mov 0x40(%rbx),%rdx + if (c >= '0' && c <= '9') { +ffffffff800035ba: 3c 09 cmp $0x9,%al +ffffffff800035bc: 0f 87 8a 08 00 00 ja ffffffff80003e4c + if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) { +ffffffff800035c2: 48 83 fa 10 cmp $0x10,%rdx +ffffffff800035c6: 0f 84 cb fa ff ff je ffffffff80003097 + ctx->esc_values[ctx->esc_values_i] += c - '0'; +ffffffff800035cc: 48 83 c2 1c add $0x1c,%rdx +ffffffff800035d0: 45 0f be e4 movsbl %r12b,%r12d + ctx->rrr = true; +ffffffff800035d4: c6 43 0f 01 movb $0x1,0xf(%rbx) + ctx->esc_values[ctx->esc_values_i] *= 10; +ffffffff800035d8: 8b 44 93 08 mov 0x8(%rbx,%rdx,4),%eax +ffffffff800035dc: 8d 04 80 lea (%rax,%rax,4),%eax + ctx->esc_values[ctx->esc_values_i] += c - '0'; +ffffffff800035df: 41 8d 44 44 d0 lea -0x30(%r12,%rax,2),%eax +ffffffff800035e4: 89 44 93 08 mov %eax,0x8(%rbx,%rdx,4) + return; +ffffffff800035e8: e9 aa fa ff ff jmp ffffffff80003097 + ctx->raw_putchar(ctx, c); +ffffffff800035ed: 41 0f be f4 movsbl %r12b,%esi +ffffffff800035f1: 48 89 df mov %rbx,%rdi +ffffffff800035f4: ff d0 call *%rax +ffffffff800035f6: e9 9c fa ff ff jmp ffffffff80003097 + switch (code_point) { +ffffffff800035fb: 49 81 fc a8 21 00 00 cmp $0x21a8,%r12 +ffffffff80003602: 0f 87 b8 fd ff ff ja ffffffff800033c0 +ffffffff80003608: 49 81 fc 8f 21 00 00 cmp $0x218f,%r12 +ffffffff8000360f: 0f 86 8c 09 00 00 jbe ffffffff80003fa1 +ffffffff80003615: 49 8d 84 24 70 de ff lea -0x2190(%r12),%rax +ffffffff8000361c: ff +ffffffff8000361d: 48 83 f8 18 cmp $0x18,%rax +ffffffff80003621: 0f 87 99 fd ff ff ja ffffffff800033c0 +ffffffff80003627: 3e ff 24 c5 50 97 00 notrack jmp *-0x7fff68b0(,%rax,8) +ffffffff8000362e: 80 +ffffffff8000362f: 49 81 fc 02 23 00 00 cmp $0x2302,%r12 +ffffffff80003636: 0f 84 0e 0b 00 00 je ffffffff8000414a +ffffffff8000363c: 0f 87 4a fd ff ff ja ffffffff8000338c +ffffffff80003642: 49 81 fc 64 22 00 00 cmp $0x2264,%r12 +ffffffff80003649: 0f 84 2d 0b 00 00 je ffffffff8000417c +ffffffff8000364f: 49 81 fc 65 22 00 00 cmp $0x2265,%r12 +ffffffff80003656: 0f 84 16 0b 00 00 je ffffffff80004172 + case 0x2261: return 240; +ffffffff8000365c: be f0 00 00 00 mov $0xf0,%esi + switch (code_point) { +ffffffff80003661: 49 81 fc 61 22 00 00 cmp $0x2261,%r12 +ffffffff80003668: 0f 85 52 fd ff ff jne ffffffff800033c0 +ffffffff8000366e: 66 90 xchg %ax,%ax + for (size_t i = 0; i < count; i++) { +ffffffff80003670: 48 83 c5 01 add $0x1,%rbp + ctx->raw_putchar(ctx, cc); +ffffffff80003674: 48 89 df mov %rbx,%rdi +ffffffff80003677: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff8000367d: 49 39 ed cmp %rbp,%r13 +ffffffff80003680: 0f 85 62 f9 ff ff jne ffffffff80002fe8 +ffffffff80003686: e9 19 fa ff ff jmp ffffffff800030a4 + ctx->g_select = c - '\''; +ffffffff8000368b: 41 83 ec 27 sub $0x27,%r12d +ffffffff8000368f: 44 88 63 28 mov %r12b,0x28(%rbx) + break; +ffffffff80003693: e9 c0 fd ff ff jmp ffffffff80003458 + if (y == ctx->scroll_bottom_margin - 1) { +ffffffff80003698: 48 8b 4b 70 mov 0x70(%rbx),%rcx +ffffffff8000369c: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff800036a1: 48 8d 51 ff lea -0x1(%rcx),%rdx +ffffffff800036a5: 48 39 c2 cmp %rax,%rdx +ffffffff800036a8: 0f 84 e9 09 00 00 je ffffffff80004097 + ctx->set_cursor_pos(ctx, x, y + 1); +ffffffff800036ae: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff800036b3: 48 8d 50 01 lea 0x1(%rax),%rdx +ffffffff800036b7: 48 89 df mov %rbx,%rdi +ffffffff800036ba: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff800036c0: e9 93 fd ff ff jmp ffffffff80003458 + ctx->bold = ctx->saved_state_bold; +ffffffff800036c5: 0f b7 83 c0 00 00 00 movzwl 0xc0(%rbx),%eax + ctx->current_primary = ctx->saved_state_current_primary; +ffffffff800036cc: 48 8b 93 d0 00 00 00 mov 0xd0(%rbx),%rdx + ctx->restore_state(ctx); +ffffffff800036d3: 48 89 df mov %rbx,%rdi + ctx->bold = ctx->saved_state_bold; +ffffffff800036d6: 66 89 43 11 mov %ax,0x11(%rbx) + ctx->reverse_video = ctx->saved_state_reverse_video; +ffffffff800036da: 0f b6 83 c2 00 00 00 movzbl 0xc2(%rbx),%eax + ctx->current_primary = ctx->saved_state_current_primary; +ffffffff800036e1: 48 89 53 58 mov %rdx,0x58(%rbx) + ctx->reverse_video = ctx->saved_state_reverse_video; +ffffffff800036e5: 88 43 13 mov %al,0x13(%rbx) + ctx->current_charset = ctx->saved_state_current_charset; +ffffffff800036e8: 48 8b 83 c8 00 00 00 mov 0xc8(%rbx),%rax +ffffffff800036ef: 48 89 43 30 mov %rax,0x30(%rbx) + ctx->current_primary = ctx->saved_state_current_primary; +ffffffff800036f3: 48 8b 83 d8 00 00 00 mov 0xd8(%rbx),%rax +ffffffff800036fa: 48 89 43 60 mov %rax,0x60(%rbx) + ctx->restore_state(ctx); +ffffffff800036fe: ff 93 88 01 00 00 call *0x188(%rbx) +} +ffffffff80003704: e9 4f fd ff ff jmp ffffffff80003458 + ctx->tab_size = 8; +ffffffff80003709: 48 c7 03 08 00 00 00 movq $0x8,(%rbx) + ctx->clear(ctx, true); +ffffffff80003710: be 01 00 00 00 mov $0x1,%esi +ffffffff80003715: 48 89 df mov %rbx,%rdi + ctx->dec_private = false; +ffffffff80003718: 0f b7 05 81 72 00 00 movzwl 0x7281(%rip),%eax # ffffffff8000a9a0 + ctx->autoflush = true; +ffffffff8000371f: 48 c7 43 08 01 01 01 movq $0x10101,0x8(%rbx) +ffffffff80003726: 00 + ctx->dec_private = false; +ffffffff80003727: 66 89 43 14 mov %ax,0x14(%rbx) + ctx->g_select = 0; +ffffffff8000372b: 66 89 43 28 mov %ax,0x28(%rbx) + ctx->scroll_bottom_margin = ctx->rows; +ffffffff8000372f: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax + ctx->discard_next = false; +ffffffff80003736: c7 43 10 00 00 00 00 movl $0x0,0x10(%rbx) + ctx->unicode_remaining = 0; +ffffffff8000373d: 48 c7 43 20 00 00 00 movq $0x0,0x20(%rbx) +ffffffff80003744: 00 + ctx->charsets[1] = CHARSET_DEC_SPECIAL; +ffffffff80003745: c6 43 2a 01 movb $0x1,0x2a(%rbx) + ctx->current_charset = 0; +ffffffff80003749: 48 c7 43 30 00 00 00 movq $0x0,0x30(%rbx) +ffffffff80003750: 00 + ctx->escape_offset = 0; +ffffffff80003751: 48 c7 43 38 00 00 00 movq $0x0,0x38(%rbx) +ffffffff80003758: 00 + ctx->esc_values_i = 0; +ffffffff80003759: 48 c7 43 40 00 00 00 movq $0x0,0x40(%rbx) +ffffffff80003760: 00 + ctx->saved_cursor_x = 0; +ffffffff80003761: 48 c7 43 48 00 00 00 movq $0x0,0x48(%rbx) +ffffffff80003768: 00 + ctx->saved_cursor_y = 0; +ffffffff80003769: 48 c7 43 50 00 00 00 movq $0x0,0x50(%rbx) +ffffffff80003770: 00 + ctx->current_primary = (size_t)-1; +ffffffff80003771: 48 c7 43 58 ff ff ff movq $0xffffffffffffffff,0x58(%rbx) +ffffffff80003778: ff + ctx->current_bg = (size_t)-1; +ffffffff80003779: 48 c7 43 60 ff ff ff movq $0xffffffffffffffff,0x60(%rbx) +ffffffff80003780: ff + ctx->scroll_top_margin = 0; +ffffffff80003781: 48 c7 43 68 00 00 00 movq $0x0,0x68(%rbx) +ffffffff80003788: 00 + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80003789: 48 89 43 70 mov %rax,0x70(%rbx) + ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR; +ffffffff8000378d: 48 c7 83 b8 00 00 00 movq $0x10,0xb8(%rbx) +ffffffff80003794: 10 00 00 00 + ctx->clear(ctx, true); +ffffffff80003798: ff 93 f8 00 00 00 call *0xf8(%rbx) + break; +ffffffff8000379e: e9 b5 fc ff ff jmp ffffffff80003458 + ctx->osc = true; +ffffffff800037a3: b8 01 00 00 00 mov $0x1,%eax +ffffffff800037a8: 66 89 43 0d mov %ax,0xd(%rbx) + return; +ffffffff800037ac: e9 e6 f8 ff ff jmp ffffffff80003097 +ffffffff800037b1: 48 8d 43 78 lea 0x78(%rbx),%rax +ffffffff800037b5: 48 8d 93 b8 00 00 00 lea 0xb8(%rbx),%rdx + ctx->esc_values[i] = 0; +ffffffff800037bc: 48 c7 00 00 00 00 00 movq $0x0,(%rax) +ffffffff800037c3: 48 83 c0 10 add $0x10,%rax +ffffffff800037c7: 48 c7 40 f8 00 00 00 movq $0x0,-0x8(%rax) +ffffffff800037ce: 00 + for (size_t i = 0; i < FLANTERM_MAX_ESC_VALUES; i++) +ffffffff800037cf: 48 39 c2 cmp %rax,%rdx +ffffffff800037d2: 75 e8 jne ffffffff800037bc + ctx->esc_values_i = 0; +ffffffff800037d4: 48 c7 43 40 00 00 00 movq $0x0,0x40(%rbx) +ffffffff800037db: 00 + ctx->rrr = false; +ffffffff800037dc: c6 43 0f 00 movb $0x0,0xf(%rbx) + ctx->control_sequence = true; +ffffffff800037e0: c6 43 0b 01 movb $0x1,0xb(%rbx) + return; +ffffffff800037e4: e9 ae f8 ff ff jmp ffffffff80003097 + if (ctx->callback != NULL) { +ffffffff800037e9: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff800037f0: 48 85 c0 test %rax,%rax +ffffffff800037f3: 0f 84 5f fc ff ff je ffffffff80003458 + ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0); +ffffffff800037f9: 45 31 c0 xor %r8d,%r8d +ffffffff800037fc: 31 c9 xor %ecx,%ecx +ffffffff800037fe: 31 d2 xor %edx,%edx +ffffffff80003800: be 1e 00 00 00 mov $0x1e,%esi +ffffffff80003805: 48 89 df mov %rbx,%rdi +ffffffff80003808: ff d0 call *%rax +ffffffff8000380a: e9 49 fc ff ff jmp ffffffff80003458 + if (y == ctx->scroll_top_margin) { +ffffffff8000380f: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff80003814: 48 39 43 68 cmp %rax,0x68(%rbx) +ffffffff80003818: 0f 84 9a 08 00 00 je ffffffff800040b8 + ctx->set_cursor_pos(ctx, 0, y - 1); +ffffffff8000381e: 48 8d 50 ff lea -0x1(%rax),%rdx +ffffffff80003822: 31 f6 xor %esi,%esi +ffffffff80003824: 48 89 df mov %rbx,%rdi +ffffffff80003827: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff8000382d: e9 26 fc ff ff jmp ffffffff80003458 + if (y == ctx->scroll_bottom_margin - 1) { +ffffffff80003832: 48 8b 4b 70 mov 0x70(%rbx),%rcx +ffffffff80003836: 48 8b 44 24 18 mov 0x18(%rsp),%rax +ffffffff8000383b: 48 8d 51 ff lea -0x1(%rcx),%rdx +ffffffff8000383f: 48 39 c2 cmp %rax,%rdx +ffffffff80003842: 0f 84 28 08 00 00 je ffffffff80004070 + ctx->set_cursor_pos(ctx, 0, y + 1); +ffffffff80003848: 48 8d 50 01 lea 0x1(%rax),%rdx +ffffffff8000384c: 31 f6 xor %esi,%esi +ffffffff8000384e: 48 89 df mov %rbx,%rdi +ffffffff80003851: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff80003857: e9 fc fb ff ff jmp ffffffff80003458 + case 0x00a2: return 155; +ffffffff8000385c: be 9b 00 00 00 mov $0x9b,%esi +ffffffff80003861: e9 0a fe ff ff jmp ffffffff80003670 + case 0x00a1: return 173; +ffffffff80003866: be ad 00 00 00 mov $0xad,%esi +ffffffff8000386b: e9 00 fe ff ff jmp ffffffff80003670 + case 0x00b1: return 241; +ffffffff80003870: be f1 00 00 00 mov $0xf1,%esi +ffffffff80003875: e9 f6 fd ff ff jmp ffffffff80003670 + case 0x00b0: return 248; +ffffffff8000387a: be f8 00 00 00 mov $0xf8,%esi +ffffffff8000387f: e9 ec fd ff ff jmp ffffffff80003670 + case 0x00ac: return 170; +ffffffff80003884: be aa 00 00 00 mov $0xaa,%esi +ffffffff80003889: e9 e2 fd ff ff jmp ffffffff80003670 + case 0x00ab: return 174; +ffffffff8000388e: be ae 00 00 00 mov $0xae,%esi +ffffffff80003893: e9 d8 fd ff ff jmp ffffffff80003670 + case 0x00aa: return 166; +ffffffff80003898: be a6 00 00 00 mov $0xa6,%esi +ffffffff8000389d: e9 ce fd ff ff jmp ffffffff80003670 + case 0x00a5: return 157; +ffffffff800038a2: be 9d 00 00 00 mov $0x9d,%esi +ffffffff800038a7: e9 c4 fd ff ff jmp ffffffff80003670 + case 0x00a3: return 156; +ffffffff800038ac: be 9c 00 00 00 mov $0x9c,%esi +ffffffff800038b1: e9 ba fd ff ff jmp ffffffff80003670 + case 0x2663: return 5; +ffffffff800038b6: be 05 00 00 00 mov $0x5,%esi +ffffffff800038bb: e9 b0 fd ff ff jmp ffffffff80003670 + case 0x2660: return 6; +ffffffff800038c0: be 06 00 00 00 mov $0x6,%esi +ffffffff800038c5: e9 a6 fd ff ff jmp ffffffff80003670 + case 0x2642: return 11; +ffffffff800038ca: be 0b 00 00 00 mov $0xb,%esi +ffffffff800038cf: e9 9c fd ff ff jmp ffffffff80003670 + case 0x2640: return 12; +ffffffff800038d4: be 0c 00 00 00 mov $0xc,%esi +ffffffff800038d9: e9 92 fd ff ff jmp ffffffff80003670 + case 0x263c: return 15; +ffffffff800038de: be 0f 00 00 00 mov $0xf,%esi +ffffffff800038e3: e9 88 fd ff ff jmp ffffffff80003670 + case 0x263b: return 2; +ffffffff800038e8: be 02 00 00 00 mov $0x2,%esi +ffffffff800038ed: e9 7e fd ff ff jmp ffffffff80003670 + case 0x25d9: return 10; +ffffffff800038f2: be 0a 00 00 00 mov $0xa,%esi +ffffffff800038f7: e9 74 fd ff ff jmp ffffffff80003670 + case 0x266b: return 14; +ffffffff800038fc: be 0e 00 00 00 mov $0xe,%esi +ffffffff80003901: e9 6a fd ff ff jmp ffffffff80003670 + case 0x266a: return 13; +ffffffff80003906: be 0d 00 00 00 mov $0xd,%esi +ffffffff8000390b: e9 60 fd ff ff jmp ffffffff80003670 + case 0x2524: return 180; +ffffffff80003910: be b4 00 00 00 mov $0xb4,%esi +ffffffff80003915: e9 56 fd ff ff jmp ffffffff80003670 + case 0x251c: return 195; +ffffffff8000391a: be c3 00 00 00 mov $0xc3,%esi +ffffffff8000391f: e9 4c fd ff ff jmp ffffffff80003670 + case 0x2518: return 217; +ffffffff80003924: be d9 00 00 00 mov $0xd9,%esi +ffffffff80003929: e9 42 fd ff ff jmp ffffffff80003670 + case 0x2514: return 192; +ffffffff8000392e: be c0 00 00 00 mov $0xc0,%esi +ffffffff80003933: e9 38 fd ff ff jmp ffffffff80003670 + case 0x2510: return 191; +ffffffff80003938: be bf 00 00 00 mov $0xbf,%esi +ffffffff8000393d: e9 2e fd ff ff jmp ffffffff80003670 + case 0x250c: return 218; +ffffffff80003942: be da 00 00 00 mov $0xda,%esi +ffffffff80003947: e9 24 fd ff ff jmp ffffffff80003670 + case 0x2502: return 179; +ffffffff8000394c: be b3 00 00 00 mov $0xb3,%esi +ffffffff80003951: e9 1a fd ff ff jmp ffffffff80003670 + case 0x2500: return 196; +ffffffff80003956: be c4 00 00 00 mov $0xc4,%esi +ffffffff8000395b: e9 10 fd ff ff jmp ffffffff80003670 + case 0x0192: return 159; +ffffffff80003960: be 9f 00 00 00 mov $0x9f,%esi +ffffffff80003965: e9 06 fd ff ff jmp ffffffff80003670 + case 0x00ff: return 152; +ffffffff8000396a: be 98 00 00 00 mov $0x98,%esi +ffffffff8000396f: e9 fc fc ff ff jmp ffffffff80003670 + case 0x00fc: return 129; +ffffffff80003974: be 81 00 00 00 mov $0x81,%esi +ffffffff80003979: e9 f2 fc ff ff jmp ffffffff80003670 + case 0x00fb: return 150; +ffffffff8000397e: be 96 00 00 00 mov $0x96,%esi +ffffffff80003983: e9 e8 fc ff ff jmp ffffffff80003670 + case 0x00fa: return 163; +ffffffff80003988: be a3 00 00 00 mov $0xa3,%esi +ffffffff8000398d: e9 de fc ff ff jmp ffffffff80003670 + case 0x00f9: return 151; +ffffffff80003992: be 97 00 00 00 mov $0x97,%esi +ffffffff80003997: e9 d4 fc ff ff jmp ffffffff80003670 + case 0x00f7: return 246; +ffffffff8000399c: be f6 00 00 00 mov $0xf6,%esi +ffffffff800039a1: e9 ca fc ff ff jmp ffffffff80003670 + case 0x00f6: return 148; +ffffffff800039a6: be 94 00 00 00 mov $0x94,%esi +ffffffff800039ab: e9 c0 fc ff ff jmp ffffffff80003670 + case 0x00f4: return 147; +ffffffff800039b0: be 93 00 00 00 mov $0x93,%esi +ffffffff800039b5: e9 b6 fc ff ff jmp ffffffff80003670 + case 0x00f3: return 162; +ffffffff800039ba: be a2 00 00 00 mov $0xa2,%esi +ffffffff800039bf: e9 ac fc ff ff jmp ffffffff80003670 + case 0x00f2: return 149; +ffffffff800039c4: be 95 00 00 00 mov $0x95,%esi +ffffffff800039c9: e9 a2 fc ff ff jmp ffffffff80003670 + case 0x00f1: return 164; +ffffffff800039ce: be a4 00 00 00 mov $0xa4,%esi +ffffffff800039d3: e9 98 fc ff ff jmp ffffffff80003670 + case 0x00ef: return 139; +ffffffff800039d8: be 8b 00 00 00 mov $0x8b,%esi +ffffffff800039dd: e9 8e fc ff ff jmp ffffffff80003670 + case 0x2194: return 29; +ffffffff800039e2: be 1d 00 00 00 mov $0x1d,%esi +ffffffff800039e7: e9 84 fc ff ff jmp ffffffff80003670 + case 0x2193: return 25; +ffffffff800039ec: be 19 00 00 00 mov $0x19,%esi +ffffffff800039f1: e9 7a fc ff ff jmp ffffffff80003670 + case 0x2192: return 26; +ffffffff800039f6: be 1a 00 00 00 mov $0x1a,%esi +ffffffff800039fb: e9 70 fc ff ff jmp ffffffff80003670 + case 0x2191: return 24; +ffffffff80003a00: be 18 00 00 00 mov $0x18,%esi +ffffffff80003a05: e9 66 fc ff ff jmp ffffffff80003670 + case 0x2190: return 27; +ffffffff80003a0a: be 1b 00 00 00 mov $0x1b,%esi +ffffffff80003a0f: e9 5c fc ff ff jmp ffffffff80003670 + case 0x00ee: return 140; +ffffffff80003a14: be 8c 00 00 00 mov $0x8c,%esi +ffffffff80003a19: e9 52 fc ff ff jmp ffffffff80003670 + case 0x00ed: return 161; +ffffffff80003a1e: be a1 00 00 00 mov $0xa1,%esi +ffffffff80003a23: e9 48 fc ff ff jmp ffffffff80003670 + case 0x00ec: return 141; +ffffffff80003a28: be 8d 00 00 00 mov $0x8d,%esi +ffffffff80003a2d: e9 3e fc ff ff jmp ffffffff80003670 + case 0x00eb: return 137; +ffffffff80003a32: be 89 00 00 00 mov $0x89,%esi +ffffffff80003a37: e9 34 fc ff ff jmp ffffffff80003670 + case 0x00ea: return 136; +ffffffff80003a3c: be 88 00 00 00 mov $0x88,%esi +ffffffff80003a41: e9 2a fc ff ff jmp ffffffff80003670 + case 0x00e9: return 130; +ffffffff80003a46: be 82 00 00 00 mov $0x82,%esi +ffffffff80003a4b: e9 20 fc ff ff jmp ffffffff80003670 + case 0x00e8: return 138; +ffffffff80003a50: be 8a 00 00 00 mov $0x8a,%esi +ffffffff80003a55: e9 16 fc ff ff jmp ffffffff80003670 + case 0x00e7: return 135; +ffffffff80003a5a: be 87 00 00 00 mov $0x87,%esi +ffffffff80003a5f: e9 0c fc ff ff jmp ffffffff80003670 + case 0x00e6: return 145; +ffffffff80003a64: be 91 00 00 00 mov $0x91,%esi +ffffffff80003a69: e9 02 fc ff ff jmp ffffffff80003670 + case 0x00e5: return 134; +ffffffff80003a6e: be 86 00 00 00 mov $0x86,%esi +ffffffff80003a73: e9 f8 fb ff ff jmp ffffffff80003670 + case 0x00e4: return 132; +ffffffff80003a78: be 84 00 00 00 mov $0x84,%esi +ffffffff80003a7d: e9 ee fb ff ff jmp ffffffff80003670 + case 0x00e2: return 131; +ffffffff80003a82: be 83 00 00 00 mov $0x83,%esi +ffffffff80003a87: e9 e4 fb ff ff jmp ffffffff80003670 + case 0x00e1: return 160; +ffffffff80003a8c: be a0 00 00 00 mov $0xa0,%esi +ffffffff80003a91: e9 da fb ff ff jmp ffffffff80003670 + case 0x00e0: return 133; +ffffffff80003a96: be 85 00 00 00 mov $0x85,%esi +ffffffff80003a9b: e9 d0 fb ff ff jmp ffffffff80003670 + case 0x00df: return 225; +ffffffff80003aa0: be e1 00 00 00 mov $0xe1,%esi +ffffffff80003aa5: e9 c6 fb ff ff jmp ffffffff80003670 + case 0x00dc: return 154; +ffffffff80003aaa: be 9a 00 00 00 mov $0x9a,%esi +ffffffff80003aaf: e9 bc fb ff ff jmp ffffffff80003670 + case 0x00d6: return 153; +ffffffff80003ab4: be 99 00 00 00 mov $0x99,%esi +ffffffff80003ab9: e9 b2 fb ff ff jmp ffffffff80003670 + case 0x00d1: return 165; +ffffffff80003abe: be a5 00 00 00 mov $0xa5,%esi +ffffffff80003ac3: e9 a8 fb ff ff jmp ffffffff80003670 + case 0x00c9: return 144; +ffffffff80003ac8: be 90 00 00 00 mov $0x90,%esi +ffffffff80003acd: e9 9e fb ff ff jmp ffffffff80003670 + case 0x00c7: return 128; +ffffffff80003ad2: be 80 00 00 00 mov $0x80,%esi +ffffffff80003ad7: e9 94 fb ff ff jmp ffffffff80003670 + case 0x00c6: return 146; +ffffffff80003adc: be 92 00 00 00 mov $0x92,%esi +ffffffff80003ae1: e9 8a fb ff ff jmp ffffffff80003670 + case 0x00c5: return 143; +ffffffff80003ae6: be 8f 00 00 00 mov $0x8f,%esi +ffffffff80003aeb: e9 80 fb ff ff jmp ffffffff80003670 + case 0x00c4: return 142; +ffffffff80003af0: be 8e 00 00 00 mov $0x8e,%esi +ffffffff80003af5: e9 76 fb ff ff jmp ffffffff80003670 + case 0x00bf: return 168; +ffffffff80003afa: be a8 00 00 00 mov $0xa8,%esi +ffffffff80003aff: e9 6c fb ff ff jmp ffffffff80003670 + case 0x00bd: return 171; +ffffffff80003b04: be ab 00 00 00 mov $0xab,%esi +ffffffff80003b09: e9 62 fb ff ff jmp ffffffff80003670 + case 0x00bc: return 172; +ffffffff80003b0e: be ac 00 00 00 mov $0xac,%esi +ffffffff80003b13: e9 58 fb ff ff jmp ffffffff80003670 + case 0x00bb: return 175; +ffffffff80003b18: be af 00 00 00 mov $0xaf,%esi +ffffffff80003b1d: e9 4e fb ff ff jmp ffffffff80003670 + case 0x00ba: return 167; +ffffffff80003b22: be a7 00 00 00 mov $0xa7,%esi +ffffffff80003b27: e9 44 fb ff ff jmp ffffffff80003670 + case 0x00b7: return 250; +ffffffff80003b2c: be fa 00 00 00 mov $0xfa,%esi +ffffffff80003b31: e9 3a fb ff ff jmp ffffffff80003670 + case 0x00b5: return 230; +ffffffff80003b36: be e6 00 00 00 mov $0xe6,%esi +ffffffff80003b3b: e9 30 fb ff ff jmp ffffffff80003670 + case 0x00b2: return 253; +ffffffff80003b40: be fd 00 00 00 mov $0xfd,%esi +ffffffff80003b45: e9 26 fb ff ff jmp ffffffff80003670 + case 0x03c6: return 237; +ffffffff80003b4a: be ed 00 00 00 mov $0xed,%esi +ffffffff80003b4f: e9 1c fb ff ff jmp ffffffff80003670 + case 0x03c4: return 231; +ffffffff80003b54: be e7 00 00 00 mov $0xe7,%esi +ffffffff80003b59: e9 12 fb ff ff jmp ffffffff80003670 + case 0x03c3: return 229; +ffffffff80003b5e: be e5 00 00 00 mov $0xe5,%esi +ffffffff80003b63: e9 08 fb ff ff jmp ffffffff80003670 + case 0x03c0: return 227; +ffffffff80003b68: be e3 00 00 00 mov $0xe3,%esi +ffffffff80003b6d: e9 fe fa ff ff jmp ffffffff80003670 + case 0x03b5: return 238; +ffffffff80003b72: be ee 00 00 00 mov $0xee,%esi +ffffffff80003b77: e9 f4 fa ff ff jmp ffffffff80003670 + case 0x03b4: return 235; +ffffffff80003b7c: be eb 00 00 00 mov $0xeb,%esi +ffffffff80003b81: e9 ea fa ff ff jmp ffffffff80003670 + case 0x03a9: return 234; +ffffffff80003b86: be ea 00 00 00 mov $0xea,%esi +ffffffff80003b8b: e9 e0 fa ff ff jmp ffffffff80003670 + case 0x03a6: return 232; +ffffffff80003b90: be e8 00 00 00 mov $0xe8,%esi +ffffffff80003b95: e9 d6 fa ff ff jmp ffffffff80003670 + case 0x03a3: return 228; +ffffffff80003b9a: be e4 00 00 00 mov $0xe4,%esi +ffffffff80003b9f: e9 cc fa ff ff jmp ffffffff80003670 + case 0x0398: return 233; +ffffffff80003ba4: be e9 00 00 00 mov $0xe9,%esi +ffffffff80003ba9: e9 c2 fa ff ff jmp ffffffff80003670 + case 0x255c: return 189; +ffffffff80003bae: be bd 00 00 00 mov $0xbd,%esi +ffffffff80003bb3: e9 b8 fa ff ff jmp ffffffff80003670 + case 0x255b: return 190; +ffffffff80003bb8: be be 00 00 00 mov $0xbe,%esi +ffffffff80003bbd: e9 ae fa ff ff jmp ffffffff80003670 + case 0x255a: return 200; +ffffffff80003bc2: be c8 00 00 00 mov $0xc8,%esi +ffffffff80003bc7: e9 a4 fa ff ff jmp ffffffff80003670 + case 0x2559: return 211; +ffffffff80003bcc: be d3 00 00 00 mov $0xd3,%esi +ffffffff80003bd1: e9 9a fa ff ff jmp ffffffff80003670 + case 0x2558: return 212; +ffffffff80003bd6: be d4 00 00 00 mov $0xd4,%esi +ffffffff80003bdb: e9 90 fa ff ff jmp ffffffff80003670 + case 0x2557: return 187; +ffffffff80003be0: be bb 00 00 00 mov $0xbb,%esi +ffffffff80003be5: e9 86 fa ff ff jmp ffffffff80003670 + case 0x2556: return 183; +ffffffff80003bea: be b7 00 00 00 mov $0xb7,%esi +ffffffff80003bef: e9 7c fa ff ff jmp ffffffff80003670 + case 0x2555: return 184; +ffffffff80003bf4: be b8 00 00 00 mov $0xb8,%esi +ffffffff80003bf9: e9 72 fa ff ff jmp ffffffff80003670 + case 0x2554: return 201; +ffffffff80003bfe: be c9 00 00 00 mov $0xc9,%esi +ffffffff80003c03: e9 68 fa ff ff jmp ffffffff80003670 + case 0x2553: return 214; +ffffffff80003c08: be d6 00 00 00 mov $0xd6,%esi +ffffffff80003c0d: e9 5e fa ff ff jmp ffffffff80003670 + case 0x2552: return 213; +ffffffff80003c12: be d5 00 00 00 mov $0xd5,%esi +ffffffff80003c17: e9 54 fa ff ff jmp ffffffff80003670 + case 0x2551: return 186; +ffffffff80003c1c: be ba 00 00 00 mov $0xba,%esi +ffffffff80003c21: e9 4a fa ff ff jmp ffffffff80003670 + case 0x2550: return 205; +ffffffff80003c26: be cd 00 00 00 mov $0xcd,%esi +ffffffff80003c2b: e9 40 fa ff ff jmp ffffffff80003670 + case 0x253c: return 197; +ffffffff80003c30: be c5 00 00 00 mov $0xc5,%esi +ffffffff80003c35: e9 36 fa ff ff jmp ffffffff80003670 + case 0x2534: return 193; +ffffffff80003c3a: be c1 00 00 00 mov $0xc1,%esi +ffffffff80003c3f: e9 2c fa ff ff jmp ffffffff80003670 + case 0x252c: return 194; +ffffffff80003c44: be c2 00 00 00 mov $0xc2,%esi +ffffffff80003c49: e9 22 fa ff ff jmp ffffffff80003670 + case 0x25d8: return 8; +ffffffff80003c4e: be 08 00 00 00 mov $0x8,%esi +ffffffff80003c53: e9 18 fa ff ff jmp ffffffff80003670 + case 0x25cb: return 9; +ffffffff80003c58: be 09 00 00 00 mov $0x9,%esi +ffffffff80003c5d: e9 0e fa ff ff jmp ffffffff80003670 + case 0x25c4: return 17; +ffffffff80003c62: be 11 00 00 00 mov $0x11,%esi +ffffffff80003c67: e9 04 fa ff ff jmp ffffffff80003670 + case 0x25bc: return 31; +ffffffff80003c6c: be 1f 00 00 00 mov $0x1f,%esi +ffffffff80003c71: e9 fa f9 ff ff jmp ffffffff80003670 + case 0x25ba: return 16; +ffffffff80003c76: be 10 00 00 00 mov $0x10,%esi +ffffffff80003c7b: e9 f0 f9 ff ff jmp ffffffff80003670 + case 0x25b2: return 30; +ffffffff80003c80: be 1e 00 00 00 mov $0x1e,%esi +ffffffff80003c85: e9 e6 f9 ff ff jmp ffffffff80003670 + case 0x25ac: return 22; +ffffffff80003c8a: be 16 00 00 00 mov $0x16,%esi +ffffffff80003c8f: e9 dc f9 ff ff jmp ffffffff80003670 + case 0x25a0: return 254; +ffffffff80003c94: be fe 00 00 00 mov $0xfe,%esi +ffffffff80003c99: e9 d2 f9 ff ff jmp ffffffff80003670 + case 0x2593: return 178; +ffffffff80003c9e: be b2 00 00 00 mov $0xb2,%esi +ffffffff80003ca3: e9 c8 f9 ff ff jmp ffffffff80003670 + case 0x2592: return 177; +ffffffff80003ca8: be b1 00 00 00 mov $0xb1,%esi +ffffffff80003cad: e9 be f9 ff ff jmp ffffffff80003670 + case 0x2591: return 176; +ffffffff80003cb2: be b0 00 00 00 mov $0xb0,%esi +ffffffff80003cb7: e9 b4 f9 ff ff jmp ffffffff80003670 + case 0x2590: return 222; +ffffffff80003cbc: be de 00 00 00 mov $0xde,%esi +ffffffff80003cc1: e9 aa f9 ff ff jmp ffffffff80003670 + case 0x258c: return 221; +ffffffff80003cc6: be dd 00 00 00 mov $0xdd,%esi +ffffffff80003ccb: e9 a0 f9 ff ff jmp ffffffff80003670 + case 0x2588: return 219; +ffffffff80003cd0: be db 00 00 00 mov $0xdb,%esi +ffffffff80003cd5: e9 96 f9 ff ff jmp ffffffff80003670 + case 0x2584: return 220; +ffffffff80003cda: be dc 00 00 00 mov $0xdc,%esi +ffffffff80003cdf: e9 8c f9 ff ff jmp ffffffff80003670 + case 0x2580: return 223; +ffffffff80003ce4: be df 00 00 00 mov $0xdf,%esi +ffffffff80003ce9: e9 82 f9 ff ff jmp ffffffff80003670 + case 0x256c: return 206; +ffffffff80003cee: be ce 00 00 00 mov $0xce,%esi +ffffffff80003cf3: e9 78 f9 ff ff jmp ffffffff80003670 + case 0x256b: return 215; +ffffffff80003cf8: be d7 00 00 00 mov $0xd7,%esi +ffffffff80003cfd: e9 6e f9 ff ff jmp ffffffff80003670 + case 0x256a: return 216; +ffffffff80003d02: be d8 00 00 00 mov $0xd8,%esi +ffffffff80003d07: e9 64 f9 ff ff jmp ffffffff80003670 + case 0x2569: return 202; +ffffffff80003d0c: be ca 00 00 00 mov $0xca,%esi +ffffffff80003d11: e9 5a f9 ff ff jmp ffffffff80003670 + case 0x2568: return 208; +ffffffff80003d16: be d0 00 00 00 mov $0xd0,%esi +ffffffff80003d1b: e9 50 f9 ff ff jmp ffffffff80003670 + case 0x2567: return 207; +ffffffff80003d20: be cf 00 00 00 mov $0xcf,%esi +ffffffff80003d25: e9 46 f9 ff ff jmp ffffffff80003670 + case 0x2566: return 203; +ffffffff80003d2a: be cb 00 00 00 mov $0xcb,%esi +ffffffff80003d2f: e9 3c f9 ff ff jmp ffffffff80003670 + case 0x2565: return 210; +ffffffff80003d34: be d2 00 00 00 mov $0xd2,%esi +ffffffff80003d39: e9 32 f9 ff ff jmp ffffffff80003670 + case 0x2564: return 209; +ffffffff80003d3e: be d1 00 00 00 mov $0xd1,%esi +ffffffff80003d43: e9 28 f9 ff ff jmp ffffffff80003670 + case 0x2563: return 185; +ffffffff80003d48: be b9 00 00 00 mov $0xb9,%esi +ffffffff80003d4d: e9 1e f9 ff ff jmp ffffffff80003670 + case 0x2562: return 182; +ffffffff80003d52: be b6 00 00 00 mov $0xb6,%esi +ffffffff80003d57: e9 14 f9 ff ff jmp ffffffff80003670 + case 0x2561: return 181; +ffffffff80003d5c: be b5 00 00 00 mov $0xb5,%esi +ffffffff80003d61: e9 0a f9 ff ff jmp ffffffff80003670 + case 0x2560: return 204; +ffffffff80003d66: be cc 00 00 00 mov $0xcc,%esi +ffffffff80003d6b: e9 00 f9 ff ff jmp ffffffff80003670 + case 0x255f: return 199; +ffffffff80003d70: be c7 00 00 00 mov $0xc7,%esi +ffffffff80003d75: e9 f6 f8 ff ff jmp ffffffff80003670 + case 0x255e: return 198; +ffffffff80003d7a: be c6 00 00 00 mov $0xc6,%esi +ffffffff80003d7f: e9 ec f8 ff ff jmp ffffffff80003670 + case 0x255d: return 188; +ffffffff80003d84: be bc 00 00 00 mov $0xbc,%esi +ffffffff80003d89: e9 e2 f8 ff ff jmp ffffffff80003670 + case 0x03b1: return 224; +ffffffff80003d8e: be e0 00 00 00 mov $0xe0,%esi +ffffffff80003d93: e9 d8 f8 ff ff jmp ffffffff80003670 + case 0x0393: return 226; +ffffffff80003d98: be e2 00 00 00 mov $0xe2,%esi +ffffffff80003d9d: e9 ce f8 ff ff jmp ffffffff80003670 + case 0x00b6: return 20; +ffffffff80003da2: be 14 00 00 00 mov $0x14,%esi +ffffffff80003da7: e9 c4 f8 ff ff jmp ffffffff80003670 + switch (code_point) { +ffffffff80003dac: be 01 00 00 00 mov $0x1,%esi +ffffffff80003db1: e9 ba f8 ff ff jmp ffffffff80003670 + case 0x2666: return 4; +ffffffff80003db6: be 04 00 00 00 mov $0x4,%esi +ffffffff80003dbb: e9 b0 f8 ff ff jmp ffffffff80003670 + switch (code_point) { +ffffffff80003dc0: be 03 00 00 00 mov $0x3,%esi +ffffffff80003dc5: e9 a6 f8 ff ff jmp ffffffff80003670 + case 0x21a8: return 23; +ffffffff80003dca: be 17 00 00 00 mov $0x17,%esi +ffffffff80003dcf: e9 9c f8 ff ff jmp ffffffff80003670 + case 0x2195: return 18; +ffffffff80003dd4: be 12 00 00 00 mov $0x12,%esi +ffffffff80003dd9: e9 92 f8 ff ff jmp ffffffff80003670 + case 0x00a7: return 21; +ffffffff80003dde: be 15 00 00 00 mov $0x15,%esi +ffffffff80003de3: e9 88 f8 ff ff jmp ffffffff80003670 +ffffffff80003de8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80003def: 00 + ctx->osc_escape = true; +ffffffff80003df0: c6 43 0e 01 movb $0x1,0xe(%rbx) + return; +ffffffff80003df4: e9 9e f2 ff ff jmp ffffffff80003097 + ctx->scroll(ctx); +ffffffff80003df9: 48 89 df mov %rbx,%rdi +ffffffff80003dfc: ff 93 68 01 00 00 call *0x168(%rbx) + ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y); +ffffffff80003e02: 48 8b 83 00 01 00 00 mov 0x100(%rbx),%rax +ffffffff80003e09: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff80003e0e: 31 f6 xor %esi,%esi +ffffffff80003e10: f6 83 b8 00 00 00 10 testb $0x10,0xb8(%rbx) +ffffffff80003e17: 0f 85 65 f5 ff ff jne ffffffff80003382 +ffffffff80003e1d: e9 5b f5 ff ff jmp ffffffff8000337d + ctx->set_cursor_pos(ctx, ctx->cols - 1, y); +ffffffff80003e22: 48 8d 72 ff lea -0x1(%rdx),%rsi +ffffffff80003e26: 48 89 fa mov %rdi,%rdx +ffffffff80003e29: 48 89 df mov %rbx,%rdi +ffffffff80003e2c: ff d1 call *%rcx + return; +ffffffff80003e2e: e9 64 f2 ff ff jmp ffffffff80003097 + switch (c) { +ffffffff80003e33: 41 8d 54 24 d5 lea -0x2b(%r12),%edx +ffffffff80003e38: 80 fa 53 cmp $0x53,%dl +ffffffff80003e3b: 0f 87 e0 f4 ff ff ja ffffffff80003321 +ffffffff80003e41: 0f b6 d2 movzbl %dl,%edx +ffffffff80003e44: 3e ff 24 d5 18 98 00 notrack jmp *-0x7fff67e8(,%rdx,8) +ffffffff80003e4b: 80 + if (ctx->rrr == true) { +ffffffff80003e4c: 80 7b 0f 00 cmpb $0x0,0xf(%rbx) +ffffffff80003e50: 0f 84 8a 01 00 00 je ffffffff80003fe0 + ctx->esc_values_i++; +ffffffff80003e56: 48 83 c2 01 add $0x1,%rdx + ctx->rrr = false; +ffffffff80003e5a: c6 43 0f 00 movb $0x0,0xf(%rbx) + ctx->esc_values_i++; +ffffffff80003e5e: 48 89 53 40 mov %rdx,0x40(%rbx) + if (c == ';') +ffffffff80003e62: 41 80 fc 3b cmp $0x3b,%r12b +ffffffff80003e66: 0f 84 2b f2 ff ff je ffffffff80003097 + if (ctx->dec_private == true) { +ffffffff80003e6c: 0f b6 73 14 movzbl 0x14(%rbx),%esi + switch (c) { +ffffffff80003e70: 41 80 fc 4b cmp $0x4b,%r12b +ffffffff80003e74: 0f 8f 8f 01 00 00 jg ffffffff80004009 +ffffffff80003e7a: 41 80 fc 49 cmp $0x49,%r12b +ffffffff80003e7e: 0f 8f 67 02 00 00 jg ffffffff800040eb + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80003e84: 41 b8 01 00 00 00 mov $0x1,%r8d +ffffffff80003e8a: 48 83 fa 0f cmp $0xf,%rdx +ffffffff80003e8e: 0f 87 d2 09 00 00 ja ffffffff80004866 +ffffffff80003e94: 48 8d bb b8 00 00 00 lea 0xb8(%rbx),%rdi +ffffffff80003e9b: 48 8d 44 93 78 lea 0x78(%rbx,%rdx,4),%rax + ctx->esc_values[i] = esc_default; +ffffffff80003ea0: 44 89 c1 mov %r8d,%ecx +ffffffff80003ea3: 49 89 f9 mov %rdi,%r9 +ffffffff80003ea6: 49 29 c1 sub %rax,%r9 +ffffffff80003ea9: 41 83 e1 04 and $0x4,%r9d +ffffffff80003ead: 74 0c je ffffffff80003ebb +ffffffff80003eaf: 44 89 00 mov %r8d,(%rax) + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80003eb2: 48 83 c0 04 add $0x4,%rax +ffffffff80003eb6: 48 39 c7 cmp %rax,%rdi +ffffffff80003eb9: 74 0e je ffffffff80003ec9 + ctx->esc_values[i] = esc_default; +ffffffff80003ebb: 89 08 mov %ecx,(%rax) + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80003ebd: 48 83 c0 08 add $0x8,%rax + ctx->esc_values[i] = esc_default; +ffffffff80003ec1: 89 48 fc mov %ecx,-0x4(%rax) + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80003ec4: 48 39 c7 cmp %rax,%rdi +ffffffff80003ec7: 75 f2 jne ffffffff80003ebb + if (ctx->dec_private == true) { +ffffffff80003ec9: 40 84 f6 test %sil,%sil +ffffffff80003ecc: 0f 85 e8 02 00 00 jne ffffffff800041ba + bool r = ctx->scroll_enabled; +ffffffff80003ed2: 44 0f b6 73 0a movzbl 0xa(%rbx),%r14d + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80003ed7: 48 8d 54 24 18 lea 0x18(%rsp),%rdx + ctx->scroll_enabled = false; +ffffffff80003edc: c6 43 0a 00 movb $0x0,0xa(%rbx) + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80003ee0: 48 89 df mov %rbx,%rdi +ffffffff80003ee3: 48 8d 74 24 10 lea 0x10(%rsp),%rsi +ffffffff80003ee8: ff 93 08 01 00 00 call *0x108(%rbx) + switch (c) { +ffffffff80003eee: 41 8d 44 24 c0 lea -0x40(%r12),%eax +ffffffff80003ef3: 3c 35 cmp $0x35,%al +ffffffff80003ef5: 77 67 ja ffffffff80003f5e +ffffffff80003ef7: 0f b6 c0 movzbl %al,%eax +ffffffff80003efa: 3e ff 24 c5 b8 9a 00 notrack jmp *-0x7fff6548(,%rax,8) +ffffffff80003f01: 80 + x = 0; +ffffffff80003f02: 31 ff xor %edi,%edi +ffffffff80003f04: 48 89 7c 24 10 mov %rdi,0x10(%rsp) + if (y + ctx->esc_values[0] > ctx->rows - 1) +ffffffff80003f09: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx +ffffffff80003f0e: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff80003f15: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80003f18: 48 8d 78 ff lea -0x1(%rax),%rdi +ffffffff80003f1c: 48 8d 34 0a lea (%rdx,%rcx,1),%rsi +ffffffff80003f20: 48 39 f7 cmp %rsi,%rdi +ffffffff80003f23: 73 08 jae ffffffff80003f2d + ctx->esc_values[0] = (ctx->rows - 1) - y; +ffffffff80003f25: 29 c8 sub %ecx,%eax +ffffffff80003f27: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80003f2a: 89 53 78 mov %edx,0x78(%rbx) + if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y) +ffffffff80003f2d: 48 8b 73 68 mov 0x68(%rbx),%rsi + || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) { +ffffffff80003f31: 48 8b 43 70 mov 0x70(%rbx),%rax + size_t dest_y = y + ctx->esc_values[0]; +ffffffff80003f35: 48 01 ca add %rcx,%rdx + if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y) +ffffffff80003f38: 48 39 ce cmp %rcx,%rsi +ffffffff80003f3b: 72 05 jb ffffffff80003f42 +ffffffff80003f3d: 48 39 f2 cmp %rsi,%rdx +ffffffff80003f40: 73 05 jae ffffffff80003f47 + || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) { +ffffffff80003f42: 48 39 c8 cmp %rcx,%rax +ffffffff80003f45: 72 09 jb ffffffff80003f50 + if (will_be_in_scroll_region && dest_y >= ctx->scroll_bottom_margin) { +ffffffff80003f47: 48 39 c2 cmp %rax,%rdx +ffffffff80003f4a: 0f 83 dc 07 00 00 jae ffffffff8000472c + ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]); +ffffffff80003f50: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff80003f55: 48 89 df mov %rbx,%rdi +ffffffff80003f58: ff 93 00 01 00 00 call *0x100(%rbx) + ctx->scroll_enabled = r; +ffffffff80003f5e: 44 88 73 0a mov %r14b,0xa(%rbx) + ctx->control_sequence = false; +ffffffff80003f62: 31 d2 xor %edx,%edx +ffffffff80003f64: 66 89 53 0b mov %dx,0xb(%rbx) +ffffffff80003f68: e9 2a f1 ff ff jmp ffffffff80003097 + switch (c) { +ffffffff80003f6d: 41 80 fc 3f cmp $0x3f,%r12b +ffffffff80003f71: 0f 84 17 01 00 00 je ffffffff8000408e +ffffffff80003f77: 41 80 fc 5b cmp $0x5b,%r12b +ffffffff80003f7b: 0f 85 30 f6 ff ff jne ffffffff800035b1 + ctx->discard_next = true; +ffffffff80003f81: c6 43 10 01 movb $0x1,0x10(%rbx) + goto cleanup; +ffffffff80003f85: eb db jmp ffffffff80003f62 + switch (code_point) { +ffffffff80003f87: 49 8d 84 24 e7 dd ff lea -0x2219(%r12),%rax +ffffffff80003f8e: ff +ffffffff80003f8f: 48 83 f8 2f cmp $0x2f,%rax +ffffffff80003f93: 0f 87 27 f4 ff ff ja ffffffff800033c0 +ffffffff80003f99: 3e ff 24 c5 68 9c 00 notrack jmp *-0x7fff6398(,%rax,8) +ffffffff80003fa0: 80 +ffffffff80003fa1: 49 81 fc 7f 20 00 00 cmp $0x207f,%r12 +ffffffff80003fa8: 0f 84 02 02 00 00 je ffffffff800041b0 +ffffffff80003fae: 0f 87 dc 01 00 00 ja ffffffff80004190 +ffffffff80003fb4: 49 81 fc 22 20 00 00 cmp $0x2022,%r12 +ffffffff80003fbb: 0f 84 c5 01 00 00 je ffffffff80004186 + case 0x203c: return 19; +ffffffff80003fc1: be 13 00 00 00 mov $0x13,%esi + switch (code_point) { +ffffffff80003fc6: 49 81 fc 3c 20 00 00 cmp $0x203c,%r12 +ffffffff80003fcd: 0f 84 9d f6 ff ff je ffffffff80003670 +ffffffff80003fd3: e9 e8 f3 ff ff jmp ffffffff800033c0 +ffffffff80003fd8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80003fdf: 00 + } else if (c == ';') { +ffffffff80003fe0: 41 80 fc 3b cmp $0x3b,%r12b +ffffffff80003fe4: 0f 85 82 fe ff ff jne ffffffff80003e6c + if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) { +ffffffff80003fea: 48 83 fa 10 cmp $0x10,%rdx +ffffffff80003fee: 0f 84 a3 f0 ff ff je ffffffff80003097 + ctx->esc_values[ctx->esc_values_i] = 0; +ffffffff80003ff4: c7 44 93 78 00 00 00 movl $0x0,0x78(%rbx,%rdx,4) +ffffffff80003ffb: 00 + ctx->esc_values_i++; +ffffffff80003ffc: 48 83 c2 01 add $0x1,%rdx +ffffffff80004000: 48 89 53 40 mov %rdx,0x40(%rbx) + return; +ffffffff80004004: e9 8e f0 ff ff jmp ffffffff80003097 + switch (c) { +ffffffff80004009: 41 80 fc 71 cmp $0x71,%r12b +ffffffff8000400d: 0f 85 c3 00 00 00 jne ffffffff800040d6 + esc_default = 0; break; +ffffffff80004013: 45 31 c0 xor %r8d,%r8d + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff80004016: 48 83 fa 0f cmp $0xf,%rdx +ffffffff8000401a: 0f 86 74 fe ff ff jbe ffffffff80003e94 + if (ctx->dec_private == true) { +ffffffff80004020: 40 84 f6 test %sil,%sil +ffffffff80004023: 0f 85 46 08 00 00 jne ffffffff8000486f + bool r = ctx->scroll_enabled; +ffffffff80004029: 44 0f b6 73 0a movzbl 0xa(%rbx),%r14d + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff8000402e: 48 8d 54 24 18 lea 0x18(%rsp),%rdx + ctx->scroll_enabled = false; +ffffffff80004033: c6 43 0a 00 movb $0x0,0xa(%rbx) + ctx->get_cursor_pos(ctx, &x, &y); +ffffffff80004037: 48 89 df mov %rbx,%rdi +ffffffff8000403a: 48 8d 74 24 10 lea 0x10(%rsp),%rsi +ffffffff8000403f: ff 93 08 01 00 00 call *0x108(%rbx) + if (ctx->callback != NULL) { +ffffffff80004045: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff8000404c: 48 85 c0 test %rax,%rax +ffffffff8000404f: 0f 84 09 ff ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_KBD_LEDS, ctx->esc_values[0], 0, 0); +ffffffff80004055: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80004058: 45 31 c0 xor %r8d,%r8d +ffffffff8000405b: 31 c9 xor %ecx,%ecx +ffffffff8000405d: be 3c 00 00 00 mov $0x3c,%esi +ffffffff80004062: 48 89 df mov %rbx,%rdi +ffffffff80004065: ff d0 call *%rax +ffffffff80004067: e9 f2 fe ff ff jmp ffffffff80003f5e +ffffffff8000406c: 0f 1f 40 00 nopl 0x0(%rax) + ctx->scroll(ctx); +ffffffff80004070: 48 89 df mov %rbx,%rdi +ffffffff80004073: ff 93 68 01 00 00 call *0x168(%rbx) + ctx->set_cursor_pos(ctx, 0, y); +ffffffff80004079: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000407e: 31 f6 xor %esi,%esi +ffffffff80004080: 48 89 df mov %rbx,%rdi +ffffffff80004083: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff80004089: e9 ca f3 ff ff jmp ffffffff80003458 + ctx->dec_private = true; +ffffffff8000408e: c6 43 14 01 movb $0x1,0x14(%rbx) + return; +ffffffff80004092: e9 00 f0 ff ff jmp ffffffff80003097 + ctx->scroll(ctx); +ffffffff80004097: 48 89 df mov %rbx,%rdi +ffffffff8000409a: ff 93 68 01 00 00 call *0x168(%rbx) + ctx->set_cursor_pos(ctx, x, y); +ffffffff800040a0: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800040a5: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff800040aa: 48 89 df mov %rbx,%rdi +ffffffff800040ad: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff800040b3: e9 a0 f3 ff ff jmp ffffffff80003458 + ctx->revscroll(ctx); +ffffffff800040b8: 48 89 df mov %rbx,%rdi +ffffffff800040bb: ff 93 70 01 00 00 call *0x170(%rbx) + ctx->set_cursor_pos(ctx, 0, y); +ffffffff800040c1: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800040c6: 31 f6 xor %esi,%esi +ffffffff800040c8: 48 89 df mov %rbx,%rdi +ffffffff800040cb: ff 93 00 01 00 00 call *0x100(%rbx) +ffffffff800040d1: e9 82 f3 ff ff jmp ffffffff80003458 + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff800040d6: 48 83 fa 0f cmp $0xf,%rdx +ffffffff800040da: 0f 87 31 06 00 00 ja ffffffff80004711 +ffffffff800040e0: 41 b8 01 00 00 00 mov $0x1,%r8d +ffffffff800040e6: e9 a9 fd ff ff jmp ffffffff80003e94 + esc_default = 0; break; +ffffffff800040eb: 45 31 c0 xor %r8d,%r8d + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { +ffffffff800040ee: 48 83 fa 0f cmp $0xf,%rdx +ffffffff800040f2: 0f 86 9c fd ff ff jbe ffffffff80003e94 + if (ctx->dec_private == true) { +ffffffff800040f8: 40 84 f6 test %sil,%sil +ffffffff800040fb: 0f 84 d1 fd ff ff je ffffffff80003ed2 + ctx->dec_private = false; +ffffffff80004101: c6 43 14 00 movb $0x0,0x14(%rbx) + switch (c) { +ffffffff80004105: 41 80 fc 6c cmp $0x6c,%r12b +ffffffff80004109: 0f 85 53 fe ff ff jne ffffffff80003f62 + switch (ctx->esc_values[0]) { +ffffffff8000410f: 83 7b 78 19 cmpl $0x19,0x78(%rbx) +ffffffff80004113: 0f 84 0a 06 00 00 je ffffffff80004723 + if (ctx->callback != NULL) { +ffffffff80004119: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff80004120: 48 85 c0 test %rax,%rax +ffffffff80004123: 0f 84 39 fe ff ff je ffffffff80003f62 + ctx->callback(ctx, FLANTERM_CB_DEC, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c); +ffffffff80004129: 48 8d 4b 78 lea 0x78(%rbx),%rcx +ffffffff8000412d: 4d 0f be c4 movsbq %r12b,%r8 +ffffffff80004131: be 0a 00 00 00 mov $0xa,%esi +ffffffff80004136: 48 89 df mov %rbx,%rdi +ffffffff80004139: ff d0 call *%rax +ffffffff8000413b: e9 22 fe ff ff jmp ffffffff80003f62 + case 0x2248: return 247; +ffffffff80004140: be f7 00 00 00 mov $0xf7,%esi +ffffffff80004145: e9 26 f5 ff ff jmp ffffffff80003670 + case 0x2302: return 127; +ffffffff8000414a: be 7f 00 00 00 mov $0x7f,%esi +ffffffff8000414f: e9 1c f5 ff ff jmp ffffffff80003670 + case 0x2229: return 239; +ffffffff80004154: be ef 00 00 00 mov $0xef,%esi +ffffffff80004159: e9 12 f5 ff ff jmp ffffffff80003670 + case 0x221a: return 251; +ffffffff8000415e: be fb 00 00 00 mov $0xfb,%esi +ffffffff80004163: e9 08 f5 ff ff jmp ffffffff80003670 + case 0x2219: return 249; +ffffffff80004168: be f9 00 00 00 mov $0xf9,%esi +ffffffff8000416d: e9 fe f4 ff ff jmp ffffffff80003670 + case 0x2265: return 242; +ffffffff80004172: be f2 00 00 00 mov $0xf2,%esi +ffffffff80004177: e9 f4 f4 ff ff jmp ffffffff80003670 + case 0x2264: return 243; +ffffffff8000417c: be f3 00 00 00 mov $0xf3,%esi +ffffffff80004181: e9 ea f4 ff ff jmp ffffffff80003670 + case 0x2022: return 7; +ffffffff80004186: be 07 00 00 00 mov $0x7,%esi +ffffffff8000418b: e9 e0 f4 ff ff jmp ffffffff80003670 + case 0x20a7: return 158; +ffffffff80004190: be 9e 00 00 00 mov $0x9e,%esi + switch (code_point) { +ffffffff80004195: 49 81 fc a7 20 00 00 cmp $0x20a7,%r12 +ffffffff8000419c: 0f 84 ce f4 ff ff je ffffffff80003670 +ffffffff800041a2: e9 19 f2 ff ff jmp ffffffff800033c0 +ffffffff800041a7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff800041ae: 00 00 + case 0x207f: return 252; +ffffffff800041b0: be fc 00 00 00 mov $0xfc,%esi +ffffffff800041b5: e9 b6 f4 ff ff jmp ffffffff80003670 + ctx->dec_private = false; +ffffffff800041ba: c6 43 14 00 movb $0x0,0x14(%rbx) + if (ctx->esc_values_i == 0) { +ffffffff800041be: 48 85 d2 test %rdx,%rdx +ffffffff800041c1: 0f 84 9b fd ff ff je ffffffff80003f62 + switch (c) { +ffffffff800041c7: 41 80 fc 68 cmp $0x68,%r12b +ffffffff800041cb: 0f 85 34 ff ff ff jne ffffffff80004105 + switch (ctx->esc_values[0]) { +ffffffff800041d1: 83 7b 78 19 cmpl $0x19,0x78(%rbx) +ffffffff800041d5: 0f 85 3e ff ff ff jne ffffffff80004119 + ctx->cursor_enabled = true; +ffffffff800041db: c6 43 09 01 movb $0x1,0x9(%rbx) +ffffffff800041df: e9 7e fd ff ff jmp ffffffff80003f62 +ffffffff800041e4: 0f 1f 40 00 nopl 0x0(%rax) + case 0x2321: return 245; +ffffffff800041e8: be f5 00 00 00 mov $0xf5,%esi +ffffffff800041ed: e9 7e f4 ff ff jmp ffffffff80003670 + case 0x2320: return 244; +ffffffff800041f2: be f4 00 00 00 mov $0xf4,%esi +ffffffff800041f7: e9 74 f4 ff ff jmp ffffffff80003670 + for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++) +ffffffff800041fc: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff800041ff: 4c 8b 64 24 10 mov 0x10(%rsp),%r12 +ffffffff80004204: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff8000420b: 49 01 d4 add %rdx,%r12 +ffffffff8000420e: 49 39 c4 cmp %rax,%r12 +ffffffff80004211: 73 2d jae ffffffff80004240 + ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y); +ffffffff80004213: 4c 8b 44 24 18 mov 0x18(%rsp),%r8 +ffffffff80004218: 4c 89 e6 mov %r12,%rsi +ffffffff8000421b: 4c 89 e1 mov %r12,%rcx +ffffffff8000421e: 48 89 df mov %rbx,%rdi +ffffffff80004221: 48 29 d6 sub %rdx,%rsi + for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++) +ffffffff80004224: 49 83 c4 01 add $0x1,%r12 + ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y); +ffffffff80004228: 4c 89 c2 mov %r8,%rdx +ffffffff8000422b: ff 93 60 01 00 00 call *0x160(%rbx) + for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++) +ffffffff80004231: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff80004238: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff8000423b: 49 39 c4 cmp %rax,%r12 +ffffffff8000423e: 72 d3 jb ffffffff80004213 + ctx->set_cursor_pos(ctx, ctx->cols - ctx->esc_values[0], y); +ffffffff80004240: 48 29 d0 sub %rdx,%rax +ffffffff80004243: 48 89 df mov %rbx,%rdi +ffffffff80004246: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000424b: 48 89 c6 mov %rax,%rsi +ffffffff8000424e: ff 93 00 01 00 00 call *0x100(%rbx) + size_t count = ctx->esc_values[0] > ctx->cols ? ctx->cols : ctx->esc_values[0]; +ffffffff80004254: 44 8b 63 78 mov 0x78(%rbx),%r12d +ffffffff80004258: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff8000425f: 49 39 c4 cmp %rax,%r12 +ffffffff80004262: 4c 0f 47 e0 cmova %rax,%r12 + for (size_t i = 0; i < count; i++) +ffffffff80004266: 45 31 ff xor %r15d,%r15d +ffffffff80004269: 4d 85 e4 test %r12,%r12 +ffffffff8000426c: 74 17 je ffffffff80004285 +ffffffff8000426e: 49 83 c7 01 add $0x1,%r15 + ctx->raw_putchar(ctx, ' '); +ffffffff80004272: be 20 00 00 00 mov $0x20,%esi +ffffffff80004277: 48 89 df mov %rbx,%rdi +ffffffff8000427a: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < count; i++) +ffffffff80004280: 4d 39 fc cmp %r15,%r12 +ffffffff80004283: 75 e9 jne ffffffff8000426e + ctx->set_cursor_pos(ctx, x, y); +ffffffff80004285: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000428a: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff8000428f: 48 89 df mov %rbx,%rdi +ffffffff80004292: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004298: e9 c1 fc ff ff jmp ffffffff80003f5e + x = 0; +ffffffff8000429d: 45 31 c0 xor %r8d,%r8d +ffffffff800042a0: 4c 89 44 24 10 mov %r8,0x10(%rsp) + if (ctx->esc_values[0] > y) +ffffffff800042a5: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx +ffffffff800042aa: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff800042ad: 48 39 d1 cmp %rdx,%rcx +ffffffff800042b0: 73 05 jae ffffffff800042b7 + ctx->esc_values[0] = y; +ffffffff800042b2: 89 4b 78 mov %ecx,0x78(%rbx) +ffffffff800042b5: 89 ca mov %ecx,%edx + size_t dest_y = y - ctx->esc_values[0]; +ffffffff800042b7: 48 89 c8 mov %rcx,%rax +ffffffff800042ba: 48 29 d0 sub %rdx,%rax + if ((ctx->scroll_top_margin >= dest_y && ctx->scroll_top_margin <= orig_y) +ffffffff800042bd: 48 8b 53 68 mov 0x68(%rbx),%rdx +ffffffff800042c1: 48 39 c2 cmp %rax,%rdx +ffffffff800042c4: 72 09 jb ffffffff800042cf +ffffffff800042c6: 48 39 d1 cmp %rdx,%rcx +ffffffff800042c9: 0f 83 2c 04 00 00 jae ffffffff800046fb + || (ctx->scroll_bottom_margin >= dest_y && ctx->scroll_bottom_margin <= orig_y)) { +ffffffff800042cf: 48 8b 73 70 mov 0x70(%rbx),%rsi +ffffffff800042d3: 48 39 c6 cmp %rax,%rsi +ffffffff800042d6: 72 09 jb ffffffff800042e1 +ffffffff800042d8: 48 39 f1 cmp %rsi,%rcx +ffffffff800042db: 0f 83 1a 04 00 00 jae ffffffff800046fb + ctx->set_cursor_pos(ctx, x, dest_y); +ffffffff800042e1: 48 8b 74 24 10 mov 0x10(%rsp),%rsi +ffffffff800042e6: 48 89 c2 mov %rax,%rdx +ffffffff800042e9: 48 89 df mov %rbx,%rdi +ffffffff800042ec: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff800042f2: e9 67 fc ff ff jmp ffffffff80003f5e + case 0x221f: return 28; +ffffffff800042f7: be 1c 00 00 00 mov $0x1c,%esi +ffffffff800042fc: e9 6f f3 ff ff jmp ffffffff80003670 + case '~': FLANTERM_DEC_SPCL_PRN(0xfa) +ffffffff80004301: be fa 00 00 00 mov $0xfa,%esi +ffffffff80004306: 48 89 df mov %rbx,%rdi +ffffffff80004309: ff d0 call *%rax +ffffffff8000430b: e9 87 ed ff ff jmp ffffffff80003097 + case '}': FLANTERM_DEC_SPCL_PRN(0x9c) +ffffffff80004310: be 9c 00 00 00 mov $0x9c,%esi +ffffffff80004315: 48 89 df mov %rbx,%rdi +ffffffff80004318: ff d0 call *%rax +ffffffff8000431a: e9 78 ed ff ff jmp ffffffff80003097 + case '{': FLANTERM_DEC_SPCL_PRN(0xe3) +ffffffff8000431f: be e3 00 00 00 mov $0xe3,%esi +ffffffff80004324: 48 89 df mov %rbx,%rdi +ffffffff80004327: ff d0 call *%rax +ffffffff80004329: e9 69 ed ff ff jmp ffffffff80003097 + case 'z': FLANTERM_DEC_SPCL_PRN(0xf2) +ffffffff8000432e: be f2 00 00 00 mov $0xf2,%esi +ffffffff80004333: 48 89 df mov %rbx,%rdi +ffffffff80004336: ff d0 call *%rax +ffffffff80004338: e9 5a ed ff ff jmp ffffffff80003097 + case 'y': FLANTERM_DEC_SPCL_PRN(0xf3) +ffffffff8000433d: be f3 00 00 00 mov $0xf3,%esi +ffffffff80004342: 48 89 df mov %rbx,%rdi +ffffffff80004345: ff d0 call *%rax +ffffffff80004347: e9 4b ed ff ff jmp ffffffff80003097 + case 'x': FLANTERM_DEC_SPCL_PRN(0xb3) +ffffffff8000434c: be b3 00 00 00 mov $0xb3,%esi +ffffffff80004351: 48 89 df mov %rbx,%rdi +ffffffff80004354: ff d0 call *%rax +ffffffff80004356: e9 3c ed ff ff jmp ffffffff80003097 + case 'w': FLANTERM_DEC_SPCL_PRN(0xc2) +ffffffff8000435b: be c2 00 00 00 mov $0xc2,%esi +ffffffff80004360: 48 89 df mov %rbx,%rdi +ffffffff80004363: ff d0 call *%rax +ffffffff80004365: e9 2d ed ff ff jmp ffffffff80003097 + case 'v': FLANTERM_DEC_SPCL_PRN(0xc1) +ffffffff8000436a: be c1 00 00 00 mov $0xc1,%esi +ffffffff8000436f: 48 89 df mov %rbx,%rdi +ffffffff80004372: ff d0 call *%rax +ffffffff80004374: e9 1e ed ff ff jmp ffffffff80003097 + case 'u': FLANTERM_DEC_SPCL_PRN(0xb4) +ffffffff80004379: be b4 00 00 00 mov $0xb4,%esi +ffffffff8000437e: 48 89 df mov %rbx,%rdi +ffffffff80004381: ff d0 call *%rax +ffffffff80004383: e9 0f ed ff ff jmp ffffffff80003097 + case 't': FLANTERM_DEC_SPCL_PRN(0xc3) +ffffffff80004388: be c3 00 00 00 mov $0xc3,%esi +ffffffff8000438d: 48 89 df mov %rbx,%rdi +ffffffff80004390: ff d0 call *%rax +ffffffff80004392: e9 00 ed ff ff jmp ffffffff80003097 + case 's': FLANTERM_DEC_SPCL_PRN(0x5f) +ffffffff80004397: be 5f 00 00 00 mov $0x5f,%esi +ffffffff8000439c: 48 89 df mov %rbx,%rdi +ffffffff8000439f: ff d0 call *%rax +ffffffff800043a1: e9 f1 ec ff ff jmp ffffffff80003097 + case 'q': FLANTERM_DEC_SPCL_PRN(0xc4) +ffffffff800043a6: be c4 00 00 00 mov $0xc4,%esi +ffffffff800043ab: 48 89 df mov %rbx,%rdi +ffffffff800043ae: ff d0 call *%rax +ffffffff800043b0: e9 e2 ec ff ff jmp ffffffff80003097 + case 'n': FLANTERM_DEC_SPCL_PRN(0xc5) +ffffffff800043b5: be c5 00 00 00 mov $0xc5,%esi +ffffffff800043ba: 48 89 df mov %rbx,%rdi +ffffffff800043bd: ff d0 call *%rax +ffffffff800043bf: e9 d3 ec ff ff jmp ffffffff80003097 + case 'm': FLANTERM_DEC_SPCL_PRN(0xc0) +ffffffff800043c4: be c0 00 00 00 mov $0xc0,%esi +ffffffff800043c9: 48 89 df mov %rbx,%rdi +ffffffff800043cc: ff d0 call *%rax +ffffffff800043ce: e9 c4 ec ff ff jmp ffffffff80003097 + case 'l': FLANTERM_DEC_SPCL_PRN(0xda) +ffffffff800043d3: be da 00 00 00 mov $0xda,%esi +ffffffff800043d8: 48 89 df mov %rbx,%rdi +ffffffff800043db: ff d0 call *%rax +ffffffff800043dd: e9 b5 ec ff ff jmp ffffffff80003097 + case 'k': FLANTERM_DEC_SPCL_PRN(0xbf) +ffffffff800043e2: be bf 00 00 00 mov $0xbf,%esi +ffffffff800043e7: 48 89 df mov %rbx,%rdi +ffffffff800043ea: ff d0 call *%rax +ffffffff800043ec: e9 a6 ec ff ff jmp ffffffff80003097 + case 'j': FLANTERM_DEC_SPCL_PRN(0xd9) +ffffffff800043f1: be d9 00 00 00 mov $0xd9,%esi +ffffffff800043f6: 48 89 df mov %rbx,%rdi +ffffffff800043f9: ff d0 call *%rax +ffffffff800043fb: e9 97 ec ff ff jmp ffffffff80003097 + case 'h': FLANTERM_DEC_SPCL_PRN(0xb0) +ffffffff80004400: be b0 00 00 00 mov $0xb0,%esi +ffffffff80004405: 48 89 df mov %rbx,%rdi +ffffffff80004408: ff d0 call *%rax +ffffffff8000440a: e9 88 ec ff ff jmp ffffffff80003097 + case 'g': FLANTERM_DEC_SPCL_PRN(0xf1) +ffffffff8000440f: be f1 00 00 00 mov $0xf1,%esi +ffffffff80004414: 48 89 df mov %rbx,%rdi +ffffffff80004417: ff d0 call *%rax +ffffffff80004419: e9 79 ec ff ff jmp ffffffff80003097 + case 'f': FLANTERM_DEC_SPCL_PRN(0xf8) +ffffffff8000441e: be f8 00 00 00 mov $0xf8,%esi +ffffffff80004423: 48 89 df mov %rbx,%rdi +ffffffff80004426: ff d0 call *%rax +ffffffff80004428: e9 6a ec ff ff jmp ffffffff80003097 + case 'a': FLANTERM_DEC_SPCL_PRN(0xb1) +ffffffff8000442d: be b1 00 00 00 mov $0xb1,%esi +ffffffff80004432: 48 89 df mov %rbx,%rdi +ffffffff80004435: ff d0 call *%rax +ffffffff80004437: e9 5b ec ff ff jmp ffffffff80003097 + case '`': FLANTERM_DEC_SPCL_PRN(0x04) +ffffffff8000443c: be 04 00 00 00 mov $0x4,%esi +ffffffff80004441: 48 89 df mov %rbx,%rdi +ffffffff80004444: ff d0 call *%rax +ffffffff80004446: e9 4c ec ff ff jmp ffffffff80003097 + case '_': FLANTERM_DEC_SPCL_PRN(0xff) +ffffffff8000444b: be ff 00 00 00 mov $0xff,%esi +ffffffff80004450: 48 89 df mov %rbx,%rdi +ffffffff80004453: ff d0 call *%rax +ffffffff80004455: e9 3d ec ff ff jmp ffffffff80003097 + case '0': FLANTERM_DEC_SPCL_PRN(0xdb) +ffffffff8000445a: be db 00 00 00 mov $0xdb,%esi +ffffffff8000445f: 48 89 df mov %rbx,%rdi +ffffffff80004462: ff d0 call *%rax +ffffffff80004464: e9 2e ec ff ff jmp ffffffff80003097 + case '.': FLANTERM_DEC_SPCL_PRN(0x19) +ffffffff80004469: be 19 00 00 00 mov $0x19,%esi +ffffffff8000446e: 48 89 df mov %rbx,%rdi +ffffffff80004471: ff d0 call *%rax +ffffffff80004473: e9 1f ec ff ff jmp ffffffff80003097 + case '-': FLANTERM_DEC_SPCL_PRN(0x18) +ffffffff80004478: be 18 00 00 00 mov $0x18,%esi +ffffffff8000447d: 48 89 df mov %rbx,%rdi +ffffffff80004480: ff d0 call *%rax +ffffffff80004482: e9 10 ec ff ff jmp ffffffff80003097 + case ',': FLANTERM_DEC_SPCL_PRN(0x1b) +ffffffff80004487: be 1b 00 00 00 mov $0x1b,%esi +ffffffff8000448c: 48 89 df mov %rbx,%rdi +ffffffff8000448f: ff d0 call *%rax +ffffffff80004491: e9 01 ec ff ff jmp ffffffff80003097 + case '+': FLANTERM_DEC_SPCL_PRN(0x1a) +ffffffff80004496: be 1a 00 00 00 mov $0x1a,%esi +ffffffff8000449b: 48 89 df mov %rbx,%rdi +ffffffff8000449e: ff d0 call *%rax +ffffffff800044a0: e9 f2 eb ff ff jmp ffffffff80003097 + size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0]; +ffffffff800044a5: 44 8b 63 78 mov 0x78(%rbx),%r12d +ffffffff800044a9: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff800044b0: 49 39 c4 cmp %rax,%r12 +ffffffff800044b3: 4c 0f 47 e0 cmova %rax,%r12 + for (size_t i = 0; i < count; i++) { +ffffffff800044b7: 4d 85 e4 test %r12,%r12 +ffffffff800044ba: 0f 84 9e fa ff ff je ffffffff80003f5e +ffffffff800044c0: 45 31 ff xor %r15d,%r15d +ffffffff800044c3: 49 83 c7 01 add $0x1,%r15 + ctx->scroll(ctx); +ffffffff800044c7: 48 89 df mov %rbx,%rdi +ffffffff800044ca: ff 93 68 01 00 00 call *0x168(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff800044d0: 4d 39 fc cmp %r15,%r12 +ffffffff800044d3: 75 ee jne ffffffff800044c3 +ffffffff800044d5: e9 84 fa ff ff jmp ffffffff80003f5e + ctx->scroll_top_margin = y; +ffffffff800044da: 48 8b 44 24 18 mov 0x18(%rsp),%rax + size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0]; +ffffffff800044df: 44 8b 63 78 mov 0x78(%rbx),%r12d + size_t old_scroll_top_margin = ctx->scroll_top_margin; +ffffffff800044e3: 48 8b 53 68 mov 0x68(%rbx),%rdx + ctx->scroll_top_margin = y; +ffffffff800044e7: 48 89 43 68 mov %rax,0x68(%rbx) + size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0]; +ffffffff800044eb: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff800044f2: 49 39 c4 cmp %rax,%r12 +ffffffff800044f5: 4c 0f 47 e0 cmova %rax,%r12 + for (size_t i = 0; i < count; i++) { +ffffffff800044f9: 45 31 ff xor %r15d,%r15d +ffffffff800044fc: 4d 85 e4 test %r12,%r12 +ffffffff800044ff: 74 1c je ffffffff8000451d +ffffffff80004501: 49 83 c7 01 add $0x1,%r15 +ffffffff80004505: 48 89 54 24 08 mov %rdx,0x8(%rsp) + ctx->revscroll(ctx); +ffffffff8000450a: 48 89 df mov %rbx,%rdi +ffffffff8000450d: ff 93 70 01 00 00 call *0x170(%rbx) + for (size_t i = 0; i < count; i++) { +ffffffff80004513: 4d 39 fc cmp %r15,%r12 +ffffffff80004516: 48 8b 54 24 08 mov 0x8(%rsp),%rdx +ffffffff8000451b: 75 e4 jne ffffffff80004501 + ctx->scroll_top_margin = old_scroll_top_margin; +ffffffff8000451d: 48 89 53 68 mov %rdx,0x68(%rbx) + break; +ffffffff80004521: e9 38 fa ff ff jmp ffffffff80003f5e + switch (ctx->esc_values[0]) { +ffffffff80004526: 8b 43 78 mov 0x78(%rbx),%eax +ffffffff80004529: 83 f8 01 cmp $0x1,%eax +ffffffff8000452c: 74 69 je ffffffff80004597 +ffffffff8000452e: 83 f8 02 cmp $0x2,%eax +ffffffff80004531: 74 2f je ffffffff80004562 +ffffffff80004533: 85 c0 test %eax,%eax +ffffffff80004535: 0f 85 23 fa ff ff jne ffffffff80003f5e + for (size_t i = x; i < ctx->cols; i++) +ffffffff8000453b: 4c 8b 64 24 10 mov 0x10(%rsp),%r12 +ffffffff80004540: eb 12 jmp ffffffff80004554 + ctx->raw_putchar(ctx, ' '); +ffffffff80004542: be 20 00 00 00 mov $0x20,%esi +ffffffff80004547: 48 89 df mov %rbx,%rdi + for (size_t i = x; i < ctx->cols; i++) +ffffffff8000454a: 49 83 c4 01 add $0x1,%r12 + ctx->raw_putchar(ctx, ' '); +ffffffff8000454e: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = x; i < ctx->cols; i++) +ffffffff80004554: 4c 3b a3 e8 00 00 00 cmp 0xe8(%rbx),%r12 +ffffffff8000455b: 72 e5 jb ffffffff80004542 +ffffffff8000455d: e9 23 fd ff ff jmp ffffffff80004285 + ctx->set_cursor_pos(ctx, 0, y); +ffffffff80004562: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff80004567: 31 f6 xor %esi,%esi +ffffffff80004569: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < ctx->cols; i++) +ffffffff8000456c: 45 31 e4 xor %r12d,%r12d + ctx->set_cursor_pos(ctx, 0, y); +ffffffff8000456f: ff 93 00 01 00 00 call *0x100(%rbx) + for (size_t i = 0; i < ctx->cols; i++) +ffffffff80004575: eb 12 jmp ffffffff80004589 + ctx->raw_putchar(ctx, ' '); +ffffffff80004577: be 20 00 00 00 mov $0x20,%esi +ffffffff8000457c: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < ctx->cols; i++) +ffffffff8000457f: 49 83 c4 01 add $0x1,%r12 + ctx->raw_putchar(ctx, ' '); +ffffffff80004583: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < ctx->cols; i++) +ffffffff80004589: 4c 3b a3 e8 00 00 00 cmp 0xe8(%rbx),%r12 +ffffffff80004590: 72 e5 jb ffffffff80004577 +ffffffff80004592: e9 ee fc ff ff jmp ffffffff80004285 + ctx->set_cursor_pos(ctx, 0, y); +ffffffff80004597: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000459c: 31 f6 xor %esi,%esi +ffffffff8000459e: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < x; i++) +ffffffff800045a1: 45 31 e4 xor %r12d,%r12d + ctx->set_cursor_pos(ctx, 0, y); +ffffffff800045a4: ff 93 00 01 00 00 call *0x100(%rbx) + for (size_t i = 0; i < x; i++) +ffffffff800045aa: eb 12 jmp ffffffff800045be + ctx->raw_putchar(ctx, ' '); +ffffffff800045ac: be 20 00 00 00 mov $0x20,%esi +ffffffff800045b1: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < x; i++) +ffffffff800045b4: 49 83 c4 01 add $0x1,%r12 + ctx->raw_putchar(ctx, ' '); +ffffffff800045b8: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < x; i++) +ffffffff800045be: 4c 3b 64 24 10 cmp 0x10(%rsp),%r12 +ffffffff800045c3: 72 e7 jb ffffffff800045ac +ffffffff800045c5: e9 94 f9 ff ff jmp ffffffff80003f5e + switch (ctx->esc_values[0]) { +ffffffff800045ca: 8b 43 78 mov 0x78(%rbx),%eax +ffffffff800045cd: 83 f8 01 cmp $0x1,%eax +ffffffff800045d0: 0f 84 b3 00 00 00 je ffffffff80004689 +ffffffff800045d6: 0f 87 91 00 00 00 ja ffffffff8000466d + size_t cols_diff = ctx->cols - (x + 1); +ffffffff800045dc: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax + size_t rows_remaining = ctx->rows - (y + 1); +ffffffff800045e3: 4c 8b a3 e0 00 00 00 mov 0xe0(%rbx),%r12 + for (size_t i = 0; i < to_clear; i++) { +ffffffff800045ea: 45 31 ff xor %r15d,%r15d + size_t rows_remaining = ctx->rows - (y + 1); +ffffffff800045ed: 4c 2b 64 24 18 sub 0x18(%rsp),%r12 +ffffffff800045f2: 49 83 ec 01 sub $0x1,%r12 + size_t to_clear = rows_remaining * ctx->cols + cols_diff + 1; +ffffffff800045f6: 4c 0f af e0 imul %rax,%r12 +ffffffff800045fa: 48 2b 44 24 10 sub 0x10(%rsp),%rax +ffffffff800045ff: 49 01 c4 add %rax,%r12 + for (size_t i = 0; i < to_clear; i++) { +ffffffff80004602: eb 12 jmp ffffffff80004616 + ctx->raw_putchar(ctx, ' '); +ffffffff80004604: be 20 00 00 00 mov $0x20,%esi +ffffffff80004609: 48 89 df mov %rbx,%rdi + for (size_t i = 0; i < to_clear; i++) { +ffffffff8000460c: 49 83 c7 01 add $0x1,%r15 + ctx->raw_putchar(ctx, ' '); +ffffffff80004610: ff 93 f0 00 00 00 call *0xf0(%rbx) + for (size_t i = 0; i < to_clear; i++) { +ffffffff80004616: 4d 39 fc cmp %r15,%r12 +ffffffff80004619: 75 e9 jne ffffffff80004604 +ffffffff8000461b: e9 65 fc ff ff jmp ffffffff80004285 + if (ctx->esc_values[0] != 0) { +ffffffff80004620: 8b 43 78 mov 0x78(%rbx),%eax +ffffffff80004623: 85 c0 test %eax,%eax +ffffffff80004625: 74 06 je ffffffff8000462d + ctx->esc_values[0]--; +ffffffff80004627: 83 e8 01 sub $0x1,%eax +ffffffff8000462a: 89 43 78 mov %eax,0x78(%rbx) + if (ctx->esc_values[1] != 0) { +ffffffff8000462d: 8b 43 7c mov 0x7c(%rbx),%eax +ffffffff80004630: 85 c0 test %eax,%eax +ffffffff80004632: 74 06 je ffffffff8000463a + ctx->esc_values[1]--; +ffffffff80004634: 83 e8 01 sub $0x1,%eax +ffffffff80004637: 89 43 7c mov %eax,0x7c(%rbx) + if (ctx->esc_values[1] >= ctx->cols) +ffffffff8000463a: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff80004641: 8b 73 7c mov 0x7c(%rbx),%esi +ffffffff80004644: 48 39 c6 cmp %rax,%rsi +ffffffff80004647: 72 06 jb ffffffff8000464f + ctx->esc_values[1] = ctx->cols - 1; +ffffffff80004649: 8d 70 ff lea -0x1(%rax),%esi +ffffffff8000464c: 89 73 7c mov %esi,0x7c(%rbx) + if (ctx->esc_values[0] >= ctx->rows) +ffffffff8000464f: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax +ffffffff80004656: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80004659: 48 39 c2 cmp %rax,%rdx +ffffffff8000465c: 0f 82 f3 f8 ff ff jb ffffffff80003f55 + ctx->esc_values[0] = ctx->rows - 1; +ffffffff80004662: 8d 50 ff lea -0x1(%rax),%edx +ffffffff80004665: 89 53 78 mov %edx,0x78(%rbx) + ctx->set_cursor_pos(ctx, ctx->esc_values[1], ctx->esc_values[0]); +ffffffff80004668: e9 e8 f8 ff ff jmp ffffffff80003f55 + switch (ctx->esc_values[0]) { +ffffffff8000466d: 83 e8 02 sub $0x2,%eax +ffffffff80004670: 83 f8 01 cmp $0x1,%eax +ffffffff80004673: 0f 87 e5 f8 ff ff ja ffffffff80003f5e + ctx->clear(ctx, false); +ffffffff80004679: 31 f6 xor %esi,%esi +ffffffff8000467b: 48 89 df mov %rbx,%rdi +ffffffff8000467e: ff 93 f8 00 00 00 call *0xf8(%rbx) + break; +ffffffff80004684: e9 d5 f8 ff ff jmp ffffffff80003f5e + ctx->set_cursor_pos(ctx, 0, 0); +ffffffff80004689: 31 d2 xor %edx,%edx +ffffffff8000468b: 31 f6 xor %esi,%esi +ffffffff8000468d: 48 89 df mov %rbx,%rdi + for (size_t yc = 0; yc < ctx->rows; yc++) { +ffffffff80004690: 45 31 ff xor %r15d,%r15d + ctx->set_cursor_pos(ctx, 0, 0); +ffffffff80004693: ff 93 00 01 00 00 call *0x100(%rbx) + for (size_t yc = 0; yc < ctx->rows; yc++) { +ffffffff80004699: 4c 3b bb e0 00 00 00 cmp 0xe0(%rbx),%r15 +ffffffff800046a0: 0f 83 b8 f8 ff ff jae ffffffff80003f5e + for (size_t xc = 0; xc < ctx->cols; xc++) { +ffffffff800046a6: 45 31 e4 xor %r12d,%r12d +ffffffff800046a9: 48 83 bb e8 00 00 00 cmpq $0x0,0xe8(%rbx) +ffffffff800046b0: 00 +ffffffff800046b1: 75 12 jne ffffffff800046c5 +ffffffff800046b3: eb 40 jmp ffffffff800046f5 +ffffffff800046b5: 0f 1f 00 nopl (%rax) +ffffffff800046b8: 49 83 c4 01 add $0x1,%r12 +ffffffff800046bc: 4c 3b a3 e8 00 00 00 cmp 0xe8(%rbx),%r12 +ffffffff800046c3: 73 30 jae ffffffff800046f5 + ctx->raw_putchar(ctx, ' '); +ffffffff800046c5: be 20 00 00 00 mov $0x20,%esi +ffffffff800046ca: 48 89 df mov %rbx,%rdi +ffffffff800046cd: ff 93 f0 00 00 00 call *0xf0(%rbx) + if (xc == x && yc == y) { +ffffffff800046d3: 4c 39 64 24 10 cmp %r12,0x10(%rsp) +ffffffff800046d8: 75 de jne ffffffff800046b8 +ffffffff800046da: 4c 39 7c 24 18 cmp %r15,0x18(%rsp) +ffffffff800046df: 75 d7 jne ffffffff800046b8 + ctx->set_cursor_pos(ctx, x, y); +ffffffff800046e1: 4c 89 fa mov %r15,%rdx +ffffffff800046e4: 4c 89 e6 mov %r12,%rsi +ffffffff800046e7: 48 89 df mov %rbx,%rdi +ffffffff800046ea: ff 93 00 01 00 00 call *0x100(%rbx) + if (b == true) +ffffffff800046f0: e9 69 f8 ff ff jmp ffffffff80003f5e + for (size_t yc = 0; yc < ctx->rows; yc++) { +ffffffff800046f5: 49 83 c7 01 add $0x1,%r15 +ffffffff800046f9: eb 9e jmp ffffffff80004699 + if (will_be_in_scroll_region && dest_y < ctx->scroll_top_margin) { +ffffffff800046fb: 48 39 d0 cmp %rdx,%rax +ffffffff800046fe: 48 0f 42 c2 cmovb %rdx,%rax +ffffffff80004702: e9 da fb ff ff jmp ffffffff800042e1 + case 0x221e: return 236; +ffffffff80004707: be ec 00 00 00 mov $0xec,%esi +ffffffff8000470c: e9 5f ef ff ff jmp ffffffff80003670 + if (ctx->dec_private == true) { +ffffffff80004711: 40 84 f6 test %sil,%sil +ffffffff80004714: 0f 84 b8 f7 ff ff je ffffffff80003ed2 + ctx->dec_private = false; +ffffffff8000471a: c6 43 14 00 movb $0x0,0x14(%rbx) + if (ctx->esc_values_i == 0) { +ffffffff8000471e: e9 a4 fa ff ff jmp ffffffff800041c7 + ctx->cursor_enabled = false; +ffffffff80004723: c6 43 09 00 movb $0x0,0x9(%rbx) +ffffffff80004727: e9 36 f8 ff ff jmp ffffffff80003f62 + dest_y = ctx->scroll_bottom_margin - 1; +ffffffff8000472c: 48 8d 50 ff lea -0x1(%rax),%rdx + ctx->set_cursor_pos(ctx, x, dest_y); +ffffffff80004730: e9 1b f8 ff ff jmp ffffffff80003f50 + for (size_t i = ctx->cols - 1; ; i--) { +ffffffff80004735: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff8000473c: 4c 8d 60 ff lea -0x1(%rax),%r12 +ffffffff80004740: eb 04 jmp ffffffff80004746 +ffffffff80004742: 49 83 ec 01 sub $0x1,%r12 + ctx->move_character(ctx, i + ctx->esc_values[0], y, i, y); +ffffffff80004746: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000474b: 8b 73 78 mov 0x78(%rbx),%esi +ffffffff8000474e: 4c 89 e1 mov %r12,%rcx +ffffffff80004751: 48 89 df mov %rbx,%rdi +ffffffff80004754: 4c 01 e6 add %r12,%rsi +ffffffff80004757: 49 89 d0 mov %rdx,%r8 +ffffffff8000475a: ff 93 60 01 00 00 call *0x160(%rbx) + ctx->set_cursor_pos(ctx, i, y); +ffffffff80004760: 4c 89 e6 mov %r12,%rsi +ffffffff80004763: 48 89 df mov %rbx,%rdi +ffffffff80004766: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000476b: ff 93 00 01 00 00 call *0x100(%rbx) + ctx->raw_putchar(ctx, ' '); +ffffffff80004771: be 20 00 00 00 mov $0x20,%esi +ffffffff80004776: 48 89 df mov %rbx,%rdi +ffffffff80004779: ff 93 f0 00 00 00 call *0xf0(%rbx) + if (i == x) { +ffffffff8000477f: 4c 3b 64 24 10 cmp 0x10(%rsp),%r12 +ffffffff80004784: 75 bc jne ffffffff80004742 + ctx->set_cursor_pos(ctx, x, y); +ffffffff80004786: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000478b: 4c 89 e6 mov %r12,%rsi +ffffffff8000478e: 48 89 df mov %rbx,%rdi +ffffffff80004791: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004797: e9 c2 f7 ff ff jmp ffffffff80003f5e + if (ctx->esc_values_i == 0) { +ffffffff8000479c: 48 8b 53 40 mov 0x40(%rbx),%rdx +ffffffff800047a0: 48 85 d2 test %rdx,%rdx +ffffffff800047a3: 0f 84 b5 f7 ff ff je ffffffff80003f5e + if (ctx->callback != NULL) { +ffffffff800047a9: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff800047b0: 48 85 c0 test %rax,%rax +ffffffff800047b3: 0f 84 a5 f7 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_LINUX, ctx->esc_values_i, (uintptr_t)ctx->esc_values, 0); +ffffffff800047b9: 48 8d 4b 78 lea 0x78(%rbx),%rcx +ffffffff800047bd: 45 31 c0 xor %r8d,%r8d +ffffffff800047c0: be 50 00 00 00 mov $0x50,%esi +ffffffff800047c5: 48 89 df mov %rbx,%rdi +ffffffff800047c8: ff d0 call *%rax +ffffffff800047ca: e9 8f f7 ff ff jmp ffffffff80003f5e + if (x + ctx->esc_values[0] > ctx->cols - 1) +ffffffff800047cf: 48 8b 4c 24 10 mov 0x10(%rsp),%rcx +ffffffff800047d4: 48 8b 83 e8 00 00 00 mov 0xe8(%rbx),%rax +ffffffff800047db: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff800047de: 48 8d 78 ff lea -0x1(%rax),%rdi +ffffffff800047e2: 48 8d 34 0a lea (%rdx,%rcx,1),%rsi +ffffffff800047e6: 48 39 f7 cmp %rsi,%rdi +ffffffff800047e9: 73 08 jae ffffffff800047f3 + ctx->esc_values[0] = (ctx->cols - 1) - x; +ffffffff800047eb: 29 c8 sub %ecx,%eax +ffffffff800047ed: 8d 50 ff lea -0x1(%rax),%edx +ffffffff800047f0: 89 53 78 mov %edx,0x78(%rbx) + ctx->set_cursor_pos(ctx, x + ctx->esc_values[0], y); +ffffffff800047f3: 48 8d 34 0a lea (%rdx,%rcx,1),%rsi +ffffffff800047f7: 48 89 df mov %rbx,%rdi +ffffffff800047fa: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff800047ff: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004805: e9 54 f7 ff ff jmp ffffffff80003f5e + ctx->esc_values[0] -= 1; +ffffffff8000480a: 8b 43 78 mov 0x78(%rbx),%eax + if (ctx->esc_values[0] >= ctx->cols) +ffffffff8000480d: 48 8b 93 e8 00 00 00 mov 0xe8(%rbx),%rdx + ctx->esc_values[0] -= 1; +ffffffff80004814: 83 e8 01 sub $0x1,%eax +ffffffff80004817: 89 43 78 mov %eax,0x78(%rbx) + if (ctx->esc_values[0] >= ctx->cols) +ffffffff8000481a: 48 39 d0 cmp %rdx,%rax +ffffffff8000481d: 72 06 jb ffffffff80004825 + ctx->esc_values[0] = ctx->cols - 1; +ffffffff8000481f: 83 ea 01 sub $0x1,%edx +ffffffff80004822: 89 53 78 mov %edx,0x78(%rbx) + ctx->set_cursor_pos(ctx, ctx->esc_values[0], y); +ffffffff80004825: 8b 73 78 mov 0x78(%rbx),%esi +ffffffff80004828: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff8000482d: 48 89 df mov %rbx,%rdi +ffffffff80004830: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004836: e9 23 f7 ff ff jmp ffffffff80003f5e + if (ctx->esc_values[0] > x) +ffffffff8000483b: 48 8b 44 24 10 mov 0x10(%rsp),%rax +ffffffff80004840: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80004843: 48 39 d0 cmp %rdx,%rax +ffffffff80004846: 73 05 jae ffffffff8000484d + ctx->esc_values[0] = x; +ffffffff80004848: 89 43 78 mov %eax,0x78(%rbx) +ffffffff8000484b: 89 c2 mov %eax,%edx + ctx->set_cursor_pos(ctx, x - ctx->esc_values[0], y); +ffffffff8000484d: 48 29 d0 sub %rdx,%rax +ffffffff80004850: 48 89 df mov %rbx,%rdi +ffffffff80004853: 48 8b 54 24 18 mov 0x18(%rsp),%rdx +ffffffff80004858: 48 89 c6 mov %rax,%rsi +ffffffff8000485b: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff80004861: e9 f8 f6 ff ff jmp ffffffff80003f5e + if (ctx->dec_private == true) { +ffffffff80004866: 40 84 f6 test %sil,%sil +ffffffff80004869: 0f 84 63 f6 ff ff je ffffffff80003ed2 + ctx->dec_private = false; +ffffffff8000486f: c6 43 14 00 movb $0x0,0x14(%rbx) +ffffffff80004873: e9 ea f6 ff ff jmp ffffffff80003f62 + switch (ctx->esc_values[0]) { +ffffffff80004878: 8b 43 78 mov 0x78(%rbx),%eax +ffffffff8000487b: 83 f8 05 cmp $0x5,%eax +ffffffff8000487e: 74 53 je ffffffff800048d3 +ffffffff80004880: 83 f8 06 cmp $0x6,%eax +ffffffff80004883: 0f 85 d5 f6 ff ff jne ffffffff80003f5e + if (ctx->callback != NULL) { +ffffffff80004889: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff80004890: 48 85 c0 test %rax,%rax +ffffffff80004893: 0f 84 c5 f6 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_POS_REPORT, x + 1, y + 1, 0); +ffffffff80004899: 48 8b 7c 24 10 mov 0x10(%rsp),%rdi +ffffffff8000489e: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx +ffffffff800048a3: 45 31 c0 xor %r8d,%r8d +ffffffff800048a6: be 32 00 00 00 mov $0x32,%esi +ffffffff800048ab: 48 8d 57 01 lea 0x1(%rdi),%rdx +ffffffff800048af: 48 83 c1 01 add $0x1,%rcx +ffffffff800048b3: 48 89 df mov %rbx,%rdi +ffffffff800048b6: ff d0 call *%rax +ffffffff800048b8: e9 a1 f6 ff ff jmp ffffffff80003f5e + ctx->set_cursor_pos(ctx, ctx->saved_cursor_x, ctx->saved_cursor_y); +ffffffff800048bd: 48 8b 53 50 mov 0x50(%rbx),%rdx +ffffffff800048c1: 48 8b 73 48 mov 0x48(%rbx),%rsi +ffffffff800048c5: 48 89 df mov %rbx,%rdi +ffffffff800048c8: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff800048ce: e9 8b f6 ff ff jmp ffffffff80003f5e + if (ctx->callback != NULL) { +ffffffff800048d3: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff800048da: 48 85 c0 test %rax,%rax +ffffffff800048dd: 0f 84 7b f6 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_STATUS_REPORT, 0, 0, 0); +ffffffff800048e3: 45 31 c0 xor %r8d,%r8d +ffffffff800048e6: 31 c9 xor %ecx,%ecx +ffffffff800048e8: 31 d2 xor %edx,%edx +ffffffff800048ea: be 28 00 00 00 mov $0x28,%esi +ffffffff800048ef: 48 89 df mov %rbx,%rdi +ffffffff800048f2: ff d0 call *%rax +ffffffff800048f4: e9 65 f6 ff ff jmp ffffffff80003f5e + ctx->get_cursor_pos(ctx, &ctx->saved_cursor_x, &ctx->saved_cursor_y); +ffffffff800048f9: 48 8d 53 50 lea 0x50(%rbx),%rdx +ffffffff800048fd: 48 8d 73 48 lea 0x48(%rbx),%rsi +ffffffff80004901: 48 89 df mov %rbx,%rdi +ffffffff80004904: ff 93 08 01 00 00 call *0x108(%rbx) + break; +ffffffff8000490a: e9 4f f6 ff ff jmp ffffffff80003f5e + if (ctx->esc_values[0] == 0) { +ffffffff8000490f: 83 7b 78 00 cmpl $0x0,0x78(%rbx) +ffffffff80004913: 75 07 jne ffffffff8000491c + ctx->esc_values[0] = 1; +ffffffff80004915: c7 43 78 01 00 00 00 movl $0x1,0x78(%rbx) + if (ctx->esc_values[1] == 0) { +ffffffff8000491c: 83 7b 7c 00 cmpl $0x0,0x7c(%rbx) +ffffffff80004920: 75 07 jne ffffffff80004929 + ctx->esc_values[1] = 1; +ffffffff80004922: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%rbx) + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80004929: 48 8b 93 e0 00 00 00 mov 0xe0(%rbx),%rdx + if (ctx->esc_values_i > 0) { +ffffffff80004930: 48 8b 43 40 mov 0x40(%rbx),%rax + ctx->scroll_top_margin = 0; +ffffffff80004934: 31 f6 xor %esi,%esi +ffffffff80004936: 48 89 73 68 mov %rsi,0x68(%rbx) + ctx->scroll_bottom_margin = ctx->rows; +ffffffff8000493a: 48 89 53 70 mov %rdx,0x70(%rbx) + if (ctx->esc_values_i > 0) { +ffffffff8000493e: 48 85 c0 test %rax,%rax +ffffffff80004941: 74 3d je ffffffff80004980 + ctx->scroll_top_margin = ctx->esc_values[0] - 1; +ffffffff80004943: 8b 4b 78 mov 0x78(%rbx),%ecx +ffffffff80004946: 83 e9 01 sub $0x1,%ecx + if (ctx->esc_values_i > 1) { +ffffffff80004949: 48 83 e8 01 sub $0x1,%rax + ctx->scroll_top_margin = ctx->esc_values[0] - 1; +ffffffff8000494d: 48 89 4b 68 mov %rcx,0x68(%rbx) + if (ctx->esc_values_i > 1) { +ffffffff80004951: 74 2d je ffffffff80004980 + ctx->scroll_bottom_margin = ctx->esc_values[1]; +ffffffff80004953: 8b 43 7c mov 0x7c(%rbx),%eax +ffffffff80004956: 48 89 43 70 mov %rax,0x70(%rbx) + if (ctx->scroll_top_margin >= ctx->rows +ffffffff8000495a: 48 39 d1 cmp %rdx,%rcx +ffffffff8000495d: 73 05 jae ffffffff80004964 + || ctx->scroll_bottom_margin > ctx->rows +ffffffff8000495f: 48 39 c2 cmp %rax,%rdx +ffffffff80004962: 73 28 jae ffffffff8000498c + ctx->scroll_top_margin = 0; +ffffffff80004964: 31 c9 xor %ecx,%ecx + ctx->scroll_bottom_margin = ctx->rows; +ffffffff80004966: 48 89 53 70 mov %rdx,0x70(%rbx) + ctx->scroll_top_margin = 0; +ffffffff8000496a: 48 89 4b 68 mov %rcx,0x68(%rbx) + ctx->set_cursor_pos(ctx, 0, 0); +ffffffff8000496e: 31 d2 xor %edx,%edx +ffffffff80004970: 31 f6 xor %esi,%esi +ffffffff80004972: 48 89 df mov %rbx,%rdi +ffffffff80004975: ff 93 00 01 00 00 call *0x100(%rbx) + break; +ffffffff8000497b: e9 de f5 ff ff jmp ffffffff80003f5e + if (ctx->scroll_top_margin >= ctx->rows +ffffffff80004980: 48 8b 4b 68 mov 0x68(%rbx),%rcx + || ctx->scroll_bottom_margin > ctx->rows +ffffffff80004984: 48 89 d0 mov %rdx,%rax + if (ctx->scroll_top_margin >= ctx->rows +ffffffff80004987: 48 39 d1 cmp %rdx,%rcx +ffffffff8000498a: 73 d8 jae ffffffff80004964 + || ctx->scroll_top_margin >= (ctx->scroll_bottom_margin - 1)) { +ffffffff8000498c: 48 83 e8 01 sub $0x1,%rax +ffffffff80004990: 48 39 c1 cmp %rax,%rcx +ffffffff80004993: 73 cf jae ffffffff80004964 +ffffffff80004995: eb d7 jmp ffffffff8000496e + if (!ctx->esc_values_i) +ffffffff80004997: 4c 8b 63 40 mov 0x40(%rbx),%r12 +ffffffff8000499b: 4d 85 e4 test %r12,%r12 +ffffffff8000499e: 0f 84 c8 00 00 00 je ffffffff80004a6c + for (; i < ctx->esc_values_i; i++) { +ffffffff800049a4: 4c 89 e6 mov %r12,%rsi + size_t i = 0; +ffffffff800049a7: 45 31 e4 xor %r12d,%r12d + if (ctx->esc_values[i] == 0) { +ffffffff800049aa: 4a 8d 0c a3 lea (%rbx,%r12,4),%rcx +ffffffff800049ae: 8b 51 78 mov 0x78(%rcx),%edx +ffffffff800049b1: 83 fa 6b cmp $0x6b,%edx +ffffffff800049b4: 77 71 ja ffffffff80004a27 +ffffffff800049b6: 89 d0 mov %edx,%eax +ffffffff800049b8: 3e ff 24 c5 e8 9d 00 notrack jmp *-0x7fff6218(,%rax,8) +ffffffff800049bf: 80 + if (ctx->esc_values_i == 0) { +ffffffff800049c0: 48 8b 53 40 mov 0x40(%rbx),%rdx +ffffffff800049c4: 48 85 d2 test %rdx,%rdx +ffffffff800049c7: 0f 84 91 f5 ff ff je ffffffff80003f5e + switch (c) { +ffffffff800049cd: 41 80 fc 68 cmp $0x68,%r12b +ffffffff800049d1: 0f 94 c0 sete %al + switch (ctx->esc_values[0]) { +ffffffff800049d4: 83 7b 78 04 cmpl $0x4,0x78(%rbx) +ffffffff800049d8: 0f 84 86 00 00 00 je ffffffff80004a64 + if (ctx->callback != NULL) { +ffffffff800049de: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff800049e5: 48 85 c0 test %rax,%rax +ffffffff800049e8: 0f 84 70 f5 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_MODE, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c); +ffffffff800049ee: 48 8d 4b 78 lea 0x78(%rbx),%rcx +ffffffff800049f2: 4d 0f be c4 movsbq %r12b,%r8 +ffffffff800049f6: be 46 00 00 00 mov $0x46,%esi +ffffffff800049fb: 48 89 df mov %rbx,%rdi +ffffffff800049fe: ff d0 call *%rax +ffffffff80004a00: e9 59 f5 ff ff jmp ffffffff80003f5e + ctx->current_bg = ctx->esc_values[i] - offset; +ffffffff80004a05: 48 8d 50 9c lea -0x64(%rax),%rdx + if (ctx->reverse_video) { +ffffffff80004a09: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_bg = ctx->esc_values[i] - offset; +ffffffff80004a0d: 48 89 53 60 mov %rdx,0x60(%rbx) + offset = 100; +ffffffff80004a11: ba 64 00 00 00 mov $0x64,%edx + if (ctx->reverse_video) { +ffffffff80004a16: 75 3b jne ffffffff80004a53 + ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset); +ffffffff80004a18: 48 29 d0 sub %rdx,%rax +ffffffff80004a1b: 48 89 df mov %rbx,%rdi +ffffffff80004a1e: 48 89 c6 mov %rax,%rsi +ffffffff80004a21: ff 93 28 01 00 00 call *0x128(%rbx) + continue; +ffffffff80004a27: 4d 89 e7 mov %r12,%r15 + for (; i < ctx->esc_values_i; i++) { +ffffffff80004a2a: 48 8b 73 40 mov 0x40(%rbx),%rsi +ffffffff80004a2e: 4d 8d 67 01 lea 0x1(%r15),%r12 +ffffffff80004a32: 49 39 f4 cmp %rsi,%r12 +ffffffff80004a35: 0f 83 23 f5 ff ff jae ffffffff80003f5e +ffffffff80004a3b: e9 6a ff ff ff jmp ffffffff800049aa + ctx->current_primary = ctx->esc_values[i] - offset; +ffffffff80004a40: 48 8d 50 a6 lea -0x5a(%rax),%rdx + if (ctx->reverse_video) { +ffffffff80004a44: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_primary = ctx->esc_values[i] - offset; +ffffffff80004a48: 48 89 53 58 mov %rdx,0x58(%rbx) + offset = 90; +ffffffff80004a4c: ba 5a 00 00 00 mov $0x5a,%edx + if (ctx->reverse_video) { +ffffffff80004a51: 75 c5 jne ffffffff80004a18 + ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset); +ffffffff80004a53: 48 29 d0 sub %rdx,%rax +ffffffff80004a56: 48 89 df mov %rbx,%rdi +ffffffff80004a59: 48 89 c6 mov %rax,%rsi +ffffffff80004a5c: ff 93 20 01 00 00 call *0x120(%rbx) + continue; +ffffffff80004a62: eb c3 jmp ffffffff80004a27 + ctx->insert_mode = set; return; +ffffffff80004a64: 88 43 15 mov %al,0x15(%rbx) +ffffffff80004a67: e9 f2 f4 ff ff jmp ffffffff80003f5e + if (ctx->reverse_video) { +ffffffff80004a6c: 80 7b 13 00 cmpb $0x0,0x13(%rbx) +ffffffff80004a70: 74 0d je ffffffff80004a7f + ctx->reverse_video = false; +ffffffff80004a72: c6 43 13 00 movb $0x0,0x13(%rbx) + ctx->swap_palette(ctx); +ffffffff80004a76: 48 89 df mov %rbx,%rdi +ffffffff80004a79: ff 93 78 01 00 00 call *0x178(%rbx) + ctx->set_text_bg_default(ctx); +ffffffff80004a7f: 48 89 df mov %rbx,%rdi + ctx->bold = false; +ffffffff80004a82: 66 c7 43 11 00 00 movw $0x0,0x11(%rbx) + continue; +ffffffff80004a88: 4d 89 e7 mov %r12,%r15 + ctx->current_primary = (size_t)-1; +ffffffff80004a8b: 48 c7 43 58 ff ff ff movq $0xffffffffffffffff,0x58(%rbx) +ffffffff80004a92: ff + ctx->current_bg = (size_t)-1; +ffffffff80004a93: 48 c7 43 60 ff ff ff movq $0xffffffffffffffff,0x60(%rbx) +ffffffff80004a9a: ff + ctx->set_text_bg_default(ctx); +ffffffff80004a9b: ff 93 48 01 00 00 call *0x148(%rbx) + ctx->set_text_fg_default(ctx); +ffffffff80004aa1: 48 89 df mov %rbx,%rdi +ffffffff80004aa4: ff 93 40 01 00 00 call *0x140(%rbx) + continue; +ffffffff80004aaa: e9 7b ff ff ff jmp ffffffff80004a2a + ctx->esc_values[0] -= 1; +ffffffff80004aaf: 8b 43 78 mov 0x78(%rbx),%eax + if (ctx->esc_values[0] >= ctx->rows) +ffffffff80004ab2: 48 8b 93 e0 00 00 00 mov 0xe0(%rbx),%rdx + ctx->esc_values[0] -= 1; +ffffffff80004ab9: 83 e8 01 sub $0x1,%eax +ffffffff80004abc: 89 43 78 mov %eax,0x78(%rbx) + if (ctx->esc_values[0] >= ctx->rows) +ffffffff80004abf: 48 39 d0 cmp %rdx,%rax +ffffffff80004ac2: 72 06 jb ffffffff80004aca + ctx->esc_values[0] = ctx->rows - 1; +ffffffff80004ac4: 83 ea 01 sub $0x1,%edx +ffffffff80004ac7: 89 53 78 mov %edx,0x78(%rbx) + ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]); +ffffffff80004aca: 8b 53 78 mov 0x78(%rbx),%edx +ffffffff80004acd: e9 7e f4 ff ff jmp ffffffff80003f50 + if (ctx->callback != NULL) { +ffffffff80004ad2: 48 8b 83 a8 01 00 00 mov 0x1a8(%rbx),%rax +ffffffff80004ad9: 48 85 c0 test %rax,%rax +ffffffff80004adc: 0f 84 7c f4 ff ff je ffffffff80003f5e + ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0); +ffffffff80004ae2: 45 31 c0 xor %r8d,%r8d +ffffffff80004ae5: 31 c9 xor %ecx,%ecx +ffffffff80004ae7: 31 d2 xor %edx,%edx +ffffffff80004ae9: be 1e 00 00 00 mov $0x1e,%esi +ffffffff80004aee: 48 89 df mov %rbx,%rdi +ffffffff80004af1: ff d0 call *%rax +ffffffff80004af3: e9 66 f4 ff ff jmp ffffffff80003f5e + if (ctx->reverse_video) { +ffffffff80004af8: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_bg = (size_t)-1; +ffffffff80004afc: 48 c7 43 60 ff ff ff movq $0xffffffffffffffff,0x60(%rbx) +ffffffff80004b03: ff + if (ctx->reverse_video) { +ffffffff80004b04: 74 09 je ffffffff80004b0f + ctx->swap_palette(ctx); +ffffffff80004b06: 48 89 df mov %rbx,%rdi +ffffffff80004b09: ff 93 78 01 00 00 call *0x178(%rbx) + if (!ctx->bg_bold) { +ffffffff80004b0f: 80 7b 12 00 cmpb $0x0,0x12(%rbx) + ctx->set_text_bg_default(ctx); +ffffffff80004b13: 48 89 df mov %rbx,%rdi + if (!ctx->bg_bold) { +ffffffff80004b16: 75 77 jne ffffffff80004b8f + ctx->set_text_bg_default(ctx); +ffffffff80004b18: ff 93 48 01 00 00 call *0x148(%rbx) + if (ctx->reverse_video) { +ffffffff80004b1e: 80 7b 13 00 cmpb $0x0,0x13(%rbx) +ffffffff80004b22: 0f 84 ff fe ff ff je ffffffff80004a27 + ctx->swap_palette(ctx); +ffffffff80004b28: 48 89 df mov %rbx,%rdi +ffffffff80004b2b: ff 93 78 01 00 00 call *0x178(%rbx) +ffffffff80004b31: e9 f1 fe ff ff jmp ffffffff80004a27 + ctx->current_bg = ctx->esc_values[i] - offset; +ffffffff80004b36: 48 8d 50 d8 lea -0x28(%rax),%rdx + if (ctx->reverse_video) { +ffffffff80004b3a: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_bg = ctx->esc_values[i] - offset; +ffffffff80004b3e: 48 89 53 60 mov %rdx,0x60(%rbx) + if (ctx->reverse_video) { +ffffffff80004b42: 75 53 jne ffffffff80004b97 + || (ctx->bg_bold && !ctx->reverse_video)) { +ffffffff80004b44: 80 7b 12 00 cmpb $0x0,0x12(%rbx) +ffffffff80004b48: ba 28 00 00 00 mov $0x28,%edx +ffffffff80004b4d: 0f 85 c5 fe ff ff jne ffffffff80004a18 + ctx->set_text_bg(ctx, ctx->esc_values[i] - offset); +ffffffff80004b53: 48 29 d0 sub %rdx,%rax +ffffffff80004b56: 48 89 df mov %rbx,%rdi +ffffffff80004b59: 48 89 c6 mov %rax,%rsi +ffffffff80004b5c: ff 93 18 01 00 00 call *0x118(%rbx) +ffffffff80004b62: e9 c0 fe ff ff jmp ffffffff80004a27 + if (ctx->reverse_video) { +ffffffff80004b67: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + ctx->current_primary = (size_t)-1; +ffffffff80004b6b: 48 c7 43 58 ff ff ff movq $0xffffffffffffffff,0x58(%rbx) +ffffffff80004b72: ff + if (ctx->reverse_video) { +ffffffff80004b73: 74 09 je ffffffff80004b7e + ctx->swap_palette(ctx); +ffffffff80004b75: 48 89 df mov %rbx,%rdi +ffffffff80004b78: ff 93 78 01 00 00 call *0x178(%rbx) + if (!ctx->bold) { +ffffffff80004b7e: 80 7b 11 00 cmpb $0x0,0x11(%rbx) + ctx->set_text_fg_default(ctx); +ffffffff80004b82: 48 89 df mov %rbx,%rdi + if (!ctx->bold) { +ffffffff80004b85: 75 33 jne ffffffff80004bba + ctx->set_text_fg_default(ctx); +ffffffff80004b87: ff 93 40 01 00 00 call *0x140(%rbx) +ffffffff80004b8d: eb 8f jmp ffffffff80004b1e + ctx->set_text_bg_default_bright(ctx); +ffffffff80004b8f: ff 93 58 01 00 00 call *0x158(%rbx) +ffffffff80004b95: eb 87 jmp ffffffff80004b1e + || (ctx->bg_bold && ctx->reverse_video)) { +ffffffff80004b97: 80 7b 12 00 cmpb $0x0,0x12(%rbx) +ffffffff80004b9b: ba 28 00 00 00 mov $0x28,%edx +ffffffff80004ba0: 0f 85 ad fe ff ff jne ffffffff80004a53 + ctx->set_text_fg(ctx, ctx->esc_values[i] - offset); +ffffffff80004ba6: 48 29 d0 sub %rdx,%rax +ffffffff80004ba9: 48 89 df mov %rbx,%rdi +ffffffff80004bac: 48 89 c6 mov %rax,%rsi +ffffffff80004baf: ff 93 10 01 00 00 call *0x110(%rbx) +ffffffff80004bb5: e9 6d fe ff ff jmp ffffffff80004a27 + ctx->set_text_fg_default_bright(ctx); +ffffffff80004bba: ff 93 50 01 00 00 call *0x150(%rbx) + if (ctx->reverse_video) { +ffffffff80004bc0: e9 59 ff ff ff jmp ffffffff80004b1e + if (ctx->current_primary != (size_t)-1) { +ffffffff80004bc5: 48 8b 73 58 mov 0x58(%rbx),%rsi + if (!ctx->reverse_video) { +ffffffff80004bc9: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->bold = false; +ffffffff80004bcd: c6 43 11 00 movb $0x0,0x11(%rbx) + ctx->set_text_fg(ctx, ctx->current_primary); +ffffffff80004bd1: 48 89 df mov %rbx,%rdi + if (ctx->current_primary != (size_t)-1) { +ffffffff80004bd4: 48 83 fe ff cmp $0xffffffffffffffff,%rsi +ffffffff80004bd8: 74 26 je ffffffff80004c00 + if (!ctx->reverse_video) { +ffffffff80004bda: 84 c0 test %al,%al +ffffffff80004bdc: 0f 85 7a ff ff ff jne ffffffff80004b5c +ffffffff80004be2: eb cb jmp ffffffff80004baf + if (!ctx->reverse_video) { +ffffffff80004be4: 80 7b 13 00 cmpb $0x0,0x13(%rbx) +ffffffff80004be8: 0f 85 39 fe ff ff jne ffffffff80004a27 + ctx->reverse_video = true; +ffffffff80004bee: c6 43 13 01 movb $0x1,0x13(%rbx) + ctx->swap_palette(ctx); +ffffffff80004bf2: 48 89 df mov %rbx,%rdi +ffffffff80004bf5: ff 93 78 01 00 00 call *0x178(%rbx) +ffffffff80004bfb: e9 27 fe ff ff jmp ffffffff80004a27 + if (!ctx->reverse_video) { +ffffffff80004c00: 84 c0 test %al,%al +ffffffff80004c02: 75 53 jne ffffffff80004c57 + ctx->set_text_fg_default(ctx); +ffffffff80004c04: ff 93 40 01 00 00 call *0x140(%rbx) +ffffffff80004c0a: e9 18 fe ff ff jmp ffffffff80004a27 + if (ctx->current_bg != (size_t)-1) { +ffffffff80004c0f: 48 8b 73 60 mov 0x60(%rbx),%rsi + if (!ctx->reverse_video) { +ffffffff80004c13: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->bg_bold = true; +ffffffff80004c17: c6 43 12 01 movb $0x1,0x12(%rbx) + ctx->set_text_bg_bright(ctx, ctx->current_bg); +ffffffff80004c1b: 48 89 df mov %rbx,%rdi + if (ctx->current_bg != (size_t)-1) { +ffffffff80004c1e: 48 83 fe ff cmp $0xffffffffffffffff,%rsi +ffffffff80004c22: 74 3e je ffffffff80004c62 + if (!ctx->reverse_video) { +ffffffff80004c24: 84 c0 test %al,%al +ffffffff80004c26: 0f 85 30 fe ff ff jne ffffffff80004a5c +ffffffff80004c2c: e9 f0 fd ff ff jmp ffffffff80004a21 + if (ctx->current_primary != (size_t)-1) { +ffffffff80004c31: 48 8b 73 58 mov 0x58(%rbx),%rsi + if (!ctx->reverse_video) { +ffffffff80004c35: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->bold = true; +ffffffff80004c39: c6 43 11 01 movb $0x1,0x11(%rbx) + ctx->set_text_fg_bright(ctx, ctx->current_primary); +ffffffff80004c3d: 48 89 df mov %rbx,%rdi + if (ctx->current_primary != (size_t)-1) { +ffffffff80004c40: 48 83 fe ff cmp $0xffffffffffffffff,%rsi +ffffffff80004c44: 74 2b je ffffffff80004c71 + if (!ctx->reverse_video) { +ffffffff80004c46: 84 c0 test %al,%al +ffffffff80004c48: 0f 85 d3 fd ff ff jne ffffffff80004a21 +ffffffff80004c4e: e9 09 fe ff ff jmp ffffffff80004a5c + if (!ctx->reverse_video) { +ffffffff80004c53: 84 c0 test %al,%al +ffffffff80004c55: 75 ad jne ffffffff80004c04 + ctx->set_text_bg_default(ctx); +ffffffff80004c57: ff 93 48 01 00 00 call *0x148(%rbx) +ffffffff80004c5d: e9 c5 fd ff ff jmp ffffffff80004a27 + if (!ctx->reverse_video) { +ffffffff80004c62: 84 c0 test %al,%al +ffffffff80004c64: 75 0f jne ffffffff80004c75 + ctx->set_text_bg_default_bright(ctx); +ffffffff80004c66: ff 93 58 01 00 00 call *0x158(%rbx) +ffffffff80004c6c: e9 b6 fd ff ff jmp ffffffff80004a27 + if (!ctx->reverse_video) { +ffffffff80004c71: 84 c0 test %al,%al +ffffffff80004c73: 75 f1 jne ffffffff80004c66 + ctx->set_text_fg_default_bright(ctx); +ffffffff80004c75: ff 93 50 01 00 00 call *0x150(%rbx) +ffffffff80004c7b: e9 a7 fd ff ff jmp ffffffff80004a27 + i++; +ffffffff80004c80: 4d 8d 7c 24 01 lea 0x1(%r12),%r15 + if (i >= ctx->esc_values_i) { +ffffffff80004c85: 49 39 f7 cmp %rsi,%r15 +ffffffff80004c88: 0f 83 d0 f2 ff ff jae ffffffff80003f5e + switch (ctx->esc_values[i]) { +ffffffff80004c8e: 8b 41 7c mov 0x7c(%rcx),%eax +ffffffff80004c91: 83 f8 02 cmp $0x2,%eax +ffffffff80004c94: 0f 84 a3 00 00 00 je ffffffff80004d3d +ffffffff80004c9a: 83 f8 05 cmp $0x5,%eax +ffffffff80004c9d: 0f 85 87 fd ff ff jne ffffffff80004a2a + if (i + 1 >= ctx->esc_values_i) { +ffffffff80004ca3: 4d 8d 7c 24 02 lea 0x2(%r12),%r15 +ffffffff80004ca8: 49 39 f7 cmp %rsi,%r15 +ffffffff80004cab: 0f 83 ad f2 ff ff jae ffffffff80003f5e + uint32_t col = ctx->esc_values[i + 1]; +ffffffff80004cb1: 8b 81 80 00 00 00 mov 0x80(%rcx),%eax + if (col < 8) { +ffffffff80004cb7: 83 f8 07 cmp $0x7,%eax +ffffffff80004cba: 77 46 ja ffffffff80004d02 + (fg ? ctx->set_text_fg : ctx->set_text_bg)(ctx, col); +ffffffff80004cbc: 48 8b 8b 18 01 00 00 mov 0x118(%rbx),%rcx +ffffffff80004cc3: 83 fa 26 cmp $0x26,%edx +ffffffff80004cc6: 89 c6 mov %eax,%esi +ffffffff80004cc8: 48 89 df mov %rbx,%rdi +ffffffff80004ccb: 48 0f 44 8b 10 01 00 cmove 0x110(%rbx),%rcx +ffffffff80004cd2: 00 +ffffffff80004cd3: ff d1 call *%rcx +ffffffff80004cd5: e9 50 fd ff ff jmp ffffffff80004a2a + ctx->current_primary = ctx->esc_values[i] - offset; +ffffffff80004cda: 48 8d 50 e2 lea -0x1e(%rax),%rdx + if (ctx->reverse_video) { +ffffffff80004cde: 80 7b 13 00 cmpb $0x0,0x13(%rbx) + if ((ctx->bold && ctx->reverse_video) +ffffffff80004ce2: 0f b6 4b 11 movzbl 0x11(%rbx),%ecx + ctx->current_primary = ctx->esc_values[i] - offset; +ffffffff80004ce6: 48 89 53 58 mov %rdx,0x58(%rbx) + if (ctx->reverse_video) { +ffffffff80004cea: 0f 85 91 00 00 00 jne ffffffff80004d81 + offset = 30; +ffffffff80004cf0: ba 1e 00 00 00 mov $0x1e,%edx + if ((ctx->bold && !ctx->reverse_video) +ffffffff80004cf5: 84 c9 test %cl,%cl +ffffffff80004cf7: 0f 84 a9 fe ff ff je ffffffff80004ba6 +ffffffff80004cfd: e9 51 fd ff ff jmp ffffffff80004a53 + } else if (col < 16) { +ffffffff80004d02: 83 f8 0f cmp $0xf,%eax +ffffffff80004d05: 0f 87 ae 00 00 00 ja ffffffff80004db9 + (fg ? ctx->set_text_fg_bright : ctx->set_text_bg_bright)(ctx, col - 8); +ffffffff80004d0b: 48 8b 8b 28 01 00 00 mov 0x128(%rbx),%rcx +ffffffff80004d12: 83 fa 26 cmp $0x26,%edx +ffffffff80004d15: 8d 70 f8 lea -0x8(%rax),%esi +ffffffff80004d18: 48 89 df mov %rbx,%rdi +ffffffff80004d1b: 48 0f 44 8b 20 01 00 cmove 0x120(%rbx),%rcx +ffffffff80004d22: 00 +ffffffff80004d23: ff d1 call *%rcx +ffffffff80004d25: e9 00 fd ff ff jmp ffffffff80004a2a + if (ctx->reverse_video) { +ffffffff80004d2a: 80 7b 13 00 cmpb $0x0,0x13(%rbx) +ffffffff80004d2e: 0f 84 f3 fc ff ff je ffffffff80004a27 + ctx->reverse_video = false; +ffffffff80004d34: c6 43 13 00 movb $0x0,0x13(%rbx) +ffffffff80004d38: e9 eb fd ff ff jmp ffffffff80004b28 + if (i + 3 >= ctx->esc_values_i) { +ffffffff80004d3d: 4d 8d 7c 24 04 lea 0x4(%r12),%r15 +ffffffff80004d42: 49 39 f7 cmp %rsi,%r15 +ffffffff80004d45: 0f 83 13 f2 ff ff jae ffffffff80003f5e + rgb_value |= ctx->esc_values[i + 1] << 16; +ffffffff80004d4b: 8b b1 80 00 00 00 mov 0x80(%rcx),%esi + rgb_value |= ctx->esc_values[i + 2] << 8; +ffffffff80004d51: 8b 81 84 00 00 00 mov 0x84(%rcx),%eax + rgb_value |= ctx->esc_values[i + 1] << 16; +ffffffff80004d57: c1 e6 10 shl $0x10,%esi + rgb_value |= ctx->esc_values[i + 2] << 8; +ffffffff80004d5a: c1 e0 08 shl $0x8,%eax +ffffffff80004d5d: 09 c6 or %eax,%esi + rgb_value |= ctx->esc_values[i + 3]; +ffffffff80004d5f: 0b b1 88 00 00 00 or 0x88(%rcx),%esi + (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value); +ffffffff80004d65: 48 8b 83 38 01 00 00 mov 0x138(%rbx),%rax +ffffffff80004d6c: 83 fa 26 cmp $0x26,%edx +ffffffff80004d6f: 48 89 df mov %rbx,%rdi +ffffffff80004d72: 48 0f 44 83 30 01 00 cmove 0x130(%rbx),%rax +ffffffff80004d79: 00 +ffffffff80004d7a: ff d0 call *%rax +ffffffff80004d7c: e9 a9 fc ff ff jmp ffffffff80004a2a + offset = 30; +ffffffff80004d81: ba 1e 00 00 00 mov $0x1e,%edx + if ((ctx->bold && ctx->reverse_video) +ffffffff80004d86: 84 c9 test %cl,%cl +ffffffff80004d88: 0f 85 8a fc ff ff jne ffffffff80004a18 +ffffffff80004d8e: e9 c0 fd ff ff jmp ffffffff80004b53 + if (ctx->current_bg != (size_t)-1) { +ffffffff80004d93: 48 8b 73 60 mov 0x60(%rbx),%rsi + if (!ctx->reverse_video) { +ffffffff80004d97: 0f b6 43 13 movzbl 0x13(%rbx),%eax + ctx->bg_bold = false; +ffffffff80004d9b: c6 43 12 00 movb $0x0,0x12(%rbx) + ctx->set_text_bg(ctx, ctx->current_bg); +ffffffff80004d9f: 48 89 df mov %rbx,%rdi + if (ctx->current_bg != (size_t)-1) { +ffffffff80004da2: 48 83 fe ff cmp $0xffffffffffffffff,%rsi +ffffffff80004da6: 0f 84 a7 fe ff ff je ffffffff80004c53 + if (!ctx->reverse_video) { +ffffffff80004dac: 84 c0 test %al,%al +ffffffff80004dae: 0f 85 fb fd ff ff jne ffffffff80004baf +ffffffff80004db4: e9 a3 fd ff ff jmp ffffffff80004b5c + } else if (col < 256) { +ffffffff80004db9: 3d ff 00 00 00 cmp $0xff,%eax +ffffffff80004dbe: 0f 87 66 fc ff ff ja ffffffff80004a2a + uint32_t rgb_value = col256[col - 16]; +ffffffff80004dc4: 83 e8 10 sub $0x10,%eax +ffffffff80004dc7: 8b 34 85 e0 a5 00 80 mov -0x7fff5a20(,%rax,4),%esi +ffffffff80004dce: eb 95 jmp ffffffff80004d65 + +ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>: +ffffffff80004dd0: f3 0f 1e fa endbr64 +ffffffff80004dd4: 55 push %rbp +ffffffff80004dd5: 48 89 f5 mov %rsi,%rbp +ffffffff80004dd8: 53 push %rbx +ffffffff80004dd9: 48 89 fb mov %rdi,%rbx + #if defined (__x86_64__) +ffffffff80004ddc: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80004de3: 48 83 ec 08 sub $0x8,%rsp + #if defined (__x86_64__) +ffffffff80004de7: e8 94 21 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004dec: 48 89 ef mov %rbp,%rdi +ffffffff80004def: e8 8c 21 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004df4: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi +ffffffff80004dfb: e8 80 21 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004e00: 48 83 c4 08 add $0x8,%rsp +ffffffff80004e04: 48 89 d8 mov %rbx,%rax +ffffffff80004e07: 5b pop %rbx +ffffffff80004e08: 5d pop %rbp +ffffffff80004e09: c3 ret +ffffffff80004e0a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>: +ffffffff80004e10: f3 0f 1e fa endbr64 +ffffffff80004e14: 55 push %rbp +ffffffff80004e15: 48 89 fd mov %rdi,%rbp + #if defined (__x86_64__) +ffffffff80004e18: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80004e1f: 53 push %rbx +ffffffff80004e20: 89 f3 mov %esi,%ebx +ffffffff80004e22: 48 83 ec 08 sub $0x8,%rsp + #if defined (__x86_64__) +ffffffff80004e26: e8 55 21 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004e2b: 8b 35 c7 62 00 00 mov 0x62c7(%rip),%esi # ffffffff8000b0f8 +ffffffff80004e31: 0f b6 fb movzbl %bl,%edi +ffffffff80004e34: e8 67 1a 00 00 call ffffffff800068a0 <_ZN3Lib11int2basestrEim> +ffffffff80004e39: 48 89 c7 mov %rax,%rdi +ffffffff80004e3c: e8 3f 21 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + #if defined (__x86_64__) +ffffffff80004e41: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi +ffffffff80004e48: e8 33 21 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004e4d: 48 83 c4 08 add $0x8,%rsp +ffffffff80004e51: 48 89 e8 mov %rbp,%rax +ffffffff80004e54: 5b pop %rbx +ffffffff80004e55: 5d pop %rbp +ffffffff80004e56: c3 ret +ffffffff80004e57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80004e5e: 00 00 + +ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>: +ffffffff80004e60: f3 0f 1e fa endbr64 +ffffffff80004e64: 55 push %rbp +ffffffff80004e65: 48 89 f5 mov %rsi,%rbp +ffffffff80004e68: 53 push %rbx +ffffffff80004e69: 48 89 fb mov %rdi,%rbx + #if defined (__x86_64__) +ffffffff80004e6c: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80004e73: 48 83 ec 08 sub $0x8,%rsp + #if defined (__x86_64__) +ffffffff80004e77: e8 04 21 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004e7c: 8b 35 76 62 00 00 mov 0x6276(%rip),%esi # ffffffff8000b0f8 +ffffffff80004e82: 48 89 ef mov %rbp,%rdi +ffffffff80004e85: e8 26 1b 00 00 call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80004e8a: 48 89 c7 mov %rax,%rdi +ffffffff80004e8d: e8 ee 20 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + #if defined (__x86_64__) +ffffffff80004e92: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi +ffffffff80004e99: e8 e2 20 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004e9e: 48 83 c4 08 add $0x8,%rsp +ffffffff80004ea2: 48 89 d8 mov %rbx,%rax +ffffffff80004ea5: 5b pop %rbx +ffffffff80004ea6: 5d pop %rbp +ffffffff80004ea7: c3 ret +ffffffff80004ea8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80004eaf: 00 + +ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>: +void Panic(const char *meditationString, System::PanicFrame* frame) { +ffffffff80004eb0: f3 0f 1e fa endbr64 +ffffffff80004eb4: 41 54 push %r12 +ffffffff80004eb6: 55 push %rbp +ffffffff80004eb7: 48 89 fd mov %rdi,%rbp + kerr << "\nGuru Meditation" << "\n" << "\n"; +ffffffff80004eba: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +void Panic(const char *meditationString, System::PanicFrame* frame) { +ffffffff80004ec1: 53 push %rbx +ffffffff80004ec2: 48 89 f3 mov %rsi,%rbx + kerr << "\nGuru Meditation" << "\n" << "\n"; +ffffffff80004ec5: 48 c7 c6 af a9 00 80 mov $0xffffffff8000a9af,%rsi +ffffffff80004ecc: e8 ff fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004ed1: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80004ed8: 48 89 c7 mov %rax,%rdi +ffffffff80004edb: e8 f0 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004ee0: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80004ee7: 48 89 c7 mov %rax,%rdi +ffffffff80004eea: e8 e1 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "MeditationString: " << meditationString << Kt::newline; +ffffffff80004eef: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80004ef6: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff80004efd: e8 ce fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f02: 48 c7 c6 c4 a9 00 80 mov $0xffffffff8000a9c4,%rsi +ffffffff80004f09: 48 89 c7 mov %rax,%rdi +ffffffff80004f0c: e8 bf fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f11: 48 89 ee mov %rbp,%rsi +ffffffff80004f14: 48 89 c7 mov %rax,%rdi +ffffffff80004f17: e8 b4 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + base streamBaseType = base::dec; + + // C++ streaming operator like cout + friend KernelOutStream &operator<<(KernelOutStream &t, const char *string) + { + Print(string); +ffffffff80004f1c: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80004f23: e8 58 20 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + } + + // C++ streaming operator like cout + friend KernelOutStream &operator<<(KernelOutStream &t, const char chr) + { + Putchar(chr); +ffffffff80004f28: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80004f2d: e8 1e 20 00 00 call ffffffff80006f50 <_ZN2Kt7PutcharEc> + Print(string); +ffffffff80004f32: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi +ffffffff80004f39: e8 42 20 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + if (frame != nullptr) { +ffffffff80004f3e: 48 85 db test %rbx,%rbx +ffffffff80004f41: 0f 84 b9 02 00 00 je ffffffff80005200 <_Z5PanicPKcPN6System10PanicFrameE+0x350> + kerr << "\t" << "InterruptVector: " << "0x" << base::hex << frame->InterruptVector << "\n"; +ffffffff80004f47: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80004f4e: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff80004f55: e8 76 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f5a: 48 c7 c6 d7 a9 00 80 mov $0xffffffff8000a9d7,%rsi +ffffffff80004f61: 48 89 c7 mov %rax,%rdi +ffffffff80004f64: e8 67 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f69: 48 c7 c6 04 ad 00 80 mov $0xffffffff8000ad04,%rsi +ffffffff80004f70: 48 89 c7 mov %rax,%rdi +ffffffff80004f73: e8 58 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004f78: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80004f7f: 48 89 c5 mov %rax,%rbp +ffffffff80004f82: e8 f9 1f 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004f87: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + return t; + } + + friend KernelOutStream &operator<<(KernelOutStream &t, base newBase) + { + t.streamBaseType = newBase; +ffffffff80004f8e: c7 05 60 61 00 00 10 movl $0x10,0x6160(%rip) # ffffffff8000b0f8 +ffffffff80004f95: 00 00 00 + Print(string); +ffffffff80004f98: e8 e3 1f 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80004f9d: 0f b6 73 28 movzbl 0x28(%rbx),%esi +ffffffff80004fa1: 48 89 ef mov %rbp,%rdi +ffffffff80004fa4: e8 67 fe ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff80004fa9: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80004fb0: 48 89 c7 mov %rax,%rdi +ffffffff80004fb3: e8 18 fe ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + if (frame->InterruptVector == 0xE) { // In case of #PF the CPU pushes an error code to the frame +ffffffff80004fb8: 0f b6 43 28 movzbl 0x28(%rbx),%eax +ffffffff80004fbc: 3c 0e cmp $0xe,%al +ffffffff80004fbe: 0f 84 40 02 00 00 je ffffffff80005204 <_Z5PanicPKcPN6System10PanicFrameE+0x354> + else if (frame->InterruptVector == 0xD) { +ffffffff80004fc4: 3c 0d cmp $0xd,%al +ffffffff80004fc6: 0f 84 7f 05 00 00 je ffffffff8000554b <_Z5PanicPKcPN6System10PanicFrameE+0x69b> + kerr << "\t" << "InstructionPointer: " << "0x" << base::hex << frame->IP << "\n"; +ffffffff80004fcc: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80004fd3: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff80004fda: e8 f1 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004fdf: 48 c7 c6 9d aa 00 80 mov $0xffffffff8000aa9d,%rsi +ffffffff80004fe6: 48 89 c7 mov %rax,%rdi +ffffffff80004fe9: e8 e2 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004fee: 48 c7 c6 04 ad 00 80 mov $0xffffffff8000ad04,%rsi +ffffffff80004ff5: 48 89 c7 mov %rax,%rdi +ffffffff80004ff8: e8 d3 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80004ffd: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005004: 48 89 c5 mov %rax,%rbp +ffffffff80005007: e8 74 1f 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000500c: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005013: c7 05 db 60 00 00 10 movl $0x10,0x60db(%rip) # ffffffff8000b0f8 +ffffffff8000501a: 00 00 00 + Print(string); +ffffffff8000501d: e8 5e 1f 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005022: 48 8b 33 mov (%rbx),%rsi +ffffffff80005025: 48 89 ef mov %rbp,%rdi +ffffffff80005028: e8 33 fe ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff8000502d: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80005034: 48 89 c7 mov %rax,%rdi +ffffffff80005037: e8 94 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "CodeSegment: " << "0x" << base::hex << frame->CS << "\n"; +ffffffff8000503c: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80005043: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff8000504a: e8 81 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000504f: 48 c7 c6 b2 aa 00 80 mov $0xffffffff8000aab2,%rsi +ffffffff80005056: 48 89 c7 mov %rax,%rdi +ffffffff80005059: e8 72 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000505e: 48 c7 c6 04 ad 00 80 mov $0xffffffff8000ad04,%rsi +ffffffff80005065: 48 89 c7 mov %rax,%rdi +ffffffff80005068: e8 63 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000506d: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005074: 48 89 c5 mov %rax,%rbp +ffffffff80005077: e8 04 1f 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000507c: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005083: c7 05 6b 60 00 00 10 movl $0x10,0x606b(%rip) # ffffffff8000b0f8 +ffffffff8000508a: 00 00 00 + Print(string); +ffffffff8000508d: e8 ee 1e 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005092: 48 8b 73 08 mov 0x8(%rbx),%rsi +ffffffff80005096: 48 89 ef mov %rbp,%rdi +ffffffff80005099: e8 c2 fd ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff8000509e: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff800050a5: 48 89 c7 mov %rax,%rdi +ffffffff800050a8: e8 23 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "Flags: " << "0x" << base::hex << frame->Flags << "\n"; +ffffffff800050ad: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff800050b4: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff800050bb: e8 10 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800050c0: 48 c7 c6 c0 aa 00 80 mov $0xffffffff8000aac0,%rsi +ffffffff800050c7: 48 89 c7 mov %rax,%rdi +ffffffff800050ca: e8 01 fd ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800050cf: 48 c7 c6 04 ad 00 80 mov $0xffffffff8000ad04,%rsi +ffffffff800050d6: 48 89 c7 mov %rax,%rdi +ffffffff800050d9: e8 f2 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800050de: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff800050e5: 48 89 c5 mov %rax,%rbp +ffffffff800050e8: e8 93 1e 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800050ed: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff800050f4: c7 05 fa 5f 00 00 10 movl $0x10,0x5ffa(%rip) # ffffffff8000b0f8 +ffffffff800050fb: 00 00 00 + Print(string); +ffffffff800050fe: e8 7d 1e 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005103: 48 8b 73 10 mov 0x10(%rbx),%rsi +ffffffff80005107: 48 89 ef mov %rbp,%rdi +ffffffff8000510a: e8 51 fd ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff8000510f: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80005116: 48 89 c7 mov %rax,%rdi +ffffffff80005119: e8 b2 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "StackPointer: " << "0x" << base::hex << frame->SP << "\n"; +ffffffff8000511e: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80005125: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff8000512c: e8 9f fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005131: 48 c7 c6 c8 aa 00 80 mov $0xffffffff8000aac8,%rsi +ffffffff80005138: 48 89 c7 mov %rax,%rdi +ffffffff8000513b: e8 90 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005140: 48 c7 c6 04 ad 00 80 mov $0xffffffff8000ad04,%rsi +ffffffff80005147: 48 89 c7 mov %rax,%rdi +ffffffff8000514a: e8 81 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000514f: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005156: 48 89 c5 mov %rax,%rbp +ffffffff80005159: e8 22 1e 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000515e: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005165: c7 05 89 5f 00 00 10 movl $0x10,0x5f89(%rip) # ffffffff8000b0f8 +ffffffff8000516c: 00 00 00 + Print(string); +ffffffff8000516f: e8 0c 1e 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005174: 48 8b 73 18 mov 0x18(%rbx),%rsi +ffffffff80005178: 48 89 ef mov %rbp,%rdi +ffffffff8000517b: e8 e0 fc ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff80005180: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80005187: 48 89 c7 mov %rax,%rdi +ffffffff8000518a: e8 41 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "StackSegment: " << "0x" << base::hex << frame->SS << "\n"; +ffffffff8000518f: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80005196: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff8000519d: e8 2e fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800051a2: 48 c7 c6 d7 aa 00 80 mov $0xffffffff8000aad7,%rsi +ffffffff800051a9: 48 89 c7 mov %rax,%rdi +ffffffff800051ac: e8 1f fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800051b1: 48 c7 c6 04 ad 00 80 mov $0xffffffff8000ad04,%rsi +ffffffff800051b8: 48 89 c7 mov %rax,%rdi +ffffffff800051bb: e8 10 fc ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800051c0: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff800051c7: 48 89 c5 mov %rax,%rbp +ffffffff800051ca: e8 b1 1d 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800051cf: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff800051d6: c7 05 18 5f 00 00 10 movl $0x10,0x5f18(%rip) # ffffffff8000b0f8 +ffffffff800051dd: 00 00 00 + Print(string); +ffffffff800051e0: e8 9b 1d 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800051e5: 48 8b 73 20 mov 0x20(%rbx),%rsi +ffffffff800051e9: 48 89 ef mov %rbp,%rdi +ffffffff800051ec: e8 6f fc ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff800051f1: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff800051f8: 48 89 c7 mov %rax,%rdi +ffffffff800051fb: e8 d0 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + asm ("cli"); +ffffffff80005200: fa cli + asm ("hlt"); +ffffffff80005201: f4 hlt + while (true) { +ffffffff80005202: eb fc jmp ffffffff80005200 <_Z5PanicPKcPN6System10PanicFrameE+0x350> + kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n"; +ffffffff80005204: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff8000520b: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi + frame = (System::PanicFrame*)&pf_frame->IP; +ffffffff80005212: 48 8d 6b 08 lea 0x8(%rbx),%rbp + kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n"; +ffffffff80005216: e8 b5 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000521b: 48 c7 c6 e9 a9 00 80 mov $0xffffffff8000a9e9,%rsi +ffffffff80005222: 48 89 c7 mov %rax,%rdi +ffffffff80005225: e8 a6 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000522a: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005231: 49 89 c4 mov %rax,%r12 +ffffffff80005234: e8 47 1d 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005239: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005240: c7 05 ae 5e 00 00 0a movl $0xa,0x5eae(%rip) # ffffffff8000b0f8 +ffffffff80005247: 00 00 00 + Print(string); +ffffffff8000524a: e8 31 1d 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000524f: 0f b6 33 movzbl (%rbx),%esi +ffffffff80005252: 4c 89 e7 mov %r12,%rdi +ffffffff80005255: 83 e6 01 and $0x1,%esi +ffffffff80005258: e8 b3 fb ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff8000525d: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80005264: 48 89 c7 mov %rax,%rdi +ffffffff80005267: e8 64 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultWrite: " << base::dec << pf_frame->PageFaultError.Write << "\n"; +ffffffff8000526c: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80005273: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff8000527a: e8 51 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000527f: 48 c7 c6 fc a9 00 80 mov $0xffffffff8000a9fc,%rsi +ffffffff80005286: 48 89 c7 mov %rax,%rdi +ffffffff80005289: e8 42 fb ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000528e: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005295: 49 89 c4 mov %rax,%r12 +ffffffff80005298: e8 e3 1c 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000529d: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff800052a4: c7 05 4a 5e 00 00 0a movl $0xa,0x5e4a(%rip) # ffffffff8000b0f8 +ffffffff800052ab: 00 00 00 + Print(string); +ffffffff800052ae: e8 cd 1c 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800052b3: 0f b6 33 movzbl (%rbx),%esi +ffffffff800052b6: 4c 89 e7 mov %r12,%rdi +ffffffff800052b9: 40 d0 ee shr $1,%sil +ffffffff800052bc: 83 e6 01 and $0x1,%esi +ffffffff800052bf: e8 4c fb ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff800052c4: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff800052cb: 48 89 c7 mov %rax,%rdi +ffffffff800052ce: e8 fd fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultUser: " << base::dec << pf_frame->PageFaultError.User << "\n"; +ffffffff800052d3: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff800052da: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff800052e1: e8 ea fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800052e6: 48 c7 c6 0d aa 00 80 mov $0xffffffff8000aa0d,%rsi +ffffffff800052ed: 48 89 c7 mov %rax,%rdi +ffffffff800052f0: e8 db fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800052f5: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff800052fc: 49 89 c4 mov %rax,%r12 +ffffffff800052ff: e8 7c 1c 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005304: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff8000530b: c7 05 e3 5d 00 00 0a movl $0xa,0x5de3(%rip) # ffffffff8000b0f8 +ffffffff80005312: 00 00 00 + Print(string); +ffffffff80005315: e8 66 1c 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000531a: 0f b6 33 movzbl (%rbx),%esi +ffffffff8000531d: 4c 89 e7 mov %r12,%rdi +ffffffff80005320: 40 c0 ee 02 shr $0x2,%sil +ffffffff80005324: 83 e6 01 and $0x1,%esi +ffffffff80005327: e8 e4 fa ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff8000532c: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80005333: 48 89 c7 mov %rax,%rdi +ffffffff80005336: e8 95 fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultReservedWrite: " << base::dec << pf_frame->PageFaultError.ReservedWrite << "\n"; +ffffffff8000533b: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80005342: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff80005349: e8 82 fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000534e: 48 c7 c6 1d aa 00 80 mov $0xffffffff8000aa1d,%rsi +ffffffff80005355: 48 89 c7 mov %rax,%rdi +ffffffff80005358: e8 73 fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000535d: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005364: 49 89 c4 mov %rax,%r12 +ffffffff80005367: e8 14 1c 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000536c: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005373: c7 05 7b 5d 00 00 0a movl $0xa,0x5d7b(%rip) # ffffffff8000b0f8 +ffffffff8000537a: 00 00 00 + Print(string); +ffffffff8000537d: e8 fe 1b 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005382: 0f b6 33 movzbl (%rbx),%esi +ffffffff80005385: 4c 89 e7 mov %r12,%rdi +ffffffff80005388: 40 c0 ee 03 shr $0x3,%sil +ffffffff8000538c: 83 e6 01 and $0x1,%esi +ffffffff8000538f: e8 7c fa ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff80005394: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff8000539b: 48 89 c7 mov %rax,%rdi +ffffffff8000539e: e8 2d fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultInstructionFetch: " << base::dec << pf_frame->PageFaultError.InstructionFetch << "\n"; +ffffffff800053a3: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff800053aa: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff800053b1: e8 1a fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800053b6: 48 c7 c6 36 aa 00 80 mov $0xffffffff8000aa36,%rsi +ffffffff800053bd: 48 89 c7 mov %rax,%rdi +ffffffff800053c0: e8 0b fa ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800053c5: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff800053cc: 49 89 c4 mov %rax,%r12 +ffffffff800053cf: e8 ac 1b 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800053d4: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff800053db: c7 05 13 5d 00 00 0a movl $0xa,0x5d13(%rip) # ffffffff8000b0f8 +ffffffff800053e2: 00 00 00 + Print(string); +ffffffff800053e5: e8 96 1b 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800053ea: 0f b6 33 movzbl (%rbx),%esi +ffffffff800053ed: 4c 89 e7 mov %r12,%rdi +ffffffff800053f0: 40 c0 ee 04 shr $0x4,%sil +ffffffff800053f4: 83 e6 01 and $0x1,%esi +ffffffff800053f7: e8 14 fa ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff800053fc: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff80005403: 48 89 c7 mov %rax,%rdi +ffffffff80005406: e8 c5 f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultProtectionKey: " << base::dec << pf_frame->PageFaultError.ProtectionKey << "\n"; +ffffffff8000540b: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80005412: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff80005419: e8 b2 f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000541e: 48 c7 c6 52 aa 00 80 mov $0xffffffff8000aa52,%rsi +ffffffff80005425: 48 89 c7 mov %rax,%rdi +ffffffff80005428: e8 a3 f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000542d: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005434: 49 89 c4 mov %rax,%r12 +ffffffff80005437: e8 44 1b 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000543c: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005443: c7 05 ab 5c 00 00 0a movl $0xa,0x5cab(%rip) # ffffffff8000b0f8 +ffffffff8000544a: 00 00 00 + Print(string); +ffffffff8000544d: e8 2e 1b 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005452: 0f b6 33 movzbl (%rbx),%esi +ffffffff80005455: 4c 89 e7 mov %r12,%rdi +ffffffff80005458: 40 c0 ee 05 shr $0x5,%sil +ffffffff8000545c: 83 e6 01 and $0x1,%esi +ffffffff8000545f: e8 ac f9 ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff80005464: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff8000546b: 48 89 c7 mov %rax,%rdi +ffffffff8000546e: e8 5d f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultShadowStack: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n"; +ffffffff80005473: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff8000547a: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff80005481: e8 4a f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005486: 48 c7 c6 6b aa 00 80 mov $0xffffffff8000aa6b,%rsi +ffffffff8000548d: 48 89 c7 mov %rax,%rdi +ffffffff80005490: e8 3b f9 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005495: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff8000549c: 49 89 c4 mov %rax,%r12 +ffffffff8000549f: e8 dc 1a 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800054a4: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff800054ab: c7 05 43 5c 00 00 0a movl $0xa,0x5c43(%rip) # ffffffff8000b0f8 +ffffffff800054b2: 00 00 00 + Print(string); +ffffffff800054b5: e8 c6 1a 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800054ba: 0f b6 33 movzbl (%rbx),%esi +ffffffff800054bd: 4c 89 e7 mov %r12,%rdi +ffffffff800054c0: 40 c0 ee 06 shr $0x6,%sil +ffffffff800054c4: 83 e6 01 and $0x1,%esi +ffffffff800054c7: e8 44 f9 ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff800054cc: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff800054d3: 48 89 c7 mov %rax,%rdi +ffffffff800054d6: e8 f5 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> + kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n"; +ffffffff800054db: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff800054e2: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff800054e9: e8 e2 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800054ee: 48 c7 c6 82 aa 00 80 mov $0xffffffff8000aa82,%rsi +ffffffff800054f5: 48 89 c7 mov %rax,%rdi +ffffffff800054f8: e8 d3 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800054fd: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005504: 49 89 c4 mov %rax,%r12 +ffffffff80005507: e8 74 1a 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000550c: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005513: c7 05 db 5b 00 00 0a movl $0xa,0x5bdb(%rip) # ffffffff8000b0f8 +ffffffff8000551a: 00 00 00 + Print(string); +ffffffff8000551d: e8 5e 1a 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005522: 0f b6 33 movzbl (%rbx),%esi +ffffffff80005525: 4c 89 e7 mov %r12,%rdi + frame = (System::PanicFrame*)&pf_frame->IP; +ffffffff80005528: 48 89 eb mov %rbp,%rbx + kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n"; +ffffffff8000552b: 40 c0 ee 06 shr $0x6,%sil +ffffffff8000552f: 83 e6 01 and $0x1,%esi +ffffffff80005532: e8 d9 f8 ff ff call ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_> +ffffffff80005537: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff8000553e: 48 89 c7 mov %rax,%rdi +ffffffff80005541: e8 8a f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff80005546: e9 81 fa ff ff jmp ffffffff80004fcc <_Z5PanicPKcPN6System10PanicFrameE+0x11c> + kerr << "\t" << "ErrorCode: " << base::dec << gpf_frame->GeneralProtectionFaultError << "\n"; +ffffffff8000554b: 48 c7 c6 c2 a9 00 80 mov $0xffffffff8000a9c2,%rsi +ffffffff80005552: 48 c7 c7 c0 07 0e 80 mov $0xffffffff800e07c0,%rdi +ffffffff80005559: e8 72 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000555e: 48 c7 c6 91 aa 00 80 mov $0xffffffff8000aa91,%rsi +ffffffff80005565: 48 89 c7 mov %rax,%rdi +ffffffff80005568: e8 63 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff8000556d: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff80005574: 48 89 c5 mov %rax,%rbp +ffffffff80005577: e8 04 1a 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000557c: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi + t.streamBaseType = newBase; +ffffffff80005583: c7 05 6b 5b 00 00 0a movl $0xa,0x5b6b(%rip) # ffffffff8000b0f8 +ffffffff8000558a: 00 00 00 + Print(string); +ffffffff8000558d: e8 ee 19 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff80005592: 48 8b 33 mov (%rbx),%rsi +ffffffff80005595: 48 89 ef mov %rbp,%rdi +ffffffff80005598: e8 c3 f8 ff ff call ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_> +ffffffff8000559d: 48 c7 c6 c0 a9 00 80 mov $0xffffffff8000a9c0,%rsi +ffffffff800055a4: 48 89 c7 mov %rax,%rdi +ffffffff800055a7: e8 24 f8 ff ff call ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_> +ffffffff800055ac: e9 1b fa ff ff jmp ffffffff80004fcc <_Z5PanicPKcPN6System10PanicFrameE+0x11c> +ffffffff800055b1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800055b8: 00 00 00 +ffffffff800055bb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff800055c0 <_ZdlPvm>: +{ + Memory::g_heap->Free(block); +} + +void operator delete(void* block, long unsigned int) +{ +ffffffff800055c0: f3 0f 1e fa endbr64 +ffffffff800055c4: 48 89 fe mov %rdi,%rsi + Memory::g_heap->Free(block); +ffffffff800055c7: 48 8b 3d 02 b2 0d 00 mov 0xdb202(%rip),%rdi # ffffffff800e07d0 <_ZN6Memory6g_heapE> +ffffffff800055ce: e9 cd 16 00 00 jmp ffffffff80006ca0 <_ZN6Memory13HeapAllocator4FreeEPv> +ffffffff800055d3: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800055da: 00 00 00 +ffffffff800055dd: 0f 1f 00 nopl (%rax) + +ffffffff800055e0 <_ZN3kcp13cstringstreamC1Ev>: +#include "Stream.hpp" +#include +#include +#include + +kcp::cstringstream::cstringstream() +ffffffff800055e0: f3 0f 1e fa endbr64 +ffffffff800055e4: c7 47 10 0a 00 00 00 movl $0xa,0x10(%rdi) +{ + this->string = nullptr; +ffffffff800055eb: 48 c7 07 00 00 00 00 movq $0x0,(%rdi) + this->size = 0; +ffffffff800055f2: 48 c7 47 08 00 00 00 movq $0x0,0x8(%rdi) +ffffffff800055f9: 00 +} +ffffffff800055fa: c3 ret +ffffffff800055fb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80005600 <_ZN3kcp13cstringstreamD1Ev>: + +kcp::cstringstream::~cstringstream() +ffffffff80005600: f3 0f 1e fa endbr64 +{ + delete this->string; +ffffffff80005604: 48 8b 3f mov (%rdi),%rdi +ffffffff80005607: 48 85 ff test %rdi,%rdi +ffffffff8000560a: 74 14 je ffffffff80005620 <_ZN3kcp13cstringstreamD1Ev+0x20> +ffffffff8000560c: be 01 00 00 00 mov $0x1,%esi +ffffffff80005611: e9 aa ff ff ff jmp ffffffff800055c0 <_ZdlPvm> +ffffffff80005616: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000561d: 00 00 00 +} +ffffffff80005620: c3 ret +ffffffff80005621: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80005628: 00 00 00 +ffffffff8000562b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80005630 <_ZN3kcp13cstringstreamlsEPKc>: + } + + return *this; +} + +kcp::cstringstream& kcp::cstringstream::operator<<(const char* str) { +ffffffff80005630: f3 0f 1e fa endbr64 +ffffffff80005634: 41 54 push %r12 +ffffffff80005636: 55 push %rbp +ffffffff80005637: 53 push %rbx + while (*str != '\0') +ffffffff80005638: 44 0f b6 26 movzbl (%rsi),%r12d +kcp::cstringstream& kcp::cstringstream::operator<<(const char* str) { +ffffffff8000563c: 48 89 fb mov %rdi,%rbx + while (*str != '\0') +ffffffff8000563f: 45 84 e4 test %r12b,%r12b +ffffffff80005642: 74 49 je ffffffff8000568d <_ZN3kcp13cstringstreamlsEPKc+0x5d> +ffffffff80005644: 48 89 f5 mov %rsi,%rbp +ffffffff80005647: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000564e: 00 00 + this->string = (char *)Memory::g_heap->Realloc((void *)this->string, this->size + 2); +ffffffff80005650: 48 8b 43 08 mov 0x8(%rbx),%rax +ffffffff80005654: 48 8b 33 mov (%rbx),%rsi +ffffffff80005657: 48 8b 3d 72 b1 0d 00 mov 0xdb172(%rip),%rdi # ffffffff800e07d0 <_ZN6Memory6g_heapE> +ffffffff8000565e: 48 8d 50 02 lea 0x2(%rax),%rdx +ffffffff80005662: e8 a9 15 00 00 call ffffffff80006c10 <_ZN6Memory13HeapAllocator7ReallocEPvm> +ffffffff80005667: 48 89 03 mov %rax,(%rbx) + if (!this->string) +ffffffff8000566a: 48 85 c0 test %rax,%rax +ffffffff8000566d: 74 29 je ffffffff80005698 <_ZN3kcp13cstringstreamlsEPKc+0x68> + char* ref = (char *)&string[size]; +ffffffff8000566f: 48 03 43 08 add 0x8(%rbx),%rax + *ref = c; +ffffffff80005673: 44 88 20 mov %r12b,(%rax) + *ref = '\0'; +ffffffff80005676: c6 40 01 00 movb $0x0,0x1(%rax) + this->size++; +ffffffff8000567a: 48 83 43 08 01 addq $0x1,0x8(%rbx) + while (*str != '\0') +ffffffff8000567f: 44 0f b6 65 01 movzbl 0x1(%rbp),%r12d + str++; +ffffffff80005684: 48 83 c5 01 add $0x1,%rbp + while (*str != '\0') +ffffffff80005688: 45 84 e4 test %r12b,%r12b +ffffffff8000568b: 75 c3 jne ffffffff80005650 <_ZN3kcp13cstringstreamlsEPKc+0x20> + *this << (char*)str; + + return *this; +} +ffffffff8000568d: 48 89 d8 mov %rbx,%rax +ffffffff80005690: 5b pop %rbx +ffffffff80005691: 5d pop %rbp +ffffffff80005692: 41 5c pop %r12 +ffffffff80005694: c3 ret +ffffffff80005695: 0f 1f 00 nopl (%rax) +ffffffff80005698: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff8000569f: e8 dc 18 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800056a4: 48 c7 c7 10 ad 00 80 mov $0xffffffff8000ad10,%rdi +ffffffff800056ab: e8 d0 18 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800056b0: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi +ffffffff800056b7: e8 c4 18 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff800056bc: 48 c7 c7 a2 a9 00 80 mov $0xffffffff8000a9a2,%rdi +ffffffff800056c3: e8 b8 18 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff800056c8: bf 0a 00 00 00 mov $0xa,%edi +ffffffff800056cd: e8 7e 18 00 00 call ffffffff80006f50 <_ZN2Kt7PutcharEc> + Print(string); +ffffffff800056d2: 48 c7 c7 aa a9 00 80 mov $0xffffffff8000a9aa,%rdi +ffffffff800056d9: e8 a2 18 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + return *this; +ffffffff800056de: eb 9f jmp ffffffff8000567f <_ZN3kcp13cstringstreamlsEPKc+0x4f> + +ffffffff800056e0 <_ZN3Hal10PrepareGDTEv>: + using namespace Kt; + + GDTPointer gdtPointer{}; + BasicGDT kernelGDT{}; + + void PrepareGDT() { +ffffffff800056e0: f3 0f 1e fa endbr64 +ffffffff800056e4: 48 83 ec 08 sub $0x8,%rsp + base streamBaseType = base::dec; + + // C++ streaming operator like cout + friend KernelOutStream &operator<<(KernelOutStream &t, const char *string) + { + Print(string); +ffffffff800056e8: 48 c7 c7 e6 aa 00 80 mov $0xffffffff8000aae6,%rdi +ffffffff800056ef: e8 8c 18 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + return t; + } + + friend KernelOutStream &operator<<(KernelOutStream &t, std::uint64_t number) + { + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff800056f4: be 10 00 00 00 mov $0x10,%esi +ffffffff800056f9: 48 c7 c7 60 03 0e 80 mov $0xffffffff800e0360,%rdi + return t; + } + + friend KernelOutStream &operator<<(KernelOutStream &t, base newBase) + { + t.streamBaseType = newBase; +ffffffff80005700: c7 05 ee 59 00 00 10 movl $0x10,0x59ee(%rip) # ffffffff8000b0f8 +ffffffff80005707: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff8000570a: e8 a1 12 00 00 call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff8000570f: 48 89 c7 mov %rax,%rdi +ffffffff80005712: e8 69 18 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80005717: 48 c7 c7 c0 a9 00 80 mov $0xffffffff8000a9c0,%rdi +ffffffff8000571e: e8 5d 18 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + kout << "HardwareAbstraction: GDT at " << base::hex << (uint64_t)&kernelGDT << "\n"; + kernelGDT = { +ffffffff80005723: 48 b8 ff ff 00 00 00 movabs $0xa092000000ffff,%rax +ffffffff8000572a: 92 a0 00 +ffffffff8000572d: 48 ba ff ff 00 00 00 movabs $0xa09a000000ffff,%rdx +ffffffff80005734: 9a a0 00 +ffffffff80005737: 48 c7 05 1e ac 0d 00 movq $0xffff,0xdac1e(%rip) # ffffffff800e0360 <_ZN3Hal9kernelGDTE> +ffffffff8000573e: ff ff 00 00 +ffffffff80005742: 48 89 05 27 ac 0d 00 mov %rax,0xdac27(%rip) # ffffffff800e0370 <_ZN3Hal9kernelGDTE+0x10> +ffffffff80005749: 48 89 05 30 ac 0d 00 mov %rax,0xdac30(%rip) # ffffffff800e0380 <_ZN3Hal9kernelGDTE+0x20> +ffffffff80005750: 48 b8 00 00 00 00 00 movabs $0xfa0000000000,%rax +ffffffff80005757: fa 00 00 +ffffffff8000575a: 48 89 05 27 ac 0d 00 mov %rax,0xdac27(%rip) # ffffffff800e0388 <_ZN3Hal9kernelGDTE+0x28> + + 0x0 + } + }; + + gdtPointer = GDTPointer{ +ffffffff80005761: b8 2f 00 00 00 mov $0x2f,%eax + kernelGDT = { +ffffffff80005766: 48 89 15 fb ab 0d 00 mov %rdx,0xdabfb(%rip) # ffffffff800e0368 <_ZN3Hal9kernelGDTE+0x8> +ffffffff8000576d: 48 89 15 04 ac 0d 00 mov %rdx,0xdac04(%rip) # ffffffff800e0378 <_ZN3Hal9kernelGDTE+0x18> + gdtPointer = GDTPointer{ +ffffffff80005774: 66 89 05 15 ac 0d 00 mov %ax,0xdac15(%rip) # ffffffff800e0390 <_ZN3Hal10gdtPointerE> +ffffffff8000577b: 48 c7 05 0c ac 0d 00 movq $0xffffffff800e0360,0xdac0c(%rip) # ffffffff800e0392 <_ZN3Hal10gdtPointerE+0x2> +ffffffff80005782: 60 03 0e 80 + .Size = sizeof(kernelGDT) - 1, + .GDTAddress = (uint64_t)&kernelGDT + }; + } +ffffffff80005786: 48 83 c4 08 add $0x8,%rsp +ffffffff8000578a: c3 ret +ffffffff8000578b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80005790 <_ZN3Hal13BridgeLoadGDTEv>: + + // Helpers implemented in gdt.asm + extern "C" void LoadGDT(GDTPointer *gdtPointer); + extern "C" void ReloadSegments(); + + void BridgeLoadGDT() { +ffffffff80005790: f3 0f 1e fa endbr64 +ffffffff80005794: 48 83 ec 08 sub $0x8,%rsp +ffffffff80005798: 48 c7 c7 40 ad 00 80 mov $0xffffffff8000ad40,%rdi +ffffffff8000579f: e8 dc 17 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff800057a4: bf 0a 00 00 00 mov $0xa,%edi +ffffffff800057a9: e8 a2 17 00 00 call ffffffff80006f50 <_ZN2Kt7PutcharEc> + // Puts the GDT pointer structure into the GDTR + kout << "HardwareAbstraction: Setting GDTR" << Kt::newline; + LoadGDT(&gdtPointer); +ffffffff800057ae: 48 c7 c7 90 03 0e 80 mov $0xffffffff800e0390,%rdi +ffffffff800057b5: e8 16 18 00 00 call ffffffff80006fd0 + Print(string); +ffffffff800057ba: 48 c7 c7 68 ad 00 80 mov $0xffffffff8000ad68,%rdi +ffffffff800057c1: e8 ba 17 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff800057c6: bf 0a 00 00 00 mov $0xa,%edi +ffffffff800057cb: e8 80 17 00 00 call ffffffff80006f50 <_ZN2Kt7PutcharEc> + + kout << "HardwareAbstraction: Reloading segments" << Kt::newline; + ReloadSegments(); + } +ffffffff800057d0: 48 83 c4 08 add $0x8,%rsp + ReloadSegments(); +ffffffff800057d4: e9 fb 17 00 00 jmp ffffffff80006fd4 +ffffffff800057d9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + +ffffffff800057e0 <_ZN3Hal16ExceptionHandlerILm0EEEvPN6System10PanicFrameE>: + "Security Exception", + "Reserved" + }; + + template + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800057e0: f3 0f 1e fa endbr64 +ffffffff800057e4: 41 53 push %r11 +ffffffff800057e6: 41 52 push %r10 +ffffffff800057e8: 41 51 push %r9 +ffffffff800057ea: 41 50 push %r8 +ffffffff800057ec: 57 push %rdi + // kcp::cstringstream stream; + // stream << "Caught " << base::hex << "0x" << i << " " << ExceptionStrings[i] << " in kernel"; + + frame->InterruptVector = i; + + Panic(ExceptionStrings[i], frame); +ffffffff800057ed: 48 8b 3d 0c 58 00 00 mov 0x580c(%rip),%rdi # ffffffff8000b000 <_ZN3Hal16ExceptionStringsE> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800057f4: 56 push %rsi +ffffffff800057f5: 51 push %rcx +ffffffff800057f6: 52 push %rdx +ffffffff800057f7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800057f8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800057fd: c6 44 24 70 00 movb $0x0,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005802: fc cld +ffffffff80005803: e8 a8 f6 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005808: 58 pop %rax +ffffffff80005809: 5a pop %rdx +ffffffff8000580a: 59 pop %rcx +ffffffff8000580b: 5e pop %rsi +ffffffff8000580c: 5f pop %rdi +ffffffff8000580d: 41 58 pop %r8 +ffffffff8000580f: 41 59 pop %r9 +ffffffff80005811: 41 5a pop %r10 +ffffffff80005813: 41 5b pop %r11 +ffffffff80005815: 48 cf iretq +ffffffff80005817: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000581e: 00 00 + +ffffffff80005820 <_ZN3Hal16ExceptionHandlerILm1EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005820: f3 0f 1e fa endbr64 +ffffffff80005824: 41 53 push %r11 +ffffffff80005826: 41 52 push %r10 +ffffffff80005828: 41 51 push %r9 +ffffffff8000582a: 41 50 push %r8 +ffffffff8000582c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff8000582d: 48 8b 3d d4 57 00 00 mov 0x57d4(%rip),%rdi # ffffffff8000b008 <_ZN3Hal16ExceptionStringsE+0x8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005834: 56 push %rsi +ffffffff80005835: 51 push %rcx +ffffffff80005836: 52 push %rdx +ffffffff80005837: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005838: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff8000583d: c6 44 24 70 01 movb $0x1,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005842: fc cld +ffffffff80005843: e8 68 f6 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005848: 58 pop %rax +ffffffff80005849: 5a pop %rdx +ffffffff8000584a: 59 pop %rcx +ffffffff8000584b: 5e pop %rsi +ffffffff8000584c: 5f pop %rdi +ffffffff8000584d: 41 58 pop %r8 +ffffffff8000584f: 41 59 pop %r9 +ffffffff80005851: 41 5a pop %r10 +ffffffff80005853: 41 5b pop %r11 +ffffffff80005855: 48 cf iretq +ffffffff80005857: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000585e: 00 00 + +ffffffff80005860 <_ZN3Hal16ExceptionHandlerILm2EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005860: f3 0f 1e fa endbr64 +ffffffff80005864: 41 53 push %r11 +ffffffff80005866: 41 52 push %r10 +ffffffff80005868: 41 51 push %r9 +ffffffff8000586a: 41 50 push %r8 +ffffffff8000586c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff8000586d: 48 8b 3d 9c 57 00 00 mov 0x579c(%rip),%rdi # ffffffff8000b010 <_ZN3Hal16ExceptionStringsE+0x10> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005874: 56 push %rsi +ffffffff80005875: 51 push %rcx +ffffffff80005876: 52 push %rdx +ffffffff80005877: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005878: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff8000587d: c6 44 24 70 02 movb $0x2,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005882: fc cld +ffffffff80005883: e8 28 f6 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005888: 58 pop %rax +ffffffff80005889: 5a pop %rdx +ffffffff8000588a: 59 pop %rcx +ffffffff8000588b: 5e pop %rsi +ffffffff8000588c: 5f pop %rdi +ffffffff8000588d: 41 58 pop %r8 +ffffffff8000588f: 41 59 pop %r9 +ffffffff80005891: 41 5a pop %r10 +ffffffff80005893: 41 5b pop %r11 +ffffffff80005895: 48 cf iretq +ffffffff80005897: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000589e: 00 00 + +ffffffff800058a0 <_ZN3Hal16ExceptionHandlerILm3EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800058a0: f3 0f 1e fa endbr64 +ffffffff800058a4: 41 53 push %r11 +ffffffff800058a6: 41 52 push %r10 +ffffffff800058a8: 41 51 push %r9 +ffffffff800058aa: 41 50 push %r8 +ffffffff800058ac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff800058ad: 48 8b 3d 64 57 00 00 mov 0x5764(%rip),%rdi # ffffffff8000b018 <_ZN3Hal16ExceptionStringsE+0x18> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800058b4: 56 push %rsi +ffffffff800058b5: 51 push %rcx +ffffffff800058b6: 52 push %rdx +ffffffff800058b7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800058b8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800058bd: c6 44 24 70 03 movb $0x3,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff800058c2: fc cld +ffffffff800058c3: e8 e8 f5 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff800058c8: 58 pop %rax +ffffffff800058c9: 5a pop %rdx +ffffffff800058ca: 59 pop %rcx +ffffffff800058cb: 5e pop %rsi +ffffffff800058cc: 5f pop %rdi +ffffffff800058cd: 41 58 pop %r8 +ffffffff800058cf: 41 59 pop %r9 +ffffffff800058d1: 41 5a pop %r10 +ffffffff800058d3: 41 5b pop %r11 +ffffffff800058d5: 48 cf iretq +ffffffff800058d7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff800058de: 00 00 + +ffffffff800058e0 <_ZN3Hal16ExceptionHandlerILm4EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800058e0: f3 0f 1e fa endbr64 +ffffffff800058e4: 41 53 push %r11 +ffffffff800058e6: 41 52 push %r10 +ffffffff800058e8: 41 51 push %r9 +ffffffff800058ea: 41 50 push %r8 +ffffffff800058ec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff800058ed: 48 8b 3d 2c 57 00 00 mov 0x572c(%rip),%rdi # ffffffff8000b020 <_ZN3Hal16ExceptionStringsE+0x20> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800058f4: 56 push %rsi +ffffffff800058f5: 51 push %rcx +ffffffff800058f6: 52 push %rdx +ffffffff800058f7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800058f8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800058fd: c6 44 24 70 04 movb $0x4,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005902: fc cld +ffffffff80005903: e8 a8 f5 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005908: 58 pop %rax +ffffffff80005909: 5a pop %rdx +ffffffff8000590a: 59 pop %rcx +ffffffff8000590b: 5e pop %rsi +ffffffff8000590c: 5f pop %rdi +ffffffff8000590d: 41 58 pop %r8 +ffffffff8000590f: 41 59 pop %r9 +ffffffff80005911: 41 5a pop %r10 +ffffffff80005913: 41 5b pop %r11 +ffffffff80005915: 48 cf iretq +ffffffff80005917: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000591e: 00 00 + +ffffffff80005920 <_ZN3Hal16ExceptionHandlerILm5EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005920: f3 0f 1e fa endbr64 +ffffffff80005924: 41 53 push %r11 +ffffffff80005926: 41 52 push %r10 +ffffffff80005928: 41 51 push %r9 +ffffffff8000592a: 41 50 push %r8 +ffffffff8000592c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff8000592d: 48 8b 3d f4 56 00 00 mov 0x56f4(%rip),%rdi # ffffffff8000b028 <_ZN3Hal16ExceptionStringsE+0x28> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005934: 56 push %rsi +ffffffff80005935: 51 push %rcx +ffffffff80005936: 52 push %rdx +ffffffff80005937: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005938: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff8000593d: c6 44 24 70 05 movb $0x5,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005942: fc cld +ffffffff80005943: e8 68 f5 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005948: 58 pop %rax +ffffffff80005949: 5a pop %rdx +ffffffff8000594a: 59 pop %rcx +ffffffff8000594b: 5e pop %rsi +ffffffff8000594c: 5f pop %rdi +ffffffff8000594d: 41 58 pop %r8 +ffffffff8000594f: 41 59 pop %r9 +ffffffff80005951: 41 5a pop %r10 +ffffffff80005953: 41 5b pop %r11 +ffffffff80005955: 48 cf iretq +ffffffff80005957: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000595e: 00 00 + +ffffffff80005960 <_ZN3Hal16ExceptionHandlerILm6EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005960: f3 0f 1e fa endbr64 +ffffffff80005964: 41 53 push %r11 +ffffffff80005966: 41 52 push %r10 +ffffffff80005968: 41 51 push %r9 +ffffffff8000596a: 41 50 push %r8 +ffffffff8000596c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff8000596d: 48 8b 3d bc 56 00 00 mov 0x56bc(%rip),%rdi # ffffffff8000b030 <_ZN3Hal16ExceptionStringsE+0x30> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005974: 56 push %rsi +ffffffff80005975: 51 push %rcx +ffffffff80005976: 52 push %rdx +ffffffff80005977: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005978: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff8000597d: c6 44 24 70 06 movb $0x6,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005982: fc cld +ffffffff80005983: e8 28 f5 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005988: 58 pop %rax +ffffffff80005989: 5a pop %rdx +ffffffff8000598a: 59 pop %rcx +ffffffff8000598b: 5e pop %rsi +ffffffff8000598c: 5f pop %rdi +ffffffff8000598d: 41 58 pop %r8 +ffffffff8000598f: 41 59 pop %r9 +ffffffff80005991: 41 5a pop %r10 +ffffffff80005993: 41 5b pop %r11 +ffffffff80005995: 48 cf iretq +ffffffff80005997: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff8000599e: 00 00 + +ffffffff800059a0 <_ZN3Hal16ExceptionHandlerILm7EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800059a0: f3 0f 1e fa endbr64 +ffffffff800059a4: 41 53 push %r11 +ffffffff800059a6: 41 52 push %r10 +ffffffff800059a8: 41 51 push %r9 +ffffffff800059aa: 41 50 push %r8 +ffffffff800059ac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff800059ad: 48 8b 3d 84 56 00 00 mov 0x5684(%rip),%rdi # ffffffff8000b038 <_ZN3Hal16ExceptionStringsE+0x38> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800059b4: 56 push %rsi +ffffffff800059b5: 51 push %rcx +ffffffff800059b6: 52 push %rdx +ffffffff800059b7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800059b8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800059bd: c6 44 24 70 07 movb $0x7,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff800059c2: fc cld +ffffffff800059c3: e8 e8 f4 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff800059c8: 58 pop %rax +ffffffff800059c9: 5a pop %rdx +ffffffff800059ca: 59 pop %rcx +ffffffff800059cb: 5e pop %rsi +ffffffff800059cc: 5f pop %rdi +ffffffff800059cd: 41 58 pop %r8 +ffffffff800059cf: 41 59 pop %r9 +ffffffff800059d1: 41 5a pop %r10 +ffffffff800059d3: 41 5b pop %r11 +ffffffff800059d5: 48 cf iretq +ffffffff800059d7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff800059de: 00 00 + +ffffffff800059e0 <_ZN3Hal16ExceptionHandlerILm8EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800059e0: f3 0f 1e fa endbr64 +ffffffff800059e4: 41 53 push %r11 +ffffffff800059e6: 41 52 push %r10 +ffffffff800059e8: 41 51 push %r9 +ffffffff800059ea: 41 50 push %r8 +ffffffff800059ec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff800059ed: 48 8b 3d 4c 56 00 00 mov 0x564c(%rip),%rdi # ffffffff8000b040 <_ZN3Hal16ExceptionStringsE+0x40> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff800059f4: 56 push %rsi +ffffffff800059f5: 51 push %rcx +ffffffff800059f6: 52 push %rdx +ffffffff800059f7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff800059f8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff800059fd: c6 44 24 70 08 movb $0x8,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005a02: fc cld +ffffffff80005a03: e8 a8 f4 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005a08: 58 pop %rax +ffffffff80005a09: 5a pop %rdx +ffffffff80005a0a: 59 pop %rcx +ffffffff80005a0b: 5e pop %rsi +ffffffff80005a0c: 5f pop %rdi +ffffffff80005a0d: 41 58 pop %r8 +ffffffff80005a0f: 41 59 pop %r9 +ffffffff80005a11: 41 5a pop %r10 +ffffffff80005a13: 41 5b pop %r11 +ffffffff80005a15: 48 cf iretq +ffffffff80005a17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005a1e: 00 00 + +ffffffff80005a20 <_ZN3Hal16ExceptionHandlerILm9EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005a20: f3 0f 1e fa endbr64 +ffffffff80005a24: 41 53 push %r11 +ffffffff80005a26: 41 52 push %r10 +ffffffff80005a28: 41 51 push %r9 +ffffffff80005a2a: 41 50 push %r8 +ffffffff80005a2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005a2d: 48 8b 3d 14 56 00 00 mov 0x5614(%rip),%rdi # ffffffff8000b048 <_ZN3Hal16ExceptionStringsE+0x48> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005a34: 56 push %rsi +ffffffff80005a35: 51 push %rcx +ffffffff80005a36: 52 push %rdx +ffffffff80005a37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005a38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005a3d: c6 44 24 70 09 movb $0x9,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005a42: fc cld +ffffffff80005a43: e8 68 f4 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005a48: 58 pop %rax +ffffffff80005a49: 5a pop %rdx +ffffffff80005a4a: 59 pop %rcx +ffffffff80005a4b: 5e pop %rsi +ffffffff80005a4c: 5f pop %rdi +ffffffff80005a4d: 41 58 pop %r8 +ffffffff80005a4f: 41 59 pop %r9 +ffffffff80005a51: 41 5a pop %r10 +ffffffff80005a53: 41 5b pop %r11 +ffffffff80005a55: 48 cf iretq +ffffffff80005a57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005a5e: 00 00 + +ffffffff80005a60 <_ZN3Hal16ExceptionHandlerILm10EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005a60: f3 0f 1e fa endbr64 +ffffffff80005a64: 41 53 push %r11 +ffffffff80005a66: 41 52 push %r10 +ffffffff80005a68: 41 51 push %r9 +ffffffff80005a6a: 41 50 push %r8 +ffffffff80005a6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005a6d: 48 8b 3d dc 55 00 00 mov 0x55dc(%rip),%rdi # ffffffff8000b050 <_ZN3Hal16ExceptionStringsE+0x50> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005a74: 56 push %rsi +ffffffff80005a75: 51 push %rcx +ffffffff80005a76: 52 push %rdx +ffffffff80005a77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005a78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005a7d: c6 44 24 70 0a movb $0xa,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005a82: fc cld +ffffffff80005a83: e8 28 f4 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005a88: 58 pop %rax +ffffffff80005a89: 5a pop %rdx +ffffffff80005a8a: 59 pop %rcx +ffffffff80005a8b: 5e pop %rsi +ffffffff80005a8c: 5f pop %rdi +ffffffff80005a8d: 41 58 pop %r8 +ffffffff80005a8f: 41 59 pop %r9 +ffffffff80005a91: 41 5a pop %r10 +ffffffff80005a93: 41 5b pop %r11 +ffffffff80005a95: 48 cf iretq +ffffffff80005a97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005a9e: 00 00 + +ffffffff80005aa0 <_ZN3Hal16ExceptionHandlerILm11EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005aa0: f3 0f 1e fa endbr64 +ffffffff80005aa4: 41 53 push %r11 +ffffffff80005aa6: 41 52 push %r10 +ffffffff80005aa8: 41 51 push %r9 +ffffffff80005aaa: 41 50 push %r8 +ffffffff80005aac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005aad: 48 8b 3d a4 55 00 00 mov 0x55a4(%rip),%rdi # ffffffff8000b058 <_ZN3Hal16ExceptionStringsE+0x58> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ab4: 56 push %rsi +ffffffff80005ab5: 51 push %rcx +ffffffff80005ab6: 52 push %rdx +ffffffff80005ab7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005ab8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005abd: c6 44 24 70 0b movb $0xb,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005ac2: fc cld +ffffffff80005ac3: e8 e8 f3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005ac8: 58 pop %rax +ffffffff80005ac9: 5a pop %rdx +ffffffff80005aca: 59 pop %rcx +ffffffff80005acb: 5e pop %rsi +ffffffff80005acc: 5f pop %rdi +ffffffff80005acd: 41 58 pop %r8 +ffffffff80005acf: 41 59 pop %r9 +ffffffff80005ad1: 41 5a pop %r10 +ffffffff80005ad3: 41 5b pop %r11 +ffffffff80005ad5: 48 cf iretq +ffffffff80005ad7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005ade: 00 00 + +ffffffff80005ae0 <_ZN3Hal16ExceptionHandlerILm12EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ae0: f3 0f 1e fa endbr64 +ffffffff80005ae4: 41 53 push %r11 +ffffffff80005ae6: 41 52 push %r10 +ffffffff80005ae8: 41 51 push %r9 +ffffffff80005aea: 41 50 push %r8 +ffffffff80005aec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005aed: 48 8b 3d 6c 55 00 00 mov 0x556c(%rip),%rdi # ffffffff8000b060 <_ZN3Hal16ExceptionStringsE+0x60> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005af4: 56 push %rsi +ffffffff80005af5: 51 push %rcx +ffffffff80005af6: 52 push %rdx +ffffffff80005af7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005af8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005afd: c6 44 24 70 0c movb $0xc,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005b02: fc cld +ffffffff80005b03: e8 a8 f3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005b08: 58 pop %rax +ffffffff80005b09: 5a pop %rdx +ffffffff80005b0a: 59 pop %rcx +ffffffff80005b0b: 5e pop %rsi +ffffffff80005b0c: 5f pop %rdi +ffffffff80005b0d: 41 58 pop %r8 +ffffffff80005b0f: 41 59 pop %r9 +ffffffff80005b11: 41 5a pop %r10 +ffffffff80005b13: 41 5b pop %r11 +ffffffff80005b15: 48 cf iretq +ffffffff80005b17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005b1e: 00 00 + +ffffffff80005b20 <_ZN3Hal16ExceptionHandlerILm13EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005b20: f3 0f 1e fa endbr64 +ffffffff80005b24: 41 53 push %r11 +ffffffff80005b26: 41 52 push %r10 +ffffffff80005b28: 41 51 push %r9 +ffffffff80005b2a: 41 50 push %r8 +ffffffff80005b2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005b2d: 48 8b 3d 34 55 00 00 mov 0x5534(%rip),%rdi # ffffffff8000b068 <_ZN3Hal16ExceptionStringsE+0x68> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005b34: 56 push %rsi +ffffffff80005b35: 51 push %rcx +ffffffff80005b36: 52 push %rdx +ffffffff80005b37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005b38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005b3d: c6 44 24 70 0d movb $0xd,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005b42: fc cld +ffffffff80005b43: e8 68 f3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005b48: 58 pop %rax +ffffffff80005b49: 5a pop %rdx +ffffffff80005b4a: 59 pop %rcx +ffffffff80005b4b: 5e pop %rsi +ffffffff80005b4c: 5f pop %rdi +ffffffff80005b4d: 41 58 pop %r8 +ffffffff80005b4f: 41 59 pop %r9 +ffffffff80005b51: 41 5a pop %r10 +ffffffff80005b53: 41 5b pop %r11 +ffffffff80005b55: 48 cf iretq +ffffffff80005b57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005b5e: 00 00 + +ffffffff80005b60 <_ZN3Hal16ExceptionHandlerILm14EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005b60: f3 0f 1e fa endbr64 +ffffffff80005b64: 41 53 push %r11 +ffffffff80005b66: 41 52 push %r10 +ffffffff80005b68: 41 51 push %r9 +ffffffff80005b6a: 41 50 push %r8 +ffffffff80005b6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005b6d: 48 8b 3d fc 54 00 00 mov 0x54fc(%rip),%rdi # ffffffff8000b070 <_ZN3Hal16ExceptionStringsE+0x70> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005b74: 56 push %rsi +ffffffff80005b75: 51 push %rcx +ffffffff80005b76: 52 push %rdx +ffffffff80005b77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005b78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005b7d: c6 44 24 70 0e movb $0xe,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005b82: fc cld +ffffffff80005b83: e8 28 f3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005b88: 58 pop %rax +ffffffff80005b89: 5a pop %rdx +ffffffff80005b8a: 59 pop %rcx +ffffffff80005b8b: 5e pop %rsi +ffffffff80005b8c: 5f pop %rdi +ffffffff80005b8d: 41 58 pop %r8 +ffffffff80005b8f: 41 59 pop %r9 +ffffffff80005b91: 41 5a pop %r10 +ffffffff80005b93: 41 5b pop %r11 +ffffffff80005b95: 48 cf iretq +ffffffff80005b97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005b9e: 00 00 + +ffffffff80005ba0 <_ZN3Hal16ExceptionHandlerILm15EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ba0: f3 0f 1e fa endbr64 +ffffffff80005ba4: 41 53 push %r11 +ffffffff80005ba6: 41 52 push %r10 +ffffffff80005ba8: 41 51 push %r9 +ffffffff80005baa: 41 50 push %r8 +ffffffff80005bac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005bad: 48 8b 3d c4 54 00 00 mov 0x54c4(%rip),%rdi # ffffffff8000b078 <_ZN3Hal16ExceptionStringsE+0x78> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005bb4: 56 push %rsi +ffffffff80005bb5: 51 push %rcx +ffffffff80005bb6: 52 push %rdx +ffffffff80005bb7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005bb8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005bbd: c6 44 24 70 0f movb $0xf,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005bc2: fc cld +ffffffff80005bc3: e8 e8 f2 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005bc8: 58 pop %rax +ffffffff80005bc9: 5a pop %rdx +ffffffff80005bca: 59 pop %rcx +ffffffff80005bcb: 5e pop %rsi +ffffffff80005bcc: 5f pop %rdi +ffffffff80005bcd: 41 58 pop %r8 +ffffffff80005bcf: 41 59 pop %r9 +ffffffff80005bd1: 41 5a pop %r10 +ffffffff80005bd3: 41 5b pop %r11 +ffffffff80005bd5: 48 cf iretq +ffffffff80005bd7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005bde: 00 00 + +ffffffff80005be0 <_ZN3Hal16ExceptionHandlerILm16EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005be0: f3 0f 1e fa endbr64 +ffffffff80005be4: 41 53 push %r11 +ffffffff80005be6: 41 52 push %r10 +ffffffff80005be8: 41 51 push %r9 +ffffffff80005bea: 41 50 push %r8 +ffffffff80005bec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005bed: 48 8b 3d 8c 54 00 00 mov 0x548c(%rip),%rdi # ffffffff8000b080 <_ZN3Hal16ExceptionStringsE+0x80> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005bf4: 56 push %rsi +ffffffff80005bf5: 51 push %rcx +ffffffff80005bf6: 52 push %rdx +ffffffff80005bf7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005bf8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005bfd: c6 44 24 70 10 movb $0x10,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005c02: fc cld +ffffffff80005c03: e8 a8 f2 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005c08: 58 pop %rax +ffffffff80005c09: 5a pop %rdx +ffffffff80005c0a: 59 pop %rcx +ffffffff80005c0b: 5e pop %rsi +ffffffff80005c0c: 5f pop %rdi +ffffffff80005c0d: 41 58 pop %r8 +ffffffff80005c0f: 41 59 pop %r9 +ffffffff80005c11: 41 5a pop %r10 +ffffffff80005c13: 41 5b pop %r11 +ffffffff80005c15: 48 cf iretq +ffffffff80005c17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005c1e: 00 00 + +ffffffff80005c20 <_ZN3Hal16ExceptionHandlerILm17EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005c20: f3 0f 1e fa endbr64 +ffffffff80005c24: 41 53 push %r11 +ffffffff80005c26: 41 52 push %r10 +ffffffff80005c28: 41 51 push %r9 +ffffffff80005c2a: 41 50 push %r8 +ffffffff80005c2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005c2d: 48 8b 3d 54 54 00 00 mov 0x5454(%rip),%rdi # ffffffff8000b088 <_ZN3Hal16ExceptionStringsE+0x88> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005c34: 56 push %rsi +ffffffff80005c35: 51 push %rcx +ffffffff80005c36: 52 push %rdx +ffffffff80005c37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005c38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005c3d: c6 44 24 70 11 movb $0x11,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005c42: fc cld +ffffffff80005c43: e8 68 f2 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005c48: 58 pop %rax +ffffffff80005c49: 5a pop %rdx +ffffffff80005c4a: 59 pop %rcx +ffffffff80005c4b: 5e pop %rsi +ffffffff80005c4c: 5f pop %rdi +ffffffff80005c4d: 41 58 pop %r8 +ffffffff80005c4f: 41 59 pop %r9 +ffffffff80005c51: 41 5a pop %r10 +ffffffff80005c53: 41 5b pop %r11 +ffffffff80005c55: 48 cf iretq +ffffffff80005c57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005c5e: 00 00 + +ffffffff80005c60 <_ZN3Hal16ExceptionHandlerILm18EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005c60: f3 0f 1e fa endbr64 +ffffffff80005c64: 41 53 push %r11 +ffffffff80005c66: 41 52 push %r10 +ffffffff80005c68: 41 51 push %r9 +ffffffff80005c6a: 41 50 push %r8 +ffffffff80005c6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005c6d: 48 8b 3d 1c 54 00 00 mov 0x541c(%rip),%rdi # ffffffff8000b090 <_ZN3Hal16ExceptionStringsE+0x90> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005c74: 56 push %rsi +ffffffff80005c75: 51 push %rcx +ffffffff80005c76: 52 push %rdx +ffffffff80005c77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005c78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005c7d: c6 44 24 70 12 movb $0x12,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005c82: fc cld +ffffffff80005c83: e8 28 f2 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005c88: 58 pop %rax +ffffffff80005c89: 5a pop %rdx +ffffffff80005c8a: 59 pop %rcx +ffffffff80005c8b: 5e pop %rsi +ffffffff80005c8c: 5f pop %rdi +ffffffff80005c8d: 41 58 pop %r8 +ffffffff80005c8f: 41 59 pop %r9 +ffffffff80005c91: 41 5a pop %r10 +ffffffff80005c93: 41 5b pop %r11 +ffffffff80005c95: 48 cf iretq +ffffffff80005c97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005c9e: 00 00 + +ffffffff80005ca0 <_ZN3Hal16ExceptionHandlerILm19EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ca0: f3 0f 1e fa endbr64 +ffffffff80005ca4: 41 53 push %r11 +ffffffff80005ca6: 41 52 push %r10 +ffffffff80005ca8: 41 51 push %r9 +ffffffff80005caa: 41 50 push %r8 +ffffffff80005cac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005cad: 48 8b 3d e4 53 00 00 mov 0x53e4(%rip),%rdi # ffffffff8000b098 <_ZN3Hal16ExceptionStringsE+0x98> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005cb4: 56 push %rsi +ffffffff80005cb5: 51 push %rcx +ffffffff80005cb6: 52 push %rdx +ffffffff80005cb7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005cb8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005cbd: c6 44 24 70 13 movb $0x13,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005cc2: fc cld +ffffffff80005cc3: e8 e8 f1 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005cc8: 58 pop %rax +ffffffff80005cc9: 5a pop %rdx +ffffffff80005cca: 59 pop %rcx +ffffffff80005ccb: 5e pop %rsi +ffffffff80005ccc: 5f pop %rdi +ffffffff80005ccd: 41 58 pop %r8 +ffffffff80005ccf: 41 59 pop %r9 +ffffffff80005cd1: 41 5a pop %r10 +ffffffff80005cd3: 41 5b pop %r11 +ffffffff80005cd5: 48 cf iretq +ffffffff80005cd7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005cde: 00 00 + +ffffffff80005ce0 <_ZN3Hal16ExceptionHandlerILm20EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ce0: f3 0f 1e fa endbr64 +ffffffff80005ce4: 41 53 push %r11 +ffffffff80005ce6: 41 52 push %r10 +ffffffff80005ce8: 41 51 push %r9 +ffffffff80005cea: 41 50 push %r8 +ffffffff80005cec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005ced: 48 8b 3d ac 53 00 00 mov 0x53ac(%rip),%rdi # ffffffff8000b0a0 <_ZN3Hal16ExceptionStringsE+0xa0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005cf4: 56 push %rsi +ffffffff80005cf5: 51 push %rcx +ffffffff80005cf6: 52 push %rdx +ffffffff80005cf7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005cf8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005cfd: c6 44 24 70 14 movb $0x14,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005d02: fc cld +ffffffff80005d03: e8 a8 f1 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005d08: 58 pop %rax +ffffffff80005d09: 5a pop %rdx +ffffffff80005d0a: 59 pop %rcx +ffffffff80005d0b: 5e pop %rsi +ffffffff80005d0c: 5f pop %rdi +ffffffff80005d0d: 41 58 pop %r8 +ffffffff80005d0f: 41 59 pop %r9 +ffffffff80005d11: 41 5a pop %r10 +ffffffff80005d13: 41 5b pop %r11 +ffffffff80005d15: 48 cf iretq +ffffffff80005d17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005d1e: 00 00 + +ffffffff80005d20 <_ZN3Hal16ExceptionHandlerILm21EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005d20: f3 0f 1e fa endbr64 +ffffffff80005d24: 41 53 push %r11 +ffffffff80005d26: 41 52 push %r10 +ffffffff80005d28: 41 51 push %r9 +ffffffff80005d2a: 41 50 push %r8 +ffffffff80005d2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005d2d: 48 8b 3d 74 53 00 00 mov 0x5374(%rip),%rdi # ffffffff8000b0a8 <_ZN3Hal16ExceptionStringsE+0xa8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005d34: 56 push %rsi +ffffffff80005d35: 51 push %rcx +ffffffff80005d36: 52 push %rdx +ffffffff80005d37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005d38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005d3d: c6 44 24 70 15 movb $0x15,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005d42: fc cld +ffffffff80005d43: e8 68 f1 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005d48: 58 pop %rax +ffffffff80005d49: 5a pop %rdx +ffffffff80005d4a: 59 pop %rcx +ffffffff80005d4b: 5e pop %rsi +ffffffff80005d4c: 5f pop %rdi +ffffffff80005d4d: 41 58 pop %r8 +ffffffff80005d4f: 41 59 pop %r9 +ffffffff80005d51: 41 5a pop %r10 +ffffffff80005d53: 41 5b pop %r11 +ffffffff80005d55: 48 cf iretq +ffffffff80005d57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005d5e: 00 00 + +ffffffff80005d60 <_ZN3Hal16ExceptionHandlerILm22EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005d60: f3 0f 1e fa endbr64 +ffffffff80005d64: 41 53 push %r11 +ffffffff80005d66: 41 52 push %r10 +ffffffff80005d68: 41 51 push %r9 +ffffffff80005d6a: 41 50 push %r8 +ffffffff80005d6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005d6d: 48 8b 3d 3c 53 00 00 mov 0x533c(%rip),%rdi # ffffffff8000b0b0 <_ZN3Hal16ExceptionStringsE+0xb0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005d74: 56 push %rsi +ffffffff80005d75: 51 push %rcx +ffffffff80005d76: 52 push %rdx +ffffffff80005d77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005d78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005d7d: c6 44 24 70 16 movb $0x16,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005d82: fc cld +ffffffff80005d83: e8 28 f1 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005d88: 58 pop %rax +ffffffff80005d89: 5a pop %rdx +ffffffff80005d8a: 59 pop %rcx +ffffffff80005d8b: 5e pop %rsi +ffffffff80005d8c: 5f pop %rdi +ffffffff80005d8d: 41 58 pop %r8 +ffffffff80005d8f: 41 59 pop %r9 +ffffffff80005d91: 41 5a pop %r10 +ffffffff80005d93: 41 5b pop %r11 +ffffffff80005d95: 48 cf iretq +ffffffff80005d97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005d9e: 00 00 + +ffffffff80005da0 <_ZN3Hal16ExceptionHandlerILm23EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005da0: f3 0f 1e fa endbr64 +ffffffff80005da4: 41 53 push %r11 +ffffffff80005da6: 41 52 push %r10 +ffffffff80005da8: 41 51 push %r9 +ffffffff80005daa: 41 50 push %r8 +ffffffff80005dac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005dad: 48 8b 3d 04 53 00 00 mov 0x5304(%rip),%rdi # ffffffff8000b0b8 <_ZN3Hal16ExceptionStringsE+0xb8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005db4: 56 push %rsi +ffffffff80005db5: 51 push %rcx +ffffffff80005db6: 52 push %rdx +ffffffff80005db7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005db8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005dbd: c6 44 24 70 17 movb $0x17,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005dc2: fc cld +ffffffff80005dc3: e8 e8 f0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005dc8: 58 pop %rax +ffffffff80005dc9: 5a pop %rdx +ffffffff80005dca: 59 pop %rcx +ffffffff80005dcb: 5e pop %rsi +ffffffff80005dcc: 5f pop %rdi +ffffffff80005dcd: 41 58 pop %r8 +ffffffff80005dcf: 41 59 pop %r9 +ffffffff80005dd1: 41 5a pop %r10 +ffffffff80005dd3: 41 5b pop %r11 +ffffffff80005dd5: 48 cf iretq +ffffffff80005dd7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005dde: 00 00 + +ffffffff80005de0 <_ZN3Hal16ExceptionHandlerILm24EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005de0: f3 0f 1e fa endbr64 +ffffffff80005de4: 41 53 push %r11 +ffffffff80005de6: 41 52 push %r10 +ffffffff80005de8: 41 51 push %r9 +ffffffff80005dea: 41 50 push %r8 +ffffffff80005dec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005ded: 48 8b 3d cc 52 00 00 mov 0x52cc(%rip),%rdi # ffffffff8000b0c0 <_ZN3Hal16ExceptionStringsE+0xc0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005df4: 56 push %rsi +ffffffff80005df5: 51 push %rcx +ffffffff80005df6: 52 push %rdx +ffffffff80005df7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005df8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005dfd: c6 44 24 70 18 movb $0x18,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005e02: fc cld +ffffffff80005e03: e8 a8 f0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005e08: 58 pop %rax +ffffffff80005e09: 5a pop %rdx +ffffffff80005e0a: 59 pop %rcx +ffffffff80005e0b: 5e pop %rsi +ffffffff80005e0c: 5f pop %rdi +ffffffff80005e0d: 41 58 pop %r8 +ffffffff80005e0f: 41 59 pop %r9 +ffffffff80005e11: 41 5a pop %r10 +ffffffff80005e13: 41 5b pop %r11 +ffffffff80005e15: 48 cf iretq +ffffffff80005e17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005e1e: 00 00 + +ffffffff80005e20 <_ZN3Hal16ExceptionHandlerILm25EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005e20: f3 0f 1e fa endbr64 +ffffffff80005e24: 41 53 push %r11 +ffffffff80005e26: 41 52 push %r10 +ffffffff80005e28: 41 51 push %r9 +ffffffff80005e2a: 41 50 push %r8 +ffffffff80005e2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005e2d: 48 8b 3d 94 52 00 00 mov 0x5294(%rip),%rdi # ffffffff8000b0c8 <_ZN3Hal16ExceptionStringsE+0xc8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005e34: 56 push %rsi +ffffffff80005e35: 51 push %rcx +ffffffff80005e36: 52 push %rdx +ffffffff80005e37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005e38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005e3d: c6 44 24 70 19 movb $0x19,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005e42: fc cld +ffffffff80005e43: e8 68 f0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005e48: 58 pop %rax +ffffffff80005e49: 5a pop %rdx +ffffffff80005e4a: 59 pop %rcx +ffffffff80005e4b: 5e pop %rsi +ffffffff80005e4c: 5f pop %rdi +ffffffff80005e4d: 41 58 pop %r8 +ffffffff80005e4f: 41 59 pop %r9 +ffffffff80005e51: 41 5a pop %r10 +ffffffff80005e53: 41 5b pop %r11 +ffffffff80005e55: 48 cf iretq +ffffffff80005e57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005e5e: 00 00 + +ffffffff80005e60 <_ZN3Hal16ExceptionHandlerILm26EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005e60: f3 0f 1e fa endbr64 +ffffffff80005e64: 41 53 push %r11 +ffffffff80005e66: 41 52 push %r10 +ffffffff80005e68: 41 51 push %r9 +ffffffff80005e6a: 41 50 push %r8 +ffffffff80005e6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005e6d: 48 8b 3d 5c 52 00 00 mov 0x525c(%rip),%rdi # ffffffff8000b0d0 <_ZN3Hal16ExceptionStringsE+0xd0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005e74: 56 push %rsi +ffffffff80005e75: 51 push %rcx +ffffffff80005e76: 52 push %rdx +ffffffff80005e77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005e78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005e7d: c6 44 24 70 1a movb $0x1a,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005e82: fc cld +ffffffff80005e83: e8 28 f0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005e88: 58 pop %rax +ffffffff80005e89: 5a pop %rdx +ffffffff80005e8a: 59 pop %rcx +ffffffff80005e8b: 5e pop %rsi +ffffffff80005e8c: 5f pop %rdi +ffffffff80005e8d: 41 58 pop %r8 +ffffffff80005e8f: 41 59 pop %r9 +ffffffff80005e91: 41 5a pop %r10 +ffffffff80005e93: 41 5b pop %r11 +ffffffff80005e95: 48 cf iretq +ffffffff80005e97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005e9e: 00 00 + +ffffffff80005ea0 <_ZN3Hal16ExceptionHandlerILm27EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ea0: f3 0f 1e fa endbr64 +ffffffff80005ea4: 41 53 push %r11 +ffffffff80005ea6: 41 52 push %r10 +ffffffff80005ea8: 41 51 push %r9 +ffffffff80005eaa: 41 50 push %r8 +ffffffff80005eac: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005ead: 48 8b 3d 24 52 00 00 mov 0x5224(%rip),%rdi # ffffffff8000b0d8 <_ZN3Hal16ExceptionStringsE+0xd8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005eb4: 56 push %rsi +ffffffff80005eb5: 51 push %rcx +ffffffff80005eb6: 52 push %rdx +ffffffff80005eb7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005eb8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005ebd: c6 44 24 70 1b movb $0x1b,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005ec2: fc cld +ffffffff80005ec3: e8 e8 ef ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005ec8: 58 pop %rax +ffffffff80005ec9: 5a pop %rdx +ffffffff80005eca: 59 pop %rcx +ffffffff80005ecb: 5e pop %rsi +ffffffff80005ecc: 5f pop %rdi +ffffffff80005ecd: 41 58 pop %r8 +ffffffff80005ecf: 41 59 pop %r9 +ffffffff80005ed1: 41 5a pop %r10 +ffffffff80005ed3: 41 5b pop %r11 +ffffffff80005ed5: 48 cf iretq +ffffffff80005ed7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005ede: 00 00 + +ffffffff80005ee0 <_ZN3Hal16ExceptionHandlerILm28EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ee0: f3 0f 1e fa endbr64 +ffffffff80005ee4: 41 53 push %r11 +ffffffff80005ee6: 41 52 push %r10 +ffffffff80005ee8: 41 51 push %r9 +ffffffff80005eea: 41 50 push %r8 +ffffffff80005eec: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005eed: 48 8b 3d ec 51 00 00 mov 0x51ec(%rip),%rdi # ffffffff8000b0e0 <_ZN3Hal16ExceptionStringsE+0xe0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005ef4: 56 push %rsi +ffffffff80005ef5: 51 push %rcx +ffffffff80005ef6: 52 push %rdx +ffffffff80005ef7: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005ef8: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005efd: c6 44 24 70 1c movb $0x1c,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005f02: fc cld +ffffffff80005f03: e8 a8 ef ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005f08: 58 pop %rax +ffffffff80005f09: 5a pop %rdx +ffffffff80005f0a: 59 pop %rcx +ffffffff80005f0b: 5e pop %rsi +ffffffff80005f0c: 5f pop %rdi +ffffffff80005f0d: 41 58 pop %r8 +ffffffff80005f0f: 41 59 pop %r9 +ffffffff80005f11: 41 5a pop %r10 +ffffffff80005f13: 41 5b pop %r11 +ffffffff80005f15: 48 cf iretq +ffffffff80005f17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005f1e: 00 00 + +ffffffff80005f20 <_ZN3Hal16ExceptionHandlerILm29EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005f20: f3 0f 1e fa endbr64 +ffffffff80005f24: 41 53 push %r11 +ffffffff80005f26: 41 52 push %r10 +ffffffff80005f28: 41 51 push %r9 +ffffffff80005f2a: 41 50 push %r8 +ffffffff80005f2c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005f2d: 48 8b 3d b4 51 00 00 mov 0x51b4(%rip),%rdi # ffffffff8000b0e8 <_ZN3Hal16ExceptionStringsE+0xe8> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005f34: 56 push %rsi +ffffffff80005f35: 51 push %rcx +ffffffff80005f36: 52 push %rdx +ffffffff80005f37: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005f38: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005f3d: c6 44 24 70 1d movb $0x1d,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005f42: fc cld +ffffffff80005f43: e8 68 ef ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005f48: 58 pop %rax +ffffffff80005f49: 5a pop %rdx +ffffffff80005f4a: 59 pop %rcx +ffffffff80005f4b: 5e pop %rsi +ffffffff80005f4c: 5f pop %rdi +ffffffff80005f4d: 41 58 pop %r8 +ffffffff80005f4f: 41 59 pop %r9 +ffffffff80005f51: 41 5a pop %r10 +ffffffff80005f53: 41 5b pop %r11 +ffffffff80005f55: 48 cf iretq +ffffffff80005f57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005f5e: 00 00 + +ffffffff80005f60 <_ZN3Hal16ExceptionHandlerILm30EEEvPN6System10PanicFrameE>: + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005f60: f3 0f 1e fa endbr64 +ffffffff80005f64: 41 53 push %r11 +ffffffff80005f66: 41 52 push %r10 +ffffffff80005f68: 41 51 push %r9 +ffffffff80005f6a: 41 50 push %r8 +ffffffff80005f6c: 57 push %rdi + Panic(ExceptionStrings[i], frame); +ffffffff80005f6d: 48 8b 3d 7c 51 00 00 mov 0x517c(%rip),%rdi # ffffffff8000b0f0 <_ZN3Hal16ExceptionStringsE+0xf0> + __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame) +ffffffff80005f74: 56 push %rsi +ffffffff80005f75: 51 push %rcx +ffffffff80005f76: 52 push %rdx +ffffffff80005f77: 50 push %rax + Panic(ExceptionStrings[i], frame); +ffffffff80005f78: 48 8d 74 24 48 lea 0x48(%rsp),%rsi + frame->InterruptVector = i; +ffffffff80005f7d: c6 44 24 70 1e movb $0x1e,0x70(%rsp) + Panic(ExceptionStrings[i], frame); +ffffffff80005f82: fc cld +ffffffff80005f83: e8 28 ef ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80005f88: 58 pop %rax +ffffffff80005f89: 5a pop %rdx +ffffffff80005f8a: 59 pop %rcx +ffffffff80005f8b: 5e pop %rsi +ffffffff80005f8c: 5f pop %rdi +ffffffff80005f8d: 41 58 pop %r8 +ffffffff80005f8f: 41 59 pop %r9 +ffffffff80005f91: 41 5a pop %r10 +ffffffff80005f93: 41 5b pop %r11 +ffffffff80005f95: 48 cf iretq +ffffffff80005f97: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80005f9e: 00 00 + +ffffffff80005fa0 <_ZN3Hal10SetHandlerILi23ELi31EE3runEv>: + }; + } + + template + struct SetHandler { + static void run() { +ffffffff80005fa0: f3 0f 1e fa endbr64 + InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor)); +ffffffff80005fa4: 48 8b 05 f7 a3 0d 00 mov 0xda3f7(%rip),%rax # ffffffff800e03a2 <_ZN3Hal4IDTRE+0x2> + uint64_t offset = (uint64_t)handler; +ffffffff80005fab: 48 c7 c2 a0 5d 00 80 mov $0xffffffff80005da0,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80005fb2: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80005fb5: 66 89 90 70 01 00 00 mov %dx,0x170(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80005fbc: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80005fc0: 48 c1 ee 10 shr $0x10,%rsi + InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor)); +ffffffff80005fc4: 48 8d 88 e0 01 00 00 lea 0x1e0(%rax),%rcx + *ptr = InterruptDescriptor { +ffffffff80005fcb: 89 90 78 01 00 00 mov %edx,0x178(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80005fd1: 48 c7 c2 e0 5d 00 80 mov $0xffffffff80005de0,%rdx + *ptr = InterruptDescriptor { +ffffffff80005fd8: 66 89 b0 76 01 00 00 mov %si,0x176(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80005fdf: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80005fe2: 66 89 90 80 01 00 00 mov %dx,0x180(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80005fe9: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80005fed: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80005ff1: 89 90 88 01 00 00 mov %edx,0x188(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80005ff7: 48 c7 c2 20 5e 00 80 mov $0xffffffff80005e20,%rdx + *ptr = InterruptDescriptor { +ffffffff80005ffe: 66 89 b0 86 01 00 00 mov %si,0x186(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006005: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006008: 66 89 90 90 01 00 00 mov %dx,0x190(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000600f: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006013: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006017: 89 90 98 01 00 00 mov %edx,0x198(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff8000601d: 48 c7 c2 60 5e 00 80 mov $0xffffffff80005e60,%rdx + *ptr = InterruptDescriptor { +ffffffff80006024: 66 89 b0 96 01 00 00 mov %si,0x196(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000602b: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000602e: 66 89 90 a0 01 00 00 mov %dx,0x1a0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006035: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006039: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff8000603d: 89 90 a8 01 00 00 mov %edx,0x1a8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006043: 48 c7 c2 a0 5e 00 80 mov $0xffffffff80005ea0,%rdx + *ptr = InterruptDescriptor { +ffffffff8000604a: 66 89 b0 a6 01 00 00 mov %si,0x1a6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006051: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006054: 66 89 90 b0 01 00 00 mov %dx,0x1b0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000605b: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000605f: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006063: 89 90 b8 01 00 00 mov %edx,0x1b8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006069: 48 c7 c2 e0 5e 00 80 mov $0xffffffff80005ee0,%rdx + *ptr = InterruptDescriptor { +ffffffff80006070: 66 89 b0 b6 01 00 00 mov %si,0x1b6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006077: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000607a: 66 89 90 c0 01 00 00 mov %dx,0x1c0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006081: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006085: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006089: 89 90 c8 01 00 00 mov %edx,0x1c8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff8000608f: 48 c7 c2 20 5f 00 80 mov $0xffffffff80005f20,%rdx + *ptr = InterruptDescriptor { +ffffffff80006096: 66 89 b0 c6 01 00 00 mov %si,0x1c6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000609d: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff800060a0: 66 89 90 d0 01 00 00 mov %dx,0x1d0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800060a7: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800060ab: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff800060af: c7 80 72 01 00 00 08 movl $0x8f000008,0x172(%rax) +ffffffff800060b6: 00 00 8f +ffffffff800060b9: c7 80 7c 01 00 00 00 movl $0x0,0x17c(%rax) +ffffffff800060c0: 00 00 00 +ffffffff800060c3: c7 80 82 01 00 00 08 movl $0x8f000008,0x182(%rax) +ffffffff800060ca: 00 00 8f +ffffffff800060cd: c7 80 8c 01 00 00 00 movl $0x0,0x18c(%rax) +ffffffff800060d4: 00 00 00 +ffffffff800060d7: c7 80 92 01 00 00 08 movl $0x8f000008,0x192(%rax) +ffffffff800060de: 00 00 8f +ffffffff800060e1: c7 80 9c 01 00 00 00 movl $0x0,0x19c(%rax) +ffffffff800060e8: 00 00 00 +ffffffff800060eb: c7 80 a2 01 00 00 08 movl $0x8f000008,0x1a2(%rax) +ffffffff800060f2: 00 00 8f +ffffffff800060f5: c7 80 ac 01 00 00 00 movl $0x0,0x1ac(%rax) +ffffffff800060fc: 00 00 00 +ffffffff800060ff: c7 80 b2 01 00 00 08 movl $0x8f000008,0x1b2(%rax) +ffffffff80006106: 00 00 8f +ffffffff80006109: c7 80 bc 01 00 00 00 movl $0x0,0x1bc(%rax) +ffffffff80006110: 00 00 00 +ffffffff80006113: c7 80 c2 01 00 00 08 movl $0x8f000008,0x1c2(%rax) +ffffffff8000611a: 00 00 8f +ffffffff8000611d: c7 80 cc 01 00 00 00 movl $0x0,0x1cc(%rax) +ffffffff80006124: 00 00 00 +ffffffff80006127: c7 80 d2 01 00 00 08 movl $0x8f000008,0x1d2(%rax) +ffffffff8000612e: 00 00 8f +ffffffff80006131: 89 90 d8 01 00 00 mov %edx,0x1d8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006137: 48 c7 c2 60 5f 00 80 mov $0xffffffff80005f60,%rdx + *ptr = InterruptDescriptor { +ffffffff8000613e: 66 89 90 e0 01 00 00 mov %dx,0x1e0(%rax) +ffffffff80006145: 66 89 b0 d6 01 00 00 mov %si,0x1d6(%rax) +ffffffff8000614c: c7 80 dc 01 00 00 00 movl $0x0,0x1dc(%rax) +ffffffff80006153: 00 00 00 +ffffffff80006156: c7 80 e2 01 00 00 08 movl $0x8f000008,0x1e2(%rax) +ffffffff8000615d: 00 00 8f + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006160: 48 89 d0 mov %rdx,%rax + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006163: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006167: 48 c1 e8 10 shr $0x10,%rax + *ptr = InterruptDescriptor { +ffffffff8000616b: 89 51 08 mov %edx,0x8(%rcx) +ffffffff8000616e: 66 89 41 06 mov %ax,0x6(%rcx) +ffffffff80006172: c7 41 0c 00 00 00 00 movl $0x0,0xc(%rcx) + IDTEncodeInterrupt(I, (void*)&ExceptionHandler, TrapGate); + SetHandler::run(); + } +ffffffff80006179: c3 ret +ffffffff8000617a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + +ffffffff80006180 <_ZN3Hal10SetHandlerILi11ELi31EE3runEv>: + static void run() { +ffffffff80006180: f3 0f 1e fa endbr64 + InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor)); +ffffffff80006184: 48 8b 05 17 a2 0d 00 mov 0xda217(%rip),%rax # ffffffff800e03a2 <_ZN3Hal4IDTRE+0x2> + uint64_t offset = (uint64_t)handler; +ffffffff8000618b: 48 c7 c2 a0 5a 00 80 mov $0xffffffff80005aa0,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006192: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006195: 66 89 90 b0 00 00 00 mov %dx,0xb0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000619c: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061a0: 48 c1 ee 10 shr $0x10,%rsi + InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor)); +ffffffff800061a4: 48 8d 88 60 01 00 00 lea 0x160(%rax),%rcx + *ptr = InterruptDescriptor { +ffffffff800061ab: 89 90 b8 00 00 00 mov %edx,0xb8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff800061b1: 48 c7 c2 e0 5a 00 80 mov $0xffffffff80005ae0,%rdx + *ptr = InterruptDescriptor { +ffffffff800061b8: 66 89 b0 b6 00 00 00 mov %si,0xb6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061bf: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff800061c2: 66 89 90 c0 00 00 00 mov %dx,0xc0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800061c9: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061cd: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff800061d1: 89 90 c8 00 00 00 mov %edx,0xc8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff800061d7: 48 c7 c2 20 5b 00 80 mov $0xffffffff80005b20,%rdx + *ptr = InterruptDescriptor { +ffffffff800061de: 66 89 b0 c6 00 00 00 mov %si,0xc6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061e5: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff800061e8: 66 89 90 d0 00 00 00 mov %dx,0xd0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800061ef: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800061f3: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff800061f7: 89 90 d8 00 00 00 mov %edx,0xd8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff800061fd: 48 c7 c2 60 5b 00 80 mov $0xffffffff80005b60,%rdx + *ptr = InterruptDescriptor { +ffffffff80006204: 66 89 b0 d6 00 00 00 mov %si,0xd6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000620b: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000620e: 66 89 90 e0 00 00 00 mov %dx,0xe0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006215: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006219: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff8000621d: 89 90 e8 00 00 00 mov %edx,0xe8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006223: 48 c7 c2 a0 5b 00 80 mov $0xffffffff80005ba0,%rdx + *ptr = InterruptDescriptor { +ffffffff8000622a: 66 89 b0 e6 00 00 00 mov %si,0xe6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006231: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006234: 66 89 90 f0 00 00 00 mov %dx,0xf0(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000623b: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000623f: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006243: 89 90 f8 00 00 00 mov %edx,0xf8(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006249: 48 c7 c2 e0 5b 00 80 mov $0xffffffff80005be0,%rdx + *ptr = InterruptDescriptor { +ffffffff80006250: 66 89 b0 f6 00 00 00 mov %si,0xf6(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006257: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000625a: 66 89 90 00 01 00 00 mov %dx,0x100(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006261: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006265: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006269: 89 90 08 01 00 00 mov %edx,0x108(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff8000626f: 48 c7 c2 20 5c 00 80 mov $0xffffffff80005c20,%rdx + *ptr = InterruptDescriptor { +ffffffff80006276: 66 89 b0 06 01 00 00 mov %si,0x106(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000627d: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006280: 66 89 90 10 01 00 00 mov %dx,0x110(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006287: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000628b: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff8000628f: c7 80 b2 00 00 00 08 movl $0x8f000008,0xb2(%rax) +ffffffff80006296: 00 00 8f +ffffffff80006299: c7 80 bc 00 00 00 00 movl $0x0,0xbc(%rax) +ffffffff800062a0: 00 00 00 +ffffffff800062a3: c7 80 c2 00 00 00 08 movl $0x8f000008,0xc2(%rax) +ffffffff800062aa: 00 00 8f +ffffffff800062ad: c7 80 cc 00 00 00 00 movl $0x0,0xcc(%rax) +ffffffff800062b4: 00 00 00 +ffffffff800062b7: c7 80 d2 00 00 00 08 movl $0x8f000008,0xd2(%rax) +ffffffff800062be: 00 00 8f +ffffffff800062c1: c7 80 dc 00 00 00 00 movl $0x0,0xdc(%rax) +ffffffff800062c8: 00 00 00 +ffffffff800062cb: c7 80 e2 00 00 00 08 movl $0x8f000008,0xe2(%rax) +ffffffff800062d2: 00 00 8f +ffffffff800062d5: c7 80 ec 00 00 00 00 movl $0x0,0xec(%rax) +ffffffff800062dc: 00 00 00 +ffffffff800062df: c7 80 f2 00 00 00 08 movl $0x8f000008,0xf2(%rax) +ffffffff800062e6: 00 00 8f +ffffffff800062e9: c7 80 fc 00 00 00 00 movl $0x0,0xfc(%rax) +ffffffff800062f0: 00 00 00 +ffffffff800062f3: c7 80 02 01 00 00 08 movl $0x8f000008,0x102(%rax) +ffffffff800062fa: 00 00 8f +ffffffff800062fd: c7 80 0c 01 00 00 00 movl $0x0,0x10c(%rax) +ffffffff80006304: 00 00 00 +ffffffff80006307: c7 80 12 01 00 00 08 movl $0x8f000008,0x112(%rax) +ffffffff8000630e: 00 00 8f +ffffffff80006311: 89 90 18 01 00 00 mov %edx,0x118(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006317: 48 c7 c2 60 5c 00 80 mov $0xffffffff80005c60,%rdx + *ptr = InterruptDescriptor { +ffffffff8000631e: 66 89 b0 16 01 00 00 mov %si,0x116(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006325: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006328: 66 89 90 20 01 00 00 mov %dx,0x120(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000632f: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006333: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006337: 89 90 28 01 00 00 mov %edx,0x128(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff8000633d: 48 c7 c2 a0 5c 00 80 mov $0xffffffff80005ca0,%rdx + *ptr = InterruptDescriptor { +ffffffff80006344: 66 89 b0 26 01 00 00 mov %si,0x126(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000634b: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000634e: 66 89 90 30 01 00 00 mov %dx,0x130(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006355: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006359: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff8000635d: 89 90 38 01 00 00 mov %edx,0x138(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006363: 48 c7 c2 e0 5c 00 80 mov $0xffffffff80005ce0,%rdx + *ptr = InterruptDescriptor { +ffffffff8000636a: 66 89 b0 36 01 00 00 mov %si,0x136(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006371: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff80006374: 66 89 90 40 01 00 00 mov %dx,0x140(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000637b: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000637f: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff80006383: 89 90 48 01 00 00 mov %edx,0x148(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff80006389: 48 c7 c2 20 5d 00 80 mov $0xffffffff80005d20,%rdx + *ptr = InterruptDescriptor { +ffffffff80006390: 66 89 b0 46 01 00 00 mov %si,0x146(%rax) + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006397: 48 89 d6 mov %rdx,%rsi + *ptr = InterruptDescriptor { +ffffffff8000639a: 66 89 90 50 01 00 00 mov %dx,0x150(%rax) + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800063a1: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800063a5: 48 c1 ee 10 shr $0x10,%rsi + *ptr = InterruptDescriptor { +ffffffff800063a9: 89 90 58 01 00 00 mov %edx,0x158(%rax) + uint64_t offset = (uint64_t)handler; +ffffffff800063af: 48 c7 c2 60 5d 00 80 mov $0xffffffff80005d60,%rdx + *ptr = InterruptDescriptor { +ffffffff800063b6: 66 89 90 60 01 00 00 mov %dx,0x160(%rax) +ffffffff800063bd: c7 80 1c 01 00 00 00 movl $0x0,0x11c(%rax) +ffffffff800063c4: 00 00 00 +ffffffff800063c7: c7 80 22 01 00 00 08 movl $0x8f000008,0x122(%rax) +ffffffff800063ce: 00 00 8f +ffffffff800063d1: c7 80 2c 01 00 00 00 movl $0x0,0x12c(%rax) +ffffffff800063d8: 00 00 00 +ffffffff800063db: c7 80 32 01 00 00 08 movl $0x8f000008,0x132(%rax) +ffffffff800063e2: 00 00 8f +ffffffff800063e5: c7 80 3c 01 00 00 00 movl $0x0,0x13c(%rax) +ffffffff800063ec: 00 00 00 +ffffffff800063ef: c7 80 42 01 00 00 08 movl $0x8f000008,0x142(%rax) +ffffffff800063f6: 00 00 8f +ffffffff800063f9: c7 80 4c 01 00 00 00 movl $0x0,0x14c(%rax) +ffffffff80006400: 00 00 00 +ffffffff80006403: c7 80 52 01 00 00 08 movl $0x8f000008,0x152(%rax) +ffffffff8000640a: 00 00 8f +ffffffff8000640d: 66 89 b0 56 01 00 00 mov %si,0x156(%rax) +ffffffff80006414: c7 80 5c 01 00 00 00 movl $0x0,0x15c(%rax) +ffffffff8000641b: 00 00 00 +ffffffff8000641e: c7 80 62 01 00 00 08 movl $0x8f000008,0x162(%rax) +ffffffff80006425: 00 00 8f + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006428: 48 89 d0 mov %rdx,%rax + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000642b: 48 c1 ea 20 shr $0x20,%rdx + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000642f: 48 c1 e8 10 shr $0x10,%rax + *ptr = InterruptDescriptor { +ffffffff80006433: 89 51 08 mov %edx,0x8(%rcx) +ffffffff80006436: 66 89 41 06 mov %ax,0x6(%rcx) +ffffffff8000643a: c7 41 0c 00 00 00 00 movl $0x0,0xc(%rcx) + SetHandler::run(); +ffffffff80006441: e9 5a fb ff ff jmp ffffffff80005fa0 <_ZN3Hal10SetHandlerILi23ELi31EE3runEv> +ffffffff80006446: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000644d: 00 00 00 + +ffffffff80006450 <_ZN3Hal13IDTInitializeEv>: + }; + + template + struct SetHandler {static void run() {}}; + + void IDTInitialize() { +ffffffff80006450: f3 0f 1e fa endbr64 +ffffffff80006454: 48 83 ec 08 sub $0x8,%rsp + IDT = (InterruptDescriptor*)Memory::g_heap->Request(4096); +ffffffff80006458: 48 8b 3d 71 a3 0d 00 mov 0xda371(%rip),%rdi # ffffffff800e07d0 <_ZN6Memory6g_heapE> +ffffffff8000645f: be 00 10 00 00 mov $0x1000,%esi +ffffffff80006464: e8 57 07 00 00 call ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm> + IDTR.Limit = 0x0FF; +ffffffff80006469: b8 ff 00 00 00 mov $0xff,%eax + IDTR.Base = (uint64_t)&IDT; +ffffffff8000646e: 48 c7 05 29 9f 0d 00 movq $0xffffffff800e03b0,0xd9f29(%rip) # ffffffff800e03a2 <_ZN3Hal4IDTRE+0x2> +ffffffff80006475: b0 03 0e 80 + IDTR.Limit = 0x0FF; +ffffffff80006479: 66 89 05 20 9f 0d 00 mov %ax,0xd9f20(%rip) # ffffffff800e03a0 <_ZN3Hal4IDTRE> + uint64_t offset = (uint64_t)handler; +ffffffff80006480: 48 c7 c0 e0 57 00 80 mov $0xffffffff800057e0,%rax + *ptr = InterruptDescriptor { +ffffffff80006487: 66 89 05 22 9f 0d 00 mov %ax,0xd9f22(%rip) # ffffffff800e03b0 <_ZN3Hal3IDTE> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000648e: 48 89 c2 mov %rax,%rdx + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006491: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006495: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006499: 89 05 19 9f 0d 00 mov %eax,0xd9f19(%rip) # ffffffff800e03b8 <_ZN3Hal3IDTE+0x8> + uint64_t offset = (uint64_t)handler; +ffffffff8000649f: 48 c7 c0 20 58 00 80 mov $0xffffffff80005820,%rax + *ptr = InterruptDescriptor { +ffffffff800064a6: 66 89 15 09 9f 0d 00 mov %dx,0xd9f09(%rip) # ffffffff800e03b6 <_ZN3Hal3IDTE+0x6> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064ad: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff800064b0: 66 89 05 09 9f 0d 00 mov %ax,0xd9f09(%rip) # ffffffff800e03c0 <_ZN3Lib6outputE> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800064b7: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064bb: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff800064bf: 89 05 03 9f 0d 00 mov %eax,0xd9f03(%rip) # ffffffff800e03c8 <_ZN3Lib6outputE+0x8> + uint64_t offset = (uint64_t)handler; +ffffffff800064c5: 48 c7 c0 60 58 00 80 mov $0xffffffff80005860,%rax + *ptr = InterruptDescriptor { +ffffffff800064cc: 66 89 15 f3 9e 0d 00 mov %dx,0xd9ef3(%rip) # ffffffff800e03c6 <_ZN3Lib6outputE+0x6> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064d3: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff800064d6: 66 89 05 f3 9e 0d 00 mov %ax,0xd9ef3(%rip) # ffffffff800e03d0 <_ZN3Lib6outputE+0x10> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800064dd: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064e1: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff800064e5: 89 05 ed 9e 0d 00 mov %eax,0xd9eed(%rip) # ffffffff800e03d8 <_ZN3Lib6outputE+0x18> + uint64_t offset = (uint64_t)handler; +ffffffff800064eb: 48 c7 c0 a0 58 00 80 mov $0xffffffff800058a0,%rax + *ptr = InterruptDescriptor { +ffffffff800064f2: 66 89 15 dd 9e 0d 00 mov %dx,0xd9edd(%rip) # ffffffff800e03d6 <_ZN3Lib6outputE+0x16> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff800064f9: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff800064fc: 66 89 05 dd 9e 0d 00 mov %ax,0xd9edd(%rip) # ffffffff800e03e0 <_ZN3Lib6outputE+0x20> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006503: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006507: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff8000650b: 89 05 d7 9e 0d 00 mov %eax,0xd9ed7(%rip) # ffffffff800e03e8 <_ZN3Lib6outputE+0x28> + uint64_t offset = (uint64_t)handler; +ffffffff80006511: 48 c7 c0 e0 58 00 80 mov $0xffffffff800058e0,%rax + *ptr = InterruptDescriptor { +ffffffff80006518: 66 89 15 c7 9e 0d 00 mov %dx,0xd9ec7(%rip) # ffffffff800e03e6 <_ZN3Lib6outputE+0x26> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000651f: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff80006522: 66 89 05 c7 9e 0d 00 mov %ax,0xd9ec7(%rip) # ffffffff800e03f0 <_ZN3Lib6outputE+0x30> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006529: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000652d: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006531: 89 05 c1 9e 0d 00 mov %eax,0xd9ec1(%rip) # ffffffff800e03f8 <_ZN3Lib6outputE+0x38> + uint64_t offset = (uint64_t)handler; +ffffffff80006537: 48 c7 c0 20 59 00 80 mov $0xffffffff80005920,%rax + *ptr = InterruptDescriptor { +ffffffff8000653e: 66 89 15 b1 9e 0d 00 mov %dx,0xd9eb1(%rip) # ffffffff800e03f6 <_ZN3Lib6outputE+0x36> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006545: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff80006548: 66 89 05 b1 9e 0d 00 mov %ax,0xd9eb1(%rip) # ffffffff800e0400 <_ZN3Lib6outputE+0x40> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000654f: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006553: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006557: 89 05 ab 9e 0d 00 mov %eax,0xd9eab(%rip) # ffffffff800e0408 <_ZN3Lib6outputE+0x48> + uint64_t offset = (uint64_t)handler; +ffffffff8000655d: 48 c7 c0 60 59 00 80 mov $0xffffffff80005960,%rax + *ptr = InterruptDescriptor { +ffffffff80006564: 66 89 15 9b 9e 0d 00 mov %dx,0xd9e9b(%rip) # ffffffff800e0406 <_ZN3Lib6outputE+0x46> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000656b: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff8000656e: c7 05 3a 9e 0d 00 08 movl $0x8f000008,0xd9e3a(%rip) # ffffffff800e03b2 <_ZN3Hal3IDTE+0x2> +ffffffff80006575: 00 00 8f + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006578: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff8000657c: c7 05 36 9e 0d 00 00 movl $0x0,0xd9e36(%rip) # ffffffff800e03bc <_ZN3Hal3IDTE+0xc> +ffffffff80006583: 00 00 00 +ffffffff80006586: c7 05 32 9e 0d 00 08 movl $0x8f000008,0xd9e32(%rip) # ffffffff800e03c2 <_ZN3Lib6outputE+0x2> +ffffffff8000658d: 00 00 8f +ffffffff80006590: c7 05 32 9e 0d 00 00 movl $0x0,0xd9e32(%rip) # ffffffff800e03cc <_ZN3Lib6outputE+0xc> +ffffffff80006597: 00 00 00 +ffffffff8000659a: c7 05 2e 9e 0d 00 08 movl $0x8f000008,0xd9e2e(%rip) # ffffffff800e03d2 <_ZN3Lib6outputE+0x12> +ffffffff800065a1: 00 00 8f +ffffffff800065a4: c7 05 2e 9e 0d 00 00 movl $0x0,0xd9e2e(%rip) # ffffffff800e03dc <_ZN3Lib6outputE+0x1c> +ffffffff800065ab: 00 00 00 +ffffffff800065ae: c7 05 2a 9e 0d 00 08 movl $0x8f000008,0xd9e2a(%rip) # ffffffff800e03e2 <_ZN3Lib6outputE+0x22> +ffffffff800065b5: 00 00 8f +ffffffff800065b8: c7 05 2a 9e 0d 00 00 movl $0x0,0xd9e2a(%rip) # ffffffff800e03ec <_ZN3Lib6outputE+0x2c> +ffffffff800065bf: 00 00 00 +ffffffff800065c2: c7 05 26 9e 0d 00 08 movl $0x8f000008,0xd9e26(%rip) # ffffffff800e03f2 <_ZN3Lib6outputE+0x32> +ffffffff800065c9: 00 00 8f +ffffffff800065cc: c7 05 26 9e 0d 00 00 movl $0x0,0xd9e26(%rip) # ffffffff800e03fc <_ZN3Lib6outputE+0x3c> +ffffffff800065d3: 00 00 00 +ffffffff800065d6: c7 05 22 9e 0d 00 08 movl $0x8f000008,0xd9e22(%rip) # ffffffff800e0402 <_ZN3Lib6outputE+0x42> +ffffffff800065dd: 00 00 8f +ffffffff800065e0: c7 05 22 9e 0d 00 00 movl $0x0,0xd9e22(%rip) # ffffffff800e040c <_ZN3Lib6outputE+0x4c> +ffffffff800065e7: 00 00 00 +ffffffff800065ea: 66 89 05 1f 9e 0d 00 mov %ax,0xd9e1f(%rip) # ffffffff800e0410 <_ZN3Lib6outputE+0x50> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff800065f1: 48 c1 e8 20 shr $0x20,%rax + *ptr = InterruptDescriptor { +ffffffff800065f5: 89 05 1d 9e 0d 00 mov %eax,0xd9e1d(%rip) # ffffffff800e0418 <_ZN3Lib6outputE+0x58> + uint64_t offset = (uint64_t)handler; +ffffffff800065fb: 48 c7 c0 a0 59 00 80 mov $0xffffffff800059a0,%rax + *ptr = InterruptDescriptor { +ffffffff80006602: 66 89 15 0d 9e 0d 00 mov %dx,0xd9e0d(%rip) # ffffffff800e0416 <_ZN3Lib6outputE+0x56> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006609: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff8000660c: 66 89 05 0d 9e 0d 00 mov %ax,0xd9e0d(%rip) # ffffffff800e0420 <_ZN3Lib6outputE+0x60> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006613: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006617: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff8000661b: 89 05 07 9e 0d 00 mov %eax,0xd9e07(%rip) # ffffffff800e0428 <_ZN3Lib6outputE+0x68> + uint64_t offset = (uint64_t)handler; +ffffffff80006621: 48 c7 c0 e0 59 00 80 mov $0xffffffff800059e0,%rax + *ptr = InterruptDescriptor { +ffffffff80006628: 66 89 15 f7 9d 0d 00 mov %dx,0xd9df7(%rip) # ffffffff800e0426 <_ZN3Lib6outputE+0x66> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000662f: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff80006632: 66 89 05 f7 9d 0d 00 mov %ax,0xd9df7(%rip) # ffffffff800e0430 <_ZN3Lib6outputE+0x70> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006639: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000663d: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006641: 89 05 f1 9d 0d 00 mov %eax,0xd9df1(%rip) # ffffffff800e0438 <_ZN3Lib6outputE+0x78> + uint64_t offset = (uint64_t)handler; +ffffffff80006647: 48 c7 c0 20 5a 00 80 mov $0xffffffff80005a20,%rax + *ptr = InterruptDescriptor { +ffffffff8000664e: 66 89 15 e1 9d 0d 00 mov %dx,0xd9de1(%rip) # ffffffff800e0436 <_ZN3Lib6outputE+0x76> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006655: 48 89 c2 mov %rax,%rdx + *ptr = InterruptDescriptor { +ffffffff80006658: 66 89 05 e1 9d 0d 00 mov %ax,0xd9de1(%rip) # ffffffff800e0440 <_ZN3Lib6outputE+0x80> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff8000665f: 48 c1 e8 20 shr $0x20,%rax + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff80006663: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006667: 89 05 db 9d 0d 00 mov %eax,0xd9ddb(%rip) # ffffffff800e0448 <_ZN3Lib6outputE+0x88> + uint64_t offset = (uint64_t)handler; +ffffffff8000666d: 48 c7 c0 60 5a 00 80 mov $0xffffffff80005a60,%rax + *ptr = InterruptDescriptor { +ffffffff80006674: 66 89 15 cb 9d 0d 00 mov %dx,0xd9dcb(%rip) # ffffffff800e0446 <_ZN3Lib6outputE+0x86> + .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16), +ffffffff8000667b: 48 89 c2 mov %rax,%rdx +ffffffff8000667e: 48 c1 ea 10 shr $0x10,%rdx + *ptr = InterruptDescriptor { +ffffffff80006682: 66 89 05 c7 9d 0d 00 mov %ax,0xd9dc7(%rip) # ffffffff800e0450 <_ZN3Lib6outputE+0x90> + .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32), +ffffffff80006689: 48 c1 e8 20 shr $0x20,%rax + *ptr = InterruptDescriptor { +ffffffff8000668d: 66 89 15 c2 9d 0d 00 mov %dx,0xd9dc2(%rip) # ffffffff800e0456 <_ZN3Lib6outputE+0x96> +ffffffff80006694: 89 05 be 9d 0d 00 mov %eax,0xd9dbe(%rip) # ffffffff800e0458 <_ZN3Lib6outputE+0x98> +ffffffff8000669a: c7 05 6e 9d 0d 00 08 movl $0x8f000008,0xd9d6e(%rip) # ffffffff800e0412 <_ZN3Lib6outputE+0x52> +ffffffff800066a1: 00 00 8f +ffffffff800066a4: c7 05 6e 9d 0d 00 00 movl $0x0,0xd9d6e(%rip) # ffffffff800e041c <_ZN3Lib6outputE+0x5c> +ffffffff800066ab: 00 00 00 +ffffffff800066ae: c7 05 6a 9d 0d 00 08 movl $0x8f000008,0xd9d6a(%rip) # ffffffff800e0422 <_ZN3Lib6outputE+0x62> +ffffffff800066b5: 00 00 8f +ffffffff800066b8: c7 05 6a 9d 0d 00 00 movl $0x0,0xd9d6a(%rip) # ffffffff800e042c <_ZN3Lib6outputE+0x6c> +ffffffff800066bf: 00 00 00 +ffffffff800066c2: c7 05 66 9d 0d 00 08 movl $0x8f000008,0xd9d66(%rip) # ffffffff800e0432 <_ZN3Lib6outputE+0x72> +ffffffff800066c9: 00 00 8f +ffffffff800066cc: c7 05 66 9d 0d 00 00 movl $0x0,0xd9d66(%rip) # ffffffff800e043c <_ZN3Lib6outputE+0x7c> +ffffffff800066d3: 00 00 00 +ffffffff800066d6: c7 05 62 9d 0d 00 08 movl $0x8f000008,0xd9d62(%rip) # ffffffff800e0442 <_ZN3Lib6outputE+0x82> +ffffffff800066dd: 00 00 8f +ffffffff800066e0: c7 05 62 9d 0d 00 00 movl $0x0,0xd9d62(%rip) # ffffffff800e044c <_ZN3Lib6outputE+0x8c> +ffffffff800066e7: 00 00 00 +ffffffff800066ea: c7 05 5e 9d 0d 00 08 movl $0x8f000008,0xd9d5e(%rip) # ffffffff800e0452 <_ZN3Lib6outputE+0x92> +ffffffff800066f1: 00 00 8f +ffffffff800066f4: c7 05 5e 9d 0d 00 00 movl $0x0,0xd9d5e(%rip) # ffffffff800e045c <_ZN3Lib6outputE+0x9c> +ffffffff800066fb: 00 00 00 + SetHandler::run(); +ffffffff800066fe: e8 7d fa ff ff call ffffffff80006180 <_ZN3Hal10SetHandlerILi11ELi31EE3runEv> +ffffffff80006703: 48 c7 c7 90 ad 00 80 mov $0xffffffff8000ad90,%rdi +ffffffff8000670a: e8 71 08 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000670f: 48 c7 c7 c0 a9 00 80 mov $0xffffffff8000a9c0,%rdi +ffffffff80006716: e8 65 08 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + asm("lidt %0" : : "m"(idtr)); +ffffffff8000671b: 0f 01 1d 7e 9c 0d 00 lidt 0xd9c7e(%rip) # ffffffff800e03a0 <_ZN3Hal4IDTRE> +ffffffff80006722: 48 c7 c7 d0 ad 00 80 mov $0xffffffff8000add0,%rdi +ffffffff80006729: e8 52 08 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000672e: 48 c7 c7 c0 a9 00 80 mov $0xffffffff8000a9c0,%rdi + kout << "HardwareAbstraction: Created exception interrupt vectors" << "\n"; + + LoadIDT(IDTR); + + kout << "HardwareAbstraction: Loaded new IDT" << "\n"; + } +ffffffff80006735: 48 83 c4 08 add $0x8,%rsp +ffffffff80006739: e9 42 08 00 00 jmp ffffffff80006f80 <_ZN2Kt5PrintEPKc> +ffffffff8000673e: 66 90 xchg %ax,%ax + +ffffffff80006740 : +// They CAN be moved to a different .cpp file. +#include + +extern "C" { + + void *memcpy(void *dest, const void *src, std::size_t n) { +ffffffff80006740: f3 0f 1e fa endbr64 +ffffffff80006744: 48 89 f8 mov %rdi,%rax + std::uint8_t *pdest = static_cast(dest); + const std::uint8_t *psrc = static_cast(src); + + for (std::size_t i = 0; i < n; i++) { +ffffffff80006747: 48 85 d2 test %rdx,%rdx +ffffffff8000674a: 74 16 je ffffffff80006762 +ffffffff8000674c: 31 c9 xor %ecx,%ecx +ffffffff8000674e: 66 90 xchg %ax,%ax + pdest[i] = psrc[i]; +ffffffff80006750: 44 0f b6 04 0e movzbl (%rsi,%rcx,1),%r8d +ffffffff80006755: 44 88 04 08 mov %r8b,(%rax,%rcx,1) + for (std::size_t i = 0; i < n; i++) { +ffffffff80006759: 48 83 c1 01 add $0x1,%rcx +ffffffff8000675d: 48 39 ca cmp %rcx,%rdx +ffffffff80006760: 75 ee jne ffffffff80006750 + } + + return dest; + } +ffffffff80006762: c3 ret +ffffffff80006763: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000676a: 00 00 00 +ffffffff8000676d: 0f 1f 00 nopl (%rax) + +ffffffff80006770 : + + void *memset(void *s, int c, std::size_t n) { +ffffffff80006770: f3 0f 1e fa endbr64 +ffffffff80006774: 48 89 f8 mov %rdi,%rax +ffffffff80006777: 48 89 f9 mov %rdi,%rcx +ffffffff8000677a: 48 8d 3c 3a lea (%rdx,%rdi,1),%rdi + std::uint8_t *p = static_cast(s); + + for (std::size_t i = 0; i < n; i++) { + p[i] = static_cast(c); +ffffffff8000677e: 41 89 f0 mov %esi,%r8d + for (std::size_t i = 0; i < n; i++) { +ffffffff80006781: 48 85 d2 test %rdx,%rdx +ffffffff80006784: 74 2a je ffffffff800067b0 +ffffffff80006786: 48 89 fa mov %rdi,%rdx +ffffffff80006789: 48 29 c2 sub %rax,%rdx +ffffffff8000678c: 83 e2 01 and $0x1,%edx +ffffffff8000678f: 74 0f je ffffffff800067a0 +ffffffff80006791: 48 8d 48 01 lea 0x1(%rax),%rcx + p[i] = static_cast(c); +ffffffff80006795: 40 88 30 mov %sil,(%rax) + for (std::size_t i = 0; i < n; i++) { +ffffffff80006798: 48 39 f9 cmp %rdi,%rcx +ffffffff8000679b: 74 14 je ffffffff800067b1 +ffffffff8000679d: 0f 1f 00 nopl (%rax) + p[i] = static_cast(c); +ffffffff800067a0: 44 88 01 mov %r8b,(%rcx) + for (std::size_t i = 0; i < n; i++) { +ffffffff800067a3: 48 83 c1 02 add $0x2,%rcx + p[i] = static_cast(c); +ffffffff800067a7: 44 88 41 ff mov %r8b,-0x1(%rcx) + for (std::size_t i = 0; i < n; i++) { +ffffffff800067ab: 48 39 f9 cmp %rdi,%rcx +ffffffff800067ae: 75 f0 jne ffffffff800067a0 + } + + return s; + } +ffffffff800067b0: c3 ret +ffffffff800067b1: c3 ret +ffffffff800067b2: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800067b9: 00 00 00 +ffffffff800067bc: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff800067c0 <_ZN3Lib13u64_2_basestrEmm.part.0>: + str[si++] = tmp[rdi--]; + str[si] = '\0'; + return str; + } + + char *u64_2_basestr(uint64_t num, size_t radix) +ffffffff800067c0: 48 81 ec 20 01 00 00 sub $0x120,%rsp + + if (!num) { + return (char *)"0"; + } + + char base[] = "0123456789ABCDEFGH"; // IJKLMN .... +ffffffff800067c7: 48 b8 30 31 32 33 34 movabs $0x3736353433323130,%rax +ffffffff800067ce: 35 36 37 +ffffffff800067d1: 48 89 44 24 0d mov %rax,0xd(%rsp) +ffffffff800067d6: 48 b8 38 39 41 42 43 movabs $0x4645444342413938,%rax +ffffffff800067dd: 44 45 46 +ffffffff800067e0: 48 89 44 24 15 mov %rax,0x15(%rsp) + + if (radix < 2 || radix > (sizeof(base) - 1)) +ffffffff800067e5: 48 8d 46 fe lea -0x2(%rsi),%rax + char base[] = "0123456789ABCDEFGH"; // IJKLMN .... +ffffffff800067e9: c7 44 24 1c 46 47 48 movl $0x484746,0x1c(%rsp) +ffffffff800067f0: 00 + if (radix < 2 || radix > (sizeof(base) - 1)) +ffffffff800067f1: 48 83 f8 10 cmp $0x10,%rax +ffffffff800067f5: 0f 87 8d 00 00 00 ja ffffffff80006888 <_ZN3Lib13u64_2_basestrEmm.part.0+0xc8> + + int si = 0; + + char tmp[256]; + int rdi = -1; + while (num) +ffffffff800067fb: 45 31 c0 xor %r8d,%r8d +ffffffff800067fe: 48 c7 c1 c0 03 0e 80 mov $0xffffffff800e03c0,%rcx +ffffffff80006805: 48 85 ff test %rdi,%rdi +ffffffff80006808: 74 65 je ffffffff8000686f <_ZN3Lib13u64_2_basestrEmm.part.0+0xaf> +ffffffff8000680a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + { + tmp[++rdi] = base[num % radix]; +ffffffff80006810: 48 89 f8 mov %rdi,%rax +ffffffff80006813: 31 d2 xor %edx,%edx +ffffffff80006815: 4c 89 c1 mov %r8,%rcx +ffffffff80006818: 48 f7 f6 div %rsi +ffffffff8000681b: 0f b6 54 14 0d movzbl 0xd(%rsp,%rdx,1),%edx +ffffffff80006820: 42 88 54 04 20 mov %dl,0x20(%rsp,%r8,1) + num /= radix; +ffffffff80006825: 48 89 fa mov %rdi,%rdx + while (num) +ffffffff80006828: 4d 8d 40 01 lea 0x1(%r8),%r8 + num /= radix; +ffffffff8000682c: 48 89 c7 mov %rax,%rdi + while (num) +ffffffff8000682f: 48 39 f2 cmp %rsi,%rdx +ffffffff80006832: 73 dc jae ffffffff80006810 <_ZN3Lib13u64_2_basestrEmm.part.0+0x50> +ffffffff80006834: 48 63 c1 movslq %ecx,%rax +ffffffff80006837: 48 8d 7c 24 20 lea 0x20(%rsp),%rdi + tmp[++rdi] = base[num % radix]; +ffffffff8000683c: 31 d2 xor %edx,%edx +ffffffff8000683e: 48 01 f8 add %rdi,%rax +ffffffff80006841: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + } + while (rdi >= 0) + str[si++] = tmp[rdi--]; +ffffffff80006848: 0f b6 30 movzbl (%rax),%esi + while (rdi >= 0) +ffffffff8000684b: 48 83 e8 01 sub $0x1,%rax + str[si++] = tmp[rdi--]; +ffffffff8000684f: 40 88 b2 c0 03 0e 80 mov %sil,-0x7ff1fc40(%rdx) + while (rdi >= 0) +ffffffff80006856: 48 89 d6 mov %rdx,%rsi +ffffffff80006859: 48 83 c2 01 add $0x1,%rdx +ffffffff8000685d: 48 39 ce cmp %rcx,%rsi +ffffffff80006860: 75 e6 jne ffffffff80006848 <_ZN3Lib13u64_2_basestrEmm.part.0+0x88> + str[si] = '\0'; +ffffffff80006862: 83 c1 01 add $0x1,%ecx +ffffffff80006865: 48 63 c9 movslq %ecx,%rcx +ffffffff80006868: 48 81 c1 c0 03 0e 80 add $0xffffffff800e03c0,%rcx +ffffffff8000686f: c6 01 00 movb $0x0,(%rcx) + return str; + } +ffffffff80006872: 48 c7 c0 c0 03 0e 80 mov $0xffffffff800e03c0,%rax +ffffffff80006879: 48 81 c4 20 01 00 00 add $0x120,%rsp +ffffffff80006880: c3 ret +ffffffff80006881: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + str[0] = '\0'; +ffffffff80006888: c6 05 31 9b 0d 00 00 movb $0x0,0xd9b31(%rip) # ffffffff800e03c0 <_ZN3Lib6outputE> + } +ffffffff8000688f: 48 c7 c0 c0 03 0e 80 mov $0xffffffff800e03c0,%rax +ffffffff80006896: 48 81 c4 20 01 00 00 add $0x120,%rsp +ffffffff8000689d: c3 ret +ffffffff8000689e: 66 90 xchg %ax,%ax + +ffffffff800068a0 <_ZN3Lib11int2basestrEim>: + { +ffffffff800068a0: f3 0f 1e fa endbr64 + if (!num) { +ffffffff800068a4: 85 ff test %edi,%edi +ffffffff800068a6: 0f 84 d4 00 00 00 je ffffffff80006980 <_ZN3Lib11int2basestrEim+0xe0> + { +ffffffff800068ac: 48 81 ec 20 01 00 00 sub $0x120,%rsp + char base[] = "0123456789ABCDEFGH"; // IJKLMN .... +ffffffff800068b3: 48 b8 30 31 32 33 34 movabs $0x3736353433323130,%rax +ffffffff800068ba: 35 36 37 +ffffffff800068bd: 48 89 44 24 0d mov %rax,0xd(%rsp) +ffffffff800068c2: 48 b8 38 39 41 42 43 movabs $0x4645444342413938,%rax +ffffffff800068c9: 44 45 46 +ffffffff800068cc: 48 89 44 24 15 mov %rax,0x15(%rsp) + if (radix < 2 || radix > (sizeof(base) - 1)) +ffffffff800068d1: 48 8d 46 fe lea -0x2(%rsi),%rax + char base[] = "0123456789ABCDEFGH"; // IJKLMN .... +ffffffff800068d5: c7 44 24 1c 46 47 48 movl $0x484746,0x1c(%rsp) +ffffffff800068dc: 00 + if (radix < 2 || radix > (sizeof(base) - 1)) +ffffffff800068dd: 48 83 f8 10 cmp $0x10,%rax +ffffffff800068e1: 77 7d ja ffffffff80006960 <_ZN3Lib11int2basestrEim+0xc0> + if (num < 0) +ffffffff800068e3: 45 31 c9 xor %r9d,%r9d +ffffffff800068e6: 85 ff test %edi,%edi +ffffffff800068e8: 0f 88 a2 00 00 00 js ffffffff80006990 <_ZN3Lib11int2basestrEim+0xf0> + str[si++] = '-'; +ffffffff800068ee: 31 c9 xor %ecx,%ecx + tmp[++rdi] = base[num % radix]; +ffffffff800068f0: 48 63 c7 movslq %edi,%rax +ffffffff800068f3: 31 d2 xor %edx,%edx +ffffffff800068f5: 49 89 c8 mov %rcx,%r8 +ffffffff800068f8: 48 f7 f6 div %rsi +ffffffff800068fb: 0f b6 54 14 0d movzbl 0xd(%rsp,%rdx,1),%edx + num /= radix; +ffffffff80006900: 89 c7 mov %eax,%edi + tmp[++rdi] = base[num % radix]; +ffffffff80006902: 88 54 0c 20 mov %dl,0x20(%rsp,%rcx,1) + while (num) +ffffffff80006906: 48 8d 49 01 lea 0x1(%rcx),%rcx +ffffffff8000690a: 85 c0 test %eax,%eax +ffffffff8000690c: 75 e2 jne ffffffff800068f0 <_ZN3Lib11int2basestrEim+0x50> +ffffffff8000690e: 48 8d 74 24 20 lea 0x20(%rsp),%rsi +ffffffff80006913: 49 63 c9 movslq %r9d,%rcx +ffffffff80006916: 49 63 c0 movslq %r8d,%rax +ffffffff80006919: 48 01 f0 add %rsi,%rax +ffffffff8000691c: 48 8d 91 c0 03 0e 80 lea -0x7ff1fc40(%rcx),%rdx +ffffffff80006923: 4a 8d b4 01 c1 03 0e lea -0x7ff1fc3f(%rcx,%r8,1),%rsi +ffffffff8000692a: 80 +ffffffff8000692b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + str[si++] = tmp[rdi--]; +ffffffff80006930: 0f b6 08 movzbl (%rax),%ecx + while (rdi >= 0) +ffffffff80006933: 48 83 c2 01 add $0x1,%rdx +ffffffff80006937: 48 83 e8 01 sub $0x1,%rax + str[si++] = tmp[rdi--]; +ffffffff8000693b: 88 4a ff mov %cl,-0x1(%rdx) + while (rdi >= 0) +ffffffff8000693e: 48 39 f2 cmp %rsi,%rdx +ffffffff80006941: 75 ed jne ffffffff80006930 <_ZN3Lib11int2basestrEim+0x90> + str[si] = '\0'; +ffffffff80006943: 43 8d 44 01 01 lea 0x1(%r9,%r8,1),%eax +ffffffff80006948: 48 98 cltq +ffffffff8000694a: c6 80 c0 03 0e 80 00 movb $0x0,-0x7ff1fc40(%rax) + return str; +ffffffff80006951: 48 c7 c0 c0 03 0e 80 mov $0xffffffff800e03c0,%rax + } +ffffffff80006958: 48 81 c4 20 01 00 00 add $0x120,%rsp +ffffffff8000695f: c3 ret + str[0] = '\0'; +ffffffff80006960: c6 05 59 9a 0d 00 00 movb $0x0,0xd9a59(%rip) # ffffffff800e03c0 <_ZN3Lib6outputE> + return str; +ffffffff80006967: 48 c7 c0 c0 03 0e 80 mov $0xffffffff800e03c0,%rax + } +ffffffff8000696e: 48 81 c4 20 01 00 00 add $0x120,%rsp +ffffffff80006975: c3 ret +ffffffff80006976: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff8000697d: 00 00 00 +ffffffff80006980: 48 c7 c0 c3 ac 00 80 mov $0xffffffff8000acc3,%rax +ffffffff80006987: c3 ret +ffffffff80006988: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff8000698f: 00 + str[si++] = '-'; +ffffffff80006990: c6 05 29 9a 0d 00 2d movb $0x2d,0xd9a29(%rip) # ffffffff800e03c0 <_ZN3Lib6outputE> + num = -num; +ffffffff80006997: f7 df neg %edi + str[si++] = '-'; +ffffffff80006999: 41 b9 01 00 00 00 mov $0x1,%r9d +ffffffff8000699f: e9 4a ff ff ff jmp ffffffff800068ee <_ZN3Lib11int2basestrEim+0x4e> +ffffffff800069a4: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff800069ab: 00 00 00 +ffffffff800069ae: 66 90 xchg %ax,%ax + +ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>: + { +ffffffff800069b0: f3 0f 1e fa endbr64 + if (!num) { +ffffffff800069b4: 48 85 ff test %rdi,%rdi +ffffffff800069b7: 74 07 je ffffffff800069c0 <_ZN3Lib13u64_2_basestrEmm+0x10> +ffffffff800069b9: e9 02 fe ff ff jmp ffffffff800067c0 <_ZN3Lib13u64_2_basestrEmm.part.0> +ffffffff800069be: 66 90 xchg %ax,%ax + } +ffffffff800069c0: 48 c7 c0 c3 ac 00 80 mov $0xffffffff8000acc3,%rax +ffffffff800069c7: c3 ret +ffffffff800069c8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff800069cf: 00 + +ffffffff800069d0 : + +// Extern declarations for global constructors array. +extern void (*__init_array[])(); +extern void (*__init_array_end[])(); + +extern "C" void kmain() { +ffffffff800069d0: f3 0f 1e fa endbr64 +ffffffff800069d4: 53 push %rbx +ffffffff800069d5: 48 83 ec 20 sub $0x20,%rsp + if (LIMINE_BASE_REVISION_SUPPORTED == false) { +ffffffff800069d9: 48 8b 05 40 97 ff ff mov -0x68c0(%rip),%rax # ffffffff80000120 <_ZN12_GLOBAL__N_120limine_base_revisionE+0x10> +ffffffff800069e0: 48 85 c0 test %rax,%rax +ffffffff800069e3: 0f 85 47 01 00 00 jne ffffffff80006b30 + hcf(); + } + + // Call global constructors. + for (std::size_t i = 0; &__init_array[i] != __init_array_end; i++) { +ffffffff800069e9: 48 c7 c0 0f af 00 80 mov $0xffffffff8000af0f,%rax +ffffffff800069f0: 48 3d 0f af 00 80 cmp $0xffffffff8000af0f,%rax +ffffffff800069f6: 74 17 je ffffffff80006a0f +ffffffff800069f8: 48 89 c3 mov %rax,%rbx +ffffffff800069fb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + __init_array[i](); +ffffffff80006a00: ff 13 call *(%rbx) + for (std::size_t i = 0; &__init_array[i] != __init_array_end; i++) { +ffffffff80006a02: 48 83 c3 08 add $0x8,%rbx +ffffffff80006a06: 48 81 fb 0f af 00 80 cmp $0xffffffff8000af0f,%rbx +ffffffff80006a0d: 75 f1 jne ffffffff80006a00 + } + + if (framebuffer_request.response == nullptr +ffffffff80006a0f: 48 8b 05 f2 96 ff ff mov -0x690e(%rip),%rax # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28> + || framebuffer_request.response->framebuffer_count < 1) { +ffffffff80006a16: 48 85 c0 test %rax,%rax +ffffffff80006a19: 0f 84 01 01 00 00 je ffffffff80006b20 +ffffffff80006a1f: 48 8b 05 e2 96 ff ff mov -0x691e(%rip),%rax # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28> +ffffffff80006a26: 48 83 78 08 00 cmpq $0x0,0x8(%rax) +ffffffff80006a2b: 0f 84 ef 00 00 00 je ffffffff80006b20 + hcf(); + } + + limine_framebuffer *framebuffer{framebuffer_request.response->framebuffers[0]}; +ffffffff80006a31: 48 8b 05 d0 96 ff ff mov -0x6930(%rip),%rax # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28> +ffffffff80006a38: 48 8b 40 10 mov 0x10(%rax),%rax +ffffffff80006a3c: 48 8b 00 mov (%rax),%rax + + Kt::Initialize( +ffffffff80006a3f: 44 0f b6 50 28 movzbl 0x28(%rax),%r10d +ffffffff80006a44: 44 0f b6 48 24 movzbl 0x24(%rax),%r9d +ffffffff80006a49: 44 0f b6 40 23 movzbl 0x23(%rax),%r8d +ffffffff80006a4e: 48 8b 48 18 mov 0x18(%rax),%rcx +ffffffff80006a52: 48 8b 50 10 mov 0x10(%rax),%rdx +ffffffff80006a56: 48 8b 70 08 mov 0x8(%rax),%rsi +ffffffff80006a5a: 48 8b 38 mov (%rax),%rdi +ffffffff80006a5d: 41 52 push %r10 +ffffffff80006a5f: 44 0f b6 50 27 movzbl 0x27(%rax),%r10d +ffffffff80006a64: 41 52 push %r10 +ffffffff80006a66: 44 0f b6 50 26 movzbl 0x26(%rax),%r10d +ffffffff80006a6b: 41 52 push %r10 +ffffffff80006a6d: 0f b6 40 25 movzbl 0x25(%rax),%eax +ffffffff80006a71: 50 push %rax +ffffffff80006a72: e8 59 04 00 00 call ffffffff80006ed0 <_ZN2Kt10InitializeEPjmmmhhhhhh> + framebuffer->blue_mask_size, + framebuffer->blue_mask_shift + ); + +#if defined (__x86_64__) + Hal::PrepareGDT(); +ffffffff80006a77: 48 83 c4 20 add $0x20,%rsp +ffffffff80006a7b: e8 60 ec ff ff call ffffffff800056e0 <_ZN3Hal10PrepareGDTEv> + Hal::BridgeLoadGDT(); +ffffffff80006a80: e8 0b ed ff ff call ffffffff80005790 <_ZN3Hal13BridgeLoadGDTEv> +#endif + + uint64_t hhdm_offset = hhdm_request.response->offset; +ffffffff80006a85: 48 8b 05 fc 95 ff ff mov -0x6a04(%rip),%rax # ffffffff80000088 <_ZN12_GLOBAL__N_112hhdm_requestE+0x28> + Memory::HHDMBase = hhdm_offset; +ffffffff80006a8c: 48 8b 40 08 mov 0x8(%rax),%rax +ffffffff80006a90: 48 89 05 31 9d 0d 00 mov %rax,0xd9d31(%rip) # ffffffff800e07c8 <_ZN6Memory8HHDMBaseE> + + if (memmap_request.response != nullptr) { +ffffffff80006a97: 48 8b 05 aa 95 ff ff mov -0x6a56(%rip),%rax # ffffffff80000048 <_ZN12_GLOBAL__N_114memmap_requestE+0x28> +ffffffff80006a9e: 48 85 c0 test %rax,%rax +ffffffff80006aa1: 0f 84 99 00 00 00 je ffffffff80006b40 +ffffffff80006aa7: 48 c7 c7 18 ae 00 80 mov $0xffffffff8000ae18,%rdi + kout << "MemoryManagement: Creating global HeapAllocator" << newline; + + auto result = Memory::Scan(memmap_request.response); + auto allocator = Memory::HeapAllocator(result); +ffffffff80006aae: 48 89 e3 mov %rsp,%rbx +ffffffff80006ab1: e8 ca 04 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff80006ab6: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80006abb: e8 90 04 00 00 call ffffffff80006f50 <_ZN2Kt7PutcharEc> + auto result = Memory::Scan(memmap_request.response); +ffffffff80006ac0: 48 8b 3d 81 95 ff ff mov -0x6a7f(%rip),%rdi # ffffffff80000048 <_ZN12_GLOBAL__N_114memmap_requestE+0x28> +ffffffff80006ac7: e8 c4 02 00 00 call ffffffff80006d90 <_ZN6Memory4ScanEP22limine_memmap_response> + auto allocator = Memory::HeapAllocator(result); +ffffffff80006acc: 48 89 df mov %rbx,%rdi + auto result = Memory::Scan(memmap_request.response); +ffffffff80006acf: 48 89 c6 mov %rax,%rsi + auto allocator = Memory::HeapAllocator(result); +ffffffff80006ad2: e8 89 00 00 00 call ffffffff80006b60 <_ZN6Memory13HeapAllocatorC1ENS_14LargestSectionE> + + Memory::g_heap = &allocator; +ffffffff80006ad7: 48 89 1d f2 9c 0d 00 mov %rbx,0xd9cf2(%rip) # ffffffff800e07d0 <_ZN6Memory6g_heapE> + } else { + Panic("Guru Meditation Error: System memory map missing!", nullptr); + } + +#if defined (__x86_64__) + Hal::IDTInitialize(); +ffffffff80006ade: e8 6d f9 ff ff call ffffffff80006450 <_ZN3Hal13IDTInitializeEv> +#endif + + kcp::cstringstream stream; +ffffffff80006ae3: 48 89 df mov %rbx,%rdi +ffffffff80006ae6: e8 f5 ea ff ff call ffffffff800055e0 <_ZN3kcp13cstringstreamC1Ev> + stream<<"Hello, World"; +ffffffff80006aeb: 48 c7 c6 c5 ac 00 80 mov $0xffffffff8000acc5,%rsi +ffffffff80006af2: 48 89 df mov %rbx,%rdi +ffffffff80006af5: e8 36 eb ff ff call ffffffff80005630 <_ZN3kcp13cstringstreamlsEPKc> + + Memory::g_heap->Walk(); +ffffffff80006afa: 48 8b 3d cf 9c 0d 00 mov 0xd9ccf(%rip),%rdi # ffffffff800e07d0 <_ZN6Memory6g_heapE> +ffffffff80006b01: e8 ba 01 00 00 call ffffffff80006cc0 <_ZN6Memory13HeapAllocator4WalkEv> + + hcf(); +ffffffff80006b06: e8 b5 03 00 00 call ffffffff80006ec0 <_Z3hcfv> +} +ffffffff80006b0b: 48 89 df mov %rbx,%rdi +ffffffff80006b0e: e8 ed ea ff ff call ffffffff80005600 <_ZN3kcp13cstringstreamD1Ev> +ffffffff80006b13: 48 83 c4 20 add $0x20,%rsp +ffffffff80006b17: 5b pop %rbx +ffffffff80006b18: c3 ret +ffffffff80006b19: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + hcf(); +ffffffff80006b20: e8 9b 03 00 00 call ffffffff80006ec0 <_Z3hcfv> +ffffffff80006b25: e9 07 ff ff ff jmp ffffffff80006a31 +ffffffff80006b2a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + hcf(); +ffffffff80006b30: e8 8b 03 00 00 call ffffffff80006ec0 <_Z3hcfv> +ffffffff80006b35: e9 af fe ff ff jmp ffffffff800069e9 +ffffffff80006b3a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) + Panic("Guru Meditation Error: System memory map missing!", nullptr); +ffffffff80006b40: 31 f6 xor %esi,%esi +ffffffff80006b42: 48 c7 c7 48 ae 00 80 mov $0xffffffff8000ae48,%rdi +ffffffff80006b49: 48 89 e3 mov %rsp,%rbx +ffffffff80006b4c: e8 5f e3 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> +ffffffff80006b51: eb 8b jmp ffffffff80006ade +ffffffff80006b53: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006b5a: 00 00 00 +ffffffff80006b5d: 0f 1f 00 nopl (%rax) + +ffffffff80006b60 <_ZN6Memory13HeapAllocatorC1ENS_14LargestSectionE>: + +namespace Memory +{ + constexpr size_t metadata_size = 8; // 8 bytes + + HeapAllocator::HeapAllocator(LargestSection section) +ffffffff80006b60: f3 0f 1e fa endbr64 +ffffffff80006b64: 41 54 push %r12 +ffffffff80006b66: 49 89 d4 mov %rdx,%r12 +ffffffff80006b69: 55 push %rbp +ffffffff80006b6a: 48 89 f5 mov %rsi,%rbp +ffffffff80006b6d: 53 push %rbx +ffffffff80006b6e: 48 89 fb mov %rdi,%rbx +ffffffff80006b71: 48 c7 47 10 00 00 00 movq $0x0,0x10(%rdi) +ffffffff80006b78: 00 +ffffffff80006b79: 48 c7 47 18 00 00 00 movq $0x0,0x18(%rdi) +ffffffff80006b80: 00 + Print(string); +ffffffff80006b81: 48 c7 c7 80 ae 00 80 mov $0xffffffff8000ae80,%rdi +ffffffff80006b88: e8 f3 03 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff80006b8d: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80006b92: e8 b9 03 00 00 call ffffffff80006f50 <_ZN2Kt7PutcharEc> + +namespace Memory { + extern std::uint64_t HHDMBase; + + inline uint64_t HHDM(uint64_t address) { + return HHDMBase + address; +ffffffff80006b97: 48 8b 35 2a 9c 0d 00 mov 0xd9c2a(%rip),%rsi # ffffffff800e07c8 <_ZN6Memory8HHDMBaseE> + { + kout << "HeapAllocator: constructor called" << Kt::newline; + + // section contains the physical address, we need the virtual address, so we call the helper + g_section = LargestSection { +ffffffff80006b9e: 4c 89 63 08 mov %r12,0x8(%rbx) + .address = HHDM(section.address), + .size = section.size + }; + + head = Node { +ffffffff80006ba2: 48 c7 43 10 00 00 00 movq $0x0,0x10(%rbx) +ffffffff80006ba9: 00 +ffffffff80006baa: 48 01 ee add %rbp,%rsi + g_section = LargestSection { +ffffffff80006bad: 48 89 33 mov %rsi,(%rbx) + head = Node { +ffffffff80006bb0: 48 89 73 18 mov %rsi,0x18(%rbx) + .size = 0, + .next = (Node*)g_section.address + }; + + head.next->size = g_section.size; +ffffffff80006bb4: 4c 89 26 mov %r12,(%rsi) + head.size = 0;//!!!!!! + } +ffffffff80006bb7: 5b pop %rbx +ffffffff80006bb8: 5d pop %rbp +ffffffff80006bb9: 41 5c pop %r12 +ffffffff80006bbb: c3 ret +ffffffff80006bbc: 0f 1f 40 00 nopl 0x0(%rax) + +ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm>: + + void* HeapAllocator::Request(size_t size) { +ffffffff80006bc0: f3 0f 1e fa endbr64 + Node* current = &head; +ffffffff80006bc4: 48 83 c7 10 add $0x10,%rdi + Node* prev = nullptr; +ffffffff80006bc8: 31 c9 xor %ecx,%ecx +ffffffff80006bca: eb 0f jmp ffffffff80006bdb <_ZN6Memory13HeapAllocator7RequestEm+0x1b> +ffffffff80006bcc: 0f 1f 40 00 nopl 0x0(%rax) + + while (current != nullptr) { +ffffffff80006bd0: 48 89 f9 mov %rdi,%rcx +ffffffff80006bd3: 48 85 c0 test %rax,%rax +ffffffff80006bd6: 74 30 je ffffffff80006c08 <_ZN6Memory13HeapAllocator7RequestEm+0x48> +ffffffff80006bd8: 48 89 c7 mov %rax,%rdi + if (current->size >= size) { +ffffffff80006bdb: 48 8b 17 mov (%rdi),%rdx + Node copy = *current; +ffffffff80006bde: 48 8b 47 08 mov 0x8(%rdi),%rax + if (current->size >= size) { +ffffffff80006be2: 48 39 f2 cmp %rsi,%rdx +ffffffff80006be5: 72 e9 jb ffffffff80006bd0 <_ZN6Memory13HeapAllocator7RequestEm+0x10> + size_t total_size_needed = size + sizeof(Metadata); + + Metadata* meta = (Metadata*)current; + + meta->size = size; +ffffffff80006be7: 48 89 37 mov %rsi,(%rdi) + + prev->next = (Node*)((uint64_t)current + total_size_needed); +ffffffff80006bea: 48 8d 74 37 08 lea 0x8(%rdi,%rsi,1),%rsi +ffffffff80006bef: 48 89 71 08 mov %rsi,0x8(%rcx) + prev->next->next = copy.next; +ffffffff80006bf3: 48 89 46 08 mov %rax,0x8(%rsi) + prev->next->size = copy.size; +ffffffff80006bf7: 48 8b 41 08 mov 0x8(%rcx),%rax +ffffffff80006bfb: 48 89 10 mov %rdx,(%rax) + + return (void*)((uint64_t)meta + sizeof(Metadata)); +ffffffff80006bfe: 48 8d 47 08 lea 0x8(%rdi),%rax +ffffffff80006c02: c3 ret +ffffffff80006c03: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + prev = current; + current = current->next; + } + + return nullptr; + } +ffffffff80006c08: c3 ret +ffffffff80006c09: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + +ffffffff80006c10 <_ZN6Memory13HeapAllocator7ReallocEPvm>: + + void* HeapAllocator::Realloc(void* ptr, size_t size) { +ffffffff80006c10: f3 0f 1e fa endbr64 +ffffffff80006c14: 41 54 push %r12 + Node* current = &head; +ffffffff80006c16: 48 8d 47 10 lea 0x10(%rdi),%rax + Node* prev = nullptr; +ffffffff80006c1a: 45 31 c0 xor %r8d,%r8d + void* HeapAllocator::Realloc(void* ptr, size_t size) { +ffffffff80006c1d: 55 push %rbp +ffffffff80006c1e: 48 89 f5 mov %rsi,%rbp +ffffffff80006c21: 53 push %rbx +ffffffff80006c22: 48 89 fb mov %rdi,%rbx +ffffffff80006c25: eb 14 jmp ffffffff80006c3b <_ZN6Memory13HeapAllocator7ReallocEPvm+0x2b> +ffffffff80006c27: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80006c2e: 00 00 + while (current != nullptr) { +ffffffff80006c30: 49 89 c0 mov %rax,%r8 +ffffffff80006c33: 48 85 c9 test %rcx,%rcx +ffffffff80006c36: 74 63 je ffffffff80006c9b <_ZN6Memory13HeapAllocator7ReallocEPvm+0x8b> +ffffffff80006c38: 48 89 c8 mov %rcx,%rax + if (current->size >= size) { +ffffffff80006c3b: 48 8b 38 mov (%rax),%rdi + Node copy = *current; +ffffffff80006c3e: 48 8b 48 08 mov 0x8(%rax),%rcx + if (current->size >= size) { +ffffffff80006c42: 48 39 d7 cmp %rdx,%rdi +ffffffff80006c45: 72 e9 jb ffffffff80006c30 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x20> + prev->next = (Node*)((uint64_t)current + total_size_needed); +ffffffff80006c47: 48 8d 74 10 08 lea 0x8(%rax,%rdx,1),%rsi + meta->size = size; +ffffffff80006c4c: 48 89 10 mov %rdx,(%rax) + return (void*)((uint64_t)meta + sizeof(Metadata)); +ffffffff80006c4f: 4c 8d 60 08 lea 0x8(%rax),%r12 + prev->next = (Node*)((uint64_t)current + total_size_needed); +ffffffff80006c53: 49 89 70 08 mov %rsi,0x8(%r8) + prev->next->next = copy.next; +ffffffff80006c57: 48 89 4e 08 mov %rcx,0x8(%rsi) + prev->next->size = copy.size; +ffffffff80006c5b: 49 8b 48 08 mov 0x8(%r8),%rcx +ffffffff80006c5f: 48 89 39 mov %rdi,(%rcx) + auto new_ptr = Request(size); + + if (new_ptr == nullptr) { +ffffffff80006c62: 48 83 f8 f8 cmp $0xfffffffffffffff8,%rax +ffffffff80006c66: 74 33 je ffffffff80006c9b <_ZN6Memory13HeapAllocator7ReallocEPvm+0x8b> + return nullptr; + } + + if (ptr == nullptr) { +ffffffff80006c68: 48 85 ed test %rbp,%rbp +ffffffff80006c6b: 74 26 je ffffffff80006c93 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x83> + return new_ptr; + } + + memcpy(new_ptr, ptr, size); +ffffffff80006c6d: 48 89 ee mov %rbp,%rsi +ffffffff80006c70: 4c 89 e7 mov %r12,%rdi +ffffffff80006c73: e8 c8 fa ff ff call ffffffff80006740 + + void HeapAllocator::Free(void* ptr) { + Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata)); + size_t size = meta->size; + + auto prev_next = head.next; +ffffffff80006c78: 48 8b 4b 18 mov 0x18(%rbx),%rcx + Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata)); +ffffffff80006c7c: 48 8d 45 f8 lea -0x8(%rbp),%rax + size_t size = meta->size; +ffffffff80006c80: 48 8b 55 f8 mov -0x8(%rbp),%rdx + + head.next = (Node*)meta; +ffffffff80006c84: 48 89 43 18 mov %rax,0x18(%rbx) + head.next->next = prev_next; +ffffffff80006c88: 48 89 4d 00 mov %rcx,0x0(%rbp) + head.next->size = size; +ffffffff80006c8c: 48 8b 43 18 mov 0x18(%rbx),%rax +ffffffff80006c90: 48 89 10 mov %rdx,(%rax) + } +ffffffff80006c93: 4c 89 e0 mov %r12,%rax +ffffffff80006c96: 5b pop %rbx +ffffffff80006c97: 5d pop %rbp +ffffffff80006c98: 41 5c pop %r12 +ffffffff80006c9a: c3 ret + return nullptr; +ffffffff80006c9b: 45 31 e4 xor %r12d,%r12d +ffffffff80006c9e: eb f3 jmp ffffffff80006c93 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x83> + +ffffffff80006ca0 <_ZN6Memory13HeapAllocator4FreeEPv>: + void HeapAllocator::Free(void* ptr) { +ffffffff80006ca0: f3 0f 1e fa endbr64 + auto prev_next = head.next; +ffffffff80006ca4: 48 8b 4f 18 mov 0x18(%rdi),%rcx + Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata)); +ffffffff80006ca8: 48 8d 46 f8 lea -0x8(%rsi),%rax + size_t size = meta->size; +ffffffff80006cac: 48 8b 56 f8 mov -0x8(%rsi),%rdx + head.next = (Node*)meta; +ffffffff80006cb0: 48 89 47 18 mov %rax,0x18(%rdi) + head.next->next = prev_next; +ffffffff80006cb4: 48 89 0e mov %rcx,(%rsi) + head.next->size = size; +ffffffff80006cb7: 48 8b 47 18 mov 0x18(%rdi),%rax +ffffffff80006cbb: 48 89 10 mov %rdx,(%rax) + } +ffffffff80006cbe: c3 ret +ffffffff80006cbf: 90 nop + +ffffffff80006cc0 <_ZN6Memory13HeapAllocator4WalkEv>: + + // Traverses the Allocator's linked list for debugging + void HeapAllocator::Walk() { +ffffffff80006cc0: f3 0f 1e fa endbr64 +ffffffff80006cc4: 55 push %rbp +ffffffff80006cc5: 53 push %rbx +ffffffff80006cc6: 48 83 ec 08 sub $0x8,%rsp + Node* current = {head.next}; +ffffffff80006cca: 48 8b 5f 18 mov 0x18(%rdi),%rbx + size_t i{0}; + + while (current != nullptr) { +ffffffff80006cce: 48 85 db test %rbx,%rbx +ffffffff80006cd1: 0f 84 a8 00 00 00 je ffffffff80006d7f <_ZN6Memory13HeapAllocator4WalkEv+0xbf> + size_t i{0}; +ffffffff80006cd7: 31 ed xor %ebp,%ebp +ffffffff80006cd9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + Print(string); +ffffffff80006ce0: 48 c7 c7 d2 ac 00 80 mov $0xffffffff8000acd2,%rdi +ffffffff80006ce7: e8 94 02 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006cec: be 0a 00 00 00 mov $0xa,%esi +ffffffff80006cf1: 48 89 ef mov %rbp,%rdi + t.streamBaseType = newBase; +ffffffff80006cf4: c7 05 fa 43 00 00 0a movl $0xa,0x43fa(%rip) # ffffffff8000b0f8 +ffffffff80006cfb: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006cfe: e8 ad fc ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> + kout << "Block " << base::dec << i << " {" << current->size << " bytes & address 0x" << base::hex << (uint64_t)current << "}" << Kt::newline; + current = current->next; + i++; +ffffffff80006d03: 48 83 c5 01 add $0x1,%rbp +ffffffff80006d07: 48 89 c7 mov %rax,%rdi +ffffffff80006d0a: e8 71 02 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006d0f: 48 c7 c7 d9 ac 00 80 mov $0xffffffff8000acd9,%rdi +ffffffff80006d16: e8 65 02 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006d1b: 8b 35 d7 43 00 00 mov 0x43d7(%rip),%esi # ffffffff8000b0f8 +ffffffff80006d21: 48 8b 3b mov (%rbx),%rdi +ffffffff80006d24: e8 87 fc ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006d29: 48 89 c7 mov %rax,%rdi +ffffffff80006d2c: e8 4f 02 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006d31: 48 c7 c7 dc ac 00 80 mov $0xffffffff8000acdc,%rdi +ffffffff80006d38: e8 43 02 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006d3d: be 10 00 00 00 mov $0x10,%esi +ffffffff80006d42: 48 89 df mov %rbx,%rdi + t.streamBaseType = newBase; +ffffffff80006d45: c7 05 a9 43 00 00 10 movl $0x10,0x43a9(%rip) # ffffffff8000b0f8 +ffffffff80006d4c: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006d4f: e8 5c fc ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006d54: 48 89 c7 mov %rax,%rdi +ffffffff80006d57: e8 24 02 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006d5c: 48 c7 c7 f0 ac 00 80 mov $0xffffffff8000acf0,%rdi +ffffffff80006d63: e8 18 02 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff80006d68: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80006d6d: e8 de 01 00 00 call ffffffff80006f50 <_ZN2Kt7PutcharEc> + current = current->next; +ffffffff80006d72: 48 8b 5b 08 mov 0x8(%rbx),%rbx + while (current != nullptr) { +ffffffff80006d76: 48 85 db test %rbx,%rbx +ffffffff80006d79: 0f 85 61 ff ff ff jne ffffffff80006ce0 <_ZN6Memory13HeapAllocator4WalkEv+0x20> + } + } +ffffffff80006d7f: 48 83 c4 08 add $0x8,%rsp +ffffffff80006d83: 5b pop %rbx +ffffffff80006d84: 5d pop %rbp +ffffffff80006d85: c3 ret +ffffffff80006d86: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006d8d: 00 00 00 + +ffffffff80006d90 <_ZN6Memory4ScanEP22limine_memmap_response>: +#include "Heap.hpp" + +using namespace Kt; + +namespace Memory { + LargestSection Scan(limine_memmap_response* mmap) { +ffffffff80006d90: f3 0f 1e fa endbr64 +ffffffff80006d94: 41 56 push %r14 +ffffffff80006d96: 41 55 push %r13 +ffffffff80006d98: 41 54 push %r12 +ffffffff80006d9a: 55 push %rbp +ffffffff80006d9b: 53 push %rbx + LargestSection currentLargestSection{}; + + for (size_t i = 0; i < mmap->entry_count; i++) { +ffffffff80006d9c: 4c 8b 6f 08 mov 0x8(%rdi),%r13 +ffffffff80006da0: 4d 85 ed test %r13,%r13 +ffffffff80006da3: 0f 84 ef 00 00 00 je ffffffff80006e98 <_ZN6Memory4ScanEP22limine_memmap_response+0x108> +ffffffff80006da9: 49 89 fc mov %rdi,%r12 + LargestSection currentLargestSection{}; +ffffffff80006dac: 45 31 ed xor %r13d,%r13d +ffffffff80006daf: 45 31 f6 xor %r14d,%r14d + for (size_t i = 0; i < mmap->entry_count; i++) { +ffffffff80006db2: 31 db xor %ebx,%ebx +ffffffff80006db4: eb 19 jmp ffffffff80006dcf <_ZN6Memory4ScanEP22limine_memmap_response+0x3f> +ffffffff80006db6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006dbd: 00 00 00 +ffffffff80006dc0: 48 83 c3 01 add $0x1,%rbx +ffffffff80006dc4: 49 3b 5c 24 08 cmp 0x8(%r12),%rbx +ffffffff80006dc9: 0f 83 b1 00 00 00 jae ffffffff80006e80 <_ZN6Memory4ScanEP22limine_memmap_response+0xf0> + auto entry = mmap->entries[i]; +ffffffff80006dcf: 49 8b 44 24 10 mov 0x10(%r12),%rax +ffffffff80006dd4: 48 8b 2c d8 mov (%rax,%rbx,8),%rbp + + if (entry->base == 0) { +ffffffff80006dd8: 48 83 7d 00 00 cmpq $0x0,0x0(%rbp) +ffffffff80006ddd: 74 e1 je ffffffff80006dc0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30> + continue; + } + + if (entry->type == LIMINE_MEMMAP_USABLE) { +ffffffff80006ddf: 48 83 7d 10 00 cmpq $0x0,0x10(%rbp) +ffffffff80006de4: 75 da jne ffffffff80006dc0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30> + Print(string); +ffffffff80006de6: 48 c7 c7 a8 ae 00 80 mov $0xffffffff8000aea8,%rdi +ffffffff80006ded: e8 8e 01 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006df2: 48 8b 7d 08 mov 0x8(%rbp),%rdi +ffffffff80006df6: be 0a 00 00 00 mov $0xa,%esi + t.streamBaseType = newBase; +ffffffff80006dfb: c7 05 f3 42 00 00 0a movl $0xa,0x42f3(%rip) # ffffffff8000b0f8 +ffffffff80006e02: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006e05: e8 a6 fb ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006e0a: 48 89 c7 mov %rax,%rdi +ffffffff80006e0d: e8 6e 01 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006e12: 48 c7 c7 f2 ac 00 80 mov $0xffffffff8000acf2,%rdi +ffffffff80006e19: e8 62 01 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006e1e: 48 8b 7d 00 mov 0x0(%rbp),%rdi +ffffffff80006e22: be 10 00 00 00 mov $0x10,%esi + t.streamBaseType = newBase; +ffffffff80006e27: c7 05 c7 42 00 00 10 movl $0x10,0x42c7(%rip) # ffffffff8000b0f8 +ffffffff80006e2e: 00 00 00 + Print(Lib::u64_2_basestr(number, t.streamBaseType)); +ffffffff80006e31: e8 7a fb ff ff call ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm> +ffffffff80006e36: 48 89 c7 mov %rax,%rdi +ffffffff80006e39: e8 42 01 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Print(string); +ffffffff80006e3e: 48 c7 c7 07 ad 00 80 mov $0xffffffff8000ad07,%rdi +ffffffff80006e45: e8 36 01 00 00 call ffffffff80006f80 <_ZN2Kt5PrintEPKc> + Putchar(chr); +ffffffff80006e4a: bf 0a 00 00 00 mov $0xa,%edi +ffffffff80006e4f: e8 fc 00 00 00 call ffffffff80006f50 <_ZN2Kt7PutcharEc> + kout << "MemoryManagement: Found conventional memory section (size = " << base::dec << entry->length << " bytes, address = 0x" << base::hex << (uint64_t)entry->base << ")" << newline; + + if (entry->length > currentLargestSection.size) { +ffffffff80006e54: 48 8b 45 08 mov 0x8(%rbp),%rax +ffffffff80006e58: 49 39 c5 cmp %rax,%r13 +ffffffff80006e5b: 0f 83 5f ff ff ff jae ffffffff80006dc0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30> + currentLargestSection = { + .address = (uint64_t)entry->base, +ffffffff80006e61: 4c 8b 75 00 mov 0x0(%rbp),%r14 + currentLargestSection = { +ffffffff80006e65: 49 89 c5 mov %rax,%r13 + for (size_t i = 0; i < mmap->entry_count; i++) { +ffffffff80006e68: 48 83 c3 01 add $0x1,%rbx +ffffffff80006e6c: 49 3b 5c 24 08 cmp 0x8(%r12),%rbx +ffffffff80006e71: 0f 82 58 ff ff ff jb ffffffff80006dcf <_ZN6Memory4ScanEP22limine_memmap_response+0x3f> +ffffffff80006e77: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) +ffffffff80006e7e: 00 00 + }; + } + } + } + + [[unlikely]] if (currentLargestSection.address == 0) { +ffffffff80006e80: 4d 85 f6 test %r14,%r14 +ffffffff80006e83: 74 13 je ffffffff80006e98 <_ZN6Memory4ScanEP22limine_memmap_response+0x108> + Panic("Couldn't find a usable memory section.", nullptr); + } + + return currentLargestSection; + } +ffffffff80006e85: 5b pop %rbx +ffffffff80006e86: 4c 89 f0 mov %r14,%rax +ffffffff80006e89: 5d pop %rbp +ffffffff80006e8a: 4c 89 ea mov %r13,%rdx +ffffffff80006e8d: 41 5c pop %r12 +ffffffff80006e8f: 41 5d pop %r13 +ffffffff80006e91: 41 5e pop %r14 +ffffffff80006e93: c3 ret +ffffffff80006e94: 0f 1f 40 00 nopl 0x0(%rax) + Panic("Couldn't find a usable memory section.", nullptr); +ffffffff80006e98: 45 31 f6 xor %r14d,%r14d +ffffffff80006e9b: 31 f6 xor %esi,%esi +ffffffff80006e9d: 48 c7 c7 e8 ae 00 80 mov $0xffffffff8000aee8,%rdi +ffffffff80006ea4: e8 07 e0 ff ff call ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE> + } +ffffffff80006ea9: 5b pop %rbx +ffffffff80006eaa: 4c 89 f0 mov %r14,%rax +ffffffff80006ead: 5d pop %rbp +ffffffff80006eae: 4c 89 ea mov %r13,%rdx +ffffffff80006eb1: 41 5c pop %r12 +ffffffff80006eb3: 41 5d pop %r13 +ffffffff80006eb5: 41 5e pop %r14 +ffffffff80006eb7: c3 ret +ffffffff80006eb8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80006ebf: 00 + +ffffffff80006ec0 <_Z3hcfv>: + * Copyright (c) Daniel Hammer, Limine Contributors (via Limine C++ example) +*/ + +// Halt and catch fire function. +void hcf() +{ +ffffffff80006ec0: f3 0f 1e fa endbr64 +ffffffff80006ec4: 0f 1f 40 00 nopl 0x0(%rax) + for (;;) + { +#if defined(__x86_64__) + asm("hlt"); +ffffffff80006ec8: f4 hlt + for (;;) +ffffffff80006ec9: eb fd jmp ffffffff80006ec8 <_Z3hcfv+0x8> +ffffffff80006ecb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80006ed0 <_ZN2Kt10InitializeEPjmmmhhhhhh>: + void Initialize(std::uint32_t *framebuffer, std::size_t width, std::size_t height, std::size_t pitch, + std::uint8_t red_mask_size, std::uint8_t red_mask_shift, + std::uint8_t green_mask_size, std::uint8_t green_mask_shift, + std::uint8_t blue_mask_size, std::uint8_t blue_mask_shift + ) + { +ffffffff80006ed0: f3 0f 1e fa endbr64 +ffffffff80006ed4: 48 83 ec 08 sub $0x8,%rsp +ffffffff80006ed8: 48 89 f8 mov %rdi,%rax + ctx = flanterm_fb_init( +ffffffff80006edb: 45 0f b6 c9 movzbl %r9b,%r9d +ffffffff80006edf: 45 0f b6 c0 movzbl %r8b,%r8d +ffffffff80006ee3: 6a 00 push $0x0 +ffffffff80006ee5: 6a 00 push $0x0 +ffffffff80006ee7: 6a 00 push $0x0 +ffffffff80006ee9: 6a 01 push $0x1 +ffffffff80006eeb: 6a 00 push $0x0 +ffffffff80006eed: 6a 00 push $0x0 +ffffffff80006eef: 6a 00 push $0x0 +ffffffff80006ef1: 6a 00 push $0x0 +ffffffff80006ef3: 6a 00 push $0x0 +ffffffff80006ef5: 6a 00 push $0x0 +ffffffff80006ef7: 6a 00 push $0x0 +ffffffff80006ef9: 6a 00 push $0x0 +ffffffff80006efb: 6a 00 push $0x0 +ffffffff80006efd: 6a 00 push $0x0 +ffffffff80006eff: 0f b6 bc 24 98 00 00 movzbl 0x98(%rsp),%edi +ffffffff80006f06: 00 +ffffffff80006f07: 57 push %rdi +ffffffff80006f08: 0f b6 bc 24 98 00 00 movzbl 0x98(%rsp),%edi +ffffffff80006f0f: 00 +ffffffff80006f10: 57 push %rdi +ffffffff80006f11: 0f b6 bc 24 98 00 00 movzbl 0x98(%rsp),%edi +ffffffff80006f18: 00 +ffffffff80006f19: 57 push %rdi +ffffffff80006f1a: 0f b6 bc 24 98 00 00 movzbl 0x98(%rsp),%edi +ffffffff80006f21: 00 +ffffffff80006f22: 57 push %rdi +ffffffff80006f23: 31 ff xor %edi,%edi +ffffffff80006f25: 41 51 push %r9 +ffffffff80006f27: 49 89 c9 mov %rcx,%r9 +ffffffff80006f2a: 48 89 f1 mov %rsi,%rcx +ffffffff80006f2d: 31 f6 xor %esi,%esi +ffffffff80006f2f: 41 50 push %r8 +ffffffff80006f31: 49 89 d0 mov %rdx,%r8 +ffffffff80006f34: 48 89 c2 mov %rax,%rdx +ffffffff80006f37: e8 24 b2 ff ff call ffffffff80002160 +ffffffff80006f3c: 48 89 05 95 98 0d 00 mov %rax,0xd9895(%rip) # ffffffff800e07d8 <_ZN2Kt3ctxE> + NULL, NULL, + NULL, 0, 0, 1, + 0, 0, + 0 + ); + } +ffffffff80006f43: 48 81 c4 a8 00 00 00 add $0xa8,%rsp +ffffffff80006f4a: c3 ret +ffffffff80006f4b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) + +ffffffff80006f50 <_ZN2Kt7PutcharEc>: + + void Putchar(char c) { +ffffffff80006f50: f3 0f 1e fa endbr64 +ffffffff80006f54: 48 83 ec 18 sub $0x18,%rsp + flanterm_write(ctx, &c, 1); +ffffffff80006f58: ba 01 00 00 00 mov $0x1,%edx + void Putchar(char c) { +ffffffff80006f5d: 40 88 7c 24 0c mov %dil,0xc(%rsp) + flanterm_write(ctx, &c, 1); +ffffffff80006f62: 48 8b 3d 6f 98 0d 00 mov 0xd986f(%rip),%rdi # ffffffff800e07d8 <_ZN2Kt3ctxE> +ffffffff80006f69: 48 8d 74 24 0c lea 0xc(%rsp),%rsi +ffffffff80006f6e: e8 4d c0 ff ff call ffffffff80002fc0 + } +ffffffff80006f73: 48 83 c4 18 add $0x18,%rsp +ffffffff80006f77: c3 ret +ffffffff80006f78: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80006f7f: 00 + +ffffffff80006f80 <_ZN2Kt5PrintEPKc>: + + void Print(const char *text) { +ffffffff80006f80: f3 0f 1e fa endbr64 + +namespace Lib { + inline int strlen(const char *string) { + int c = 0; + + while (*string != '\0') { +ffffffff80006f84: 80 3f 00 cmpb $0x0,(%rdi) +ffffffff80006f87: 48 89 fe mov %rdi,%rsi +ffffffff80006f8a: 74 2c je ffffffff80006fb8 <_ZN2Kt5PrintEPKc+0x38> +ffffffff80006f8c: 48 89 f8 mov %rdi,%rax + int c = 0; +ffffffff80006f8f: 31 d2 xor %edx,%edx +ffffffff80006f91: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) + string++; +ffffffff80006f98: 48 83 c0 01 add $0x1,%rax + c++; +ffffffff80006f9c: 83 c2 01 add $0x1,%edx + while (*string != '\0') { +ffffffff80006f9f: 80 38 00 cmpb $0x0,(%rax) +ffffffff80006fa2: 75 f4 jne ffffffff80006f98 <_ZN2Kt5PrintEPKc+0x18> + flanterm_write(ctx, text, Lib::strlen(text)); +ffffffff80006fa4: 48 8b 3d 2d 98 0d 00 mov 0xd982d(%rip),%rdi # ffffffff800e07d8 <_ZN2Kt3ctxE> +ffffffff80006fab: 48 63 d2 movslq %edx,%rdx +ffffffff80006fae: e9 0d c0 ff ff jmp ffffffff80002fc0 +ffffffff80006fb3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) +ffffffff80006fb8: 48 8b 3d 19 98 0d 00 mov 0xd9819(%rip),%rdi # ffffffff800e07d8 <_ZN2Kt3ctxE> +ffffffff80006fbf: 31 d2 xor %edx,%edx +ffffffff80006fc1: e9 fa bf ff ff jmp ffffffff80002fc0 +ffffffff80006fc6: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1) +ffffffff80006fcd: 00 00 00 + +ffffffff80006fd0 : +ffffffff80006fd0: 0f 01 17 lgdt (%rdi) +ffffffff80006fd3: c3 ret + +ffffffff80006fd4 : +ffffffff80006fd4: 6a 08 push $0x8 +ffffffff80006fd6: 48 8d 05 03 00 00 00 lea 0x3(%rip),%rax # ffffffff80006fe0 +ffffffff80006fdd: 50 push %rax +ffffffff80006fde: 48 cb lretq + +ffffffff80006fe0 : +ffffffff80006fe0: 66 b8 10 00 mov $0x10,%ax +ffffffff80006fe4: 8e d8 mov %eax,%ds +ffffffff80006fe6: 8e c0 mov %eax,%es +ffffffff80006fe8: 8e e0 mov %eax,%fs +ffffffff80006fea: 8e e8 mov %eax,%gs +ffffffff80006fec: 8e d0 mov %eax,%ss +ffffffff80006fee: c3 ret