blt | streamlined CMake build system foundation | Build Tool library

You can use

The setup of your types is perfectly fine. However, when we look at the loop you are using:

My guess is that this linker does not handle branch instructions (bne or beq) to external labels.

This will preclude using beq label where label is external (global and in another object file), but this is only really possible to do in assembly.

Compiler output, for example, will have both the branch instruction and target location all within a single function, which goes into a single code chunk. (modulo certain tail call optimization).

With that limitation, then all bne and beq instructions are already fixed up by the compiler or assembler, using pc-relative addressing — there would be no need for an entry in the relocation table for these.

Further, the range of the branch (beq/bne) instructions (+/-128k) is shorter than for j, so if the linker were really intending to support branching to external label, it might also have to provide the capability to introduce branch islands to handle the ones that are branching too far away.

To expand on your example:

If one wanted to remove an element from an array of integers/words, we would not look for a special value so as to mark that element as invalid; one would do as Peter says and close up the gap by repositioning succeeding elements, effectively shortening the array in place.

The same applies for strings, which are also arrays: a string is an array of bytes/characters.

To understand why it is better to remove the element rather than overwriting it, consider other things beside printing that we can do with strings: for example, we can compare them, we can ask for their length, we can extract individual bytes, search for substrings, save them to a file for later use by another program, etc..

With funny characters in random locations all these operations would either not work or require special casing.  It is better to completely remove unwanted characters shortening the string, rather than overwrite them with characters of special meaning.

Further, similar in that there are no zero-width ASCII characters, with an integer/word array, there are no special element values to choose — all the possible values of already have meaning as numbers.

addi $t0, $t0, -32 is faulty.

It should be addi $t1, $t1, -32 .

There are a couple of concepts to disentangle here:

(1) Arm vs Thumb : these are two different instruction sets. Most CPUs support both, some support only one. Both are available simultaneously if the CPU supports both. To simplify a little bit, if you jump to an address with the least significant bit set that means "go to Thumb mode", and jumping to an address with that bit clear means "go to Arm mode". (Interworking is a touch more complicated than that, but that's a good initial mental model.) Note that all Arm instructions are 4 bytes long, but Thumb instructions can be either 2 or 4 bytes long.

(2) A-profile vs M-profile : these are two different families of CPU architecture. M-profile is "microcontrollers"; A-profile is "applications processors", which is "(almost) everything else". M-profile CPUs always support Thumb and only Thumb code. A-profile CPUs support both Arm and Thumb. The Raspberry Pi Pico is a Cortex-M0+, which is M-profile.

(3) QEMU system emulation vs user-mode emulation : these are two different QEMU executables which run guest code in different ways. The system emulation binary (typically qemu-system-arm) runs "bare metal code", eg an entire OS. The guest code has full control and can handle exceptions, write to hardware devices, etc. The user emulation binary (typically qemu-arm) is for running Linux user-space binaries. Guest code is started in unprivileged mode and has access to the usual Linux system calls. For system emulation, which CPU is being emulated depends on what machine type you select with the -M or --machine option. For user-mode emulation, the default CPU is "A-profile with all supported features enabled" (this is --cpu max).

You're currently using qemu-arm which means you get user-mode emulation. This should support Thumb binaries, but unless you pass it a --cpu option it will be using an A-profile CPU. I would also suggest using a newer QEMU for M-profile work, because a lot of M-profile CPU bugs have been fixed since version 4.2. I think 4.2 is also too old to have the Cortex-M0 CPU.

GDB should tell you in the PSR what the T bit is set to -- use that to check whether you're in Thumb mode or Arm mode, rather than looking at how much the PC is incrementing by.

There's currently no QEMU system emulation of the Raspberry Pi Pico (though somebody has been doing some experimental work on one). If your assembly is just basic "working with registers and a bit of memory" you can do that with the user-mode emulator. Or you can try the 'microbit' machine model, which is a Cortex-M0 board -- if you're not doing things that are specific to the Pi Pico that might be good enough.

Simple original answer:

let's take this subquery to understand how can we do it

buffet is the tuple itself. You will print it n (items in your tuple) times with your current implementation.

This should give you the expected output: