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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [bfd/] [elf32-avr.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* AVR-specific support for 32-bit ELF
2 225 jeremybenn
   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 24 jeremybenn
   Free Software Foundation, Inc.
4
   Contributed by Denis Chertykov <denisc@overta.ru>
5
 
6
   This file is part of BFD, the Binary File Descriptor library.
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,
21
   Boston, MA 02110-1301, USA.  */
22
 
23
#include "sysdep.h"
24
#include "bfd.h"
25
#include "libbfd.h"
26
#include "elf-bfd.h"
27
#include "elf/avr.h"
28
#include "elf32-avr.h"
29
 
30
/* Enable debugging printout at stdout with this variable.  */
31
static bfd_boolean debug_relax = FALSE;
32
 
33
/* Enable debugging printout at stdout with this variable.  */
34
static bfd_boolean debug_stubs = FALSE;
35
 
36
/* Hash table initialization and handling.  Code is taken from the hppa port
37
   and adapted to the needs of AVR.  */
38
 
39
/* We use two hash tables to hold information for linking avr objects.
40
 
41
   The first is the elf32_avr_link_hash_tablse which is derived from the
42
   stanard ELF linker hash table.  We use this as a place to attach the other
43
   hash table and some static information.
44
 
45
   The second is the stub hash table which is derived from the base BFD
46
   hash table.  The stub hash table holds the information on the linker
47
   stubs.  */
48
 
49
struct elf32_avr_stub_hash_entry
50
{
51
  /* Base hash table entry structure.  */
52
  struct bfd_hash_entry bh_root;
53
 
54
  /* Offset within stub_sec of the beginning of this stub.  */
55
  bfd_vma stub_offset;
56
 
57
  /* Given the symbol's value and its section we can determine its final
58
     value when building the stubs (so the stub knows where to jump).  */
59
  bfd_vma target_value;
60
 
61
  /* This way we could mark stubs to be no longer necessary.  */
62
  bfd_boolean is_actually_needed;
63
};
64
 
65
struct elf32_avr_link_hash_table
66
{
67
  /* The main hash table.  */
68
  struct elf_link_hash_table etab;
69
 
70
  /* The stub hash table.  */
71
  struct bfd_hash_table bstab;
72
 
73
  bfd_boolean no_stubs;
74
 
75
  /* Linker stub bfd.  */
76
  bfd *stub_bfd;
77
 
78
  /* The stub section.  */
79
  asection *stub_sec;
80
 
81
  /* Usually 0, unless we are generating code for a bootloader.  Will
82
     be initialized by elf32_avr_size_stubs to the vma offset of the
83
     output section associated with the stub section.  */
84
  bfd_vma vector_base;
85
 
86
  /* Assorted information used by elf32_avr_size_stubs.  */
87
  unsigned int        bfd_count;
88
  int                 top_index;
89
  asection **         input_list;
90
  Elf_Internal_Sym ** all_local_syms;
91
 
92
  /* Tables for mapping vma beyond the 128k boundary to the address of the
93
     corresponding stub.  (AMT)
94
     "amt_max_entry_cnt" reflects the number of entries that memory is allocated
95
     for in the "amt_stub_offsets" and "amt_destination_addr" arrays.
96
     "amt_entry_cnt" informs how many of these entries actually contain
97
     useful data.  */
98
  unsigned int amt_entry_cnt;
99
  unsigned int amt_max_entry_cnt;
100
  bfd_vma *    amt_stub_offsets;
101
  bfd_vma *    amt_destination_addr;
102
};
103
 
104
/* Various hash macros and functions.  */
105
#define avr_link_hash_table(p) \
106
  /* PR 3874: Check that we have an AVR style hash table before using it.  */\
107
  ((p)->hash->table.newfunc != elf32_avr_link_hash_newfunc ? NULL : \
108
   ((struct elf32_avr_link_hash_table *) ((p)->hash)))
109
 
110
#define avr_stub_hash_entry(ent) \
111
  ((struct elf32_avr_stub_hash_entry *)(ent))
112
 
113
#define avr_stub_hash_lookup(table, string, create, copy) \
114
  ((struct elf32_avr_stub_hash_entry *) \
115
   bfd_hash_lookup ((table), (string), (create), (copy)))
116
 
117
static reloc_howto_type elf_avr_howto_table[] =
118
{
119
  HOWTO (R_AVR_NONE,            /* type */
120
         0,                      /* rightshift */
121
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
122
         32,                    /* bitsize */
123
         FALSE,                 /* pc_relative */
124
         0,                      /* bitpos */
125
         complain_overflow_bitfield, /* complain_on_overflow */
126
         bfd_elf_generic_reloc, /* special_function */
127
         "R_AVR_NONE",          /* name */
128
         FALSE,                 /* partial_inplace */
129
         0,                      /* src_mask */
130
         0,                      /* dst_mask */
131
         FALSE),                /* pcrel_offset */
132
 
133
  HOWTO (R_AVR_32,              /* type */
134
         0,                      /* rightshift */
135
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
136
         32,                    /* bitsize */
137
         FALSE,                 /* pc_relative */
138
         0,                      /* bitpos */
139
         complain_overflow_bitfield, /* complain_on_overflow */
140
         bfd_elf_generic_reloc, /* special_function */
141
         "R_AVR_32",            /* name */
142
         FALSE,                 /* partial_inplace */
143
         0xffffffff,            /* src_mask */
144
         0xffffffff,            /* dst_mask */
145
         FALSE),                /* pcrel_offset */
146
 
147
  /* A 7 bit PC relative relocation.  */
148
  HOWTO (R_AVR_7_PCREL,         /* type */
149
         1,                     /* rightshift */
150
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
151
         7,                     /* bitsize */
152
         TRUE,                  /* pc_relative */
153
         3,                     /* bitpos */
154
         complain_overflow_bitfield, /* complain_on_overflow */
155
         bfd_elf_generic_reloc, /* special_function */
156
         "R_AVR_7_PCREL",       /* name */
157
         FALSE,                 /* partial_inplace */
158
         0xffff,                /* src_mask */
159
         0xffff,                /* dst_mask */
160
         TRUE),                 /* pcrel_offset */
161
 
162
  /* A 13 bit PC relative relocation.  */
163
  HOWTO (R_AVR_13_PCREL,        /* type */
164
         1,                     /* rightshift */
165
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
166
         13,                    /* bitsize */
167
         TRUE,                  /* pc_relative */
168
         0,                      /* bitpos */
169
         complain_overflow_bitfield, /* complain_on_overflow */
170
         bfd_elf_generic_reloc, /* special_function */
171
         "R_AVR_13_PCREL",      /* name */
172
         FALSE,                 /* partial_inplace */
173
         0xfff,                 /* src_mask */
174
         0xfff,                 /* dst_mask */
175
         TRUE),                 /* pcrel_offset */
176
 
177
  /* A 16 bit absolute relocation.  */
178
  HOWTO (R_AVR_16,              /* type */
179
         0,                      /* rightshift */
180
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
181
         16,                    /* bitsize */
182
         FALSE,                 /* pc_relative */
183
         0,                      /* bitpos */
184
         complain_overflow_dont, /* complain_on_overflow */
185
         bfd_elf_generic_reloc, /* special_function */
186
         "R_AVR_16",            /* name */
187
         FALSE,                 /* partial_inplace */
188
         0xffff,                /* src_mask */
189
         0xffff,                /* dst_mask */
190
         FALSE),                /* pcrel_offset */
191
 
192
  /* A 16 bit absolute relocation for command address
193
     Will be changed when linker stubs are needed.  */
194
  HOWTO (R_AVR_16_PM,           /* type */
195
         1,                     /* rightshift */
196
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
197
         16,                    /* bitsize */
198
         FALSE,                 /* pc_relative */
199
         0,                      /* bitpos */
200
         complain_overflow_bitfield, /* complain_on_overflow */
201
         bfd_elf_generic_reloc, /* special_function */
202
         "R_AVR_16_PM",         /* name */
203
         FALSE,                 /* partial_inplace */
204
         0xffff,                /* src_mask */
205
         0xffff,                /* dst_mask */
206
         FALSE),                /* pcrel_offset */
207
  /* A low 8 bit absolute relocation of 16 bit address.
208
     For LDI command.  */
209
  HOWTO (R_AVR_LO8_LDI,         /* type */
210
         0,                      /* rightshift */
211
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
212
         8,                     /* bitsize */
213
         FALSE,                 /* pc_relative */
214
         0,                      /* bitpos */
215
         complain_overflow_dont, /* complain_on_overflow */
216
         bfd_elf_generic_reloc, /* special_function */
217
         "R_AVR_LO8_LDI",       /* name */
218
         FALSE,                 /* partial_inplace */
219
         0xffff,                /* src_mask */
220
         0xffff,                /* dst_mask */
221
         FALSE),                /* pcrel_offset */
222
  /* A high 8 bit absolute relocation of 16 bit address.
223
     For LDI command.  */
224
  HOWTO (R_AVR_HI8_LDI,         /* type */
225
         8,                     /* rightshift */
226
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
227
         8,                     /* bitsize */
228
         FALSE,                 /* pc_relative */
229
         0,                      /* bitpos */
230
         complain_overflow_dont, /* complain_on_overflow */
231
         bfd_elf_generic_reloc, /* special_function */
232
         "R_AVR_HI8_LDI",       /* name */
233
         FALSE,                 /* partial_inplace */
234
         0xffff,                /* src_mask */
235
         0xffff,                /* dst_mask */
236
         FALSE),                /* pcrel_offset */
237
  /* A high 6 bit absolute relocation of 22 bit address.
238
     For LDI command.  As well second most significant 8 bit value of
239
     a 32 bit link-time constant.  */
240
  HOWTO (R_AVR_HH8_LDI,         /* type */
241
         16,                    /* rightshift */
242
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
243
         8,                     /* bitsize */
244
         FALSE,                 /* pc_relative */
245
         0,                      /* bitpos */
246
         complain_overflow_dont, /* complain_on_overflow */
247
         bfd_elf_generic_reloc, /* special_function */
248
         "R_AVR_HH8_LDI",       /* name */
249
         FALSE,                 /* partial_inplace */
250
         0xffff,                /* src_mask */
251
         0xffff,                /* dst_mask */
252
         FALSE),                /* pcrel_offset */
253
  /* A negative low 8 bit absolute relocation of 16 bit address.
254
     For LDI command.  */
255
  HOWTO (R_AVR_LO8_LDI_NEG,     /* type */
256
         0,                      /* rightshift */
257
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
258
         8,                     /* bitsize */
259
         FALSE,                 /* pc_relative */
260
         0,                      /* bitpos */
261
         complain_overflow_dont, /* complain_on_overflow */
262
         bfd_elf_generic_reloc, /* special_function */
263
         "R_AVR_LO8_LDI_NEG",   /* name */
264
         FALSE,                 /* partial_inplace */
265
         0xffff,                /* src_mask */
266
         0xffff,                /* dst_mask */
267
         FALSE),                /* pcrel_offset */
268
  /* A negative high 8 bit absolute relocation of 16 bit address.
269
     For LDI command.  */
270
  HOWTO (R_AVR_HI8_LDI_NEG,     /* type */
271
         8,                     /* rightshift */
272
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
273
         8,                     /* bitsize */
274
         FALSE,                 /* pc_relative */
275
         0,                      /* bitpos */
276
         complain_overflow_dont, /* complain_on_overflow */
277
         bfd_elf_generic_reloc, /* special_function */
278
         "R_AVR_HI8_LDI_NEG",   /* name */
279
         FALSE,                 /* partial_inplace */
280
         0xffff,                /* src_mask */
281
         0xffff,                /* dst_mask */
282
         FALSE),                /* pcrel_offset */
283
  /* A negative high 6 bit absolute relocation of 22 bit address.
284
     For LDI command.  */
285
  HOWTO (R_AVR_HH8_LDI_NEG,     /* type */
286
         16,                    /* rightshift */
287
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
288
         8,                     /* bitsize */
289
         FALSE,                 /* pc_relative */
290
         0,                      /* bitpos */
291
         complain_overflow_dont, /* complain_on_overflow */
292
         bfd_elf_generic_reloc, /* special_function */
293
         "R_AVR_HH8_LDI_NEG",   /* name */
294
         FALSE,                 /* partial_inplace */
295
         0xffff,                /* src_mask */
296
         0xffff,                /* dst_mask */
297
         FALSE),                /* pcrel_offset */
298
  /* A low 8 bit absolute relocation of 24 bit program memory address.
299
     For LDI command.  Will not be changed when linker stubs are needed. */
300
  HOWTO (R_AVR_LO8_LDI_PM,      /* type */
301
         1,                     /* rightshift */
302
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
303
         8,                     /* bitsize */
304
         FALSE,                 /* pc_relative */
305
         0,                      /* bitpos */
306
         complain_overflow_dont, /* complain_on_overflow */
307
         bfd_elf_generic_reloc, /* special_function */
308
         "R_AVR_LO8_LDI_PM",    /* name */
309
         FALSE,                 /* partial_inplace */
310
         0xffff,                /* src_mask */
311
         0xffff,                /* dst_mask */
312
         FALSE),                /* pcrel_offset */
313
  /* A low 8 bit absolute relocation of 24 bit program memory address.
314
     For LDI command.  Will not be changed when linker stubs are needed. */
315
  HOWTO (R_AVR_HI8_LDI_PM,      /* type */
316
         9,                     /* rightshift */
317
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
318
         8,                     /* bitsize */
319
         FALSE,                 /* pc_relative */
320
         0,                      /* bitpos */
321
         complain_overflow_dont, /* complain_on_overflow */
322
         bfd_elf_generic_reloc, /* special_function */
323
         "R_AVR_HI8_LDI_PM",    /* name */
324
         FALSE,                 /* partial_inplace */
325
         0xffff,                /* src_mask */
326
         0xffff,                /* dst_mask */
327
         FALSE),                /* pcrel_offset */
328
  /* A low 8 bit absolute relocation of 24 bit program memory address.
329
     For LDI command.  Will not be changed when linker stubs are needed. */
330
  HOWTO (R_AVR_HH8_LDI_PM,      /* type */
331
         17,                    /* rightshift */
332
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
333
         8,                     /* bitsize */
334
         FALSE,                 /* pc_relative */
335
         0,                      /* bitpos */
336
         complain_overflow_dont, /* complain_on_overflow */
337
         bfd_elf_generic_reloc, /* special_function */
338
         "R_AVR_HH8_LDI_PM",    /* name */
339
         FALSE,                 /* partial_inplace */
340
         0xffff,                /* src_mask */
341
         0xffff,                /* dst_mask */
342
         FALSE),                /* pcrel_offset */
343
  /* A low 8 bit absolute relocation of 24 bit program memory address.
344
     For LDI command.  Will not be changed when linker stubs are needed. */
345
  HOWTO (R_AVR_LO8_LDI_PM_NEG,  /* type */
346
         1,                     /* rightshift */
347
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
348
         8,                     /* bitsize */
349
         FALSE,                 /* pc_relative */
350
         0,                      /* bitpos */
351
         complain_overflow_dont, /* complain_on_overflow */
352
         bfd_elf_generic_reloc, /* special_function */
353
         "R_AVR_LO8_LDI_PM_NEG", /* name */
354
         FALSE,                 /* partial_inplace */
355
         0xffff,                /* src_mask */
356
         0xffff,                /* dst_mask */
357
         FALSE),                /* pcrel_offset */
358
  /* A low 8 bit absolute relocation of 24 bit program memory address.
359
     For LDI command.  Will not be changed when linker stubs are needed. */
360
  HOWTO (R_AVR_HI8_LDI_PM_NEG,  /* type */
361
         9,                     /* rightshift */
362
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
363
         8,                     /* bitsize */
364
         FALSE,                 /* pc_relative */
365
         0,                      /* bitpos */
366
         complain_overflow_dont, /* complain_on_overflow */
367
         bfd_elf_generic_reloc, /* special_function */
368
         "R_AVR_HI8_LDI_PM_NEG", /* name */
369
         FALSE,                 /* partial_inplace */
370
         0xffff,                /* src_mask */
371
         0xffff,                /* dst_mask */
372
         FALSE),                /* pcrel_offset */
373
  /* A low 8 bit absolute relocation of 24 bit program memory address.
374
     For LDI command.  Will not be changed when linker stubs are needed. */
375
  HOWTO (R_AVR_HH8_LDI_PM_NEG,  /* type */
376
         17,                    /* rightshift */
377
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
378
         8,                     /* bitsize */
379
         FALSE,                 /* pc_relative */
380
         0,                      /* bitpos */
381
         complain_overflow_dont, /* complain_on_overflow */
382
         bfd_elf_generic_reloc, /* special_function */
383
         "R_AVR_HH8_LDI_PM_NEG", /* name */
384
         FALSE,                 /* partial_inplace */
385
         0xffff,                /* src_mask */
386
         0xffff,                /* dst_mask */
387
         FALSE),                /* pcrel_offset */
388
  /* Relocation for CALL command in ATmega.  */
389
  HOWTO (R_AVR_CALL,            /* type */
390
         1,                     /* rightshift */
391
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
392
         23,                    /* bitsize */
393
         FALSE,                 /* pc_relative */
394
         0,                      /* bitpos */
395
         complain_overflow_dont,/* complain_on_overflow */
396
         bfd_elf_generic_reloc, /* special_function */
397
         "R_AVR_CALL",          /* name */
398
         FALSE,                 /* partial_inplace */
399
         0xffffffff,            /* src_mask */
400
         0xffffffff,            /* dst_mask */
401
         FALSE),                        /* pcrel_offset */
402
  /* A 16 bit absolute relocation of 16 bit address.
403
     For LDI command.  */
404
  HOWTO (R_AVR_LDI,             /* type */
405
         0,                      /* rightshift */
406
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
407
         16,                    /* bitsize */
408
         FALSE,                 /* pc_relative */
409
         0,                      /* bitpos */
410
         complain_overflow_dont,/* complain_on_overflow */
411
         bfd_elf_generic_reloc, /* special_function */
412
         "R_AVR_LDI",           /* name */
413
         FALSE,                 /* partial_inplace */
414
         0xffff,                /* src_mask */
415
         0xffff,                /* dst_mask */
416
         FALSE),                /* pcrel_offset */
417
  /* A 6 bit absolute relocation of 6 bit offset.
418
     For ldd/sdd command.  */
419
  HOWTO (R_AVR_6,               /* type */
420
         0,                      /* rightshift */
421
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
422
         6,                     /* bitsize */
423
         FALSE,                 /* pc_relative */
424
         0,                      /* bitpos */
425
         complain_overflow_dont,/* complain_on_overflow */
426
         bfd_elf_generic_reloc, /* special_function */
427
         "R_AVR_6",             /* name */
428
         FALSE,                 /* partial_inplace */
429
         0xffff,                /* src_mask */
430
         0xffff,                /* dst_mask */
431
         FALSE),                /* pcrel_offset */
432
  /* A 6 bit absolute relocation of 6 bit offset.
433
     For sbiw/adiw command.  */
434
  HOWTO (R_AVR_6_ADIW,          /* type */
435
         0,                      /* rightshift */
436
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
437
         6,                     /* bitsize */
438
         FALSE,                 /* pc_relative */
439
         0,                      /* bitpos */
440
         complain_overflow_dont,/* complain_on_overflow */
441
         bfd_elf_generic_reloc, /* special_function */
442
         "R_AVR_6_ADIW",        /* name */
443
         FALSE,                 /* partial_inplace */
444
         0xffff,                /* src_mask */
445
         0xffff,                /* dst_mask */
446
         FALSE),                /* pcrel_offset */
447
  /* Most significant 8 bit value of a 32 bit link-time constant.  */
448
  HOWTO (R_AVR_MS8_LDI,         /* type */
449
         24,                    /* rightshift */
450
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
451
         8,                     /* bitsize */
452
         FALSE,                 /* pc_relative */
453
         0,                      /* bitpos */
454
         complain_overflow_dont, /* complain_on_overflow */
455
         bfd_elf_generic_reloc, /* special_function */
456
         "R_AVR_MS8_LDI",       /* name */
457
         FALSE,                 /* partial_inplace */
458
         0xffff,                /* src_mask */
459
         0xffff,                /* dst_mask */
460
         FALSE),                /* pcrel_offset */
461
  /* Negative most significant 8 bit value of a 32 bit link-time constant.  */
462
  HOWTO (R_AVR_MS8_LDI_NEG,     /* type */
463
         24,                    /* rightshift */
464
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
465
         8,                     /* bitsize */
466
         FALSE,                 /* pc_relative */
467
         0,                      /* bitpos */
468
         complain_overflow_dont, /* complain_on_overflow */
469
         bfd_elf_generic_reloc, /* special_function */
470
         "R_AVR_MS8_LDI_NEG",   /* name */
471
         FALSE,                 /* partial_inplace */
472
         0xffff,                /* src_mask */
473
         0xffff,                /* dst_mask */
474
         FALSE),                /* pcrel_offset */
475
  /* A low 8 bit absolute relocation of 24 bit program memory address.
476
     For LDI command.  Will be changed when linker stubs are needed. */
477
  HOWTO (R_AVR_LO8_LDI_GS,      /* type */
478
         1,                     /* rightshift */
479
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
480
         8,                     /* bitsize */
481
         FALSE,                 /* pc_relative */
482
         0,                     /* bitpos */
483
         complain_overflow_dont, /* complain_on_overflow */
484
         bfd_elf_generic_reloc, /* special_function */
485
         "R_AVR_LO8_LDI_GS",    /* name */
486
         FALSE,                 /* partial_inplace */
487
         0xffff,                /* src_mask */
488
         0xffff,                /* dst_mask */
489
         FALSE),                /* pcrel_offset */
490
  /* A low 8 bit absolute relocation of 24 bit program memory address.
491
     For LDI command.  Will be changed when linker stubs are needed. */
492
  HOWTO (R_AVR_HI8_LDI_GS,      /* type */
493
         9,                     /* rightshift */
494
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
495
         8,                     /* bitsize */
496
         FALSE,                 /* pc_relative */
497
         0,                     /* bitpos */
498
         complain_overflow_dont, /* complain_on_overflow */
499
         bfd_elf_generic_reloc, /* special_function */
500
         "R_AVR_HI8_LDI_GS",    /* name */
501
         FALSE,                 /* partial_inplace */
502
         0xffff,                /* src_mask */
503
         0xffff,                /* dst_mask */
504
         FALSE)                 /* pcrel_offset */
505
};
506
 
507
/* Map BFD reloc types to AVR ELF reloc types.  */
508
 
509
struct avr_reloc_map
510
{
511
  bfd_reloc_code_real_type bfd_reloc_val;
512
  unsigned int elf_reloc_val;
513
};
514
 
515
static const struct avr_reloc_map avr_reloc_map[] =
516
{
517
  { BFD_RELOC_NONE,                 R_AVR_NONE },
518
  { BFD_RELOC_32,                   R_AVR_32 },
519
  { BFD_RELOC_AVR_7_PCREL,          R_AVR_7_PCREL },
520
  { BFD_RELOC_AVR_13_PCREL,         R_AVR_13_PCREL },
521
  { BFD_RELOC_16,                   R_AVR_16 },
522
  { BFD_RELOC_AVR_16_PM,            R_AVR_16_PM },
523
  { BFD_RELOC_AVR_LO8_LDI,          R_AVR_LO8_LDI},
524
  { BFD_RELOC_AVR_HI8_LDI,          R_AVR_HI8_LDI },
525
  { BFD_RELOC_AVR_HH8_LDI,          R_AVR_HH8_LDI },
526
  { BFD_RELOC_AVR_MS8_LDI,          R_AVR_MS8_LDI },
527
  { BFD_RELOC_AVR_LO8_LDI_NEG,      R_AVR_LO8_LDI_NEG },
528
  { BFD_RELOC_AVR_HI8_LDI_NEG,      R_AVR_HI8_LDI_NEG },
529
  { BFD_RELOC_AVR_HH8_LDI_NEG,      R_AVR_HH8_LDI_NEG },
530
  { BFD_RELOC_AVR_MS8_LDI_NEG,      R_AVR_MS8_LDI_NEG },
531
  { BFD_RELOC_AVR_LO8_LDI_PM,       R_AVR_LO8_LDI_PM },
532
  { BFD_RELOC_AVR_LO8_LDI_GS,       R_AVR_LO8_LDI_GS },
533
  { BFD_RELOC_AVR_HI8_LDI_PM,       R_AVR_HI8_LDI_PM },
534
  { BFD_RELOC_AVR_HI8_LDI_GS,       R_AVR_HI8_LDI_GS },
535
  { BFD_RELOC_AVR_HH8_LDI_PM,       R_AVR_HH8_LDI_PM },
536
  { BFD_RELOC_AVR_LO8_LDI_PM_NEG,   R_AVR_LO8_LDI_PM_NEG },
537
  { BFD_RELOC_AVR_HI8_LDI_PM_NEG,   R_AVR_HI8_LDI_PM_NEG },
538
  { BFD_RELOC_AVR_HH8_LDI_PM_NEG,   R_AVR_HH8_LDI_PM_NEG },
539
  { BFD_RELOC_AVR_CALL,             R_AVR_CALL },
540
  { BFD_RELOC_AVR_LDI,              R_AVR_LDI  },
541
  { BFD_RELOC_AVR_6,                R_AVR_6    },
542
  { BFD_RELOC_AVR_6_ADIW,           R_AVR_6_ADIW }
543
};
544
 
545
/* Meant to be filled one day with the wrap around address for the
546
   specific device.  I.e. should get the value 0x4000 for 16k devices,
547
   0x8000 for 32k devices and so on.
548
 
549
   We initialize it here with a value of 0x1000000 resulting in
550
   that we will never suggest a wrap-around jump during relaxation.
551
   The logic of the source code later on assumes that in
552
   avr_pc_wrap_around one single bit is set.  */
553
static bfd_vma avr_pc_wrap_around = 0x10000000;
554
 
555
/* If this variable holds a value different from zero, the linker relaxation
556
   machine will try to optimize call/ret sequences by a single jump
557
   instruction. This option could be switched off by a linker switch.  */
558
static int avr_replace_call_ret_sequences = 1;
559
 
560
/* Initialize an entry in the stub hash table.  */
561
 
562
static struct bfd_hash_entry *
563
stub_hash_newfunc (struct bfd_hash_entry *entry,
564
                   struct bfd_hash_table *table,
565
                   const char *string)
566
{
567
  /* Allocate the structure if it has not already been allocated by a
568
     subclass.  */
569
  if (entry == NULL)
570
    {
571
      entry = bfd_hash_allocate (table,
572
                                 sizeof (struct elf32_avr_stub_hash_entry));
573
      if (entry == NULL)
574
        return entry;
575
    }
576
 
577
  /* Call the allocation method of the superclass.  */
578
  entry = bfd_hash_newfunc (entry, table, string);
579
  if (entry != NULL)
580
    {
581
      struct elf32_avr_stub_hash_entry *hsh;
582
 
583
      /* Initialize the local fields.  */
584
      hsh = avr_stub_hash_entry (entry);
585
      hsh->stub_offset = 0;
586
      hsh->target_value = 0;
587
    }
588
 
589
  return entry;
590
}
591
 
592
/* This function is just a straight passthrough to the real
593
   function in linker.c.  Its prupose is so that its address
594
   can be compared inside the avr_link_hash_table macro.  */
595
 
596
static struct bfd_hash_entry *
597
elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
598
                             struct bfd_hash_table * table,
599
                             const char * string)
600
{
601
  return _bfd_elf_link_hash_newfunc (entry, table, string);
602
}
603
 
604
/* Create the derived linker hash table.  The AVR ELF port uses the derived
605
   hash table to keep information specific to the AVR ELF linker (without
606
   using static variables).  */
607
 
608
static struct bfd_link_hash_table *
609
elf32_avr_link_hash_table_create (bfd *abfd)
610
{
611
  struct elf32_avr_link_hash_table *htab;
612
  bfd_size_type amt = sizeof (*htab);
613
 
614
  htab = bfd_malloc (amt);
615
  if (htab == NULL)
616
    return NULL;
617
 
618
  if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
619
                                      elf32_avr_link_hash_newfunc,
620
                                      sizeof (struct elf_link_hash_entry)))
621
    {
622
      free (htab);
623
      return NULL;
624
    }
625
 
626
  /* Init the stub hash table too.  */
627
  if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
628
                            sizeof (struct elf32_avr_stub_hash_entry)))
629
    return NULL;
630
 
631
  htab->stub_bfd = NULL;
632
  htab->stub_sec = NULL;
633
 
634
  /* Initialize the address mapping table.  */
635
  htab->amt_stub_offsets = NULL;
636
  htab->amt_destination_addr = NULL;
637
  htab->amt_entry_cnt = 0;
638
  htab->amt_max_entry_cnt = 0;
639
 
640
  return &htab->etab.root;
641
}
642
 
643
/* Free the derived linker hash table.  */
644
 
645
static void
646
elf32_avr_link_hash_table_free (struct bfd_link_hash_table *btab)
647
{
648
  struct elf32_avr_link_hash_table *htab
649
    = (struct elf32_avr_link_hash_table *) btab;
650
 
651
  /* Free the address mapping table.  */
652
  if (htab->amt_stub_offsets != NULL)
653
    free (htab->amt_stub_offsets);
654
  if (htab->amt_destination_addr != NULL)
655
    free (htab->amt_destination_addr);
656
 
657
  bfd_hash_table_free (&htab->bstab);
658
  _bfd_generic_link_hash_table_free (btab);
659
}
660
 
661
/* Calculates the effective distance of a pc relative jump/call.  */
662
 
663
static int
664
avr_relative_distance_considering_wrap_around (unsigned int distance)
665
{
666
  unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
667
  int dist_with_wrap_around = distance & wrap_around_mask;
668
 
669
  if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
670
    dist_with_wrap_around -= avr_pc_wrap_around;
671
 
672
  return dist_with_wrap_around;
673
}
674
 
675
 
676
static reloc_howto_type *
677
bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
678
                                 bfd_reloc_code_real_type code)
679
{
680
  unsigned int i;
681
 
682
  for (i = 0;
683
       i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
684
       i++)
685
    if (avr_reloc_map[i].bfd_reloc_val == code)
686
      return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
687
 
688
  return NULL;
689
}
690
 
691
static reloc_howto_type *
692
bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
693
                                 const char *r_name)
694
{
695
  unsigned int i;
696
 
697
  for (i = 0;
698
       i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
699
       i++)
700
    if (elf_avr_howto_table[i].name != NULL
701
        && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
702
      return &elf_avr_howto_table[i];
703
 
704
  return NULL;
705
}
706
 
707
/* Set the howto pointer for an AVR ELF reloc.  */
708
 
709
static void
710
avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
711
                        arelent *cache_ptr,
712
                        Elf_Internal_Rela *dst)
713
{
714
  unsigned int r_type;
715
 
716
  r_type = ELF32_R_TYPE (dst->r_info);
717
  BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
718
  cache_ptr->howto = &elf_avr_howto_table[r_type];
719
}
720
 
721
/* Look through the relocs for a section during the first phase.
722
   Since we don't do .gots or .plts, we just need to consider the
723
   virtual table relocs for gc.  */
724
 
725
static bfd_boolean
726
elf32_avr_check_relocs (bfd *abfd,
727
                        struct bfd_link_info *info,
728
                        asection *sec,
729
                        const Elf_Internal_Rela *relocs)
730
{
731
  Elf_Internal_Shdr *symtab_hdr;
732
  struct elf_link_hash_entry **sym_hashes;
733
  const Elf_Internal_Rela *rel;
734
  const Elf_Internal_Rela *rel_end;
735
 
736
  if (info->relocatable)
737
    return TRUE;
738
 
739
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
740
  sym_hashes = elf_sym_hashes (abfd);
741
 
742
  rel_end = relocs + sec->reloc_count;
743
  for (rel = relocs; rel < rel_end; rel++)
744
    {
745
      struct elf_link_hash_entry *h;
746
      unsigned long r_symndx;
747
 
748
      r_symndx = ELF32_R_SYM (rel->r_info);
749
      if (r_symndx < symtab_hdr->sh_info)
750
        h = NULL;
751
      else
752
        {
753
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
754
          while (h->root.type == bfd_link_hash_indirect
755
                 || h->root.type == bfd_link_hash_warning)
756
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
757
        }
758
    }
759
 
760
  return TRUE;
761
}
762
 
763
static bfd_boolean
764
avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
765
{
766
  return (relocation >= 0x020000);
767
}
768
 
769
/* Returns the address of the corresponding stub if there is one.
770
   Returns otherwise an address above 0x020000.  This function
771
   could also be used, if there is no knowledge on the section where
772
   the destination is found.  */
773
 
774
static bfd_vma
775
avr_get_stub_addr (bfd_vma srel,
776
                   struct elf32_avr_link_hash_table *htab)
777
{
778
  unsigned int index;
779
  bfd_vma stub_sec_addr =
780
              (htab->stub_sec->output_section->vma +
781
               htab->stub_sec->output_offset);
782
 
783
  for (index = 0; index < htab->amt_max_entry_cnt; index ++)
784
    if (htab->amt_destination_addr[index] == srel)
785
      return htab->amt_stub_offsets[index] + stub_sec_addr;
786
 
787
  /* Return an address that could not be reached by 16 bit relocs.  */
788
  return 0x020000;
789
}
790
 
791
/* Perform a single relocation.  By default we use the standard BFD
792
   routines, but a few relocs, we have to do them ourselves.  */
793
 
794
static bfd_reloc_status_type
795
avr_final_link_relocate (reloc_howto_type *                 howto,
796
                         bfd *                              input_bfd,
797
                         asection *                         input_section,
798
                         bfd_byte *                         contents,
799
                         Elf_Internal_Rela *                rel,
800
                         bfd_vma                            relocation,
801
                         struct elf32_avr_link_hash_table * htab)
802
{
803
  bfd_reloc_status_type r = bfd_reloc_ok;
804
  bfd_vma               x;
805
  bfd_signed_vma        srel;
806
  bfd_signed_vma        reloc_addr;
807
  bfd_boolean           use_stubs = FALSE;
808
  /* Usually is 0, unless we are generating code for a bootloader.  */
809
  bfd_signed_vma        base_addr = htab->vector_base;
810
 
811
  /* Absolute addr of the reloc in the final excecutable.  */
812
  reloc_addr = rel->r_offset + input_section->output_section->vma
813
               + input_section->output_offset;
814
 
815
  switch (howto->type)
816
    {
817
    case R_AVR_7_PCREL:
818
      contents += rel->r_offset;
819
      srel = (bfd_signed_vma) relocation;
820
      srel += rel->r_addend;
821
      srel -= rel->r_offset;
822
      srel -= 2;        /* Branch instructions add 2 to the PC...  */
823
      srel -= (input_section->output_section->vma +
824
               input_section->output_offset);
825
 
826
      if (srel & 1)
827
        return bfd_reloc_outofrange;
828
      if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
829
        return bfd_reloc_overflow;
830
      x = bfd_get_16 (input_bfd, contents);
831
      x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
832
      bfd_put_16 (input_bfd, x, contents);
833
      break;
834
 
835
    case R_AVR_13_PCREL:
836
      contents   += rel->r_offset;
837
      srel = (bfd_signed_vma) relocation;
838
      srel += rel->r_addend;
839
      srel -= rel->r_offset;
840
      srel -= 2;        /* Branch instructions add 2 to the PC...  */
841
      srel -= (input_section->output_section->vma +
842
               input_section->output_offset);
843
 
844
      if (srel & 1)
845
        return bfd_reloc_outofrange;
846
 
847
      srel = avr_relative_distance_considering_wrap_around (srel);
848
 
849
      /* AVR addresses commands as words.  */
850
      srel >>= 1;
851
 
852
      /* Check for overflow.  */
853
      if (srel < -2048 || srel > 2047)
854
        {
855
          /* Relative distance is too large.  */
856
 
857 225 jeremybenn
          /* Always apply WRAPAROUND for avr2, avr25, and avr4.  */
858 24 jeremybenn
          switch (bfd_get_mach (input_bfd))
859
            {
860
            case bfd_mach_avr2:
861 225 jeremybenn
            case bfd_mach_avr25:
862 24 jeremybenn
            case bfd_mach_avr4:
863
              break;
864
 
865
            default:
866
              return bfd_reloc_overflow;
867
            }
868
        }
869
 
870
      x = bfd_get_16 (input_bfd, contents);
871
      x = (x & 0xf000) | (srel & 0xfff);
872
      bfd_put_16 (input_bfd, x, contents);
873
      break;
874
 
875
    case R_AVR_LO8_LDI:
876
      contents += rel->r_offset;
877
      srel = (bfd_signed_vma) relocation + rel->r_addend;
878
      x = bfd_get_16 (input_bfd, contents);
879
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
880
      bfd_put_16 (input_bfd, x, contents);
881
      break;
882
 
883
    case R_AVR_LDI:
884
      contents += rel->r_offset;
885
      srel = (bfd_signed_vma) relocation + rel->r_addend;
886
      if (((srel > 0) && (srel & 0xffff) > 255)
887
          || ((srel < 0) && ((-srel) & 0xffff) > 128))
888
        /* Remove offset for data/eeprom section.  */
889
        return bfd_reloc_overflow;
890
 
891
      x = bfd_get_16 (input_bfd, contents);
892
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
893
      bfd_put_16 (input_bfd, x, contents);
894
      break;
895
 
896
    case R_AVR_6:
897
      contents += rel->r_offset;
898
      srel = (bfd_signed_vma) relocation + rel->r_addend;
899
      if (((srel & 0xffff) > 63) || (srel < 0))
900
        /* Remove offset for data/eeprom section.  */
901
        return bfd_reloc_overflow;
902
      x = bfd_get_16 (input_bfd, contents);
903
      x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
904
                       | ((srel & (1 << 5)) << 8));
905
      bfd_put_16 (input_bfd, x, contents);
906
      break;
907
 
908
    case R_AVR_6_ADIW:
909
      contents += rel->r_offset;
910
      srel = (bfd_signed_vma) relocation + rel->r_addend;
911
      if (((srel & 0xffff) > 63) || (srel < 0))
912
        /* Remove offset for data/eeprom section.  */
913
        return bfd_reloc_overflow;
914
      x = bfd_get_16 (input_bfd, contents);
915
      x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
916
      bfd_put_16 (input_bfd, x, contents);
917
      break;
918
 
919
    case R_AVR_HI8_LDI:
920
      contents += rel->r_offset;
921
      srel = (bfd_signed_vma) relocation + rel->r_addend;
922
      srel = (srel >> 8) & 0xff;
923
      x = bfd_get_16 (input_bfd, contents);
924
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
925
      bfd_put_16 (input_bfd, x, contents);
926
      break;
927
 
928
    case R_AVR_HH8_LDI:
929
      contents += rel->r_offset;
930
      srel = (bfd_signed_vma) relocation + rel->r_addend;
931
      srel = (srel >> 16) & 0xff;
932
      x = bfd_get_16 (input_bfd, contents);
933
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
934
      bfd_put_16 (input_bfd, x, contents);
935
      break;
936
 
937
    case R_AVR_MS8_LDI:
938
      contents += rel->r_offset;
939
      srel = (bfd_signed_vma) relocation + rel->r_addend;
940
      srel = (srel >> 24) & 0xff;
941
      x = bfd_get_16 (input_bfd, contents);
942
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
943
      bfd_put_16 (input_bfd, x, contents);
944
      break;
945
 
946
    case R_AVR_LO8_LDI_NEG:
947
      contents += rel->r_offset;
948
      srel = (bfd_signed_vma) relocation + rel->r_addend;
949
      srel = -srel;
950
      x = bfd_get_16 (input_bfd, contents);
951
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
952
      bfd_put_16 (input_bfd, x, contents);
953
      break;
954
 
955
    case R_AVR_HI8_LDI_NEG:
956
      contents += rel->r_offset;
957
      srel = (bfd_signed_vma) relocation + rel->r_addend;
958
      srel = -srel;
959
      srel = (srel >> 8) & 0xff;
960
      x = bfd_get_16 (input_bfd, contents);
961
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
962
      bfd_put_16 (input_bfd, x, contents);
963
      break;
964
 
965
    case R_AVR_HH8_LDI_NEG:
966
      contents += rel->r_offset;
967
      srel = (bfd_signed_vma) relocation + rel->r_addend;
968
      srel = -srel;
969
      srel = (srel >> 16) & 0xff;
970
      x = bfd_get_16 (input_bfd, contents);
971
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
972
      bfd_put_16 (input_bfd, x, contents);
973
      break;
974
 
975
    case R_AVR_MS8_LDI_NEG:
976
      contents += rel->r_offset;
977
      srel = (bfd_signed_vma) relocation + rel->r_addend;
978
      srel = -srel;
979
      srel = (srel >> 24) & 0xff;
980
      x = bfd_get_16 (input_bfd, contents);
981
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
982
      bfd_put_16 (input_bfd, x, contents);
983
      break;
984
 
985
    case R_AVR_LO8_LDI_GS:
986
      use_stubs = (!htab->no_stubs);
987
      /* Fall through.  */
988
    case R_AVR_LO8_LDI_PM:
989
      contents += rel->r_offset;
990
      srel = (bfd_signed_vma) relocation + rel->r_addend;
991
 
992
      if (use_stubs
993
          && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
994
        {
995
          bfd_vma old_srel = srel;
996
 
997
          /* We need to use the address of the stub instead.  */
998
          srel = avr_get_stub_addr (srel, htab);
999
          if (debug_stubs)
1000
            printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1001
                    "reloc at address 0x%x.\n",
1002
                    (unsigned int) srel,
1003
                    (unsigned int) old_srel,
1004
                    (unsigned int) reloc_addr);
1005
 
1006
          if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1007
            return bfd_reloc_outofrange;
1008
        }
1009
 
1010
      if (srel & 1)
1011
        return bfd_reloc_outofrange;
1012
      srel = srel >> 1;
1013
      x = bfd_get_16 (input_bfd, contents);
1014
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1015
      bfd_put_16 (input_bfd, x, contents);
1016
      break;
1017
 
1018
    case R_AVR_HI8_LDI_GS:
1019
      use_stubs = (!htab->no_stubs);
1020
      /* Fall through.  */
1021
    case R_AVR_HI8_LDI_PM:
1022
      contents += rel->r_offset;
1023
      srel = (bfd_signed_vma) relocation + rel->r_addend;
1024
 
1025
      if (use_stubs
1026
          && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1027
        {
1028
          bfd_vma old_srel = srel;
1029
 
1030
          /* We need to use the address of the stub instead.  */
1031
          srel = avr_get_stub_addr (srel, htab);
1032
          if (debug_stubs)
1033
            printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1034
                    "reloc at address 0x%x.\n",
1035
                    (unsigned int) srel,
1036
                    (unsigned int) old_srel,
1037
                    (unsigned int) reloc_addr);
1038
 
1039
          if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1040
            return bfd_reloc_outofrange;
1041
        }
1042
 
1043
      if (srel & 1)
1044
        return bfd_reloc_outofrange;
1045
      srel = srel >> 1;
1046
      srel = (srel >> 8) & 0xff;
1047
      x = bfd_get_16 (input_bfd, contents);
1048
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1049
      bfd_put_16 (input_bfd, x, contents);
1050
      break;
1051
 
1052
    case R_AVR_HH8_LDI_PM:
1053
      contents += rel->r_offset;
1054
      srel = (bfd_signed_vma) relocation + rel->r_addend;
1055
      if (srel & 1)
1056
        return bfd_reloc_outofrange;
1057
      srel = srel >> 1;
1058
      srel = (srel >> 16) & 0xff;
1059
      x = bfd_get_16 (input_bfd, contents);
1060
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1061
      bfd_put_16 (input_bfd, x, contents);
1062
      break;
1063
 
1064
    case R_AVR_LO8_LDI_PM_NEG:
1065
      contents += rel->r_offset;
1066
      srel = (bfd_signed_vma) relocation + rel->r_addend;
1067
      srel = -srel;
1068
      if (srel & 1)
1069
        return bfd_reloc_outofrange;
1070
      srel = srel >> 1;
1071
      x = bfd_get_16 (input_bfd, contents);
1072
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1073
      bfd_put_16 (input_bfd, x, contents);
1074
      break;
1075
 
1076
    case R_AVR_HI8_LDI_PM_NEG:
1077
      contents += rel->r_offset;
1078
      srel = (bfd_signed_vma) relocation + rel->r_addend;
1079
      srel = -srel;
1080
      if (srel & 1)
1081
        return bfd_reloc_outofrange;
1082
      srel = srel >> 1;
1083
      srel = (srel >> 8) & 0xff;
1084
      x = bfd_get_16 (input_bfd, contents);
1085
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1086
      bfd_put_16 (input_bfd, x, contents);
1087
      break;
1088
 
1089
    case R_AVR_HH8_LDI_PM_NEG:
1090
      contents += rel->r_offset;
1091
      srel = (bfd_signed_vma) relocation + rel->r_addend;
1092
      srel = -srel;
1093
      if (srel & 1)
1094
        return bfd_reloc_outofrange;
1095
      srel = srel >> 1;
1096
      srel = (srel >> 16) & 0xff;
1097
      x = bfd_get_16 (input_bfd, contents);
1098
      x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1099
      bfd_put_16 (input_bfd, x, contents);
1100
      break;
1101
 
1102
    case R_AVR_CALL:
1103
      contents += rel->r_offset;
1104
      srel = (bfd_signed_vma) relocation + rel->r_addend;
1105
      if (srel & 1)
1106
        return bfd_reloc_outofrange;
1107
      srel = srel >> 1;
1108
      x = bfd_get_16 (input_bfd, contents);
1109
      x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1110
      bfd_put_16 (input_bfd, x, contents);
1111
      bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1112
      break;
1113
 
1114
    case R_AVR_16_PM:
1115
      use_stubs = (!htab->no_stubs);
1116
      contents += rel->r_offset;
1117
      srel = (bfd_signed_vma) relocation + rel->r_addend;
1118
 
1119
      if (use_stubs
1120
          && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1121
        {
1122
          bfd_vma old_srel = srel;
1123
 
1124
          /* We need to use the address of the stub instead.  */
1125
          srel = avr_get_stub_addr (srel,htab);
1126
          if (debug_stubs)
1127
            printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1128
                    "reloc at address 0x%x.\n",
1129
                    (unsigned int) srel,
1130
                    (unsigned int) old_srel,
1131
                    (unsigned int) reloc_addr);
1132
 
1133
          if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1134
            return bfd_reloc_outofrange;
1135
        }
1136
 
1137
      if (srel & 1)
1138
        return bfd_reloc_outofrange;
1139
      srel = srel >> 1;
1140
      bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1141
      break;
1142
 
1143
    default:
1144
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1145
                                    contents, rel->r_offset,
1146
                                    relocation, rel->r_addend);
1147
    }
1148
 
1149
  return r;
1150
}
1151
 
1152
/* Relocate an AVR ELF section.  */
1153
 
1154
static bfd_boolean
1155
elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1156
                            struct bfd_link_info *info,
1157
                            bfd *input_bfd,
1158
                            asection *input_section,
1159
                            bfd_byte *contents,
1160
                            Elf_Internal_Rela *relocs,
1161
                            Elf_Internal_Sym *local_syms,
1162
                            asection **local_sections)
1163
{
1164
  Elf_Internal_Shdr *           symtab_hdr;
1165
  struct elf_link_hash_entry ** sym_hashes;
1166
  Elf_Internal_Rela *           rel;
1167
  Elf_Internal_Rela *           relend;
1168
  struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1169
 
1170
  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1171
  sym_hashes = elf_sym_hashes (input_bfd);
1172
  relend     = relocs + input_section->reloc_count;
1173
 
1174
  for (rel = relocs; rel < relend; rel ++)
1175
    {
1176
      reloc_howto_type *           howto;
1177
      unsigned long                r_symndx;
1178
      Elf_Internal_Sym *           sym;
1179
      asection *                   sec;
1180
      struct elf_link_hash_entry * h;
1181
      bfd_vma                      relocation;
1182
      bfd_reloc_status_type        r;
1183
      const char *                 name;
1184
      int                          r_type;
1185
 
1186
      r_type = ELF32_R_TYPE (rel->r_info);
1187
      r_symndx = ELF32_R_SYM (rel->r_info);
1188
      howto  = elf_avr_howto_table + ELF32_R_TYPE (rel->r_info);
1189
      h      = NULL;
1190
      sym    = NULL;
1191
      sec    = NULL;
1192
 
1193
      if (r_symndx < symtab_hdr->sh_info)
1194
        {
1195
          sym = local_syms + r_symndx;
1196
          sec = local_sections [r_symndx];
1197
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1198
 
1199
          name = bfd_elf_string_from_elf_section
1200
            (input_bfd, symtab_hdr->sh_link, sym->st_name);
1201
          name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1202
        }
1203
      else
1204
        {
1205
          bfd_boolean unresolved_reloc, warned;
1206
 
1207
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1208
                                   r_symndx, symtab_hdr, sym_hashes,
1209
                                   h, sec, relocation,
1210
                                   unresolved_reloc, warned);
1211
 
1212
          name = h->root.root.string;
1213
        }
1214
 
1215
      if (sec != NULL && elf_discarded_section (sec))
1216
        {
1217
          /* For relocs against symbols from removed linkonce sections,
1218
             or sections discarded by a linker script, we just want the
1219
             section contents zeroed.  Avoid any special processing.  */
1220
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1221
          rel->r_info = 0;
1222
          rel->r_addend = 0;
1223
          continue;
1224
        }
1225
 
1226
      if (info->relocatable)
1227
        continue;
1228
 
1229
      r = avr_final_link_relocate (howto, input_bfd, input_section,
1230
                                   contents, rel, relocation, htab);
1231
 
1232
      if (r != bfd_reloc_ok)
1233
        {
1234
          const char * msg = (const char *) NULL;
1235
 
1236
          switch (r)
1237
            {
1238
            case bfd_reloc_overflow:
1239
              r = info->callbacks->reloc_overflow
1240
                (info, (h ? &h->root : NULL),
1241
                 name, howto->name, (bfd_vma) 0,
1242
                 input_bfd, input_section, rel->r_offset);
1243
              break;
1244
 
1245
            case bfd_reloc_undefined:
1246
              r = info->callbacks->undefined_symbol
1247
                (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1248
              break;
1249
 
1250
            case bfd_reloc_outofrange:
1251
              msg = _("internal error: out of range error");
1252
              break;
1253
 
1254
            case bfd_reloc_notsupported:
1255
              msg = _("internal error: unsupported relocation error");
1256
              break;
1257
 
1258
            case bfd_reloc_dangerous:
1259
              msg = _("internal error: dangerous relocation");
1260
              break;
1261
 
1262
            default:
1263
              msg = _("internal error: unknown error");
1264
              break;
1265
            }
1266
 
1267
          if (msg)
1268
            r = info->callbacks->warning
1269
              (info, msg, name, input_bfd, input_section, rel->r_offset);
1270
 
1271
          if (! r)
1272
            return FALSE;
1273
        }
1274
    }
1275
 
1276
  return TRUE;
1277
}
1278
 
1279
/* The final processing done just before writing out a AVR ELF object
1280
   file.  This gets the AVR architecture right based on the machine
1281
   number.  */
1282
 
1283
static void
1284
bfd_elf_avr_final_write_processing (bfd *abfd,
1285
                                    bfd_boolean linker ATTRIBUTE_UNUSED)
1286
{
1287
  unsigned long val;
1288
 
1289
  switch (bfd_get_mach (abfd))
1290
    {
1291
    default:
1292
    case bfd_mach_avr2:
1293
      val = E_AVR_MACH_AVR2;
1294
      break;
1295
 
1296
    case bfd_mach_avr1:
1297
      val = E_AVR_MACH_AVR1;
1298
      break;
1299
 
1300 225 jeremybenn
    case bfd_mach_avr25:
1301
      val = E_AVR_MACH_AVR25;
1302
      break;
1303
 
1304 24 jeremybenn
    case bfd_mach_avr3:
1305
      val = E_AVR_MACH_AVR3;
1306
      break;
1307
 
1308 225 jeremybenn
    case bfd_mach_avr31:
1309
      val = E_AVR_MACH_AVR31;
1310
      break;
1311
 
1312
    case bfd_mach_avr35:
1313
      val = E_AVR_MACH_AVR35;
1314
      break;
1315
 
1316 24 jeremybenn
    case bfd_mach_avr4:
1317
      val = E_AVR_MACH_AVR4;
1318
      break;
1319
 
1320
    case bfd_mach_avr5:
1321
      val = E_AVR_MACH_AVR5;
1322
      break;
1323
 
1324 225 jeremybenn
    case bfd_mach_avr51:
1325
      val = E_AVR_MACH_AVR51;
1326
      break;
1327
 
1328 24 jeremybenn
    case bfd_mach_avr6:
1329
      val = E_AVR_MACH_AVR6;
1330
      break;
1331
    }
1332
 
1333
  elf_elfheader (abfd)->e_machine = EM_AVR;
1334
  elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1335
  elf_elfheader (abfd)->e_flags |= val;
1336
  elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
1337
}
1338
 
1339
/* Set the right machine number.  */
1340
 
1341
static bfd_boolean
1342
elf32_avr_object_p (bfd *abfd)
1343
{
1344
  unsigned int e_set = bfd_mach_avr2;
1345
 
1346
  if (elf_elfheader (abfd)->e_machine == EM_AVR
1347
      || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1348
    {
1349
      int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1350
 
1351
      switch (e_mach)
1352
        {
1353
        default:
1354
        case E_AVR_MACH_AVR2:
1355
          e_set = bfd_mach_avr2;
1356
          break;
1357
 
1358
        case E_AVR_MACH_AVR1:
1359
          e_set = bfd_mach_avr1;
1360
          break;
1361
 
1362 225 jeremybenn
        case E_AVR_MACH_AVR25:
1363
          e_set = bfd_mach_avr25;
1364
          break;
1365
 
1366 24 jeremybenn
        case E_AVR_MACH_AVR3:
1367
          e_set = bfd_mach_avr3;
1368
          break;
1369
 
1370 225 jeremybenn
        case E_AVR_MACH_AVR31:
1371
          e_set = bfd_mach_avr31;
1372
          break;
1373
 
1374
        case E_AVR_MACH_AVR35:
1375
          e_set = bfd_mach_avr35;
1376
          break;
1377
 
1378 24 jeremybenn
        case E_AVR_MACH_AVR4:
1379
          e_set = bfd_mach_avr4;
1380
          break;
1381
 
1382
        case E_AVR_MACH_AVR5:
1383
          e_set = bfd_mach_avr5;
1384
          break;
1385
 
1386 225 jeremybenn
        case E_AVR_MACH_AVR51:
1387
          e_set = bfd_mach_avr51;
1388
          break;
1389
 
1390 24 jeremybenn
        case E_AVR_MACH_AVR6:
1391
          e_set = bfd_mach_avr6;
1392
          break;
1393
        }
1394
    }
1395
  return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1396
                                    e_set);
1397
}
1398
 
1399
 
1400
/* Delete some bytes from a section while changing the size of an instruction.
1401
   The parameter "addr" denotes the section-relative offset pointing just
1402
   behind the shrinked instruction. "addr+count" point at the first
1403
   byte just behind the original unshrinked instruction.  */
1404
 
1405
static bfd_boolean
1406
elf32_avr_relax_delete_bytes (bfd *abfd,
1407
                              asection *sec,
1408
                              bfd_vma addr,
1409
                              int count)
1410
{
1411
  Elf_Internal_Shdr *symtab_hdr;
1412
  unsigned int sec_shndx;
1413
  bfd_byte *contents;
1414
  Elf_Internal_Rela *irel, *irelend;
1415
  Elf_Internal_Rela *irelalign;
1416
  Elf_Internal_Sym *isym;
1417
  Elf_Internal_Sym *isymbuf = NULL;
1418
  bfd_vma toaddr;
1419
  struct elf_link_hash_entry **sym_hashes;
1420
  struct elf_link_hash_entry **end_hashes;
1421
  unsigned int symcount;
1422
 
1423
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1424
  sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1425
  contents = elf_section_data (sec)->this_hdr.contents;
1426
 
1427
  /* The deletion must stop at the next ALIGN reloc for an aligment
1428
     power larger than the number of bytes we are deleting.  */
1429
 
1430
  irelalign = NULL;
1431
  toaddr = sec->size;
1432
 
1433
  irel = elf_section_data (sec)->relocs;
1434
  irelend = irel + sec->reloc_count;
1435
 
1436
  /* Actually delete the bytes.  */
1437
  if (toaddr - addr - count > 0)
1438
    memmove (contents + addr, contents + addr + count,
1439
             (size_t) (toaddr - addr - count));
1440
  sec->size -= count;
1441
 
1442
  /* Adjust all the reloc addresses.  */
1443
  for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1444
    {
1445
      bfd_vma old_reloc_address;
1446
      bfd_vma shrinked_insn_address;
1447
 
1448
      old_reloc_address = (sec->output_section->vma
1449
                           + sec->output_offset + irel->r_offset);
1450
      shrinked_insn_address = (sec->output_section->vma
1451
                              + sec->output_offset + addr - count);
1452
 
1453
      /* Get the new reloc address.  */
1454
      if ((irel->r_offset > addr
1455
           && irel->r_offset < toaddr))
1456
        {
1457
          if (debug_relax)
1458
            printf ("Relocation at address 0x%x needs to be moved.\n"
1459
                    "Old section offset: 0x%x, New section offset: 0x%x \n",
1460
                    (unsigned int) old_reloc_address,
1461
                    (unsigned int) irel->r_offset,
1462
                    (unsigned int) ((irel->r_offset) - count));
1463
 
1464
          irel->r_offset -= count;
1465
        }
1466
 
1467
    }
1468
 
1469
   /* The reloc's own addresses are now ok. However, we need to readjust
1470
      the reloc's addend, i.e. the reloc's value if two conditions are met:
1471
      1.) the reloc is relative to a symbol in this section that
1472
          is located in front of the shrinked instruction
1473
      2.) symbol plus addend end up behind the shrinked instruction.
1474
 
1475
      The most common case where this happens are relocs relative to
1476
      the section-start symbol.
1477
 
1478
      This step needs to be done for all of the sections of the bfd.  */
1479
 
1480
  {
1481
    struct bfd_section *isec;
1482
 
1483
    for (isec = abfd->sections; isec; isec = isec->next)
1484
     {
1485
       bfd_vma symval;
1486
       bfd_vma shrinked_insn_address;
1487
 
1488
       shrinked_insn_address = (sec->output_section->vma
1489
                                + sec->output_offset + addr - count);
1490
 
1491
       irelend = elf_section_data (isec)->relocs + isec->reloc_count;
1492
       for (irel = elf_section_data (isec)->relocs;
1493
            irel < irelend;
1494
            irel++)
1495
         {
1496
           /* Read this BFD's local symbols if we haven't done
1497
              so already.  */
1498
           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1499
             {
1500
               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1501
               if (isymbuf == NULL)
1502
                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1503
                                                 symtab_hdr->sh_info, 0,
1504
                                                 NULL, NULL, NULL);
1505
               if (isymbuf == NULL)
1506
                 return FALSE;
1507
             }
1508
 
1509
           /* Get the value of the symbol referred to by the reloc.  */
1510
           if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1511
             {
1512
               /* A local symbol.  */
1513
               Elf_Internal_Sym *isym;
1514
               asection *sym_sec;
1515
 
1516
               isym = isymbuf + ELF32_R_SYM (irel->r_info);
1517
               sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1518
               symval = isym->st_value;
1519
               /* If the reloc is absolute, it will not have
1520
                  a symbol or section associated with it.  */
1521
               if (sym_sec == sec)
1522
                 {
1523
                   symval += sym_sec->output_section->vma
1524
                             + sym_sec->output_offset;
1525
 
1526
                   if (debug_relax)
1527
                     printf ("Checking if the relocation's "
1528
                             "addend needs corrections.\n"
1529
                             "Address of anchor symbol: 0x%x \n"
1530
                             "Address of relocation target: 0x%x \n"
1531
                             "Address of relaxed insn: 0x%x \n",
1532
                             (unsigned int) symval,
1533
                             (unsigned int) (symval + irel->r_addend),
1534
                             (unsigned int) shrinked_insn_address);
1535
 
1536
                   if (symval <= shrinked_insn_address
1537
                       && (symval + irel->r_addend) > shrinked_insn_address)
1538
                     {
1539
                       irel->r_addend -= count;
1540
 
1541
                       if (debug_relax)
1542
                         printf ("Relocation's addend needed to be fixed \n");
1543
                     }
1544
                 }
1545
               /* else...Reference symbol is absolute.  No adjustment needed.  */
1546
             }
1547
           /* else...Reference symbol is extern.  No need for adjusting
1548
              the addend.  */
1549
         }
1550
     }
1551
  }
1552
 
1553
  /* Adjust the local symbols defined in this section.  */
1554
  isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1555 225 jeremybenn
  /* Fix PR 9841, there may be no local symbols.  */
1556
  if (isym != NULL)
1557 24 jeremybenn
    {
1558 225 jeremybenn
      Elf_Internal_Sym *isymend;
1559
 
1560
      isymend = isym + symtab_hdr->sh_info;
1561
      for (; isym < isymend; isym++)
1562
        {
1563
          if (isym->st_shndx == sec_shndx
1564
              && isym->st_value > addr
1565
              && isym->st_value < toaddr)
1566
            isym->st_value -= count;
1567
        }
1568 24 jeremybenn
    }
1569
 
1570
  /* Now adjust the global symbols defined in this section.  */
1571
  symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1572
              - symtab_hdr->sh_info);
1573
  sym_hashes = elf_sym_hashes (abfd);
1574
  end_hashes = sym_hashes + symcount;
1575
  for (; sym_hashes < end_hashes; sym_hashes++)
1576
    {
1577
      struct elf_link_hash_entry *sym_hash = *sym_hashes;
1578
      if ((sym_hash->root.type == bfd_link_hash_defined
1579
           || sym_hash->root.type == bfd_link_hash_defweak)
1580
          && sym_hash->root.u.def.section == sec
1581
          && sym_hash->root.u.def.value > addr
1582
          && sym_hash->root.u.def.value < toaddr)
1583
        {
1584
          sym_hash->root.u.def.value -= count;
1585
        }
1586
    }
1587
 
1588
  return TRUE;
1589
}
1590
 
1591
/* This function handles relaxing for the avr.
1592
   Many important relaxing opportunities within functions are already
1593
   realized by the compiler itself.
1594
   Here we try to replace  call (4 bytes) ->  rcall (2 bytes)
1595
   and jump -> rjmp (safes also 2 bytes).
1596
   As well we now optimize seqences of
1597
     - call/rcall function
1598
     - ret
1599
   to yield
1600
     - jmp/rjmp function
1601
     - ret
1602
   . In case that within a sequence
1603
     - jmp/rjmp label
1604
     - ret
1605
   the ret could no longer be reached it is optimized away. In order
1606
   to check if the ret is no longer needed, it is checked that the ret's address
1607
   is not the target of a branch or jump within the same section, it is checked
1608
   that there is no skip instruction before the jmp/rjmp and that there
1609
   is no local or global label place at the address of the ret.
1610
 
1611
   We refrain from relaxing within sections ".vectors" and
1612
   ".jumptables" in order to maintain the position of the instructions.
1613
   There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1614
   if possible. (In future one could possibly use the space of the nop
1615
   for the first instruction of the irq service function.
1616
 
1617
   The .jumptables sections is meant to be used for a future tablejump variant
1618
   for the devices with 3-byte program counter where the table itself
1619
   contains 4-byte jump instructions whose relative offset must not
1620
   be changed.  */
1621
 
1622
static bfd_boolean
1623
elf32_avr_relax_section (bfd *abfd,
1624
                         asection *sec,
1625
                         struct bfd_link_info *link_info,
1626
                         bfd_boolean *again)
1627
{
1628
  Elf_Internal_Shdr *symtab_hdr;
1629
  Elf_Internal_Rela *internal_relocs;
1630
  Elf_Internal_Rela *irel, *irelend;
1631
  bfd_byte *contents = NULL;
1632
  Elf_Internal_Sym *isymbuf = NULL;
1633
  static asection *last_input_section = NULL;
1634
  static Elf_Internal_Rela *last_reloc = NULL;
1635
  struct elf32_avr_link_hash_table *htab;
1636
 
1637 225 jeremybenn
  if (link_info->relocatable)
1638
    (*link_info->callbacks->einfo)
1639
      (_("%P%F: --relax and -r may not be used together\n"));
1640
 
1641 24 jeremybenn
  htab = avr_link_hash_table (link_info);
1642
  if (htab == NULL)
1643
    return FALSE;
1644
 
1645
  /* Assume nothing changes.  */
1646
  *again = FALSE;
1647
 
1648
  if ((!htab->no_stubs) && (sec == htab->stub_sec))
1649
    {
1650
      /* We are just relaxing the stub section.
1651
         Let's calculate the size needed again.  */
1652
      bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
1653
 
1654
      if (debug_relax)
1655
        printf ("Relaxing the stub section. Size prior to this pass: %i\n",
1656
                (int) last_estimated_stub_section_size);
1657
 
1658
      elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
1659
                            link_info, FALSE);
1660
 
1661
      /* Check if the number of trampolines changed.  */
1662
      if (last_estimated_stub_section_size != htab->stub_sec->size)
1663
        *again = TRUE;
1664
 
1665
      if (debug_relax)
1666
        printf ("Size of stub section after this pass: %i\n",
1667
                (int) htab->stub_sec->size);
1668
 
1669
      return TRUE;
1670
    }
1671
 
1672
  /* We don't have to do anything for a relocatable link, if
1673
     this section does not have relocs, or if this is not a
1674
     code section.  */
1675
  if (link_info->relocatable
1676
      || (sec->flags & SEC_RELOC) == 0
1677
      || sec->reloc_count == 0
1678
      || (sec->flags & SEC_CODE) == 0)
1679
    return TRUE;
1680
 
1681
  /* Check if the object file to relax uses internal symbols so that we
1682
     could fix up the relocations.  */
1683
  if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1684
    return TRUE;
1685
 
1686
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1687
 
1688
  /* Get a copy of the native relocations.  */
1689
  internal_relocs = (_bfd_elf_link_read_relocs
1690
                     (abfd, sec, NULL, NULL, link_info->keep_memory));
1691
  if (internal_relocs == NULL)
1692
    goto error_return;
1693
 
1694
  if (sec != last_input_section)
1695
    last_reloc = NULL;
1696
 
1697
  last_input_section = sec;
1698
 
1699
  /* Walk through the relocs looking for relaxing opportunities.  */
1700
  irelend = internal_relocs + sec->reloc_count;
1701
  for (irel = internal_relocs; irel < irelend; irel++)
1702
    {
1703
      bfd_vma symval;
1704
 
1705
      if (   ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
1706
          && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1707
          && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
1708
        continue;
1709
 
1710
      /* Get the section contents if we haven't done so already.  */
1711
      if (contents == NULL)
1712
        {
1713
          /* Get cached copy if it exists.  */
1714
          if (elf_section_data (sec)->this_hdr.contents != NULL)
1715
            contents = elf_section_data (sec)->this_hdr.contents;
1716
          else
1717
            {
1718
              /* Go get them off disk.  */
1719
              if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1720
                goto error_return;
1721
            }
1722
        }
1723
 
1724
     /* Read this BFD's local symbols if we haven't done so already.  */
1725
      if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1726
        {
1727
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1728
          if (isymbuf == NULL)
1729
            isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1730
                                            symtab_hdr->sh_info, 0,
1731
                                            NULL, NULL, NULL);
1732
          if (isymbuf == NULL)
1733
            goto error_return;
1734
        }
1735
 
1736
 
1737
      /* Get the value of the symbol referred to by the reloc.  */
1738
      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1739
        {
1740
          /* A local symbol.  */
1741
          Elf_Internal_Sym *isym;
1742
          asection *sym_sec;
1743
 
1744
          isym = isymbuf + ELF32_R_SYM (irel->r_info);
1745
          sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1746
          symval = isym->st_value;
1747
          /* If the reloc is absolute, it will not have
1748
             a symbol or section associated with it.  */
1749
          if (sym_sec)
1750
            symval += sym_sec->output_section->vma
1751
              + sym_sec->output_offset;
1752
        }
1753
      else
1754
        {
1755
          unsigned long indx;
1756
          struct elf_link_hash_entry *h;
1757
 
1758
          /* An external symbol.  */
1759
          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1760
          h = elf_sym_hashes (abfd)[indx];
1761
          BFD_ASSERT (h != NULL);
1762
          if (h->root.type != bfd_link_hash_defined
1763
              && h->root.type != bfd_link_hash_defweak)
1764
            /* This appears to be a reference to an undefined
1765
               symbol.  Just ignore it--it will be caught by the
1766
               regular reloc processing.  */
1767
            continue;
1768
 
1769
          symval = (h->root.u.def.value
1770
                    + h->root.u.def.section->output_section->vma
1771
                    + h->root.u.def.section->output_offset);
1772
        }
1773
 
1774
      /* For simplicity of coding, we are going to modify the section
1775
         contents, the section relocs, and the BFD symbol table.  We
1776
         must tell the rest of the code not to free up this
1777
         information.  It would be possible to instead create a table
1778
         of changes which have to be made, as is done in coff-mips.c;
1779
         that would be more work, but would require less memory when
1780
         the linker is run.  */
1781
      switch (ELF32_R_TYPE (irel->r_info))
1782
        {
1783
         /* Try to turn a 22-bit absolute call/jump into an 13-bit
1784
            pc-relative rcall/rjmp.  */
1785
         case R_AVR_CALL:
1786
          {
1787
            bfd_vma value = symval + irel->r_addend;
1788
            bfd_vma dot, gap;
1789
            int distance_short_enough = 0;
1790
 
1791
            /* Get the address of this instruction.  */
1792
            dot = (sec->output_section->vma
1793
                   + sec->output_offset + irel->r_offset);
1794
 
1795
            /* Compute the distance from this insn to the branch target.  */
1796
            gap = value - dot;
1797
 
1798
            /* If the distance is within -4094..+4098 inclusive, then we can
1799
               relax this jump/call.  +4098 because the call/jump target
1800
               will be closer after the relaxation.  */
1801
            if ((int) gap >= -4094 && (int) gap <= 4098)
1802
              distance_short_enough = 1;
1803
 
1804
            /* Here we handle the wrap-around case.  E.g. for a 16k device
1805
               we could use a rjmp to jump from address 0x100 to 0x3d00!
1806
               In order to make this work properly, we need to fill the
1807
               vaiable avr_pc_wrap_around with the appropriate value.
1808
               I.e. 0x4000 for a 16k device.  */
1809
            {
1810
               /* Shrinking the code size makes the gaps larger in the
1811
                  case of wrap-arounds.  So we use a heuristical safety
1812
                  margin to avoid that during relax the distance gets
1813
                  again too large for the short jumps.  Let's assume
1814
                  a typical code-size reduction due to relax for a
1815
                  16k device of 600 bytes.  So let's use twice the
1816
                  typical value as safety margin.  */
1817
               int rgap;
1818
               int safety_margin;
1819
 
1820
               int assumed_shrink = 600;
1821
               if (avr_pc_wrap_around > 0x4000)
1822
                 assumed_shrink = 900;
1823
 
1824
               safety_margin = 2 * assumed_shrink;
1825
 
1826
               rgap = avr_relative_distance_considering_wrap_around (gap);
1827
 
1828
               if (rgap >= (-4092 + safety_margin)
1829
                   && rgap <= (4094 - safety_margin))
1830
                 distance_short_enough = 1;
1831
            }
1832
 
1833
            if (distance_short_enough)
1834
              {
1835
                unsigned char code_msb;
1836
                unsigned char code_lsb;
1837
 
1838
                if (debug_relax)
1839
                  printf ("shrinking jump/call instruction at address 0x%x"
1840
                          " in section %s\n\n",
1841
                          (int) dot, sec->name);
1842
 
1843
                /* Note that we've changed the relocs, section contents,
1844
                   etc.  */
1845
                elf_section_data (sec)->relocs = internal_relocs;
1846
                elf_section_data (sec)->this_hdr.contents = contents;
1847
                symtab_hdr->contents = (unsigned char *) isymbuf;
1848
 
1849
                /* Get the instruction code for relaxing.  */
1850
                code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
1851
                code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1852
 
1853
                /* Mask out the relocation bits.  */
1854
                code_msb &= 0x94;
1855
                code_lsb &= 0x0E;
1856
                if (code_msb == 0x94 && code_lsb == 0x0E)
1857
                  {
1858
                    /* we are changing call -> rcall .  */
1859
                    bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1860
                    bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
1861
                  }
1862
                else if (code_msb == 0x94 && code_lsb == 0x0C)
1863
                  {
1864
                    /* we are changeing jump -> rjmp.  */
1865
                    bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1866
                    bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
1867
                  }
1868
                else
1869
                  abort ();
1870
 
1871
                /* Fix the relocation's type.  */
1872
                irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1873
                                             R_AVR_13_PCREL);
1874
 
1875
                /* Check for the vector section. There we don't want to
1876
                   modify the ordering!  */
1877
 
1878
                if (!strcmp (sec->name,".vectors")
1879
                    || !strcmp (sec->name,".jumptables"))
1880
                  {
1881
                    /* Let's insert a nop.  */
1882
                    bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
1883
                    bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
1884
                  }
1885
                else
1886
                  {
1887
                    /* Delete two bytes of data.  */
1888
                    if (!elf32_avr_relax_delete_bytes (abfd, sec,
1889
                                                       irel->r_offset + 2, 2))
1890
                      goto error_return;
1891
 
1892
                    /* That will change things, so, we should relax again.
1893
                       Note that this is not required, and it may be slow.  */
1894
                    *again = TRUE;
1895
                  }
1896
              }
1897
          }
1898
 
1899
        default:
1900
          {
1901
            unsigned char code_msb;
1902
            unsigned char code_lsb;
1903
            bfd_vma dot;
1904
 
1905
            code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1906
            code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
1907
 
1908
            /* Get the address of this instruction.  */
1909
            dot = (sec->output_section->vma
1910
                   + sec->output_offset + irel->r_offset);
1911
 
1912
            /* Here we look for rcall/ret or call/ret sequences that could be
1913
               safely replaced by rjmp/ret or jmp/ret.  */
1914
            if (((code_msb & 0xf0) == 0xd0)
1915
                && avr_replace_call_ret_sequences)
1916
              {
1917
                /* This insn is a rcall.  */
1918
                unsigned char next_insn_msb = 0;
1919
                unsigned char next_insn_lsb = 0;
1920
 
1921
                if (irel->r_offset + 3 < sec->size)
1922
                  {
1923
                    next_insn_msb =
1924
                        bfd_get_8 (abfd, contents + irel->r_offset + 3);
1925
                    next_insn_lsb =
1926
                        bfd_get_8 (abfd, contents + irel->r_offset + 2);
1927
                  }
1928
 
1929
                if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1930
                  {
1931
                    /* The next insn is a ret. We now convert the rcall insn
1932
                       into a rjmp instruction.  */
1933
                    code_msb &= 0xef;
1934
                    bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
1935
                    if (debug_relax)
1936
                      printf ("converted rcall/ret sequence at address 0x%x"
1937
                              " into rjmp/ret sequence. Section is %s\n\n",
1938
                              (int) dot, sec->name);
1939
                    *again = TRUE;
1940
                    break;
1941
                  }
1942
              }
1943
            else if ((0x94 == (code_msb & 0xfe))
1944
                     && (0x0e == (code_lsb & 0x0e))
1945
                     && avr_replace_call_ret_sequences)
1946
              {
1947
                /* This insn is a call.  */
1948
                unsigned char next_insn_msb = 0;
1949
                unsigned char next_insn_lsb = 0;
1950
 
1951
                if (irel->r_offset + 5 < sec->size)
1952
                  {
1953
                    next_insn_msb =
1954
                        bfd_get_8 (abfd, contents + irel->r_offset + 5);
1955
                    next_insn_lsb =
1956
                        bfd_get_8 (abfd, contents + irel->r_offset + 4);
1957
                  }
1958
 
1959
                if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1960
                  {
1961
                    /* The next insn is a ret. We now convert the call insn
1962
                       into a jmp instruction.  */
1963
 
1964
                    code_lsb &= 0xfd;
1965
                    bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
1966
                    if (debug_relax)
1967
                      printf ("converted call/ret sequence at address 0x%x"
1968
                              " into jmp/ret sequence. Section is %s\n\n",
1969
                              (int) dot, sec->name);
1970
                    *again = TRUE;
1971
                    break;
1972
                  }
1973
              }
1974
            else if ((0xc0 == (code_msb & 0xf0))
1975
                     || ((0x94 == (code_msb & 0xfe))
1976
                         && (0x0c == (code_lsb & 0x0e))))
1977
              {
1978
                /* This insn is a rjmp or a jmp.  */
1979
                unsigned char next_insn_msb = 0;
1980
                unsigned char next_insn_lsb = 0;
1981
                int insn_size;
1982
 
1983
                if (0xc0 == (code_msb & 0xf0))
1984
                  insn_size = 2; /* rjmp insn */
1985
                else
1986
                  insn_size = 4; /* jmp insn */
1987
 
1988
                if (irel->r_offset + insn_size + 1 < sec->size)
1989
                  {
1990
                    next_insn_msb =
1991
                        bfd_get_8 (abfd, contents + irel->r_offset
1992
                                         + insn_size + 1);
1993
                    next_insn_lsb =
1994
                        bfd_get_8 (abfd, contents + irel->r_offset
1995
                                         + insn_size);
1996
                  }
1997
 
1998
                if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1999
                  {
2000
                    /* The next insn is a ret. We possibly could delete
2001
                       this ret. First we need to check for preceeding
2002
                       sbis/sbic/sbrs or cpse "skip" instructions.  */
2003
 
2004
                    int there_is_preceeding_non_skip_insn = 1;
2005
                    bfd_vma address_of_ret;
2006
 
2007
                    address_of_ret = dot + insn_size;
2008
 
2009
                    if (debug_relax && (insn_size == 2))
2010
                      printf ("found rjmp / ret sequence at address 0x%x\n",
2011
                              (int) dot);
2012
                    if (debug_relax && (insn_size == 4))
2013
                      printf ("found jmp / ret sequence at address 0x%x\n",
2014
                              (int) dot);
2015
 
2016
                    /* We have to make sure that there is a preceeding insn.  */
2017
                    if (irel->r_offset >= 2)
2018
                      {
2019
                        unsigned char preceeding_msb;
2020
                        unsigned char preceeding_lsb;
2021
                        preceeding_msb =
2022
                            bfd_get_8 (abfd, contents + irel->r_offset - 1);
2023
                        preceeding_lsb =
2024
                            bfd_get_8 (abfd, contents + irel->r_offset - 2);
2025
 
2026
                        /* sbic.  */
2027
                        if (0x99 == preceeding_msb)
2028
                          there_is_preceeding_non_skip_insn = 0;
2029
 
2030
                        /* sbis.  */
2031
                        if (0x9b == preceeding_msb)
2032
                          there_is_preceeding_non_skip_insn = 0;
2033
 
2034
                        /* sbrc */
2035
                        if ((0xfc == (preceeding_msb & 0xfe)
2036
                            && (0x00 == (preceeding_lsb & 0x08))))
2037
                          there_is_preceeding_non_skip_insn = 0;
2038
 
2039
                        /* sbrs */
2040
                        if ((0xfe == (preceeding_msb & 0xfe)
2041
                            && (0x00 == (preceeding_lsb & 0x08))))
2042
                          there_is_preceeding_non_skip_insn = 0;
2043
 
2044
                        /* cpse */
2045
                        if (0x10 == (preceeding_msb & 0xfc))
2046
                          there_is_preceeding_non_skip_insn = 0;
2047
 
2048
                        if (there_is_preceeding_non_skip_insn == 0)
2049
                          if (debug_relax)
2050
                            printf ("preceeding skip insn prevents deletion of"
2051
                                    " ret insn at addr 0x%x in section %s\n",
2052
                                    (int) dot + 2, sec->name);
2053
                      }
2054
                    else
2055
                      {
2056
                        /* There is no previous instruction.  */
2057
                        there_is_preceeding_non_skip_insn = 0;
2058
                      }
2059
 
2060
                    if (there_is_preceeding_non_skip_insn)
2061
                      {
2062
                        /* We now only have to make sure that there is no
2063
                           local label defined at the address of the ret
2064
                           instruction and that there is no local relocation
2065
                           in this section pointing to the ret.  */
2066
 
2067
                        int deleting_ret_is_safe = 1;
2068
                        unsigned int section_offset_of_ret_insn =
2069
                                          irel->r_offset + insn_size;
2070
                        Elf_Internal_Sym *isym, *isymend;
2071
                        unsigned int sec_shndx;
2072
 
2073
                        sec_shndx =
2074
                          _bfd_elf_section_from_bfd_section (abfd, sec);
2075
 
2076
                        /* Check for local symbols.  */
2077
                        isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2078
                        isymend = isym + symtab_hdr->sh_info;
2079 225 jeremybenn
                        /* PR 6019: There may not be any local symbols.  */
2080
                        for (; isym != NULL && isym < isymend; isym++)
2081 24 jeremybenn
                         {
2082
                           if (isym->st_value == section_offset_of_ret_insn
2083
                               && isym->st_shndx == sec_shndx)
2084
                             {
2085
                               deleting_ret_is_safe = 0;
2086
                               if (debug_relax)
2087
                                 printf ("local label prevents deletion of ret "
2088
                                         "insn at address 0x%x\n",
2089
                                         (int) dot + insn_size);
2090
                             }
2091
                         }
2092
 
2093
                         /* Now check for global symbols.  */
2094
                         {
2095
                           int symcount;
2096
                           struct elf_link_hash_entry **sym_hashes;
2097
                           struct elf_link_hash_entry **end_hashes;
2098
 
2099
                           symcount = (symtab_hdr->sh_size
2100
                                       / sizeof (Elf32_External_Sym)
2101
                                       - symtab_hdr->sh_info);
2102
                           sym_hashes = elf_sym_hashes (abfd);
2103
                           end_hashes = sym_hashes + symcount;
2104
                           for (; sym_hashes < end_hashes; sym_hashes++)
2105
                            {
2106
                              struct elf_link_hash_entry *sym_hash =
2107
                                                                 *sym_hashes;
2108
                              if ((sym_hash->root.type == bfd_link_hash_defined
2109
                                  || sym_hash->root.type ==
2110
                                   bfd_link_hash_defweak)
2111
                                  && sym_hash->root.u.def.section == sec
2112
                                  && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2113
                                {
2114
                                  deleting_ret_is_safe = 0;
2115
                                  if (debug_relax)
2116
                                    printf ("global label prevents deletion of "
2117
                                            "ret insn at address 0x%x\n",
2118
                                            (int) dot + insn_size);
2119
                                }
2120
                            }
2121
                         }
2122
                         /* Now we check for relocations pointing to ret.  */
2123
                         {
2124
                           Elf_Internal_Rela *irel;
2125
                           Elf_Internal_Rela *relend;
2126
                           Elf_Internal_Shdr *symtab_hdr;
2127
 
2128
                           symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2129
                           relend = elf_section_data (sec)->relocs
2130
                                    + sec->reloc_count;
2131
 
2132
                           for (irel = elf_section_data (sec)->relocs;
2133
                                irel < relend; irel++)
2134
                             {
2135
                               bfd_vma reloc_target = 0;
2136
                               bfd_vma symval;
2137
                               Elf_Internal_Sym *isymbuf = NULL;
2138
 
2139
                               /* Read this BFD's local symbols if we haven't
2140
                                  done so already.  */
2141
                               if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2142
                                 {
2143
                                   isymbuf = (Elf_Internal_Sym *)
2144
                                             symtab_hdr->contents;
2145
                                   if (isymbuf == NULL)
2146
                                     isymbuf = bfd_elf_get_elf_syms
2147
                                       (abfd,
2148
                                        symtab_hdr,
2149
                                        symtab_hdr->sh_info, 0,
2150
                                        NULL, NULL, NULL);
2151
                                   if (isymbuf == NULL)
2152
                                     break;
2153
                                  }
2154
 
2155
                               /* Get the value of the symbol referred to
2156
                                  by the reloc.  */
2157
                               if (ELF32_R_SYM (irel->r_info)
2158
                                   < symtab_hdr->sh_info)
2159
                                 {
2160
                                   /* A local symbol.  */
2161
                                   Elf_Internal_Sym *isym;
2162
                                   asection *sym_sec;
2163
 
2164
                                   isym = isymbuf
2165
                                          + ELF32_R_SYM (irel->r_info);
2166
                                   sym_sec = bfd_section_from_elf_index
2167
                                     (abfd, isym->st_shndx);
2168
                                   symval = isym->st_value;
2169
 
2170
                                   /* If the reloc is absolute, it will not
2171
                                      have a symbol or section associated
2172
                                      with it.  */
2173
 
2174
                                   if (sym_sec)
2175
                                     {
2176
                                       symval +=
2177
                                           sym_sec->output_section->vma
2178
                                           + sym_sec->output_offset;
2179
                                       reloc_target = symval + irel->r_addend;
2180
                                     }
2181
                                   else
2182
                                     {
2183
                                       reloc_target = symval + irel->r_addend;
2184
                                       /* Reference symbol is absolute.  */
2185
                                     }
2186
                                 }
2187
                               /* else ... reference symbol is extern.  */
2188
 
2189
                               if (address_of_ret == reloc_target)
2190
                                 {
2191
                                   deleting_ret_is_safe = 0;
2192
                                   if (debug_relax)
2193
                                     printf ("ret from "
2194
                                             "rjmp/jmp ret sequence at address"
2195
                                             " 0x%x could not be deleted. ret"
2196
                                             " is target of a relocation.\n",
2197
                                             (int) address_of_ret);
2198
                                 }
2199
                             }
2200
                         }
2201
 
2202
                         if (deleting_ret_is_safe)
2203
                           {
2204
                             if (debug_relax)
2205
                               printf ("unreachable ret instruction "
2206
                                       "at address 0x%x deleted.\n",
2207
                                       (int) dot + insn_size);
2208
 
2209
                             /* Delete two bytes of data.  */
2210
                             if (!elf32_avr_relax_delete_bytes (abfd, sec,
2211
                                        irel->r_offset + insn_size, 2))
2212
                               goto error_return;
2213
 
2214
                             /* That will change things, so, we should relax
2215
                                again. Note that this is not required, and it
2216
                                may be slow.  */
2217
                             *again = TRUE;
2218
                             break;
2219
                           }
2220
                      }
2221
 
2222
                  }
2223
              }
2224
            break;
2225
          }
2226
        }
2227
    }
2228
 
2229
  if (contents != NULL
2230
      && elf_section_data (sec)->this_hdr.contents != contents)
2231
    {
2232
      if (! link_info->keep_memory)
2233
        free (contents);
2234
      else
2235
        {
2236
          /* Cache the section contents for elf_link_input_bfd.  */
2237
          elf_section_data (sec)->this_hdr.contents = contents;
2238
        }
2239
    }
2240
 
2241
  if (internal_relocs != NULL
2242
      && elf_section_data (sec)->relocs != internal_relocs)
2243
    free (internal_relocs);
2244
 
2245
  return TRUE;
2246
 
2247
 error_return:
2248
  if (isymbuf != NULL
2249
      && symtab_hdr->contents != (unsigned char *) isymbuf)
2250
    free (isymbuf);
2251
  if (contents != NULL
2252
      && elf_section_data (sec)->this_hdr.contents != contents)
2253
    free (contents);
2254
  if (internal_relocs != NULL
2255
      && elf_section_data (sec)->relocs != internal_relocs)
2256
    free (internal_relocs);
2257
 
2258
  return FALSE;
2259
}
2260
 
2261
/* This is a version of bfd_generic_get_relocated_section_contents
2262
   which uses elf32_avr_relocate_section.
2263
 
2264
   For avr it's essentially a cut and paste taken from the H8300 port.
2265
   The author of the relaxation support patch for avr had absolutely no
2266
   clue what is happening here but found out that this part of the code
2267
   seems to be important.  */
2268
 
2269
static bfd_byte *
2270
elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2271
                                          struct bfd_link_info *link_info,
2272
                                          struct bfd_link_order *link_order,
2273
                                          bfd_byte *data,
2274
                                          bfd_boolean relocatable,
2275
                                          asymbol **symbols)
2276
{
2277
  Elf_Internal_Shdr *symtab_hdr;
2278
  asection *input_section = link_order->u.indirect.section;
2279
  bfd *input_bfd = input_section->owner;
2280
  asection **sections = NULL;
2281
  Elf_Internal_Rela *internal_relocs = NULL;
2282
  Elf_Internal_Sym *isymbuf = NULL;
2283
 
2284
  /* We only need to handle the case of relaxing, or of having a
2285
     particular set of section contents, specially.  */
2286
  if (relocatable
2287
      || elf_section_data (input_section)->this_hdr.contents == NULL)
2288
    return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2289
                                                       link_order, data,
2290
                                                       relocatable,
2291
                                                       symbols);
2292
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2293
 
2294
  memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2295
          (size_t) input_section->size);
2296
 
2297
  if ((input_section->flags & SEC_RELOC) != 0
2298
      && input_section->reloc_count > 0)
2299
    {
2300
      asection **secpp;
2301
      Elf_Internal_Sym *isym, *isymend;
2302
      bfd_size_type amt;
2303
 
2304
      internal_relocs = (_bfd_elf_link_read_relocs
2305
                         (input_bfd, input_section, NULL, NULL, FALSE));
2306
      if (internal_relocs == NULL)
2307
        goto error_return;
2308
 
2309
      if (symtab_hdr->sh_info != 0)
2310
        {
2311
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2312
          if (isymbuf == NULL)
2313
            isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2314
                                            symtab_hdr->sh_info, 0,
2315
                                            NULL, NULL, NULL);
2316
          if (isymbuf == NULL)
2317
            goto error_return;
2318
        }
2319
 
2320
      amt = symtab_hdr->sh_info;
2321
      amt *= sizeof (asection *);
2322
      sections = bfd_malloc (amt);
2323
      if (sections == NULL && amt != 0)
2324
        goto error_return;
2325
 
2326
      isymend = isymbuf + symtab_hdr->sh_info;
2327
      for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2328
        {
2329
          asection *isec;
2330
 
2331
          if (isym->st_shndx == SHN_UNDEF)
2332
            isec = bfd_und_section_ptr;
2333
          else if (isym->st_shndx == SHN_ABS)
2334
            isec = bfd_abs_section_ptr;
2335
          else if (isym->st_shndx == SHN_COMMON)
2336
            isec = bfd_com_section_ptr;
2337
          else
2338
            isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2339
 
2340
          *secpp = isec;
2341
        }
2342
 
2343
      if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2344
                                        input_section, data, internal_relocs,
2345
                                        isymbuf, sections))
2346
        goto error_return;
2347
 
2348
      if (sections != NULL)
2349
        free (sections);
2350
      if (isymbuf != NULL
2351
          && symtab_hdr->contents != (unsigned char *) isymbuf)
2352
        free (isymbuf);
2353
      if (elf_section_data (input_section)->relocs != internal_relocs)
2354
        free (internal_relocs);
2355
    }
2356
 
2357
  return data;
2358
 
2359
 error_return:
2360
  if (sections != NULL)
2361
    free (sections);
2362
  if (isymbuf != NULL
2363
      && symtab_hdr->contents != (unsigned char *) isymbuf)
2364
    free (isymbuf);
2365
  if (internal_relocs != NULL
2366
      && elf_section_data (input_section)->relocs != internal_relocs)
2367
    free (internal_relocs);
2368
  return NULL;
2369
}
2370
 
2371
 
2372
/* Determines the hash entry name for a particular reloc. It consists of
2373
   the identifier of the symbol section and the added reloc addend and
2374
   symbol offset relative to the section the symbol is attached to.  */
2375
 
2376
static char *
2377
avr_stub_name (const asection *symbol_section,
2378
               const bfd_vma symbol_offset,
2379
               const Elf_Internal_Rela *rela)
2380
{
2381
  char *stub_name;
2382
  bfd_size_type len;
2383
 
2384
  len = 8 + 1 + 8 + 1 + 1;
2385
  stub_name = bfd_malloc (len);
2386
 
2387
  sprintf (stub_name, "%08x+%08x",
2388
           symbol_section->id & 0xffffffff,
2389
           (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2390
 
2391
  return stub_name;
2392
}
2393
 
2394
 
2395
/* Add a new stub entry to the stub hash.  Not all fields of the new
2396
   stub entry are initialised.  */
2397
 
2398
static struct elf32_avr_stub_hash_entry *
2399
avr_add_stub (const char *stub_name,
2400
              struct elf32_avr_link_hash_table *htab)
2401
{
2402
  struct elf32_avr_stub_hash_entry *hsh;
2403
 
2404
  /* Enter this entry into the linker stub hash table.  */
2405
  hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2406
 
2407
  if (hsh == NULL)
2408
    {
2409
      (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2410
                             NULL, stub_name);
2411
      return NULL;
2412
    }
2413
 
2414
  hsh->stub_offset = 0;
2415
  return hsh;
2416
}
2417
 
2418
/* We assume that there is already space allocated for the stub section
2419
   contents and that before building the stubs the section size is
2420
   initialized to 0.  We assume that within the stub hash table entry,
2421
   the absolute position of the jmp target has been written in the
2422
   target_value field.  We write here the offset of the generated jmp insn
2423
   relative to the trampoline section start to the stub_offset entry in
2424
   the stub hash table entry.  */
2425
 
2426
static  bfd_boolean
2427
avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2428
{
2429
  struct elf32_avr_stub_hash_entry *hsh;
2430
  struct bfd_link_info *info;
2431
  struct elf32_avr_link_hash_table *htab;
2432
  bfd *stub_bfd;
2433
  bfd_byte *loc;
2434
  bfd_vma target;
2435
  bfd_vma starget;
2436
 
2437
  /* Basic opcode */
2438
  bfd_vma jmp_insn = 0x0000940c;
2439
 
2440
  /* Massage our args to the form they really have.  */
2441
  hsh = avr_stub_hash_entry (bh);
2442
 
2443
  if (!hsh->is_actually_needed)
2444
    return TRUE;
2445
 
2446
  info = (struct bfd_link_info *) in_arg;
2447
 
2448
  htab = avr_link_hash_table (info);
2449
  if (htab == NULL)
2450
    return FALSE;
2451
 
2452
  target = hsh->target_value;
2453
 
2454
  /* Make a note of the offset within the stubs for this entry.  */
2455
  hsh->stub_offset = htab->stub_sec->size;
2456
  loc = htab->stub_sec->contents + hsh->stub_offset;
2457
 
2458
  stub_bfd = htab->stub_sec->owner;
2459
 
2460
  if (debug_stubs)
2461
    printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2462
             (unsigned int) target,
2463
             (unsigned int) hsh->stub_offset);
2464
 
2465
  /* We now have to add the information on the jump target to the bare
2466
     opcode bits already set in jmp_insn.  */
2467
 
2468
  /* Check for the alignment of the address.  */
2469
  if (target & 1)
2470
     return FALSE;
2471
 
2472
  starget = target >> 1;
2473
  jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2474
  bfd_put_16 (stub_bfd, jmp_insn, loc);
2475
  bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2476
 
2477
  htab->stub_sec->size += 4;
2478
 
2479
  /* Now add the entries in the address mapping table if there is still
2480
     space left.  */
2481
  {
2482
    unsigned int nr;
2483
 
2484
    nr = htab->amt_entry_cnt + 1;
2485
    if (nr <= htab->amt_max_entry_cnt)
2486
      {
2487
        htab->amt_entry_cnt = nr;
2488
 
2489
        htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2490
        htab->amt_destination_addr[nr - 1] = target;
2491
      }
2492
  }
2493
 
2494
  return TRUE;
2495
}
2496
 
2497
static bfd_boolean
2498
avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2499
                                   void *in_arg)
2500
{
2501
  struct elf32_avr_stub_hash_entry *hsh;
2502
  struct elf32_avr_link_hash_table *htab;
2503
 
2504
  htab = in_arg;
2505
  hsh = avr_stub_hash_entry (bh);
2506
  hsh->is_actually_needed = FALSE;
2507
 
2508
  return TRUE;
2509
}
2510
 
2511
static bfd_boolean
2512
avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2513
{
2514
  struct elf32_avr_stub_hash_entry *hsh;
2515
  struct elf32_avr_link_hash_table *htab;
2516
  int size;
2517
 
2518
  /* Massage our args to the form they really have.  */
2519
  hsh = avr_stub_hash_entry (bh);
2520
  htab = in_arg;
2521
 
2522
  if (hsh->is_actually_needed)
2523
    size = 4;
2524
  else
2525
    size = 0;
2526
 
2527
  htab->stub_sec->size += size;
2528
  return TRUE;
2529
}
2530
 
2531
void
2532
elf32_avr_setup_params (struct bfd_link_info *info,
2533
                        bfd *avr_stub_bfd,
2534
                        asection *avr_stub_section,
2535
                        bfd_boolean no_stubs,
2536
                        bfd_boolean deb_stubs,
2537
                        bfd_boolean deb_relax,
2538
                        bfd_vma pc_wrap_around,
2539
                        bfd_boolean call_ret_replacement)
2540
{
2541
  struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2542
 
2543
  if (htab == NULL)
2544
    return;
2545
  htab->stub_sec = avr_stub_section;
2546
  htab->stub_bfd = avr_stub_bfd;
2547
  htab->no_stubs = no_stubs;
2548
 
2549
  debug_relax = deb_relax;
2550
  debug_stubs = deb_stubs;
2551
  avr_pc_wrap_around = pc_wrap_around;
2552
  avr_replace_call_ret_sequences = call_ret_replacement;
2553
}
2554
 
2555
 
2556
/* Set up various things so that we can make a list of input sections
2557
   for each output section included in the link.  Returns -1 on error,
2558
 
2559
   information on the stubs bfd and the stub section in the info
2560
   struct.  */
2561
 
2562
int
2563
elf32_avr_setup_section_lists (bfd *output_bfd,
2564
                               struct bfd_link_info *info)
2565
{
2566
  bfd *input_bfd;
2567
  unsigned int bfd_count;
2568
  int top_id, top_index;
2569
  asection *section;
2570
  asection **input_list, **list;
2571
  bfd_size_type amt;
2572
  struct elf32_avr_link_hash_table *htab = avr_link_hash_table(info);
2573
 
2574
  if (htab == NULL || htab->no_stubs)
2575
    return 0;
2576
 
2577
  /* Count the number of input BFDs and find the top input section id.  */
2578
  for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2579
       input_bfd != NULL;
2580
       input_bfd = input_bfd->link_next)
2581
    {
2582
      bfd_count += 1;
2583
      for (section = input_bfd->sections;
2584
           section != NULL;
2585
           section = section->next)
2586
        if (top_id < section->id)
2587
          top_id = section->id;
2588
    }
2589
 
2590
  htab->bfd_count = bfd_count;
2591
 
2592
  /* We can't use output_bfd->section_count here to find the top output
2593
     section index as some sections may have been removed, and
2594
     strip_excluded_output_sections doesn't renumber the indices.  */
2595
  for (section = output_bfd->sections, top_index = 0;
2596
       section != NULL;
2597
       section = section->next)
2598
    if (top_index < section->index)
2599
      top_index = section->index;
2600
 
2601
  htab->top_index = top_index;
2602
  amt = sizeof (asection *) * (top_index + 1);
2603
  input_list = bfd_malloc (amt);
2604
  htab->input_list = input_list;
2605
  if (input_list == NULL)
2606
    return -1;
2607
 
2608
  /* For sections we aren't interested in, mark their entries with a
2609
     value we can check later.  */
2610
  list = input_list + top_index;
2611
  do
2612
    *list = bfd_abs_section_ptr;
2613
  while (list-- != input_list);
2614
 
2615
  for (section = output_bfd->sections;
2616
       section != NULL;
2617
       section = section->next)
2618
    if ((section->flags & SEC_CODE) != 0)
2619
      input_list[section->index] = NULL;
2620
 
2621
  return 1;
2622
}
2623
 
2624
 
2625
/* Read in all local syms for all input bfds, and create hash entries
2626
   for export stubs if we are building a multi-subspace shared lib.
2627
   Returns -1 on error, 0 otherwise.  */
2628
 
2629
static int
2630
get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2631
{
2632
  unsigned int bfd_indx;
2633
  Elf_Internal_Sym *local_syms, **all_local_syms;
2634
  struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2635 225 jeremybenn
  bfd_size_type amt;
2636 24 jeremybenn
 
2637
  if (htab == NULL)
2638
    return -1;
2639
 
2640
  /* We want to read in symbol extension records only once.  To do this
2641
     we need to read in the local symbols in parallel and save them for
2642
     later use; so hold pointers to the local symbols in an array.  */
2643 225 jeremybenn
  amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2644 24 jeremybenn
  all_local_syms = bfd_zmalloc (amt);
2645
  htab->all_local_syms = all_local_syms;
2646
  if (all_local_syms == NULL)
2647
    return -1;
2648
 
2649
  /* Walk over all the input BFDs, swapping in local symbols.
2650
     If we are creating a shared library, create hash entries for the
2651
     export stubs.  */
2652
  for (bfd_indx = 0;
2653
       input_bfd != NULL;
2654
       input_bfd = input_bfd->link_next, bfd_indx++)
2655
    {
2656
      Elf_Internal_Shdr *symtab_hdr;
2657
 
2658
      /* We'll need the symbol table in a second.  */
2659
      symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2660
      if (symtab_hdr->sh_info == 0)
2661
        continue;
2662
 
2663
      /* We need an array of the local symbols attached to the input bfd.  */
2664
      local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2665
      if (local_syms == NULL)
2666
        {
2667
          local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2668
                                             symtab_hdr->sh_info, 0,
2669
                                             NULL, NULL, NULL);
2670
          /* Cache them for elf_link_input_bfd.  */
2671
          symtab_hdr->contents = (unsigned char *) local_syms;
2672
        }
2673
      if (local_syms == NULL)
2674
        return -1;
2675
 
2676
      all_local_syms[bfd_indx] = local_syms;
2677
    }
2678
 
2679
  return 0;
2680
}
2681
 
2682
#define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
2683
 
2684
bfd_boolean
2685
elf32_avr_size_stubs (bfd *output_bfd,
2686
                      struct bfd_link_info *info,
2687
                      bfd_boolean is_prealloc_run)
2688
{
2689
  struct elf32_avr_link_hash_table *htab;
2690
  int stub_changed = 0;
2691
 
2692
  htab = avr_link_hash_table (info);
2693
  if (htab == NULL)
2694
    return FALSE;
2695
 
2696
  /* At this point we initialize htab->vector_base
2697
     To the start of the text output section.  */
2698
  htab->vector_base = htab->stub_sec->output_section->vma;
2699
 
2700
  if (get_local_syms (info->input_bfds, info))
2701
    {
2702
      if (htab->all_local_syms)
2703
        goto error_ret_free_local;
2704
      return FALSE;
2705
    }
2706
 
2707
  if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
2708
    {
2709
      struct elf32_avr_stub_hash_entry *test;
2710
 
2711
      test = avr_add_stub ("Hugo",htab);
2712
      test->target_value = 0x123456;
2713
      test->stub_offset = 13;
2714
 
2715
      test = avr_add_stub ("Hugo2",htab);
2716
      test->target_value = 0x84210;
2717
      test->stub_offset = 14;
2718
    }
2719
 
2720
  while (1)
2721
    {
2722
      bfd *input_bfd;
2723
      unsigned int bfd_indx;
2724
 
2725
      /* We will have to re-generate the stub hash table each time anything
2726
         in memory has changed.  */
2727
 
2728
      bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
2729
      for (input_bfd = info->input_bfds, bfd_indx = 0;
2730
           input_bfd != NULL;
2731
           input_bfd = input_bfd->link_next, bfd_indx++)
2732
        {
2733
          Elf_Internal_Shdr *symtab_hdr;
2734
          asection *section;
2735
          Elf_Internal_Sym *local_syms;
2736
 
2737
          /* We'll need the symbol table in a second.  */
2738
          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2739
          if (symtab_hdr->sh_info == 0)
2740
            continue;
2741
 
2742
          local_syms = htab->all_local_syms[bfd_indx];
2743
 
2744
          /* Walk over each section attached to the input bfd.  */
2745
          for (section = input_bfd->sections;
2746
               section != NULL;
2747
               section = section->next)
2748
            {
2749
              Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2750
 
2751
              /* If there aren't any relocs, then there's nothing more
2752
                 to do.  */
2753
              if ((section->flags & SEC_RELOC) == 0
2754
                  || section->reloc_count == 0)
2755
                continue;
2756
 
2757
              /* If this section is a link-once section that will be
2758
                 discarded, then don't create any stubs.  */
2759
              if (section->output_section == NULL
2760
                  || section->output_section->owner != output_bfd)
2761
                continue;
2762
 
2763
              /* Get the relocs.  */
2764
              internal_relocs
2765
                = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2766
                                             info->keep_memory);
2767
              if (internal_relocs == NULL)
2768
                goto error_ret_free_local;
2769
 
2770
              /* Now examine each relocation.  */
2771
              irela = internal_relocs;
2772
              irelaend = irela + section->reloc_count;
2773
              for (; irela < irelaend; irela++)
2774
                {
2775
                  unsigned int r_type, r_indx;
2776
                  struct elf32_avr_stub_hash_entry *hsh;
2777
                  asection *sym_sec;
2778
                  bfd_vma sym_value;
2779
                  bfd_vma destination;
2780
                  struct elf_link_hash_entry *hh;
2781
                  char *stub_name;
2782
 
2783
                  r_type = ELF32_R_TYPE (irela->r_info);
2784
                  r_indx = ELF32_R_SYM (irela->r_info);
2785
 
2786
                  /* Only look for 16 bit GS relocs. No other reloc will need a
2787
                     stub.  */
2788
                  if (!((r_type == R_AVR_16_PM)
2789
                        || (r_type == R_AVR_LO8_LDI_GS)
2790
                        || (r_type == R_AVR_HI8_LDI_GS)))
2791
                    continue;
2792
 
2793
                  /* Now determine the call target, its name, value,
2794
                     section.  */
2795
                  sym_sec = NULL;
2796
                  sym_value = 0;
2797
                  destination = 0;
2798
                  hh = NULL;
2799
                  if (r_indx < symtab_hdr->sh_info)
2800
                    {
2801
                      /* It's a local symbol.  */
2802
                      Elf_Internal_Sym *sym;
2803
                      Elf_Internal_Shdr *hdr;
2804 225 jeremybenn
                      unsigned int shndx;
2805 24 jeremybenn
 
2806
                      sym = local_syms + r_indx;
2807
                      if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2808
                        sym_value = sym->st_value;
2809 225 jeremybenn
                      shndx = sym->st_shndx;
2810
                      if (shndx < elf_numsections (input_bfd))
2811
                        {
2812
                          hdr = elf_elfsections (input_bfd)[shndx];
2813
                          sym_sec = hdr->bfd_section;
2814
                          destination = (sym_value + irela->r_addend
2815
                                         + sym_sec->output_offset
2816
                                         + sym_sec->output_section->vma);
2817
                        }
2818 24 jeremybenn
                    }
2819
                  else
2820
                    {
2821
                      /* It's an external symbol.  */
2822
                      int e_indx;
2823
 
2824
                      e_indx = r_indx - symtab_hdr->sh_info;
2825
                      hh = elf_sym_hashes (input_bfd)[e_indx];
2826
 
2827
                      while (hh->root.type == bfd_link_hash_indirect
2828
                             || hh->root.type == bfd_link_hash_warning)
2829
                        hh = (struct elf_link_hash_entry *)
2830
                              (hh->root.u.i.link);
2831
 
2832
                      if (hh->root.type == bfd_link_hash_defined
2833
                          || hh->root.type == bfd_link_hash_defweak)
2834
                        {
2835
                          sym_sec = hh->root.u.def.section;
2836
                          sym_value = hh->root.u.def.value;
2837
                          if (sym_sec->output_section != NULL)
2838
                          destination = (sym_value + irela->r_addend
2839
                                         + sym_sec->output_offset
2840
                                         + sym_sec->output_section->vma);
2841
                        }
2842
                      else if (hh->root.type == bfd_link_hash_undefweak)
2843
                        {
2844
                          if (! info->shared)
2845
                            continue;
2846
                        }
2847
                      else if (hh->root.type == bfd_link_hash_undefined)
2848
                        {
2849
                          if (! (info->unresolved_syms_in_objects == RM_IGNORE
2850
                                 && (ELF_ST_VISIBILITY (hh->other)
2851
                                     == STV_DEFAULT)))
2852
                             continue;
2853
                        }
2854
                      else
2855
                        {
2856
                          bfd_set_error (bfd_error_bad_value);
2857
 
2858
                          error_ret_free_internal:
2859
                          if (elf_section_data (section)->relocs == NULL)
2860
                            free (internal_relocs);
2861
                          goto error_ret_free_local;
2862
                        }
2863
                    }
2864
 
2865
                  if (! avr_stub_is_required_for_16_bit_reloc
2866
                      (destination - htab->vector_base))
2867
                    {
2868
                      if (!is_prealloc_run)
2869
                        /* We are having a reloc that does't need a stub.  */
2870
                        continue;
2871
 
2872
                      /* We don't right now know if a stub will be needed.
2873
                         Let's rather be on the safe side.  */
2874
                    }
2875
 
2876
                  /* Get the name of this stub.  */
2877
                  stub_name = avr_stub_name (sym_sec, sym_value, irela);
2878
 
2879
                  if (!stub_name)
2880
                    goto error_ret_free_internal;
2881
 
2882
 
2883
                  hsh = avr_stub_hash_lookup (&htab->bstab,
2884
                                              stub_name,
2885
                                              FALSE, FALSE);
2886
                  if (hsh != NULL)
2887
                    {
2888
                      /* The proper stub has already been created.  Mark it
2889
                         to be used and write the possibly changed destination
2890
                         value.  */
2891
                      hsh->is_actually_needed = TRUE;
2892
                      hsh->target_value = destination;
2893
                      free (stub_name);
2894
                      continue;
2895
                    }
2896
 
2897
                  hsh = avr_add_stub (stub_name, htab);
2898
                  if (hsh == NULL)
2899
                    {
2900
                      free (stub_name);
2901
                      goto error_ret_free_internal;
2902
                    }
2903
 
2904
                  hsh->is_actually_needed = TRUE;
2905
                  hsh->target_value = destination;
2906
 
2907
                  if (debug_stubs)
2908
                    printf ("Adding stub with destination 0x%x to the"
2909
                            " hash table.\n", (unsigned int) destination);
2910
                  if (debug_stubs)
2911
                    printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
2912
 
2913
                  stub_changed = TRUE;
2914
                }
2915
 
2916
              /* We're done with the internal relocs, free them.  */
2917
              if (elf_section_data (section)->relocs == NULL)
2918
                free (internal_relocs);
2919
            }
2920
        }
2921
 
2922
      /* Re-Calculate the number of needed stubs.  */
2923
      htab->stub_sec->size = 0;
2924
      bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
2925
 
2926
      if (!stub_changed)
2927
        break;
2928
 
2929
      stub_changed = FALSE;
2930
    }
2931
 
2932
  free (htab->all_local_syms);
2933
  return TRUE;
2934
 
2935
 error_ret_free_local:
2936
  free (htab->all_local_syms);
2937
  return FALSE;
2938
}
2939
 
2940
 
2941
/* Build all the stubs associated with the current output file.  The
2942
   stubs are kept in a hash table attached to the main linker hash
2943
   table.  We also set up the .plt entries for statically linked PIC
2944
   functions here.  This function is called via hppaelf_finish in the
2945
   linker.  */
2946
 
2947
bfd_boolean
2948
elf32_avr_build_stubs (struct bfd_link_info *info)
2949
{
2950
  asection *stub_sec;
2951
  struct bfd_hash_table *table;
2952
  struct elf32_avr_link_hash_table *htab;
2953
  bfd_size_type total_size = 0;
2954
 
2955
  htab = avr_link_hash_table (info);
2956
  if (htab == NULL)
2957
    return FALSE;
2958
 
2959
  /* In case that there were several stub sections:  */
2960
  for (stub_sec = htab->stub_bfd->sections;
2961
       stub_sec != NULL;
2962
       stub_sec = stub_sec->next)
2963
    {
2964
      bfd_size_type size;
2965
 
2966
      /* Allocate memory to hold the linker stubs.  */
2967
      size = stub_sec->size;
2968
      total_size += size;
2969
 
2970
      stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2971
      if (stub_sec->contents == NULL && size != 0)
2972
        return FALSE;
2973
      stub_sec->size = 0;
2974
    }
2975
 
2976
  /* Allocate memory for the adress mapping table.  */
2977
  htab->amt_entry_cnt = 0;
2978
  htab->amt_max_entry_cnt = total_size / 4;
2979
  htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
2980
                                       * htab->amt_max_entry_cnt);
2981
  htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
2982
                                           * htab->amt_max_entry_cnt );
2983
 
2984
  if (debug_stubs)
2985
    printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
2986
 
2987
  /* Build the stubs as directed by the stub hash table.  */
2988
  table = &htab->bstab;
2989
  bfd_hash_traverse (table, avr_build_one_stub, info);
2990
 
2991
  if (debug_stubs)
2992
    printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
2993
 
2994
  return TRUE;
2995
}
2996
 
2997
#define ELF_ARCH                bfd_arch_avr
2998
#define ELF_MACHINE_CODE        EM_AVR
2999
#define ELF_MACHINE_ALT1        EM_AVR_OLD
3000
#define ELF_MAXPAGESIZE         1
3001
 
3002
#define TARGET_LITTLE_SYM       bfd_elf32_avr_vec
3003
#define TARGET_LITTLE_NAME      "elf32-avr"
3004
 
3005
#define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3006
#define bfd_elf32_bfd_link_hash_table_free   elf32_avr_link_hash_table_free
3007
 
3008
#define elf_info_to_howto                    avr_info_to_howto_rela
3009
#define elf_info_to_howto_rel                NULL
3010
#define elf_backend_relocate_section         elf32_avr_relocate_section
3011
#define elf_backend_check_relocs             elf32_avr_check_relocs
3012
#define elf_backend_can_gc_sections          1
3013
#define elf_backend_rela_normal              1
3014
#define elf_backend_final_write_processing \
3015
                                        bfd_elf_avr_final_write_processing
3016
#define elf_backend_object_p            elf32_avr_object_p
3017
 
3018
#define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3019
#define bfd_elf32_bfd_get_relocated_section_contents \
3020
                                        elf32_avr_get_relocated_section_contents
3021
 
3022
#include "elf32-target.h"

powered by: WebSVN 2.1.0

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