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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [ld/] [mri.c] - Blame information for rev 818

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
/* mri.c -- handle MRI style linker scripts
2
   Copyright 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
3
   2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4
   Contributed by Steve Chamberlain <sac@cygnus.com>.
5
 
6
   This file is part of the GNU Binutils.
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
 
24
/* This bit does the tree decoration when MRI style link scripts
25
   are parsed.  */
26
 
27
#include "sysdep.h"
28
#include "bfd.h"
29
#include "ld.h"
30
#include "ldexp.h"
31
#include "ldlang.h"
32
#include "ldmisc.h"
33
#include "mri.h"
34
#include <ldgram.h>
35
#include "libiberty.h"
36
 
37
struct section_name_struct {
38
  struct section_name_struct *next;
39
  const char *name;
40
  const char *alias;
41
  etree_type *vma;
42
  etree_type *align;
43
  etree_type *subalign;
44
  int ok_to_load;
45
};
46
 
47
static unsigned int symbol_truncate = 10000;
48
static struct section_name_struct *order;
49
static struct section_name_struct *only_load;
50
static struct section_name_struct *address;
51
static struct section_name_struct *alias;
52
 
53
static struct section_name_struct *alignment;
54
static struct section_name_struct *subalignment;
55
 
56
static struct section_name_struct **
57
lookup (const char *name, struct section_name_struct **list)
58
{
59
  struct section_name_struct **ptr = list;
60
 
61
  while (*ptr)
62
    {
63
      if (strcmp (name, (*ptr)->name) == 0)
64
        /* If this is a match, delete it, we only keep the last instance
65
           of any name.  */
66
        *ptr = (*ptr)->next;
67
      else
68
        ptr = &((*ptr)->next);
69
    }
70
 
71
  *ptr = (struct section_name_struct *)
72
      xmalloc (sizeof (struct section_name_struct));
73
  return ptr;
74
}
75
 
76
static void
77
mri_add_to_list (struct section_name_struct **list,
78
                 const char *name,
79
                 etree_type *vma,
80
                 const char *zalias,
81
                 etree_type *align,
82
                 etree_type *subalign)
83
{
84
  struct section_name_struct **ptr = lookup (name, list);
85
 
86
  (*ptr)->name = name;
87
  (*ptr)->vma = vma;
88
  (*ptr)->next = NULL;
89
  (*ptr)->ok_to_load = 0;
90
  (*ptr)->alias = zalias;
91
  (*ptr)->align = align;
92
  (*ptr)->subalign = subalign;
93
}
94
 
95
void
96
mri_output_section (const char *name, etree_type *vma)
97
{
98
  mri_add_to_list (&address, name, vma, 0, 0, 0);
99
}
100
 
101
/* If any ABSOLUTE <name> are in the script, only load those files
102
   marked thus.  */
103
 
104
void
105
mri_only_load (const char *name)
106
{
107
  mri_add_to_list (&only_load, name, 0, 0, 0, 0);
108
}
109
 
110
void
111
mri_base (etree_type *exp)
112
{
113
  base = exp;
114
}
115
 
116
static int done_tree = 0;
117
 
118
void
119
mri_draw_tree (void)
120
{
121
  if (done_tree)
122
    return;
123
 
124
  /* Now build the statements for the ldlang machine.  */
125
 
126
  /* Attach the addresses of any which have addresses,
127
     and add the ones not mentioned.  */
128
  if (address != NULL)
129
    {
130
      struct section_name_struct *alist;
131
      struct section_name_struct *olist;
132
 
133
      if (order == NULL)
134
        order = address;
135
 
136
      for (alist = address;
137
           alist != NULL;
138
           alist = alist->next)
139
        {
140
          int done = 0;
141
 
142
          for (olist = order; done == 0 && olist != NULL; olist = olist->next)
143
            {
144
              if (strcmp (alist->name, olist->name) == 0)
145
                {
146
                  olist->vma = alist->vma;
147
                  done = 1;
148
                }
149
            }
150
 
151
          if (!done)
152
            {
153
              /* Add this onto end of order list.  */
154
              mri_add_to_list (&order, alist->name, alist->vma, 0, 0, 0);
155
            }
156
        }
157
    }
158
 
159
  /* If we're only supposed to load a subset of them in, then prune
160
     the list.  */
161
  if (only_load != NULL)
162
    {
163
      struct section_name_struct *ptr1;
164
      struct section_name_struct *ptr2;
165
 
166
      if (order == NULL)
167
        order = only_load;
168
 
169
      /* See if this name is in the list, if it is then we can load it.  */
170
      for (ptr1 = only_load; ptr1; ptr1 = ptr1->next)
171
        for (ptr2 = order; ptr2; ptr2 = ptr2->next)
172
          if (strcmp (ptr2->name, ptr1->name) == 0)
173
            ptr2->ok_to_load = 1;
174
    }
175
  else
176
    {
177
      /* No only load list, so everything is ok to load.  */
178
      struct section_name_struct *ptr;
179
 
180
      for (ptr = order; ptr; ptr = ptr->next)
181
        ptr->ok_to_load = 1;
182
    }
183
 
184
  /* Create the order of sections to load.  */
185
  if (order != NULL)
186
    {
187
      /* Been told to output the sections in a certain order.  */
188
      struct section_name_struct *p = order;
189
 
190
      while (p)
191
        {
192
          struct section_name_struct *aptr;
193
          etree_type *align = 0;
194
          etree_type *subalign = 0;
195
          struct wildcard_list *tmp;
196
 
197
          /* See if an alignment has been specified.  */
198
          for (aptr = alignment; aptr; aptr = aptr->next)
199
            if (strcmp (aptr->name, p->name) == 0)
200
              align = aptr->align;
201
 
202
          for (aptr = subalignment; aptr; aptr = aptr->next)
203
            if (strcmp (aptr->name, p->name) == 0)
204
              subalign = aptr->subalign;
205
 
206
          if (base == 0)
207
            base = p->vma ? p->vma : exp_nameop (NAME, ".");
208
 
209
          lang_enter_output_section_statement (p->name, base,
210
                                               p->ok_to_load ? normal_section : noload_section,
211
                                               align, subalign, NULL, 0);
212
          base = 0;
213
          tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
214
          tmp->next = NULL;
215
          tmp->spec.name = p->name;
216
          tmp->spec.exclude_name_list = NULL;
217
          tmp->spec.sorted = none;
218
          lang_add_wild (NULL, tmp, FALSE);
219
 
220
          /* If there is an alias for this section, add it too.  */
221
          for (aptr = alias; aptr; aptr = aptr->next)
222
            if (strcmp (aptr->alias, p->name) == 0)
223
              {
224
                tmp = (struct wildcard_list *) xmalloc (sizeof *tmp);
225
                tmp->next = NULL;
226
                tmp->spec.name = aptr->name;
227
                tmp->spec.exclude_name_list = NULL;
228
                tmp->spec.sorted = none;
229
                lang_add_wild (NULL, tmp, FALSE);
230
              }
231
 
232
          lang_leave_output_section_statement (0, "*default*", NULL, NULL);
233
 
234
          p = p->next;
235
        }
236
    }
237
 
238
  done_tree = 1;
239
}
240
 
241
void
242
mri_load (const char *name)
243
{
244
  base = 0;
245
  lang_add_input_file (name, lang_input_file_is_file_enum, NULL);
246
}
247
 
248
void
249
mri_order (const char *name)
250
{
251
  mri_add_to_list (&order, name, 0, 0, 0, 0);
252
}
253
 
254
void
255
mri_alias (const char *want, const char *is, int isn)
256
{
257
  if (!is)
258
    {
259
      char buf[20];
260
 
261
      /* Some sections are digits.  */
262
      sprintf (buf, "%d", isn);
263
 
264
      is = xstrdup (buf);
265
 
266
      if (is == NULL)
267
        abort ();
268
    }
269
 
270
  mri_add_to_list (&alias, is, 0, want, 0, 0);
271
}
272
 
273
void
274
mri_name (const char *name)
275
{
276
  lang_add_output (name, 1);
277
}
278
 
279
void
280
mri_format (const char *name)
281
{
282
  if (strcmp (name, "S") == 0)
283
    lang_add_output_format ("srec", NULL, NULL, 1);
284
 
285
  else if (strcmp (name, "IEEE") == 0)
286
    lang_add_output_format ("ieee", NULL, NULL, 1);
287
 
288
  else if (strcmp (name, "COFF") == 0)
289
    lang_add_output_format ("coff-m68k", NULL, NULL, 1);
290
 
291
  else
292
    einfo (_("%P%F: unknown format type %s\n"), name);
293
}
294
 
295
void
296
mri_public (const char *name, etree_type *exp)
297
{
298
  lang_add_assignment (exp_assop ('=', name, exp));
299
}
300
 
301
void
302
mri_align (const char *name, etree_type *exp)
303
{
304
  mri_add_to_list (&alignment, name, 0, 0, exp, 0);
305
}
306
 
307
void
308
mri_alignmod (const char *name, etree_type *exp)
309
{
310
  mri_add_to_list (&subalignment, name, 0, 0, 0, exp);
311
}
312
 
313
void
314
mri_truncate (unsigned int exp)
315
{
316
  symbol_truncate = exp;
317
}

powered by: WebSVN 2.1.0

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