]> git.kernelconcepts.de Git - karo-tx-uboot.git/blob - tools/elftosb/bdfiles/complex.bd
merged tx6dl-devel into denx master branch
[karo-tx-uboot.git] / tools / elftosb / bdfiles / complex.bd
1 /*
2  * Copyright (c) 2006 SigmaTel, Inc.
3  *
4  * elftosb boot description file that creates some complicated situations for
5  * the loader to handle. of course this is also a good test for elftosb itself.
6  */
7
8 /* testing C style comments */
9 // testing C++ style comments
10 # testing shell style comments
11
12 constants {
13         kProgressReportsImageFlag = 0x1;
14         
15         kPlayerDriveTag = 0xa0;
16         kHostlinkDriveTag = 0xb0;
17 }
18
19 options {
20         productVersion = "5.0.999";
21         componentVersion = "5.0.999";
22     
23     flags = kProgressReportsImageFlag;  // turn on progress reports
24         
25         secinfoClear = "ignore";
26 }
27
28 constants {
29     arg = 0xfeedf00d;
30     
31     callArg1 = 2;
32     callArg2 = 3;
33     
34     halfword = 10.h;
35     
36 //    flag = 1;
37         
38         testboolexpr = 1 > 0;
39         
40         mainSizeIsDefined = defined(mainSize);
41 }
42
43 sources {
44     elffile = extern(0) (toolset="ghs");
45     binfile1 = extern(1);
46     binfile2 = extern(2);
47     foofile = "file.dat";
48     anotherfile = "another.dat";
49         srecfile = "test_files/sd_player_gcc.srec";
50 }
51
52 options {
53         driveTag = kPlayerDriveTag;
54         
55         some_option = defined(testboolexpr);
56 }
57
58 constants {
59         printMessageAddr = elffile:printMessage;
60         printMessageSize = sizeof(elffile:printMessage);
61         
62         // create const with address of main() in elffile
63         mainAddr = elffile:main;
64         
65         mainSize = sizeof(elffile:main);
66         
67         halfwordSize = sizeof(halfword);
68         
69         elf_startAddr = elffile:_start;
70         
71 //      poop = exists(nonexistantfile);
72
73         binfile1size = sizeof(binfile1);
74 }
75
76 /*
77  * test s-record support
78  */
79 section (0)
80 {
81         load dcd {{ 00 11 22 33 }} > 0;
82         load srecfile;
83         call srecfile;
84 }
85
86 section(1; coalesce=true) {
87         
88         info "welcome to section 1!";
89         info "elffile path = $(elffile)";
90         info "mainSizeIsDefined = $(d:mainSizeIsDefined)";
91         info "printMessage = $(x:printMessageAddr)";
92         
93         info "size of binfile1 = $(binfile1size)";
94         
95         // can use symbol refs inside bool expressions in an if stmt
96         if elffile:main == 0
97         {
98                 warning "$(elffile) does not seem to have a main() function";
99         }
100         else
101         {
102                 info "address of main() of $(elffile) is $(x:mainAddr)";
103         }
104         
105         if defined(flag) && flag != 0
106         {
107                 load 0x1234.h > 0..10K;
108         }
109         else
110         {
111                 // print message using both decimal and hex formatting
112                 warning "loading only halfword = $(d:halfword) [$(x:halfword)]!";
113                 load halfword > 0..1K;
114         }
115         
116         info "size of main() in $(elffile) is $(mainSize)";
117         info "printMessage() size is $(printMessageSize)";
118         info "size of halfword = $(halfwordSize)";
119         
120         load 0xff.b > 32K..32K + sizeof(elffile:printMessage);
121         
122         from elffile {
123         load {{ 00 01 02 03 04 }} > 1K;
124                 
125                 // load all sections except .mytext
126                 load ~$.mytext;
127                 
128                 // figure out where to go from here
129                 call :maybeSwitchSections(callArg1);
130                 
131                 // print msg and loop
132                 load "hi from section 1" > :szMsg;
133                 call :printMessage(0);
134                 
135                 jump :hello(0);
136         }
137         
138         // erase a function in memory
139         load 0.w > (elffile:endOfLine)..(elffile:endOfLine + sizeof(elffile:endOfLine));
140 }
141
142 section(2; alignment=64K) {
143         // cause an error if testConst has not been set
144         if !defined(testConst)
145         {
146                 error "testConst is not defined!";
147         }
148         
149     from elffile {
150         load "in section 2" > :szMsg;
151         call :printMessage();
152     }
153     
154     // load the contents of binfile1 into the upper 128KB of ocram
155     load binfile1 > 128K..192K;
156     
157     from elffile {
158         load "loaded binfile1" > :szMsg;
159         call :printMessage(0);
160         
161         call :maybeSwitchSections(callArg2);
162         
163         jump :endOfLine(2);
164     }
165 }
166
167 // non-bootable section between two bootable sections
168 section(0xbeef; alignment=32K, cleartext=false) <= binfile2;
169
170 section(3; alignment=8K) {
171     // load our special section
172     load $.mytext from elffile;
173     call elffile:countToN(5);
174     
175         if (exists(foofile) && exists(anotherfile))
176         {
177                 // a trainload of beef!
178                 load 0xbeef.h > 128K..192K;
179         }
180         else if (exists(elffile) && callArg1 == 2)
181         {
182                 // aaaaaaah!
183                 load 0x12345678.w > 128K..192K;
184         }
185         else
186         {
187                 from elffile
188                 {
189                         // aaaaaaah!
190                         load 0xaaaa.h > 128K..192K;
191                         load $.text;
192                         load 0xbbbb.h > 128K..192K;
193                 }
194         }
195     
196     from elffile {
197         load "hold on now, in section 3" > :szMsg;
198         call :printMessage(0);
199         
200         jump :endOfLine(3);
201     }
202     
203     from elffile {
204         load elffile;
205         load elffile > .;
206         load elffile[ $.bss ] > elffile:countToN;
207 //              load [ $.bss ] > (elffile:countToN)..(elffile:countToN + sizeof(elffile:countToN));
208         call elffile;
209         call elffile(1);
210     }
211     
212     info "address of _start in $(elffile) is $(elf_startAddr)";
213 }
214
215 section ('four'; alignment=8K, sectionFlags=0x1000) <= binfile1;
216
217 section ('five'; alignment=8K, cleartext=1, sectionFlags=0x1000) <= binfile1;
218
219 /*
220  * create a data section out of some sections of an elf file
221  */
222 section (1234) <= ~$.bss, ~$.data from elffile;
223 section (4321) <= elffile [ $* ];
224 section (1111) <= elffile;
225
226 /* test data sections from various data sources */
227 section (0xaa) <= 0x12345678.w;
228 section (0xbb) <= "hi there! this is a data section.";
229 section (0xcc) <= {{ aa55aa55aa55aa55aa55aa55aa55aa55 }};
230
231
232 section (2345)
233 {
234         load elffile[ $*.text*, ~$.sdram* ];
235 }
236
237
238 section ('six_')
239 {
240         // load a blob at address 0x1000
241         load {{
242                 00 0a 07 b0 bb ff 03 78
243                 00 0a 07 b0 bb ff 03 78
244                 00 0a 07 b0 bb ff 03 78
245                 00 0a 07 b0 bb ff 03 78
246                 00 0a 07 b0 bb ff 03 78
247         }} > 0x1000;
248 }
249
250 section ('bad_')
251 {
252         // uncomment to test better error reporting for files that failed to open
253 //      load foofile;
254 }
255
256 //section (2345) <= {{ 00 11 22 33 44 55 }};
257
258
259
260