← Back to branch summary

~ubuntu-branches/ubuntu/raring/codeblocks/raring-proposed

« back to all changes in this revision

Viewing changes to src/plugins/scriptedwizard/resources/tricore/templates/TriBoard-TC1766/targetIntResources.ld

  • Committer: Bazaar Package Importer
  • Author(s): Cosme Domínguez Díaz
  • Date: 2010-08-09 04:38:38 UTC
  • mfrom: (1.1.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20100809043838-a59ygguym4eg0jgw
Tags: 10.05-0ubuntu1
https://launchpad.net/bugs/322350
* New upstream release. Closes (LP: #322350)
 - Switch to dpkg-source 3.0 (quilt) format
 - Remove unneeded README.source
 - Add debian/get-source-orig script that removes all
   Windows prebuilt binaries
* Bump Standards-Version to 3.9.1
 - Stop shipping *.la files
* debian/control
 - Add cdbs package as Build-Depend
 - Add libbz2-dev and zlib1g-dev packages as
   Build-Depends (needed by libhelp_plugin.so)
 - Remove dpatch package of Build-Depends
 - Add codeblocks-contrib-debug package
 - Split architecture-independent files of codeblocks
   package in codeblocks-common package
* debian/rules
 - Switch to CDBS rules system
 - Add parallel build support
 - Add a call to debian/get-source-orig script
 - Use lzma compression (saves 23,5 MB of free space)
* debian/patches
 - Refresh 01_codeblocks_plugin_path
 - Add 02_no_Makefiles_in_debian_dir to remove any link
   in codeblocks build system to deleted Makefiles of debian directory
 - Drop 02_ftbfs_gcc44 and 03_ftbfs_glib221 (merged in upstream)
* debian/watch
 - Update to use the new host (berlios.de)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/scriptedwizard/resources/tricore/templates/TriBoard-TC1766/targetIntResources.ld
 
1
/* Default linker script, for normal executables */
 
2
OUTPUT_FORMAT("elf32-tricore")
 
3
OUTPUT_ARCH(tricore)
 
4
ENTRY(_start)
 
5
 
 
6
/* __TC1766__ __TC13__ with Core TC1.3 */
 
7
__TRICORE_DERIVATE_MEMORY_MAP__ = 0x1766;
 
8
/* the internal FLASH description */
 
9
__EXT_CODE_RAM_BEGIN = 0xa0000000;
 
10
__EXT_CODE_RAM_SIZE = 1504K ;
 
11
/* the internal ram description */
 
12
__INT_CODE_RAM_BEGIN = 0xd4000000;
 
13
__INT_CODE_RAM_SIZE = 16K;
 
14
__INT_DATA_RAM_BEGIN = 0xd0000000;
 
15
__INT_DATA_RAM_SIZE = 56K;
 
16
__RAM_END = __INT_DATA_RAM_BEGIN + __INT_DATA_RAM_SIZE;
 
17
/* the pcp memory description */
 
18
__PCP_CODE_RAM_BEGIN = 0xf0060000;
 
19
__PCP_CODE_RAM_SIZE = 12K;
 
20
__PCP_DATA_RAM_BEGIN = 0xf0050000;
 
21
__PCP_DATA_RAM_SIZE = 8K;
 
22
 
 
23
 
 
24
MEMORY
 
25
{
 
26
  ext_cram (rx!p):      org = 0xa0000000, len = 1504K
 
27
  int_cram (rx!p):      org = 0xd4000000, len = 16K
 
28
  int_dram (w!xp):      org = 0xd0002000, len = 48K
 
29
  pcp_data (wp!x):      org = 0xf0050000, len = 8K
 
30
  pcp_text (rxp):       org = 0xf0060000, len = 12K
 
31
}
 
32
/*
 
33
 * Define the sizes of the user and system stacks.
 
34
 */
 
35
__ISTACK_SIZE = DEFINED (__ISTACK_SIZE) ? __ISTACK_SIZE : 64 ;
 
36
__USTACK_SIZE = DEFINED (__USTACK_SIZE) ? __USTACK_SIZE : 1K ;
 
37
/*
 
38
 * The heap is the memory between the top of the user stack and
 
39
 * __RAM_END (as defined above); programs can dynamically allocate
 
40
 * space in this area using malloc() and various other functions.
 
41
 * Below you can define the minimum amount of memory that the heap
 
42
 * should provide.
 
43
 */
 
44
__HEAP_MIN = DEFINED (__HEAP_MIN) ? __HEAP_MIN : 512 ;
 
45
/*
 
46
 * Define the start address and the size of the context save area.
 
47
 */
 
48
__CSA_BEGIN = DEFINED (__CSA_BEGIN) ? __CSA_BEGIN : 0xd0000000 ;
 
49
__CSA_SIZE = DEFINED (__CSA_SIZE) ? __CSA_SIZE : 8k ;
 
50
__CSA_END = __CSA_BEGIN + __CSA_SIZE ;
 
51
 
 
52
SECTIONS
 
53
{
 
54
  /*
 
55
   * The startup code should be placed where the CPU expects it after a reset,
 
56
   * so we try to locate it first, no matter where it appears in the list of
 
57
   * objects and libraries (note: because the wildcard pattern doesn't match
 
58
   * directories, we'll try to find crt0.o in various (sub)directories).
 
59
   */
 
60
  .startup :
 
61
  {
 
62
    KEEP (*(.startup_code))
 
63
    . = ALIGN(8);
 
64
  } > int_cram =0
 
65
  /*
 
66
   * Allocate space for absolute addressable sections; this requires that
 
67
   * "int_dram" starts at a TriCore segment (256M) and points to
 
68
   * some RAM area!  If these conditions are not met by your particular
 
69
   * hardware setup, you should either not use absolute data, or you
 
70
   * must move .zdata*,.zbss*,.bdata*,.bbss* input sections to some appropriate
 
71
   * memory area.
 
72
   */
 
73
 .zbss  (NOLOAD) :
 
74
  {
 
75
    ZBSS_BASE = . ;
 
76
    *(.zbss)
 
77
    *(.zbss.*)
 
78
    *(.gnu.linkonce.zb.*)
 
79
    *(.bbss)
 
80
    *(.bbss.*)
 
81
    . = ALIGN(8);
 
82
    ZBSS_END = . ;
 
83
  } > int_dram
 
84
  .zdata  :
 
85
  {
 
86
    ZDATA_BASE = . ;
 
87
    *(.zrodata)
 
88
    *(.zrodata.*)
 
89
    *(.zdata)
 
90
    *(.zdata.*)
 
91
    *(.gnu.linkonce.z.*)
 
92
    *(.bdata)
 
93
    *(.bdata.*)
 
94
    . = ALIGN(8);
 
95
    ZDATA_END = . ;
 
96
  } > int_dram AT> int_cram
 
97
 
 
98
  /*
 
99
   * Allocate trap and interrupt vector tables.
 
100
   */
 
101
  .traptab  :
 
102
  {
 
103
    *(.traptab)
 
104
    . = ALIGN(8) ;
 
105
  } > int_cram
 
106
 
 
107
  .inttab  :
 
108
  {
 
109
    *(.inttab)
 
110
    . = ALIGN(8) ;
 
111
  } > int_cram
 
112
 
 
113
  .init  :
 
114
  {
 
115
    *(.init)
 
116
    *(.fini)
 
117
    . = ALIGN(8);
 
118
  } > int_cram =0
 
119
 
 
120
  /*
 
121
   * Allocate .text and other read-only sections.
 
122
   */
 
123
  .text  :
 
124
  {
 
125
    *(.text)
 
126
    *(.text.*)
 
127
    *(.pcp_c_ptr_init)
 
128
    *(.pcp_c_ptr_init.*)
 
129
    *(.gnu.linkonce.t.*)
 
130
    /*
 
131
     * .gnu.warning sections are handled specially by elf32.em.
 
132
     */
 
133
    *(.gnu.warning)
 
134
 
 
135
    . = ALIGN(8);
 
136
  } > int_cram =0
 
137
  .rodata   :
 
138
  {
 
139
    *(.rodata)
 
140
    *(.rodata.*)
 
141
    *(.gnu.linkonce.r.*)
 
142
    *(.rodata1)
 
143
    *(.toc)
 
144
    *(.jcr)
 
145
    /*
 
146
     * Create the clear and copy tables that tell the startup code
 
147
     * which memory areas to clear and to copy, respectively.
 
148
     */
 
149
    . = ALIGN(4) ;
 
150
    PROVIDE(__clear_table = .) ;
 
151
    LONG(0 + ADDR(.bss));     LONG(SIZEOF(.bss));
 
152
    LONG(0 + ADDR(.sbss));    LONG(SIZEOF(.sbss));
 
153
    LONG(0 + ADDR(.zbss));    LONG(SIZEOF(.zbss));
 
154
    LONG(-1);                 LONG(-1);
 
155
    PROVIDE(__copy_table = .) ;
 
156
    LONG(LOADADDR(.data));    LONG(0 + ADDR(.data));    LONG(SIZEOF(.data));
 
157
    LONG(LOADADDR(.sdata));   LONG(0 + ADDR(.sdata));   LONG(SIZEOF(.sdata));
 
158
    LONG(LOADADDR(.zdata));   LONG(0 + ADDR(.zdata));   LONG(SIZEOF(.zdata));
 
159
    LONG(LOADADDR(.pcpdata)); LONG(0 + ADDR(.pcpdata)); LONG(SIZEOF(.pcpdata));
 
160
    LONG(LOADADDR(.pcptext)); LONG(0 + ADDR(.pcptext)); LONG(SIZEOF(.pcptext));
 
161
    LONG(-1);                 LONG(-1);                 LONG(-1);
 
162
    . = ALIGN(8);
 
163
  } > int_cram
 
164
  .sdata2  :
 
165
  {
 
166
    *(.sdata.rodata)
 
167
    *(.sdata.rodata.*)
 
168
    . = ALIGN(8);
 
169
  } > int_cram
 
170
  /*
 
171
   * C++ exception handling tables.  NOTE: gcc emits .eh_frame
 
172
   * sections when compiling C sources with debugging enabled (-g).
 
173
   * If you can be sure that your final application consists
 
174
   * exclusively of C objects (i.e., no C++ objects), you may use
 
175
   * the -R option of the "strip" and "objcopy" utilities to remove
 
176
   * the .eh_frame section from the executable.
 
177
   */
 
178
  .eh_frame  :
 
179
  {
 
180
    *(.gcc_except_table)
 
181
    __EH_FRAME_BEGIN__ = . ;
 
182
    KEEP (*(.eh_frame))
 
183
    __EH_FRAME_END__ = . ;
 
184
    . = ALIGN(8);
 
185
  } > int_cram
 
186
  /*
 
187
   * Constructors and destructors.
 
188
   */
 
189
  .ctors :
 
190
  {
 
191
    __CTOR_LIST__ = . ;
 
192
    LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2);
 
193
    *(.ctors)
 
194
    LONG(0) ;
 
195
    __CTOR_END__ = . ;
 
196
    . = ALIGN(8);
 
197
  } > int_cram
 
198
  .dtors :
 
199
  {
 
200
    __DTOR_LIST__ = . ;
 
201
    LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2);
 
202
    *(.dtors)
 
203
    LONG(0) ;
 
204
    __DTOR_END__ = . ;
 
205
    . = ALIGN(8);
 
206
  } > int_cram
 
207
  /*
 
208
   * We're done now with the text part of the executable.  The
 
209
   * following sections are special in that their initial code or
 
210
   * data (if any) must also be stored in said text part of an
 
211
   * executable, but they "live" at completely different addresses
 
212
   * at runtime -- usually in RAM areas.  NOTE: This is not really
 
213
   * necessary if you use a special program loader (e.g., a debugger)
 
214
   * to load a complete executable consisting of code, data, BSS, etc.
 
215
   * into the RAM of some target hardware or a simulator, but it *is*
 
216
   * necessary if you want to burn your application into non-volatile
 
217
   * memories such as EPROM or FLASH.
 
218
   */
 
219
  .pcptext :
 
220
  {
 
221
    PCODE_BASE = . ;
 
222
    *(.pcptext)
 
223
    *(.pcptext.*)
 
224
    . = ALIGN(8) ;
 
225
    PCODE_END = . ;
 
226
  } > pcp_text AT> int_cram
 
227
  .pcpdata :
 
228
  {
 
229
    PRAM_BASE = . ;
 
230
    *(.pcpdata)
 
231
    *(.pcpdata.*)
 
232
    . = ALIGN(8) ;
 
233
    PRAM_END = . ;
 
234
  } > pcp_data AT> int_cram
 
235
  .data :
 
236
  {
 
237
    . = ALIGN(8) ;
 
238
    DATA_BASE = . ;
 
239
    *(.data)
 
240
    *(.data.*)
 
241
    *(.gnu.linkonce.d.*)
 
242
    SORT(CONSTRUCTORS)
 
243
    . = ALIGN(8) ;
 
244
    DATA_END = . ;
 
245
  } > int_dram AT> int_cram
 
246
  .sdata  :
 
247
  {
 
248
    . = ALIGN(8) ;
 
249
    SDATA_BASE = . ;
 
250
    PROVIDE(__sdata_start = .);
 
251
    *(.sdata)
 
252
    *(.sdata.*)
 
253
    *(.gnu.linkonce.s.*)
 
254
    . = ALIGN(8) ;
 
255
  } > int_dram AT> int_cram
 
256
  .sbss  :
 
257
  {
 
258
    PROVIDE(__sbss_start = .);
 
259
    *(.sbss)
 
260
    *(.sbss.*)
 
261
    *(.gnu.linkonce.sb.*)
 
262
    . = ALIGN(8) ;
 
263
  } > int_dram
 
264
  /*
 
265
   * Allocate space for BSS sections.
 
266
   */
 
267
  .bss  (NOLOAD) :
 
268
  {
 
269
    BSS_BASE = . ;
 
270
    *(.bss)
 
271
    *(.bss.*)
 
272
    *(.gnu.linkonce.b.*)
 
273
    *(COMMON)
 
274
    . = ALIGN(8) ;
 
275
    __ISTACK = . + __ISTACK_SIZE ;
 
276
    __USTACK = __ISTACK + __USTACK_SIZE ;
 
277
    __HEAP = __USTACK ;
 
278
    __HEAP_END = __RAM_END ;
 
279
  } > int_dram
 
280
  _end = __HEAP_END ;
 
281
  PROVIDE(end = _end) ;
 
282
  /* Make sure CSA, stack and heap addresses are properly aligned.  */
 
283
  _. = ASSERT ((__CSA_BEGIN & 0x3f) == 0 , "illegal CSA start address") ;
 
284
  _. = ASSERT ((__CSA_SIZE & 0x3f) == 0 , "illegal CSA size") ;
 
285
  _. = ASSERT ((__ISTACK & 7) == 0 , "ISTACK not doubleword aligned") ;
 
286
  _. = ASSERT ((__USTACK & 7) == 0 , "USTACK not doubleword aligned") ;
 
287
  _. = ASSERT ((__HEAP_END & 7) == 0 , "HEAP not doubleword aligned") ;
 
288
 
 
289
  /* Define a default symbol for address 0.  */
 
290
  NULL = DEFINED (NULL) ? NULL : 0 ;
 
291
  /*
 
292
   * DWARF debug sections.
 
293
   * Symbols in the DWARF debugging sections are relative to the
 
294
   * beginning of the section, so we begin them at 0.
 
295
   */
 
296
  /*
 
297
   * DWARF 1
 
298
   */
 
299
  .comment         0 : { *(.comment) }
 
300
  .debug           0 : { *(.debug) }
 
301
  .line            0 : { *(.line) }
 
302
  /*
 
303
   * GNU DWARF 1 extensions
 
304
   */
 
305
  .debug_srcinfo   0 : { *(.debug_srcinfo) }
 
306
  .debug_sfnames   0 : { *(.debug_sfnames) }
 
307
  /*
 
308
   * DWARF 1.1 and DWARF 2
 
309
   */
 
310
  .debug_aranges   0 : { *(.debug_aranges) }
 
311
  .debug_pubnames  0 : { *(.debug_pubnames) }
 
312
  /*
 
313
   * DWARF 2
 
314
   */
 
315
  .debug_info      0 : { *(.debug_info) }
 
316
  .debug_abbrev    0 : { *(.debug_abbrev) }
 
317
  .debug_line      0 : { *(.debug_line) }
 
318
  .debug_frame     0 : { *(.debug_frame) }
 
319
  .debug_str       0 : { *(.debug_str) }
 
320
  .debug_loc       0 : { *(.debug_loc) }
 
321
  .debug_macinfo   0 : { *(.debug_macinfo) }
 
322
  .debug_ranges    0 : { *(.debug_ranges) }
 
323
  /*
 
324
   * SGI/MIPS DWARF 2 extensions
 
325
   */
 
326
  .debug_weaknames 0 : { *(.debug_weaknames) }
 
327
  .debug_funcnames 0 : { *(.debug_funcnames) }
 
328
  .debug_typenames 0 : { *(.debug_typenames) }
 
329
  .debug_varnames  0 : { *(.debug_varnames) }
 
330
  /*
 
331
   * Optional sections that may only appear when relocating.
 
332
   */
 
333
  /*
 
334
   * Optional sections that may appear regardless of relocating.
 
335
   */
 
336
  .version_info    0 : { *(.version_info) }
 
337
  .boffs           0 : { KEEP (*(.boffs)) }
 
338
}