~terry.guo/+junk/xbinutils : revision 1

1

/* nlmconv.c -- NLM conversion program

2

3

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

4

5

This file is part of GNU Binutils.

6

7

This program is free software; you can redistribute it and/or modify

8

it under the terms of the GNU General Public License as published by

9

the Free Software Foundation; either version 3 of the License, or

10

(at your option) any later version.

11

12

This program is distributed in the hope that it will be useful,

13

but WITHOUT ANY WARRANTY; without even the implied warranty of

14

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

15

GNU General Public License for more details.

16

17

You should have received a copy of the GNU General Public License

18

along with this program; if not, write to the Free Software

19

Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

20

MA 02110-1301, USA. */

21

22

23

/* Written by Ian Lance Taylor <ian@cygnus.com>.

24

25

This program can be used to convert any appropriate object file

26

into a NetWare Loadable Module (an NLM). It will accept a linker

27

specification file which is identical to that accepted by the

28

NetWare linker, NLMLINK. */

29

30

/* AIX requires this to be the first thing in the file. */

31

#ifndef __GNUC__

32

# ifdef _AIX

33

#pragma alloca

34

#endif

35

#endif

36

37

#include "sysdep.h"

38

#include "bfd.h"

39

#include "libiberty.h"

40

#include "filenames.h"

41

#include "safe-ctype.h"

42

43

#include "ansidecl.h"

44

#include <time.h>

45

#include <sys/stat.h>

46

#include <sys/file.h>

47

#include <assert.h>

48

#include "getopt.h"

49

50

/* Internal BFD NLM header. */

51

#include "libnlm.h"

52

#include "nlmconv.h"

53

54

#ifdef NLMCONV_ALPHA

55

#include "coff/sym.h"

56

#include "coff/ecoff.h"

57

#endif

58

59

#include "bucomm.h"

60

61

/* If strerror is just a macro, we want to use the one from libiberty

62

since it will handle undefined values. */

63

#undef strerror

64

extern char *strerror (int);

65

66

#ifndef SEEK_SET

67

#define SEEK_SET 0

68

#endif

69

70

#ifndef R_OK

71

#define R_OK 4

72

#define W_OK 2

73

#define X_OK 1

74

#endif

75

76

/* Global variables. */

77

78

/* The name used to invoke the program. */

79

char *program_name;

80

81

/* Local variables. */

82

83

/* Whether to print out debugging information (currently just controls

84

whether it prints the linker command if there is one). */

85

static int debug;

86

87

/* The symbol table. */

88

static asymbol **symbols;

89

90

/* A section we create in the output file to hold pointers to where

91

the sections of the input file end up. We will put a pointer to

92

this section in the NLM header. These is an entry for each input

93

section. The format is

94

null terminated section name

95

zeroes to adjust to 4 byte boundary

96

4 byte section data file pointer

97

4 byte section size

98

We don't need a version number. The way we find this information

99

is by finding a stamp in the NLM header information. If we need to

100

change the format of this information, we can simply change the

101

stamp. */

102

static asection *secsec;

103

104

/* A temporary file name to be unlinked on exit. Actually, for most

105

errors, we leave it around. It's not clear whether that is helpful

106

or not. */

107

static char *unlink_on_exit;

108

109

/* The list of long options. */

110

static struct option long_options[] =

111

{

112

{ "debug", no_argument, 0, 'd' },

113

{ "header-file", required_argument, 0, 'T' },

114

{ "help", no_argument, 0, 'h' },

115

{ "input-target", required_argument, 0, 'I' },

116

{ "input-format", required_argument, 0, 'I' }, /* Obsolete */

117

{ "linker", required_argument, 0, 'l' },

118

{ "output-target", required_argument, 0, 'O' },

119

{ "output-format", required_argument, 0, 'O' }, /* Obsolete */

120

{ "version", no_argument, 0, 'V' },

121

{ NULL, no_argument, 0, 0 }

122

};

123

124

/* Local routines. */

125

126

int main (int, char **);

127

128

static void show_usage (FILE *, int);

129

static const char *select_output_format

130

(enum bfd_architecture, unsigned long, bfd_boolean);

131

static void setup_sections (bfd *, asection *, void *);

132

static void copy_sections (bfd *, asection *, void *);

133

static void mangle_relocs

134

(bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

135

static void default_mangle_relocs

136

(bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

137

static char *link_inputs (struct string_list *, char *, char *);

138

139

#ifdef NLMCONV_I386

140

static void i386_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

141

#endif

142

143

#ifdef NLMCONV_ALPHA

144

static void alpha_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

145

#endif

146

147

#ifdef NLMCONV_POWERPC

148

static void powerpc_build_stubs (bfd *, bfd *, asymbol ***, long *);

149

static void powerpc_resolve_stubs (bfd *, bfd *);

150

static void powerpc_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

151

#endif

152

153

/* The main routine. */

154

155

int

156

main (int argc, char **argv)

157

{

158

int opt;

159

char *input_file = NULL;

160

const char *input_format = NULL;

161

const char *output_format = NULL;

162

const char *header_file = NULL;

163

char *ld_arg = NULL;

164

Nlm_Internal_Fixed_Header fixed_hdr_struct;

165

Nlm_Internal_Variable_Header var_hdr_struct;

166

Nlm_Internal_Version_Header version_hdr_struct;

167

Nlm_Internal_Copyright_Header copyright_hdr_struct;

168

Nlm_Internal_Extended_Header extended_hdr_struct;

169

bfd *inbfd;

170

bfd *outbfd;

171

asymbol **newsyms, **outsyms;

172

long symcount, newsymalloc, newsymcount;

173

long symsize;

174

asection *text_sec, *bss_sec, *data_sec;

175

bfd_vma vma;

176

bfd_size_type align;

177

asymbol *endsym;

178

long i;

179

char inlead, outlead;

180

bfd_boolean gotstart, gotexit, gotcheck;

181

struct stat st;

182

FILE *custom_data = NULL;

183

FILE *help_data = NULL;

184

FILE *message_data = NULL;

185

FILE *rpc_data = NULL;

186

FILE *shared_data = NULL;

187

size_t custom_size = 0;

188

size_t help_size = 0;

189

size_t message_size = 0;

190

size_t module_size = 0;

191

size_t rpc_size = 0;

192

asection *custom_section = NULL;

193

asection *help_section = NULL;

194

asection *message_section = NULL;

195

asection *module_section = NULL;

196

asection *rpc_section = NULL;

197

asection *shared_section = NULL;

198

bfd *sharedbfd;

199

size_t shared_offset = 0;

200

size_t shared_size = 0;

201

static Nlm_Internal_Fixed_Header sharedhdr;

202

int len;

203

char *modname;

204

char **matching;

205

206

#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)

207

setlocale (LC_MESSAGES, "");

208

#endif

209

#if defined (HAVE_SETLOCALE)

210

setlocale (LC_CTYPE, "");

211

#endif

212

bindtextdomain (PACKAGE, LOCALEDIR);

213

textdomain (PACKAGE);

214

215

program_name = argv[0];

216

xmalloc_set_program_name (program_name);

217

218

expandargv (&argc, &argv);

219

220

bfd_init ();

221

set_default_bfd_target ();

222

223

while ((opt = getopt_long (argc, argv, "dHhI:l:O:T:Vv", long_options,

224

(int *) NULL))

225

!= EOF)

226

{

227

switch (opt)

228

{

229

case 'd':

230

debug = 1;

231

break;

232

case 'H':

233

case 'h':

234

show_usage (stdout, 0);

235

break;

236

case 'I':

237

input_format = optarg;

238

break;

239

case 'l':

240

ld_arg = optarg;

241

break;

242

case 'O':

243

output_format = optarg;

244

break;

245

case 'T':

246

header_file = optarg;

247

break;

248

case 'v':

249

case 'V':

250

print_version ("nlmconv");

251

break;

252

case 0:

253

break;

254

default:

255

show_usage (stderr, 1);

256

break;

257

}

258

}

259

260

/* The input and output files may be named on the command line. */

261

output_file = NULL;

262

if (optind < argc)

263

{

264

input_file = argv[optind];

265

++optind;

266

if (optind < argc)

267

{

268

output_file = argv[optind];

269

++optind;

270

if (optind < argc)

271

show_usage (stderr, 1);

272

if (filename_cmp (input_file, output_file) == 0)

273

{

274

fatal (_("input and output files must be different"));

275

}

276

}

277

}

278

279

/* Initialize the header information to default values. */

280

fixed_hdr = &fixed_hdr_struct;

281

memset ((void *) &fixed_hdr_struct, 0, sizeof fixed_hdr_struct);

282

var_hdr = &var_hdr_struct;

283

memset ((void *) &var_hdr_struct, 0, sizeof var_hdr_struct);

284

version_hdr = &version_hdr_struct;

285

memset ((void *) &version_hdr_struct, 0, sizeof version_hdr_struct);

286

copyright_hdr = &copyright_hdr_struct;

287

memset ((void *) &copyright_hdr_struct, 0, sizeof copyright_hdr_struct);

288

extended_hdr = &extended_hdr_struct;

289

memset ((void *) &extended_hdr_struct, 0, sizeof extended_hdr_struct);

290

check_procedure = NULL;

291

custom_file = NULL;

292

debug_info = FALSE;

293

exit_procedure = "_Stop";

294

export_symbols = NULL;

295

map_file = NULL;

296

full_map = FALSE;

297

help_file = NULL;

298

import_symbols = NULL;

299

message_file = NULL;

300

modules = NULL;

301

sharelib_file = NULL;

302

start_procedure = "_Prelude";

303

verbose = FALSE;

304

rpc_file = NULL;

305

306

parse_errors = 0;

307

308

/* Parse the header file (if there is one). */

309

if (header_file != NULL)

310

{

311

if (! nlmlex_file (header_file)

312

|| yyparse () != 0

313

|| parse_errors != 0)

314

exit (1);

315

}

316

317

if (input_files != NULL)

318

{

319

if (input_file != NULL)

320

{

321

fatal (_("input file named both on command line and with INPUT"));

322

}

323

if (input_files->next == NULL)

324

input_file = input_files->string;

325

else

326

input_file = link_inputs (input_files, ld_arg, map_file);

327

}

328

else if (input_file == NULL)

329

{

330

non_fatal (_("no input file"));

331

show_usage (stderr, 1);

332

}

333

334

inbfd = bfd_openr (input_file, input_format);

335

if (inbfd == NULL)

336

bfd_fatal (input_file);

337

338

if (! bfd_check_format_matches (inbfd, bfd_object, &matching))

339

{

340

bfd_nonfatal (input_file);

341

if (bfd_get_error () == bfd_error_file_ambiguously_recognized)

342

{

343

list_matching_formats (matching);

344

free (matching);

345

}

346

exit (1);

347

}

348

349

if (output_format == NULL)

350

output_format = select_output_format (bfd_get_arch (inbfd),

351

bfd_get_mach (inbfd),

352

bfd_big_endian (inbfd));

353

354

assert (output_format != NULL);

355

356

/* Use the output file named on the command line if it exists.

357

Otherwise use the file named in the OUTPUT statement. */

358

if (output_file == NULL)

359

{

360

non_fatal (_("no name for output file"));

361

show_usage (stderr, 1);

362

}

363

364

outbfd = bfd_openw (output_file, output_format);

365

if (outbfd == NULL)

366

bfd_fatal (output_file);

367

if (! bfd_set_format (outbfd, bfd_object))

368

bfd_fatal (output_file);

369

370

assert (bfd_get_flavour (outbfd) == bfd_target_nlm_flavour);

371

372

/* XXX: Should we accept the unknown bfd format here ? */

373

if (bfd_arch_get_compatible (inbfd, outbfd, TRUE) == NULL)

374

non_fatal (_("warning: input and output formats are not compatible"));

375

376

/* Move the values read from the command file into outbfd. */

377

*nlm_fixed_header (outbfd) = fixed_hdr_struct;

378

*nlm_variable_header (outbfd) = var_hdr_struct;

379

*nlm_version_header (outbfd) = version_hdr_struct;

380

*nlm_copyright_header (outbfd) = copyright_hdr_struct;

381

*nlm_extended_header (outbfd) = extended_hdr_struct;

382

383

/* Start copying the input BFD to the output BFD. */

384

if (! bfd_set_file_flags (outbfd, bfd_get_file_flags (inbfd)))

385

bfd_fatal (bfd_get_filename (outbfd));

386

387

symsize = bfd_get_symtab_upper_bound (inbfd);

388

if (symsize < 0)

389

bfd_fatal (input_file);

390

symbols = (asymbol **) xmalloc (symsize);

391

symcount = bfd_canonicalize_symtab (inbfd, symbols);

392

if (symcount < 0)

393

bfd_fatal (input_file);

394

395

/* Make sure we have a .bss section. */

396

bss_sec = bfd_get_section_by_name (outbfd, NLM_UNINITIALIZED_DATA_NAME);

397

if (bss_sec == NULL)

398

{

399

bss_sec = bfd_make_section_with_flags (outbfd,

400

NLM_UNINITIALIZED_DATA_NAME,

401

SEC_ALLOC);

402

if (bss_sec == NULL

403

|| ! bfd_set_section_alignment (outbfd, bss_sec, 1))

404

bfd_fatal (_("make .bss section"));

405

}

406

407

/* We store the original section names in the .nlmsections section,

408

so that programs which understand it can resurrect the original

409

sections from the NLM. We will put a pointer to .nlmsections in

410

the NLM header area. */

411

secsec = bfd_make_section_with_flags (outbfd, ".nlmsections",

412

SEC_HAS_CONTENTS);

413

if (secsec == NULL)

414

bfd_fatal (_("make .nlmsections section"));

415

416

#ifdef NLMCONV_POWERPC

417

/* For PowerPC NetWare we need to build stubs for calls to undefined

418

symbols. Because each stub requires an entry in the TOC section

419

which must be at the same location as other entries in the TOC

420

section, we must do this before determining where the TOC section

421

goes in setup_sections. */

422

if (bfd_get_arch (inbfd) == bfd_arch_powerpc)

423

powerpc_build_stubs (inbfd, outbfd, &symbols, &symcount);

424

#endif

425

426

/* Set up the sections. */

427

bfd_map_over_sections (inbfd, setup_sections, (void *) outbfd);

428

429

text_sec = bfd_get_section_by_name (outbfd, NLM_CODE_NAME);

430

431

/* The .bss section immediately follows the .data section. */

432

data_sec = bfd_get_section_by_name (outbfd, NLM_INITIALIZED_DATA_NAME);

433

if (data_sec != NULL)

434

{

435

bfd_size_type add;

436

437

vma = bfd_get_section_size (data_sec);

438

align = 1 << bss_sec->alignment_power;

439

add = ((vma + align - 1) &~ (align - 1)) - vma;

440

vma += add;

441

if (! bfd_set_section_vma (outbfd, bss_sec, vma))

442

bfd_fatal (_("set .bss vma"));

443

if (add != 0)

444

{

445

bfd_size_type data_size;

446

447

data_size = bfd_get_section_size (data_sec);

448

if (! bfd_set_section_size (outbfd, data_sec, data_size + add))

449

bfd_fatal (_("set .data size"));

450

}

451

}

452

453

/* Adjust symbol information. */

454

inlead = bfd_get_symbol_leading_char (inbfd);

455

outlead = bfd_get_symbol_leading_char (outbfd);

456

gotstart = FALSE;

457

gotexit = FALSE;

458

gotcheck = FALSE;

459

newsymalloc = 10;

460

newsyms = (asymbol **) xmalloc (newsymalloc * sizeof (asymbol *));

461

newsymcount = 0;

462

endsym = NULL;

463

for (i = 0; i < symcount; i++)

464

{

465

asymbol *sym;

466

467

sym = symbols[i];

468

469

/* Add or remove a leading underscore. */

470

if (inlead != outlead)

471

{

472

if (inlead != '\0')

473

{

474

if (bfd_asymbol_name (sym)[0] == inlead)

475

{

476

if (outlead == '\0')

477

++sym->name;

478

else

479

{

480

char *new_name;

481

482

new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 1);

483

new_name[0] = outlead;

484

strcpy (new_name + 1, bfd_asymbol_name (sym) + 1);

485

sym->name = new_name;

486

}

487

}

488

}

489

else

490

{

491

char *new_name;

492

493

new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 2);

494

new_name[0] = outlead;

495

strcpy (new_name + 1, bfd_asymbol_name (sym));

496

sym->name = new_name;

497

}

498

}

499

500

/* NLM's have an uninitialized data section, but they do not

501

have a common section in the Unix sense. Move all common

502

symbols into the .bss section, and mark them as exported. */

503

if (bfd_is_com_section (bfd_get_section (sym)))

504

{

505

bfd_vma size = sym->value;

506

507

sym->section = bss_sec;

508

sym->value = bfd_get_section_size (bss_sec);

509

size += sym->value;

510

align = 1 << bss_sec->alignment_power;

511

size = (size + align - 1) & ~(align - 1);

512

bfd_set_section_size (outbfd, bss_sec, size);

513

sym->flags |= BSF_EXPORT | BSF_GLOBAL;

514

}

515

else if (bfd_get_section (sym)->output_section != NULL)

516

{

517

/* Move the symbol into the output section. */

518

sym->value += bfd_get_section (sym)->output_offset;

519

sym->section = bfd_get_section (sym)->output_section;

520

/* This is no longer a section symbol. */

521

sym->flags &=~ BSF_SECTION_SYM;

522

}

523

524

/* Force _edata and _end to be defined. This would normally be

525

done by the linker, but the manipulation of the common

526

symbols will confuse it. */

527

if ((sym->flags & BSF_DEBUGGING) == 0

528

&& bfd_asymbol_name (sym)[0] == '_'

529

&& bfd_is_und_section (bfd_get_section (sym)))

530

{

531

if (strcmp (bfd_asymbol_name (sym), "_edata") == 0)

532

{

533

sym->section = bss_sec;

534

sym->value = 0;

535

}

536

if (strcmp (bfd_asymbol_name (sym), "_end") == 0)

537

{

538

sym->section = bss_sec;

539

endsym = sym;

540

}

541

542

#ifdef NLMCONV_POWERPC

543

/* For PowerPC NetWare, we define __GOT0. This is the start

544

of the .got section. */

545

if (bfd_get_arch (inbfd) == bfd_arch_powerpc

546

&& strcmp (bfd_asymbol_name (sym), "__GOT0") == 0)

547

{

548

asection *got_sec;

549

550

got_sec = bfd_get_section_by_name (inbfd, ".got");

551

assert (got_sec != (asection *) NULL);

552

sym->value = got_sec->output_offset;

553

sym->section = got_sec->output_section;

554

}

555

#endif

556

}

557

558

/* If this is a global symbol, check the export list. */

559

if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0)

560

{

561

struct string_list *l;

562

int found_simple;

563

564

/* Unfortunately, a symbol can appear multiple times on the

565

export list, with and without prefixes. */

566

found_simple = 0;

567

for (l = export_symbols; l != NULL; l = l->next)

568

{

569

if (strcmp (l->string, bfd_asymbol_name (sym)) == 0)

570

found_simple = 1;

571

else

572

{

573

char *zbase;

574

575

zbase = strchr (l->string, '@');

576

if (zbase != NULL

577

&& strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0)

578

{

579

/* We must add a symbol with this prefix. */

580

if (newsymcount >= newsymalloc)

581

{

582

newsymalloc += 10;

583

newsyms = ((asymbol **)

584

xrealloc ((void *) newsyms,

585

(newsymalloc

586

* sizeof (asymbol *))));

587

}

588

newsyms[newsymcount] =

589

(asymbol *) xmalloc (sizeof (asymbol));

590

*newsyms[newsymcount] = *sym;

591

newsyms[newsymcount]->name = l->string;

592

++newsymcount;

593

}

594

}

595

}

596

if (! found_simple)

597

{

598

/* The unmodified symbol is actually not exported at

599

all. */

600

sym->flags &=~ (BSF_GLOBAL | BSF_EXPORT);

601

sym->flags |= BSF_LOCAL;

602

}

603

}

604

605

/* If it's an undefined symbol, see if it's on the import list.

606

Change the prefix if necessary. */

607

if (bfd_is_und_section (bfd_get_section (sym)))

608

{

609

struct string_list *l;

610

611

for (l = import_symbols; l != NULL; l = l->next)

612

{

613

if (strcmp (l->string, bfd_asymbol_name (sym)) == 0)

614

break;

615

else

616

{

617

char *zbase;

618

619

zbase = strchr (l->string, '@');

620

if (zbase != NULL

621

&& strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0)

622

{

623

sym->name = l->string;

624

break;

625

}

626

}

627

}

628

if (l == NULL)

629

non_fatal (_("warning: symbol %s imported but not in import list"),

630

bfd_asymbol_name (sym));

631

}

632

633

/* See if it's one of the special named symbols. */

634

if ((sym->flags & BSF_DEBUGGING) == 0)

635

{

636

bfd_vma val;

637

638

/* FIXME: If these symbols are not in the .text section, we

639

add the .text section size to the value. This may not be

640

correct for all targets. I'm not sure how this should

641

really be handled. */

642

if (strcmp (bfd_asymbol_name (sym), start_procedure) == 0)

643

{

644

val = bfd_asymbol_value (sym);

645

if (bfd_get_section (sym) == data_sec

646

&& text_sec != (asection *) NULL)

647

val += bfd_section_size (outbfd, text_sec);

648

if (! bfd_set_start_address (outbfd, val))

649

bfd_fatal (_("set start address"));

650

gotstart = TRUE;

651

}

652

if (strcmp (bfd_asymbol_name (sym), exit_procedure) == 0)

653

{

654

val = bfd_asymbol_value (sym);

655

if (bfd_get_section (sym) == data_sec

656

&& text_sec != (asection *) NULL)

657

val += bfd_section_size (outbfd, text_sec);

658

nlm_fixed_header (outbfd)->exitProcedureOffset = val;

659

gotexit = TRUE;

660

}

661

if (check_procedure != NULL

662

&& strcmp (bfd_asymbol_name (sym), check_procedure) == 0)

663

{

664

val = bfd_asymbol_value (sym);

665

if (bfd_get_section (sym) == data_sec

666

&& text_sec != (asection *) NULL)

667

val += bfd_section_size (outbfd, text_sec);

668

nlm_fixed_header (outbfd)->checkUnloadProcedureOffset = val;

669

gotcheck = TRUE;

670

}

671

}

672

}

673

674

if (endsym != NULL)

675

{

676

endsym->value = bfd_get_section_size (bss_sec);

677

678

/* FIXME: If any relocs referring to _end use inplace addends,

679

then I think they need to be updated. This is handled by

680

i386_mangle_relocs. Is it needed for any other object

681

formats? */

682

}

683

684

if (newsymcount == 0)

685

outsyms = symbols;

686

else

687

{

688

outsyms = (asymbol **) xmalloc ((symcount + newsymcount + 1)

689

* sizeof (asymbol *));

690

memcpy (outsyms, symbols, symcount * sizeof (asymbol *));

691

memcpy (outsyms + symcount, newsyms, newsymcount * sizeof (asymbol *));

692

outsyms[symcount + newsymcount] = NULL;

693

}

694

695

bfd_set_symtab (outbfd, outsyms, symcount + newsymcount);

696

697

if (! gotstart)

698

non_fatal (_("warning: START procedure %s not defined"), start_procedure);

699

if (! gotexit)

700

non_fatal (_("warning: EXIT procedure %s not defined"), exit_procedure);

701

if (check_procedure != NULL && ! gotcheck)

702

non_fatal (_("warning: CHECK procedure %s not defined"), check_procedure);

703

704

/* Add additional sections required for the header information. */

705

if (custom_file != NULL)

706

{

707

custom_data = fopen (custom_file, "r");

708

if (custom_data == NULL

709

|| fstat (fileno (custom_data), &st) < 0)

710

{

711

fprintf (stderr, "%s:%s: %s\n", program_name, custom_file,

712

strerror (errno));

713

custom_file = NULL;

714

}

715

else

716

{

717

custom_size = st.st_size;

718

custom_section = bfd_make_section_with_flags (outbfd, ".nlmcustom",

719

SEC_HAS_CONTENTS);

720

if (custom_section == NULL

721

|| ! bfd_set_section_size (outbfd, custom_section, custom_size))

722

bfd_fatal (_("custom section"));

723

}

724

}

725

if (help_file != NULL)

726

{

727

help_data = fopen (help_file, "r");

728

if (help_data == NULL

729

|| fstat (fileno (help_data), &st) < 0)

730

{

731

fprintf (stderr, "%s:%s: %s\n", program_name, help_file,

732

strerror (errno));

733

help_file = NULL;

734

}

735

else

736

{

737

help_size = st.st_size;

738

help_section = bfd_make_section_with_flags (outbfd, ".nlmhelp",

739

SEC_HAS_CONTENTS);

740

if (help_section == NULL

741

|| ! bfd_set_section_size (outbfd, help_section, help_size))

742

bfd_fatal (_("help section"));

743

LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

744

}

745

}

746

if (message_file != NULL)

747

{

748

message_data = fopen (message_file, "r");

749

if (message_data == NULL

750

|| fstat (fileno (message_data), &st) < 0)

751

{

752

fprintf (stderr, "%s:%s: %s\n", program_name, message_file,

753

strerror (errno));

754

message_file = NULL;

755

}

756

else

757

{

758

message_size = st.st_size;

759

message_section = bfd_make_section_with_flags (outbfd,

760

".nlmmessages",

761

SEC_HAS_CONTENTS);

762

if (message_section == NULL

763

|| ! bfd_set_section_size (outbfd, message_section, message_size))

764

bfd_fatal (_("message section"));

765

LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

766

}

767

}

768

if (modules != NULL)

769

{

770

struct string_list *l;

771

772

module_size = 0;

773

for (l = modules; l != NULL; l = l->next)

774

module_size += strlen (l->string) + 1;

775

module_section = bfd_make_section_with_flags (outbfd, ".nlmmodules",

776

SEC_HAS_CONTENTS);

777

if (module_section == NULL

778

|| ! bfd_set_section_size (outbfd, module_section, module_size))

779

bfd_fatal (_("module section"));

780

}

781

if (rpc_file != NULL)

782

{

783

rpc_data = fopen (rpc_file, "r");

784

if (rpc_data == NULL

785

|| fstat (fileno (rpc_data), &st) < 0)

786

{

787

fprintf (stderr, "%s:%s: %s\n", program_name, rpc_file,

788

strerror (errno));

789

rpc_file = NULL;

790

}

791

else

792

{

793

rpc_size = st.st_size;

794

rpc_section = bfd_make_section_with_flags (outbfd, ".nlmrpc",

795

SEC_HAS_CONTENTS);

796

if (rpc_section == NULL

797

|| ! bfd_set_section_size (outbfd, rpc_section, rpc_size))

798

bfd_fatal (_("rpc section"));

799

LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

800

}

801

}

802

if (sharelib_file != NULL)

803

{

804

sharedbfd = bfd_openr (sharelib_file, output_format);

805

if (sharedbfd == NULL

806

|| ! bfd_check_format (sharedbfd, bfd_object))

807

{

808

fprintf (stderr, "%s:%s: %s\n", program_name, sharelib_file,

809

bfd_errmsg (bfd_get_error ()));

810

sharelib_file = NULL;

811

}

812

else

813

{

814

sharedhdr = *nlm_fixed_header (sharedbfd);

815

bfd_close (sharedbfd);

816

shared_data = fopen (sharelib_file, "r");

817

if (shared_data == NULL

818

|| (fstat (fileno (shared_data), &st) < 0))

819

{

820

fprintf (stderr, "%s:%s: %s\n", program_name, sharelib_file,

821

strerror (errno));

822

sharelib_file = NULL;

823

}

824

else

825

{

826

/* If we were clever, we could just copy out the

827

sections of the shared library which we actually

828

need. However, we would have to figure out the sizes

829

of the external and public information, and that can

830

not be done without reading through them. */

831

if (sharedhdr.uninitializedDataSize > 0)

832

{

833

/* There is no place to record this information. */

834

non_fatal (_("%s: warning: shared libraries can not have uninitialized data"),

835

sharelib_file);

836

}

837

shared_offset = st.st_size;

838

if (shared_offset > (size_t) sharedhdr.codeImageOffset)

839

shared_offset = sharedhdr.codeImageOffset;

840

if (shared_offset > (size_t) sharedhdr.dataImageOffset)

841

shared_offset = sharedhdr.dataImageOffset;

842

if (shared_offset > (size_t) sharedhdr.relocationFixupOffset)

843

shared_offset = sharedhdr.relocationFixupOffset;

844

if (shared_offset > (size_t) sharedhdr.externalReferencesOffset)

845

shared_offset = sharedhdr.externalReferencesOffset;

846

if (shared_offset > (size_t) sharedhdr.publicsOffset)

847

shared_offset = sharedhdr.publicsOffset;

848

shared_size = st.st_size - shared_offset;

849

shared_section = bfd_make_section_with_flags (outbfd,

850

".nlmshared",

851

SEC_HAS_CONTENTS);

852

if (shared_section == NULL

853

|| ! bfd_set_section_size (outbfd, shared_section,

854

shared_size))

855

bfd_fatal (_("shared section"));

856

LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

857

}

858

}

859

}

860

861

/* Check whether a version was given. */

862

if (!CONST_STRNEQ (version_hdr->stamp, "VeRsIoN#"))

863

non_fatal (_("warning: No version number given"));

864

865

/* At least for now, always create an extended header, because that

866

is what NLMLINK does. */

867

LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

868

869

LITMEMCPY (nlm_cygnus_ext_header (outbfd)->stamp, "CyGnUsEx");

870

871

/* If the date was not given, force it in. */

872

if (nlm_version_header (outbfd)->month == 0

873

&& nlm_version_header (outbfd)->day == 0

874

&& nlm_version_header (outbfd)->year == 0)

875

{

876

time_t now;

877

struct tm *ptm;

878

879

time (&now);

880

ptm = localtime (&now);

881

nlm_version_header (outbfd)->month = ptm->tm_mon + 1;

882

nlm_version_header (outbfd)->day = ptm->tm_mday;

883

nlm_version_header (outbfd)->year = ptm->tm_year + 1900;

884

LITMEMCPY (version_hdr->stamp, "VeRsIoN#");

885

}

886

887

#ifdef NLMCONV_POWERPC

888

/* Resolve the stubs we build for PowerPC NetWare. */

889

if (bfd_get_arch (inbfd) == bfd_arch_powerpc)

890

powerpc_resolve_stubs (inbfd, outbfd);

891

#endif

892

893

/* Copy over the sections. */

894

bfd_map_over_sections (inbfd, copy_sections, (void *) outbfd);

895

896

/* Finish up the header information. */

897

if (custom_file != NULL)

898

{

899

void *data;

900

901

data = xmalloc (custom_size);

902

if (fread (data, 1, custom_size, custom_data) != custom_size)

903

non_fatal (_("%s: read: %s"), custom_file, strerror (errno));

904

else

905

{

906

if (! bfd_set_section_contents (outbfd, custom_section, data,

907

(file_ptr) 0, custom_size))

908

bfd_fatal (_("custom section"));

909

nlm_fixed_header (outbfd)->customDataOffset =

910

custom_section->filepos;

911

nlm_fixed_header (outbfd)->customDataSize = custom_size;

912

}

913

free (data);

914

}

915

if (! debug_info)

916

{

917

/* As a special hack, the backend recognizes a debugInfoOffset

918

of -1 to mean that it should not output any debugging

919

information. This can not be handling by fiddling with the

920

symbol table because exported symbols appear in both the

921

export information and the debugging information. */

922

nlm_fixed_header (outbfd)->debugInfoOffset = (file_ptr) -1;

923

}

924

if (full_map)

925

non_fatal (_("warning: FULLMAP is not supported; try ld -M"));

926

if (help_file != NULL)

927

{

928

void *data;

929

930

data = xmalloc (help_size);

931

if (fread (data, 1, help_size, help_data) != help_size)

932

non_fatal (_("%s: read: %s"), help_file, strerror (errno));

933

else

934

{

935

if (! bfd_set_section_contents (outbfd, help_section, data,

936

(file_ptr) 0, help_size))

937

bfd_fatal (_("help section"));

938

nlm_extended_header (outbfd)->helpFileOffset =

939

help_section->filepos;

940

nlm_extended_header (outbfd)->helpFileLength = help_size;

941

}

942

free (data);

943

}

944

if (message_file != NULL)

945

{

946

void *data;

947

948

data = xmalloc (message_size);

949

if (fread (data, 1, message_size, message_data) != message_size)

950

non_fatal (_("%s: read: %s"), message_file, strerror (errno));

951

else

952

{

953

if (! bfd_set_section_contents (outbfd, message_section, data,

954

(file_ptr) 0, message_size))

955

bfd_fatal (_("message section"));

956

nlm_extended_header (outbfd)->messageFileOffset =

957

message_section->filepos;

958

nlm_extended_header (outbfd)->messageFileLength = message_size;

959

960

/* FIXME: Are these offsets correct on all platforms? Are

961

they 32 bits on all platforms? What endianness? */

962

nlm_extended_header (outbfd)->languageID =

963

bfd_h_get_32 (outbfd, (bfd_byte *) data + 106);

964

nlm_extended_header (outbfd)->messageCount =

965

bfd_h_get_32 (outbfd, (bfd_byte *) data + 110);

966

}

967

free (data);

968

}

969

if (modules != NULL)

970

{

971

void *data;

972

unsigned char *set;

973

struct string_list *l;

974

bfd_size_type c;

975

976

data = xmalloc (module_size);

977

c = 0;

978

set = (unsigned char *) data;

979

for (l = modules; l != NULL; l = l->next)

980

{

981

*set = strlen (l->string);

982

strncpy ((char *) set + 1, l->string, *set);

983

set += *set + 1;

984

++c;

985

}

986

if (! bfd_set_section_contents (outbfd, module_section, data,

987

(file_ptr) 0, module_size))

988

bfd_fatal (_("module section"));

989

nlm_fixed_header (outbfd)->moduleDependencyOffset =

990

module_section->filepos;

991

nlm_fixed_header (outbfd)->numberOfModuleDependencies = c;

992

}

993

if (rpc_file != NULL)

994

{

995

void *data;

996

997

data = xmalloc (rpc_size);

998

if (fread (data, 1, rpc_size, rpc_data) != rpc_size)

999

non_fatal (_("%s: read: %s"), rpc_file, strerror (errno));

1000

else

1001

{

1002

if (! bfd_set_section_contents (outbfd, rpc_section, data,

1003

(file_ptr) 0, rpc_size))

1004

bfd_fatal (_("rpc section"));

1005

nlm_extended_header (outbfd)->RPCDataOffset =

1006

rpc_section->filepos;

1007

nlm_extended_header (outbfd)->RPCDataLength = rpc_size;

1008

}

1009

free (data);

1010

}

1011

if (sharelib_file != NULL)

1012

{

1013

void *data;

1014

1015

data = xmalloc (shared_size);

1016

if (fseek (shared_data, shared_offset, SEEK_SET) != 0

1017

|| fread (data, 1, shared_size, shared_data) != shared_size)

1018

non_fatal (_("%s: read: %s"), sharelib_file, strerror (errno));

1019

else

1020

{

1021

if (! bfd_set_section_contents (outbfd, shared_section, data,

1022

(file_ptr) 0, shared_size))

1023

bfd_fatal (_("shared section"));

1024

}

1025

nlm_extended_header (outbfd)->sharedCodeOffset =

1026

sharedhdr.codeImageOffset - shared_offset + shared_section->filepos;

1027

nlm_extended_header (outbfd)->sharedCodeLength =

1028

sharedhdr.codeImageSize;

1029

nlm_extended_header (outbfd)->sharedDataOffset =

1030

sharedhdr.dataImageOffset - shared_offset + shared_section->filepos;

1031

nlm_extended_header (outbfd)->sharedDataLength =

1032

sharedhdr.dataImageSize;

1033

nlm_extended_header (outbfd)->sharedRelocationFixupOffset =

1034

(sharedhdr.relocationFixupOffset

1035

- shared_offset

1036

+ shared_section->filepos);

1037

nlm_extended_header (outbfd)->sharedRelocationFixupCount =

1038

sharedhdr.numberOfRelocationFixups;

1039

nlm_extended_header (outbfd)->sharedExternalReferenceOffset =

1040

(sharedhdr.externalReferencesOffset

1041

- shared_offset

1042

+ shared_section->filepos);

1043

nlm_extended_header (outbfd)->sharedExternalReferenceCount =

1044

sharedhdr.numberOfExternalReferences;

1045

nlm_extended_header (outbfd)->sharedPublicsOffset =

1046

sharedhdr.publicsOffset - shared_offset + shared_section->filepos;

1047

nlm_extended_header (outbfd)->sharedPublicsCount =

1048

sharedhdr.numberOfPublics;

1049

nlm_extended_header (outbfd)->sharedDebugRecordOffset =

1050

sharedhdr.debugInfoOffset - shared_offset + shared_section->filepos;

1051

nlm_extended_header (outbfd)->sharedDebugRecordCount =

1052

sharedhdr.numberOfDebugRecords;

1053

nlm_extended_header (outbfd)->SharedInitializationOffset =

1054

sharedhdr.codeStartOffset;

1055

nlm_extended_header (outbfd)->SharedExitProcedureOffset =

1056

sharedhdr.exitProcedureOffset;

1057

free (data);

1058

}

1059

1060

{

1061

const int max_len = NLM_MODULE_NAME_SIZE - 2;

1062

const char * filename = lbasename (output_file);

1063

1064

len = strlen (filename);

1065

if (len > max_len)

1066

len = max_len;

1067

nlm_fixed_header (outbfd)->moduleName[0] = len;

1068

1069

strncpy (nlm_fixed_header (outbfd)->moduleName + 1, filename, max_len);

1070

nlm_fixed_header (outbfd)->moduleName[max_len + 1] = '\0';

1071

1072

for (modname = nlm_fixed_header (outbfd)->moduleName;

1073

*modname != '\0';

1074

modname++)

1075

*modname = TOUPPER (*modname);

1076

}

1077

1078

strncpy (nlm_variable_header (outbfd)->oldThreadName, " LONG",

1079

NLM_OLD_THREAD_NAME_LENGTH);

1080

1081

nlm_cygnus_ext_header (outbfd)->offset = secsec->filepos;

1082

nlm_cygnus_ext_header (outbfd)->length = bfd_section_size (outbfd, secsec);

1083

1084

if (! bfd_close (outbfd))

1085

bfd_fatal (output_file);

1086

if (! bfd_close (inbfd))

1087

bfd_fatal (input_file);

1088

1089

if (unlink_on_exit != NULL)

1090

unlink (unlink_on_exit);

1091

1092

return 0;

1093

}

1094

1095

1096

/* Show a usage message and exit. */

1097

1098

static void

1099

show_usage (FILE *file, int status)

1100

{

1101

fprintf (file, _("Usage: %s [option(s)] [in-file [out-file]]\n"), program_name);

1102

fprintf (file, _(" Convert an object file into a NetWare Loadable Module\n"));

1103

fprintf (file, _(" The options are:\n\

1104

-I --input-target=<bfdname> Set the input binary file format\n\

1105

-O --output-target=<bfdname> Set the output binary file format\n\

1106

-T --header-file=<file> Read <file> for NLM header information\n\

1107

-l --linker=<linker> Use <linker> for any linking\n\

1108

-d --debug Display on stderr the linker command line\n\

1109

@<file> Read options from <file>.\n\

1110

-h --help Display this information\n\

1111

-v --version Display the program's version\n\

1112

"));

1113

if (REPORT_BUGS_TO[0] && status == 0)

1114

fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);

1115

exit (status);

1116

}

1117

1118

/* Select the output format based on the input architecture, machine,

1119

and endianness. This chooses the appropriate NLM target. */

1120

1121

static const char *

1122

select_output_format (enum bfd_architecture arch, unsigned long mach,

1123

bfd_boolean bigendian ATTRIBUTE_UNUSED)

1124

{

1125

switch (arch)

1126

{

1127

#ifdef NLMCONV_I386

1128

case bfd_arch_i386:

1129

return "nlm32-i386";

1130

#endif

1131

#ifdef NLMCONV_SPARC

1132

case bfd_arch_sparc:

1133

return "nlm32-sparc";

1134

#endif

1135

#ifdef NLMCONV_ALPHA

1136

case bfd_arch_alpha:

1137

return "nlm32-alpha";

1138

#endif

1139

#ifdef NLMCONV_POWERPC

1140

case bfd_arch_powerpc:

1141

return "nlm32-powerpc";

1142

#endif

1143

default:

1144

fatal (_("support not compiled in for %s"),

1145

bfd_printable_arch_mach (arch, mach));

1146

}

1147

/*NOTREACHED*/

1148

}

1149

1150

/* The BFD sections are copied in two passes. This function selects

1151

the output section for each input section, and sets up the section

1152

name, size, etc. */

1153

1154

static void

1155

setup_sections (bfd *inbfd ATTRIBUTE_UNUSED, asection *insec, void *data_ptr)

1156

{

1157

bfd *outbfd = (bfd *) data_ptr;

1158

flagword f;

1159

const char *outname;

1160

asection *outsec;

1161

bfd_vma offset;

1162

bfd_size_type align;

1163

bfd_size_type add;

1164

bfd_size_type secsecsize;

1165

1166

f = bfd_get_section_flags (inbfd, insec);

1167

if (f & SEC_CODE)

1168

outname = NLM_CODE_NAME;

1169

else if ((f & SEC_LOAD) && (f & SEC_HAS_CONTENTS))

1170

outname = NLM_INITIALIZED_DATA_NAME;

1171

else if (f & SEC_ALLOC)

1172

outname = NLM_UNINITIALIZED_DATA_NAME;

1173

else

1174

outname = bfd_section_name (inbfd, insec);

1175

1176

outsec = bfd_get_section_by_name (outbfd, outname);

1177

if (outsec == NULL)

1178

{

1179

outsec = bfd_make_section (outbfd, outname);

1180

if (outsec == NULL)

1181

bfd_fatal (_("make section"));

1182

}

1183

1184

insec->output_section = outsec;

1185

1186

offset = bfd_section_size (outbfd, outsec);

1187

align = 1 << bfd_section_alignment (inbfd, insec);

1188

add = ((offset + align - 1) &~ (align - 1)) - offset;

1189

insec->output_offset = offset + add;

1190

1191

if (! bfd_set_section_size (outbfd, outsec,

1192

(bfd_section_size (outbfd, outsec)

1193

+ bfd_section_size (inbfd, insec)

1194

+ add)))

1195

bfd_fatal (_("set section size"));

1196

1197

if ((bfd_section_alignment (inbfd, insec)

1198

> bfd_section_alignment (outbfd, outsec))

1199

&& ! bfd_set_section_alignment (outbfd, outsec,

1200

bfd_section_alignment (inbfd, insec)))

1201

bfd_fatal (_("set section alignment"));

1202

1203

if (! bfd_set_section_flags (outbfd, outsec,

1204

f | bfd_get_section_flags (outbfd, outsec)))

1205

bfd_fatal (_("set section flags"));

1206

1207

bfd_set_reloc (outbfd, outsec, (arelent **) NULL, 0);

1208

1209

/* For each input section we allocate space for an entry in

1210

.nlmsections. */

1211

secsecsize = bfd_section_size (outbfd, secsec);

1212

secsecsize += strlen (bfd_section_name (inbfd, insec)) + 1;

1213

secsecsize = (secsecsize + 3) &~ 3;

1214

secsecsize += 8;

1215

if (! bfd_set_section_size (outbfd, secsec, secsecsize))

1216

bfd_fatal (_("set .nlmsections size"));

1217

}

1218

1219

/* Copy the section contents. */

1220

1221

static void

1222

copy_sections (bfd *inbfd, asection *insec, void *data_ptr)

1223

{

1224

static bfd_size_type secsecoff = 0;

1225

bfd *outbfd = (bfd *) data_ptr;

1226

const char *inname;

1227

asection *outsec;

1228

bfd_size_type size;

1229

void *contents;

1230

long reloc_size;

1231

bfd_byte buf[4];

1232

bfd_size_type add;

1233

1234

inname = bfd_section_name (inbfd, insec);

1235

1236

outsec = insec->output_section;

1237

assert (outsec != NULL);

1238

1239

size = bfd_get_section_size (insec);

1240

1241

if ((bfd_get_section_flags (inbfd, insec) & SEC_HAS_CONTENTS) == 0)

1242

contents = NULL;

1243

else

1244

{

1245

contents = xmalloc (size);

1246

if (! bfd_get_section_contents (inbfd, insec, contents,

1247

(file_ptr) 0, size))

1248

bfd_fatal (bfd_get_filename (inbfd));

1249

}

1250

1251

reloc_size = bfd_get_reloc_upper_bound (inbfd, insec);

1252

if (reloc_size < 0)

1253

bfd_fatal (bfd_get_filename (inbfd));

1254

if (reloc_size != 0)

1255

{

1256

arelent **relocs;

1257

long reloc_count;

1258

1259

relocs = (arelent **) xmalloc (reloc_size);

1260

reloc_count = bfd_canonicalize_reloc (inbfd, insec, relocs, symbols);

1261

if (reloc_count < 0)

1262

bfd_fatal (bfd_get_filename (inbfd));

1263

mangle_relocs (outbfd, insec, &relocs, &reloc_count, (char *) contents,

1264

size);

1265

1266

/* FIXME: refers to internal BFD fields. */

1267

if (outsec->orelocation != (arelent **) NULL)

1268

{

1269

bfd_size_type total_count;

1270

arelent **combined;

1271

1272

total_count = reloc_count + outsec->reloc_count;

1273

combined = (arelent **) xmalloc (total_count * sizeof (arelent *));

1274

memcpy (combined, outsec->orelocation,

1275

outsec->reloc_count * sizeof (arelent *));

1276

memcpy (combined + outsec->reloc_count, relocs,

1277

(size_t) (reloc_count * sizeof (arelent *)));

1278

free (outsec->orelocation);

1279

reloc_count = total_count;

1280

relocs = combined;

1281

}

1282

1283

bfd_set_reloc (outbfd, outsec, relocs, reloc_count);

1284

}

1285

1286

if (contents != NULL)

1287

{

1288

if (! bfd_set_section_contents (outbfd, outsec, contents,

1289

insec->output_offset, size))

1290

bfd_fatal (bfd_get_filename (outbfd));

1291

free (contents);

1292

}

1293

1294

/* Add this section to .nlmsections. */

1295

if (! bfd_set_section_contents (outbfd, secsec, (void *) inname, secsecoff,

1296

strlen (inname) + 1))

1297

bfd_fatal (_("set .nlmsection contents"));

1298

secsecoff += strlen (inname) + 1;

1299

1300

add = ((secsecoff + 3) &~ 3) - secsecoff;

1301

if (add != 0)

1302

{

1303

bfd_h_put_32 (outbfd, (bfd_vma) 0, buf);

1304

if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, add))

1305

bfd_fatal (_("set .nlmsection contents"));

1306

secsecoff += add;

1307

}

1308

1309

if (contents != NULL)

1310

bfd_h_put_32 (outbfd, (bfd_vma) outsec->filepos, buf);

1311

else

1312

bfd_h_put_32 (outbfd, (bfd_vma) 0, buf);

1313

if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, 4))

1314

bfd_fatal (_("set .nlmsection contents"));

1315

secsecoff += 4;

1316

1317

bfd_h_put_32 (outbfd, (bfd_vma) size, buf);

1318

if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, 4))

1319

bfd_fatal (_("set .nlmsection contents"));

1320

secsecoff += 4;

1321

}

1322

1323

/* Some, perhaps all, NetWare targets require changing the relocs used

1324

by the input formats. */

1325

1326

static void

1327

mangle_relocs (bfd *outbfd, asection *insec, arelent ***relocs_ptr,

1328

long *reloc_count_ptr, char *contents,

1329

bfd_size_type contents_size)

1330

{

1331

switch (bfd_get_arch (outbfd))

1332

{

1333

#ifdef NLMCONV_I386

1334

case bfd_arch_i386:

1335

i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr,

1336

contents, contents_size);

1337

break;

1338

#endif

1339

#ifdef NLMCONV_ALPHA

1340

case bfd_arch_alpha:

1341

alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr,

1342

contents, contents_size);

1343

break;

1344

#endif

1345

#ifdef NLMCONV_POWERPC

1346

case bfd_arch_powerpc:

1347

powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr,

1348

contents, contents_size);

1349

break;

1350

#endif

1351

default:

1352

default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr,

1353

contents, contents_size);

1354

break;

1355

}

1356

}

1357

1358

/* By default all we need to do for relocs is change the address by

1359

the output_offset. */

1360

1361

static void

1362

default_mangle_relocs (bfd *outbfd ATTRIBUTE_UNUSED, asection *insec,

1363

arelent ***relocs_ptr, long *reloc_count_ptr,

1364

char *contents ATTRIBUTE_UNUSED,

1365

bfd_size_type contents_size ATTRIBUTE_UNUSED)

1366

{

1367

if (insec->output_offset != 0)

1368

{

1369

long reloc_count;

1370

arelent **relocs;

1371

long i;

1372

1373

reloc_count = *reloc_count_ptr;

1374

relocs = *relocs_ptr;

1375

for (i = 0; i < reloc_count; i++, relocs++)

1376

(*relocs)->address += insec->output_offset;

1377

}

1378

}

1379

1380

#ifdef NLMCONV_I386

1381

1382

/* NetWare on the i386 supports a restricted set of relocs, which are

1383

different from those used on other i386 targets. This routine

1384

converts the relocs. It is, obviously, very target dependent. At

1385

the moment, the nlm32-i386 backend performs similar translations;

1386

however, it is more reliable and efficient to do them here. */

1387

1388

static reloc_howto_type nlm_i386_pcrel_howto =

1389

HOWTO (1, /* type */

1390

0, /* rightshift */

1391

2, /* size (0 = byte, 1 = short, 2 = long) */

1392

32, /* bitsize */

1393

TRUE, /* pc_relative */

1394

0, /* bitpos */

1395

complain_overflow_signed, /* complain_on_overflow */

1396

0, /* special_function */

1397

"DISP32", /* name */

1398

TRUE, /* partial_inplace */

1399

0xffffffff, /* src_mask */

1400

0xffffffff, /* dst_mask */

1401

TRUE); /* pcrel_offset */

1402

1403

static void

1404

i386_mangle_relocs (bfd *outbfd, asection *insec, arelent ***relocs_ptr,

1405

long *reloc_count_ptr, char *contents,

1406

bfd_size_type contents_size)

1407

{

1408

long reloc_count, i;

1409

arelent **relocs;

1410

1411

reloc_count = *reloc_count_ptr;

1412

relocs = *relocs_ptr;

1413

for (i = 0; i < reloc_count; i++)

1414

{

1415

arelent *rel;

1416

asymbol *sym;

1417

bfd_size_type address;

1418

bfd_vma addend;

1419

1420

rel = *relocs++;

1421

sym = *rel->sym_ptr_ptr;

1422

1423

/* We're moving the relocs from the input section to the output

1424

section, so we must adjust the address accordingly. */

1425

address = rel->address;

1426

rel->address += insec->output_offset;

1427

1428

/* Note that no serious harm will ensue if we fail to change a

1429

reloc. The backend will fail when writing out the reloc. */

1430

1431

/* Make sure this reloc is within the data we have. We use only

1432

4 byte relocs here, so we insist on having 4 bytes. */

1433

if (address + 4 > contents_size)

1434

continue;

1435

1436

/* A PC relative reloc entirely within a single section is

1437

completely unnecessary. This can be generated by ld -r. */

1438

if (sym == insec->symbol

1439

&& rel->howto != NULL

1440

&& rel->howto->pc_relative

1441

&& ! rel->howto->pcrel_offset)

1442

{

1443

--*reloc_count_ptr;

1444

--relocs;

1445

memmove (relocs, relocs + 1,

1446

(size_t) ((reloc_count - i) * sizeof (arelent *)));

1447

continue;

1448

}

1449

1450

/* Get the amount the relocation will add in. */

1451

addend = rel->addend + sym->value;

1452

1453

/* NetWare doesn't support PC relative relocs against defined

1454

symbols, so we have to eliminate them by doing the relocation

1455

now. We can only do this if the reloc is within a single

1456

section. */

1457

if (rel->howto != NULL

1458

&& rel->howto->pc_relative

1459

&& bfd_get_section (sym) == insec->output_section)

1460

{

1461

bfd_vma val;

1462

1463

if (rel->howto->pcrel_offset)

1464

addend -= address;

1465

1466

val = bfd_get_32 (outbfd, (bfd_byte *) contents + address);

1467

val += addend;

1468

bfd_put_32 (outbfd, val, (bfd_byte *) contents + address);

1469

1470

--*reloc_count_ptr;

1471

--relocs;

1472

memmove (relocs, relocs + 1,

1473

(size_t) ((reloc_count - i) * sizeof (arelent *)));

1474

continue;

1475

}

1476

1477

/* NetWare doesn't support reloc addends, so we get rid of them

1478

here by simply adding them into the object data. We handle

1479

the symbol value, if any, the same way. */

1480

if (addend != 0

1481

&& rel->howto != NULL

1482

&& rel->howto->rightshift == 0

1483

&& rel->howto->size == 2

1484

&& rel->howto->bitsize == 32

1485

&& rel->howto->bitpos == 0

1486

&& rel->howto->src_mask == 0xffffffff

1487

&& rel->howto->dst_mask == 0xffffffff)

1488

{

1489

bfd_vma val;

1490

1491

val = bfd_get_32 (outbfd, (bfd_byte *) contents + address);

1492

val += addend;

1493

bfd_put_32 (outbfd, val, (bfd_byte *) contents + address);

1494

1495

/* Adjust the reloc for the changes we just made. */

1496

rel->addend = 0;

1497

if (! bfd_is_und_section (bfd_get_section (sym)))

1498

rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr;

1499

}

1500

1501

/* NetWare uses a reloc with pcrel_offset set. We adjust

1502

pc_relative relocs accordingly. We are going to change the

1503

howto field, so we can only do this if the current one is

1504

compatible. We should check that special_function is NULL

1505

here, but at the moment coff-i386 uses a special_function

1506

which does not affect what we are doing here. */

1507

if (rel->howto != NULL

1508

&& rel->howto->pc_relative

1509

&& ! rel->howto->pcrel_offset

1510

&& rel->howto->rightshift == 0

1511

&& rel->howto->size == 2

1512

&& rel->howto->bitsize == 32

1513

&& rel->howto->bitpos == 0

1514

&& rel->howto->src_mask == 0xffffffff

1515

&& rel->howto->dst_mask == 0xffffffff)

1516

{

1517

bfd_vma val;

1518

1519

/* When pcrel_offset is not set, it means that the negative

1520

of the address of the memory location is stored in the

1521

memory location. We must add it back in. */

1522

val = bfd_get_32 (outbfd, (bfd_byte *) contents + address);

1523

val += address;

1524

bfd_put_32 (outbfd, val, (bfd_byte *) contents + address);

1525

1526

/* We must change to a new howto. */

1527

rel->howto = &nlm_i386_pcrel_howto;

1528

}

1529

}

1530

}

1531

1532

#endif /* NLMCONV_I386 */

1533

1534

#ifdef NLMCONV_ALPHA

1535

1536

/* On the Alpha the first reloc for every section must be a special

1537

relocs which hold the GP address. Also, the first reloc in the

1538

file must be a special reloc which holds the address of the .lita

1539

section. */

1540

1541

static reloc_howto_type nlm32_alpha_nw_howto =

1542

HOWTO (ALPHA_R_NW_RELOC, /* type */

1543

0, /* rightshift */

1544

0, /* size (0 = byte, 1 = short, 2 = long) */

1545

0, /* bitsize */

1546

FALSE, /* pc_relative */

1547

0, /* bitpos */

1548

complain_overflow_dont, /* complain_on_overflow */

1549

0, /* special_function */

1550

"NW_RELOC", /* name */

1551

FALSE, /* partial_inplace */

1552

0, /* src_mask */

1553

0, /* dst_mask */

1554

FALSE); /* pcrel_offset */

1555

1556

static void

1557

alpha_mangle_relocs (bfd *outbfd, asection *insec,

1558

arelent ***relocs_ptr, long *reloc_count_ptr,

1559

char *contents ATTRIBUTE_UNUSED,

1560

bfd_size_type contents_size ATTRIBUTE_UNUSED)

1561

{

1562

long old_reloc_count;

1563

arelent **old_relocs;

1564

arelent **relocs;

1565

1566

old_reloc_count = *reloc_count_ptr;

1567

old_relocs = *relocs_ptr;

1568

relocs = (arelent **) xmalloc ((old_reloc_count + 3) * sizeof (arelent *));

1569

*relocs_ptr = relocs;

1570

1571

if (nlm_alpha_backend_data (outbfd)->lita_address == 0)

1572

{

1573

bfd *inbfd;

1574

asection *lita_section;

1575

1576

inbfd = insec->owner;

1577

lita_section = bfd_get_section_by_name (inbfd, _LITA);

1578

if (lita_section != (asection *) NULL)

1579

{

1580

nlm_alpha_backend_data (outbfd)->lita_address =

1581

bfd_get_section_vma (inbfd, lita_section);

1582

nlm_alpha_backend_data (outbfd)->lita_size =

1583

bfd_section_size (inbfd, lita_section);

1584

}

1585

else

1586

{

1587

/* Avoid outputting this reloc again. */

1588

nlm_alpha_backend_data (outbfd)->lita_address = 4;

1589

}

1590

1591

*relocs = (arelent *) xmalloc (sizeof (arelent));

1592

(*relocs)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;

1593

(*relocs)->address = nlm_alpha_backend_data (outbfd)->lita_address;

1594

(*relocs)->addend = nlm_alpha_backend_data (outbfd)->lita_size + 1;

1595

(*relocs)->howto = &nlm32_alpha_nw_howto;

1596

++relocs;

1597

++(*reloc_count_ptr);

1598

}

1599

1600

/* Get the GP value from bfd. */

1601

if (nlm_alpha_backend_data (outbfd)->gp == 0)

1602

nlm_alpha_backend_data (outbfd)->gp =

1603

bfd_ecoff_get_gp_value (insec->owner);

1604

1605

*relocs = (arelent *) xmalloc (sizeof (arelent));

1606

(*relocs)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;

1607

(*relocs)->address = nlm_alpha_backend_data (outbfd)->gp;

1608

(*relocs)->addend = 0;

1609

(*relocs)->howto = &nlm32_alpha_nw_howto;

1610

++relocs;

1611

++(*reloc_count_ptr);

1612

1613

memcpy (relocs, old_relocs, (size_t) old_reloc_count * sizeof (arelent *));

1614

relocs[old_reloc_count] = (arelent *) NULL;

1615

1616

free (old_relocs);

1617

1618

if (insec->output_offset != 0)

1619

{

1620

bfd_size_type i;

1621

1622

for (i = 0; i < (bfd_size_type) old_reloc_count; i++, relocs++)

1623

(*relocs)->address += insec->output_offset;

1624

}

1625

}

1626

1627

#endif /* NLMCONV_ALPHA */

1628

1629

#ifdef NLMCONV_POWERPC

1630

1631

/* We keep a linked list of stubs which we must build. Because BFD

1632

requires us to know the sizes of all sections before we can set the

1633

contents of any, we must figure out which stubs we want to build

1634

before we can actually build any of them. */

1635

1636

struct powerpc_stub

1637

{

1638

/* Next stub in linked list. */

1639

struct powerpc_stub *next;

1640

1641

/* Symbol whose value is the start of the stub. This is a symbol

1642

whose name begins with `.'. */

1643

asymbol *start;

1644

1645

/* Symbol we are going to create a reloc against. This is a symbol

1646

with the same name as START but without the leading `.'. */

1647

asymbol *reloc;

1648

1649

/* The TOC index for this stub. This is the index into the TOC

1650

section at which the reloc is created. */

1651

unsigned int toc_index;

1652

};

1653

1654

/* The linked list of stubs. */

1655

1656

static struct powerpc_stub *powerpc_stubs;

1657

1658

/* This is what a stub looks like. The first instruction will get

1659

adjusted with the correct TOC index. */

1660

1661

static unsigned long powerpc_stub_insns[] =

1662

{

1663

0x81820000, /* lwz r12,0(r2) */

1664

0x90410014, /* stw r2,20(r1) */

1665

0x800c0000, /* lwz r0,0(r12) */

1666

0x804c0004, /* lwz r2,r(r12) */

1667

0x7c0903a6, /* mtctr r0 */

1668

0x4e800420, /* bctr */

1669

0, /* Traceback table. */

1670

0xc8000,

1671

0

1672

};

1673

1674

#define POWERPC_STUB_INSN_COUNT \

1675

(sizeof powerpc_stub_insns / sizeof powerpc_stub_insns[0])

1676

1677

#define POWERPC_STUB_SIZE (4 * POWERPC_STUB_INSN_COUNT)

1678

1679

/* Each stub uses a four byte TOC entry. */

1680

#define POWERPC_STUB_TOC_ENTRY_SIZE (4)

1681

1682

/* The original size of the .got section. */

1683

static bfd_size_type powerpc_initial_got_size;

1684

1685

/* Look for all undefined symbols beginning with `.', and prepare to

1686

build a stub for each one. */

1687

1688

static void

1689

powerpc_build_stubs (bfd *inbfd, bfd *outbfd ATTRIBUTE_UNUSED,

1690

asymbol ***symbols_ptr, long *symcount_ptr)

1691

{

1692

asection *stub_sec;

1693

asection *got_sec;

1694

unsigned int got_base;

1695

long i;

1696

long symcount;

1697

long stubcount;

1698

1699

/* Make a section to hold stubs. We don't set SEC_HAS_CONTENTS for

1700

the section to prevent copy_sections from reading from it. */

1701

stub_sec = bfd_make_section_with_flags (inbfd, ".stubs",

1702

(SEC_CODE

1703

| SEC_RELOC

1704

| SEC_ALLOC

1705

| SEC_LOAD));

1706

if (stub_sec == (asection *) NULL

1707

|| ! bfd_set_section_alignment (inbfd, stub_sec, 2))

1708

bfd_fatal (".stubs");

1709

1710

/* Get the TOC section, which is named .got. */

1711

got_sec = bfd_get_section_by_name (inbfd, ".got");

1712

if (got_sec == (asection *) NULL)

1713

{

1714

got_sec = bfd_make_section_with_flags (inbfd, ".got",

1715

(SEC_DATA

1716

| SEC_RELOC

1717

| SEC_ALLOC

1718

| SEC_LOAD

1719

| SEC_HAS_CONTENTS));

1720

if (got_sec == (asection *) NULL

1721

|| ! bfd_set_section_alignment (inbfd, got_sec, 2))

1722

bfd_fatal (".got");

1723

}

1724

1725

powerpc_initial_got_size = bfd_section_size (inbfd, got_sec);

1726

got_base = powerpc_initial_got_size;

1727

got_base = (got_base + 3) &~ 3;

1728

1729

stubcount = 0;

1730

1731

symcount = *symcount_ptr;

1732

for (i = 0; i < symcount; i++)

1733

{

1734

asymbol *sym;

1735

asymbol *newsym;

1736

char *newname;

1737

struct powerpc_stub *item;

1738

1739

sym = (*symbols_ptr)[i];

1740

1741

/* We must make a stub for every undefined symbol whose name

1742

starts with '.'. */

1743

if (bfd_asymbol_name (sym)[0] != '.'

1744

|| ! bfd_is_und_section (bfd_get_section (sym)))

1745

continue;

1746

1747

/* Make a new undefined symbol with the same name but without

1748

the leading `.'. */

1749

newsym = xmalloc (sizeof (asymbol));

1750

*newsym = *sym;

1751

newname = xmalloc (strlen (bfd_asymbol_name (sym)));

1752

strcpy (newname, bfd_asymbol_name (sym) + 1);

1753

newsym->name = newname;

1754

1755

/* Define the `.' symbol to be in the stub section. */

1756

sym->section = stub_sec;

1757

sym->value = stubcount * POWERPC_STUB_SIZE;

1758

/* We set the BSF_DYNAMIC flag here so that we can check it when

1759

we are mangling relocs. FIXME: This is a hack. */

1760

sym->flags = BSF_LOCAL | BSF_DYNAMIC;

1761

1762

/* Add this stub to the linked list. */

1763

item = (struct powerpc_stub *) xmalloc (sizeof (struct powerpc_stub));

1764

item->start = sym;

1765

item->reloc = newsym;

1766

item->toc_index = got_base + stubcount * POWERPC_STUB_TOC_ENTRY_SIZE;

1767

1768

item->next = powerpc_stubs;

1769

powerpc_stubs = item;

1770

1771

++stubcount;

1772

}

1773

1774

if (stubcount > 0)

1775

{

1776

asymbol **s;

1777

struct powerpc_stub *l;

1778

1779

/* Add the new symbols we just created to the symbol table. */

1780

*symbols_ptr = (asymbol **) xrealloc ((char *) *symbols_ptr,

1781

((symcount + stubcount)

1782

* sizeof (asymbol)));

1783

*symcount_ptr += stubcount;

1784

s = &(*symbols_ptr)[symcount];

1785

for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next)

1786

*s++ = l->reloc;

1787

1788

/* Set the size of the .stubs section and increase the size of

1789

the .got section. */

1790

if (! bfd_set_section_size (inbfd, stub_sec,

1791

stubcount * POWERPC_STUB_SIZE)

1792

|| ! bfd_set_section_size (inbfd, got_sec,

1793

(got_base

1794

+ (stubcount

1795

* POWERPC_STUB_TOC_ENTRY_SIZE))))

1796

bfd_fatal (_("stub section sizes"));

1797

}

1798

}

1799

1800

/* Resolve all the stubs for PowerPC NetWare. We fill in the contents

1801

of the output section, and create new relocs in the TOC. */

1802

1803

static void

1804

powerpc_resolve_stubs (bfd *inbfd, bfd *outbfd)

1805

{

1806

bfd_byte buf[POWERPC_STUB_SIZE];

1807

unsigned int i;

1808

unsigned int stubcount;

1809

arelent **relocs;

1810

asection *got_sec;

1811

arelent **r;

1812

struct powerpc_stub *l;

1813

1814

if (powerpc_stubs == (struct powerpc_stub *) NULL)

1815

return;

1816

1817

for (i = 0; i < POWERPC_STUB_INSN_COUNT; i++)

1818

bfd_put_32 (outbfd, (bfd_vma) powerpc_stub_insns[i], buf + i * 4);

1819

1820

got_sec = bfd_get_section_by_name (inbfd, ".got");

1821

assert (got_sec != (asection *) NULL);

1822

assert (got_sec->output_section->orelocation == (arelent **) NULL);

1823

1824

stubcount = 0;

1825

for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next)

1826

++stubcount;

1827

relocs = (arelent **) xmalloc (stubcount * sizeof (arelent *));

1828

1829

r = relocs;

1830

for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next)

1831

{

1832

arelent *reloc;

1833

1834

/* Adjust the first instruction to use the right TOC index. */

1835

bfd_put_32 (outbfd, (bfd_vma) powerpc_stub_insns[0] + l->toc_index, buf);

1836

1837

/* Write this stub out. */

1838

if (! bfd_set_section_contents (outbfd,

1839

bfd_get_section (l->start),

1840

buf,

1841

l->start->value,

1842

POWERPC_STUB_SIZE))

1843

bfd_fatal (_("writing stub"));

1844

1845

/* Create a new reloc for the TOC entry. */

1846

reloc = (arelent *) xmalloc (sizeof (arelent));

1847

reloc->sym_ptr_ptr = &l->reloc;

1848

reloc->address = l->toc_index + got_sec->output_offset;

1849

reloc->addend = 0;

1850

reloc->howto = bfd_reloc_type_lookup (inbfd, BFD_RELOC_32);

1851

1852

*r++ = reloc;

1853

}

1854

1855

bfd_set_reloc (outbfd, got_sec->output_section, relocs, stubcount);

1856

}

1857

1858

/* Adjust relocation entries for PowerPC NetWare. We do not output

1859

TOC relocations. The object code already contains the offset from

1860

the TOC pointer. When the function is called, the TOC register,

1861

r2, will be set to the correct TOC value, so there is no need for

1862

any further reloc. */

1863

1864

static void

1865

powerpc_mangle_relocs (bfd *outbfd, asection *insec,

1866

arelent ***relocs_ptr,

1867

long *reloc_count_ptr, char *contents,

1868

bfd_size_type contents_size ATTRIBUTE_UNUSED)

1869

{

1870

reloc_howto_type *toc_howto;

1871

long reloc_count;

1872

arelent **relocs;

1873

long i;

1874

1875

toc_howto = bfd_reloc_type_lookup (insec->owner, BFD_RELOC_PPC_TOC16);

1876

if (toc_howto == (reloc_howto_type *) NULL)

1877

abort ();

1878

1879

/* If this is the .got section, clear out all the contents beyond

1880

the initial size. We must do this here because copy_sections is

1881

going to write out whatever we return in the contents field. */

1882

if (strcmp (bfd_get_section_name (insec->owner, insec), ".got") == 0)

1883

memset (contents + powerpc_initial_got_size, 0,

1884

(size_t) (bfd_get_section_size (insec) - powerpc_initial_got_size));

1885

1886

reloc_count = *reloc_count_ptr;

1887

relocs = *relocs_ptr;

1888

for (i = 0; i < reloc_count; i++)

1889

{

1890

arelent *rel;

1891

asymbol *sym;

1892

bfd_vma sym_value;

1893

1894

rel = *relocs++;

1895

sym = *rel->sym_ptr_ptr;

1896

1897

/* Convert any relocs against the .bss section into relocs

1898

against the .data section. */

1899

if (strcmp (bfd_get_section_name (outbfd, bfd_get_section (sym)),

1900

NLM_UNINITIALIZED_DATA_NAME) == 0)

1901

{

1902

asection *datasec;

1903

1904

datasec = bfd_get_section_by_name (outbfd,

1905

NLM_INITIALIZED_DATA_NAME);

1906

if (datasec != NULL)

1907

{

1908

rel->addend += (bfd_get_section_vma (outbfd,

1909

bfd_get_section (sym))

1910

+ sym->value);

1911

rel->sym_ptr_ptr = datasec->symbol_ptr_ptr;

1912

sym = *rel->sym_ptr_ptr;

1913

}

1914

}

1915

1916

/* We must be able to resolve all PC relative relocs at this

1917

point. If we get a branch to an undefined symbol we build a

1918

stub, since NetWare will resolve undefined symbols into a

1919

pointer to a function descriptor. */

1920

if (rel->howto->pc_relative)

1921

{

1922

/* This check for whether a symbol is in the same section as

1923

the reloc will be wrong if there is a PC relative reloc

1924

between two sections both of which were placed in the

1925

same output section. This should not happen. */

1926

if (bfd_get_section (sym) != insec->output_section)

1927

non_fatal (_("unresolved PC relative reloc against %s"),

1928

bfd_asymbol_name (sym));

1929

else

1930

{

1931

bfd_vma val;

1932

1933

assert (rel->howto->size == 2 && rel->howto->pcrel_offset);

1934

val = bfd_get_32 (outbfd, (bfd_byte *) contents + rel->address);

1935

val = ((val &~ rel->howto->dst_mask)

1936

| (((val & rel->howto->src_mask)

1937

+ (sym->value - rel->address)

1938

+ rel->addend)

1939

& rel->howto->dst_mask));

1940

bfd_put_32 (outbfd, val, (bfd_byte *) contents + rel->address);

1941

1942

/* If this reloc is against an stubbed symbol and the

1943

next instruction is

1944

cror 31,31,31

1945

then we replace the next instruction with

1946

lwz r2,20(r1)

1947

This reloads the TOC pointer after a stub call. */

1948

if (bfd_asymbol_name (sym)[0] == '.'

1949

&& (sym->flags & BSF_DYNAMIC) != 0

1950

&& (bfd_get_32 (outbfd,

1951

(bfd_byte *) contents + rel->address + 4)

1952

== 0x4ffffb82)) /* cror 31,31,31 */

1953

bfd_put_32 (outbfd, (bfd_vma) 0x80410014, /* lwz r2,20(r1) */

1954

(bfd_byte *) contents + rel->address + 4);

1955

1956

--*reloc_count_ptr;

1957

--relocs;

1958

memmove (relocs, relocs + 1,

1959

(size_t) ((reloc_count - 1) * sizeof (arelent *)));

1960

continue;

1961

}

1962

}

1963

1964

/* When considering a TOC reloc, we do not want to include the

1965

symbol value. The symbol will be start of the TOC section

1966

(which is named .got). We do want to include the addend. */

1967

if (rel->howto == toc_howto)

1968

sym_value = 0;

1969

else

1970

sym_value = sym->value;

1971

1972

/* If this is a relocation against a symbol with a value, or

1973

there is a reloc addend, we need to update the addend in the

1974

object file. */

1975

if (sym_value + rel->addend != 0)

1976

{

1977

bfd_vma val;

1978

1979

switch (rel->howto->size)

1980

{

1981

case 1:

1982

val = bfd_get_16 (outbfd,

1983

(bfd_byte *) contents + rel->address);

1984

val = ((val &~ rel->howto->dst_mask)

1985

| (((val & rel->howto->src_mask)

1986

+ sym_value

1987

+ rel->addend)

1988

& rel->howto->dst_mask));

1989

if ((bfd_signed_vma) val < - 0x8000

1990

|| (bfd_signed_vma) val >= 0x8000)

1991

non_fatal (_("overflow when adjusting relocation against %s"),

1992

bfd_asymbol_name (sym));

1993

bfd_put_16 (outbfd, val, (bfd_byte *) contents + rel->address);

1994

break;

1995

1996

case 2:

1997

val = bfd_get_32 (outbfd,

1998

(bfd_byte *) contents + rel->address);

1999

val = ((val &~ rel->howto->dst_mask)

2000

| (((val & rel->howto->src_mask)

2001

+ sym_value

2002

+ rel->addend)

2003

& rel->howto->dst_mask));

2004

bfd_put_32 (outbfd, val, (bfd_byte *) contents + rel->address);

2005

break;

2006

2007

default:

2008

abort ();

2009

}

2010

2011

if (! bfd_is_und_section (bfd_get_section (sym)))

2012

rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr;

2013

rel->addend = 0;

2014

}

2015

2016

/* Now that we have incorporated the addend, remove any TOC

2017

relocs. */

2018

if (rel->howto == toc_howto)

2019

{

2020

--*reloc_count_ptr;

2021

--relocs;

2022

memmove (relocs, relocs + 1,

2023

(size_t) ((reloc_count - i) * sizeof (arelent *)));

2024

continue;

2025

}

2026

2027

rel->address += insec->output_offset;

2028

}

2029

}

2030

2031

#endif /* NLMCONV_POWERPC */

2032

2033

/* Name of linker. */

2034

#ifndef LD_NAME

2035

#define LD_NAME "ld"

2036

#endif

2037

2038

/* The user has specified several input files. Invoke the linker to

2039

link them all together, and convert and delete the resulting output

2040

file. */

2041

2042

static char *

2043

link_inputs (struct string_list *inputs, char *ld, char * mfile)

2044

{

2045

size_t c;

2046

struct string_list *q;

2047

char **argv;

2048

size_t i;

2049

int pid;

2050

int status;

2051

char *errfmt;

2052

char *errarg;

2053

2054

c = 0;

2055

for (q = inputs; q != NULL; q = q->next)

2056

++c;

2057

2058

argv = (char **) alloca ((c + 7) * sizeof (char *));

2059

2060

#ifndef __MSDOS__

2061

if (ld == NULL)

2062

{

2063

char *p;

2064

2065

/* Find the linker to invoke based on how nlmconv was run. */

2066

p = program_name + strlen (program_name);

2067

while (p != program_name)

2068

{

2069

if (p[-1] == '/')

2070

{

2071

ld = (char *) xmalloc (p - program_name + strlen (LD_NAME) + 1);

2072

memcpy (ld, program_name, p - program_name);

2073

strcpy (ld + (p - program_name), LD_NAME);

2074

break;

2075

}

2076

--p;

2077

}

2078

}

2079

#endif

2080

2081

if (ld == NULL)

2082

ld = (char *) LD_NAME;

2083

2084

unlink_on_exit = make_temp_file (".O");

2085

2086

argv[0] = ld;

2087

argv[1] = (char *) "-Ur";

2088

argv[2] = (char *) "-o";

2089

argv[3] = unlink_on_exit;

2090

/* If we have been given the name of a mapfile and that

2091

name is not 'stderr' then pass it on to the linker. */

2092

if (mfile

2093

&& * mfile

2094

&& strcmp (mfile, "stderr") == 0)

2095

{

2096

argv[4] = (char *) "-Map";

2097

argv[5] = mfile;

2098

i = 6;

2099

}

2100

else

2101

i = 4;

2102

2103

for (q = inputs; q != NULL; q = q->next, i++)

2104

argv[i] = q->string;

2105

argv[i] = NULL;

2106

2107

if (debug)

2108

{

2109

for (i = 0; argv[i] != NULL; i++)

2110

fprintf (stderr, " %s", argv[i]);

2111

fprintf (stderr, "\n");

2112

}

2113

2114

pid = pexecute (ld, argv, program_name, (char *) NULL, &errfmt, &errarg,

2115

PEXECUTE_SEARCH | PEXECUTE_ONE);

2116

if (pid == -1)

2117

{

2118

fprintf (stderr, _("%s: execution of %s failed: "), program_name, ld);

2119

fprintf (stderr, errfmt, errarg);

2120

unlink (unlink_on_exit);

2121

exit (1);

2122

}

2123

2124

if (pwait (pid, &status, 0) < 0)

2125

{

2126

perror ("pwait");

2127

unlink (unlink_on_exit);

2128

exit (1);

2129

}

2130

2131

if (status != 0)

2132

{

2133

non_fatal (_("Execution of %s failed"), ld);

2134

unlink (unlink_on_exit);

2135

exit (1);

2136

}

2137

2138

return unlink_on_exit;

2139

}