~louis/ubuntu/trusty/clamav/lp799623_fix

1

//===-- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info --===//

2

//

3

// The LLVM Compiler Infrastructure

4

//

5

// This file is distributed under the University of Illinois Open Source

6

// License. See LICENSE.TXT for details.

7

//

8

//===----------------------------------------------------------------------===//

9

//

10

// This file implements classes used to handle lowerings specific to common

11

// object file formats.

12

//

13

//===----------------------------------------------------------------------===//

14

15

#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"

16

#include "llvm/Constants.h"

17

#include "llvm/DerivedTypes.h"

18

#include "llvm/Function.h"

19

#include "llvm/GlobalVariable.h"

20

#include "llvm/CodeGen/MachineModuleInfoImpls.h"

21

#include "llvm/MC/MCContext.h"

22

#include "llvm/MC/MCExpr.h"

23

#include "llvm/MC/MCSectionMachO.h"

24

#include "llvm/MC/MCSectionELF.h"

25

#include "llvm/MC/MCSymbol.h"

26

#include "llvm/Target/Mangler.h"

27

#include "llvm/Target/TargetData.h"

28

#include "llvm/Target/TargetMachine.h"

29

#include "llvm/Target/TargetOptions.h"

30

#include "llvm/Support/Dwarf.h"

31

#include "llvm/Support/ErrorHandling.h"

32

#include "llvm/Support/raw_ostream.h"

33

#include "llvm/ADT/SmallString.h"

34

#include "llvm/ADT/StringExtras.h"

35

using namespace llvm;

36

using namespace dwarf;

37

38

//===----------------------------------------------------------------------===//

39

// ELF

40

//===----------------------------------------------------------------------===//

41

typedef StringMap<const MCSectionELF*> ELFUniqueMapTy;

42

43

TargetLoweringObjectFileELF::~TargetLoweringObjectFileELF() {

44

// If we have the section uniquing map, free it.

45

delete (ELFUniqueMapTy*)UniquingMap;

46

}

47

48

const MCSection *TargetLoweringObjectFileELF::

49

getELFSection(StringRef Section, unsigned Type, unsigned Flags,

50

SectionKind Kind, bool IsExplicit) const {

51

if (UniquingMap == 0)

52

UniquingMap = new ELFUniqueMapTy();

53

ELFUniqueMapTy &Map = *(ELFUniqueMapTy*)UniquingMap;

54

55

// Do the lookup, if we have a hit, return it.

56

const MCSectionELF *&Entry = Map[Section];

57

if (Entry) return Entry;

58

59

return Entry = MCSectionELF::Create(Section, Type, Flags, Kind, IsExplicit,

60

getContext());

61

}

62

63

void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,

64

const TargetMachine &TM) {

65

if (UniquingMap != 0)

66

((ELFUniqueMapTy*)UniquingMap)->clear();

67

TargetLoweringObjectFile::Initialize(Ctx, TM);

68

69

BSSSection =

70

getELFSection(".bss", MCSectionELF::SHT_NOBITS,

71

MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,

72

SectionKind::getBSS());

73

74

TextSection =

75

getELFSection(".text", MCSectionELF::SHT_PROGBITS,

76

MCSectionELF::SHF_EXECINSTR | MCSectionELF::SHF_ALLOC,

77

SectionKind::getText());

78

79

DataSection =

80

getELFSection(".data", MCSectionELF::SHT_PROGBITS,

81

MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,

82

SectionKind::getDataRel());

83

84

ReadOnlySection =

85

getELFSection(".rodata", MCSectionELF::SHT_PROGBITS,

86

MCSectionELF::SHF_ALLOC,

87

SectionKind::getReadOnly());

88

89

TLSDataSection =

90

getELFSection(".tdata", MCSectionELF::SHT_PROGBITS,

91

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |

92

MCSectionELF::SHF_WRITE, SectionKind::getThreadData());

93

94

TLSBSSSection =

95

getELFSection(".tbss", MCSectionELF::SHT_NOBITS,

96

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |

97

MCSectionELF::SHF_WRITE, SectionKind::getThreadBSS());

98

99

DataRelSection =

100

getELFSection(".data.rel", MCSectionELF::SHT_PROGBITS,

101

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,

102

SectionKind::getDataRel());

103

104

DataRelLocalSection =

105

getELFSection(".data.rel.local", MCSectionELF::SHT_PROGBITS,

106

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,

107

SectionKind::getDataRelLocal());

108

109

DataRelROSection =

110

getELFSection(".data.rel.ro", MCSectionELF::SHT_PROGBITS,

111

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,

112

SectionKind::getReadOnlyWithRel());

113

114

DataRelROLocalSection =

115

getELFSection(".data.rel.ro.local", MCSectionELF::SHT_PROGBITS,

116

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,

117

SectionKind::getReadOnlyWithRelLocal());

118

119

MergeableConst4Section =

120

getELFSection(".rodata.cst4", MCSectionELF::SHT_PROGBITS,

121

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,

122

SectionKind::getMergeableConst4());

123

124

MergeableConst8Section =

125

getELFSection(".rodata.cst8", MCSectionELF::SHT_PROGBITS,

126

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,

127

SectionKind::getMergeableConst8());

128

129

MergeableConst16Section =

130

getELFSection(".rodata.cst16", MCSectionELF::SHT_PROGBITS,

131

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,

132

SectionKind::getMergeableConst16());

133

134

StaticCtorSection =

135

getELFSection(".ctors", MCSectionELF::SHT_PROGBITS,

136

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,

137

SectionKind::getDataRel());

138

139

StaticDtorSection =

140

getELFSection(".dtors", MCSectionELF::SHT_PROGBITS,

141

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,

142

SectionKind::getDataRel());

143

144

// Exception Handling Sections.

145

146

// FIXME: We're emitting LSDA info into a readonly section on ELF, even though

147

// it contains relocatable pointers. In PIC mode, this is probably a big

148

// runtime hit for C++ apps. Either the contents of the LSDA need to be

149

// adjusted or this should be a data section.

150

LSDASection =

151

getELFSection(".gcc_except_table", MCSectionELF::SHT_PROGBITS,

152

MCSectionELF::SHF_ALLOC, SectionKind::getReadOnly());

153

EHFrameSection =

154

getELFSection(".eh_frame", MCSectionELF::SHT_PROGBITS,

155

MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,

156

SectionKind::getDataRel());

157

158

// Debug Info Sections.

159

DwarfAbbrevSection =

160

getELFSection(".debug_abbrev", MCSectionELF::SHT_PROGBITS, 0,

161

SectionKind::getMetadata());

162

DwarfInfoSection =

163

getELFSection(".debug_info", MCSectionELF::SHT_PROGBITS, 0,

164

SectionKind::getMetadata());

165

DwarfLineSection =

166

getELFSection(".debug_line", MCSectionELF::SHT_PROGBITS, 0,

167

SectionKind::getMetadata());

168

DwarfFrameSection =

169

getELFSection(".debug_frame", MCSectionELF::SHT_PROGBITS, 0,

170

SectionKind::getMetadata());

171

DwarfPubNamesSection =

172

getELFSection(".debug_pubnames", MCSectionELF::SHT_PROGBITS, 0,

173

SectionKind::getMetadata());

174

DwarfPubTypesSection =

175

getELFSection(".debug_pubtypes", MCSectionELF::SHT_PROGBITS, 0,

176

SectionKind::getMetadata());

177

DwarfStrSection =

178

getELFSection(".debug_str", MCSectionELF::SHT_PROGBITS, 0,

179

SectionKind::getMetadata());

180

DwarfLocSection =

181

getELFSection(".debug_loc", MCSectionELF::SHT_PROGBITS, 0,

182

SectionKind::getMetadata());

183

DwarfARangesSection =

184

getELFSection(".debug_aranges", MCSectionELF::SHT_PROGBITS, 0,

185

SectionKind::getMetadata());

186

DwarfRangesSection =

187

getELFSection(".debug_ranges", MCSectionELF::SHT_PROGBITS, 0,

188

SectionKind::getMetadata());

189

DwarfMacroInfoSection =

190

getELFSection(".debug_macinfo", MCSectionELF::SHT_PROGBITS, 0,

191

SectionKind::getMetadata());

192

}

193

194

195

static SectionKind

196

getELFKindForNamedSection(StringRef Name, SectionKind K) {

197

if (Name.empty() || Name[0] != '.') return K;

198

199

// Some lame default implementation based on some magic section names.

200

if (Name == ".bss" ||

201

Name.startswith(".bss.") ||

202

Name.startswith(".gnu.linkonce.b.") ||

203

Name.startswith(".llvm.linkonce.b.") ||

204

Name == ".sbss" ||

205

Name.startswith(".sbss.") ||

206

Name.startswith(".gnu.linkonce.sb.") ||

207

Name.startswith(".llvm.linkonce.sb."))

208

return SectionKind::getBSS();

209

210

if (Name == ".tdata" ||

211

Name.startswith(".tdata.") ||

212

Name.startswith(".gnu.linkonce.td.") ||

213

Name.startswith(".llvm.linkonce.td."))

214

return SectionKind::getThreadData();

215

216

if (Name == ".tbss" ||

217

Name.startswith(".tbss.") ||

218

Name.startswith(".gnu.linkonce.tb.") ||

219

Name.startswith(".llvm.linkonce.tb."))

220

return SectionKind::getThreadBSS();

221

222

return K;

223

}

224

225

226

static unsigned getELFSectionType(StringRef Name, SectionKind K) {

227

228

if (Name == ".init_array")

229

return MCSectionELF::SHT_INIT_ARRAY;

230

231

if (Name == ".fini_array")

232

return MCSectionELF::SHT_FINI_ARRAY;

233

234

if (Name == ".preinit_array")

235

return MCSectionELF::SHT_PREINIT_ARRAY;

236

237

if (K.isBSS() || K.isThreadBSS())

238

return MCSectionELF::SHT_NOBITS;

239

240

return MCSectionELF::SHT_PROGBITS;

241

}

242

243

244

static unsigned

245

getELFSectionFlags(SectionKind K) {

246

unsigned Flags = 0;

247

248

if (!K.isMetadata())

249

Flags |= MCSectionELF::SHF_ALLOC;

250

251

if (K.isText())

252

Flags |= MCSectionELF::SHF_EXECINSTR;

253

254

if (K.isWriteable())

255

Flags |= MCSectionELF::SHF_WRITE;

256

257

if (K.isThreadLocal())

258

Flags |= MCSectionELF::SHF_TLS;

259

260

// K.isMergeableConst() is left out to honour PR4650

261

if (K.isMergeableCString() || K.isMergeableConst4() ||

262

K.isMergeableConst8() || K.isMergeableConst16())

263

Flags |= MCSectionELF::SHF_MERGE;

264

265

if (K.isMergeableCString())

266

Flags |= MCSectionELF::SHF_STRINGS;

267

268

return Flags;

269

}

270

271

272

const MCSection *TargetLoweringObjectFileELF::

273

getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,

274

Mangler *Mang, const TargetMachine &TM) const {

275

StringRef SectionName = GV->getSection();

276

277

// Infer section flags from the section name if we can.

278

Kind = getELFKindForNamedSection(SectionName, Kind);

279

280

return getELFSection(SectionName,

281

getELFSectionType(SectionName, Kind),

282

getELFSectionFlags(Kind), Kind, true);

283

}

284

285

static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {

286

if (Kind.isText()) return ".gnu.linkonce.t.";

287

if (Kind.isReadOnly()) return ".gnu.linkonce.r.";

288

289

if (Kind.isThreadData()) return ".gnu.linkonce.td.";

290

if (Kind.isThreadBSS()) return ".gnu.linkonce.tb.";

291

292

if (Kind.isDataNoRel()) return ".gnu.linkonce.d.";

293

if (Kind.isDataRelLocal()) return ".gnu.linkonce.d.rel.local.";

294

if (Kind.isDataRel()) return ".gnu.linkonce.d.rel.";

295

if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";

296

297

assert(Kind.isReadOnlyWithRel() && "Unknown section kind");

298

return ".gnu.linkonce.d.rel.ro.";

299

}

300

301

const MCSection *TargetLoweringObjectFileELF::

302

SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,

303

Mangler *Mang, const TargetMachine &TM) const {

304

305

// If this global is linkonce/weak and the target handles this by emitting it

306

// into a 'uniqued' section name, create and return the section now.

307

if (GV->isWeakForLinker() && !Kind.isCommon() && !Kind.isBSS()) {

308

const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);

309

SmallString<128> Name;

310

Name.append(Prefix, Prefix+strlen(Prefix));

311

Mang->getNameWithPrefix(Name, GV, false);

312

return getELFSection(Name.str(), getELFSectionType(Name.str(), Kind),

313

getELFSectionFlags(Kind), Kind);

314

}

315

316

if (Kind.isText()) return TextSection;

317

318

if (Kind.isMergeable1ByteCString() ||

319

Kind.isMergeable2ByteCString() ||

320

Kind.isMergeable4ByteCString()) {

321

322

// We also need alignment here.

323

// FIXME: this is getting the alignment of the character, not the

324

// alignment of the global!

325

unsigned Align =

326

TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));

327

328

const char *SizeSpec = ".rodata.str1.";

329

if (Kind.isMergeable2ByteCString())

330

SizeSpec = ".rodata.str2.";

331

else if (Kind.isMergeable4ByteCString())

332

SizeSpec = ".rodata.str4.";

333

else

334

assert(Kind.isMergeable1ByteCString() && "unknown string width");

335

336

337

std::string Name = SizeSpec + utostr(Align);

338

return getELFSection(Name, MCSectionELF::SHT_PROGBITS,

339

MCSectionELF::SHF_ALLOC |

340

MCSectionELF::SHF_MERGE |

341

MCSectionELF::SHF_STRINGS,

342

Kind);

343

}

344

345

if (Kind.isMergeableConst()) {

346

if (Kind.isMergeableConst4() && MergeableConst4Section)

347

return MergeableConst4Section;

348

if (Kind.isMergeableConst8() && MergeableConst8Section)

349

return MergeableConst8Section;

350

if (Kind.isMergeableConst16() && MergeableConst16Section)

351

return MergeableConst16Section;

352

return ReadOnlySection; // .const

353

}

354

355

if (Kind.isReadOnly()) return ReadOnlySection;

356

357

if (Kind.isThreadData()) return TLSDataSection;

358

if (Kind.isThreadBSS()) return TLSBSSSection;

359

360

// Note: we claim that common symbols are put in BSSSection, but they are

361

// really emitted with the magic .comm directive, which creates a symbol table

362

// entry but not a section.

363

if (Kind.isBSS() || Kind.isCommon()) return BSSSection;

364

365

if (Kind.isDataNoRel()) return DataSection;

366

if (Kind.isDataRelLocal()) return DataRelLocalSection;

367

if (Kind.isDataRel()) return DataRelSection;

368

if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;

369

370

assert(Kind.isReadOnlyWithRel() && "Unknown section kind");

371

return DataRelROSection;

372

}

373

374

/// getSectionForConstant - Given a mergeable constant with the

375

/// specified size and relocation information, return a section that it

376

/// should be placed in.

377

const MCSection *TargetLoweringObjectFileELF::

378

getSectionForConstant(SectionKind Kind) const {

379

if (Kind.isMergeableConst4() && MergeableConst4Section)

380

return MergeableConst4Section;

381

if (Kind.isMergeableConst8() && MergeableConst8Section)

382

return MergeableConst8Section;

383

if (Kind.isMergeableConst16() && MergeableConst16Section)

384

return MergeableConst16Section;

385

if (Kind.isReadOnly())

386

return ReadOnlySection;

387

388

if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;

389

assert(Kind.isReadOnlyWithRel() && "Unknown section kind");

390

return DataRelROSection;

391

}

392

393

const MCExpr *TargetLoweringObjectFileELF::

394

getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,

395

MachineModuleInfo *MMI, unsigned Encoding) const {

396

397

if (Encoding & dwarf::DW_EH_PE_indirect) {

398

MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();

399

400

SmallString<128> Name;

401

Mang->getNameWithPrefix(Name, GV, true);

402

Name += ".DW.stub";

403

404

// Add information about the stub reference to ELFMMI so that the stub

405

// gets emitted by the asmprinter.

406

MCSymbol *Sym = getContext().GetOrCreateSymbol(Name.str());

407

MCSymbol *&StubSym = ELFMMI.getGVStubEntry(Sym);

408

if (StubSym == 0) {

409

Name.clear();

410

Mang->getNameWithPrefix(Name, GV, false);

411

StubSym = getContext().GetOrCreateSymbol(Name.str());

412

}

413

414

return TargetLoweringObjectFile::

415

getSymbolForDwarfReference(Sym, MMI,

416

Encoding & ~dwarf::DW_EH_PE_indirect);

417

}

418

419

return TargetLoweringObjectFile::

420

getSymbolForDwarfGlobalReference(GV, Mang, MMI, Encoding);

421

}

422

423

//===----------------------------------------------------------------------===//

424

// MachO

425

//===----------------------------------------------------------------------===//

426

427

typedef StringMap<const MCSectionMachO*> MachOUniqueMapTy;

428

429

TargetLoweringObjectFileMachO::~TargetLoweringObjectFileMachO() {

430

// If we have the MachO uniquing map, free it.

431

delete (MachOUniqueMapTy*)UniquingMap;

432

}

433

434

435

const MCSectionMachO *TargetLoweringObjectFileMachO::

436

getMachOSection(StringRef Segment, StringRef Section,

437

unsigned TypeAndAttributes,

438

unsigned Reserved2, SectionKind Kind) const {

439

// We unique sections by their segment/section pair. The returned section

440

// may not have the same flags as the requested section, if so this should be

441

// diagnosed by the client as an error.

442

443

// Create the map if it doesn't already exist.

444

if (UniquingMap == 0)

445

UniquingMap = new MachOUniqueMapTy();

446

MachOUniqueMapTy &Map = *(MachOUniqueMapTy*)UniquingMap;

447

448

// Form the name to look up.

449

SmallString<64> Name;

450

Name += Segment;

451

Name.push_back(',');

452

Name += Section;

453

454

// Do the lookup, if we have a hit, return it.

455

const MCSectionMachO *&Entry = Map[Name.str()];

456

if (Entry) return Entry;

457

458

// Otherwise, return a new section.

459

return Entry = MCSectionMachO::Create(Segment, Section, TypeAndAttributes,

460

Reserved2, Kind, getContext());

461

}

462

463

464

void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,

465

const TargetMachine &TM) {

466

if (UniquingMap != 0)

467

((MachOUniqueMapTy*)UniquingMap)->clear();

468

TargetLoweringObjectFile::Initialize(Ctx, TM);

469

470

TextSection // .text

471

= getMachOSection("__TEXT", "__text",

472

MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,

473

SectionKind::getText());

474

DataSection // .data

475

= getMachOSection("__DATA", "__data", 0, SectionKind::getDataRel());

476

477

CStringSection // .cstring

478

= getMachOSection("__TEXT", "__cstring", MCSectionMachO::S_CSTRING_LITERALS,

479

SectionKind::getMergeable1ByteCString());

480

UStringSection

481

= getMachOSection("__TEXT","__ustring", 0,

482

SectionKind::getMergeable2ByteCString());

483

FourByteConstantSection // .literal4

484

= getMachOSection("__TEXT", "__literal4", MCSectionMachO::S_4BYTE_LITERALS,

485

SectionKind::getMergeableConst4());

486

EightByteConstantSection // .literal8

487

= getMachOSection("__TEXT", "__literal8", MCSectionMachO::S_8BYTE_LITERALS,

488

SectionKind::getMergeableConst8());

489

490

// ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back

491

// to using it in -static mode.

492

SixteenByteConstantSection = 0;

493

if (TM.getRelocationModel() != Reloc::Static &&

494

TM.getTargetData()->getPointerSize() == 32)

495

SixteenByteConstantSection = // .literal16

496

getMachOSection("__TEXT", "__literal16",MCSectionMachO::S_16BYTE_LITERALS,

497

SectionKind::getMergeableConst16());

498

499

ReadOnlySection // .const

500

= getMachOSection("__TEXT", "__const", 0, SectionKind::getReadOnly());

501

502

TextCoalSection

503

= getMachOSection("__TEXT", "__textcoal_nt",

504

MCSectionMachO::S_COALESCED |

505

MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,

506

SectionKind::getText());

507

ConstTextCoalSection

508

= getMachOSection("__TEXT", "__const_coal", MCSectionMachO::S_COALESCED,

509

SectionKind::getText());

510

ConstDataCoalSection

511

= getMachOSection("__DATA","__const_coal", MCSectionMachO::S_COALESCED,

512

SectionKind::getText());

513

ConstDataSection // .const_data

514

= getMachOSection("__DATA", "__const", 0,

515

SectionKind::getReadOnlyWithRel());

516

DataCoalSection

517

= getMachOSection("__DATA","__datacoal_nt", MCSectionMachO::S_COALESCED,

518

SectionKind::getDataRel());

519

DataCommonSection

520

= getMachOSection("__DATA","__common", MCSectionMachO::S_ZEROFILL,

521

SectionKind::getBSS());

522

DataBSSSection

523

= getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL,

524

SectionKind::getBSS());

525

526

527

LazySymbolPointerSection

528

= getMachOSection("__DATA", "__la_symbol_ptr",

529

MCSectionMachO::S_LAZY_SYMBOL_POINTERS,

530

SectionKind::getMetadata());

531

NonLazySymbolPointerSection

532

= getMachOSection("__DATA", "__nl_symbol_ptr",

533

MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,

534

SectionKind::getMetadata());

535

536

if (TM.getRelocationModel() == Reloc::Static) {

537

StaticCtorSection

538

= getMachOSection("__TEXT", "__constructor", 0,SectionKind::getDataRel());

539

StaticDtorSection

540

= getMachOSection("__TEXT", "__destructor", 0, SectionKind::getDataRel());

541

} else {

542

StaticCtorSection

543

= getMachOSection("__DATA", "__mod_init_func",

544

MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,

545

SectionKind::getDataRel());

546

StaticDtorSection

547

= getMachOSection("__DATA", "__mod_term_func",

548

MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,

549

SectionKind::getDataRel());

550

}

551

552

// Exception Handling.

553

LSDASection = getMachOSection("__DATA", "__gcc_except_tab", 0,

554

SectionKind::getDataRel());

555

EHFrameSection =

556

getMachOSection("__TEXT", "__eh_frame",

557

MCSectionMachO::S_COALESCED |

558

MCSectionMachO::S_ATTR_NO_TOC |

559

MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |

560

MCSectionMachO::S_ATTR_LIVE_SUPPORT,

561

SectionKind::getReadOnly());

562

563

// Debug Information.

564

DwarfAbbrevSection =

565

getMachOSection("__DWARF", "__debug_abbrev", MCSectionMachO::S_ATTR_DEBUG,

566

SectionKind::getMetadata());

567

DwarfInfoSection =

568

getMachOSection("__DWARF", "__debug_info", MCSectionMachO::S_ATTR_DEBUG,

569

SectionKind::getMetadata());

570

DwarfLineSection =

571

getMachOSection("__DWARF", "__debug_line", MCSectionMachO::S_ATTR_DEBUG,

572

SectionKind::getMetadata());

573

DwarfFrameSection =

574

getMachOSection("__DWARF", "__debug_frame", MCSectionMachO::S_ATTR_DEBUG,

575

SectionKind::getMetadata());

576

DwarfPubNamesSection =

577

getMachOSection("__DWARF", "__debug_pubnames", MCSectionMachO::S_ATTR_DEBUG,

578

SectionKind::getMetadata());

579

DwarfPubTypesSection =

580

getMachOSection("__DWARF", "__debug_pubtypes", MCSectionMachO::S_ATTR_DEBUG,

581

SectionKind::getMetadata());

582

DwarfStrSection =

583

getMachOSection("__DWARF", "__debug_str", MCSectionMachO::S_ATTR_DEBUG,

584

SectionKind::getMetadata());

585

DwarfLocSection =

586

getMachOSection("__DWARF", "__debug_loc", MCSectionMachO::S_ATTR_DEBUG,

587

SectionKind::getMetadata());

588

DwarfARangesSection =

589

getMachOSection("__DWARF", "__debug_aranges", MCSectionMachO::S_ATTR_DEBUG,

590

SectionKind::getMetadata());

591

DwarfRangesSection =

592

getMachOSection("__DWARF", "__debug_ranges", MCSectionMachO::S_ATTR_DEBUG,

593

SectionKind::getMetadata());

594

DwarfMacroInfoSection =

595

getMachOSection("__DWARF", "__debug_macinfo", MCSectionMachO::S_ATTR_DEBUG,

596

SectionKind::getMetadata());

597

DwarfDebugInlineSection =

598

getMachOSection("__DWARF", "__debug_inlined", MCSectionMachO::S_ATTR_DEBUG,

599

SectionKind::getMetadata());

600

}

601

602

const MCSection *TargetLoweringObjectFileMachO::

603

getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,

604

Mangler *Mang, const TargetMachine &TM) const {

605

// Parse the section specifier and create it if valid.

606

StringRef Segment, Section;

607

unsigned TAA, StubSize;

608

std::string ErrorCode =

609

MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,

610

TAA, StubSize);

611

if (!ErrorCode.empty()) {

612

// If invalid, report the error with llvm_report_error.

613

llvm_report_error("Global variable '" + GV->getNameStr() +

614

"' has an invalid section specifier '" + GV->getSection()+

615

"': " + ErrorCode + ".");

616

// Fall back to dropping it into the data section.

617

return DataSection;

618

}

619

620

// Get the section.

621

const MCSectionMachO *S =

622

getMachOSection(Segment, Section, TAA, StubSize, Kind);

623

624

// Okay, now that we got the section, verify that the TAA & StubSize agree.

625

// If the user declared multiple globals with different section flags, we need

626

// to reject it here.

627

if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {

628

// If invalid, report the error with llvm_report_error.

629

llvm_report_error("Global variable '" + GV->getNameStr() +

630

"' section type or attributes does not match previous"

631

" section specifier");

632

}

633

634

return S;

635

}

636

637

const MCSection *TargetLoweringObjectFileMachO::

638

SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,

639

Mangler *Mang, const TargetMachine &TM) const {

640

assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");

641

642

if (Kind.isText())

643

return GV->isWeakForLinker() ? TextCoalSection : TextSection;

644

645

// If this is weak/linkonce, put this in a coalescable section, either in text

646

// or data depending on if it is writable.

647

if (GV->isWeakForLinker()) {

648

if (Kind.isReadOnly())

649

return ConstTextCoalSection;

650

return DataCoalSection;

651

}

652

653

// FIXME: Alignment check should be handled by section classifier.

654

if (Kind.isMergeable1ByteCString() ||

655

(Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage())) {

656

if (TM.getTargetData()->getPreferredAlignment(

657

cast<GlobalVariable>(GV)) < 32) {

658

if (Kind.isMergeable1ByteCString())

659

return CStringSection;

660

assert(Kind.isMergeable2ByteCString());

661

return UStringSection;

662

}

663

}

664

665

if (Kind.isMergeableConst()) {

666

if (Kind.isMergeableConst4())

667

return FourByteConstantSection;

668

if (Kind.isMergeableConst8())

669

return EightByteConstantSection;

670

if (Kind.isMergeableConst16() && SixteenByteConstantSection)

671

return SixteenByteConstantSection;

672

}

673

674

// Otherwise, if it is readonly, but not something we can specially optimize,

675

// just drop it in .const.

676

if (Kind.isReadOnly())

677

return ReadOnlySection;

678

679

// If this is marked const, put it into a const section. But if the dynamic

680

// linker needs to write to it, put it in the data segment.

681

if (Kind.isReadOnlyWithRel())

682

return ConstDataSection;

683

684

// Put zero initialized globals with strong external linkage in the

685

// DATA, __common section with the .zerofill directive.

686

if (Kind.isBSSExtern())

687

return DataCommonSection;

688

689

// Put zero initialized globals with local linkage in __DATA,__bss directive

690

// with the .zerofill directive (aka .lcomm).

691

if (Kind.isBSSLocal())

692

return DataBSSSection;

693

694

// Otherwise, just drop the variable in the normal data section.

695

return DataSection;

696

}

697

698

const MCSection *

699

TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {

700

// If this constant requires a relocation, we have to put it in the data

701

// segment, not in the text segment.

702

if (Kind.isDataRel() || Kind.isReadOnlyWithRel())

703

return ConstDataSection;

704

705

if (Kind.isMergeableConst4())

706

return FourByteConstantSection;

707

if (Kind.isMergeableConst8())

708

return EightByteConstantSection;

709

if (Kind.isMergeableConst16() && SixteenByteConstantSection)

710

return SixteenByteConstantSection;

711

return ReadOnlySection; // .const

712

}

713

714

/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide

715

/// not to emit the UsedDirective for some symbols in llvm.used.

716

// FIXME: REMOVE this (rdar://7071300)

717

bool TargetLoweringObjectFileMachO::

718

shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {

719

/// On Darwin, internally linked data beginning with "L" or "l" does not have

720

/// the directive emitted (this occurs in ObjC metadata).

721

if (!GV) return false;

722

723

// Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.

724

if (GV->hasLocalLinkage() && !isa<Function>(GV)) {

725

// FIXME: ObjC metadata is currently emitted as internal symbols that have

726

// \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and

727

// this horrible hack can go away.

728

SmallString<64> Name;

729

Mang->getNameWithPrefix(Name, GV, false);

730

if (Name[0] == 'L' || Name[0] == 'l')

731

return false;

732

}

733

734

return true;

735

}

736

737

const MCExpr *TargetLoweringObjectFileMachO::

738

getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,

739

MachineModuleInfo *MMI, unsigned Encoding) const {

740

// The mach-o version of this method defaults to returning a stub reference.

741

742

if (Encoding & DW_EH_PE_indirect) {

743

MachineModuleInfoMachO &MachOMMI =

744

MMI->getObjFileInfo<MachineModuleInfoMachO>();

745

746

SmallString<128> Name;

747

Mang->getNameWithPrefix(Name, GV, true);

748

Name += "$non_lazy_ptr";

749

750

// Add information about the stub reference to MachOMMI so that the stub

751

// gets emitted by the asmprinter.

752

MCSymbol *Sym = getContext().GetOrCreateSymbol(Name.str());

753

MCSymbol *&StubSym = MachOMMI.getGVStubEntry(Sym);

754

if (StubSym == 0) {

755

Name.clear();

756

Mang->getNameWithPrefix(Name, GV, false);

757

StubSym = getContext().GetOrCreateSymbol(Name.str());

758

}

759

760

return TargetLoweringObjectFile::

761

getSymbolForDwarfReference(Sym, MMI,

762

Encoding & ~dwarf::DW_EH_PE_indirect);

763

}

764

765

return TargetLoweringObjectFile::

766

getSymbolForDwarfGlobalReference(GV, Mang, MMI, Encoding);

767

}

768

769

unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const {

770

return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;

771

}

772

773

unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const {

774

return DW_EH_PE_pcrel;

775

}

776

777

unsigned TargetLoweringObjectFileMachO::getFDEEncoding() const {

778

return DW_EH_PE_pcrel;

779

}

780

781

unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const {

782

return DW_EH_PE_absptr;

783

}

784

785

//===----------------------------------------------------------------------===//

786

// COFF

787

//===----------------------------------------------------------------------===//

788

789

typedef StringMap<const MCSectionCOFF*> COFFUniqueMapTy;

790

791

TargetLoweringObjectFileCOFF::~TargetLoweringObjectFileCOFF() {

792

delete (COFFUniqueMapTy*)UniquingMap;

793

}

794

795

796

const MCSection *TargetLoweringObjectFileCOFF::

797

getCOFFSection(StringRef Name, bool isDirective, SectionKind Kind) const {

798

// Create the map if it doesn't already exist.

799

if (UniquingMap == 0)

800

UniquingMap = new MachOUniqueMapTy();

801

COFFUniqueMapTy &Map = *(COFFUniqueMapTy*)UniquingMap;

802

803

// Do the lookup, if we have a hit, return it.

804

const MCSectionCOFF *&Entry = Map[Name];

805

if (Entry) return Entry;

806

807

return Entry = MCSectionCOFF::Create(Name, isDirective, Kind, getContext());

808

}

809

810

void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,

811

const TargetMachine &TM) {

812

if (UniquingMap != 0)

813

((COFFUniqueMapTy*)UniquingMap)->clear();

814

TargetLoweringObjectFile::Initialize(Ctx, TM);

815

TextSection = getCOFFSection("\t.text", true, SectionKind::getText());

816

DataSection = getCOFFSection("\t.data", true, SectionKind::getDataRel());

817

StaticCtorSection =

818

getCOFFSection(".ctors", false, SectionKind::getDataRel());

819

StaticDtorSection =

820

getCOFFSection(".dtors", false, SectionKind::getDataRel());

821

822

// FIXME: We're emitting LSDA info into a readonly section on COFF, even

823

// though it contains relocatable pointers. In PIC mode, this is probably a

824

// big runtime hit for C++ apps. Either the contents of the LSDA need to be

825

// adjusted or this should be a data section.

826

LSDASection =

827

getCOFFSection(".gcc_except_table", false, SectionKind::getReadOnly());

828

EHFrameSection =

829

getCOFFSection(".eh_frame", false, SectionKind::getDataRel());

830

831

// Debug info.

832

// FIXME: Don't use 'directive' mode here.

833

DwarfAbbrevSection =

834

getCOFFSection("\t.section\t.debug_abbrev,\"dr\"",

835