~ubuntu-branches/ubuntu/utopic/binutils-arm64-cross/utopic : revision 7

1

/* COFF specific linker code.

2

3

2004, 2005, 2006, 2007, 2008, 2009, 2011 Free Software Foundation, Inc.

4

Written by Ian Lance Taylor, Cygnus Support.

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, Boston,

21

MA 02110-1301, USA. */

22

23

/* This file contains the COFF backend linker code. */

24

25

#include "sysdep.h"

26

#include "bfd.h"

27

#include "bfdlink.h"

28

#include "libbfd.h"

29

#include "coff/internal.h"

30

#include "libcoff.h"

31

#include "safe-ctype.h"

32

33

static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info);

34

static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded);

35

static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info);

36

37

/* Return TRUE if SYM is a weak, external symbol. */

38

#define IS_WEAK_EXTERNAL(abfd, sym) \

39

((sym).n_sclass == C_WEAKEXT \

40

|| (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))

41

42

/* Return TRUE if SYM is an external symbol. */

43

#define IS_EXTERNAL(abfd, sym) \

44

((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))

45

46

/* Define macros so that the ISFCN, et. al., macros work correctly.

47

These macros are defined in include/coff/internal.h in terms of

48

N_TMASK, etc. These definitions require a user to define local

49

variables with the appropriate names, and with values from the

50

coff_data (abfd) structure. */

51

52

#define N_TMASK n_tmask

53

#define N_BTSHFT n_btshft

54

#define N_BTMASK n_btmask

55

56

/* Create an entry in a COFF linker hash table. */

57

58

struct bfd_hash_entry *

59

_bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,

60

struct bfd_hash_table *table,

61

const char *string)

62

{

63

struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;

64

65

/* Allocate the structure if it has not already been allocated by a

66

subclass. */

67

if (ret == (struct coff_link_hash_entry *) NULL)

68

ret = ((struct coff_link_hash_entry *)

69

bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));

70

if (ret == (struct coff_link_hash_entry *) NULL)

71

return (struct bfd_hash_entry *) ret;

72

73

/* Call the allocation method of the superclass. */

74

ret = ((struct coff_link_hash_entry *)

75

_bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,

76

table, string));

77

if (ret != (struct coff_link_hash_entry *) NULL)

78

{

79

/* Set local fields. */

80

ret->indx = -1;

81

ret->type = T_NULL;

82

ret->symbol_class = C_NULL;

83

ret->numaux = 0;

84

ret->auxbfd = NULL;

85

ret->aux = NULL;

86

}

87

88

return (struct bfd_hash_entry *) ret;

89

}

90

91

/* Initialize a COFF linker hash table. */

92

93

bfd_boolean

94

_bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,

95

bfd *abfd,

96

struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,

97

struct bfd_hash_table *,

98

const char *),

99

unsigned int entsize)

100

{

101

memset (&table->stab_info, 0, sizeof (table->stab_info));

102

return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);

103

}

104

105

/* Create a COFF linker hash table. */

106

107

struct bfd_link_hash_table *

108

_bfd_coff_link_hash_table_create (bfd *abfd)

109

{

110

struct coff_link_hash_table *ret;

111

bfd_size_type amt = sizeof (struct coff_link_hash_table);

112

113

ret = (struct coff_link_hash_table *) bfd_malloc (amt);

114

if (ret == NULL)

115

return NULL;

116

117

if (! _bfd_coff_link_hash_table_init (ret, abfd,

118

_bfd_coff_link_hash_newfunc,

119

sizeof (struct coff_link_hash_entry)))

120

{

121

free (ret);

122

return (struct bfd_link_hash_table *) NULL;

123

}

124

return &ret->root;

125

}

126

127

/* Create an entry in a COFF debug merge hash table. */

128

129

struct bfd_hash_entry *

130

_bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,

131

struct bfd_hash_table *table,

132

const char *string)

133

{

134

struct coff_debug_merge_hash_entry *ret =

135

(struct coff_debug_merge_hash_entry *) entry;

136

137

/* Allocate the structure if it has not already been allocated by a

138

subclass. */

139

if (ret == (struct coff_debug_merge_hash_entry *) NULL)

140

ret = ((struct coff_debug_merge_hash_entry *)

141

bfd_hash_allocate (table,

142

sizeof (struct coff_debug_merge_hash_entry)));

143

if (ret == (struct coff_debug_merge_hash_entry *) NULL)

144

return (struct bfd_hash_entry *) ret;

145

146

/* Call the allocation method of the superclass. */

147

ret = ((struct coff_debug_merge_hash_entry *)

148

bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));

149

if (ret != (struct coff_debug_merge_hash_entry *) NULL)

150

{

151

/* Set local fields. */

152

ret->types = NULL;

153

}

154

155

return (struct bfd_hash_entry *) ret;

156

}

157

158

/* Given a COFF BFD, add symbols to the global hash table as

159

appropriate. */

160

161

bfd_boolean

162

_bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)

163

{

164

switch (bfd_get_format (abfd))

165

{

166

case bfd_object:

167

return coff_link_add_object_symbols (abfd, info);

168

case bfd_archive:

169

return _bfd_generic_link_add_archive_symbols

170

(abfd, info, coff_link_check_archive_element);

171

default:

172

bfd_set_error (bfd_error_wrong_format);

173

return FALSE;

174

}

175

}

176

177

/* Add symbols from a COFF object file. */

178

179

static bfd_boolean

180

coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)

181

{

182

if (! _bfd_coff_get_external_symbols (abfd))

183

return FALSE;

184

if (! coff_link_add_symbols (abfd, info))

185

return FALSE;

186

187

if (! info->keep_memory

188

&& ! _bfd_coff_free_symbols (abfd))

189

return FALSE;

190

191

return TRUE;

192

}

193

194

/* Look through the symbols to see if this object file should be

195

included in the link. */

196

197

static bfd_boolean

198

coff_link_check_ar_symbols (bfd *abfd,

199

struct bfd_link_info *info,

200

bfd_boolean *pneeded,

201

bfd **subsbfd)

202

{

203

bfd_size_type symesz;

204

bfd_byte *esym;

205

bfd_byte *esym_end;

206

207

*pneeded = FALSE;

208

209

symesz = bfd_coff_symesz (abfd);

210

esym = (bfd_byte *) obj_coff_external_syms (abfd);

211

esym_end = esym + obj_raw_syment_count (abfd) * symesz;

212

while (esym < esym_end)

213

{

214

struct internal_syment sym;

215

enum coff_symbol_classification classification;

216

217

bfd_coff_swap_sym_in (abfd, esym, &sym);

218

219

classification = bfd_coff_classify_symbol (abfd, &sym);

220

if (classification == COFF_SYMBOL_GLOBAL

221

|| classification == COFF_SYMBOL_COMMON)

222

{

223

const char *name;

224

char buf[SYMNMLEN + 1];

225

struct bfd_link_hash_entry *h;

226

227

/* This symbol is externally visible, and is defined by this

228

object file. */

229

name = _bfd_coff_internal_syment_name (abfd, &sym, buf);

230

if (name == NULL)

231

return FALSE;

232

h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);

233

234

/* Auto import. */

235

if (!h

236

&& info->pei386_auto_import

237

&& CONST_STRNEQ (name, "__imp_"))

238

h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);

239

240

/* We are only interested in symbols that are currently

241

undefined. If a symbol is currently known to be common,

242

COFF linkers do not bring in an object file which defines

243

it. */

244

if (h != (struct bfd_link_hash_entry *) NULL

245

&& h->type == bfd_link_hash_undefined)

246

{

247

if (!(*info->callbacks

248

->add_archive_element) (info, abfd, name, subsbfd))

249

return FALSE;

250

*pneeded = TRUE;

251

return TRUE;

252

}

253

}

254

255

esym += (sym.n_numaux + 1) * symesz;

256

}

257

258

/* We do not need this object file. */

259

return TRUE;

260

}

261

262

/* Check a single archive element to see if we need to include it in

263

the link. *PNEEDED is set according to whether this element is

264

needed in the link or not. This is called via

265

_bfd_generic_link_add_archive_symbols. */

266

267

static bfd_boolean

268

coff_link_check_archive_element (bfd *abfd,

269

struct bfd_link_info *info,

270

bfd_boolean *pneeded)

271

{

272

bfd *oldbfd;

273

bfd_boolean needed;

274

275

if (!_bfd_coff_get_external_symbols (abfd))

276

return FALSE;

277

278

oldbfd = abfd;

279

if (!coff_link_check_ar_symbols (abfd, info, pneeded, &abfd))

280

return FALSE;

281

282

needed = *pneeded;

283

if (needed)

284

{

285

/* Potentially, the add_archive_element hook may have set a

286

substitute BFD for us. */

287

if (abfd != oldbfd)

288

{

289

if (!info->keep_memory

290

&& !_bfd_coff_free_symbols (oldbfd))

291

return FALSE;

292

if (!_bfd_coff_get_external_symbols (abfd))

293

return FALSE;

294

}

295

if (!coff_link_add_symbols (abfd, info))

296

return FALSE;

297

}

298

299

if (!info->keep_memory || !needed)

300

{

301

if (!_bfd_coff_free_symbols (abfd))

302

return FALSE;

303

}

304

return TRUE;

305

}

306

307

/* Add all the symbols from an object file to the hash table. */

308

309

static bfd_boolean

310

coff_link_add_symbols (bfd *abfd,

311

struct bfd_link_info *info)

312

{

313

unsigned int n_tmask = coff_data (abfd)->local_n_tmask;

314

unsigned int n_btshft = coff_data (abfd)->local_n_btshft;

315

unsigned int n_btmask = coff_data (abfd)->local_n_btmask;

316

bfd_boolean keep_syms;

317

bfd_boolean default_copy;

318

bfd_size_type symcount;

319

struct coff_link_hash_entry **sym_hash;

320

bfd_size_type symesz;

321

bfd_byte *esym;

322

bfd_byte *esym_end;

323

bfd_size_type amt;

324

325

symcount = obj_raw_syment_count (abfd);

326

327

if (symcount == 0)

328

return TRUE; /* Nothing to do. */

329

330

/* Keep the symbols during this function, in case the linker needs

331

to read the generic symbols in order to report an error message. */

332

keep_syms = obj_coff_keep_syms (abfd);

333

obj_coff_keep_syms (abfd) = TRUE;

334

335

if (info->keep_memory)

336

default_copy = FALSE;

337

else

338

default_copy = TRUE;

339

340

/* We keep a list of the linker hash table entries that correspond

341

to particular symbols. */

342

amt = symcount * sizeof (struct coff_link_hash_entry *);

343

sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);

344

if (sym_hash == NULL)

345

goto error_return;

346

obj_coff_sym_hashes (abfd) = sym_hash;

347

348

symesz = bfd_coff_symesz (abfd);

349

BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));

350

esym = (bfd_byte *) obj_coff_external_syms (abfd);

351

esym_end = esym + symcount * symesz;

352

while (esym < esym_end)

353

{

354

struct internal_syment sym;

355

enum coff_symbol_classification classification;

356

bfd_boolean copy;

357

358

bfd_coff_swap_sym_in (abfd, esym, &sym);

359

360

classification = bfd_coff_classify_symbol (abfd, &sym);

361

if (classification != COFF_SYMBOL_LOCAL)

362

{

363

const char *name;

364

char buf[SYMNMLEN + 1];

365

flagword flags;

366

asection *section;

367

bfd_vma value;

368

bfd_boolean addit;

369

370

/* This symbol is externally visible. */

371

372

name = _bfd_coff_internal_syment_name (abfd, &sym, buf);

373

if (name == NULL)

374

goto error_return;

375

376

/* We must copy the name into memory if we got it from the

377

syment itself, rather than the string table. */

378

copy = default_copy;

379

if (sym._n._n_n._n_zeroes != 0

380

|| sym._n._n_n._n_offset == 0)

381

copy = TRUE;

382

383

value = sym.n_value;

384

385

switch (classification)

386

{

387

default:

388

abort ();

389

390

case COFF_SYMBOL_GLOBAL:

391

flags = BSF_EXPORT | BSF_GLOBAL;

392

section = coff_section_from_bfd_index (abfd, sym.n_scnum);

393

if (! obj_pe (abfd))

394

value -= section->vma;

395

break;

396

397

case COFF_SYMBOL_UNDEFINED:

398

flags = 0;

399

section = bfd_und_section_ptr;

400

break;

401

402

case COFF_SYMBOL_COMMON:

403

flags = BSF_GLOBAL;

404

section = bfd_com_section_ptr;

405

break;

406

407

case COFF_SYMBOL_PE_SECTION:

408

flags = BSF_SECTION_SYM | BSF_GLOBAL;

409

section = coff_section_from_bfd_index (abfd, sym.n_scnum);

410

break;

411

}

412

413

if (IS_WEAK_EXTERNAL (abfd, sym))

414

flags = BSF_WEAK;

415

416

addit = TRUE;

417

418

/* In the PE format, section symbols actually refer to the

419

start of the output section. We handle them specially

420

here. */

421

if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)

422

{

423

*sym_hash = coff_link_hash_lookup (coff_hash_table (info),

424

name, FALSE, copy, FALSE);

425

if (*sym_hash != NULL)

426

{

427

if (((*sym_hash)->coff_link_hash_flags

428

& COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0

429

&& (*sym_hash)->root.type != bfd_link_hash_undefined

430

&& (*sym_hash)->root.type != bfd_link_hash_undefweak)

431

(*_bfd_error_handler)

432

("Warning: symbol `%s' is both section and non-section",

433

name);

434

435

addit = FALSE;

436

}

437

}

438

439

/* The Microsoft Visual C compiler does string pooling by

440

hashing the constants to an internal symbol name, and

441

relying on the linker comdat support to discard

442

duplicate names. However, if one string is a literal and

443

one is a data initializer, one will end up in the .data

444

section and one will end up in the .rdata section. The

445

Microsoft linker will combine them into the .data

446

section, which seems to be wrong since it might cause the

447

literal to change.

448

449

As long as there are no external references to the

450

symbols, which there shouldn't be, we can treat the .data

451

and .rdata instances as separate symbols. The comdat

452

code in the linker will do the appropriate merging. Here

453

we avoid getting a multiple definition error for one of

454

these special symbols.

455

456

FIXME: I don't think this will work in the case where

457

there are two object files which use the constants as a

458

literal and two object files which use it as a data

459

initializer. One or the other of the second object files

460

is going to wind up with an inappropriate reference. */

461

if (obj_pe (abfd)

462

&& (classification == COFF_SYMBOL_GLOBAL

463

|| classification == COFF_SYMBOL_PE_SECTION)

464

&& coff_section_data (abfd, section) != NULL

465

&& coff_section_data (abfd, section)->comdat != NULL

466

&& CONST_STRNEQ (name, "??_")

467

&& strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)

468

{

469

if (*sym_hash == NULL)

470

*sym_hash = coff_link_hash_lookup (coff_hash_table (info),

471

name, FALSE, copy, FALSE);

472

if (*sym_hash != NULL

473

&& (*sym_hash)->root.type == bfd_link_hash_defined

474

&& coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL

475

&& strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,

476

coff_section_data (abfd, section)->comdat->name) == 0)

477

addit = FALSE;

478

}

479

480

if (addit)

481

{

482

if (! (bfd_coff_link_add_one_symbol

483

(info, abfd, name, flags, section, value,

484

(const char *) NULL, copy, FALSE,

485

(struct bfd_link_hash_entry **) sym_hash)))

486

goto error_return;

487

}

488

489

if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)

490

(*sym_hash)->coff_link_hash_flags |=

491

COFF_LINK_HASH_PE_SECTION_SYMBOL;

492

493

/* Limit the alignment of a common symbol to the possible

494

alignment of a section. There is no point to permitting

495

a higher alignment for a common symbol: we can not

496

guarantee it, and it may cause us to allocate extra space

497

in the common section. */

498

if (section == bfd_com_section_ptr

499

&& (*sym_hash)->root.type == bfd_link_hash_common

500

&& ((*sym_hash)->root.u.c.p->alignment_power

501

> bfd_coff_default_section_alignment_power (abfd)))

502

(*sym_hash)->root.u.c.p->alignment_power

503

= bfd_coff_default_section_alignment_power (abfd);

504

505

if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))

506

{

507

/* If we don't have any symbol information currently in

508

the hash table, or if we are looking at a symbol

509

definition, then update the symbol class and type in

510

the hash table. */

511

if (((*sym_hash)->symbol_class == C_NULL

512

&& (*sym_hash)->type == T_NULL)

513

|| sym.n_scnum != 0

514

|| (sym.n_value != 0

515

&& (*sym_hash)->root.type != bfd_link_hash_defined

516

&& (*sym_hash)->root.type != bfd_link_hash_defweak))

517

{

518

(*sym_hash)->symbol_class = sym.n_sclass;

519

if (sym.n_type != T_NULL)

520

{

521

/* We want to warn if the type changed, but not

522

if it changed from an unspecified type.

523

Testing the whole type byte may work, but the

524

change from (e.g.) a function of unspecified

525

type to function of known type also wants to

526

skip the warning. */

527

if ((*sym_hash)->type != T_NULL

528

&& (*sym_hash)->type != sym.n_type

529

&& !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)

530

&& (BTYPE ((*sym_hash)->type) == T_NULL

531

|| BTYPE (sym.n_type) == T_NULL)))

532

(*_bfd_error_handler)

533

(_("Warning: type of symbol `%s' changed from %d to %d in %B"),

534

abfd, name, (*sym_hash)->type, sym.n_type);

535

536

/* We don't want to change from a meaningful

537

base type to a null one, but if we know

538

nothing, take what little we might now know. */

539

if (BTYPE (sym.n_type) != T_NULL

540

|| (*sym_hash)->type == T_NULL)

541

(*sym_hash)->type = sym.n_type;

542

}

543

(*sym_hash)->auxbfd = abfd;

544

if (sym.n_numaux != 0)

545

{

546

union internal_auxent *alloc;

547

unsigned int i;

548

bfd_byte *eaux;

549

union internal_auxent *iaux;

550

551

(*sym_hash)->numaux = sym.n_numaux;

552

alloc = ((union internal_auxent *)

553

bfd_hash_allocate (&info->hash->table,

554

(sym.n_numaux

555

* sizeof (*alloc))));

556

if (alloc == NULL)

557

goto error_return;

558

for (i = 0, eaux = esym + symesz, iaux = alloc;

559

i < sym.n_numaux;

560

i++, eaux += symesz, iaux++)

561

bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,

562

sym.n_sclass, (int) i,

563

sym.n_numaux, iaux);

564

(*sym_hash)->aux = alloc;

565

}

566

}

567

}

568

569

if (classification == COFF_SYMBOL_PE_SECTION

570

&& (*sym_hash)->numaux != 0)

571

{

572

/* Some PE sections (such as .bss) have a zero size in

573

the section header, but a non-zero size in the AUX

574

record. Correct that here.

575

576

FIXME: This is not at all the right place to do this.

577

For example, it won't help objdump. This needs to be

578

done when we swap in the section header. */

579

BFD_ASSERT ((*sym_hash)->numaux == 1);

580

if (section->size == 0)

581

section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;

582

583

/* FIXME: We could test whether the section sizes

584

matches the size in the aux entry, but apparently

585

that sometimes fails unexpectedly. */

586

}

587

}

588

589

esym += (sym.n_numaux + 1) * symesz;

590

sym_hash += sym.n_numaux + 1;

591

}

592

593

/* If this is a non-traditional, non-relocatable link, try to

594

optimize the handling of any .stab/.stabstr sections. */

595

if (! info->relocatable

596

&& ! info->traditional_format

597

&& bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)

598

&& (info->strip != strip_all && info->strip != strip_debugger))

599

{

600

asection *stabstr;

601

602

stabstr = bfd_get_section_by_name (abfd, ".stabstr");

603

604

if (stabstr != NULL)

605

{

606

bfd_size_type string_offset = 0;

607

asection *stab;

608

609

for (stab = abfd->sections; stab; stab = stab->next)

610

if (CONST_STRNEQ (stab->name, ".stab")

611

&& (!stab->name[5]

612

|| (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))

613

{

614

struct coff_link_hash_table *table;

615

struct coff_section_tdata *secdata

616

= coff_section_data (abfd, stab);

617

618

if (secdata == NULL)

619

{

620

amt = sizeof (struct coff_section_tdata);

621

stab->used_by_bfd = bfd_zalloc (abfd, amt);

622

if (stab->used_by_bfd == NULL)

623

goto error_return;

624

secdata = coff_section_data (abfd, stab);

625

}

626

627

table = coff_hash_table (info);

628

629

if (! _bfd_link_section_stabs (abfd, &table->stab_info,

630

stab, stabstr,

631

&secdata->stab_info,

632

&string_offset))

633

goto error_return;

634

}

635

}

636

}

637

638

obj_coff_keep_syms (abfd) = keep_syms;

639

640

return TRUE;

641

642

error_return:

643

obj_coff_keep_syms (abfd) = keep_syms;

644

return FALSE;

645

}

646

647

/* Do the final link step. */

648

649

bfd_boolean

650

_bfd_coff_final_link (bfd *abfd,

651

struct bfd_link_info *info)

652

{

653

bfd_size_type symesz;

654

struct coff_final_link_info flaginfo;

655

bfd_boolean debug_merge_allocated;

656

bfd_boolean long_section_names;

657

asection *o;

658

struct bfd_link_order *p;

659

bfd_size_type max_sym_count;

660

bfd_size_type max_lineno_count;

661

bfd_size_type max_reloc_count;

662

bfd_size_type max_output_reloc_count;

663

bfd_size_type max_contents_size;

664

file_ptr rel_filepos;

665

unsigned int relsz;

666

file_ptr line_filepos;

667

unsigned int linesz;

668

bfd *sub;

669

bfd_byte *external_relocs = NULL;

670

char strbuf[STRING_SIZE_SIZE];

671

bfd_size_type amt;

672

673

symesz = bfd_coff_symesz (abfd);

674

675

flaginfo.info = info;

676

flaginfo.output_bfd = abfd;

677

flaginfo.strtab = NULL;

678

flaginfo.section_info = NULL;

679

flaginfo.last_file_index = -1;

680

flaginfo.last_bf_index = -1;

681

flaginfo.internal_syms = NULL;

682

flaginfo.sec_ptrs = NULL;

683

flaginfo.sym_indices = NULL;

684

flaginfo.outsyms = NULL;

685

flaginfo.linenos = NULL;

686

flaginfo.contents = NULL;

687

flaginfo.external_relocs = NULL;

688

flaginfo.internal_relocs = NULL;

689

flaginfo.global_to_static = FALSE;

690

debug_merge_allocated = FALSE;

691

692

coff_data (abfd)->link_info = info;

693

694

flaginfo.strtab = _bfd_stringtab_init ();

695

if (flaginfo.strtab == NULL)

696

goto error_return;

697

698

if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))

699

goto error_return;

700

debug_merge_allocated = TRUE;

701

702

/* Compute the file positions for all the sections. */

703

if (! abfd->output_has_begun)

704

{

705

if (! bfd_coff_compute_section_file_positions (abfd))

706

goto error_return;

707

}

708

709

/* Count the line numbers and relocation entries required for the

710

output file. Set the file positions for the relocs. */

711

rel_filepos = obj_relocbase (abfd);

712

relsz = bfd_coff_relsz (abfd);

713

max_contents_size = 0;

714

max_lineno_count = 0;

715

max_reloc_count = 0;

716

717

long_section_names = FALSE;

718

for (o = abfd->sections; o != NULL; o = o->next)

719

{

720

o->reloc_count = 0;

721

o->lineno_count = 0;

722

for (p = o->map_head.link_order; p != NULL; p = p->next)

723

{

724

if (p->type == bfd_indirect_link_order)

725

{

726

asection *sec;

727

728

sec = p->u.indirect.section;

729

730

/* Mark all sections which are to be included in the

731

link. This will normally be every section. We need

732

to do this so that we can identify any sections which

733

the linker has decided to not include. */

734

sec->linker_mark = TRUE;

735

736

if (info->strip == strip_none

737

|| info->strip == strip_some)

738

o->lineno_count += sec->lineno_count;

739

740

if (info->relocatable)

741

o->reloc_count += sec->reloc_count;

742

743

if (sec->rawsize > max_contents_size)

744

max_contents_size = sec->rawsize;

745

if (sec->size > max_contents_size)

746

max_contents_size = sec->size;

747

if (sec->lineno_count > max_lineno_count)

748

max_lineno_count = sec->lineno_count;

749

if (sec->reloc_count > max_reloc_count)

750

max_reloc_count = sec->reloc_count;

751

}

752

else if (info->relocatable

753

&& (p->type == bfd_section_reloc_link_order

754

|| p->type == bfd_symbol_reloc_link_order))

755

++o->reloc_count;

756

}

757

if (o->reloc_count == 0)

758

o->rel_filepos = 0;

759

else

760

{

761

o->flags |= SEC_RELOC;

762

o->rel_filepos = rel_filepos;

763

rel_filepos += o->reloc_count * relsz;

764

/* In PE COFF, if there are at least 0xffff relocations an

765

extra relocation will be written out to encode the count. */

766

if (obj_pe (abfd) && o->reloc_count >= 0xffff)

767

rel_filepos += relsz;

768

}

769

770

if (bfd_coff_long_section_names (abfd)

771

&& strlen (o->name) > SCNNMLEN)

772

{

773

/* This section has a long name which must go in the string

774

table. This must correspond to the code in

775

coff_write_object_contents which puts the string index

776

into the s_name field of the section header. That is why

777

we pass hash as FALSE. */

778

if (_bfd_stringtab_add (flaginfo.strtab, o->name, FALSE, FALSE)

779

== (bfd_size_type) -1)

780

goto error_return;

781

long_section_names = TRUE;

782

}

783

}

784

785

/* If doing a relocatable link, allocate space for the pointers we

786

need to keep. */

787

if (info->relocatable)

788

{

789

unsigned int i;

790

791

/* We use section_count + 1, rather than section_count, because

792

the target_index fields are 1 based. */

793

amt = abfd->section_count + 1;

794

amt *= sizeof (struct coff_link_section_info);

795

flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);

796

if (flaginfo.section_info == NULL)

797

goto error_return;

798

for (i = 0; i <= abfd->section_count; i++)

799

{

800

flaginfo.section_info[i].relocs = NULL;

801

flaginfo.section_info[i].rel_hashes = NULL;

802

}

803

}

804

805

/* We now know the size of the relocs, so we can determine the file

806

positions of the line numbers. */

807

line_filepos = rel_filepos;

808

linesz = bfd_coff_linesz (abfd);

809

max_output_reloc_count = 0;

810

for (o = abfd->sections; o != NULL; o = o->next)

811

{

812

if (o->lineno_count == 0)

813

o->line_filepos = 0;

814

else

815

{

816

o->line_filepos = line_filepos;

817

line_filepos += o->lineno_count * linesz;

818

}

819

820

if (o->reloc_count != 0)

821

{

822

/* We don't know the indices of global symbols until we have

823

written out all the local symbols. For each section in

824

the output file, we keep an array of pointers to hash

825

table entries. Each entry in the array corresponds to a

826

reloc. When we find a reloc against a global symbol, we

827

set the corresponding entry in this array so that we can

828

fix up the symbol index after we have written out all the

829

local symbols.

830

831

Because of this problem, we also keep the relocs in

832

memory until the end of the link. This wastes memory,

833

but only when doing a relocatable link, which is not the

834

common case. */

835

BFD_ASSERT (info->relocatable);

836

amt = o->reloc_count;

837

amt *= sizeof (struct internal_reloc);

838

flaginfo.section_info[o->target_index].relocs =

839

(struct internal_reloc *) bfd_malloc (amt);

840

amt = o->reloc_count;

841

amt *= sizeof (struct coff_link_hash_entry *);

842

flaginfo.section_info[o->target_index].rel_hashes =

843

(struct coff_link_hash_entry **) bfd_malloc (amt);

844

if (flaginfo.section_info[o->target_index].relocs == NULL

845

|| flaginfo.section_info[o->target_index].rel_hashes == NULL)

846

goto error_return;

847

848

if (o->reloc_count > max_output_reloc_count)

849

max_output_reloc_count = o->reloc_count;

850

}

851

852

/* Reset the reloc and lineno counts, so that we can use them to

853

count the number of entries we have output so far. */

854

o->reloc_count = 0;

855

o->lineno_count = 0;

856

}

857

858

obj_sym_filepos (abfd) = line_filepos;

859

860

/* Figure out the largest number of symbols in an input BFD. Take

861

the opportunity to clear the output_has_begun fields of all the

862

input BFD's. */

863

max_sym_count = 0;

864

for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)

865

{

866

size_t sz;

867

868

sub->output_has_begun = FALSE;

869

sz = bfd_family_coff (sub) ? obj_raw_syment_count (sub) : 2;

870

if (sz > max_sym_count)

871

max_sym_count = sz;

872

}

873

874

/* Allocate some buffers used while linking. */

875

amt = max_sym_count * sizeof (struct internal_syment);

876

flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);

877

amt = max_sym_count * sizeof (asection *);

878

flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);

879

amt = max_sym_count * sizeof (long);

880

flaginfo.sym_indices = (long int *) bfd_malloc (amt);

881

flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);

882

amt = max_lineno_count * bfd_coff_linesz (abfd);

883

flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);

884

flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);

885

amt = max_reloc_count * relsz;

886

flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt);

887

if (! info->relocatable)

888

{

889

amt = max_reloc_count * sizeof (struct internal_reloc);

890

flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);

891

}

892

if ((flaginfo.internal_syms == NULL && max_sym_count > 0)

893

|| (flaginfo.sec_ptrs == NULL && max_sym_count > 0)

894

|| (flaginfo.sym_indices == NULL && max_sym_count > 0)

895

|| flaginfo.outsyms == NULL

896

|| (flaginfo.linenos == NULL && max_lineno_count > 0)

897

|| (flaginfo.contents == NULL && max_contents_size > 0)

898

|| (flaginfo.external_relocs == NULL && max_reloc_count > 0)

899

|| (! info->relocatable

900

&& flaginfo.internal_relocs == NULL

901

&& max_reloc_count > 0))

902

goto error_return;

903

904

/* We now know the position of everything in the file, except that

905

we don't know the size of the symbol table and therefore we don't

906

know where the string table starts. We just build the string

907

table in memory as we go along. We process all the relocations

908

for a single input file at once. */

909

obj_raw_syment_count (abfd) = 0;

910

911

if (coff_backend_info (abfd)->_bfd_coff_start_final_link)

912

{

913

if (! bfd_coff_start_final_link (abfd, info))

914

goto error_return;

915

}

916

917

for (o = abfd->sections; o != NULL; o = o->next)

918

{

919

for (p = o->map_head.link_order; p != NULL; p = p->next)

920

{

921

if (p->type == bfd_indirect_link_order

922

&& bfd_family_coff (p->u.indirect.section->owner))

923

{

924

sub = p->u.indirect.section->owner;

925

if (! bfd_coff_link_output_has_begun (sub, & flaginfo))

926

{

927

if (! _bfd_coff_link_input_bfd (&flaginfo, sub))

928

goto error_return;

929

sub->output_has_begun = TRUE;

930

}

931

}

932

else if (p->type == bfd_section_reloc_link_order

933

|| p->type == bfd_symbol_reloc_link_order)

934

{

935

if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))

936

goto error_return;

937

}

938

else

939

{

940

if (! _bfd_default_link_order (abfd, info, o, p))

941

goto error_return;

942

}

943

}

944

}

945

946

if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all)

947

{

948

/* Add local symbols from foreign inputs. */

949

for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)

950

{

951

unsigned int i;

952

953

if (bfd_family_coff (sub) || ! bfd_get_outsymbols (sub))

954

continue;

955

for (i = 0; i < bfd_get_symcount (sub); ++i)

956

{

957

asymbol *sym = bfd_get_outsymbols (sub) [i];

958

file_ptr pos;

959

struct internal_syment isym;

960

bfd_size_type string_size = 0;

961

bfd_vma written = 0;

962

bfd_boolean rewrite = FALSE;

963

964

if (! (sym->flags & BSF_LOCAL)

965

|| (sym->flags & (BSF_SECTION_SYM | BSF_DEBUGGING_RELOC

966

| BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC

967

| BSF_SYNTHETIC))

968

|| ((sym->flags & BSF_DEBUGGING)

969

&& ! (sym->flags & BSF_FILE)))

970

continue;

971

972

/* See if we are discarding symbols with this name. */

973

if ((flaginfo.info->strip == strip_some

974

&& (bfd_hash_lookup (flaginfo.info->keep_hash,

975

bfd_asymbol_name(sym), FALSE, FALSE)

976

== NULL))

977

|| (((flaginfo.info->discard == discard_sec_merge

978

&& (bfd_get_section (sym)->flags & SEC_MERGE)

979

&& ! flaginfo.info->relocatable)

980

|| flaginfo.info->discard == discard_l)

981

&& bfd_is_local_label_name (sub, bfd_asymbol_name(sym))))

982

continue;

983

984

pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd)

985

* symesz;

986

if (bfd_seek (abfd, pos, SEEK_SET) != 0)

987

goto error_return;

988

if (! coff_write_alien_symbol(abfd, sym, &isym, &written,

989

&string_size, NULL, NULL))

990

goto error_return;

991

992

if (string_size)

993

{

994

bfd_boolean hash = ! (abfd->flags & BFD_TRADITIONAL_FORMAT);

995

bfd_size_type indx;

996

997

indx = _bfd_stringtab_add (flaginfo.strtab,

998

bfd_asymbol_name (sym), hash,

999

FALSE);

1000

if (indx == (bfd_size_type) -1)

1001

goto error_return;

1002

isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;

1003

bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);

1004

rewrite = TRUE;

1005

}

1006

1007

if (isym.n_sclass == C_FILE)

1008

{

1009

if (flaginfo.last_file_index != -1)

1010

{

1011

flaginfo.last_file.n_value = obj_raw_syment_count (abfd);

1012

bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,

1013

flaginfo.outsyms);

1014

pos = obj_sym_filepos (abfd) + flaginfo.last_file_index

1015

* symesz;

1016

rewrite = TRUE;

1017

}

1018

flaginfo.last_file_index = obj_raw_syment_count (abfd);

1019

flaginfo.last_file = isym;

1020

}

1021

1022

if (rewrite

1023

&& (bfd_seek (abfd, pos, SEEK_SET) != 0

1024

|| bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz))

1025

goto error_return;

1026

1027

obj_raw_syment_count (abfd) += written;

1028

}

1029

}

1030

}

1031

1032

if (! bfd_coff_final_link_postscript (abfd, & flaginfo))

1033

goto error_return;

1034

1035

/* Free up the buffers used by _bfd_coff_link_input_bfd. */

1036

1037

coff_debug_merge_hash_table_free (&flaginfo.debug_merge);

1038

debug_merge_allocated = FALSE;

1039

1040

if (flaginfo.internal_syms != NULL)

1041

{

1042

free (flaginfo.internal_syms);

1043

flaginfo.internal_syms = NULL;

1044

}

1045

if (flaginfo.sec_ptrs != NULL)

1046

{

1047

free (flaginfo.sec_ptrs);

1048

flaginfo.sec_ptrs = NULL;

1049

}

1050

if (flaginfo.sym_indices != NULL)

1051

{

1052

free (flaginfo.sym_indices);

1053

flaginfo.sym_indices = NULL;

1054

}

1055

if (flaginfo.linenos != NULL)

1056

{

1057

free (flaginfo.linenos);

1058

flaginfo.linenos = NULL;

1059

}

1060

if (flaginfo.contents != NULL)

1061

{

1062

free (flaginfo.contents);

1063

flaginfo.contents = NULL;

1064

}

1065

if (flaginfo.external_relocs != NULL)

1066

{

1067

free (flaginfo.external_relocs);

1068

flaginfo.external_relocs = NULL;

1069

}

1070

if (flaginfo.internal_relocs != NULL)

1071

{

1072

free (flaginfo.internal_relocs);

1073

flaginfo.internal_relocs = NULL;

1074

}

1075

1076

/* The value of the last C_FILE symbol is supposed to be the symbol

1077

index of the first external symbol. Write it out again if

1078

necessary. */

1079

if (flaginfo.last_file_index != -1

1080

&& (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))

1081

{

1082

file_ptr pos;

1083

1084

flaginfo.last_file.n_value = obj_raw_syment_count (abfd);

1085

bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,

1086

flaginfo.outsyms);

1087

1088

pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;

1089

if (bfd_seek (abfd, pos, SEEK_SET) != 0

1090

|| bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)

1091

return FALSE;

1092

}

1093

1094

/* If doing task linking (ld --task-link) then make a pass through the

1095

global symbols, writing out any that are defined, and making them

1096

static. */

1097

if (info->task_link)

1098

{

1099

flaginfo.failed = FALSE;

1100

coff_link_hash_traverse (coff_hash_table (info),

1101

_bfd_coff_write_task_globals, &flaginfo);

1102

if (flaginfo.failed)

1103

goto error_return;

1104

}

1105

1106

/* Write out the global symbols. */

1107

flaginfo.failed = FALSE;

1108

bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);

1109

if (flaginfo.failed)

1110

goto error_return;

1111

1112

/* The outsyms buffer is used by _bfd_coff_write_global_sym. */

1113

if (flaginfo.outsyms != NULL)

1114

{

1115

free (flaginfo.outsyms);

1116

flaginfo.outsyms = NULL;

1117

}

1118

1119

if (info->relocatable && max_output_reloc_count > 0)

1120

{

1121

/* Now that we have written out all the global symbols, we know

1122

the symbol indices to use for relocs against them, and we can

1123

finally write out the relocs. */

1124

amt = max_output_reloc_count * relsz;

1125

external_relocs = (bfd_byte *) bfd_malloc (amt);

1126

if (external_relocs == NULL)

1127

goto error_return;

1128

1129

for (o = abfd->sections; o != NULL; o = o->next)

1130

{

1131

struct internal_reloc *irel;

1132

struct internal_reloc *irelend;

1133

struct coff_link_hash_entry **rel_hash;

1134

bfd_byte *erel;

1135

1136

if (o->reloc_count == 0)

1137

continue;

1138

1139

irel = flaginfo.section_info[o->target_index].relocs;

1140

irelend = irel + o->reloc_count;

1141

rel_hash = flaginfo.section_info[o->target_index].rel_hashes;

1142

erel = external_relocs;

1143

for (; irel < irelend; irel++, rel_hash++, erel += relsz)

1144

{

1145

if (*rel_hash != NULL)

1146

{

1147

BFD_ASSERT ((*rel_hash)->indx >= 0);

1148

irel->r_symndx = (*rel_hash)->indx;

1149

}

1150

bfd_coff_swap_reloc_out (abfd, irel, erel);

1151

}

1152

1153

if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)

1154

goto error_return;

1155

if (obj_pe (abfd) && o->reloc_count >= 0xffff)

1156

{

1157

/* In PE COFF, write the count of relocs as the first

1158

reloc. The header overflow bit will be set

1159

elsewhere. */

1160

struct internal_reloc incount;

1161

bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);

1162

1163

memset (&incount, 0, sizeof (incount));

1164

incount.r_vaddr = o->reloc_count + 1;

1165

bfd_coff_swap_reloc_out (abfd, &incount, excount);

1166

if (bfd_bwrite (excount, relsz, abfd) != relsz)

1167

/* We'll leak, but it's an error anyway. */

1168

goto error_return;

1169

free (excount);

1170

}

1171

if (bfd_bwrite (external_relocs,

1172

(bfd_size_type) relsz * o->reloc_count, abfd)

1173

!= (bfd_size_type) relsz * o->reloc_count)

1174

goto error_return;

1175

}

1176

1177

free (external_relocs);

1178

external_relocs = NULL;

1179

}

1180

1181

/* Free up the section information. */

1182

if (flaginfo.section_info != NULL)

1183

{

1184

unsigned int i;

1185

1186

for (i = 0; i < abfd->section_count; i++)

1187

{

1188

if (flaginfo.section_info[i].relocs != NULL)

1189

free (flaginfo.section_info[i].relocs);

1190

if (flaginfo.section_info[i].rel_hashes != NULL)

1191

free (flaginfo.section_info[i].rel_hashes);

1192

}

1193

free (flaginfo.section_info);

1194

flaginfo.section_info = NULL;

1195

}

1196

1197

/* If we have optimized stabs strings, output them. */

1198

if (coff_hash_table (info)->stab_info.stabstr != NULL)

1199

{

1200

if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))

1201

return FALSE;

1202

}

1203

1204

/* Write out the string table. */

1205

if (obj_raw_syment_count (abfd) != 0 || long_section_names)

1206

{

1207

file_ptr pos;

1208

1209

pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;

1210

if (bfd_seek (abfd, pos, SEEK_SET) != 0)

1211

return FALSE;

1212

1213

#if STRING_SIZE_SIZE == 4

1214

H_PUT_32 (abfd,

1215

_bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,

1216

strbuf);

1217

#else

1218

#error Change H_PUT_32 above

1219

#endif

1220

1221

if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)

1222

!= STRING_SIZE_SIZE)

1223

return FALSE;

1224

1225

if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))

1226

return FALSE;

1227

1228

obj_coff_strings_written (abfd) = TRUE;

1229

}

1230

1231

_bfd_stringtab_free (flaginfo.strtab);

1232

1233

/* Setting bfd_get_symcount to 0 will cause write_object_contents to

1234

not try to write out the symbols. */

1235

bfd_get_symcount (abfd) = 0;

1236

1237

return TRUE;

1238

1239

error_return:

1240

if (debug_merge_allocated)

1241

coff_debug_merge_hash_table_free (&flaginfo.debug_merge);

1242

if (flaginfo.strtab != NULL)

1243

_bfd_stringtab_free (flaginfo.strtab);

1244

if (flaginfo.section_info != NULL)

1245

{

1246

unsigned int i;

1247

1248

for (i = 0; i < abfd->section_count; i++)

1249

{

1250

if (flaginfo.section_info[i].relocs != NULL)

1251

free (flaginfo.section_info[i].relocs);

1252

if (flaginfo.section_info[i].rel_hashes != NULL)

1253

free (flaginfo.section_info[i].rel_hashes);

1254

}

1255

free (flaginfo.section_info);

1256

}

1257

if (flaginfo.internal_syms != NULL)

1258

free (flaginfo.internal_syms);

1259

if (flaginfo.sec_ptrs != NULL)

1260

free (flaginfo.sec_ptrs);

1261

if (flaginfo.sym_indices != NULL)

1262

free (flaginfo.sym_indices);

1263

if (flaginfo.outsyms != NULL)

1264

free (flaginfo.outsyms);

1265

if (flaginfo.linenos != NULL)

1266

free (flaginfo.linenos);

1267

if (flaginfo.contents != NULL)

1268

free (flaginfo.contents);

1269

if (flaginfo.external_relocs != NULL)

1270

free (flaginfo.external_relocs);

1271

if (flaginfo.internal_relocs != NULL)

1272

free (flaginfo.internal_relocs);

1273

if (external_relocs != NULL)

1274

free (external_relocs);

1275

return FALSE;

1276

}

1277

1278

/* Parse out a -heap <reserved>,<commit> line. */

1279

1280

static char *

1281

dores_com (char *ptr, bfd *output_bfd, int heap)

1282

{

1283

if (coff_data(output_bfd)->pe)

1284

{

1285

int val = strtoul (ptr, &ptr, 0);

1286

1287

if (heap)

1288

pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;

1289

else

1290

pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;

1291

1292

if (ptr[0] == ',')

1293

{

1294

val = strtoul (ptr+1, &ptr, 0);

1295

if (heap)

1296

pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;

1297

else

1298

pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;

1299

}

1300

}

1301

return ptr;

1302

}

1303

1304

static char *

1305

get_name (char *ptr, char **dst)

1306

{

1307

while (*ptr == ' ')

1308

ptr++;

1309

*dst = ptr;

1310

while (*ptr && *ptr != ' ')

1311

ptr++;

1312

*ptr = 0;

1313

return ptr+1;

1314

}

1315

1316

/* Process any magic embedded commands in a section called .drectve. */

1317

1318

static int

1319

process_embedded_commands (bfd *output_bfd,

1320

struct bfd_link_info *info ATTRIBUTE_UNUSED,

1321

bfd *abfd)

1322

{

1323

asection *sec = bfd_get_section_by_name (abfd, ".drectve");

1324

char *s;

1325

char *e;

1326

bfd_byte *copy;

1327

1328

if (!sec)

1329

return 1;

1330

1331

if (!bfd_malloc_and_get_section (abfd, sec, &copy))

1332

{

1333

if (copy != NULL)

1334

free (copy);

1335

return 0;

1336

}

1337

e = (char *) copy + sec->size;

1338

1339

for (s = (char *) copy; s < e ; )

1340

{

1341

if (s[0] != '-')

1342

{

1343

s++;

1344

continue;

1345

}

1346

if (CONST_STRNEQ (s, "-attr"))

1347

{

1348

char *name;

1349

char *attribs;

1350

asection *asec;

1351

int loop = 1;

1352

int had_write = 0;

1353

int had_exec= 0;

1354

1355

s += 5;

1356

s = get_name (s, &name);

1357

s = get_name (s, &attribs);

1358

1359

while (loop)

1360

{

1361

switch (*attribs++)

1362

{

1363

case 'W':

1364

had_write = 1;

1365

break;

1366

case 'R':

1367

break;

1368

case 'S':

1369

break;

1370

case 'X':

1371

had_exec = 1;

1372

break;

1373

default:

1374

loop = 0;

1375

}

1376

}

1377

asec = bfd_get_section_by_name (abfd, name);

1378

if (asec)

1379

{

1380

if (had_exec)

1381

asec->flags |= SEC_CODE;

1382

if (!had_write)

1383

asec->flags |= SEC_READONLY;

1384

}

1385

}

1386

else if (CONST_STRNEQ (s, "-heap"))

1387

s = dores_com (s + 5, output_bfd, 1);

1388

1389

else if (CONST_STRNEQ (s, "-stack"))

1390

s = dores_com (s + 6, output_bfd, 0);

1391

1392

/* GNU extension for aligned commons. */

1393

else if (CONST_STRNEQ (s, "-aligncomm:"))

1394

{

1395

/* Common symbols must be aligned on reading, as it

1396

is too late to do anything here, after they have

1397

already been allocated, so just skip the directive. */

1398

s += 11;

1399

}

1400

1401

else

1402

s++;

1403

}

1404

free (copy);

1405

return 1;

1406

}

1407

1408

/* Place a marker against all symbols which are used by relocations.

1409

This marker can be picked up by the 'do we skip this symbol ?'

1410

loop in _bfd_coff_link_input_bfd() and used to prevent skipping

1411

that symbol. */

1412

1413

static void

1414

mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd)

1415

{

1416

asection * a;

1417

1418

if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)

1419

return;

1420

1421

for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)

1422

{

1423

struct internal_reloc * internal_relocs;

1424

struct internal_reloc * irel;

1425

struct internal_reloc * irelend;

1426

1427

if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1

1428

|| a->linker_mark == 0)

1429

continue;

1430

/* Don't mark relocs in excluded sections. */

1431

if (a->output_section == bfd_abs_section_ptr)

1432

continue;

1433

1434

/* Read in the relocs. */

1435

internal_relocs = _bfd_coff_read_internal_relocs

1436

(input_bfd, a, FALSE,

1437

flaginfo->external_relocs,

1438

flaginfo->info->relocatable,

1439

(flaginfo->info->relocatable

1440

? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)

1441

: flaginfo->internal_relocs)

1442

);

1443

1444

if (internal_relocs == NULL)

1445

continue;

1446

1447

irel = internal_relocs;

1448

irelend = irel + a->reloc_count;

1449

1450

/* Place a mark in the sym_indices array (whose entries have

1451

been initialised to 0) for all of the symbols that are used

1452

in the relocation table. This will then be picked up in the

1453

skip/don't-skip pass. */

1454

for (; irel < irelend; irel++)

1455

flaginfo->sym_indices[ irel->r_symndx ] = -1;

1456

}

1457

}

1458

1459

/* Link an input file into the linker output file. This function

1460

handles all the sections and relocations of the input file at once. */

1461

1462

bfd_boolean

1463

_bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd)

1464

{

1465

unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;

1466

unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;

1467

bfd_boolean (*adjust_symndx)

1468

(bfd *, struct bfd_link_info *, bfd *, asection *,

1469

struct internal_reloc *, bfd_boolean *);

1470

bfd *output_bfd;

1471

const char *strings;

1472

bfd_size_type syment_base;

1473

bfd_boolean copy, hash;

1474

bfd_size_type isymesz;

1475

bfd_size_type osymesz;

1476

bfd_size_type linesz;

1477

bfd_byte *esym;

1478

bfd_byte *esym_end;

1479

struct internal_syment *isymp;

1480

asection **secpp;

1481

long *indexp;

1482

unsigned long output_index;

1483

bfd_byte *outsym;

1484

struct coff_link_hash_entry **sym_hash;

1485

asection *o;

1486

1487

/* Move all the symbols to the output file. */

1488

1489

output_bfd = flaginfo->output_bfd;

1490

strings = NULL;

1491

syment_base = obj_raw_syment_count (output_bfd);

1492

isymesz = bfd_coff_symesz (input_bfd);

1493

osymesz = bfd_coff_symesz (output_bfd);

1494

linesz = bfd_coff_linesz (input_bfd);

1495

BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));

1496

1497

copy = FALSE;

1498

if (! flaginfo->info->keep_memory)

1499

copy = TRUE;

1500

hash = TRUE;

1501

if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)

1502

hash = FALSE;

1503

1504

if (! _bfd_coff_get_external_symbols (input_bfd))

1505

return FALSE;

1506

1507

esym = (bfd_byte *) obj_coff_external_syms (input_bfd);

1508

esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;

1509

isymp = flaginfo->internal_syms;

1510

secpp = flaginfo->sec_ptrs;

1511

indexp = flaginfo->sym_indices;

1512

output_index = syment_base;

1513

outsym = flaginfo->outsyms;

1514

1515

if (coff_data (output_bfd)->pe

1516

&& ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd))

1517

return FALSE;

1518

1519

/* If we are going to perform relocations and also strip/discard some

1520

symbols then we must make sure that we do not strip/discard those

1521

symbols that are going to be involved in the relocations. */

1522

if (( flaginfo->info->strip != strip_none

1523

|| flaginfo->info->discard != discard_none)

1524

&& flaginfo->info->relocatable)

1525

{

1526

/* Mark the symbol array as 'not-used'. */

1527

memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);

1528

1529

mark_relocs (flaginfo, input_bfd);

1530

}

1531

1532

while (esym < esym_end)

1533

{

1534

struct internal_syment isym;

1535

enum coff_symbol_classification classification;

1536

bfd_boolean skip;

1537

bfd_boolean global;

1538

bfd_boolean dont_skip_symbol;

1539

int add;

1540

1541

bfd_coff_swap_sym_in (input_bfd, esym, isymp);

1542

1543

/* Make a copy of *isymp so that the relocate_section function

1544

always sees the original values. This is more reliable than

1545

always recomputing the symbol value even if we are stripping

1546

the symbol. */

1547

isym = *isymp;

1548

1549

classification = bfd_coff_classify_symbol (input_bfd, &isym);

1550

switch (classification)

1551

{

1552

default:

1553

abort ();

1554

case COFF_SYMBOL_GLOBAL:

1555

case COFF_SYMBOL_PE_SECTION:

1556

case COFF_SYMBOL_LOCAL:

1557

*secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);

1558

break;

1559

case COFF_SYMBOL_COMMON:

1560

*secpp = bfd_com_section_ptr;

1561

break;

1562

case COFF_SYMBOL_UNDEFINED:

1563

*secpp = bfd_und_section_ptr;

1564

break;

1565

}

1566

1567

/* Extract the flag indicating if this symbol is used by a

1568

relocation. */

1569

if ((flaginfo->info->strip != strip_none

1570

|| flaginfo->info->discard != discard_none)

1571

&& flaginfo->info->relocatable)

1572

dont_skip_symbol = *indexp;

1573

else

1574

dont_skip_symbol = FALSE;

1575

1576

*indexp = -1;

1577

1578

skip = FALSE;

1579

global = FALSE;

1580

add = 1 + isym.n_numaux;

1581

1582

/* If we are stripping all symbols, we want to skip this one. */

1583

if (flaginfo->info->strip == strip_all && ! dont_skip_symbol)

1584

skip = TRUE;

1585

1586

if (! skip)

1587

{

1588

switch (classification)

1589

{

1590

default:

1591

abort ();

1592

case COFF_SYMBOL_GLOBAL:

1593

case COFF_SYMBOL_COMMON:

1594

case COFF_SYMBOL_PE_SECTION:

1595

/* This is a global symbol. Global symbols come at the

1596

end of the symbol table, so skip them for now.

1597

Locally defined function symbols, however, are an

1598

exception, and are not moved to the end. */

1599

global = TRUE;

1600

if (! ISFCN (isym.n_type))

1601

skip = TRUE;

1602

break;

1603

1604

case COFF_SYMBOL_UNDEFINED:

1605

/* Undefined symbols are left for the end. */

1606

global = TRUE;

1607

skip = TRUE;

1608

break;

1609

1610

case COFF_SYMBOL_LOCAL:

1611

/* This is a local symbol. Skip it if we are discarding

1612

local symbols. */

1613

if (flaginfo->info->discard == discard_all && ! dont_skip_symbol)

1614

skip = TRUE;

1615

break;

1616

}

1617

}

1618

1619

#ifndef COFF_WITH_PE

1620

/* Skip section symbols for sections which are not going to be

1621

emitted. */

1622

if (!skip

1623

&& !dont_skip_symbol

1624

&& isym.n_sclass == C_STAT

1625

&& isym.n_type == T_NULL

1626

&& isym.n_numaux > 0

1627

&& ((*secpp)->output_section == bfd_abs_section_ptr

1628

|| bfd_section_removed_from_list (output_bfd,

1629

(*secpp)->output_section)))

1630

skip = TRUE;

1631

#endif

1632

1633

/* If we stripping debugging symbols, and this is a debugging

1634

symbol, then skip it. FIXME: gas sets the section to N_ABS

1635

for some types of debugging symbols; I don't know if this is

1636

a bug or not. In any case, we handle it here. */

1637

if (! skip

1638

&& flaginfo->info->strip == strip_debugger

1639

&& ! dont_skip_symbol

1640

&& (isym.n_scnum == N_DEBUG

1641

|| (isym.n_scnum == N_ABS

1642

&& (isym.n_sclass == C_AUTO

1643

|| isym.n_sclass == C_REG

1644

|| isym.n_sclass == C_MOS

1645

|| isym.n_sclass == C_MOE

1646

|| isym.n_sclass == C_MOU

1647

|| isym.n_sclass == C_ARG

1648

|| isym.n_sclass == C_REGPARM

1649

|| isym.n_sclass == C_FIELD

1650

|| isym.n_sclass == C_EOS))))

1651

skip = TRUE;

1652

1653

/* If some symbols are stripped based on the name, work out the

1654

name and decide whether to skip this symbol. */

1655

if (! skip

1656

&& (flaginfo->info->strip == strip_some

1657

|| flaginfo->info->discard == discard_l))

1658

{

1659

const char *name;

1660

char buf[SYMNMLEN + 1];

1661

1662

name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);

1663

if (name == NULL)

1664

return FALSE;

1665

1666

if (! dont_skip_symbol

1667

&& ((flaginfo->info->strip == strip_some

1668

&& (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE,

1669

FALSE) == NULL))

1670

|| (! global

1671

&& flaginfo->info->discard == discard_l

1672

&& bfd_is_local_label_name (input_bfd, name))))

1673

skip = TRUE;

1674

}

1675

1676

/* If this is an enum, struct, or union tag, see if we have

1677

already output an identical type. */

1678

if (! skip

1679

&& (flaginfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0

1680

&& (isym.n_sclass == C_ENTAG

1681

|| isym.n_sclass == C_STRTAG

1682

|| isym.n_sclass == C_UNTAG)

1683

&& isym.n_numaux == 1)

1684

{

1685

const char *name;

1686

char buf[SYMNMLEN + 1];

1687

struct coff_debug_merge_hash_entry *mh;

1688

struct coff_debug_merge_type *mt;

1689

union internal_auxent aux;

1690

struct coff_debug_merge_element **epp;

1691

bfd_byte *esl, *eslend;

1692

struct internal_syment *islp;

1693

bfd_size_type amt;

1694

1695

name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);

1696

if (name == NULL)

1697

return FALSE;

1698

1699

/* Ignore fake names invented by compiler; treat them all as

1700

the same name. */

1701

if (*name == '~' || *name == '.' || *name == '$'

1702

|| (*name == bfd_get_symbol_leading_char (input_bfd)

1703

&& (name[1] == '~' || name[1] == '.' || name[1] == '$')))

1704

name = "";

1705

1706

mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name,

1707

TRUE, TRUE);

1708

if (mh == NULL)

1709

return FALSE;

1710

1711

/* Allocate memory to hold type information. If this turns

1712

out to be a duplicate, we pass this address to

1713

bfd_release. */

1714

amt = sizeof (struct coff_debug_merge_type);

1715

mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);

1716

if (mt == NULL)

1717

return FALSE;

1718

mt->type_class = isym.n_sclass;

1719

1720

/* Pick up the aux entry, which points to the end of the tag

1721

entries. */

1722

bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),

1723

isym.n_type, isym.n_sclass, 0, isym.n_numaux,

1724

&aux);

1725

1726

/* Gather the elements. */

1727

epp = &mt->elements;

1728

mt->elements = NULL;

1729

islp = isymp + 2;

1730

esl = esym + 2 * isymesz;

1731

eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)

1732

+ aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);

1733

while (esl < eslend)

1734

{

1735

const char *elename;

1736

char elebuf[SYMNMLEN + 1];

1737

char *name_copy;

1738

1739

bfd_coff_swap_sym_in (input_bfd, esl, islp);

1740

1741

amt = sizeof (struct coff_debug_merge_element);

1742

*epp = (struct coff_debug_merge_element *)

1743

bfd_alloc (input_bfd, amt);

1744

if (*epp == NULL)

1745

return FALSE;

1746

1747

elename = _bfd_coff_internal_syment_name (input_bfd, islp,

1748

elebuf);

1749

if (elename == NULL)

1750

return FALSE;

1751

1752

amt = strlen (elename) + 1;

1753

name_copy = (char *) bfd_alloc (input_bfd, amt);

1754

if (name_copy == NULL)

1755

return FALSE;

1756

strcpy (name_copy, elename);

1757

1758

(*epp)->name = name_copy;

1759

(*epp)->type = islp->n_type;

1760

(*epp)->tagndx = 0;

1761

if (islp->n_numaux >= 1

1762

&& islp->n_type != T_NULL

1763

&& islp->n_sclass != C_EOS)

1764

{

1765

union internal_auxent eleaux;

1766

long indx;

1767

1768

bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),

1769

islp->n_type, islp->n_sclass, 0,

1770

islp->n_numaux, &eleaux);

1771

indx = eleaux.x_sym.x_tagndx.l;

1772

1773

/* FIXME: If this tagndx entry refers to a symbol

1774

defined later in this file, we just ignore it.

1775

Handling this correctly would be tedious, and may

1776

not be required. */

1777

if (indx > 0

1778

&& (indx

1779

< ((esym -

1780

(bfd_byte *) obj_coff_external_syms (input_bfd))

1781

/ (long) isymesz)))

1782

{

1783

(*epp)->tagndx = flaginfo->sym_indices[indx];

1784

if ((*epp)->tagndx < 0)

1785

(*epp)->tagndx = 0;

1786

}

1787

}

1788

epp = &(*epp)->next;

1789

*epp = NULL;

1790

1791

esl += (islp->n_numaux + 1) * isymesz;

1792

islp += islp->n_numaux + 1;

1793

}

1794

1795

/* See if we already have a definition which matches this

1796

type. We always output the type if it has no elements,

1797

for simplicity. */

1798

if (mt->elements == NULL)

1799

bfd_release (input_bfd, mt);

1800

else

1801

{

1802

struct coff_debug_merge_type *mtl;

1803

1804

for (mtl = mh->types; mtl != NULL; mtl = mtl->next)

1805

{

1806

struct coff_debug_merge_element *me, *mel;

1807

1808

if (mtl->type_class != mt->type_class)

1809

continue;

1810

1811

for (me = mt->elements, mel = mtl->elements;

1812

me != NULL && mel != NULL;

1813

me = me->next, mel = mel->next)

1814

{

1815

if (strcmp (me->name, mel->name) != 0

1816

|| me->type != mel->type

1817

|| me->tagndx != mel->tagndx)

1818

break;

1819

}

1820

1821

if (me == NULL && mel == NULL)

1822

break;

1823

}

1824

1825

if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)

1826

{

1827

/* This is the first definition of this type. */

1828

mt->indx = output_index;

1829

mt->next = mh->types;

1830

mh->types = mt;

1831

}

1832

else

1833

{

1834

/* This is a redefinition which can be merged. */

1835

bfd_release (input_bfd, mt);

1836

*indexp = mtl->indx;

1837

add = (eslend - esym) / isymesz;

1838

skip = TRUE;

1839

}

1840

}

1841

}

1842

1843

/* We now know whether we are to skip this symbol or not. */

1844

if (! skip)

1845

{

1846

/* Adjust the symbol in order to output it. */

1847

1848

if (isym._n._n_n._n_zeroes == 0

1849

&& isym._n._n_n._n_offset != 0)

1850

{

1851

const char *name;

1852

bfd_size_type indx;

1853

1854

/* This symbol has a long name. Enter it in the string

1855

table we are building. Note that we do not check

1856

bfd_coff_symname_in_debug. That is only true for

1857

XCOFF, and XCOFF requires different linking code

1858

anyhow. */

1859

name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);

1860

if (name == NULL)

1861

return FALSE;

1862

indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy);

1863

if (indx == (bfd_size_type) -1)

1864

return FALSE;

1865

isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;

1866

}

1867

1868

switch (isym.n_sclass)

1869

{

1870

case C_AUTO:

1871

case C_MOS:

1872

case C_EOS:

1873

case C_MOE:

1874

case C_MOU:

1875

case C_UNTAG:

1876

case C_STRTAG:

1877

case C_ENTAG:

1878

case C_TPDEF:

1879

case C_ARG:

1880

case C_USTATIC:

1881

case C_REG:

1882

case C_REGPARM:

1883

case C_FIELD:

1884

/* The symbol value should not be modified. */

1885

break;

1886

1887

case C_FCN:

1888

if (obj_pe (input_bfd)

1889

&& strcmp (isym.n_name, ".bf") != 0

1890

&& isym.n_scnum > 0)

1891

{

1892

/* For PE, .lf and .ef get their value left alone,

1893

while .bf gets relocated. However, they all have

1894

"real" section numbers, and need to be moved into

1895

the new section. */

1896

isym.n_scnum = (*secpp)->output_section->target_index;

1897

break;

1898

}

1899

/* Fall through. */

1900

default:

1901

case C_LABEL: /* Not completely sure about these 2 */

1902

case C_EXTDEF:

1903

case C_BLOCK:

1904

case C_EFCN:

1905

case C_NULL:

1906

case C_EXT:

1907

case C_STAT:

1908

case C_SECTION:

1909

case C_NT_WEAK:

1910

/* Compute new symbol location. */

1911

if (isym.n_scnum > 0)

1912

{

1913

isym.n_scnum = (*secpp)->output_section->target_index;

1914

isym.n_value += (*secpp)->output_offset;

1915

if (! obj_pe (input_bfd))

1916

isym.n_value -= (*secpp)->vma;

1917

if (! obj_pe (flaginfo->output_bfd))

1918

isym.n_value += (*secpp)->output_section->vma;

1919

}

1920

break;

1921

1922

case C_FILE:

1923

/* The value of a C_FILE symbol is the symbol index of

1924

the next C_FILE symbol. The value of the last C_FILE

1925

symbol is the symbol index to the first external

1926

symbol (actually, coff_renumber_symbols does not get

1927

this right--it just sets the value of the last C_FILE

1928

symbol to zero--and nobody has ever complained about

1929

it). We try to get this right, below, just before we

1930

write the symbols out, but in the general case we may

1931

have to write the symbol out twice. */

1932

if (flaginfo->last_file_index != -1

1933

&& flaginfo->last_file.n_value != (bfd_vma) output_index)

1934

{

1935

/* We must correct the value of the last C_FILE

1936

entry. */

1937

flaginfo->last_file.n_value = output_index;

1938

if ((bfd_size_type) flaginfo->last_file_index >= syment_base)

1939

{

1940

/* The last C_FILE symbol is in this input file. */

1941

bfd_coff_swap_sym_out (output_bfd,

1942

&flaginfo->last_file,

1943

(flaginfo->outsyms

1944

+ ((flaginfo->last_file_index

1945

- syment_base)

1946

* osymesz)));

1947

}

1948

else

1949

{

1950

file_ptr pos;

1951

1952

/* We have already written out the last C_FILE

1953

symbol. We need to write it out again. We

1954

borrow *outsym temporarily. */

1955

bfd_coff_swap_sym_out (output_bfd,

1956

&flaginfo->last_file, outsym);

1957

pos = obj_sym_filepos (output_bfd);

1958

pos += flaginfo->last_file_index * osymesz;

1959

if (bfd_seek (output_bfd, pos, SEEK_SET) != 0

1960

|| bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)

1961

return FALSE;

1962

}

1963

}

1964

1965

flaginfo->last_file_index = output_index;

1966

flaginfo->last_file = isym;

1967

break;

1968

}

1969

1970

/* If doing task linking, convert normal global function symbols to

1971

static functions. */

1972

if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym))

1973

isym.n_sclass = C_STAT;

1974

1975

/* Output the symbol. */

1976

bfd_coff_swap_sym_out (output_bfd, &isym, outsym);

1977

1978

*indexp = output_index;

1979

1980

if (global)

1981

{

1982

long indx;

1983

struct coff_link_hash_entry *h;

1984

1985

indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))

1986

/ isymesz);

1987

h = obj_coff_sym_hashes (input_bfd)[indx];

1988

if (h == NULL)

1989

{

1990

/* This can happen if there were errors earlier in

1991

the link. */

1992

bfd_set_error (bfd_error_bad_value);

1993

return FALSE;

1994

}

1995

h->indx = output_index;

1996

}

1997

1998

output_index += add;

1999

outsym += add * osymesz;

2000

}

2001

2002

esym += add * isymesz;

2003

isymp += add;

2004

++secpp;

2005

++indexp;

2006

for (--add; add > 0; --add)

2007

{

2008

*secpp++ = NULL;

2009

*indexp++ = -1;

2010

}

2011

}

2012

2013

/* Fix up the aux entries. This must be done in a separate pass,

2014

because we don't know the correct symbol indices until we have

2015

already decided which symbols we are going to keep. */

2016

esym = (bfd_byte *) obj_coff_external_syms (input_bfd);

2017

esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;

2018

isymp = flaginfo->internal_syms;

2019

indexp = flaginfo->sym_indices;

2020

sym_hash = obj_coff_sym_hashes (input_bfd);

2021

outsym = flaginfo->outsyms;

2022

2023

while (esym < esym_end)

2024

{

2025

int add;

2026

2027

add = 1 + isymp->n_numaux;

2028

2029

if ((*indexp < 0

2030

|| (bfd_size_type) *indexp < syment_base)

2031

&& (*sym_hash == NULL

2032

|| (*sym_hash)->auxbfd != input_bfd))

2033

esym += add * isymesz;

2034

else

2035

{

2036

struct coff_link_hash_entry *h;

2037

int i;

2038

2039

h = NULL;

2040

if (*indexp < 0)

2041

{

2042

h = *sym_hash;

2043

2044

/* The m68k-motorola-sysv assembler will sometimes

2045

generate two symbols with the same name, but only one

2046

will have aux entries. */

2047

BFD_ASSERT (isymp->n_numaux == 0

2048

|| h->numaux == 0

2049

|| h->numaux == isymp->n_numaux);

2050

}

2051

2052

esym += isymesz;

2053

2054

if (h == NULL)

2055

outsym += osymesz;

2056

2057

/* Handle the aux entries. This handling is based on

2058

coff_pointerize_aux. I don't know if it always correct. */

2059

for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)

2060

{

2061

union internal_auxent aux;

2062

union internal_auxent *auxp;

2063

2064

if (h != NULL && h->aux != NULL && (h->numaux > i))

2065

auxp = h->aux + i;

2066

else

2067

{

2068

bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,

2069

isymp->n_sclass, i, isymp->n_numaux, &aux);

2070

auxp = &aux;

2071

}

2072

2073

if (isymp->n_sclass == C_FILE)

2074

{

2075

/* If this is a long filename, we must put it in the

2076

string table. */

2077

if (auxp->x_file.x_n.x_zeroes == 0

2078

&& auxp->x_file.x_n.x_offset != 0)

2079

{

2080

const char *filename;

2081

bfd_size_type indx;

2082

2083

BFD_ASSERT (auxp->x_file.x_n.x_offset

2084

>= STRING_SIZE_SIZE);

2085

if (strings == NULL)

2086

{

2087

strings = _bfd_coff_read_string_table (input_bfd);

2088

if (strings == NULL)

2089

return FALSE;

2090

}

2091

filename = strings + auxp->x_file.x_n.x_offset;

2092

indx = _bfd_stringtab_add (flaginfo->strtab, filename,

2093

hash, copy);

2094

if (indx == (bfd_size_type) -1)

2095

return FALSE;

2096

auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;

2097

}

2098

}

2099

else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)

2100

&& isymp->n_sclass != C_NT_WEAK)

2101

{

2102

unsigned long indx;

2103

2104

if (ISFCN (isymp->n_type)

2105

|| ISTAG (isymp->n_sclass)

2106

|| isymp->n_sclass == C_BLOCK

2107

|| isymp->n_sclass == C_FCN)

2108

{

2109

indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;

2110

if (indx > 0

2111

&& indx < obj_raw_syment_count (input_bfd))

2112

{

2113

/* We look forward through the symbol for

2114

the index of the next symbol we are going

2115

to include. I don't know if this is

2116

entirely right. */

2117

while ((flaginfo->sym_indices[indx] < 0

2118

|| ((bfd_size_type) flaginfo->sym_indices[indx]

2119

< syment_base))

2120

&& indx < obj_raw_syment_count (input_bfd))

2121

++indx;

2122

if (indx >= obj_raw_syment_count (input_bfd))

2123

indx = output_index;

2124

else

2125

indx = flaginfo->sym_indices[indx];

2126

auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;

2127

}

2128

}

2129

2130

indx = auxp->x_sym.x_tagndx.l;

2131

if (indx > 0 && indx < obj_raw_syment_count (input_bfd))

2132

{

2133

long symindx;

2134

2135

symindx = flaginfo->sym_indices[indx];

2136

if (symindx < 0)

2137

auxp->x_sym.x_tagndx.l = 0;

2138

else

2139

auxp->x_sym.x_tagndx.l = symindx;

2140

}

2141

2142

/* The .bf symbols are supposed to be linked through

2143

the endndx field. We need to carry this list

2144

across object files. */

2145

if (i == 0

2146

&& h == NULL

2147

&& isymp->n_sclass == C_FCN

2148

&& (isymp->_n._n_n._n_zeroes != 0

2149

|| isymp->_n._n_n._n_offset == 0)

2150

&& isymp->_n._n_name[0] == '.'

2151

&& isymp->_n._n_name[1] == 'b'

2152

&& isymp->_n._n_name[2] == 'f'

2153

&& isymp->_n._n_name[3] == '\0')

2154

{

2155

if (flaginfo->last_bf_index != -1)

2156

{

2157

flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =

2158

*indexp;

2159

2160

if ((bfd_size_type) flaginfo->last_bf_index

2161

>= syment_base)

2162

{

2163

void *auxout;

2164

2165

/* The last .bf symbol is in this input

2166

file. This will only happen if the

2167

assembler did not set up the .bf

2168

endndx symbols correctly. */

2169

auxout = (flaginfo->outsyms

2170

+ ((flaginfo->last_bf_index

2171

- syment_base)

2172

* osymesz));

2173

2174

bfd_coff_swap_aux_out (output_bfd,

2175

&flaginfo->last_bf,

2176

isymp->n_type,

2177

isymp->n_sclass,

2178

0, isymp->n_numaux,

2179

auxout);

2180

}

2181

else

2182

{

2183

file_ptr pos;

2184

2185

/* We have already written out the last

2186

.bf aux entry. We need to write it

2187

out again. We borrow *outsym

2188

temporarily. FIXME: This case should

2189

be made faster. */

2190

bfd_coff_swap_aux_out (output_bfd,

2191

&flaginfo->last_bf,

2192

isymp->n_type,

2193

isymp->n_sclass,

2194

0, isymp->n_numaux,

2195

outsym);

2196

pos = obj_sym_filepos (output_bfd);

2197

pos += flaginfo->last_bf_index * osymesz;

2198

if (bfd_seek (output_bfd, pos, SEEK_SET) != 0

2199

|| (bfd_bwrite (outsym, osymesz, output_bfd)

2200

!= osymesz))

2201

return FALSE;

2202

}

2203

}

2204

2205

if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)

2206

flaginfo->last_bf_index = -1;

2207

else

2208

{

2209

/* The endndx field of this aux entry must

2210

be updated with the symbol number of the

2211

next .bf symbol. */

2212

flaginfo->last_bf = *auxp;

2213

flaginfo->last_bf_index = (((outsym - flaginfo->outsyms)

2214

/ osymesz)

2215

+ syment_base);

2216

}

2217

}

2218

}

2219

2220

if (h == NULL)

2221

{

2222

bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,

2223

isymp->n_sclass, i, isymp->n_numaux,

2224

outsym);

2225

outsym += osymesz;

2226

}

2227

2228

esym += isymesz;

2229

}

2230

}

2231

2232

indexp += add;

2233

isymp += add;

2234

sym_hash += add;

2235

}

2236

2237

/* Relocate the line numbers, unless we are stripping them. */

2238

if (flaginfo->info->strip == strip_none

2239

|| flaginfo->info->strip == strip_some)

2240

{

2241

for (o = input_bfd->sections; o != NULL; o = o->next)

2242

{

2243

bfd_vma offset;

2244

bfd_byte *eline;

2245

bfd_byte *elineend;

2246

bfd_byte *oeline;

2247

bfd_boolean skipping;

2248

file_ptr pos;

2249

bfd_size_type amt;

2250

2251

/* FIXME: If SEC_HAS_CONTENTS is not for the section, then

2252

build_link_order in ldwrite.c will not have created a

2253

link order, which means that we will not have seen this

2254

input section in _bfd_coff_final_link, which means that

2255

we will not have allocated space for the line numbers of

2256

this section. I don't think line numbers can be

2257

meaningful for a section which does not have

2258

SEC_HAS_CONTENTS set, but, if they do, this must be

2259

changed. */

2260

if (o->lineno_count == 0

2261

|| (o->output_section->flags & SEC_HAS_CONTENTS) == 0)

2262

continue;

2263

2264

if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0

2265

|| bfd_bread (flaginfo->linenos, linesz * o->lineno_count,

2266

input_bfd) != linesz * o->lineno_count)

2267

return FALSE;

2268

2269

offset = o->output_section->vma + o->output_offset - o->vma;

2270

eline = flaginfo->linenos;

2271

oeline = flaginfo->linenos;

2272

elineend = eline + linesz * o->lineno_count;

2273

skipping = FALSE;

2274

for (; eline < elineend; eline += linesz)

2275

{

2276

struct internal_lineno iline;

2277

2278

bfd_coff_swap_lineno_in (input_bfd, eline, &iline);

2279

2280

if (iline.l_lnno != 0)

2281

iline.l_addr.l_paddr += offset;

2282

else if (iline.l_addr.l_symndx >= 0

2283

&& ((unsigned long) iline.l_addr.l_symndx

2284

< obj_raw_syment_count (input_bfd)))

2285

{

2286

long indx;

2287

2288

indx = flaginfo->sym_indices[iline.l_addr.l_symndx];

2289

2290

if (indx < 0)

2291

{

2292

/* These line numbers are attached to a symbol

2293

which we are stripping. We must discard the

2294

line numbers because reading them back with

2295

no associated symbol (or associating them all

2296

with symbol #0) will fail. We can't regain

2297

the space in the output file, but at least

2298

they're dense. */

2299

skipping = TRUE;

2300

}

2301

else

2302

{

2303

struct internal_syment is;

2304

union internal_auxent ia;

2305

2306

/* Fix up the lnnoptr field in the aux entry of

2307

the symbol. It turns out that we can't do

2308

this when we modify the symbol aux entries,

2309

because gas sometimes screws up the lnnoptr

2310

field and makes it an offset from the start

2311

of the line numbers rather than an absolute

2312

file index. */

2313

bfd_coff_swap_sym_in (output_bfd,

2314

(flaginfo->outsyms

2315

+ ((indx - syment_base)

2316

* osymesz)), &is);

2317

if ((ISFCN (is.n_type)

2318

|| is.n_sclass == C_BLOCK)

2319

&& is.n_numaux >= 1)

2320

{

2321

void *auxptr;

2322

2323

auxptr = (flaginfo->outsyms

2324

+ ((indx - syment_base + 1)

2325

* osymesz));

2326

bfd_coff_swap_aux_in (output_bfd, auxptr,

2327

is.n_type, is.n_sclass,

2328

0, is.n_numaux, &ia);

2329

ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =

2330

(o->output_section->line_filepos

2331

+ o->output_section->lineno_count * linesz

2332

+ eline - flaginfo->linenos);

2333

bfd_coff_swap_aux_out (output_bfd, &ia,

2334

is.n_type, is.n_sclass, 0,

2335

is.n_numaux, auxptr);

2336

}

2337

2338

skipping = FALSE;

2339

}

2340

2341

iline.l_addr.l_symndx = indx;

2342

}

2343

2344

if (!skipping)

2345

{

2346

bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);

2347

oeline += linesz;

2348

}

2349

}

2350

2351

pos = o->output_section->line_filepos;

2352

pos += o->output_section->lineno_count * linesz;

2353

amt = oeline - flaginfo->linenos;

2354

if (bfd_seek (output_bfd, pos, SEEK_SET) != 0

2355

|| bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt)

2356

return FALSE;

2357

2358

o->output_section->lineno_count += amt / linesz;

2359

}

2360

}

2361

2362

/* If we swapped out a C_FILE symbol, guess that the next C_FILE

2363

symbol will be the first symbol in the next input file. In the

2364

normal case, this will save us from writing out the C_FILE symbol

2365

again. */

2366

if (flaginfo->last_file_index != -1

2367

&& (bfd_size_type) flaginfo->last_file_index >= syment_base)

2368

{

2369

flaginfo->last_file.n_value = output_index;

2370

bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file,

2371

(flaginfo->outsyms

2372

+ ((flaginfo->last_file_index - syment_base)

2373

* osymesz)));

2374

}

2375

2376

/* Write the modified symbols to the output file. */

2377

if (outsym > flaginfo->outsyms)

2378

{

2379

file_ptr pos;

2380

bfd_size_type amt;

2381

2382

pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;

2383

amt = outsym - flaginfo->outsyms;

2384

if (bfd_seek (output_bfd, pos, SEEK_SET) != 0

2385

|| bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt)

2386

return FALSE;

2387

2388

BFD_ASSERT ((obj_raw_syment_count (output_bfd)

2389

+ (outsym - flaginfo->outsyms) / osymesz)

2390

== output_index);

2391

2392

obj_raw_syment_count (output_bfd) = output_index;

2393

}

2394

2395

/* Relocate the contents of each section. */

2396

adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;

2397

for (o = input_bfd->sections; o != NULL; o = o->next)

2398

{

2399

bfd_byte *contents;

2400

struct coff_section_tdata *secdata;

2401

2402

if (! o->linker_mark)

2403

/* This section was omitted from the link. */

2404

continue;

2405

2406

if ((o->flags & SEC_LINKER_CREATED) != 0)

2407

continue;

2408

2409

if ((o->flags & SEC_HAS_CONTENTS) == 0

2410

|| (o->size == 0 && (o->flags & SEC_RELOC) == 0))

2411

{

2412

if ((o->flags & SEC_RELOC) != 0

2413

&& o->reloc_count != 0)

2414

{

2415

(*_bfd_error_handler)

2416

(_("%B: relocs in section `%A', but it has no contents"),

2417

input_bfd, o);

2418

bfd_set_error (bfd_error_no_contents);

2419

return FALSE;

2420

}

2421

2422

continue;

2423

}

2424

2425

secdata = coff_section_data (input_bfd, o);

2426

if (secdata != NULL && secdata->contents != NULL)

2427

contents = secdata->contents;

2428

else

2429

{

2430

contents = flaginfo->contents;

2431

if (! bfd_get_full_section_contents (input_bfd, o, &contents))

2432

return FALSE;

2433

}

2434

2435

if ((o->flags & SEC_RELOC) != 0)

2436

{

2437

int target_index;

2438

struct internal_reloc *internal_relocs;

2439

struct internal_reloc *irel;

2440

2441

/* Read in the relocs. */

2442

target_index = o->output_section->target_index;

2443

internal_relocs = (_bfd_coff_read_internal_relocs

2444

(input_bfd, o, FALSE, flaginfo->external_relocs,

2445

flaginfo->info->relocatable,

2446

(flaginfo->info->relocatable

2447

? (flaginfo->section_info[target_index].relocs

2448

+ o->output_section->reloc_count)

2449

: flaginfo->internal_relocs)));

2450

if (internal_relocs == NULL

2451

&& o->reloc_count > 0)

2452

return FALSE;

2453

2454

/* Run through the relocs looking for relocs against symbols

2455

coming from discarded sections and complain about them. */

2456

irel = internal_relocs;

2457

for (; irel < &internal_relocs[o->reloc_count]; irel++)

2458

{

2459

struct coff_link_hash_entry *h;

2460

asection *ps = NULL;

2461

long symndx = irel->r_symndx;

2462

if (symndx < 0)

2463

continue;

2464

h = obj_coff_sym_hashes (input_bfd)[symndx];

2465

if (h == NULL)

2466

continue;

2467

while (h->root.type == bfd_link_hash_indirect

2468

|| h->root.type == bfd_link_hash_warning)

2469

h = (struct coff_link_hash_entry *) h->root.u.i.link;

2470

if (h->root.type == bfd_link_hash_defined

2471

|| h->root.type == bfd_link_hash_defweak)

2472

ps = h->root.u.def.section;

2473

if (ps == NULL)

2474

continue;

2475

/* Complain if definition comes from an excluded section. */

2476

if (ps->flags & SEC_EXCLUDE)

2477

(*flaginfo->info->callbacks->einfo)

2478

(_("%X`%s' referenced in section `%A' of %B: "

2479

"defined in discarded section `%A' of %B\n"),

2480

h->root.root.string, o, input_bfd, ps, ps->owner);

2481

}

2482

2483

/* Call processor specific code to relocate the section

2484

contents. */

2485

if (! bfd_coff_relocate_section (output_bfd, flaginfo->info,

2486

input_bfd, o,

2487

contents,

2488

internal_relocs,

2489

flaginfo->internal_syms,

2490

flaginfo->sec_ptrs))

2491

return FALSE;

2492

2493

if (flaginfo->info->relocatable)

2494

{

2495

bfd_vma offset;

2496

struct internal_reloc *irelend;

2497

struct coff_link_hash_entry **rel_hash;

2498

2499

offset = o->output_section->vma + o->output_offset - o->vma;

2500

irel = internal_relocs;

2501

irelend = irel + o->reloc_count;

2502

rel_hash = (flaginfo->section_info[target_index].rel_hashes

2503

+ o->output_section->reloc_count);

2504

for (; irel < irelend; irel++, rel_hash++)

2505

{

2506

struct coff_link_hash_entry *h;

2507

bfd_boolean adjusted;

2508

2509

*rel_hash = NULL;

2510

2511

/* Adjust the reloc address and symbol index. */

2512

irel->r_vaddr += offset;

2513

2514

if (irel->r_symndx == -1)

2515

continue;

2516

2517

if (adjust_symndx)

2518

{

2519

if (! (*adjust_symndx) (output_bfd, flaginfo->info,

2520

input_bfd, o, irel,

2521

&adjusted))

2522

return FALSE;

2523

if (adjusted)

2524

continue;

2525

}

2526

2527

h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];

2528

if (h != NULL)

2529

{

2530

/* This is a global symbol. */

2531

if (h->indx >= 0)

2532

irel->r_symndx = h->indx;

2533

else

2534

{

2535

/* This symbol is being written at the end

2536

of the file, and we do not yet know the

2537

symbol index. We save the pointer to the

2538

hash table entry in the rel_hash list.

2539

We set the indx field to -2 to indicate

2540

that this symbol must not be stripped. */

2541

*rel_hash = h;

2542

h->indx = -2;

2543

}

2544

}

2545

else

2546

{

2547

long indx;

2548

2549

indx = flaginfo->sym_indices[irel->r_symndx];

2550

if (indx != -1)

2551

irel->r_symndx = indx;

2552

else

2553

{

2554

struct internal_syment *is;

2555

const char *name;

2556

char buf[SYMNMLEN + 1];

2557

2558

/* This reloc is against a symbol we are

2559

stripping. This should have been handled

2560

by the 'dont_skip_symbol' code in the while

2561

loop at the top of this function. */

2562

is = flaginfo->internal_syms + irel->r_symndx;

2563

2564

name = (_bfd_coff_internal_syment_name

2565

(input_bfd, is, buf));

2566

if (name == NULL)

2567

return FALSE;

2568

2569

if (! ((*flaginfo->info->callbacks->unattached_reloc)

2570

(flaginfo->info, name, input_bfd, o,

2571

irel->r_vaddr)))

2572

return FALSE;

2573

}

2574

}

2575

}

2576

2577

o->output_section->reloc_count += o->reloc_count;

2578

}

2579

}

2580

2581

/* Write out the modified section contents. */

2582

if (secdata == NULL || secdata->stab_info == NULL)

2583

{

2584

file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);

2585

if (! bfd_set_section_contents (output_bfd, o->output_section,

2586

contents, loc, o->size))

2587

return FALSE;

2588

}

2589

else

2590

{

2591

if (! (_bfd_write_section_stabs

2592

(output_bfd, &coff_hash_table (flaginfo->info)->stab_info,

2593

o, &secdata->stab_info, contents)))

2594

return FALSE;

2595

}

2596

}

2597

2598

if (! flaginfo->info->keep_memory

2599

&& ! _bfd_coff_free_symbols (input_bfd))

2600

return FALSE;

2601

2602

return TRUE;

2603

}

2604

2605

/* Write out a global symbol. Called via bfd_hash_traverse. */

2606

2607

bfd_boolean

2608

_bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)

2609

{

2610

struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;

2611

struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;

2612

bfd *output_bfd;

2613

struct internal_syment isym;

2614

bfd_size_type symesz;

2615

unsigned int i;

2616

file_ptr pos;

2617

2618

output_bfd = flaginfo->output_bfd;

2619

2620

if (h->root.type == bfd_link_hash_warning)

2621

{

2622

h = (struct coff_link_hash_entry *) h->root.u.i.link;

2623

if (h->root.type == bfd_link_hash_new)

2624

return TRUE;

2625

}

2626

2627

if (h->indx >= 0)

2628

return TRUE;

2629

2630

if (h->indx != -2

2631

&& (flaginfo->info->strip == strip_all

2632

|| (flaginfo->info->strip == strip_some

2633

&& (bfd_hash_lookup (flaginfo->info->keep_hash,

2634

h->root.root.string, FALSE, FALSE)

2635

== NULL))))

2636

return TRUE;

2637

2638

switch (h->root.type)

2639

{

2640

default:

2641

case bfd_link_hash_new:

2642

case bfd_link_hash_warning:

2643

abort ();

2644

return FALSE;

2645

2646

case bfd_link_hash_undefined:

2647

case bfd_link_hash_undefweak:

2648

isym.n_scnum = N_UNDEF;

2649

isym.n_value = 0;

2650

break;

2651

2652

case bfd_link_hash_defined:

2653

case bfd_link_hash_defweak:

2654

{

2655

asection *sec;

2656

2657

sec = h->root.u.def.section->output_section;

2658

if (bfd_is_abs_section (sec))

2659

isym.n_scnum = N_ABS;

2660

else

2661

isym.n_scnum = sec->target_index;

2662

isym.n_value = (h->root.u.def.value

2663

+ h->root.u.def.section->output_offset);

2664

if (! obj_pe (flaginfo->output_bfd))

2665

isym.n_value += sec->vma;

2666

}

2667

break;

2668

2669

case bfd_link_hash_common:

2670

isym.n_scnum = N_UNDEF;

2671

isym.n_value = h->root.u.c.size;

2672

break;

2673

2674

case bfd_link_hash_indirect:

2675

/* Just ignore these. They can't be handled anyhow. */

2676

return TRUE;

2677

}

2678

2679

if (strlen (h->root.root.string) <= SYMNMLEN)

2680

strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);

2681

else

2682

{

2683

bfd_boolean hash;

2684

bfd_size_type indx;

2685

2686

hash = TRUE;

2687

if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)

2688

hash = FALSE;

2689

indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash,

2690

FALSE);

2691

if (indx == (bfd_size_type) -1)

2692

{

2693

flaginfo->failed = TRUE;

2694

return FALSE;

2695

}

2696

isym._n._n_n._n_zeroes = 0;

2697

isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;

2698

}

2699

2700

isym.n_sclass = h->symbol_class;

2701

isym.n_type = h->type;

2702

2703

if (isym.n_sclass == C_NULL)

2704

isym.n_sclass = C_EXT;

2705

2706

/* If doing task linking and this is the pass where we convert

2707

defined globals to statics, then do that conversion now. If the

2708

symbol is not being converted, just ignore it and it will be

2709

output during a later pass. */

2710

if (flaginfo->global_to_static)

2711

{

2712

if (! IS_EXTERNAL (output_bfd, isym))

2713

return TRUE;

2714

2715

isym.n_sclass = C_STAT;

2716

}

2717

2718

/* When a weak symbol is not overridden by a strong one,

2719

turn it into an external symbol when not building a

2720

shared or relocatable object. */

2721

if (! flaginfo->info->shared

2722

&& ! flaginfo->info->relocatable

2723

&& IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))

2724

isym.n_sclass = C_EXT;

2725

2726

isym.n_numaux = h->numaux;

2727

2728

bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms);

2729

2730

symesz = bfd_coff_symesz (output_bfd);

2731

2732

pos = obj_sym_filepos (output_bfd);

2733

pos += obj_raw_syment_count (output_bfd) * symesz;

2734

if (bfd_seek (output_bfd, pos, SEEK_SET) != 0

2735

|| bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)

2736

{

2737

flaginfo->failed = TRUE;

2738

return FALSE;

2739

}

2740

2741

h->indx = obj_raw_syment_count (output_bfd);

2742

2743

++obj_raw_syment_count (output_bfd);

2744

2745

/* Write out any associated aux entries. Most of the aux entries

2746

will have been modified in _bfd_coff_link_input_bfd. We have to

2747

handle section aux entries here, now that we have the final

2748

relocation and line number counts. */

2749

for (i = 0; i < isym.n_numaux; i++)

2750

{

2751

union internal_auxent *auxp;

2752

2753

auxp = h->aux + i;

2754

2755

/* Look for a section aux entry here using the same tests that

2756

coff_swap_aux_out uses. */

2757

if (i == 0

2758

&& (isym.n_sclass == C_STAT

2759

|| isym.n_sclass == C_HIDDEN)

2760

&& isym.n_type == T_NULL

2761

&& (h->root.type == bfd_link_hash_defined

2762

|| h->root.type == bfd_link_hash_defweak))

2763

{

2764

asection *sec;

2765

2766

sec = h->root.u.def.section->output_section;

2767

if (sec != NULL)

2768

{

2769

auxp->x_scn.x_scnlen = sec->size;

2770

2771

/* For PE, an overflow on the final link reportedly does

2772

not matter. FIXME: Why not? */

2773

if (sec->reloc_count > 0xffff

2774

&& (! obj_pe (output_bfd)

2775

|| flaginfo->info->relocatable))

2776

(*_bfd_error_handler)

2777

(_("%s: %s: reloc overflow: 0x%lx > 0xffff"),

2778

bfd_get_filename (output_bfd),

2779

bfd_get_section_name (output_bfd, sec),

2780

sec->reloc_count);

2781

2782

if (sec->lineno_count > 0xffff

2783

&& (! obj_pe (output_bfd)

2784

|| flaginfo->info->relocatable))

2785

(*_bfd_error_handler)

2786

(_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),

2787

bfd_get_filename (output_bfd),

2788

bfd_get_section_name (output_bfd, sec),

2789

sec->lineno_count);

2790

2791

auxp->x_scn.x_nreloc = sec->reloc_count;

2792

auxp->x_scn.x_nlinno = sec->lineno_count;

2793

auxp->x_scn.x_checksum = 0;

2794

auxp->x_scn.x_associated = 0;

2795

auxp->x_scn.x_comdat = 0;

2796

}

2797

}

2798

2799

bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,

2800

isym.n_sclass, (int) i, isym.n_numaux,

2801

flaginfo->outsyms);

2802

if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)

2803

{

2804

flaginfo->failed = TRUE;

2805

return FALSE;

2806

}

2807

++obj_raw_syment_count (output_bfd);

2808

}

2809

2810

return TRUE;

2811

}

2812

2813

/* Write out task global symbols, converting them to statics. Called

2814

via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do

2815

the dirty work, if the symbol we are processing needs conversion. */

2816

2817

bfd_boolean

2818

_bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)

2819

{

2820

struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;

2821

bfd_boolean rtnval = TRUE;

2822

bfd_boolean save_global_to_static;

2823

2824

if (h->root.type == bfd_link_hash_warning)

2825

h = (struct coff_link_hash_entry *) h->root.u.i.link;

2826

2827

if (h->indx < 0)

2828

{

2829

switch (h->root.type)

2830

{

2831

case bfd_link_hash_defined:

2832

case bfd_link_hash_defweak:

2833

save_global_to_static = flaginfo->global_to_static;

2834

flaginfo->global_to_static = TRUE;

2835

rtnval = _bfd_coff_write_global_sym (&h->root.root, data);

2836

flaginfo->global_to_static = save_global_to_static;

2837

break;

2838

default:

2839

break;

2840

}

2841

}

2842

return (rtnval);

2843

}

2844

2845

/* Handle a link order which is supposed to generate a reloc. */

2846

2847

bfd_boolean

2848

_bfd_coff_reloc_link_order (bfd *output_bfd,

2849

struct coff_final_link_info *flaginfo,

2850

asection *output_section,

2851

struct bfd_link_order *link_order)

2852

{

2853

reloc_howto_type *howto;

2854

struct internal_reloc *irel;

2855

struct coff_link_hash_entry **rel_hash_ptr;

2856

2857

howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);

2858

if (howto == NULL)

2859

{

2860

bfd_set_error (bfd_error_bad_value);

2861

return FALSE;

2862

}

2863

2864

if (link_order->u.reloc.p->addend != 0)

2865

{

2866

bfd_size_type size;

2867

bfd_byte *buf;

2868

bfd_reloc_status_type rstat;

2869

bfd_boolean ok;

2870

file_ptr loc;

2871

2872

size = bfd_get_reloc_size (howto);

2873

buf = (bfd_byte *) bfd_zmalloc (size);

2874

if (buf == NULL)

2875

return FALSE;

2876

2877

rstat = _bfd_relocate_contents (howto, output_bfd,

2878

(bfd_vma) link_order->u.reloc.p->addend,\

2879

buf);

2880

switch (rstat)

2881

{

2882

case bfd_reloc_ok:

2883

break;

2884

default:

2885

case bfd_reloc_outofrange:

2886

abort ();

2887

case bfd_reloc_overflow:

2888

if (! ((*flaginfo->info->callbacks->reloc_overflow)

2889

(flaginfo->info, NULL,

2890

(link_order->type == bfd_section_reloc_link_order

2891

? bfd_section_name (output_bfd,

2892

link_order->u.reloc.p->u.section)

2893

: link_order->u.reloc.p->u.name),

2894

howto->name, link_order->u.reloc.p->addend,

2895

(bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))

2896

{

2897

free (buf);

2898

return FALSE;

2899

}

2900

break;

2901

}

2902

loc = link_order->offset * bfd_octets_per_byte (output_bfd);

2903

ok = bfd_set_section_contents (output_bfd, output_section, buf,

2904

loc, size);

2905

free (buf);

2906

if (! ok)

2907

return FALSE;

2908

}

2909

2910

/* Store the reloc information in the right place. It will get

2911

swapped and written out at the end of the final_link routine. */

2912

irel = (flaginfo->section_info[output_section->target_index].relocs

2913

+ output_section->reloc_count);

2914

rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes

2915

+ output_section->reloc_count);

2916

2917

memset (irel, 0, sizeof (struct internal_reloc));

2918

*rel_hash_ptr = NULL;

2919

2920

irel->r_vaddr = output_section->vma + link_order->offset;

2921

2922

if (link_order->type == bfd_section_reloc_link_order)

2923

{

2924

/* We need to somehow locate a symbol in the right section. The

2925

symbol must either have a value of zero, or we must adjust

2926

the addend by the value of the symbol. FIXME: Write this

2927

when we need it. The old linker couldn't handle this anyhow. */

2928

abort ();

2929

*rel_hash_ptr = NULL;

2930

irel->r_symndx = 0;

2931

}

2932

else

2933

{

2934

struct coff_link_hash_entry *h;

2935

2936

h = ((struct coff_link_hash_entry *)

2937

bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info,

2938

link_order->u.reloc.p->u.name,

2939

FALSE, FALSE, TRUE));

2940

if (h != NULL)

2941

{

2942

if (h->indx >= 0)

2943

irel->r_symndx = h->indx;

2944

else

2945

{

2946

/* Set the index to -2 to force this symbol to get

2947

written out. */

2948

h->indx = -2;

2949

*rel_hash_ptr = h;

2950

irel->r_symndx = 0;

2951

}

2952

}

2953

else

2954

{

2955

if (! ((*flaginfo->info->callbacks->unattached_reloc)

2956

(flaginfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,

2957

(asection *) NULL, (bfd_vma) 0)))

2958

return FALSE;

2959

irel->r_symndx = 0;

2960

}

2961

}

2962

2963

/* FIXME: Is this always right? */

2964

irel->r_type = howto->type;

2965

2966

/* r_size is only used on the RS/6000, which needs its own linker

2967

routines anyhow. r_extern is only used for ECOFF. */

2968

2969

/* FIXME: What is the right value for r_offset? Is zero OK? */

2970

++output_section->reloc_count;

2971

2972

return TRUE;

2973

}

2974

2975

/* A basic reloc handling routine which may be used by processors with

2976

simple relocs. */

2977

2978

bfd_boolean

2979

_bfd_coff_generic_relocate_section (bfd *output_bfd,

2980

struct bfd_link_info *info,

2981

bfd *input_bfd,

2982

asection *input_section,

2983

bfd_byte *contents,

2984

struct internal_reloc *relocs,

2985

struct internal_syment *syms,

2986

asection **sections)

2987

{

2988

struct internal_reloc *rel;

2989

struct internal_reloc *relend;

2990

2991

rel = relocs;

2992

relend = rel + input_section->reloc_count;

2993

for (; rel < relend; rel++)

2994

{

2995

long symndx;

2996

struct coff_link_hash_entry *h;

2997

struct internal_syment *sym;

2998

bfd_vma addend;

2999

bfd_vma val;

3000

reloc_howto_type *howto;

3001

bfd_reloc_status_type rstat;

3002

3003

symndx = rel->r_symndx;

3004

3005

if (symndx == -1)

3006

{

3007

h = NULL;

3008

sym = NULL;

3009

}

3010

else if (symndx < 0

3011

|| (unsigned long) symndx >= obj_raw_syment_count (input_bfd))

3012

{

3013

(*_bfd_error_handler)

3014

("%B: illegal symbol index %ld in relocs", input_bfd, symndx);

3015

return FALSE;

3016

}

3017

else

3018

{

3019

h = obj_coff_sym_hashes (input_bfd)[symndx];

3020

sym = syms + symndx;

3021

}

3022

3023

/* COFF treats common symbols in one of two ways. Either the

3024

size of the symbol is included in the section contents, or it

3025

is not. We assume that the size is not included, and force

3026

the rtype_to_howto function to adjust the addend as needed. */

3027

if (sym != NULL && sym->n_scnum != 0)

3028

addend = - sym->n_value;

3029

else

3030

addend = 0;

3031

3032

howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,

3033

sym, &addend);

3034

if (howto == NULL)

3035

return FALSE;

3036

3037

/* If we are doing a relocatable link, then we can just ignore

3038

a PC relative reloc that is pcrel_offset. It will already

3039

have the correct value. If this is not a relocatable link,

3040

then we should ignore the symbol value. */

3041

if (howto->pc_relative && howto->pcrel_offset)

3042

{

3043

if (info->relocatable)

3044

continue;

3045

if (sym != NULL && sym->n_scnum != 0)

3046

addend += sym->n_value;

3047

}

3048

3049

val = 0;

3050

3051

if (h == NULL)

3052

{

3053

asection *sec;

3054

3055

if (symndx == -1)

3056

{

3057

sec = bfd_abs_section_ptr;

3058

val = 0;

3059

}

3060

else

3061

{

3062

sec = sections[symndx];

3063

val = (sec->output_section->vma

3064

+ sec->output_offset

3065

+ sym->n_value);

3066

if (! obj_pe (input_bfd))

3067

val -= sec->vma;

3068

}

3069

}

3070

else

3071

{

3072

if (h->root.type == bfd_link_hash_defined

3073

|| h->root.type == bfd_link_hash_defweak)

3074

{

3075

/* Defined weak symbols are a GNU extension. */

3076

asection *sec;

3077

3078

sec = h->root.u.def.section;

3079

val = (h->root.u.def.value

3080

+ sec->output_section->vma

3081

+ sec->output_offset);

3082

}

3083

3084

else if (h->root.type == bfd_link_hash_undefweak)

3085

{

3086

if (h->symbol_class == C_NT_WEAK && h->numaux == 1)

3087

{

3088

/* See _Microsoft Portable Executable and Common Object

3089

File Format Specification_, section 5.5.3.

3090

Note that weak symbols without aux records are a GNU

3091

extension.

3092

FIXME: All weak externals are treated as having

3093

characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).

3094

These behave as per SVR4 ABI: A library member

3095

will resolve a weak external only if a normal

3096

external causes the library member to be linked.

3097

See also linker.c: generic_link_check_archive_element. */

3098

asection *sec;

3099

struct coff_link_hash_entry *h2 =

3100

h->auxbfd->tdata.coff_obj_data->sym_hashes[

3101

h->aux->x_sym.x_tagndx.l];

3102

3103

if (!h2 || h2->root.type == bfd_link_hash_undefined)

3104

{

3105

sec = bfd_abs_section_ptr;

3106

val = 0;

3107

}

3108

else

3109

{

3110

sec = h2->root.u.def.section;

3111

val = h2->root.u.def.value

3112

+ sec->output_section->vma + sec->output_offset;

3113

}

3114

}

3115

else

3116

/* This is a GNU extension. */

3117

val = 0;

3118

}

3119

3120

else if (! info->relocatable)

3121

{

3122

if (! ((*info->callbacks->undefined_symbol)

3123

(info, h->root.root.string, input_bfd, input_section,

3124

rel->r_vaddr - input_section->vma, TRUE)))

3125

return FALSE;

3126

}

3127

}

3128

3129

if (info->base_file)

3130

{

3131

/* Emit a reloc if the backend thinks it needs it. */

3132

if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))

3133

{

3134

/* Relocation to a symbol in a section which isn't

3135

absolute. We output the address here to a file.

3136

This file is then read by dlltool when generating the

3137

reloc section. Note that the base file is not

3138

portable between systems. We write out a bfd_vma here,

3139

and dlltool reads in a bfd_vma. */

3140

bfd_vma addr = (rel->r_vaddr

3141

- input_section->vma

3142

+ input_section->output_offset

3143

+ input_section->output_section->vma);

3144

if (coff_data (output_bfd)->pe)

3145

addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;

3146

if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)

3147

!= sizeof (bfd_vma))

3148

{

3149

bfd_set_error (bfd_error_system_call);

3150

return FALSE;

3151

}

3152

}

3153

}

3154

3155

rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,

3156

contents,

3157

rel->r_vaddr - input_section->vma,

3158

val, addend);

3159

3160

switch (rstat)

3161

{

3162

default:

3163

abort ();

3164

case bfd_reloc_ok:

3165

break;

3166

case bfd_reloc_outofrange:

3167

(*_bfd_error_handler)

3168

(_("%B: bad reloc address 0x%lx in section `%A'"),

3169

input_bfd, input_section, (unsigned long) rel->r_vaddr);

3170

return FALSE;

3171

case bfd_reloc_overflow:

3172

{

3173

const char *name;

3174

char buf[SYMNMLEN + 1];

3175

3176

if (symndx == -1)

3177

name = "*ABS*";

3178

else if (h != NULL)

3179

name = NULL;

3180

else

3181

{

3182

name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);

3183

if (name == NULL)

3184

return FALSE;

3185

}

3186

3187

if (! ((*info->callbacks->reloc_overflow)

3188

(info, (h ? &h->root : NULL), name, howto->name,

3189

(bfd_vma) 0, input_bfd, input_section,

3190

rel->r_vaddr - input_section->vma)))

3191

return FALSE;

3192

}

3193

}

3194

}

3195

return TRUE;

3196

}