mdebug | Debugger For Cortex-M MCUs

Firstly, main, $L3 and $L2 are labels for 3 basic blocks. You are roughly correct about their functions.

Question 1: What is .frame doing

This is not a MIPS instruction. It is metadata describing the (stack) frame for this function:

• The stack is pointed to by $sp, an alias for $29.
• and the size of the stack frame (0, since the function has neither local variables, nor arguments on the stack). Further, the function is simple enough that it can work with scratch registers and does not need to save callee-saved registers $16-$23.
• the old return address ($31 for MIPS calling convention)

For more information regarding the MIPS calling convention, see this doc.

Question 2: Why lw $3,4($4) instead of lw $3,0($4)

This is due to an optimization of the loop. Normally, the sequence of loads and stores would be :

• load source[0]
• store dest[0]
• load source[1]
• store dest[1] ....

You assume that the loop is entirely in $L3, and that contains load source[k] and store dest[k]. It isn't. There are two clues to see this:

• There is a load in the block main which does not correspond to any load outside the loop
• Within the basic block $L3, the store is before the load.

In fact, load source[0] is performed in the basic-block named main. Then, the loop in the basic block $L3 is store dest[k];load source[k+1];. Therefore, the load uses an offset of 4 more than the offset of the store, because it is loading the integer for the next iteration.

Question 3: What is the lo/hi syntax?

This has to do with instruction encodings and pointers. Let us assume a 32-bit architecture, i.e. a pointer is 32 bits. Like most fixed-size instruction ISAs, let us assume that the instruction size is also 32 bits.

Before loading and storing from the source/dest arrays, you need to load their pointers into registers $6 and $7 respectively. Therefore, you need an instruction to load a 32-bit constant address into a register. However, a 32-bit instruction must contain a few bits to encode opcodes (which operation the instruction is), destination register etc. Therefore, an instruction has less than 32 bits left to encode constants (called immediates). Therefore, you need two instructions to load a 32-bit constant into a register, each loading 16 bits. The lo/hi refer to which half of the constant is loaded.

Example: Assume that dest is at address 0xabcd1234. There are two instructions to load this value into $7.

This is likely happening because .Net 4 changed the way that it corrects incorrect P/Invoke calling conventions.

From https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ee941656(v=vs.100):

To improve performance in interoperability with unmanaged code, incorrect calling conventions in a platform invoke now cause the application to fail. In previous versions, the marshaling layer resolved these errors up the stack.

To solve this, you must specify the correct calling convention in the P/Invoke declaration, e.g.

Earlier in your table definition you defined the column COL_REMOTE_FOLDER_ID as a primary key. So, when the second composite primary key definition is encountered, you get an error. Remove the first primary key definition and it should work:

This is how I solved the problem--

in the renderAxisLine function =>

You can consider adding this flag FLAG_ACTIVITY_FORWARD_RESULT to your returnedIntent. It is described here https://developer.android.com/reference/android/content/Intent.html#FLAG_ACTIVITY_FORWARD_RESULT

If set and this intent is being used to launch a new activity from an existing one, then the reply target of the existing activity will be transferred to the new activity. This way, the new activity can call Activity.setResult(int) and have that result sent back to the reply target of the original activity.

If you actively close the app (by closing it from the Android activity list), Android will most likely kill your service. You can see that in your apps Logcat. The only real way around that is a foreground service.

Furthermore, onBind will not be called every time you bind to the service. From the Android documentation:

You can connect multiple clients to a service simultaneously. However, the system caches the IBinder service communication channel. In other words, the system calls the service's onBind() method to generate the IBinder only when the first client binds. The system then delivers that same IBinder to all additional clients that bind to that same service, without calling onBind() again.

Secondly, just that onStartCommand is called does not mean the service is recreated. It can be called multiple times during the service life cycle. For instance, each time startService is called, onStartCommand is executed, but the service is not necessarily recreated.

Also, it looks like you do not un-bind the service when closing the activity. That makes your activity leak the ServiceConnection and your app crash. It would explain why you see the service re-created every time you close and re-start the app.

Try adding an unbind in your activity's onPause method:

In onPreExecute() change to this:

I managed to find a fantastic script for building what I needed: https://github.com/leenjewel/openssl_for_ios_and_android.

The big take away for me here was that if you see 'SSL support: no' and you are expecting to see 'yes' then it's one of two things: 1) it cannot find the path to SSL or 2) the path might be there but the compiled SSL is for the wrong architecture.

As Daniel Stenberg mentioned config.log is your friend here.

It seems it is not possible with free software. I can use Visual Studio with MonoRemoteDebugger and if I have doubts about code compatibility, I can build the project in Xamarin which permits targeting Mono.