msp430 | Code for Texas Instruments MSP430 LauchPad

I got an answer on another forum. Maybe someone else faces the same problem, so I'll post the solution here:

In Code Composer Studio go to Properties -> Processor Options and try the settings as shown in this screenshot.

Many thanks to Johnson, who provided this answer (https://e2e.ti.com/support/microcontrollers/msp-low-power-microcontrollers-group/msp430/f/msp-low-power-microcontroller-forum/1001359/mspdriverlib-error-when-using-msp430-driver-library-only-large-data-model-supported-for-this-rom)!

Best regards.

It seems that you are linking to the wrong memory spec file. I would recommend to ensure that this file exists link-arg=-Tlink.x, otherwise switch it to the correct file.

Rust embedded named their memory file memory.x, and I assume have followed the steps. So changing the flag to link-arg=-Tmemory.xshould fix it.

Very brief overview for GCC:

GCC's .md machine definition files tell it what instructions are available and what they do, using similar constraint syntax to GNU C inline asm. (GCC doesn't know about machine code, only asm text, that's why it can only output a .s for as to assemble separately.) There are also some C functions that know about generic rules for that architecture, and I guess stuff like register names.

The GCC-internals manual has a section 6.3.9 Anatomy of a Target Back End that documents where the relevant files are in the GCC source tree.

As pointed out in the coments by Peter Cordes, my initial thought is correct. (Even though the wording is off)

The value stored in the memoryaddress, which is equal to the sum of the value stored in r4 plus the offset -4 is decremented by the register plus -4 (offset) and stored in r15. That's it really.

Example:

If

r4 = 0x43FC and 0x43F8 = 0xAB

The instruction

Nothing changes between signed and unsigned subtraction. What changes is what kind of jump you use: JLO or JL. JL and JGE is used for signed comparison. JLO and JHS are used for unsigned comparison. So, in your case, you are using unsigned comparison and the jlo will not jump to 0xda36 as CMP will set the carry bit. Note that JLO is an alias for JNC (jump if not carry).

To compute manually the subraction you can traslate it to the sum of the first addend plus the one complement of the second + 1. So in you case you have:

It would help to take a look at the documentation.
Section 3.4.6.14 of the MSP430x2xx Family User's Guide says:

Syntax
CMP src,dst or CMP.W src,dst

Description
The source operand is subtracted from the destination operand. […] The two operands are not affected and the result is not stored; only the status bits are affected.

Status Bits
[…]
C: Set if there is a carry from the MSB of the result, reset otherwise

So the carry flag will be set if subtracting 0x200 from zero needs a carry.

This meaning of the carry flag is made clearer in the documentation of JC/JHS in section 3.4.6.24:

Description
[…] JC (jump if carry/higher or same) is used for the comparison of unsigned numbers (0 to 65536).

Example
R5 is compared to 15. If the content is higher or the same, branch to LABEL.

No, macros don’t know about namespaces. Try to avoid macros whenever possible. Here you can probably do something like

Let f(a, b,…) be a function of signed objects a, b,… Let a', b',… be the values of those objects reinterpreted as unsigned. If, for all values of a, b,… (in their signed types), the reinterpretation of f(a, b,…) as unsigned equals f(a', b',…), then no sign extension of a, b,… is needed when evaluating f.

This is evident because, if the condition is satisfied, then f(a', b',…) produces the bits required to represent f(a, b,…). However, it may be incomplete. We might have some f(a, b) that requires a sign extension of a but not of b, and that is not directly addressed by the above. However, it could be considered included in that f(a, b) may be expressed as a function g_a(b), and then the above tells us no sign extension of b is needed when evaluating g_a. If this is true for all g_a, then evaluating f(a, b) does not require sign extension of b.

Also, the fact that a sign extension is not needed does not imply a compiler will necessarily detect this and generate code without sign extension. A compiler might generate sign extension even if it is not necessary. I think this may be seen in sint8fun; I would expect (int8_t) (a+b)*2 to be evaluable as an addition and a shift without sign extension. However, the compiler may be failing to account for the fact that the expression is converted to int8_t by the return. By itself, (a+b)*2 does require sign extension, as it could produce a negative int result that it would not if the signs were not extended. It is only after the conversion to int8_t that the result is then independent of sign extension.