IAR Workbench.xcl Konfiguration für C Programm

[Peter Pippinger (Gast)]

Hallo NG,

könnte mir bitte jemand bei der Konfiguration meiner xcl-Datei helfen?`

Das Problem: ich möchte gerne eine Binary erzeugen, die ich nach 
0x202000 laden kann und dort ausführe (go 0x202000). Mit der xcl, so wie 
ich sie habe wird die Binary leider 2MB groß. Wobei der Code tatsächlich 
in der Datei dann ab 0x202000 anfängt. Nur laufen tut er trotzdem nicht.

Wäre echt super, wenn mir jemand einen Tip geben könnte.

MfG
Peter

---

// Generated : 10/01/07 07:05:46
//**********************************************************************
// XLINK template command file to be used with the ICCARM C/C++ Compiler
//
// Usage:  xlink  -f lnkarm  <your_object_file(s)>
//                -s <program start label>  <C/C++ runtime library>
//
// $Revision: 1.3 $
//
//**********************************************************************

//********************************************************************** 
***
// In this file it is assumed that the system has the following
// memory layout:
//
//   Exception vectors [0x000000--0x00001F]  RAM or ROM
//   ROMSTART--ROMEND  [0x008000--0x0FFFFF]  ROM (or other non-volatile 
memory)
//   RAMSTART--RAMEND  [0x100000--0x7FFFFF]  RAM (or other read/write 
memory)
//
// -------------
// Code segments - may be placed anywhere in memory.
// -------------
//
//   INTVEC     -- Exception vector table.
//   SWITAB     -- Software interrupt vector table.
//   ICODE      -- Startup (cstartup) and exception code.
//   DIFUNCT    -- Dynamic initialization vectors used by C++.
//   CODE       -- Compiler generated code.
//   CODE_I     -- Compiler generated code declared __ramfunc (executes 
in RAM)
//   CODE_ID    -- Initializer for CODE_I (ROM).
//
// -------------
// Data segments - may be placed anywhere in memory.
// -------------
//
//   CSTACK     -- The stack used by C/C++ programs (system and user 
mode).
//   IRQ_STACK  -- The stack used by IRQ service routines.
//   SVC_STACK  -- The stack used in supervisor mode
//                 (Define other exception stacks as needed for
//                 FIQ, ABT, UND).
//   HEAP       -- The heap used by malloc and free in C and new and
//                 delete in C++.
//   INITTAB    -- Table containing addresses and sizes of segments that
//                 need to be initialized at startup (by cstartup).
//   CHECKSUM   -- The linker places checksum byte(s) in this segment,
//                 when the -J linker command line option is used.
//   DATA_y     -- Data objects.
//
// Where _y can be one of:
//
//   _AN        -- Holds uninitialized located objects, i.e. objects 
with
//                 an absolute location given by the @ operator or the
//                 #pragma location directive. Since these segments
//                 contain objects which already have a fixed address,
//                 they should not be mentioned in this linker command
//                 file.
//   _C         -- Constants (ROM).
//   _I         -- Initialized data (RAM).
//   _ID        -- The original content of _I (copied to _I by cstartup) 
(ROM).
//   _N         -- Uninitialized data (RAM).
//   _Z         -- Zero initialized data (RAM).
//
// Note:  Be sure to use end values for the defined address ranges.
//        Otherwise, the linker may allocate space outside the
//        intended memory range.
//********************************************************************** 
***

//************************************************
// Inform the linker about the CPU family used.
//************************************************

-carm

//********************************************************************** 
***
// Segment placement - General information
//
// All numbers in the segment placement command lines below are 
interpreted
// as hexadecimal unless they are immediately preceded by a '.', which
// denotes decimal notation.
//
// When specifying the segment placement using the -P instead of the -Z
// option, the linker is free to split each segment into its segment 
parts
// and randomly place these parts within the given ranges in order to
// achieve a more efficient memory usage. One disadvantage, however, is
// that it is not possible to find the start or end address (using
// the assembler operators .sfb./.sfe.) of a segment which has been 
split
// and reformed.
//
// When generating an output file which is to be used for programming
// external ROM/Flash devices, the -M linker option is very useful
// (see xlink.pdf for details).
//********************************************************************** 
***


//********************************************************************** 
***
// Read-only segments mapped to ROM.
//********************************************************************** 
***

//************************************************
// Address range for reset and exception
// vectors (INTVEC).
// The vector area is 32 bytes,
// an additional 32 bytes is allocated for the
// constant table used by ldr PC in cstartup.s79.
//************************************************

-Z(CODE)INTVEC=0-3F

//************************************************
// Startup code and exception routines (ICODE).
//************************************************

-Z(CODE)ICODE,DIFUNCT=202000-209FFF
-Z(CODE)SWITAB=202000-209FFF

//************************************************
// Code segments may be placed anywhere.
//************************************************

-Z(CODE)CODE=202000-209FFF

//************************************************
// Original ROM location for __ramfunc code copied
// to and executed from RAM.
//************************************************

-Z(CONST)CODE_ID=202000-209FFF

//************************************************
// Various constants and initializers.
//************************************************

-Z(CONST)INITTAB,DATA_ID,DATA_C=202000-209FFF
-Z(CONST)CHECKSUM=202000-209FFF

//********************************************************************** 
***
// Read/write segments mapped to RAM.
//********************************************************************** 
***

//************************************************
// Data segments.
//************************************************

-Z(DATA)DATA_I,DATA_Z,DATA_N=20A000-20FFFF

//************************************************
// __ramfunc code copied to and executed from RAM.
//************************************************

-Z(DATA)CODE_I=20A000-20FFFF

//************************************************
// ICCARM produces code for __ramfunc functions in
// CODE_I segments. The -Q XLINK command line
// option redirects XLINK to emit the code in the
// CODE_ID segment instead, but to keep symbol and
// debug information associated with the CODE_I
// segment, where the code will execute.
//************************************************

-QCODE_I=CODE_ID

//********************************************************************** 
***
// Stack and heap segments.
//********************************************************************** 
***

-Z(DATA)CSTACK+2000=20A000-20FFFF
-Z(DATA)IRQ_STACK+100=20A000-20FFFF
-Z(DATA)HEAP+8000=20A000-20FFFF

//**********************************************************************
// Output user defined segments
//**********************************************************************



//********************************************************************** 
***
// ELF/DWARF support.
//
// Uncomment the line "-Felf" below to generate ELF/DWARF output.
// Available format specifiers are:
//
//   "-yn": Suppress DWARF debug output
//   "-yp": Multiple ELF program sections
//   "-yas": Format suitable for debuggers from ARM Ltd (also sets -p 
flag)
//
// "-Felf" and the format specifiers can also be supplied directly as
// command line options, or selected from the Xlink Output tab in the
// IAR Embedded Workbench.
//********************************************************************** 
***

// -Felf

[Peter Pippinger (Gast)]

...kann mir den keiner helfen?

Woher kommt der Init-Code in IAR? Ich habe in den Projektfiles eines 
neuangegten C-Programms nichts gefunden.

Könnte nicht jemand Licht ins Dunkle bringen, welche Segmente 
erforderlich sind, und wie ich diese definieren muss, damit mein 
Programm fürs RAM kompiliert wird, ohne dass ich was in den 
Flashspeicher laden muss?

Wo ist "__program_start" definiert?

Nur eine blinkende LED, vielleicht?

Vielen Dank!
Peter

[Peter Pippinger (Gast)]

Ok, ich habe es jetzt geschafft, dass die LEDs blinken. Allerdings hat 
meine erzeugte Binary ein großes Problem:

__program_start ist bei mit bei 0x000000. Und der Code kommt erst bei 
0x208000. Wenn ich den Code "ausschneide" und an 0x208000 lade und dann 
bei c_init (0x208048) ausführe, blinken die LEDs munter vor sich hin.

Wo wird denn der __program_start festgelegt?

[Peter Pippinger (Gast)]

So, jetzt liegt schon mal alles da, wo ich es gerne hätte. Kann mir 
vielleicht jemand sagen, ob die Konfiguration so OK ist? Gerade mit dem 
Stack / Heap bin ich mir nicht sicher.

Noch eine Frage: wenn ich jetzt ein C-Programm schreibe, und es läuft 
dann schön im Speicher mit dieser Konfiguration - ist es dann schwierig, 
das alles fürs Flash zu konfigurieren?

Gruß
Peter

-carm
-Z(CODE)INTVEC=202000
-Z(CODE)ICODE,DIFUNCT=202000-20FFFF
-Z(CODE)SWITAB=202000-20FFFF
-Z(CODE)CODE=202000-20FFFF
-Z(CONST)CODE_ID=202000-20FFFF
-Z(CONST)INITTAB,DATA_ID,DATA_C=202000-20FFFF
-Z(CONST)CHECKSUM=202000-20FFFF
-Z(DATA)DATA_I,DATA_Z,DATA_N=202040-20FFFF
-Z(DATA)CODE_I=202040-20FFFF
-QCODE_I=CODE_ID
-Z(DATA)CSTACK+2000=202040-20FFFF
-Z(DATA)IRQ_STACK+100=202040-20FFFF
-Z(DATA)HEAP+8000=202040-20FFFF