name string | code string | asm string | file string |
|---|---|---|---|
google::protobuf::MessageLite::AppendPartialToString(absl::lts_20250127::Cord*) const | bool MessageLite::AppendPartialToString(absl::Cord* output) const {
// For efficiency, we'd like to pass a size hint to CordOutputStream with
// the exact total size expected.
const size_t size = ByteSizeLong();
const size_t total_size = size + output->size();
if (size > INT_MAX) {
ABSL_LOG(ERROR) << "Exc... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x228(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x18(%rbp), %rdi
callq 0x227860
movq %rax, %r... | /protocolbuffers[P]protobuf/src/google/protobuf/message_lite.cc |
bool google::protobuf::internal::EpsCopyInputStream::ParseEndsInSlopRegion<false>(char const*, int, int) | bool EpsCopyInputStream::ParseEndsInSlopRegion(const char* begin, int overrun,
int depth) {
constexpr int kSlopBytes = EpsCopyInputStream::kSlopBytes;
ABSL_DCHECK_GE(overrun, 0);
ABSL_DCHECK_LE(overrun, kSlopBytes);
auto ptr = begin + overrun;
auto end = begin + ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x10, -0x14(%rbp)
movl -0xc(%rbp), %edi
callq 0x2c6f0
movl %eax, -0x6c(%rbp)
xorl %edi, %edi
callq 0x2c6f0
movl -0x6c(%rbp), %edi
movl %eax, %esi
leaq 0x24e3ad(%rip), %rdx # 0x56d834
callq 0x32b10
mov... | /protocolbuffers[P]protobuf/src/google/protobuf/parse_context.cc |
google_protobuf_FieldDescriptorProto_name | UPB_INLINE upb_StringView google_protobuf_FieldDescriptorProto_name(const google_protobuf_FieldDescriptorProto* msg) {
upb_StringView default_val = upb_StringView_FromString("");
upb_StringView ret;
const upb_MiniTableField field = {1, 32, 64, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAl... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x38(%rbp)
leaq 0x200a4c(%rip), %rdi # 0x5a777f
callq 0x3a7a40
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x204f65(%rip), %rax # 0x5abcac
movq %rax, -0x54(%rbp)
movl 0x204f63(%rip), %eax # 0x5abcb4
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
mov... | /protocolbuffers[P]protobuf/upb/reflection/cmake/google/protobuf/descriptor.upb.h |
main | int main( int argc , char *argv[] ) {
// parse input arguments
if ( argc == 2 ) {
if ( std::string(argv[1]) == "--help" ) {
std::cout << std::endl
<< "QPIXL++: Compile quantum circuits for image representations"
<< std::endl
<< "****************************... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x518, %rsp # imm = 0x518
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jne 0x675e
movq 0x8(%rbx), %rsi
leaq 0x190(%rsp), %r15
leaq 0x390(%rsp), %rdx
movq %r15, %rdi
callq 0x847e
leaq 0x14966(%rip), %rsi # 0x1b090
movq %r15, %rdi
c... | /QuantumComputingLab[P]qpixlpp/examples/compressedFRQI.cpp |
void qpixl::frqi::isfwht<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>&) | void isfwht( V& a ) {
using T = typename V::value_type ;
size_t n = a.size() ;
assert( qpixl::ispow2( n ) ) ;
size_t k = qpixl::ilog2( n ) ;
for ( size_t j = 1; j < n; j*=2 ) {
#pragma omp parallel for
for ( size_t i = 0; i < n; i++ ) {
if ( ( i & j ) == 0 ) {
const si... | pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, %rdx
shrq %rdx
movabsq $0x5555555555555555, %rsi # imm = 0x5555555555555555
andq %rdx, %rsi
movq %rcx, %rdx
subq %rsi, %rdx
movabsq $0x3333333333333333, %rsi # imm = 0x3333333333333333
movq %rdx, %rdi
andq %rsi, %rdi
shrq $0x2,... | /QuantumComputingLab[P]qpixlpp/include/qpixl/frqi/util.hpp |
int qpixl::writePGMA<std::vector<double, std::allocator<double>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>&, unsigned long, unsigned long, unsigned long, int) | int writePGMA( const std::string fileName, V& data , const size_t nrows ,
const size_t ncols , const size_t maxval ,
const int zeroPad = 0 ) {
using T = typename V::value_type ;
std::ofstream ostrm( fileName , std::ios::out ) ;
if ( !ostrm.is_open( ) ) {
std::cerr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %r9d, %r12d
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, %r13
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movl $0x10, %edx
callq 0x6400
leaq 0x98(%rsp), %rdi
callq 0x60d0
t... | /QuantumComputingLab[P]qpixlpp/include/qpixl/pgm.hpp |
qclab::QCircuit<double, qclab::QObject<double>>::qubits() const | std::vector< int > qubits() const override {
std::vector< int > v( nbQubits_ ) ;
std::iota( v.begin() , v.end() , offset_ ) ;
return v ;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0xc(%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0xa34e
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x9f7b
movl 0x10(%r14), %edx
movl %edx, (%rax)
incl %edx
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x9f6e
movq %rbx, %rax
addq $0x8, %rsp
popq %rb... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/QCircuit.hpp |
qclab::QCircuit<double, qclab::QObject<double>>::apply(qclab::Side, qclab::Op, int, qclab::dense::SquareMatrix<double>&, int) const | void apply( Side side , Op op , const int nbQubits ,
qclab::dense::SquareMatrix< T >& matrix ,
const int offset = 0 ) const override {
if ( op == Op::NoTrans ) {
if ( side == Side::Left ) {
// Left + NoTrans
for ( auto it = rbegin(); it != re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %r15
cmpb $0x4e, %dl
jne 0xa0f8
cmpb $0x4c, %sil
jne 0xa13a
movq 0x20(%r15), %r12
cmpq 0x18(%r15), %r12
je 0xa1b0
movq -0x8(%r12), %rdi
addq $-0x8, %r12
movl 0x10(%r15), %r9d
addl %ebx,... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/QCircuit.hpp |
qclab::dense::SquareMatrix<double>::SquareMatrix(long, double) | SquareMatrix( const int64_t size , const T value )
: size_( size )
, data_( init_unique_array< T >( size * size , value ) )
{
assert( size > 0 ) ;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, (%rdi)
testq %rsi, %rsi
je 0xa4aa
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
imulq %rbx, %r15
movq %r15, %rax
shrq $0x3d, %rax
shlq $0x3, %r15
xorl %r12d, %r12d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %r15, %rdi
callq 0x603... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/dense/SquareMatrix.hpp |
qclab::QCircuit<double, qclab::QObject<double>>::canInsert(qclab::QObject<double> const&) const | bool canInsert( const gate_type& gate ) const {
const auto qubits = gate.qubits() ;
if ( *std::max_element( qubits.begin() , qubits.end() ) >= nbQubits_ ) {
return false ;
}
return true ;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x28(%rax)
movq (%r14), %rdi
movq 0x8(%r14), %rax
cmpq %rax, %rdi
sete %dl
leaq 0x4(%rdi), %rcx
cmpq %rax, %rcx
sete %sil
orb %dl, %sil
movq %rdi, %rdx
jne 0xa5ea
movq %rdi, %rsi
movl (%rsi), ... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/QCircuit.hpp |
qclab::qgates::Hadamard<double>::toQASM(std::ostream&, int) const | int toQASM( std::ostream& stream ,
const int offset = 0 ) const override {
stream << qasmH( this->qubit_ + offset ) ;
return 0 ;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
addl 0x8(%rdi), %edx
leaq 0x117d8(%rip), %rsi # 0x1c0ac
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xab02
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x62c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa90b
movq 0x18(%rsp),... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/Hadamard.hpp |
void qclab::printMatrix2x2<qclab::dense::SquareMatrix<double>>(qclab::dense::SquareMatrix<double> const&) | void printMatrix2x2( const T& mat ) {
assert( mat.rows() == 2 ) ;
assert( mat.cols() == 2 ) ;
print( mat(0,0) ) ; print( mat(0,1) ) ; std::cout << std::endl ;
print( mat(1,0) ) ; print( mat(1,1) ) ; std::cout << std::endl ;
} | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x2, (%rdi)
jne 0xaae3
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movsd (%rax), %xmm0
callq 0xa56b
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
callq 0xa56b
movq 0x1d562(%rip), %r14 # 0x27fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %e... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/util.hpp |
qclab::qgates::QRotationGate1<double>::QRotationGate1(int, double, bool) | QRotationGate1()
: QGate1< T >( 0 )
, rotation_()
, QAdjustable()
{ } | pushq %rbx
subq $0x10, %rsp
leaq 0x1bf1e(%rip), %rax # 0x26b18
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
testl %esi, %esi
js 0xac42
movq %rdi, %rbx
movb %dl, 0xc(%rdi)
leaq 0x1c067(%rip), %rax # 0x26c78
movq %rax, (%rdi)
mulsd 0x1045c(%rip), %xmm0 # 0x1b078
movsd %xmm0, 0x8(%rsp)
callq 0x63e0
movsd %xmm0, 0x10(... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/QRotationGate1.hpp |
qclab::qgates::RotationY<double>::matrix() const | qclab::dense::SquareMatrix< T > matrix() const override {
return qclab::dense::SquareMatrix< T >( this->cos() , -this->sin() ,
this->sin() , this->cos() ) ;
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsi), %xmm0
movaps %xmm0, 0x10(%rsp)
movaps 0x103b6(%rip), %xmm1 # 0x1b040
xorps %xmm0, %xmm1
movaps %xmm1, 0x20(%rsp)
movq $0x2, (%rdi)
movl $0x20, %edi
callq 0x6030
movq %rax, 0x8(%rbx)
movsd 0x8(%rsp), %xmm0
mov... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/RotationY.hpp |
qclab::qgates::RotationY<float>::toQASM(std::ostream&, int) const | int toQASM( std::ostream& stream ,
const int offset = 0 ) const override {
stream << qasmRy( this->qubit_ + offset , this->theta() ) ;
return 0 ;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %r14
addl 0x8(%rdi), %ebx
movss 0x10(%rdi), %xmm1
movss 0x14(%rdi), %xmm0
callq 0x62e0
addss %xmm0, %xmm0
leaq 0xa795(%rip), %rsi # 0x1c0b2
movq %rsp, %r15
movq %r15, %rdi
movl %ebx, %edx
callq 0x12bfc
movq (%r15), %rsi
movq 0x8(%r15), %r... | /QuantumComputingLab[P]qpixlpp/build_O1/_deps/qclabpp-src/include/qclab/qgates/RotationY.hpp |
cinemo::threading::getCpuCoreCount() | long getCpuCoreCount() {
long numCores = 0;
#ifdef WIN32
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
numCores = sysinfo.dwNumberOfProcessors;
#else
numCores = sysconf(_SC_NPROCESSORS_ONLN);
#endif
if (numCores > 0) { //check if num of cores could... | pushq %rax
movl $0x54, %edi
callq 0x31a0
testq %rax, %rax
movl $0x4, %ecx
cmovleq %rcx, %rax
popq %rcx
retq
| /EMBEDONIX[P]wav2mp3/src/threading.cpp |
cinemo::threading::doSingleThreadedConversion(std::vector<cinemo::LameWrapper*, std::allocator<cinemo::LameWrapper*>> const&, cinemo::args::Options const&) | void doSingleThreadedConversion(const vector<LameWrapper*>& lw,
const args::Options& options) {
cout << "\nSingle-threaded conversion is in progress..." << endl;
for (auto& work : lw) {
work->init();
cout << "MainThread" << " => " << work->getFile... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x4af2(%rip), %r15 # 0xcfd8
leaq 0x1809(%rip), %rsi # 0x9cf6
movl $0x2d, %edx
movq %r15, %rdi
callq 0x3380
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32... | /EMBEDONIX[P]wav2mp3/src/threading.cpp |
fak_a | void fak_a()
{
struct kca_kinematic_chain *kc = &two_dof_robot_a;
struct solver_state_a s;
setup_simple_state_a(kc, &s);
for (int i = 1; i < s.nbody + 1; i++) {
struct kca_joint *joint = &kc->segment[i - 1].joint;
// Position
//
// X_{J,i}
kca_fpk(joint, &s.x... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq 0x2d5e(%rip), %rax # 0x3fe0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x1080
movl $0x1, -0xfc(%rbp)
movl -0xfc(%rbp), %eax
movl -0xf8(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1573
movq -0x8(%rbp), %ra... | /rosym-project[P]dyn2b/src/example/fak_algorithm.c |
GLOBAL__sub_I_WindowImplX11.cpp | Bool checkEvent(::Display*, XEvent* event, XPointer userData)
{
// Just check if the event matches the window
return event->xany.window == reinterpret_cast< ::Window >(userData);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x11fb45(%rip) # 0x12dbe0
movq $0x0, 0x11fb4a(%rip) # 0x12dbf0
leaq 0x11fb33(%rip), %rsi # 0x12dbe0
leaq 0xc07e(%rip), %rdi # 0x1a132
leaq 0x11f92d(%rip), %rbx # 0x12d9e8
movq %rbx, %rdx
callq 0xc810
leaq 0x11fb2e(%rip), %r1... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/WindowImplX11.cpp |
main | int main(int argc, char **argv) {
sf::RenderWindow window(
sf::VideoMode(kWinWidth, kWinHeight), "n_e_s visulization");
constexpr int kFps = 20;
window.setFramerateLimit(kFps);
ImGui::SFML::Init(window);
ImGuiIO &io = ImGui::GetIO();
// NOLINTNEXTLINE(hicpp-signed-bitwise)
io.Co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5608, %rsp # imm = 0x5608
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x50(%rsp), %rdi
movl $0x500, %esi # imm = 0x500
movl $0x3c0, %edx # imm = 0x3C0
movl $0x20, %ecx
callq 0x13c40
leaq 0x60(%rsp), %r14
movq %r14, %rdi
c... | /johnor[P]n_e_s_vis/application/src/main.cpp |
nesvis::Gui::Gui(n_e_s::nes::Nes*, nesvis::PpuHelper*, nesvis::Control*) | Gui(n_e_s::nes::Nes *nes, PpuHelper *ppu_helper, Control *control)
: log_widget(),
cpu_widget(nes, control),
ppu_widget(nes, ppu_helper),
memory_widget(nes) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rcx, %rdx
callq 0xe7ec
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11970
leaq 0x5040(%rbx), %rdi
movq %r14, %rsi
callq 0xfebe
movb $0x1,... | /johnor[P]n_e_s_vis/application/src/gui.h |
nesvis::Gui::~Gui() | Gui(n_e_s::nes::Nes *nes, PpuHelper *ppu_helper, Control *control)
: log_widget(),
cpu_widget(nes, control),
ppu_widget(nes, ppu_helper),
memory_widget(nes) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x50a0, %rdi # imm = 0x50A0
callq 0x10452
leaq 0x5070(%rbx), %rdi
callq 0x10452
movq 0x5048(%rbx), %rdi
leaq 0x5058(%rbx), %rax
cmpq %rax, %rdi
je 0xfe95
movq (%rax), %rsi
incq %rsi
callq 0xc940
movl $0x5018, %r14d # imm = 0x5018
leaq (%rbx,%r14)... | /johnor[P]n_e_s_vis/application/src/gui.h |
nesvis::MemoryWidget::MemoryWidget(n_e_s::nes::Nes*) | explicit MemoryWidget(n_e_s::nes::Nes *nes) : nes_(nes) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
movb %al, 0x2a(%rdi)
leaq 0x28(%rsp), %rdi
movw $0x0,... | /johnor[P]n_e_s_vis/application/src/memory_widget.h |
nesvis::MemoryWidget::draw() | void draw() {
ImGui::Begin("Memory viewer", nullptr);
ImGui::BeginTabBar("##tabs", ImGuiTabBarFlags_None);
if (ImGui::BeginTabItem("Cpu")) {
draw_tab("Cpu",
cpu_mem_labels_,
0xFFFF,
[this](uint16_t address) -> uint8_t {
... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xc4c7d(%rip), %rdi # 0xd53ea
xorl %esi, %esi
xorl %edx, %edx
callq 0x58186
leaq 0xc4c7b(%rip), %rdi # 0xd53f8
xorl %esi, %esi
callq 0xaf3e6
leaq 0xc4c74(%rip), %rdi # 0xd53ff
xorl %esi, %esi
xorl %edx, %edx
callq 0xb1085
testb %al, %al
je 0x1082d
... | /johnor[P]n_e_s_vis/application/src/memory_widget.h |
nesvis::MemoryWidget::read_mem(std::function<unsigned char (unsigned short)> const&, unsigned short) | std::optional<uint8_t> read_mem(
const std::function<uint8_t(uint16_t)> &memory_read_func,
const uint16_t address) {
try {
return memory_read_func(address);
} catch (n_e_s::core::InvalidAddress &) {
return std::nullopt;
}
} | pushq %rax
movw %dx, 0x6(%rsp)
cmpq $0x0, 0x10(%rsi)
je 0x10dcc
movq %rsi, %rdi
leaq 0x6(%rsp), %rsi
callq *0x18(%rdi)
movzbl %al, %eax
orl $0x100, %eax # imm = 0x100
popq %rcx
retq
callq 0xc310
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x10de7
callq 0xc3a0
callq 0xd090
xorl %eax, %eax
jmp 0x10dca
callq 0xd1d0
| /johnor[P]n_e_s_vis/application/src/memory_widget.h |
nesvis::MemoryWidget::draw_mem_value(unsigned short, std::optional<unsigned char> const&) | void draw_mem_value(uint16_t address,
const std::optional<uint8_t> &mem_value) {
if (mem_value) {
if (mem_value.value() == 0u) {
ImGui::TextDisabled("00");
} else {
ImGui::Text("%02hhX", mem_value.value());
}
} else {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x1, 0x1(%rdx)
jne 0x10e17
movzbl (%rdx), %esi
testl %esi, %esi
je 0x10e20
leaq 0xc432a(%rip), %rdi # 0xd5138
xorl %eax, %eax
callq 0x9b22a
jmp 0x10e2e
leaq 0xc4642(%rip), %rdi # 0xd5460
jmp 0x10e27
leaq 0xe92d6(%rip), %rdi ... | /johnor[P]n_e_s_vis/application/src/memory_widget.h |
nesvis::PpuHelper::get_pattern_table_texture(unsigned short, unsigned short, unsigned short) | sf::Texture PpuHelper::get_pattern_table_texture(uint16_t pos,
uint16_t pattern_table,
uint16_t palette) {
sf::Image image;
image.create(8, 8, sf::Color(10, 100, 0));
for (uint8_t row = 0; row < 8; ++row) {
// Second pattern table starts at 0x1000
const uint16_t base... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %ebx
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x24168
leaq 0x10(%rsp), %rdi
movl $0xa, %esi
movl $0x64, %edx
xorl %ecx, %ecx
movl $0xff, %r8d
callq 0x23f7c
leaq 0x... | /johnor[P]n_e_s_vis/application/src/ppu_helper.cpp |
nesvis::PpuHelper::get_nametable_cell(int, int, unsigned short) | PpuHelper::NametableCell PpuHelper::get_nametable_cell(int x,
int y,
uint16_t nametable) {
// $2000-$23FF $0400 Nametable 0
// $2400-$27FF $0400 Nametable 1
// $2800-$2BFF $0400 Nametable 2
// $2C00-$2FFF $0400 Nametable 3
// $3000-$3EFF $0F00 Mirrors of $2000-$2EFF
... | pushq %rbx
shll $0xa, %ecx
shll $0x5, %edx
addl %esi, %edx
leal (%rcx,%rdx), %ebx
addl $0x2000, %ebx # imm = 0x2000
movq (%rdi), %rdi
callq 0x1334c
movq (%rax), %rcx
movzwl %bx, %esi
movq %rax, %rdi
callq *0x18(%rcx)
shll $0x10, %ebx
movzbl %al, %eax
orl %ebx, %eax
popq %rbx
retq
| /johnor[P]n_e_s_vis/application/src/ppu_helper.cpp |
nesvis::PpuHelper::get_attribute_cell(int, int) | PpuHelper::AttributeCell PpuHelper::get_attribute_cell(int x, int y) {
// TODO(jn) handle mirroring, this will not work
// Each attribute cell has 4 tiles in it
const int attribute_x = x / 4;
const int attribute_y = y / 4;
const uint16_t address = 0x23C0 + attribute_y * 8 + attribute_x;
co... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
leal 0x3(%r14), %eax
testl %esi, %esi
cmovnsl %esi, %eax
sarl $0x2, %eax
leal 0x3(%rbx), %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
andl $-0x4, %ecx
leal (%rax,%rcx,2), %r15d
addl $0x23c0, %r15d # imm = 0x23C0
movq (%rdi), %rdi
callq 0x1334c
movq ... | /johnor[P]n_e_s_vis/application/src/ppu_helper.cpp |
nesvis::PpuHelper::get_sprite(unsigned char) | PpuHelper::Sprite PpuHelper::get_sprite(uint8_t sprite_index) {
constexpr uint16_t kOamAddr = 0x2003;
constexpr uint16_t kOamData = 0x2004;
const uint8_t oam_addr = sprite_index * 4u;
nes_->ppu().write_byte(kOamAddr, oam_addr);
const uint8_t y = nes_->ppu().read_byte(kOamData);
nes_->ppu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
shlb $0x2, %bl
movq (%rdi), %rdi
callq 0x13334
movq (%rax), %rcx
movzbl %bl, %r15d
movq %rax, %rdi
movl $0x2003, %esi # imm = 0x2003
movl %r15d, %edx
callq *0x18(%rcx)
movq (%r14), %rdi
callq 0x13334
movq (%rax), %rcx
movq ... | /johnor[P]n_e_s_vis/application/src/ppu_helper.cpp |
nesvis::PpuWidget::load_pattern_tables() | void PpuWidget::load_pattern_tables() {
const uint16_t palette = 0; // TODO(jn) update to correct index
for (int i = 0; i < kPatternTableSize; ++i) {
pattern_table_textures_[i] =
ppu_helper_->get_pattern_table_texture(i, 0, palette);
}
for (int i = 0; i < kPatternTableSize; ++i)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r12d, %r12d
movq %rsp, %r15
movq 0x8(%rbx), %rsi
movzwl %r12w, %edx
movq %r15, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x114a4
movq %r14, %rdi
movq %r15, %rsi
callq 0x400f8
movq %r15, %rdi
callq 0x3e828
incq %r12... | /johnor[P]n_e_s_vis/application/src/ppu_widget.cpp |
nesvis::PpuWidget::draw() | void PpuWidget::draw() {
ImGui::Begin("Nes ppu");
const auto reg = nes_->ppu_registers();
ImGui::Text("%s: %02hhX", "ctrl", reg.ctrl.value());
if (ImGui::IsItemHovered()) {
ImGui::BeginTooltip();
ImGui::Text("Ctrl: 0x2000");
ImGui::Text("Nametable address: %d:%d",
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc394d(%rip), %rdi # 0xd53e2
xorl %esi, %esi
xorl %edx, %edx
callq 0x58186
movq (%rbx), %rdi
callq 0x13360
movzbl 0x4(%rax), %ebp
movzbl 0x5(%rax), %r13d
movzbl 0x6(%rax), %r12d
movzbl 0x7(%rax), %r15d
movzbl 0x8(%rax... | /johnor[P]n_e_s_vis/application/src/ppu_widget.cpp |
nesvis::PpuWidget::draw_patterntables() | void PpuWidget::draw_patterntables() {
if (ImGui::Button("Read data")) {
load_pattern_tables();
}
ImGui::Text("Pattern table 0");
for (int i = 0; i < kPatternTableSize; ++i) {
if (i % 16 != 0) {
ImGui::SameLine();
}
ImGui::Image(pattern_table_textures_[i], {k... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq 0xc3969(%rip), %rdi # 0xd56b2
callq 0x9c371
testb %al, %al
je 0x11d5a
movq %rbx, %rdi
callq 0x119c6
leaq 0xc35f9(%rip), %rdi # 0xd535a
xorl %eax, %eax
callq 0x9b22a
leaq 0x10(%rbx)... | /johnor[P]n_e_s_vis/application/src/ppu_widget.cpp |
nesvis::PpuWidget::draw_nametables() | void PpuWidget::draw_nametables() {
const auto reg = nes_->ppu_registers();
const int pattern_table = reg.ctrl.is_set(4u) ? 1 : 0;
ImGui::Text("%s: %i", "Pattern table used: ", pattern_table);
if (ImGui::BeginTabBar("MyTabBar")) {
for (auto nametable = 0; nametable < 4; ++nametable) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x13360
movzbl 0x4(%rax), %edx
shrl $0x4, %edx
andl $0x1, %edx
leaq 0xc381c(%rip), %rdi # 0xd56c8
leaq 0xc381c(%rip), %rsi # 0xd56cf
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x9b22a
leaq 0xc... | /johnor[P]n_e_s_vis/application/src/ppu_widget.cpp |
nesvis::PpuWidget::draw_sprites() | void PpuWidget::draw_sprites() {
const auto reg = nes_->ppu_registers();
const int sprite_pattern_table = reg.ctrl.is_set(3u) ? 1 : 0;
ImGui::Text("%s: %i", "Sprite pattern table: ", sprite_pattern_table);
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
for (uint8_t index = 0; index < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x13360
movzbl 0x4(%rax), %r14d
andl $0x8, %r14d
movl %r14d, %edx
shrl $0x3, %edx
leaq 0xc3687(%rip), %rdi # 0xd56c8
leaq 0xc371f(%rip), %rsi # 0xd5767
xorl %eax, %eax
callq 0x9b22a
leaq 0x... | /johnor[P]n_e_s_vis/application/src/ppu_widget.cpp |
nesvis::PpuWidget::draw_palettes() | void PpuWidget::draw_palettes() {
ImGui::Text("Background palette");
ImGui::PushID("background palette");
const std::array<std::string, 8> palette_text = {"Background 0",
"Background 1",
"Background 2",
"Background 3",
"Sprite 0",
"Sprite 1",
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
leaq 0xc35e9(%rip), %rdi # 0xd579c
xorl %eax, %eax
callq 0x9b22a
leaq 0xc35ee(%rip), %rdi # 0xd57af
callq 0x65157
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xc35ec(%rip), %rsi ... | /johnor[P]n_e_s_vis/application/src/ppu_widget.cpp |
nesvis::Screen::draw(sf::RenderWindow&) | void Screen::draw(sf::RenderWindow &window) {
texture_.loadFromImage(image_);
sf::Sprite sprite;
sprite.setTexture(texture_, true);
sprite.setScale(scaling_, scaling_);
window.draw(sprite);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
leaq 0x30(%rdi), %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq %r15, %rdi
callq 0x3e9be
movq %rsp, %r12
movq %r12, %rdi
callq 0x42670
movq %r12, %rdi
movq %r15,... | /johnor[P]n_e_s_vis/application/src/screen.cpp |
sf::Window::setSize(sf::Vector2<unsigned int> const&) | void Window::setSize(const Vector2u& size)
{
if (m_impl)
{
m_impl->setSize(size);
// Cache the new size
m_size.x = size.x;
m_size.y = size.y;
// Notify the derived class
onResize();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x14a5c
movq %rsi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
movl (%r14), %eax
movl %eax, 0x28(%rbx)
movl 0x4(%r14), %eax
movl %eax, 0x2c(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18(%rax)
... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Window.cpp |
sf::Window::setActive(bool) const | bool Window::setActive(bool active) const
{
if (m_context)
{
if (m_context->setActive(active))
{
return true;
}
else
{
err() << "Failed to activate the window's context" << std::endl;
return false;
}
}
else
{
... | movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x14b3c
pushq %rbx
movzbl %sil, %esi
callq 0x1da10
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x14b3a
callq 0x2237c
movq %rax, %rbx
leaq 0xc298c(%rip), %rsi # 0xd7490
movl $0x27, %edx
movq %rax, %rdi
callq 0xca70
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %r... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Window.cpp |
sf::Window::display() | void Window::display()
{
// Display the backbuffer on screen
if (setActive())
m_context->display();
// Limit the framerate if needed
if (m_frameTimeLimit != Time::Zero)
{
sleep(m_frameTimeLimit - m_clock.getElapsedTime());
m_clock.restart();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x14ada
testb %al, %al
je 0x14c2d
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rbx), %rdi
leaq 0xc50a0(%rip), %rax # 0xd9cd8
movq (%rax), %rsi
callq 0x23cfa
testb %al, %al
je 0x14c76
movq 0x20(%rbx), %r14
addq $0x18, %rbx... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Window.cpp |
sf::priv::WindowImpl::popEvent(sf::Event&, bool) | bool WindowImpl::popEvent(Event& event, bool block)
{
// If the event queue is empty, let's first check if new events are available from the OS
if (m_events.empty())
{
// Get events from the system
processJoystickEvents();
processSensorEvents();
processEvents();
// I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0x14f0f
movl %edx, %ebp
movq %rbx, %rdi
callq 0x14f48
movq %rbx, %rdi
callq 0x151ae
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
testb %bpl, %bpl
je 0x14f0f
movq 0x38(%rbx), %rax... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/WindowImpl.cpp |
sf::priv::WindowImpl::processJoystickEvents() | void WindowImpl::processJoystickEvents()
{
// First update the global joystick states
JoystickManager::getInstance().update();
for (unsigned int i = 0; i < Joystick::Count; ++i)
{
// Copy the previous state of the joystick and get the new one
JoystickState previousState = m_joystickStat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
callq 0x1ebfc
movq %rax, %rdi
callq 0x1eca8
leaq 0x58(%rbx), %rax
movq %rax, 0x48(%rsp)
leaq 0x8(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x2c4(%rbx), %r14
leaq 0x5c(%rbx), %rax
leaq 0x7c(%rbx), %r12
xorl %r15d, %r15d
movq ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/WindowImpl.cpp |
sf::priv::WindowImpl::processSensorEvents() | void WindowImpl::processSensorEvents()
{
// First update the sensor states
SensorManager::getInstance().update();
for (unsigned int i = 0; i < Sensor::Count; ++i)
{
Sensor::Type sensor = static_cast<Sensor::Type>(i);
// Only process enabled sensors
if (SensorManager::getInstanc... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x1f010
movq %rax, %rdi
callq 0x1f10e
leaq 0x8(%rbx), %r14
leaq 0x280(%rbx), %r13
xorl %r15d, %r15d
leaq 0xc(%rsp), %r12
callq 0x1f010
movq %rax, %rdi
movl %r15d, %esi
callq 0x1f0ee
testb %al, %al
je 0x152b3
movss -0x8(%r13), ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/WindowImpl.cpp |
sf::priv::InputImpl::isKeyPressed(sf::Keyboard::Key) | bool InputImpl::isKeyPressed(Keyboard::Key key)
{
// Get the corresponding X11 keysym
KeySym keysym = 0;
switch (key)
{
case Keyboard::LShift: keysym = XK_Shift_L; break;
case Keyboard::RShift: keysym = XK_Shift_R; break;
case Keyboard::LControl: keysym = XK_C... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x64, %edi
ja 0x15794
movl %edi, %eax
leaq 0xc1dba(%rip), %rcx # 0xd7548
movq (%rcx,%rax,8), %r14
jmp 0x15797
xorl %r14d, %r14d
cmpl $0x64, %edi
ja 0x157e8
callq 0x202c0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xc510
testb %al, %al
je 0x157e0
mov... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/InputImpl.cpp |
sf::priv::InputImpl::getMousePosition() | Vector2i InputImpl::getMousePosition()
{
// Open a connection with the X server
Display* display = OpenDisplay();
// we don't care about these but they are required
::Window root, child;
int x, y;
unsigned int buttons;
int gx = 0;
int gy = 0;
XQueryPointer(display, DefaultRootWindo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
callq 0x202c0
movq %rax, %r15
xorl %eax, %eax
leaq 0x10(%rsp), %rbx
movl %eax, (%rbx)
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movq 0xe8(%r15), %rax
movslq 0xe0(%r15), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
subq $0x8, %rsp
leaq 0x1c(%rsp), %rax
leaq 0x20(%rsp), %... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/InputImpl.cpp |
sf::priv::InputImpl::getMousePosition(sf::Window const&) | Vector2i InputImpl::getMousePosition(const Window& relativeTo)
{
WindowHandle handle = relativeTo.getSystemHandle();
if (handle)
{
// Open a connection with the X server
Display* display = OpenDisplay();
// we don't care about these but they are required
::Window root, child... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
callq 0x14c7e
xorl %ebx, %ebx
testq %rax, %rax
je 0x159a4
movq %rax, %r14
callq 0x202c0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movl %ebx, (%r12)
leaq 0xc(%rsp), %r13
movl %ebx, (%r13)
subq $0x8, %rsp
leaq 0x1c(%rsp), %rax
leaq 0x30(%rsp), %rdx
leaq ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/InputImpl.cpp |
sf::priv::InputImpl::setMousePosition(sf::Vector2<int> const&, sf::Window const&) | void InputImpl::setMousePosition(const Vector2i& position, const Window& relativeTo)
{
// Open a connection with the X server
Display* display = OpenDisplay();
WindowHandle handle = relativeTo.getSystemHandle();
if (handle)
{
XWarpPointer(display, None, handle, 0, 0, 0, 0, position.x, posit... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x202c0
movq %rax, %rbx
movq %r15, %rdi
callq 0x14c7e
testq %rax, %rax
je 0x15a6c
movl (%r14), %r10d
movl 0x4(%r14), %r11d
subq $0x8, %rsp
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r11
pus... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/InputImpl.cpp |
sf::priv::VideoModeImpl::getFullscreenModes() | std::vector<VideoMode> VideoModeImpl::getFullscreenModes()
{
std::vector<VideoMode> modes;
// Open a connection with the X server
Display* display = OpenDisplay();
if (display)
{
// Retrieve the default screen number
int screen = DefaultScreen(display);
// Check if the XRan... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x202c0
movq %rax, %r14
testq %rax, %rax
je 0x15c51
movslq 0xe0(%r14), %r12
leaq 0xc1daa(%rip), %rsi # 0xd7870
leaq 0x44(%rsp), %rcx
movq %r14, %rdi
... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/VideoModeImpl.cpp |
sf::priv::WindowImplX11::getPosition() const | Vector2i WindowImplX11::getPosition() const
{
// Get absolute position of our window relative to root window. This
// takes into account all information that X11 has, including X11
// border widths and any decorations. It corresponds to where the
// window actually is, but not necessarily to where we to... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x3c8(%rdi), %rsi
movq 0x3d0(%rdi), %rdi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rdx
leaq 0x50(%rsp), %rax
leaq 0x4(%rsp), %r10
leaq 0x8(%rsp), %r9
xorl %ecx, %ecx
xorl %r... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/WindowImplX11.cpp |
sf::priv::WindowImplX11::requestFocus() | void WindowImplX11::requestFocus()
{
// Focus is only stolen among SFML windows, not between applications
// Check the global list of windows to find out whether an SFML window has the focus
// Note: can't handle console and other non-SFML windows belonging to the application.
bool sfmlWindowFocused = f... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x114589(%rip), %rsi # 0x12dbf8
leaq 0x8(%rsp), %rdi
callq 0x225c4
movq 0x114560(%rip), %r14 # 0x12dbe0
cmpq 0x114561(%rip), %r14 # 0x12dbe8
setne %bpl
je 0x196a0
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
jne 0x19... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/WindowImplX11.cpp |
sf::priv::WindowImplX11::grabFocus() | void WindowImplX11::grabFocus()
{
Atom netActiveWindow = None;
if (ewmhSupported())
netActiveWindow = getAtom("_NET_ACTIVE_WINDOW");
// Only try to grab focus if the window is mapped
XWindowAttributes attr;
XGetWindowAttributes(m_display, m_window, &attr);
if (attr.map_state == IsUnm... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
callq 0x162e1
testb %al, %al
je 0x197f0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xbe7ee(%rip), %rsi # 0xd7fa7
leaq 0xbe7f9(%rip), %rdx # 0xd7fb9
movq %rsp, %r14
movq %r14, %rdi
callq 0x11410
movq %r1... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/WindowImplX11.cpp |
sf::priv::WindowImplX11::checkXRandR(int&, int&) | bool WindowImplX11::checkXRandR(int& xRandRMajor, int& xRandRMinor)
{
// Check if the XRandR extension is present
int version;
if (!XQueryExtension(m_display, "RANDR", &version, &version, &version))
{
err() << "XRandR extension is not supported" << std::endl;
return false;
}
// ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3d0(%rdi), %rdi
leaq 0xbdeae(%rip), %rsi # 0xd7870
leaq 0xc(%rsp), %rcx
movq %rcx, %rdx
movq %rcx, %r8
callq 0xc2c0
testl %eax, %eax
je 0x19a15
movq 0x3d0(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc1d0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/WindowImplX11.cpp |
sf::priv::WindowImplX11::getOutputPrimary(unsigned long&, _XRRScreenResources*, int, int) | RROutput WindowImplX11::getOutputPrimary(::Window& rootWindow, XRRScreenResources* res, int xRandRMajor, int xRandRMinor)
{
// if xRandR version >= 1.3 get the primary screen else take the first screen
if ((xRandRMajor == 1 && xRandRMinor >= 3) || xRandRMajor > 1)
{
RROutput output = XRRGetOutputPri... | pushq %rbx
movq %rdx, %rbx
cmpl $0x1, %ecx
sete %al
cmpl $0x3, %r8d
setge %dl
cmpl $0x1, %ecx
jg 0x19a7e
andb %dl, %al
je 0x19a92
movq 0x3d0(%rdi), %rdi
movq (%rsi), %rsi
callq 0xc480
testq %rax, %rax
jne 0x19a99
movq 0x28(%rbx), %rax
movq (%rax), %rax
popq %rbx
retq
nop
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/WindowImplX11.cpp |
sf::priv::WindowImplX11::resetVideoMode() | void WindowImplX11::resetVideoMode()
{
if (fullscreenWindow == this)
{
// Try to set old configuration
// Check if the XRandR extension
int xRandRMajor, xRandRMinor;
if (checkXRandR(xRandRMajor, xRandRMinor))
{
XRRScreenResources* res = XRRGetScreenResources(m... | cmpq %rdi, 0x1141dd(%rip) # 0x12dc80
je 0x19aa6
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x199a2
testb %al, %al
je 0x19c50
movq 0x3d0(%r15), %rdi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
call... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/WindowImplX11.cpp |
sf::String::~String() | class SFML_SYSTEM_API String
{
public:
////////////////////////////////////////////////////////////
// Types
////////////////////////////////////////////////////////////
typedef std::basic_string<Uint32>::iterator Iterator; ///< Iterator type
typedef std::basic_string<Uint32>::const_iter... | movq %rdi, %rax
movq (%rdi), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x1a169
movq (%rax), %rax
leaq 0x4(,%rax,4), %rsi
jmp 0xc940
retq
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/include/SFML/System/String.hpp |
sf::priv::GlxContext::createSurface(sf::priv::GlxContext*, unsigned int, unsigned int, unsigned int) | void GlxContext::createSurface(GlxContext* shared, unsigned int width, unsigned int height, unsigned int bitsPerPixel)
{
// Choose the visual according to the context settings
XVisualInfo visualInfo = selectBestVisual(m_display, bitsPerPixel, m_settings);
// Check if the shared context already exists and p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
leaq 0x8(%rdi), %rcx
leaq 0x20(%rsp), %rdi
movl %r8d, %edx
callq 0x1c9fa
testq %r15, %r15
je 0x1bd63
leaq 0x1120d1(%rip), %rax # 0x12dcf8
cmpl $0x1... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/GlxContext.cpp |
sf::priv::GlxContext::createContext(sf::priv::GlxContext*) | void GlxContext::createContext(GlxContext* shared)
{
// Get a working copy of the context settings
ContextSettings settings = m_settings;
XVisualInfo* visualInfo = NULL;
if (m_pbuffer)
{
unsigned int fbConfigId = 0;
glXQueryDrawable(m_display, m_pbuffer, GLX_FBCONFIG_ID, &fbConfig... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl 0x1c(%rdi), %ebp
movq 0x48(%rdi), %rsi
testq %rsi, %rsi
je 0x1be97
xorl %r14d, %r14d
leaq 0x30(%rsp), %r12
movl %r14d, (%r12)
movq 0x30(%rbx), %rdi
movl $0x8013, %edx # imm = 0x8013
movq %r1... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/GlxContext.cpp |
sf::priv::GlxContext::GlxContext(sf::priv::GlxContext*, sf::ContextSettings const&, unsigned int, unsigned int) | GlxContext::GlxContext(GlxContext* shared, const ContextSettings& settings, unsigned int width, unsigned int height) :
m_display (NULL),
m_window (0),
m_context (NULL),
m_pbuffer (0),
m_ownsWindow(false)
{
// Save the creation settings
m_settings = settings;
// Open the connection with the X serve... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1e4fc
leaq 0x10eb6f(%rip), %rax # 0x12b2a8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movb $0x0, 0x50(%rbx)
movups (%r12), %xmm0
... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/GlxContext.cpp |
sfglx_LoadFunctions | int sfglx_LoadFunctions(Display* display, int screen)
{
ClearExtensionVars();
ProcExtsFromExtString(reinterpret_cast<const char*>(glXQueryExtensionsString(display, screen)));
return sfglx_LOAD_SUCCEEDED;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
movl %eax, 0x110c4a(%rip) # 0x12dce0
movl %eax, 0x110c48(%rip) # 0x12dce4
movl %eax, 0x110c46(%rip) # 0x12dce8
movl %eax, 0x110c44(%rip) # 0x12dcec
movl %eax, 0x110c42(%rip) # 0x12dcf0
movl %eax, 0x110c40(%... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/GlxExtensions.cpp |
sf::priv::GlContext::initialize(sf::ContextSettings const&) | void GlContext::initialize(const ContextSettings& requestedSettings)
{
// Activate the context
setActive(true);
// Retrieve the context version number
int majorVersion = 0;
int minorVersion = 0;
// Try the new way first
glGetIntegerv(GL_MAJOR_VERSION, &majorVersion);
glGetIntegerv(GL_M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1da10
xorl %eax, %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movl $0x821b, %edi # imm = 0x821B
callq 0xc8c0
movl $0x821c, %edi ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/GlContext.cpp |
sf::priv::GlContext::setActive(bool) | bool GlContext::setActive(bool active)
{
if (active)
{
if (this != currentContext)
{
Lock lock(mutex);
// Activate the context
if (makeCurrent(true))
{
// Set it as the new current context for this thread
currentCon... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x110340(%rip), %rdi # 0x12dd60
callq 0x23c92
testl %ebx, %ebx
je 0x1da62
cmpq %r14, %rax
je 0x1daa1
leaq 0x110323(%rip), %rsi # 0x12dd58
movq %rsp, %rdi
callq 0x225c4
movq (%r14), %rax
movq %r14, %rdi
movl $0x1, %esi
callq *0x20(%rax)
movl %ea... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/GlContext.cpp |
sf::priv::GlContext::cleanupResource() | void GlContext::cleanupResource()
{
// Protect from concurrent access
Lock lock(mutex);
// Decrement the resources counter
resourceCount--;
// If there's no more resource alive, we can trigger the global context cleanup
if (resourceCount == 0)
{
if (!sharedContext)
retu... | pushq %rax
leaq 0x11028e(%rip), %rsi # 0x12dd58
movq %rsp, %rdi
callq 0x225c4
decl 0x1102e0(%rip) # 0x12ddb8
jne 0x1daf7
movq 0x1102df(%rip), %rdi # 0x12ddc0
testq %rdi, %rdi
je 0x1daf7
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x1102c9(%rip) # 0x12ddc0
movq %rsp, %rdi
callq 0x225d0
popq %rax
retq
no... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/GlContext.cpp |
sf::priv::CursorImpl::loadFromSystem(sf::Cursor::Type) | bool CursorImpl::loadFromSystem(Cursor::Type type)
{
release();
unsigned int shape;
switch (type)
{
default: return false;
case Cursor::Arrow: shape = XC_arrow; break;
case Cursor::Wait: shape = XC_watch; break;
case Cursor::... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x1f4b5
movq (%rbx), %rdi
callq 0xc9e0
movq $0x0, 0x8(%rbx)
cmpl $0xc, %ebp
ja 0x1f4e0
movl $0x1e7d, %eax # imm = 0x1E7D
btl %ebp, %eax
jae 0x1f4e0
movl %ebp, %eax
leaq 0xba163(%rip), %rcx # 0xd9630
m... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/CursorImpl.cpp |
sf::priv::ClipboardImpl::getStringImpl() | String ClipboardImpl::getStringImpl()
{
// Check if anybody owns the current selection
if (XGetSelectionOwner(m_display, m_clipboard) == None)
{
m_clipboardContents.clear();
return m_clipboardContents;
}
// Process any already pending events
processEvents();
m_requestRespo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
callq 0xd300
testq %rax, %rax
je 0x1f651
callq 0x1f50a
leaq 0x10f1c9(%rip), %rdi # 0x12e778
callq 0x1f720
movb $0x0, 0xa8(%r14)
movq (%r14), %r8
movq 0x8(%r14), %rdi
movq... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/ClipboardImpl.cpp |
sf::priv::ClipboardImpl::setStringImpl(sf::String const&) | void ClipboardImpl::setStringImpl(const String& text)
{
m_clipboardContents = text;
// Set our window as the current owner of the selection
XSetSelectionOwner(m_display, m_clipboard, m_window, CurrentTime);
// Check if setting the selection owner was successful
if (XGetSelectionOwner(m_display, m_... | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x22cee
movq (%rbx), %rdx
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
xorl %ecx, %ecx
callq 0xc9f0
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0xd300
cmpq (%rbx), %rax
jne 0x1f6c7
popq %rbx
retq
callq 0x2237c
movq %rax, %rbx
leaq 0xb9fc4(%rip), %rsi # 0xd969a
mo... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/ClipboardImpl.cpp |
sf::priv::ClipboardImpl::processEventsImpl() | void ClipboardImpl::processEventsImpl()
{
XEvent event;
// Pick out the events that are interesting for this window
while (XCheckIfEvent(m_display, &event, &checkEvent, reinterpret_cast<XPointer>(m_window)))
m_events.push_back(event);
// Handle the events for this window that we just picked ou... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
leaq 0x38d(%rip), %rdx # 0x1face
movq %rsp, %rsi
callq 0xd380
testl %eax, %eax
je 0x1f7b3
leaq 0x58(%rbx), %r14
movq $-0xc0, %r13
movq %rsp, %r15
leaq 0x36c(%rip), %r12 # 0x1face
mo... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/ClipboardImpl.cpp |
sf::priv::ClipboardImpl::ClipboardImpl() | ClipboardImpl::ClipboardImpl() :
m_window (0),
m_requestResponded(false)
{
// Open a connection with the X server
m_display = OpenDisplay();
// Get the atoms we need to make use of the clipboard
m_clipboard = getAtom("CLIPBOARD", false);
m_targets = getAtom("TARGETS... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq $0x0, (%rdi)
addq $0x38, %rdi
callq 0x2267c
leaq 0x58(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
movq %r14, %rdi
xorl %esi, %... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/ClipboardImpl.cpp |
sf::priv::OpenDisplay() | Display* OpenDisplay()
{
Lock lock(mutex);
if (referenceCount == 0)
{
sharedDisplay = XOpenDisplay(NULL);
// Opening display failed: The best we can do at the moment is to output a meaningful error message
// and cause an abnormal program termination
if (!sharedDisplay)
... | pushq %rbx
subq $0x10, %rsp
leaq 0x10e564(%rip), %rsi # 0x12e830
leaq 0x8(%rsp), %rdi
callq 0x225c4
cmpl $0x0, 0x10e58b(%rip) # 0x12e868
jne 0x202f2
xorl %edi, %edi
callq 0xccc0
movq %rax, 0x10e583(%rip) # 0x12e870
testq %rax, %rax
je 0x20312
incl 0x10e570(%rip) # 0x12e868
movq 0x10e571(%rip), %rbx ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/Display.cpp |
sf::priv::CloseDisplay(_XDisplay*) | void CloseDisplay(Display* display)
{
Lock lock(mutex);
assert(display == sharedDisplay);
referenceCount--;
if (referenceCount == 0)
XCloseDisplay(display);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10e4d1(%rip), %rsi # 0x12e830
leaq 0x8(%rsp), %rdi
callq 0x225c4
cmpq %rbx, 0x10e500(%rip) # 0x12e870
jne 0x20392
decl 0x10e4f0(%rip) # 0x12e868
jne 0x20382
movq %rbx, %rdi
callq 0xd320
leaq 0x8(%rsp), %rdi
callq 0x225d0
addq $0x10, %rsp
popq %rbx
retq
l... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/Display.cpp |
sf::priv::getAtom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | Atom getAtom(const std::string& name, bool onlyIfExists)
{
AtomMap::const_iterator iter = atoms.find(name);
if (iter != atoms.end())
return iter->second;
Display* display = OpenDisplay();
Atom atom = XInternAtom(display, name.c_str(), onlyIfExists ? True : False);
CloseDisplay(display);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10e45f(%rip), %rdi # 0x12e838
movq %rbx, %rsi
callq 0x20530
leaq 0x10e458(%rip), %rcx # 0x12e840
cmpq %rcx, %rax
je 0x203f3
movq 0x40(%rax), %r14
jmp 0x20427
callq 0x202c0
movq %rax, %r15
movq (%rbx), %rsi
movzbl %bpl, %... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/Display.cpp |
sf::priv::JoystickImpl::initialize() | void JoystickImpl::initialize()
{
udevContext = udev_new();
if (!udevContext)
{
sf::err() << "Failed to create udev context, joystick support not available" << std::endl;
return;
}
udevMonitor = udev_monitor_new_from_netlink(udevContext, "udev");
if (!udevMonitor)
{
... | pushq %r14
pushq %rbx
pushq %rax
callq 0xcb70
movq %rax, 0x10dee6(%rip) # 0x12e890
testq %rax, %rax
je 0x20a16
leaq 0xb8f1c(%rip), %rsi # 0xd98d2
movq %rax, %rdi
callq 0xc240
movq %rax, 0x10ded3(%rip) # 0x12e898
testq %rax, %rax
je 0x20a60
leaq 0xb8f5b(%rip), %rsi # 0xd9930
movq %rax, %rdi
xorl %edx, %edx... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/JoystickImpl.cpp |
sf::priv::JoystickImpl::isConnected(unsigned int) | bool JoystickImpl::isConnected(unsigned int index)
{
// See if we can skip scanning if udev monitor is available
if (!udevMonitor)
{
// udev monitor is not available, perform a scan every query
updatePluggedList();
}
else if (hasMonitorEvent())
{
// Check if new joysticks... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %edi, %ebx
movq 0x10d891(%rip), %rdi # 0x12e898
testq %rdi, %rdi
je 0x210a5
callq 0xca90
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/JoystickImpl.cpp |
sf::priv::JoystickImpl::open(unsigned int) | bool JoystickImpl::open(unsigned int index)
{
if (index >= joystickList.size())
return false;
if (joystickList[index].plugged)
{
std::string devnode = joystickList[index].deviceNode;
// Open the joystick's file descriptor (read-only and non-blocking)
m_file = ::open(devnode... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %esi, %ecx
movq 0x10d776(%rip), %rdx # 0x12e880
movq 0x10d767(%rip), %rax # 0x12e878
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rsi # imm = 0x8E38E38E38E38E39
imulq %rdx, %rsi
cmpq... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/JoystickImpl.cpp |
sf::priv::JoystickImpl::update() | JoystickState JoystickImpl::JoystickImpl::update()
{
if (m_file < 0)
{
m_state = JoystickState();
return m_state;
}
// pop events from the joystick file
js_event joyState;
int result = read(m_file, &joyState, sizeof(joyState));
while (result > 0)
{
switch (joySta... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edi
testl %edi, %edi
js 0x21c2c
leaq 0x4(%rsp), %rsi
movl $0x8, %edx
callq 0xcdd0
testl %eax, %eax
jle 0x21c1b
leaq 0x4(%rsp), %r15
leaq 0xb7cec(%rip), %r12 # 0xd9848
movzbl 0xa(%rsp), %eax
andl $0x7f, %eax
cm... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Window/Unix/JoystickImpl.cpp |
sf::String::String(char, std::locale const&) | String::String(char ansiChar, const std::locale& locale)
{
m_string += Utf32::decodeAnsi(ansiChar, locale);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rdx, %rdi
callq 0xd150
movq (%rax), %rcx
movsbl %bpl, %esi
movq %rax, %rdi
callq *0x50(%rcx)
movq %rbx, %rdi
movl %eax, %esi
callq 0x1a636
addq ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/System/String.cpp |
sf::String::String(wchar_t) | String::String(wchar_t wideChar)
{
m_string += Utf32::decodeWide(wideChar);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
callq 0x1a636
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x22748
movq (%r15), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xc940
movq %r14, %rdi
callq 0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/System/String.cpp |
sf::String::String(unsigned int) | String::String(Uint32 utf32Char)
{
m_string += utf32Char;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
callq 0x1a636
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x22794
movq (%r15), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xc940
movq %r14, %rdi
callq 0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/System/String.cpp |
sf::String::String(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | String::String(const std::wstring& wideString)
{
m_string.reserve(wideString.length() + 1);
Utf32::fromWide(wideString.begin(), wideString.end(), std::back_inserter(m_string));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
incq %rsi
callq 0x22f8a
movq 0x8(%r14), %rax
testq %rax, %rax
jle 0x22988
movq (%r14), %r14
leaq (%r14,%rax,4), %r12
movl (%r14),... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/System/String.cpp |
sf::String::toUtf8[abi:cxx11]() const | std::basic_string<Uint8> String::toUtf8() const
{
// Prepare the output string
std::basic_string<Uint8> output;
output.reserve(m_string.length());
// Convert
Utf32::toUtf8(m_string.begin(), m_string.end(), std::back_inserter(output));
return output;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x2311a
movq 0x8(%r14), %rax
testq %rax, %rax
jle 0x22c11
movq (%r14), %r14
leaq (%r14,%rax,4), %r12
movq %rbx, %rax
movl (... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/System/String.cpp |
sf::priv::sleepImpl(sf::Time) | void sleepImpl(Time time)
{
Uint64 usecs = time.asMicroseconds();
// Construct the time to wait
timespec ti;
ti.tv_nsec = (usecs % 1000000) * 1000;
ti.tv_sec = usecs / 1000000;
// Wait...
// If nanosleep returns -1, we check errno. If it is EINTR
// nanosleep was interrupted and has se... | pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0x23cce
movq %rax, %rcx
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
mulq %rdx
shrq $0x12, %rdx
imulq $0xf4240, %rdx, %rax # imm = 0xF4240
subq %rax, %rcx
imulq $0x3e8, %rcx, %rax # imm = 0x3E8
leaq 0x10(%rs... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/System/Unix/SleepImpl.cpp |
sf::operator+=(sf::Color&, sf::Color const&) | Color& operator +=(Color& left, const Color& right)
{
return left = left + right;
} | movq %rdi, %rax
movzbl (%rdi), %edx
movzbl (%rsi), %ecx
addl %edx, %ecx
movl $0xff, %edi
cmpl %edi, %ecx
cmovael %edi, %ecx
movzbl 0x1(%rax), %r8d
movzbl 0x1(%rsi), %edx
addl %r8d, %edx
cmpl %edi, %edx
cmovael %edi, %edx
movzbl 0x2(%rax), %r8d
movzbl 0x2(%rsi), %r9d
addl %r8d, %r9d
cmpl %edi, %r9d
cmovael %edi, %r9d
mo... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Color.cpp |
stbi_write_jpg_core(stbi__write_context*, int, int, int, void const*, int) | static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {
// Constants that don't pollute global namespace
static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};
static const unsigned char std_dc_luminance_valu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5f8, %rsp # imm = 0x5F8
movl %ecx, %r15d
movq %rdi, 0x28(%rsp)
leal -0x5(%r15), %ecx
xorl %eax, %eax
cmpl $-0x4, %ecx
jb 0x28737
movl %edx, %ebx
testl %edx, %edx
je 0x28737
testl %esi, %esi
je 0x28737
movq %r8, %r14
testq %r8, %r8
je 0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image_write.h |
stbi_write_jpg | STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
{
stbi__write_context s;
if (stbi__start_write_file(&s,filename)) {
int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
stbi__end_write_file(&s);
return r;
} else
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r13d
leaq 0xb3977(%rip), %rsi # 0xdc0e3
callq 0xcad0
movq %rax, %r12
leaq 0x103ed(%rip), %rax # 0x38b68
movq %rax, 0x8(%rsp)
movq %r12, 0x10(%rsp)
testq ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image_write.h |
stbi__idct_block(unsigned char*, int, short*) | static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
{
int i,val[64],*v=val;
stbi_uc *o;
short *d = data;
// columns
for (i=0; i < 8; ++i,++d, ++v) {
// if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %esi, -0x78(%rsp)
movq %rdi, %r11
movl $0x38, %eax
movq %rdi, -0x70(%rsp)
movswl -0x60(%rdx,%rax,2), %edi
testl %edi, %edi
jne 0x306de
cmpw $0x0, -0x50(%rdx,%rax,2)
jne 0x306de
cmpw $0x0, -0x40(%rdx,%rax,2)
jne 0x306de
cmpw $0x0, -0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__process_frame_header(stbi__jpeg*, int) | static int stbi__process_frame_header(stbi__jpeg *z, int scan)
{
stbi__context *s = z->s;
int Lf,p,i,q, h_max=1,v_max=1,c;
Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq 0x327c6
cmpl $0xa, %eax
ja 0x32119
leaq 0xaa1ce(%rip), %rax # 0xdc2e2
jmp 0x32213
movl %eax, %r15d
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), %rax
jb 0x32189
cmpl $0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__get8(stbi__context*) | stbi_inline static stbi_uc stbi__get8(stbi__context *s)
{
if (s->img_buffer < s->img_buffer_end)
return *s->img_buffer++;
if (s->read_from_callbacks) {
stbi__refill_buffer(s);
return *s->img_buffer++;
}
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rdi), %rax
cmpq 0xc0(%rdi), %rax
jb 0x327b1
cmpl $0x0, 0x30(%rbx)
je 0x32789
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %r14
movl 0x34(%rbx), %edx
movq %r14, %rsi
callq *0x10(%rbx)
testl %eax, %eax
je 0x3278d
movq %r14, 0xb8(%rbx)
cltq
addq %r14, %rax
movq %rax, 0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__get16be(stbi__context*) | static int stbi__get16be(stbi__context *s)
{
int z = stbi__get8(s);
return (z << 8) + stbi__get8(s);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8(%rdi), %rax
cmpq 0xc0(%rdi), %rax
jb 0x32835
cmpl $0x0, 0x30(%rbx)
je 0x3280d
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %r14
movl 0x34(%rbx), %edx
movq %r14, %rsi
callq *0x10(%rbx)
testl %eax, %eax
je 0x32811
movq %r14, 0xb8(%rbx)
cltq
addq %r14, %rax
movq %rax, 0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__build_huffman(stbi__huffman*, int*) | static int stbi__build_huffman(stbi__huffman *h, int *count)
{
int i,j,k=0,code;
// build size list for each symbol (from JPEG spec)
for (i=0; i < 16; ++i)
for (j=0; j < count[i]; ++j)
h->size[k++] = (stbi_uc) (i+1);
h->size[k] = 0;
// compute actual symbols (from jpeg spec)
code = 0;
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x500(%rdi), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $0x0, (%rsi,%rcx,4)
jle 0x328f8
leal 0x1(%rcx), %edi
movslq %edx, %r8
addq %rax, %r8
xorl %r9d, %r9d
movb %dil, (%r8,%r9)
incq %r9
cmpl (%rsi,%rcx,4), %r9d
jl 0x328e8
addl %r9d, %edx
incq %rcx
cmpq $0x10, %rcx
j... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__skip(stbi__context*, int) | static void stbi__skip(stbi__context *s, int n)
{
if (n < 0) {
s->img_buffer = s->img_buffer_end;
return;
}
if (s->io.read) {
int blen = (int) (s->img_buffer_end - s->img_buffer);
if (blen < n) {
s->img_buffer = s->img_buffer_end;
(s->io.skip)(s->io_user_data, n - blen... | testl %esi, %esi
js 0x32a47
cmpq $0x0, 0x10(%rdi)
je 0x32a3d
movq 0xc0(%rdi), %rcx
movl 0xb8(%rdi), %eax
movl %ecx, %edx
subl %eax, %edx
movl %esi, %eax
subl %edx, %eax
jle 0x32a3d
movq %rcx, 0xb8(%rdi)
movq 0x18(%rdi), %rcx
movq 0x28(%rdi), %rdi
movl %eax, %esi
jmpq *%rcx
movl %esi, %eax
addq %rax, 0xb8(%rdi)
retq
mov... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__mad3sizes_valid(int, int, int, int) | static int stbi__mad3sizes_valid(int a, int b, int c, int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
stbi__addsizes_valid(a*b*c, add);
} | xorl %r9d, %r9d
movl %esi, %eax
orl %edi, %eax
js 0x32aaf
movl %edx, %r8d
testl %esi, %esi
je 0x32a76
xorl %r9d, %r9d
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %esi
cmpl %edi, %eax
jl 0x32aaf
imull %edi, %esi
movl %esi, %eax
orl %r8d, %eax
movl $0x0, %r9d
js 0x32aaf
testl %r8d, %r8d
je 0x32a9... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__resample_row_v_2(unsigned char*, unsigned char*, unsigned char*, int, int) | static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate two samples vertically for every one in input
int i;
STBI_NOTUSED(hs);
for (i=0; i < w; ++i)
out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
return out;
} | movq %rdi, %rax
testl %ecx, %ecx
jle 0x32bf0
movl %ecx, %ecx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
leal (%r8,%r8,2), %r8d
movzbl (%rdx,%rdi), %r9d
addl %r9d, %r8d
addl $0x2, %r8d
shrl $0x2, %r8d
movb %r8b, (%rax,%rdi)
incq %rdi
cmpq %rdi, %rcx
jne 0x32bcb
retq
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__resample_row_h_2(unsigned char*, unsigned char*, unsigned char*, int, int) | static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate two samples horizontally for every one in input
int i;
stbi_uc *input = in_near;
if (w == 1) {
// if only one sample, can't do any interpolation
out[0] = out[1] = input[... | movq %rdi, %rax
movb (%rsi), %dl
cmpl $0x1, %ecx
jne 0x32c01
movb %dl, 0x1(%rax)
movb %dl, (%rax)
retq
movb %dl, (%rax)
movzbl (%rsi), %edx
leal (%rdx,%rdx,2), %edx
movzbl 0x1(%rsi), %edi
addl %edi, %edx
addl $0x2, %edx
shrl $0x2, %edx
movb %dl, 0x1(%rax)
leal -0x1(%rcx), %edi
movl $0x2, %edx
cmpl $0x3, %ecx
jl 0x32c71... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__jpeg_decode_block(stbi__jpeg*, short*, stbi__huffman*, stbi__huffman*, short*, int, unsigned short*) | static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
{
int diff,dc,k;
int t;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
t = stbi__jpeg_huff_decode(j, hdc);
if (t < 0) return stbi__err("bad huffm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r12
cmpl $0xf, 0x4824(%rdi)
jg 0x32d02
movq %r12, %rdi
callq 0x331ef
cmpl $0xf, 0x4824(%r12)
jg 0x32d15
movq %r12, %rdi
callq 0x331ef
movl 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__grow_buffer_unsafe(stbi__jpeg*) | static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
{
do {
int b = j->nomore ? 0 : stbi__get8(j->s);
if (b == 0xff) {
int c = stbi__get8(j->s);
while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
if (c != 0) {
j->marker = (unsigned char) c;
j->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl $0x0, 0x482c(%rbx)
jne 0x3327f
movq (%rbx), %r15
movq 0xb8(%r15), %rax
cmpq 0xc0(%r15), %rax
jb 0x33271
cmpl $0x0, 0x30(%r15)
je 0x3327f
movq 0x28(%r15), %rdi
leaq 0x38(%r15), %r14
movl 0x34(%r15), %edx
movq %r14, %rsi
callq *0x... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__jpeg_decode_block_prog_dc(stbi__jpeg*, short*, stbi__huffman*, int) | static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
{
int diff,dc;
int t;
if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
if (j->succ_high == 0) {
// first scan fo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, 0x4838(%rdi)
je 0x333c9
leaq 0xa8f2b(%rip), %rax # 0xdc2e2
movq %rax, 0xfb642(%rip) # 0x12ea00
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xf, 0x482... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__check_png_header(stbi__context*) | static int stbi__check_png_header(stbi__context *s)
{
static stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
int i;
for (i=0; i < 8; ++i)
if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
return 1;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq 0x39(%rdi), %r15
xorl %r12d, %r12d
leaq 0xa8866(%rip), %r13 # 0xdbec4
movq 0xb8(%rbx), %rax
cmpq 0xc0(%rbx), %rax
jb 0x336be
cmpl $0x0, 0x30(%rbx)
je 0x3369a
movq 0x28(%rbx), %rdi
movl 0x34(%rbx), %edx
movq %r14, %rsi
... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__parse_png_file(stbi__png*, int, int) | static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
{
stbi_uc palette[1024], pal_img_n=0;
stbi_uc has_trans=0, tc[3];
stbi__uint16 tc16[3];
stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
int first=1,k,interlace=0, color=0, is_iphone=0;
stbi__context *s = z->s;
z->expanded = NU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movl %edx, 0x74(%rsp)
movl %esi, %ebx
movq (%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rdi)
movq %r13, %rdi
callq 0x33640
testl %eax, %eax
je 0x3475d
movl $0x1,... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__getn(stbi__context*, unsigned char*, int) | static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
{
if (s->io.read) {
int blen = (int) (s->img_buffer_end - s->img_buffer);
if (blen < n) {
int res, count;
memcpy(buffer, s->img_buffer, blen);
count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x35104
movq 0xb8(%rbx), %rsi
movq 0xc0(%rbx), %r13
subq %rsi, %r13
movl %ebp, %r15d
subl %r13d, %r15d
jle 0x350ff
movslq %r13d, %r12
movq %r14, %rdi
movq %r12, %rdx
call... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__compute_transparency16(stbi__png*, unsigned short*, int) | static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi__uint16 *p = (stbi__uint16*) z->out;
// compute color-based transparency, assuming we've
// already got 65535 as the alpha value in the ... | pushq %rax
movq (%rdi), %r8
movq 0x18(%rdi), %rax
movl 0x4(%r8), %ecx
imull (%r8), %ecx
cmpl $0x2, %edx
je 0x35194
cmpl $0x4, %edx
jne 0x351bc
testl %ecx, %ecx
je 0x351ba
movl %ecx, %ecx
xorl %edx, %edx
movzwl (%rax,%rdx,8), %edi
cmpw (%rsi), %di
jne 0x3518b
movzwl 0x2(%rax,%rdx,8), %edi
cmpw 0x2(%rsi), %di
jne 0x3518b... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__compute_transparency(stbi__png*, unsigned char*, int) | static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi_uc *p = z->out;
// compute color-based transparency, assuming we've
// already got 255 as the alpha value in the output
STBI_ASSERT(out_n ==... | pushq %rax
movq (%rdi), %r8
movq 0x18(%rdi), %rax
movl 0x4(%r8), %ecx
imull (%r8), %ecx
cmpl $0x2, %edx
je 0x3522a
cmpl $0x4, %edx
jne 0x3524e
testl %ecx, %ecx
je 0x3524c
movl %ecx, %ecx
xorl %edx, %edx
movb (%rax,%rdx,4), %dil
cmpb (%rsi), %dil
jne 0x35221
movb 0x1(%rax,%rdx,4), %dil
cmpb 0x1(%rsi), %dil
jne 0x35221
m... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.