ld/mri.c

   1 /* 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, 2011 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_assign (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 }