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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [layout.h] - Blame information for rev 27

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

Line No. Rev Author Line
1 27 khays
// layout.h -- lay out output file sections for gold  -*- C++ -*-
2
 
3
// Copyright 2006, 2007, 2008, 2009, 2010 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
#ifndef GOLD_LAYOUT_H
24
#define GOLD_LAYOUT_H
25
 
26
#include <cstring>
27
#include <list>
28
#include <map>
29
#include <string>
30
#include <utility>
31
#include <vector>
32
 
33
#include "script.h"
34
#include "workqueue.h"
35
#include "object.h"
36
#include "dynobj.h"
37
#include "stringpool.h"
38
 
39
namespace gold
40
{
41
 
42
class General_options;
43
class Incremental_inputs;
44
class Incremental_binary;
45
class Input_objects;
46
class Mapfile;
47
class Symbol_table;
48
class Output_section_data;
49
class Output_section;
50
class Output_section_headers;
51
class Output_segment_headers;
52
class Output_file_header;
53
class Output_segment;
54
class Output_data;
55
class Output_data_reloc_generic;
56
class Output_data_dynamic;
57
class Output_symtab_xindex;
58
class Output_reduced_debug_abbrev_section;
59
class Output_reduced_debug_info_section;
60
class Eh_frame;
61
class Target;
62
struct Timespec;
63
 
64
// Return TRUE if SECNAME is the name of a compressed debug section.
65
extern bool
66
is_compressed_debug_section(const char* secname);
67
 
68
// Maintain a list of free space within a section, segment, or file.
69
// Used for incremental update links.
70
 
71
class Free_list
72
{
73
 public:
74
  Free_list()
75
    : list_(), last_remove_(list_.begin()), extend_(false), length_(0)
76
  { }
77
 
78
  void
79
  init(off_t len, bool extend);
80
 
81
  void
82
  remove(off_t start, off_t end);
83
 
84
  off_t
85
  allocate(off_t len, uint64_t align, off_t minoff);
86
 
87
  void
88
  dump();
89
 
90
  static void
91
  print_stats();
92
 
93
 private:
94
  struct Free_list_node
95
  {
96
    Free_list_node(off_t start, off_t end)
97
      : start_(start), end_(end)
98
    { }
99
    off_t start_;
100
    off_t end_;
101
  };
102
  typedef std::list<Free_list_node>::iterator Iterator;
103
 
104
  // The free list.
105
  std::list<Free_list_node> list_;
106
 
107
  // The last node visited during a remove operation.
108
  Iterator last_remove_;
109
 
110
  // Whether we can extend past the original length.
111
  bool extend_;
112
 
113
  // The total length of the section, segment, or file.
114
  off_t length_;
115
 
116
  // Statistics:
117
  // The total number of free lists used.
118
  static unsigned int num_lists;
119
  // The total number of free list nodes used.
120
  static unsigned int num_nodes;
121
  // The total number of calls to Free_list::remove.
122
  static unsigned int num_removes;
123
  // The total number of nodes visited during calls to Free_list::remove.
124
  static unsigned int num_remove_visits;
125
  // The total number of calls to Free_list::allocate.
126
  static unsigned int num_allocates;
127
  // The total number of nodes visited during calls to Free_list::allocate.
128
  static unsigned int num_allocate_visits;
129
};
130
 
131
// This task function handles mapping the input sections to output
132
// sections and laying them out in memory.
133
 
134
class Layout_task_runner : public Task_function_runner
135
{
136
 public:
137
  // OPTIONS is the command line options, INPUT_OBJECTS is the list of
138
  // input objects, SYMTAB is the symbol table, LAYOUT is the layout
139
  // object.
140
  Layout_task_runner(const General_options& options,
141
                     const Input_objects* input_objects,
142
                     Symbol_table* symtab,
143
                     Target* target,
144
                     Layout* layout,
145
                     Mapfile* mapfile)
146
    : options_(options), input_objects_(input_objects), symtab_(symtab),
147
      target_(target), layout_(layout), mapfile_(mapfile)
148
  { }
149
 
150
  // Run the operation.
151
  void
152
  run(Workqueue*, const Task*);
153
 
154
 private:
155
  Layout_task_runner(const Layout_task_runner&);
156
  Layout_task_runner& operator=(const Layout_task_runner&);
157
 
158
  const General_options& options_;
159
  const Input_objects* input_objects_;
160
  Symbol_table* symtab_;
161
  Target* target_;
162
  Layout* layout_;
163
  Mapfile* mapfile_;
164
};
165
 
166
// This class holds information about the comdat group or
167
// .gnu.linkonce section that will be kept for a given signature.
168
 
169
class Kept_section
170
{
171
 private:
172
  // For a comdat group, we build a mapping from the name of each
173
  // section in the group to the section index and the size in object.
174
  // When we discard a group in some other object file, we use this
175
  // map to figure out which kept section the discarded section is
176
  // associated with.  We then use that mapping when processing relocs
177
  // against discarded sections.
178
  struct Comdat_section_info
179
  {
180
    // The section index.
181
    unsigned int shndx;
182
    // The section size.
183
    uint64_t size;
184
 
185
    Comdat_section_info(unsigned int a_shndx, uint64_t a_size)
186
      : shndx(a_shndx), size(a_size)
187
    { }
188
  };
189
 
190
  // Most comdat groups have only one or two sections, so we use a
191
  // std::map rather than an Unordered_map to optimize for that case
192
  // without paying too heavily for groups with more sections.
193
  typedef std::map<std::string, Comdat_section_info> Comdat_group;
194
 
195
 public:
196
  Kept_section()
197
    : object_(NULL), shndx_(0), is_comdat_(false), is_group_name_(false)
198
  { this->u_.linkonce_size = 0; }
199
 
200
  // We need to support copies for the signature map in the Layout
201
  // object, but we should never copy an object after it has been
202
  // marked as a comdat section.
203
  Kept_section(const Kept_section& k)
204
    : object_(k.object_), shndx_(k.shndx_), is_comdat_(false),
205
      is_group_name_(k.is_group_name_)
206
  {
207
    gold_assert(!k.is_comdat_);
208
    this->u_.linkonce_size = 0;
209
  }
210
 
211
  ~Kept_section()
212
  {
213
    if (this->is_comdat_)
214
      delete this->u_.group_sections;
215
  }
216
 
217
  // The object where this section lives.
218
  Relobj*
219
  object() const
220
  { return this->object_; }
221
 
222
  // Set the object.
223
  void
224
  set_object(Relobj* object)
225
  {
226
    gold_assert(this->object_ == NULL);
227
    this->object_ = object;
228
  }
229
 
230
  // The section index.
231
  unsigned int
232
  shndx() const
233
  { return this->shndx_; }
234
 
235
  // Set the section index.
236
  void
237
  set_shndx(unsigned int shndx)
238
  {
239
    gold_assert(this->shndx_ == 0);
240
    this->shndx_ = shndx;
241
  }
242
 
243
  // Whether this is a comdat group.
244
  bool
245
  is_comdat() const
246
  { return this->is_comdat_; }
247
 
248
  // Set that this is a comdat group.
249
  void
250
  set_is_comdat()
251
  {
252
    gold_assert(!this->is_comdat_);
253
    this->is_comdat_ = true;
254
    this->u_.group_sections = new Comdat_group();
255
  }
256
 
257
  // Whether this is associated with the name of a group or section
258
  // rather than the symbol name derived from a linkonce section.
259
  bool
260
  is_group_name() const
261
  { return this->is_group_name_; }
262
 
263
  // Note that this represents a comdat group rather than a single
264
  // linkonce section.
265
  void
266
  set_is_group_name()
267
  { this->is_group_name_ = true; }
268
 
269
  // Add a section to the group list.
270
  void
271
  add_comdat_section(const std::string& name, unsigned int shndx,
272
                     uint64_t size)
273
  {
274
    gold_assert(this->is_comdat_);
275
    Comdat_section_info sinfo(shndx, size);
276
    this->u_.group_sections->insert(std::make_pair(name, sinfo));
277
  }
278
 
279
  // Look for a section name in the group list, and return whether it
280
  // was found.  If found, returns the section index and size.
281
  bool
282
  find_comdat_section(const std::string& name, unsigned int* pshndx,
283
                      uint64_t* psize) const
284
  {
285
    gold_assert(this->is_comdat_);
286
    Comdat_group::const_iterator p = this->u_.group_sections->find(name);
287
    if (p == this->u_.group_sections->end())
288
      return false;
289
    *pshndx = p->second.shndx;
290
    *psize = p->second.size;
291
    return true;
292
  }
293
 
294
  // If there is only one section in the group list, return true, and
295
  // return the section index and size.
296
  bool
297
  find_single_comdat_section(unsigned int* pshndx, uint64_t* psize) const
298
  {
299
    gold_assert(this->is_comdat_);
300
    if (this->u_.group_sections->size() != 1)
301
      return false;
302
    Comdat_group::const_iterator p = this->u_.group_sections->begin();
303
    *pshndx = p->second.shndx;
304
    *psize = p->second.size;
305
    return true;
306
  }
307
 
308
  // Return the size of a linkonce section.
309
  uint64_t
310
  linkonce_size() const
311
  {
312
    gold_assert(!this->is_comdat_);
313
    return this->u_.linkonce_size;
314
  }
315
 
316
  // Set the size of a linkonce section.
317
  void
318
  set_linkonce_size(uint64_t size)
319
  {
320
    gold_assert(!this->is_comdat_);
321
    this->u_.linkonce_size = size;
322
  }
323
 
324
 private:
325
  // No assignment.
326
  Kept_section& operator=(const Kept_section&);
327
 
328
  // The object containing the comdat group or .gnu.linkonce section.
329
  Relobj* object_;
330
  // Index of the group section for comdats and the section itself for
331
  // .gnu.linkonce.
332
  unsigned int shndx_;
333
  // True if this is for a comdat group rather than a .gnu.linkonce
334
  // section.
335
  bool is_comdat_;
336
  // The Kept_sections are values of a mapping, that maps names to
337
  // them.  This field is true if this struct is associated with the
338
  // name of a comdat or .gnu.linkonce, false if it is associated with
339
  // the name of a symbol obtained from the .gnu.linkonce.* name
340
  // through some heuristics.
341
  bool is_group_name_;
342
  union
343
  {
344
    // If the is_comdat_ field is true, this holds a map from names of
345
    // the sections in the group to section indexes in object_ and to
346
    // section sizes.
347
    Comdat_group* group_sections;
348
    // If the is_comdat_ field is false, this holds the size of the
349
    // single section.
350
    uint64_t linkonce_size;
351
  } u_;
352
};
353
 
354
// The ordering for output sections.  This controls how output
355
// sections are ordered within a PT_LOAD output segment.
356
 
357
enum Output_section_order
358
{
359
  // Unspecified.  Used for non-load segments.  Also used for the file
360
  // and segment headers.
361
  ORDER_INVALID,
362
 
363
  // The PT_INTERP section should come first, so that the dynamic
364
  // linker can pick it up quickly.
365
  ORDER_INTERP,
366
 
367
  // Loadable read-only note sections come next so that the PT_NOTE
368
  // segment is on the first page of the executable.
369
  ORDER_RO_NOTE,
370
 
371
  // Put read-only sections used by the dynamic linker early in the
372
  // executable to minimize paging.
373
  ORDER_DYNAMIC_LINKER,
374
 
375
  // Put reloc sections used by the dynamic linker after other
376
  // sections used by the dynamic linker; otherwise, objcopy and strip
377
  // get confused.
378
  ORDER_DYNAMIC_RELOCS,
379
 
380
  // Put the PLT reloc section after the other dynamic relocs;
381
  // otherwise, prelink gets confused.
382
  ORDER_DYNAMIC_PLT_RELOCS,
383
 
384
  // The .init section.
385
  ORDER_INIT,
386
 
387
  // The PLT.
388
  ORDER_PLT,
389
 
390
  // The regular text sections.
391
  ORDER_TEXT,
392
 
393
  // The .fini section.
394
  ORDER_FINI,
395
 
396
  // The read-only sections.
397
  ORDER_READONLY,
398
 
399
  // The exception frame sections.
400
  ORDER_EHFRAME,
401
 
402
  // The TLS sections come first in the data section.
403
  ORDER_TLS_DATA,
404
  ORDER_TLS_BSS,
405
 
406
  // Local RELRO (read-only after relocation) sections come before
407
  // non-local RELRO sections.  This data will be fully resolved by
408
  // the prelinker.
409
  ORDER_RELRO_LOCAL,
410
 
411
  // Non-local RELRO sections are grouped together after local RELRO
412
  // sections.  All RELRO sections must be adjacent so that they can
413
  // all be put into a PT_GNU_RELRO segment.
414
  ORDER_RELRO,
415
 
416
  // We permit marking exactly one output section as the last RELRO
417
  // section.  We do this so that the read-only GOT can be adjacent to
418
  // the writable GOT.
419
  ORDER_RELRO_LAST,
420
 
421
  // Similarly, we permit marking exactly one output section as the
422
  // first non-RELRO section.
423
  ORDER_NON_RELRO_FIRST,
424
 
425
  // The regular data sections come after the RELRO sections.
426
  ORDER_DATA,
427
 
428
  // Large data sections normally go in large data segments.
429
  ORDER_LARGE_DATA,
430
 
431
  // Group writable notes so that we can have a single PT_NOTE
432
  // segment.
433
  ORDER_RW_NOTE,
434
 
435
  // The small data sections must be at the end of the data sections,
436
  // so that they can be adjacent to the small BSS sections.
437
  ORDER_SMALL_DATA,
438
 
439
  // The BSS sections start here.
440
 
441
  // The small BSS sections must be at the start of the BSS sections,
442
  // so that they can be adjacent to the small data sections.
443
  ORDER_SMALL_BSS,
444
 
445
  // The regular BSS sections.
446
  ORDER_BSS,
447
 
448
  // The large BSS sections come after the other BSS sections.
449
  ORDER_LARGE_BSS,
450
 
451
  // Maximum value.
452
  ORDER_MAX
453
};
454
 
455
// This class handles the details of laying out input sections.
456
 
457
class Layout
458
{
459
 public:
460
  Layout(int number_of_input_files, Script_options*);
461
 
462
  ~Layout()
463
  {
464
    delete this->relaxation_debug_check_;
465
    delete this->segment_states_;
466
  }
467
 
468
  // For incremental links, record the base file to be modified.
469
  void
470
  set_incremental_base(Incremental_binary* base);
471
 
472
  Incremental_binary*
473
  incremental_base()
474
  { return this->incremental_base_; }
475
 
476
  // For incremental links, record the initial fixed layout of a section
477
  // from the base file, and return a pointer to the Output_section.
478
  template<int size, bool big_endian>
479
  Output_section*
480
  init_fixed_output_section(const char*, elfcpp::Shdr<size, big_endian>&);
481
 
482
  // Given an input section SHNDX, named NAME, with data in SHDR, from
483
  // the object file OBJECT, return the output section where this
484
  // input section should go.  RELOC_SHNDX is the index of a
485
  // relocation section which applies to this section, or 0 if none,
486
  // or -1U if more than one.  RELOC_TYPE is the type of the
487
  // relocation section if there is one.  Set *OFFSET to the offset
488
  // within the output section.
489
  template<int size, bool big_endian>
490
  Output_section*
491
  layout(Sized_relobj_file<size, big_endian> *object, unsigned int shndx,
492
         const char* name, const elfcpp::Shdr<size, big_endian>& shdr,
493
         unsigned int reloc_shndx, unsigned int reloc_type, off_t* offset);
494
 
495
  // For incremental updates, allocate a block of memory from the
496
  // free list.  Find a block starting at or after MINOFF.
497
  off_t
498
  allocate(off_t len, uint64_t align, off_t minoff)
499
  { return this->free_list_.allocate(len, align, minoff); }
500
 
501
  unsigned int
502
  find_section_order_index(const std::string&);
503
 
504
  void
505
  read_layout_from_file();
506
 
507
  // Layout an input reloc section when doing a relocatable link.  The
508
  // section is RELOC_SHNDX in OBJECT, with data in SHDR.
509
  // DATA_SECTION is the reloc section to which it refers.  RR is the
510
  // relocatable information.
511
  template<int size, bool big_endian>
512
  Output_section*
513
  layout_reloc(Sized_relobj_file<size, big_endian>* object,
514
               unsigned int reloc_shndx,
515
               const elfcpp::Shdr<size, big_endian>& shdr,
516
               Output_section* data_section,
517
               Relocatable_relocs* rr);
518
 
519
  // Layout a group section when doing a relocatable link.
520
  template<int size, bool big_endian>
521
  void
522
  layout_group(Symbol_table* symtab,
523
               Sized_relobj_file<size, big_endian>* object,
524
               unsigned int group_shndx,
525
               const char* group_section_name,
526
               const char* signature,
527
               const elfcpp::Shdr<size, big_endian>& shdr,
528
               elfcpp::Elf_Word flags,
529
               std::vector<unsigned int>* shndxes);
530
 
531
  // Like layout, only for exception frame sections.  OBJECT is an
532
  // object file.  SYMBOLS is the contents of the symbol table
533
  // section, with size SYMBOLS_SIZE.  SYMBOL_NAMES is the contents of
534
  // the symbol name section, with size SYMBOL_NAMES_SIZE.  SHNDX is a
535
  // .eh_frame section in OBJECT.  SHDR is the section header.
536
  // RELOC_SHNDX is the index of a relocation section which applies to
537
  // this section, or 0 if none, or -1U if more than one.  RELOC_TYPE
538
  // is the type of the relocation section if there is one.  This
539
  // returns the output section, and sets *OFFSET to the offset.
540
  template<int size, bool big_endian>
541
  Output_section*
542
  layout_eh_frame(Sized_relobj_file<size, big_endian>* object,
543
                  const unsigned char* symbols,
544
                  off_t symbols_size,
545
                  const unsigned char* symbol_names,
546
                  off_t symbol_names_size,
547
                  unsigned int shndx,
548
                  const elfcpp::Shdr<size, big_endian>& shdr,
549
                  unsigned int reloc_shndx, unsigned int reloc_type,
550
                  off_t* offset);
551
 
552
  // Handle a GNU stack note.  This is called once per input object
553
  // file.  SEEN_GNU_STACK is true if the object file has a
554
  // .note.GNU-stack section.  GNU_STACK_FLAGS is the section flags
555
  // from that section if there was one.
556
  void
557
  layout_gnu_stack(bool seen_gnu_stack, uint64_t gnu_stack_flags,
558
                   const Object*);
559
 
560
  // Add an Output_section_data to the layout.  This is used for
561
  // special sections like the GOT section.  ORDER is where the
562
  // section should wind up in the output segment.  IS_RELRO is true
563
  // for relro sections.
564
  Output_section*
565
  add_output_section_data(const char* name, elfcpp::Elf_Word type,
566
                          elfcpp::Elf_Xword flags,
567
                          Output_section_data*, Output_section_order order,
568
                          bool is_relro);
569
 
570
  // Increase the size of the relro segment by this much.
571
  void
572
  increase_relro(unsigned int s)
573
  { this->increase_relro_ += s; }
574
 
575
  // Create dynamic sections if necessary.
576
  void
577
  create_initial_dynamic_sections(Symbol_table*);
578
 
579
  // Define __start and __stop symbols for output sections.
580
  void
581
  define_section_symbols(Symbol_table*);
582
 
583
  // Create automatic note sections.
584
  void
585
  create_notes();
586
 
587
  // Create sections for linker scripts.
588
  void
589
  create_script_sections()
590
  { this->script_options_->create_script_sections(this); }
591
 
592
  // Define symbols from any linker script.
593
  void
594
  define_script_symbols(Symbol_table* symtab)
595
  { this->script_options_->add_symbols_to_table(symtab); }
596
 
597
  // Define symbols for group signatures.
598
  void
599
  define_group_signatures(Symbol_table*);
600
 
601
  // Return the Stringpool used for symbol names.
602
  const Stringpool*
603
  sympool() const
604
  { return &this->sympool_; }
605
 
606
  // Return the Stringpool used for dynamic symbol names and dynamic
607
  // tags.
608
  const Stringpool*
609
  dynpool() const
610
  { return &this->dynpool_; }
611
 
612
  // Return the symtab_xindex section used to hold large section
613
  // indexes for the normal symbol table.
614
  Output_symtab_xindex*
615
  symtab_xindex() const
616
  { return this->symtab_xindex_; }
617
 
618
  // Return the dynsym_xindex section used to hold large section
619
  // indexes for the dynamic symbol table.
620
  Output_symtab_xindex*
621
  dynsym_xindex() const
622
  { return this->dynsym_xindex_; }
623
 
624
  // Return whether a section is a .gnu.linkonce section, given the
625
  // section name.
626
  static inline bool
627
  is_linkonce(const char* name)
628
  { return strncmp(name, ".gnu.linkonce", sizeof(".gnu.linkonce") - 1) == 0; }
629
 
630
  // Whether we have added an input section.
631
  bool
632
  have_added_input_section() const
633
  { return this->have_added_input_section_; }
634
 
635
  // Return true if a section is a debugging section.
636
  static inline bool
637
  is_debug_info_section(const char* name)
638
  {
639
    // Debugging sections can only be recognized by name.
640
    return (strncmp(name, ".debug", sizeof(".debug") - 1) == 0
641
            || strncmp(name, ".zdebug", sizeof(".zdebug") - 1) == 0
642
            || strncmp(name, ".gnu.linkonce.wi.",
643
                       sizeof(".gnu.linkonce.wi.") - 1) == 0
644
            || strncmp(name, ".line", sizeof(".line") - 1) == 0
645
            || strncmp(name, ".stab", sizeof(".stab") - 1) == 0);
646
  }
647
 
648
  // Check if a comdat group or .gnu.linkonce section with the given
649
  // NAME is selected for the link.  If there is already a section,
650
  // *KEPT_SECTION is set to point to the signature and the function
651
  // returns false.  Otherwise, OBJECT, SHNDX,IS_COMDAT, and
652
  // IS_GROUP_NAME are recorded for this NAME in the layout object,
653
  // *KEPT_SECTION is set to the internal copy and the function return
654
  // false.
655
  bool
656
  find_or_add_kept_section(const std::string& name, Relobj* object,
657
                           unsigned int shndx, bool is_comdat,
658
                           bool is_group_name, Kept_section** kept_section);
659
 
660
  // Finalize the layout after all the input sections have been added.
661
  off_t
662
  finalize(const Input_objects*, Symbol_table*, Target*, const Task*);
663
 
664
  // Return whether any sections require postprocessing.
665
  bool
666
  any_postprocessing_sections() const
667
  { return this->any_postprocessing_sections_; }
668
 
669
  // Return the size of the output file.
670
  off_t
671
  output_file_size() const
672
  { return this->output_file_size_; }
673
 
674
  // Return the TLS segment.  This will return NULL if there isn't
675
  // one.
676
  Output_segment*
677
  tls_segment() const
678
  { return this->tls_segment_; }
679
 
680
  // Return the normal symbol table.
681
  Output_section*
682
  symtab_section() const
683
  {
684
    gold_assert(this->symtab_section_ != NULL);
685
    return this->symtab_section_;
686
  }
687
 
688
  // Return the file offset of the normal symbol table.
689
  off_t
690
  symtab_section_offset() const;
691
 
692
  // Return the dynamic symbol table.
693
  Output_section*
694
  dynsym_section() const
695
  {
696
    gold_assert(this->dynsym_section_ != NULL);
697
    return this->dynsym_section_;
698
  }
699
 
700
  // Return the dynamic tags.
701
  Output_data_dynamic*
702
  dynamic_data() const
703
  { return this->dynamic_data_; }
704
 
705
  // Write out the output sections.
706
  void
707
  write_output_sections(Output_file* of) const;
708
 
709
  // Write out data not associated with an input file or the symbol
710
  // table.
711
  void
712
  write_data(const Symbol_table*, Output_file*) const;
713
 
714
  // Write out output sections which can not be written until all the
715
  // input sections are complete.
716
  void
717
  write_sections_after_input_sections(Output_file* of);
718
 
719
  // Return an output section named NAME, or NULL if there is none.
720
  Output_section*
721
  find_output_section(const char* name) const;
722
 
723
  // Return an output segment of type TYPE, with segment flags SET set
724
  // and segment flags CLEAR clear.  Return NULL if there is none.
725
  Output_segment*
726
  find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set,
727
                      elfcpp::Elf_Word clear) const;
728
 
729
  // Return the number of segments we expect to produce.
730
  size_t
731
  expected_segment_count() const;
732
 
733
  // Set a flag to indicate that an object file uses the static TLS model.
734
  void
735
  set_has_static_tls()
736
  { this->has_static_tls_ = true; }
737
 
738
  // Return true if any object file uses the static TLS model.
739
  bool
740
  has_static_tls() const
741
  { return this->has_static_tls_; }
742
 
743
  // Return the options which may be set by a linker script.
744
  Script_options*
745
  script_options()
746
  { return this->script_options_; }
747
 
748
  const Script_options*
749
  script_options() const
750
  { return this->script_options_; }
751
 
752
  // Return the object managing inputs in incremental build. NULL in
753
  // non-incremental builds.
754
  Incremental_inputs*
755
  incremental_inputs() const
756
  { return this->incremental_inputs_; }
757
 
758
  // For the target-specific code to add dynamic tags which are common
759
  // to most targets.
760
  void
761
  add_target_dynamic_tags(bool use_rel, const Output_data* plt_got,
762
                          const Output_data* plt_rel,
763
                          const Output_data_reloc_generic* dyn_rel,
764
                          bool add_debug, bool dynrel_includes_plt);
765
 
766
  // Compute and write out the build ID if needed.
767
  void
768
  write_build_id(Output_file*) const;
769
 
770
  // Rewrite output file in binary format.
771
  void
772
  write_binary(Output_file* in) const;
773
 
774
  // Print output sections to the map file.
775
  void
776
  print_to_mapfile(Mapfile*) const;
777
 
778
  // Dump statistical information to stderr.
779
  void
780
  print_stats() const;
781
 
782
  // A list of segments.
783
 
784
  typedef std::vector<Output_segment*> Segment_list;
785
 
786
  // A list of sections.
787
 
788
  typedef std::vector<Output_section*> Section_list;
789
 
790
  // The list of information to write out which is not attached to
791
  // either a section or a segment.
792
  typedef std::vector<Output_data*> Data_list;
793
 
794
  // Store the allocated sections into the section list.  This is used
795
  // by the linker script code.
796
  void
797
  get_allocated_sections(Section_list*) const;
798
 
799
  // Make a section for a linker script to hold data.
800
  Output_section*
801
  make_output_section_for_script(const char* name,
802
                                 Script_sections::Section_type section_type);
803
 
804
  // Make a segment.  This is used by the linker script code.
805
  Output_segment*
806
  make_output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags);
807
 
808
  // Return the number of segments.
809
  size_t
810
  segment_count() const
811
  { return this->segment_list_.size(); }
812
 
813
  // Map from section flags to segment flags.
814
  static elfcpp::Elf_Word
815
  section_flags_to_segment(elfcpp::Elf_Xword flags);
816
 
817
  // Attach sections to segments.
818
  void
819
  attach_sections_to_segments();
820
 
821
  // For relaxation clean up, we need to know output section data created
822
  // from a linker script.
823
  void
824
  new_output_section_data_from_script(Output_section_data* posd)
825
  {
826
    if (this->record_output_section_data_from_script_)
827
      this->script_output_section_data_list_.push_back(posd);
828
  }
829
 
830
  // Return section list.
831
  const Section_list&
832
  section_list() const
833
  { return this->section_list_; }
834
 
835
 private:
836
  Layout(const Layout&);
837
  Layout& operator=(const Layout&);
838
 
839
  // Mapping from input section names to output section names.
840
  struct Section_name_mapping
841
  {
842
    const char* from;
843
    int fromlen;
844
    const char* to;
845
    int tolen;
846
  };
847
  static const Section_name_mapping section_name_mapping[];
848
  static const int section_name_mapping_count;
849
 
850
  // During a relocatable link, a list of group sections and
851
  // signatures.
852
  struct Group_signature
853
  {
854
    // The group section.
855
    Output_section* section;
856
    // The signature.
857
    const char* signature;
858
 
859
    Group_signature()
860
      : section(NULL), signature(NULL)
861
    { }
862
 
863
    Group_signature(Output_section* sectiona, const char* signaturea)
864
      : section(sectiona), signature(signaturea)
865
    { }
866
  };
867
  typedef std::vector<Group_signature> Group_signatures;
868
 
869
  // Create a note section, filling in the header.
870
  Output_section*
871
  create_note(const char* name, int note_type, const char* section_name,
872
              size_t descsz, bool allocate, size_t* trailing_padding);
873
 
874
  // Create a note section for gold version.
875
  void
876
  create_gold_note();
877
 
878
  // Record whether the stack must be executable.
879
  void
880
  create_executable_stack_info();
881
 
882
  // Create a build ID note if needed.
883
  void
884
  create_build_id();
885
 
886
  // Link .stab and .stabstr sections.
887
  void
888
  link_stabs_sections();
889
 
890
  // Create .gnu_incremental_inputs and .gnu_incremental_strtab sections needed
891
  // for the next run of incremental linking to check what has changed.
892
  void
893
  create_incremental_info_sections(Symbol_table*);
894
 
895
  // Find the first read-only PT_LOAD segment, creating one if
896
  // necessary.
897
  Output_segment*
898
  find_first_load_seg();
899
 
900
  // Count the local symbols in the regular symbol table and the dynamic
901
  // symbol table, and build the respective string pools.
902
  void
903
  count_local_symbols(const Task*, const Input_objects*);
904
 
905
  // Create the output sections for the symbol table.
906
  void
907
  create_symtab_sections(const Input_objects*, Symbol_table*,
908
                         unsigned int, off_t*);
909
 
910
  // Create the .shstrtab section.
911
  Output_section*
912
  create_shstrtab();
913
 
914
  // Create the section header table.
915
  void
916
  create_shdrs(const Output_section* shstrtab_section, off_t*);
917
 
918
  // Create the dynamic symbol table.
919
  void
920
  create_dynamic_symtab(const Input_objects*, Symbol_table*,
921
                        Output_section** pdynstr,
922
                        unsigned int* plocal_dynamic_count,
923
                        std::vector<Symbol*>* pdynamic_symbols,
924
                        Versions* versions);
925
 
926
  // Assign offsets to each local portion of the dynamic symbol table.
927
  void
928
  assign_local_dynsym_offsets(const Input_objects*);
929
 
930
  // Finish the .dynamic section and PT_DYNAMIC segment.
931
  void
932
  finish_dynamic_section(const Input_objects*, const Symbol_table*);
933
 
934
  // Set the size of the _DYNAMIC symbol.
935
  void
936
  set_dynamic_symbol_size(const Symbol_table*);
937
 
938
  // Create the .interp section and PT_INTERP segment.
939
  void
940
  create_interp(const Target* target);
941
 
942
  // Create the version sections.
943
  void
944
  create_version_sections(const Versions*,
945
                          const Symbol_table*,
946
                          unsigned int local_symcount,
947
                          const std::vector<Symbol*>& dynamic_symbols,
948
                          const Output_section* dynstr);
949
 
950
  template<int size, bool big_endian>
951
  void
952
  sized_create_version_sections(const Versions* versions,
953
                                const Symbol_table*,
954
                                unsigned int local_symcount,
955
                                const std::vector<Symbol*>& dynamic_symbols,
956
                                const Output_section* dynstr);
957
 
958
  // Return whether to include this section in the link.
959
  template<int size, bool big_endian>
960
  bool
961
  include_section(Sized_relobj_file<size, big_endian>* object, const char* name,
962
                  const elfcpp::Shdr<size, big_endian>&);
963
 
964
  // Return the output section name to use given an input section
965
  // name.  Set *PLEN to the length of the name.  *PLEN must be
966
  // initialized to the length of NAME.
967
  static const char*
968
  output_section_name(const char* name, size_t* plen);
969
 
970
  // Return the number of allocated output sections.
971
  size_t
972
  allocated_output_section_count() const;
973
 
974
  // Return the output section for NAME, TYPE and FLAGS.
975
  Output_section*
976
  get_output_section(const char* name, Stringpool::Key name_key,
977
                     elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
978
                     Output_section_order order, bool is_relro);
979
 
980
  // Choose the output section for NAME in RELOBJ.
981
  Output_section*
982
  choose_output_section(const Relobj* relobj, const char* name,
983
                        elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
984
                        bool is_input_section, Output_section_order order,
985
                        bool is_relro);
986
 
987
  // Create a new Output_section.
988
  Output_section*
989
  make_output_section(const char* name, elfcpp::Elf_Word type,
990
                      elfcpp::Elf_Xword flags, Output_section_order order,
991
                      bool is_relro);
992
 
993
  // Attach a section to a segment.
994
  void
995
  attach_section_to_segment(Output_section*);
996
 
997
  // Get section order.
998
  Output_section_order
999
  default_section_order(Output_section*, bool is_relro_local);
1000
 
1001
  // Attach an allocated section to a segment.
1002
  void
1003
  attach_allocated_section_to_segment(Output_section*);
1004
 
1005
  // Set the final file offsets of all the segments.
1006
  off_t
1007
  set_segment_offsets(const Target*, Output_segment*, unsigned int* pshndx);
1008
 
1009
  // Set the file offsets of the sections when doing a relocatable
1010
  // link.
1011
  off_t
1012
  set_relocatable_section_offsets(Output_data*, unsigned int* pshndx);
1013
 
1014
  // Set the final file offsets of all the sections not associated
1015
  // with a segment.  We set section offsets in three passes: the
1016
  // first handles all allocated sections, the second sections that
1017
  // require postprocessing, and the last the late-bound STRTAB
1018
  // sections (probably only shstrtab, which is the one we care about
1019
  // because it holds section names).
1020
  enum Section_offset_pass
1021
  {
1022
    BEFORE_INPUT_SECTIONS_PASS,
1023
    POSTPROCESSING_SECTIONS_PASS,
1024
    STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS
1025
  };
1026
  off_t
1027
  set_section_offsets(off_t, Section_offset_pass pass);
1028
 
1029
  // Set the final section indexes of all the sections not associated
1030
  // with a segment.  Returns the next unused index.
1031
  unsigned int
1032
  set_section_indexes(unsigned int pshndx);
1033
 
1034
  // Set the section addresses when using a script.
1035
  Output_segment*
1036
  set_section_addresses_from_script(Symbol_table*);
1037
 
1038
  // Find appropriate places or orphan sections in a script.
1039
  void
1040
  place_orphan_sections_in_script();
1041
 
1042
  // Return whether SEG1 comes before SEG2 in the output file.
1043
  static bool
1044
  segment_precedes(const Output_segment* seg1, const Output_segment* seg2);
1045
 
1046
  // Use to save and restore segments during relaxation. 
1047
  typedef Unordered_map<const Output_segment*, const Output_segment*>
1048
    Segment_states;
1049
 
1050
  // Save states of current output segments.
1051
  void
1052
  save_segments(Segment_states*);
1053
 
1054
  // Restore output segment states.
1055
  void
1056
  restore_segments(const Segment_states*);
1057
 
1058
  // Clean up after relaxation so that it is possible to lay out the
1059
  // sections and segments again.
1060
  void
1061
  clean_up_after_relaxation();
1062
 
1063
  // Doing preparation work for relaxation.  This is factored out to make
1064
  // Layout::finalized a bit smaller and easier to read.
1065
  void
1066
  prepare_for_relaxation();
1067
 
1068
  // Main body of the relaxation loop, which lays out the section.
1069
  off_t
1070
  relaxation_loop_body(int, Target*, Symbol_table*, Output_segment**,
1071
                       Output_segment*, Output_segment_headers*,
1072
                       Output_file_header*, unsigned int*);
1073
 
1074
  // A mapping used for kept comdats/.gnu.linkonce group signatures.
1075
  typedef Unordered_map<std::string, Kept_section> Signatures;
1076
 
1077
  // Mapping from input section name/type/flags to output section.  We
1078
  // use canonicalized strings here.
1079
 
1080
  typedef std::pair<Stringpool::Key,
1081
                    std::pair<elfcpp::Elf_Word, elfcpp::Elf_Xword> > Key;
1082
 
1083
  struct Hash_key
1084
  {
1085
    size_t
1086
    operator()(const Key& k) const;
1087
  };
1088
 
1089
  typedef Unordered_map<Key, Output_section*, Hash_key> Section_name_map;
1090
 
1091
  // A comparison class for segments.
1092
 
1093
  struct Compare_segments
1094
  {
1095
    bool
1096
    operator()(const Output_segment* seg1, const Output_segment* seg2)
1097
    { return Layout::segment_precedes(seg1, seg2); }
1098
  };
1099
 
1100
  typedef std::vector<Output_section_data*> Output_section_data_list;
1101
 
1102
  // Debug checker class.
1103
  class Relaxation_debug_check
1104
  {
1105
   public:
1106
    Relaxation_debug_check()
1107
      : section_infos_()
1108
    { }
1109
 
1110
    // Check that sections and special data are in reset states.
1111
    void
1112
    check_output_data_for_reset_values(const Layout::Section_list&,
1113
                                       const Layout::Data_list&);
1114
 
1115
    // Record information of a section list.
1116
    void
1117
    read_sections(const Layout::Section_list&);
1118
 
1119
    // Verify a section list with recorded information.
1120
    void
1121
    verify_sections(const Layout::Section_list&);
1122
 
1123
   private:
1124
    // Information we care about a section.
1125
    struct Section_info
1126
    {
1127
      // Output section described by this.
1128
      Output_section* output_section;
1129
      // Load address.
1130
      uint64_t address;
1131
      // Data size.
1132
      off_t data_size;
1133
      // File offset.
1134
      off_t offset;
1135
    };
1136
 
1137
    // Section information.
1138
    std::vector<Section_info> section_infos_;
1139
  };
1140
 
1141
  // The number of input files, for sizing tables.
1142
  int number_of_input_files_;
1143
  // Information set by scripts or by command line options.
1144
  Script_options* script_options_;
1145
  // The output section names.
1146
  Stringpool namepool_;
1147
  // The output symbol names.
1148
  Stringpool sympool_;
1149
  // The dynamic strings, if needed.
1150
  Stringpool dynpool_;
1151
  // The list of group sections and linkonce sections which we have seen.
1152
  Signatures signatures_;
1153
  // The mapping from input section name/type/flags to output sections.
1154
  Section_name_map section_name_map_;
1155
  // The list of output segments.
1156
  Segment_list segment_list_;
1157
  // The list of output sections.
1158
  Section_list section_list_;
1159
  // The list of output sections which are not attached to any output
1160
  // segment.
1161
  Section_list unattached_section_list_;
1162
  // The list of unattached Output_data objects which require special
1163
  // handling because they are not Output_sections.
1164
  Data_list special_output_list_;
1165
  // The section headers.
1166
  Output_section_headers* section_headers_;
1167
  // A pointer to the PT_TLS segment if there is one.
1168
  Output_segment* tls_segment_;
1169
  // A pointer to the PT_GNU_RELRO segment if there is one.
1170
  Output_segment* relro_segment_;
1171
  // A backend may increase the size of the PT_GNU_RELRO segment if
1172
  // there is one.  This is the amount to increase it by.
1173
  unsigned int increase_relro_;
1174
  // The SHT_SYMTAB output section.
1175
  Output_section* symtab_section_;
1176
  // The SHT_SYMTAB_SHNDX for the regular symbol table if there is one.
1177
  Output_symtab_xindex* symtab_xindex_;
1178
  // The SHT_DYNSYM output section if there is one.
1179
  Output_section* dynsym_section_;
1180
  // The SHT_SYMTAB_SHNDX for the dynamic symbol table if there is one.
1181
  Output_symtab_xindex* dynsym_xindex_;
1182
  // The SHT_DYNAMIC output section if there is one.
1183
  Output_section* dynamic_section_;
1184
  // The _DYNAMIC symbol if there is one.
1185
  Symbol* dynamic_symbol_;
1186
  // The dynamic data which goes into dynamic_section_.
1187
  Output_data_dynamic* dynamic_data_;
1188
  // The exception frame output section if there is one.
1189
  Output_section* eh_frame_section_;
1190
  // The exception frame data for eh_frame_section_.
1191
  Eh_frame* eh_frame_data_;
1192
  // Whether we have added eh_frame_data_ to the .eh_frame section.
1193
  bool added_eh_frame_data_;
1194
  // The exception frame header output section if there is one.
1195
  Output_section* eh_frame_hdr_section_;
1196
  // The space for the build ID checksum if there is one.
1197
  Output_section_data* build_id_note_;
1198
  // The output section containing dwarf abbreviations
1199
  Output_reduced_debug_abbrev_section* debug_abbrev_;
1200
  // The output section containing the dwarf debug info tree
1201
  Output_reduced_debug_info_section* debug_info_;
1202
  // A list of group sections and their signatures.
1203
  Group_signatures group_signatures_;
1204
  // The size of the output file.
1205
  off_t output_file_size_;
1206
  // Whether we have added an input section to an output section.
1207
  bool have_added_input_section_;
1208
  // Whether we have attached the sections to the segments.
1209
  bool sections_are_attached_;
1210
  // Whether we have seen an object file marked to require an
1211
  // executable stack.
1212
  bool input_requires_executable_stack_;
1213
  // Whether we have seen at least one object file with an executable
1214
  // stack marker.
1215
  bool input_with_gnu_stack_note_;
1216
  // Whether we have seen at least one object file without an
1217
  // executable stack marker.
1218
  bool input_without_gnu_stack_note_;
1219
  // Whether we have seen an object file that uses the static TLS model.
1220
  bool has_static_tls_;
1221
  // Whether any sections require postprocessing.
1222
  bool any_postprocessing_sections_;
1223
  // Whether we have resized the signatures_ hash table.
1224
  bool resized_signatures_;
1225
  // Whether we have created a .stab*str output section.
1226
  bool have_stabstr_section_;
1227
  // In incremental build, holds information check the inputs and build the
1228
  // .gnu_incremental_inputs section.
1229
  Incremental_inputs* incremental_inputs_;
1230
  // Whether we record output section data created in script
1231
  bool record_output_section_data_from_script_;
1232
  // List of output data that needs to be removed at relaxation clean up.
1233
  Output_section_data_list script_output_section_data_list_;
1234
  // Structure to save segment states before entering the relaxation loop.
1235
  Segment_states* segment_states_;
1236
  // A relaxation debug checker.  We only create one when in debugging mode.
1237
  Relaxation_debug_check* relaxation_debug_check_;
1238
  // Hash a pattern to its position in the section ordering file.
1239
  Unordered_map<std::string, unsigned int> input_section_position_;
1240
  // Vector of glob only patterns in the section_ordering file.
1241
  std::vector<std::string> input_section_glob_;
1242
  // For incremental links, the base file to be modified.
1243
  Incremental_binary* incremental_base_;
1244
  // For incremental links, a list of free space within the file.
1245
  Free_list free_list_;
1246
};
1247
 
1248
// This task handles writing out data in output sections which is not
1249
// part of an input section, or which requires special handling.  When
1250
// this is done, it unblocks both output_sections_blocker and
1251
// final_blocker.
1252
 
1253
class Write_sections_task : public Task
1254
{
1255
 public:
1256
  Write_sections_task(const Layout* layout, Output_file* of,
1257
                      Task_token* output_sections_blocker,
1258
                      Task_token* final_blocker)
1259
    : layout_(layout), of_(of),
1260
      output_sections_blocker_(output_sections_blocker),
1261
      final_blocker_(final_blocker)
1262
  { }
1263
 
1264
  // The standard Task methods.
1265
 
1266
  Task_token*
1267
  is_runnable();
1268
 
1269
  void
1270
  locks(Task_locker*);
1271
 
1272
  void
1273
  run(Workqueue*);
1274
 
1275
  std::string
1276
  get_name() const
1277
  { return "Write_sections_task"; }
1278
 
1279
 private:
1280
  class Write_sections_locker;
1281
 
1282
  const Layout* layout_;
1283
  Output_file* of_;
1284
  Task_token* output_sections_blocker_;
1285
  Task_token* final_blocker_;
1286
};
1287
 
1288
// This task handles writing out data which is not part of a section
1289
// or segment.
1290
 
1291
class Write_data_task : public Task
1292
{
1293
 public:
1294
  Write_data_task(const Layout* layout, const Symbol_table* symtab,
1295
                  Output_file* of, Task_token* final_blocker)
1296
    : layout_(layout), symtab_(symtab), of_(of), final_blocker_(final_blocker)
1297
  { }
1298
 
1299
  // The standard Task methods.
1300
 
1301
  Task_token*
1302
  is_runnable();
1303
 
1304
  void
1305
  locks(Task_locker*);
1306
 
1307
  void
1308
  run(Workqueue*);
1309
 
1310
  std::string
1311
  get_name() const
1312
  { return "Write_data_task"; }
1313
 
1314
 private:
1315
  const Layout* layout_;
1316
  const Symbol_table* symtab_;
1317
  Output_file* of_;
1318
  Task_token* final_blocker_;
1319
};
1320
 
1321
// This task handles writing out the global symbols.
1322
 
1323
class Write_symbols_task : public Task
1324
{
1325
 public:
1326
  Write_symbols_task(const Layout* layout, const Symbol_table* symtab,
1327
                     const Input_objects* input_objects,
1328
                     const Stringpool* sympool, const Stringpool* dynpool,
1329
                     Output_file* of, Task_token* final_blocker)
1330
    : layout_(layout), symtab_(symtab), input_objects_(input_objects),
1331
      sympool_(sympool), dynpool_(dynpool), of_(of),
1332
      final_blocker_(final_blocker)
1333
  { }
1334
 
1335
  // The standard Task methods.
1336
 
1337
  Task_token*
1338
  is_runnable();
1339
 
1340
  void
1341
  locks(Task_locker*);
1342
 
1343
  void
1344
  run(Workqueue*);
1345
 
1346
  std::string
1347
  get_name() const
1348
  { return "Write_symbols_task"; }
1349
 
1350
 private:
1351
  const Layout* layout_;
1352
  const Symbol_table* symtab_;
1353
  const Input_objects* input_objects_;
1354
  const Stringpool* sympool_;
1355
  const Stringpool* dynpool_;
1356
  Output_file* of_;
1357
  Task_token* final_blocker_;
1358
};
1359
 
1360
// This task handles writing out data in output sections which can't
1361
// be written out until all the input sections have been handled.
1362
// This is for sections whose contents is based on the contents of
1363
// other output sections.
1364
 
1365
class Write_after_input_sections_task : public Task
1366
{
1367
 public:
1368
  Write_after_input_sections_task(Layout* layout, Output_file* of,
1369
                                  Task_token* input_sections_blocker,
1370
                                  Task_token* final_blocker)
1371
    : layout_(layout), of_(of),
1372
      input_sections_blocker_(input_sections_blocker),
1373
      final_blocker_(final_blocker)
1374
  { }
1375
 
1376
  // The standard Task methods.
1377
 
1378
  Task_token*
1379
  is_runnable();
1380
 
1381
  void
1382
  locks(Task_locker*);
1383
 
1384
  void
1385
  run(Workqueue*);
1386
 
1387
  std::string
1388
  get_name() const
1389
  { return "Write_after_input_sections_task"; }
1390
 
1391
 private:
1392
  Layout* layout_;
1393
  Output_file* of_;
1394
  Task_token* input_sections_blocker_;
1395
  Task_token* final_blocker_;
1396
};
1397
 
1398
// This task function handles closing the file.
1399
 
1400
class Close_task_runner : public Task_function_runner
1401
{
1402
 public:
1403
  Close_task_runner(const General_options* options, const Layout* layout,
1404
                    Output_file* of)
1405
    : options_(options), layout_(layout), of_(of)
1406
  { }
1407
 
1408
  // Run the operation.
1409
  void
1410
  run(Workqueue*, const Task*);
1411
 
1412
 private:
1413
  const General_options* options_;
1414
  const Layout* layout_;
1415
  Output_file* of_;
1416
};
1417
 
1418
// A small helper function to align an address.
1419
 
1420
inline uint64_t
1421
align_address(uint64_t address, uint64_t addralign)
1422
{
1423
  if (addralign != 0)
1424
    address = (address + addralign - 1) &~ (addralign - 1);
1425
  return address;
1426
}
1427
 
1428
} // End namespace gold.
1429
 
1430
#endif // !defined(GOLD_LAYOUT_H)

powered by: WebSVN 2.1.0

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