OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [gold/] [script-c.h] - Blame information for rev 438

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
/* script-c.h -- C interface for linker scripts in gold.  */
2
 
3
/* Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor <iant@google.com>.
5
 
6
   This file is part of gold.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21
   MA 02110-1301, USA.  */
22
 
23
/* This file exists so that both the bison parser and script.cc can
24
   include it, so that they can communicate back and forth.  */
25
 
26
#ifndef GOLD_SCRIPT_C_H
27
#define GOLD_SCRIPT_C_H
28
 
29
#ifdef __cplusplus
30
#include <vector>
31
#include <string>
32
#endif
33
 
34
#ifdef __cplusplus
35
 
36
// For the C++ code we declare the various supporting structures in
37
// the gold namespace.  For the C code we declare it at the top level.
38
// The namespace level should not affect the layout of the structure.
39
 
40
namespace gold
41
{
42
#endif
43
 
44
/* A string value for the bison parser.  */
45
 
46
struct Parser_string
47
{
48
  const char* value;
49
  size_t length;
50
};
51
 
52
/* The expression functions deal with pointers to Expression objects.
53
   Since the bison parser generates C code, this is a hack to keep the
54
   C++ code type safe.  This hacks assumes that all pointers look
55
   alike.  */
56
 
57
#ifdef __cplusplus
58
class Expression;
59
typedef Expression* Expression_ptr;
60
#else
61
typedef void* Expression_ptr;
62
#endif
63
 
64
/* A constraint for whether to use a particular output section
65
   definition.  */
66
 
67
enum Section_constraint
68
{
69
  /* No constraint.  */
70
  CONSTRAINT_NONE,
71
  /* Only if all input sections are read-only.  */
72
  CONSTRAINT_ONLY_IF_RO,
73
  /* Only if at least input section is writable.  */
74
  CONSTRAINT_ONLY_IF_RW,
75
  /* Special constraint.  */
76
  CONSTRAINT_SPECIAL
77
};
78
 
79
/* The information we store for an output section header in the bison
80
   parser.  */
81
 
82
struct Parser_output_section_header
83
{
84
  /* The address.  This may be NULL.  */
85
  Expression_ptr address;
86
  /* The load address, from the AT specifier.  This may be NULL.  */
87
  Expression_ptr load_address;
88
  /* The alignment, from the ALIGN specifier.  This may be NULL.  */
89
  Expression_ptr align;
90
  /* The input section alignment, from the SUBALIGN specifier.  This
91
     may be NULL.  */
92
  Expression_ptr subalign;
93
  /* A constraint on this output section.  */
94
  enum Section_constraint constraint;
95
};
96
 
97
/* We keep vectors of strings.  In order to manage this in both C and
98
   C++, we use a pointer to a vector.  This assumes that all pointers
99
   look the same.  */
100
 
101
#ifdef __cplusplus
102
typedef std::vector<std::string> String_list;
103
typedef String_list* String_list_ptr;
104
#else
105
typedef void* String_list_ptr;
106
#endif
107
 
108
/* The information we store for an output section trailer in the bison
109
   parser.  */
110
 
111
struct Parser_output_section_trailer
112
{
113
  /* The fill value.  This may be NULL.  */
114
  Expression_ptr fill;
115
  /* The program segments this section should go into.  This may be
116
     NULL.  */
117
  String_list_ptr phdrs;
118
};
119
 
120
/* The different sorts we can find in a linker script.  */
121
 
122
enum Sort_wildcard
123
{
124
  SORT_WILDCARD_NONE,
125
  SORT_WILDCARD_BY_NAME,
126
  SORT_WILDCARD_BY_ALIGNMENT,
127
  SORT_WILDCARD_BY_NAME_BY_ALIGNMENT,
128
  SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
129
};
130
 
131
/* The information we build for a single wildcard specification.  */
132
 
133
struct Wildcard_section
134
{
135
  /* The wildcard spec itself.  */
136
  struct Parser_string name;
137
  /* How the entries should be sorted.  */
138
  enum Sort_wildcard sort;
139
};
140
 
141
/* A vector of Wildcard_section entries.  */
142
 
143
#ifdef __cplusplus
144
typedef std::vector<Wildcard_section> String_sort_list;
145
typedef String_sort_list* String_sort_list_ptr;
146
#else
147
typedef void* String_sort_list_ptr;
148
#endif
149
 
150
/* A list of wildcard specifications, which may include EXCLUDE_FILE
151
   clauses.  */
152
 
153
struct Wildcard_sections
154
{
155
  /* Wildcard specs.  */
156
  String_sort_list_ptr sections;
157
  /* Exclusions.  */
158
  String_list_ptr exclude;
159
};
160
 
161
/* A complete input section specification.  */
162
 
163
struct Input_section_spec
164
{
165
  /* The file name.  */
166
  struct Wildcard_section file;
167
  /* The list of sections.  */
168
  struct Wildcard_sections input_sections;
169
};
170
 
171
/* Information for a program header.  */
172
 
173
struct Phdr_info
174
{
175
  /* A boolean value: whether to include the file header.  */
176
  int includes_filehdr;
177
  /* A boolean value: whether to include the program headers.  */
178
  int includes_phdrs;
179
  /* A boolean value: whether the flags field is valid.  */
180
  int is_flags_valid;
181
  /* The value to use for the flags.  */
182
  unsigned int flags;
183
  /* The load address.  */
184
  Expression_ptr load_address;
185
};
186
 
187
struct Version_dependency_list;
188
struct Version_expression_list;
189
struct Version_tree;
190
 
191
#ifdef __cplusplus
192
extern "C" {
193
#endif
194
 
195
/* The bison parser definitions.  */
196
 
197
#include "yyscript.h"
198
 
199
/* The bison parser function.  */
200
 
201
extern int
202
yyparse(void* closure);
203
 
204
/* Called by the bison parser skeleton to return the next token.  */
205
 
206
extern int
207
yylex(YYSTYPE*, void* closure);
208
 
209
/* Called by the bison parser skeleton to report an error.  */
210
 
211
extern void
212
yyerror(void* closure, const char*);
213
 
214
/* Called by the bison parser to add an external symbol (a symbol in
215
   an EXTERN declaration) to the link.  */
216
 
217
extern void
218
script_add_extern(void* closure, const char*, size_t);
219
 
220
/* Called by the bison parser to add a file to the link.  */
221
 
222
extern void
223
script_add_file(void* closure, const char*, size_t);
224
 
225
/* Called by the bison parser to start and stop a group.  */
226
 
227
extern void
228
script_start_group(void* closure);
229
extern void
230
script_end_group(void* closure);
231
 
232
/* Called by the bison parser to start and end an AS_NEEDED list.  */
233
 
234
extern void
235
script_start_as_needed(void* closure);
236
extern void
237
script_end_as_needed(void* closure);
238
 
239
/* Called by the bison parser to set the entry symbol.  */
240
 
241
extern void
242
script_set_entry(void* closure, const char*, size_t);
243
 
244
/* Called by the bison parser to set whether to define common symbols.  */
245
 
246
extern void
247
script_set_common_allocation(void* closure, int);
248
 
249
/* Called by the bison parser to parse an OPTION.  */
250
 
251
extern void
252
script_parse_option(void* closure, const char*, size_t);
253
 
254
/* Called by the bison parser to handle OUTPUT_FORMAT.  This return 0
255
   if the parse should be aborted.  */
256
 
257
extern int
258
script_check_output_format(void* closure, const char*, size_t,
259
                           const char*, size_t, const char*, size_t);
260
 
261
/* Called by the bison parser to handle TARGET.  */
262
extern void
263
script_set_target(void* closure, const char*, size_t);
264
 
265
/* Called by the bison parser to handle SEARCH_DIR.  */
266
 
267
extern void
268
script_add_search_dir(void* closure, const char*, size_t);
269
 
270
/* Called by the bison parser to push the lexer into expression
271
   mode.  */
272
 
273
extern void
274
script_push_lex_into_expression_mode(void* closure);
275
 
276
/* Called by the bison parser to push the lexer into version
277
   mode.  */
278
 
279
extern void
280
script_push_lex_into_version_mode(void* closure);
281
 
282
/* Called by the bison parser to pop the lexer mode.  */
283
 
284
extern void
285
script_pop_lex_mode(void* closure);
286
 
287
/* Called by the bison parser to set a symbol to a value.  PROVIDE is
288
   non-zero if the symbol should be provided--only defined if there is
289
   an undefined reference.  HIDDEN is non-zero if the symbol should be
290
   hidden.  */
291
 
292
extern void
293
script_set_symbol(void* closure, const char*, size_t, Expression_ptr,
294
                  int provide, int hidden);
295
 
296
/* Called by the bison parser to add an assertion.  */
297
 
298
extern void
299
script_add_assertion(void* closure, Expression_ptr, const char* message,
300
                     size_t messagelen);
301
 
302
/* Called by the bison parser to start a SECTIONS clause.  */
303
 
304
extern void
305
script_start_sections(void* closure);
306
 
307
/* Called by the bison parser to finish a SECTIONS clause.  */
308
 
309
extern void
310
script_finish_sections(void* closure);
311
 
312
/* Called by the bison parser to start handling input section
313
   specifications for an output section.  */
314
 
315
extern void
316
script_start_output_section(void* closure, const char* name, size_t namelen,
317
                            const struct Parser_output_section_header*);
318
 
319
/* Called by the bison parser when done handling input section
320
   specifications for an output section.  */
321
 
322
extern void
323
script_finish_output_section(void* closure,
324
                             const struct Parser_output_section_trailer*);
325
 
326
/* Called by the bison parser to handle a data statement (LONG, BYTE,
327
   etc.) in an output section.  */
328
 
329
extern void
330
script_add_data(void* closure, int data_token, Expression_ptr val);
331
 
332
/* Called by the bison parser to set the fill value in an output
333
   section.  */
334
 
335
extern void
336
script_add_fill(void* closure, Expression_ptr val);
337
 
338
/* Called by the bison parser to add an input section specification to
339
   an output section.  The KEEP parameter is non-zero if this is
340
   within a KEEP clause, meaning that the garbage collector should not
341
   discard it.  */
342
 
343
extern void
344
script_add_input_section(void* closure, const struct Input_section_spec*,
345
                         int keep);
346
 
347
/* Create a new list of string and sort entries.  */
348
 
349
extern String_sort_list_ptr
350
script_new_string_sort_list(const struct Wildcard_section*);
351
 
352
/* Add an entry to a list of string and sort entries.  */
353
 
354
extern String_sort_list_ptr
355
script_string_sort_list_add(String_sort_list_ptr,
356
                            const struct Wildcard_section*);
357
 
358
/* Create a new list of strings.  */
359
 
360
extern String_list_ptr
361
script_new_string_list(const char*, size_t);
362
 
363
/* Add an element to a list of strings.  */
364
 
365
extern String_list_ptr
366
script_string_list_push_back(String_list_ptr, const char*, size_t);
367
 
368
/* Concatenate two string lists.  */
369
 
370
extern String_list_ptr
371
script_string_list_append(String_list_ptr, String_list_ptr);
372
 
373
/* Define a new program header.  */
374
 
375
extern void
376
script_add_phdr(void* closure, const char* name, size_t namelen,
377
                unsigned int type, const struct Phdr_info*);
378
 
379
/* Convert a program header string to a type.  */
380
 
381
extern unsigned int
382
script_phdr_string_to_type(void* closure, const char*, size_t);
383
 
384
/* Handle DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
385
 
386
extern void
387
script_data_segment_align(void* closure);
388
 
389
extern void
390
script_data_segment_relro_end(void* closure);
391
 
392
/* Called by the bison parser for expressions.  */
393
 
394
extern Expression_ptr
395
script_exp_unary_minus(Expression_ptr);
396
extern Expression_ptr
397
script_exp_unary_logical_not(Expression_ptr);
398
extern Expression_ptr
399
script_exp_unary_bitwise_not(Expression_ptr);
400
extern Expression_ptr
401
script_exp_binary_mult(Expression_ptr, Expression_ptr);
402
extern Expression_ptr
403
script_exp_binary_div(Expression_ptr, Expression_ptr);
404
extern Expression_ptr
405
script_exp_binary_mod(Expression_ptr, Expression_ptr);
406
extern Expression_ptr
407
script_exp_binary_add(Expression_ptr, Expression_ptr);
408
extern Expression_ptr
409
script_exp_binary_sub(Expression_ptr, Expression_ptr);
410
extern Expression_ptr
411
script_exp_binary_lshift(Expression_ptr, Expression_ptr);
412
extern Expression_ptr
413
script_exp_binary_rshift(Expression_ptr, Expression_ptr);
414
extern Expression_ptr
415
script_exp_binary_eq(Expression_ptr, Expression_ptr);
416
extern Expression_ptr
417
script_exp_binary_ne(Expression_ptr, Expression_ptr);
418
extern Expression_ptr
419
script_exp_binary_le(Expression_ptr, Expression_ptr);
420
extern Expression_ptr
421
script_exp_binary_ge(Expression_ptr, Expression_ptr);
422
extern Expression_ptr
423
script_exp_binary_lt(Expression_ptr, Expression_ptr);
424
extern Expression_ptr
425
script_exp_binary_gt(Expression_ptr, Expression_ptr);
426
extern Expression_ptr
427
script_exp_binary_bitwise_and(Expression_ptr, Expression_ptr);
428
extern Expression_ptr
429
script_exp_binary_bitwise_xor(Expression_ptr, Expression_ptr);
430
extern Expression_ptr
431
script_exp_binary_bitwise_or(Expression_ptr, Expression_ptr);
432
extern Expression_ptr
433
script_exp_binary_logical_and(Expression_ptr, Expression_ptr);
434
extern Expression_ptr
435
script_exp_binary_logical_or(Expression_ptr, Expression_ptr);
436
extern Expression_ptr
437
script_exp_trinary_cond(Expression_ptr, Expression_ptr, Expression_ptr);
438
extern Expression_ptr
439
script_exp_integer(uint64_t);
440
extern Expression_ptr
441
script_exp_string(const char*, size_t);
442
extern Expression_ptr
443
script_exp_function_max(Expression_ptr, Expression_ptr);
444
extern Expression_ptr
445
script_exp_function_min(Expression_ptr, Expression_ptr);
446
extern Expression_ptr
447
script_exp_function_defined(const char*, size_t);
448
extern Expression_ptr
449
script_exp_function_sizeof_headers(void);
450
extern Expression_ptr
451
script_exp_function_alignof(const char*, size_t);
452
extern Expression_ptr
453
script_exp_function_sizeof(const char*, size_t);
454
extern Expression_ptr
455
script_exp_function_addr(const char*, size_t);
456
extern Expression_ptr
457
script_exp_function_loadaddr(const char*, size_t);
458
extern Expression_ptr
459
script_exp_function_origin(const char*, size_t);
460
extern Expression_ptr
461
script_exp_function_length(const char*, size_t);
462
extern Expression_ptr
463
script_exp_function_constant(const char*, size_t);
464
extern Expression_ptr
465
script_exp_function_absolute(Expression_ptr);
466
extern Expression_ptr
467
script_exp_function_align(Expression_ptr, Expression_ptr);
468
extern Expression_ptr
469
script_exp_function_data_segment_align(Expression_ptr, Expression_ptr);
470
extern Expression_ptr
471
script_exp_function_data_segment_relro_end(Expression_ptr, Expression_ptr);
472
extern Expression_ptr
473
script_exp_function_data_segment_end(Expression_ptr);
474
extern Expression_ptr
475
script_exp_function_segment_start(const char*, size_t, Expression_ptr);
476
extern Expression_ptr
477
script_exp_function_assert(Expression_ptr, const char*, size_t);
478
 
479
extern void
480
script_register_vers_node(void* closure,
481
                          const char* tag,
482
                          int taglen,
483
                          struct Version_tree *,
484
                          struct Version_dependency_list *);
485
 
486
extern struct Version_dependency_list *
487
script_add_vers_depend(void* closure,
488
                       struct Version_dependency_list *existing_dependencies,
489
                       const char *depend_to_add, int deplen);
490
 
491
extern struct Version_expression_list *
492
script_new_vers_pattern(void* closure,
493
                        struct Version_expression_list *,
494
                        const char *, int, int);
495
 
496
extern struct Version_expression_list *
497
script_merge_expressions(struct Version_expression_list *a,
498
                         struct Version_expression_list *b);
499
 
500
extern struct Version_tree *
501
script_new_vers_node(void* closure,
502
                     struct Version_expression_list *global,
503
                     struct Version_expression_list *local);
504
 
505
extern void
506
version_script_push_lang(void* closure, const char* lang, int langlen);
507
 
508
extern void
509
version_script_pop_lang(void* closure);
510
 
511
#ifdef __cplusplus
512
} // End extern "C"
513
#endif
514
 
515
#ifdef __cplusplus
516
} // End namespace gold.
517
#endif
518
 
519
#endif /* !defined(GOLD_SCRIPT_C_H) */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.