Compiler/MSP430F5438A: Maintaining variable declaration order

I'm pretty sure there's no way to do this, since the linker doesn't know what order you declared them in.

If you need variables to be grouped together, put them in a struct-ure.

So there is no option like #pragma GCC optimize ("O0") , which can turn off the optimization for the file to ensure the data is declared in the order specified 

Thanks,

Ashish

It's the linker that decides where global variables end up.

I can't tell you there's no such option, since I don't maintain the compiler. It seems (to me) like a very expensive feature which would provide very little benefit, since C provides a capability to force variables to be grouped.

If you want, you can wait to see if one of the compiler people has a comment. Is there a reason you can't use a struct?

By default the linker appears to order variables to avoid holes due to padding.

By default the TI compiler places global variables in their own subsection (the default for the --gen_data_subsections option is on).

It is possible to use a GROUP in the linker command file to specify the order in which global variables are placed, by specifying the subsection names for the global variables.

E.g. in the attached example project there are the following global variables in the C source code:

uint32_t crc;

uint8_t version[9];

bool flag1;

bool flag2;

bool flag3;

int32_t var1[2];

int32_t var2;

uint32_t var3;

Which since are uninitialised get placed in .bss:.common:<var_name> sections.

The following was added to the SECTIONS in the linker command file to control the order of allocation:

    GROUP
    {
    	/* Specify the order the global variables are to be placed */
    	.bss : {
    		*(.bss:.common:crc)
    	        *(.bss:.common:version)
    	        *(.bss:.common:flag1)
    	        *(.bss:.common:flag2)
    	        *(.bss:.common:flag3)
    	        *(.bss:.common:var1)
    	        *(.bss:.common:var2)
    	        *(.bss:.common:var3)
    	        }
    } > RAM

And the linker map file showed the order has been respected, including a one byte hole to meet the alignment requirements:

 output                                  attributes/
section   page    origin      length       input sections
--------  ----  ----------  ----------   ----------------
.bss       0    00001c00    00000022     UNINITIALIZED
                  00001c00    00000004     (.common:crc)
                  00001c04    0000000a     (.common:version)
                  00001c0e    00000001     (.common:flag1)
                  00001c0f    00000001     (.common:flag2)
                  00001c10    00000001     (.common:flag3)
                  00001c11    00000001     --HOLE--
                  00001c12    00000008     (.common:var1)
                  00001c1a    00000004     (.common:var2)
                  00001c1e    00000004     (.common:var3)

See TI Linker Command File Primer for some background information.

MSP430F5438A_linker_variable_order.zip

I tried the above method as suggested. It didn't workout. 

Basically i'm trying to generate a bin file which will be loaded to controller as a separate image based on the configuration required. So for that i create a separate project to generate the file which have only initialized data. 

Here is what i did:

content of source file

#include "file.h"

extern const Uint32 LINKER__CRC_VALUE;
/* Address of the CRC */
const Uint32* const crc_loc = &LINKER__CRC_VALUE;
const Uint8 version[19U] = {"version.1.1.1.1.1.0"};
const Uint32 number = 4000UL;
const Bool value = false;
const Bool fault = true;
const Int32 feet = 2000L;
const Uint32 press = 40UL;
const Uint32 rpm = 40UL;
const Uint32 rpm2 = 408UL;

const Uint32 gain[3U] = { 0UL, 820UL, 904UL};
const Uint32 constants[3U] = {83UL, 89UL, 89UL};
const Int32 gain2 = 678L;
const Int32 gain3 = 122L;

Contented of header file

#include "types.h"

/* Address of the CRC */
const Uint32* const crc_loc;
const Uint8 version[19U];
const Uint32 number;
const Bool value;
const Bool fault;
const Int32 feet;
const Uint32 press;
const Uint32 rpm;
const Uint32 rpm2;
const Uint32 gain[3U];
const Uint32 constants[3U];
const Int32 gain2;
const Int32 gain3;

Content of Linker file:

After compiling, it generate following linker warnings for most of the variable.

"#10068-D no matching section"

After looking at the map file, i found that linker is still generating the variable in random order and clubbing them to fill the memory in alignment.

SInce this file will be used by multiple stakeholders, test team etc. i need to be consistent with them. As they have already developed the tools and scripts, it will require lot of changes for everyone. So willing to avoid that path.

Thanks,

Ashish

I recommend you define these variables in a hand-coded assembly file.  Then you have complete control over the order.  It is not as hard as it first sounds.  Please see this post for the details.  Though you want to use the assembler directives documented in the MSP430 assembly tools manual.

Thanks and regards,

-George