Array size depending on symbol address

Discussion in 'C Programming' started by usenet@zevv.nl, Nov 29, 2005.

  1. Guest

    Hello,

    I am running my code on an embedded platform without OS. I have defined some
    data in a section called .eeprom. The section is defined by the linker
    script and starts at address zero. The symbol __eeprom_end is defined by the
    linker script as well, and lies at the end of this section. The address of
    __eeprom_end is thus equal to the number of bytes in the .eeprom section.

    My problem : I want to declare an array in .bss with the same size of this
    section. My naive approch was :

    extern void *_eeprom;
    char eeprom_shadow[(int)&_eeprom_end];

    This fails miserably, ofcourse : the compiler doesn't know the address of
    __eeprom before the linker is done, so it can not declare the array.

    Is there a trick to allocate the memory for this array at compile time ? I'd
    rather not use malloc() and friends, since I am working on a platform with a
    very small amount of memory, and don't like using dynamic memory here.

    Thanks,


    --
    :wq
    ^X^Cy^K^X^C^C^C^C
     
    , Nov 29, 2005
    #1
    1. Advertising

  2. >I am running my code on an embedded platform without OS. I have defined some
    >data in a section called .eeprom. The section is defined by the linker
    >script and starts at address zero. The symbol __eeprom_end is defined by the
    >linker script as well, and lies at the end of this section. The address of
    >__eeprom_end is thus equal to the number of bytes in the .eeprom section.
    >
    >My problem : I want to declare an array in .bss with the same size of this
    >section. My naive approch was :
    >
    > extern void *_eeprom;
    > char eeprom_shadow[(int)&_eeprom_end];
    >
    >This fails miserably, ofcourse : the compiler doesn't know the address of
    >__eeprom before the linker is done, so it can not declare the array.
    >
    >Is there a trick to allocate the memory for this array at compile time ? I'd
    >rather not use malloc() and friends, since I am working on a platform with a
    >very small amount of memory, and don't like using dynamic memory here.


    You have a fundamental chicken-or-the-egg problem here. A change
    in the size of the array can change the size of the code (because,
    for example, instructions can have short or long offsets), which
    can change the size of the .eeprom section, which can change the
    size of the array, which can change the size of the code AGAIN,
    which can change the size of the .eeprom section AGAIN, ad nauseum.

    Gordon L. Burditt
     
    Gordon Burditt, Nov 29, 2005
    #2
    1. Advertising

  3. Guest

    >>I am running my code on an embedded platform without OS. I have defined some
    >>data in a section called .eeprom. The section is defined by the linker
    >>script and starts at address zero. The symbol __eeprom_end is defined by the
    >>linker script as well, and lies at the end of this section. The address of
    >>__eeprom_end is thus equal to the number of bytes in the .eeprom section.
    >>
    >>My problem : I want to declare an array in .bss with the same size of this
    >>section. My naive approch was :
    >>
    >> extern void *_eeprom;
    >> char eeprom_shadow[(int)&_eeprom_end];
    >>
    >>This fails miserably, ofcourse : the compiler doesn't know the address of
    >>__eeprom before the linker is done, so it can not declare the array.
    >>
    >>Is there a trick to allocate the memory for this array at compile time ? I'd
    >>rather not use malloc() and friends, since I am working on a platform with a
    >>very small amount of memory, and don't like using dynamic memory here.

    >
    > You have a fundamental chicken-or-the-egg problem here. A change
    > in the size of the array can change the size of the code (because,
    > for example, instructions can have short or long offsets), which
    > can change the size of the .eeprom section, which can change the
    > size of the array, which can change the size of the code AGAIN,
    > which can change the size of the .eeprom section AGAIN, ad nauseum.
    >
    > Gordon L. Burditt


    Hi Gordon,

    Yes, this would be a problem if my the rest of my code would change anything
    to the .eeprom section. This is not the case however, since I specifically
    declare some variables with attributes to place them in the .eeprom section,
    and no other data will go there. (The rest is in the usual places, .text,
    ..data, .bss)

    --
    :wq
    ^X^Cy^K^X^C^C^C^C
     
    , Nov 29, 2005
    #3
  4. Skarmander Guest

    wrote:
    > Hello,
    >
    > I am running my code on an embedded platform without OS. I have defined some
    > data in a section called .eeprom. The section is defined by the linker
    > script and starts at address zero. The symbol __eeprom_end is defined by the
    > linker script as well, and lies at the end of this section. The address of
    > __eeprom_end is thus equal to the number of bytes in the .eeprom section.
    >
    > My problem : I want to declare an array in .bss with the same size of this
    > section. My naive approch was :
    >
    > extern void *_eeprom;
    > char eeprom_shadow[(int)&_eeprom_end];
    >
    > This fails miserably, ofcourse : the compiler doesn't know the address of
    > __eeprom before the linker is done, so it can not declare the array.
    >
    > Is there a trick to allocate the memory for this array at compile time ?


    Your identifiers are all over each other. Is _eeprom the address of the
    section .eeprom? Is _eeprom_end a typo or intended to be the same as
    __eeprom_end? What is __eeprom with two underscores?

    In any case, as you say, all this information is available at link time.
    There is simply no way to turn these symbols or their addresses into
    compile-time constants if you don't already have the information available,
    and global array sizes must be compile-time constants.

    Any reason why you can't have the linker declare a section .eeprom_shadow of
    equal size and use the address of that? Indexing would work the same; the
    only restriction is that you still don't know the size at compile time, but
    that shouldn't be too much of a problem, since you'd have __eeprom_end (or
    _eeprom_end) available at runtime.

    S.
     
    Skarmander, Nov 29, 2005
    #4
  5. Guest

    Skarmander <> wrote:
    > wrote:
    >> Hello,
    >>
    >> I am running my code on an embedded platform without OS. I have defined some
    >> data in a section called .eeprom. The section is defined by the linker
    >> script and starts at address zero. The symbol __eeprom_end is defined by the
    >> linker script as well, and lies at the end of this section. The address of
    >> __eeprom_end is thus equal to the number of bytes in the .eeprom section.
    >>
    >> My problem : I want to declare an array in .bss with the same size of this
    >> section. My naive approch was :
    >>
    >> extern void *_eeprom;
    >> char eeprom_shadow[(int)&_eeprom_end];
    >>
    >> This fails miserably, ofcourse : the compiler doesn't know the address of
    >> __eeprom before the linker is done, so it can not declare the array.
    >>
    >> Is there a trick to allocate the memory for this array at compile time ?

    >
    > Your identifiers are all over each other. Is _eeprom the address of the
    > section .eeprom? Is _eeprom_end a typo or intended to be the same as
    > __eeprom_end? What is __eeprom with two underscores?


    Yes, definitely all over eachother, very confusing, I'm sorry. It should
    read '__eeprom_end' everywhere.

    > Any reason why you can't have the linker declare a section .eeprom_shadow of
    > equal size and use the address of that? Indexing would work the same; the
    > only restriction is that you still don't know the size at compile time, but
    > that shouldn't be too much of a problem, since you'd have __eeprom_end (or
    > _eeprom_end) available at runtime.


    Yes, having the linker create another section should work ofcourse, thanks
    for the hint,

    --
    :wq
    ^X^Cy^K^X^C^C^C^C
     
    , Nov 29, 2005
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. baumann@pan
    Replies:
    1
    Views:
    751
    Richard Bos
    Apr 15, 2005
  2. bernd
    Replies:
    0
    Views:
    597
    bernd
    Aug 3, 2008
  3. Stanley Rice

    Address of array && address of pointer to array

    Stanley Rice, Sep 14, 2011, in forum: C Programming
    Replies:
    33
    Views:
    1,155
    Keith Thompson
    Sep 20, 2011
  4. Song Ma
    Replies:
    2
    Views:
    237
    Charles Oliver Nutter
    Jul 20, 2008
  5. Replies:
    6
    Views:
    1,818
Loading...

Share This Page