[SOLVED] C string literal as parameter equals -1 in avr-gcc?

Issue

I am developing a software for AVR microcontroller. Saying in fromt, now I only have LEDs and pushbuttons to debug. The problem is that if I pass a string literal into the following function:

void test_char(const char *str) {
  if (str[0] == -1)
    LED_PORT ^= 1 << 7;         /* Test */
}

Somewhere in main()

test_char("AAAAA");

And now the LED changes state. On my x86_64 machine I wrote the same function to compare (not LED, of course), but it turns out that str[0] equals to 'A'. Why is this happening?

Update: Not sure whether this is related, but I have a struct called button, like this:

typedef struct {
  int8_t seq[BTN_SEQ_COUNT];    /* The sequence of button */
  int8_t seq_count;             /* The number of buttons registered */
  int8_t detected;              /* The detected button */
  uint8_t released;             /* Whether the button is released
                                   after a hold */
} button;
button btn = {
  .seq = {-1, -1, -1},
  .detected = -1,
  .seq_count = 0,
  .released = 0
};

But it turned out that btn.seq_count start out as -1 though I defined it as 0.

Update2

For the later problem, I solved by initializing the values in a function. However, that does not explain why seq_count was set to -1 in the previous case, nor does it explain why the character in string literal equals to -1.

Update3

Back to the original problem, I added a complete mini example here, and same occurs:

void LED_on() {
  PORTA = 0x00;
}

void LED_off() {
  PORTA = 0xFF;
}

void port_init() {
  PORTA = 0xFF;
  DDRA |= 0xFF;
}

void test_char(const char* str) {
    if (str[0] == -1) {
        LED_on();
    }
}

void main() {
  port_init();
  test_char("AAAAA");
  while(1) {
  }
}

Update 4

I am trying to follow Nominal Animal's advice, but not quite successful. Here is the code I have changed:

void test_char(const char* str) {
    switch(pgm_read_byte(str++)) {
        case '\0': return;
        case 'A': LED_on(); break;
        case 'B': LED_off(); break;
    }
}
void main() {
  const char* test = "ABABA";
  port_init();
  test_char(test);
  while(1) {
  }
}

I am using gcc 4.6.4,

avr-gcc -v
Using built-in specs.
COLLECT_GCC=avr-gcc
COLLECT_LTO_WRAPPER=/home/carl/Softwares/AVR/libexec/gcc/avr/4.6.4/lto-wrapper
Target: avr
Configured with: ../configure --prefix=/home/carl/Softwares/AVR --target=avr --enable-languages=c,c++ --disable-nls --disable-libssp --with-dwarf2
Thread model: single
gcc version 4.6.4 (GCC) 

Solution

Rewritten from scratch, to hopefully clear up some of the confusion.

First, some important background:

AVR microcontrollers have separate address spaces for RAM and ROM/Flash ("program memory").

GCC generates code that assumes all data is always in RAM. (Older versions used to have special types, such as prog_char, that referred to data in the ROM address space, but newer versions of GCC do not and cannot support such data types.)

When linking against avr-libc, the linker adds code (__do_copy_data) to copy all initialized data from program memory to RAM. If you have both avr-gcc and avr-libc packages installed, and you use something like avr-gcc -Wall -O2 -fomit-frame-pointer -mmcu=AVRTYPE source.c -o binary.elf to compile your source file into a program binary, then use avr-objcopy to convert the elf file into the format your firmware utilities support, you are linking against avr-libc.

If you use avr-gcc to only produce an object file source.o, and some other utilities to link and upload your program to your microcontroller, this copying from program memory to RAM may not happen. It depends on what linker and libraries your use.

As most AVRs have only a few dozen to few hundred bytes of RAM available, it is very, very easy to run out of RAM. I'm not certain if avr-gcc and avr-libc reliably detect when you have more initialized data than you have RAM available. If you specify any arrays containing strings, it is very likely you're already overrun your RAM, causing all sorts of interesting bugs to appear.

The avr/pgmspace.h header file is part of avr-libc, and defines a macro, PROGMEM, that can be used to specify data that will only be referred to by functions that take program memory addresses (pointers), such as pgm_read_byte() or strcmp_P() defined in the same header file. The linker will not copy such variables to RAM -- but neither will the compiler tell you if you're using them wrong.

If you use both avr-gcc and avr-libc, I recommend using the following approach for all read-only data:

#include <avr/pgmspace.h>

/*
 * Define LED_init(), LED_on(), and LED_off() functions.
*/

void blinky(const char *str)
{
    while (1) {
        switch (pgm_read_byte(str++)) {
            case '\0': return;
            case 'A':  LED_on();  break;
            case 'B':  LED_off(); break;
        }

        /* Add a sleep or delay here,
         * or you won't be able to see the LED flicker. */
    }
}

static const char example1[] PROGMEM = "AB";
const char example2[] PROGMEM = "AAAA";

int main(void)
{
    static const char example3[] PROGMEM = "ABABB";

    LED_init();

    while (1) {
        blinky(example1);
        blinky(example2);
        blinky(example3);
    }
}

Because of changes (new limitations) in GCC internals, the PROGMEM attribute can only be used with a variable; if it refers to a type, it does nothing. Therefore, you need to specify strings as character arrays, using one of the forms above. (example1 is visible within this compilation unit only, example2 can be referred to from other compilation units too, and example3 is visible only in the function it is defined in. Here, visible refers to where you can refer to the variable; it has nothing to do with the contents.)

The PROGMEM attribute does not actually change the code GCC generates. All it does is put the contents to .progmem.data section, iff without it they'd be in .rodata. All of the magic is really in the linking, and in linked library code.

If you do not use avr-libc, then you need to be very specific with your const attributes, as they determine which section the contents will end up in. Mutable (non-const) data should end up in the .data section, while immutable (const) data ends up in .rodata section(s). Remember to read the specifiers from right to left, starting at the variable itself, separated by '*': the leftmost refers to the content, whereas the rightmost refers to the variable. In other words,

const char *s = p;

defines s so that the value of the variable can be changed, but the content it points to is immutable (unchangeable/const); whereas

char *const s = p;

defines s so that you cannot modify the variable itself, but you can the content -- the content s points to is mutable, modifiable. Furthermore,

const char *s = "literal";

defines s to point to a literal string (and you can modify s, ie. make it point to some other literal string for example), but you cannot modify the contents; and

char s[] = "string";

defines s to be a character array (of length 6; string length + 1 for end-of-string char), that happens to be initialized to { 's', 't', 'r', 'i', 'n', 'g', '\0' }.

All linker tools that work on object files use the sections to determine what to do with the contents. (Indeed, avr-libc copies the contents of .rodata sections to RAM, and only leaves .progmem.data in program memory.)

---

Carl Dong, there are several cases where you may observe weird behaviour, even reproducible weird behaviour. I'm no longer certain which one is the root cause of your problem, so I'll just list the ones I think are likely:

1. If linking against avr-libc, running out of RAM

   AVRs have very little RAM, and copying even string literals to RAM easily eats it all up. If this happens, any kind of weird behaviour is possible.

2. Failing to linking against avr-libc

   If you think you use avr-libc, but are not certain, then use avr-objdump -d binary.elf | grep -e '^[0-9a-f]* <_' to see if the ELF binary contains any library code. You should expect to see at least <__do_clear_bss>:, <_exit>:, and <__stop_program>: in that list, I believe.

3. Linking against some other C library, but expecting avr-libc behaviour

   Other libraries you link against may have different rules. In particular, if they're designed to work with some other C compiler -- especially one that supports multiple address spaces, and therefore can deduce when to use ld and when lpm based on types --, it might be impossible to use avr-gcc with that library, even if all the tools talk to each other nicely.

4. Using a custom linker script and a freestanding environment (no C library at all)

   Personally, I can live with immutable data (.rodata sections) being in program memory, with myself having to explicitly copy any immutable data to RAM whenever needed. This way I can use a simple microcontroller-specific linker script and GCC in freestanding mode (no C library at all used), and get complete control over the microcontroller. On the other hand, you lose all the nice predefined macros and functions avr-libc and other C libraries provide.

   In this case, you need to understand the AVR architecture to have any hope of getting sensible results. You'll need to set up the interrupt vectors and all kinds of other stuff to get even a minimal do-nothing loop to actually run; personally, I read all the assembly code GCC produces (from my own C source) simply to see if it makes sense, and to try to make sure it all gets processed correctly.

---

Questions?

Answered By - Nominal Animal