cpsr | Cancer Predisposition Sequencing Reporter | Genomics library

Update your Unity Editor to something above 2020.

To answer my own issue, the problem was I had a switch statement at the top level of my app that did not have a corresponding break a the end of the case.

Editing for clarity...

Here was the offending code:

Simply binary addition, x is the carry in to the operation and y is the carry out. For a normal add carry in is a 0 and for a normal subtract carry in is a 1. (adders are used to do subtraction, one of the features of twos complement)

The assembly code resolves the address of global variable gl_pClient using dll relocations, which are loaded using program-counter-relative addressing. Then the code loads from that address and crashes. It looks like the relocations got corrupted, so that the resolved address is invalid.

There isn't much else can be said without a reproduction.

You may like to run your program under valgrind which may report memory corruption.

Did you try m_DBFileName as std::string instead of char * or array?

And please try to share a minimal reproducible example for static variable initialization.

As you can see from the code, the compiler has placed the return address below the buffer on the stack, so it is impossible for you to overwrite it, no matter how many bytes you write.

Specifically, stp x29, x30, [sp, #-96]! is pre-decrement, so it stores x29 at the new address of [sp], and x30, which contains the return address, at [sp, 8]. The buffer, on the other hand, is at [sp, 32] (note the add x0, sp, 0x20). This is typical for ARM64; the pre-decrement addressing mode makes it convenient to store the return address at the bottom of the stack frame, below all the function's local variables.

What you may be able to overwrite instead is the return address saved by whatever function called main (somewhere in the C startup code, e.g. glibc's __libc_start_main()). That would only happen when that other function returns to its own caller, so you have stopped the program too soon.

Unfortunately for you, on many systems, that function does not return at all; it calls exit() instead. That's what glibc's __libc_start_main does.. As such, unless I am missing something, this kind of buffer overflow will not work on such a system when gets is called from within main. If you want to play with it, try writing a different program where it's called from some subroutine:

While editing my initial question to add more context as Jay proposed I think it found the issue.

What probably happens? The view where the crash is, contains a table view. Each cell will be configured before being presented. I use a flag which holds the information, if the amount of weight for this cell (it is a strength workout app) has been initially set or is a change. When prepareForReuse is being called, this flag has not been reset. And that now means scrolling through the table view triggers a DB write for each reused cell, that leads to unnecessary writes to the db. Unnecessary, because the exact same number is already saved in the db.

My speculation: Scrolling fast could maybe lead to a race condition (I have read something about that issue with realm) and that maybe causes this weird crash, because there are multiple single writes initiated in a short time.

Solution: I now reset the flag on prepareForReuse to its initial value to prevent this misbehaviour.

The crash only happens when the cell is set up and the described behaviour happens. Therefor I'm quite confident I fixed the issue finally. Let's see. -- I was not able to reproduce the issue, but it also only happens pretty rare.

I have been trying to debug an C application on aarch64 and I want to get the $ebp value.

There is no such register on the aarch64 processor, and your question makes no sense.

In general, in order to debug at the machine instruction level, you must understand the CPU architecture your program is executing on: registers available, instructions, procedure calling conventions, etc.

Without such understanding debugging at the instruction level is impossible.

To understand aarch64 architecture, you could start here.

You have a permissions problem here, in low versions of Android, when you install the app, it guarantees all the permissions, but in the latest Android APIs, you have to request permission at runtime, if you don't and for example try read your app's storage information then your app will be crash