2010-02-16 06:37:53 +08:00
|
|
|
//===-- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info --===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements classes used to handle lowerings specific to common
|
|
|
|
// object file formats.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
|
|
|
#include "llvm/ADT/Triple.h"
|
|
|
|
#include "llvm/CodeGen/MachineModuleInfoImpls.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DataLayout.h"
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
|
|
|
#include "llvm/IR/Function.h"
|
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
2014-01-08 05:19:40 +08:00
|
|
|
#include "llvm/IR/Mangler.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2015-11-04 07:40:03 +08:00
|
|
|
#include "llvm/MC/MCAsmInfo.h"
|
2010-02-16 06:37:53 +08:00
|
|
|
#include "llvm/MC/MCContext.h"
|
|
|
|
#include "llvm/MC/MCExpr.h"
|
2010-05-08 01:17:41 +08:00
|
|
|
#include "llvm/MC/MCSectionCOFF.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/MC/MCSectionELF.h"
|
|
|
|
#include "llvm/MC/MCSectionMachO.h"
|
2017-02-22 09:23:18 +08:00
|
|
|
#include "llvm/MC/MCSectionWasm.h"
|
2011-04-16 11:51:21 +08:00
|
|
|
#include "llvm/MC/MCStreamer.h"
|
2015-06-02 08:25:12 +08:00
|
|
|
#include "llvm/MC/MCSymbolELF.h"
|
2017-02-22 09:23:18 +08:00
|
|
|
#include "llvm/MC/MCSymbolWasm.h"
|
2015-03-06 21:49:05 +08:00
|
|
|
#include "llvm/MC/MCValue.h"
|
2016-01-15 02:09:45 +08:00
|
|
|
#include "llvm/ProfileData/InstrProf.h"
|
2015-09-04 00:41:50 +08:00
|
|
|
#include "llvm/Support/COFF.h"
|
2010-02-16 06:37:53 +08:00
|
|
|
#include "llvm/Support/Dwarf.h"
|
2011-01-23 12:28:49 +08:00
|
|
|
#include "llvm/Support/ELF.h"
|
2010-02-16 06:37:53 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2014-02-20 01:23:20 +08:00
|
|
|
#include "llvm/Target/TargetLowering.h"
|
2014-03-04 18:07:28 +08:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2014-08-05 05:25:23 +08:00
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
2010-02-16 06:37:53 +08:00
|
|
|
using namespace llvm;
|
2010-02-22 04:28:15 +08:00
|
|
|
using namespace dwarf;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ELF
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-02-20 01:23:20 +08:00
|
|
|
MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *GV, const TargetMachine &TM,
|
2014-02-20 01:23:20 +08:00
|
|
|
MachineModuleInfo *MMI) const {
|
2011-04-28 07:17:57 +08:00
|
|
|
unsigned Encoding = getPersonalityEncoding();
|
2014-05-31 00:48:56 +08:00
|
|
|
if ((Encoding & 0x80) == dwarf::DW_EH_PE_indirect)
|
2015-05-19 02:43:14 +08:00
|
|
|
return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
|
2016-11-23 00:17:20 +08:00
|
|
|
TM.getSymbol(GV)->getName());
|
2014-05-31 00:48:56 +08:00
|
|
|
if ((Encoding & 0x70) == dwarf::DW_EH_PE_absptr)
|
2016-11-23 00:17:20 +08:00
|
|
|
return TM.getSymbol(GV);
|
2014-05-31 00:48:56 +08:00
|
|
|
report_fatal_error("We do not support this DWARF encoding yet!");
|
2011-04-16 11:51:21 +08:00
|
|
|
}
|
|
|
|
|
2015-07-16 14:04:17 +08:00
|
|
|
void TargetLoweringObjectFileELF::emitPersonalityValue(
|
|
|
|
MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
|
2011-06-13 11:09:13 +08:00
|
|
|
SmallString<64> NameData("DW.ref.");
|
|
|
|
NameData += Sym->getName();
|
2015-06-02 08:25:12 +08:00
|
|
|
MCSymbolELF *Label =
|
|
|
|
cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData));
|
2011-04-28 05:29:52 +08:00
|
|
|
Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
|
|
|
|
Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
|
|
|
|
unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
|
2016-07-01 14:07:38 +08:00
|
|
|
MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
|
|
|
|
ELF::SHT_PROGBITS, Flags, 0);
|
2015-07-16 14:04:17 +08:00
|
|
|
unsigned Size = DL.getPointerSize();
|
2011-04-28 05:29:52 +08:00
|
|
|
Streamer.SwitchSection(Sec);
|
2015-07-16 14:04:17 +08:00
|
|
|
Streamer.EmitValueToAlignment(DL.getPointerABIAlignment());
|
2011-04-28 05:29:52 +08:00
|
|
|
Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
|
2015-05-30 09:25:56 +08:00
|
|
|
const MCExpr *E = MCConstantExpr::create(Size, getContext());
|
2015-06-02 08:25:12 +08:00
|
|
|
Streamer.emitELFSize(Label, E);
|
2011-04-28 05:29:52 +08:00
|
|
|
Streamer.EmitLabel(Label);
|
|
|
|
|
|
|
|
Streamer.EmitSymbolValue(Sym, Size);
|
2011-04-16 11:51:21 +08:00
|
|
|
}
|
|
|
|
|
2014-02-09 22:50:44 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
|
|
|
|
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
|
2012-11-14 09:47:00 +08:00
|
|
|
|
|
|
|
if (Encoding & dwarf::DW_EH_PE_indirect) {
|
|
|
|
MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
|
2012-11-14 09:47:00 +08:00
|
|
|
|
|
|
|
// Add information about the stub reference to ELFMMI so that the stub
|
|
|
|
// gets emitted by the asmprinter.
|
|
|
|
MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!StubSym.getPointer()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(GV);
|
2012-11-14 09:47:00 +08:00
|
|
|
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
|
|
|
|
}
|
|
|
|
|
|
|
|
return TargetLoweringObjectFile::
|
2015-05-30 09:25:56 +08:00
|
|
|
getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
|
2012-11-14 09:47:00 +08:00
|
|
|
Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
|
|
|
|
}
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
|
|
|
|
MMI, Streamer);
|
2012-11-14 09:47:00 +08:00
|
|
|
}
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
static SectionKind
|
|
|
|
getELFKindForNamedSection(StringRef Name, SectionKind K) {
|
2011-05-24 11:10:31 +08:00
|
|
|
// N.B.: The defaults used in here are no the same ones used in MC.
|
|
|
|
// We follow gcc, MC follows gas. For example, given ".section .eh_frame",
|
|
|
|
// both gas and MC will produce a section with no flags. Given
|
2012-07-19 08:04:14 +08:00
|
|
|
// section(".eh_frame") gcc will produce:
|
|
|
|
//
|
|
|
|
// .section .eh_frame,"a",@progbits
|
2016-01-15 02:09:45 +08:00
|
|
|
|
|
|
|
if (Name == getInstrProfCoverageSectionName(false))
|
|
|
|
return SectionKind::getMetadata();
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Name.empty() || Name[0] != '.') return K;
|
|
|
|
|
|
|
|
// Some lame default implementation based on some magic section names.
|
|
|
|
if (Name == ".bss" ||
|
|
|
|
Name.startswith(".bss.") ||
|
|
|
|
Name.startswith(".gnu.linkonce.b.") ||
|
|
|
|
Name.startswith(".llvm.linkonce.b.") ||
|
|
|
|
Name == ".sbss" ||
|
|
|
|
Name.startswith(".sbss.") ||
|
|
|
|
Name.startswith(".gnu.linkonce.sb.") ||
|
|
|
|
Name.startswith(".llvm.linkonce.sb."))
|
|
|
|
return SectionKind::getBSS();
|
|
|
|
|
|
|
|
if (Name == ".tdata" ||
|
|
|
|
Name.startswith(".tdata.") ||
|
|
|
|
Name.startswith(".gnu.linkonce.td.") ||
|
|
|
|
Name.startswith(".llvm.linkonce.td."))
|
|
|
|
return SectionKind::getThreadData();
|
|
|
|
|
|
|
|
if (Name == ".tbss" ||
|
|
|
|
Name.startswith(".tbss.") ||
|
|
|
|
Name.startswith(".gnu.linkonce.tb.") ||
|
|
|
|
Name.startswith(".llvm.linkonce.tb."))
|
|
|
|
return SectionKind::getThreadBSS();
|
|
|
|
|
|
|
|
return K;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static unsigned getELFSectionType(StringRef Name, SectionKind K) {
|
2016-09-21 04:21:13 +08:00
|
|
|
// Use SHT_NOTE for section whose name starts with ".note" to allow
|
|
|
|
// emitting ELF notes from C variable declaration.
|
|
|
|
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
|
|
|
|
if (Name.startswith(".note"))
|
|
|
|
return ELF::SHT_NOTE;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
if (Name == ".init_array")
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_INIT_ARRAY;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
if (Name == ".fini_array")
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_FINI_ARRAY;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
if (Name == ".preinit_array")
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_PREINIT_ARRAY;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
if (K.isBSS() || K.isThreadBSS())
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_NOBITS;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2011-01-23 12:28:49 +08:00
|
|
|
return ELF::SHT_PROGBITS;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
static unsigned getELFSectionFlags(SectionKind K) {
|
2010-02-16 06:37:53 +08:00
|
|
|
unsigned Flags = 0;
|
|
|
|
|
|
|
|
if (!K.isMetadata())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_ALLOC;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
if (K.isText())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_EXECINSTR;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2016-12-15 15:59:08 +08:00
|
|
|
if (K.isExecuteOnly())
|
|
|
|
Flags |= ELF::SHF_ARM_PURECODE;
|
|
|
|
|
2011-06-08 07:26:45 +08:00
|
|
|
if (K.isWriteable())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_WRITE;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
if (K.isThreadLocal())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_TLS;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
if (K.isMergeableCString() || K.isMergeableConst())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_MERGE;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
if (K.isMergeableCString())
|
2011-01-23 12:43:11 +08:00
|
|
|
Flags |= ELF::SHF_STRINGS;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
return Flags;
|
|
|
|
}
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
static const Comdat *getELFComdat(const GlobalValue *GV) {
|
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
if (!C)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (C->getSelectionKind() != Comdat::Any)
|
|
|
|
report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
|
|
|
|
C->getName() + "' cannot be lowered.");
|
|
|
|
|
|
|
|
return C;
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
|
|
|
StringRef SectionName = GO->getSection();
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
// Infer section flags from the section name if we can.
|
|
|
|
Kind = getELFKindForNamedSection(SectionName, Kind);
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
StringRef Group = "";
|
2015-02-25 08:52:15 +08:00
|
|
|
unsigned Flags = getELFSectionFlags(Kind);
|
2016-10-25 03:23:39 +08:00
|
|
|
if (const Comdat *C = getELFComdat(GO)) {
|
2014-06-28 02:19:56 +08:00
|
|
|
Group = C->getName();
|
|
|
|
Flags |= ELF::SHF_GROUP;
|
|
|
|
}
|
2010-04-09 05:34:17 +08:00
|
|
|
return getContext().getELFSection(SectionName,
|
2014-06-28 02:19:56 +08:00
|
|
|
getELFSectionType(SectionName, Kind), Flags,
|
2015-01-30 01:33:21 +08:00
|
|
|
/*EntrySize=*/0, Group);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2015-02-11 22:44:17 +08:00
|
|
|
/// Return the section prefix name used by options FunctionsSections and
|
|
|
|
/// DataSections.
|
2014-06-25 00:01:53 +08:00
|
|
|
static StringRef getSectionPrefixForGlobal(SectionKind Kind) {
|
2015-02-11 22:44:17 +08:00
|
|
|
if (Kind.isText())
|
2015-02-18 04:48:01 +08:00
|
|
|
return ".text";
|
2015-02-11 22:44:17 +08:00
|
|
|
if (Kind.isReadOnly())
|
2015-02-18 04:48:01 +08:00
|
|
|
return ".rodata";
|
2015-02-11 22:44:17 +08:00
|
|
|
if (Kind.isBSS())
|
2015-02-18 04:48:01 +08:00
|
|
|
return ".bss";
|
2015-02-11 22:44:17 +08:00
|
|
|
if (Kind.isThreadData())
|
2015-02-18 04:48:01 +08:00
|
|
|
return ".tdata";
|
2015-02-11 22:44:17 +08:00
|
|
|
if (Kind.isThreadBSS())
|
2015-02-18 04:48:01 +08:00
|
|
|
return ".tbss";
|
2015-11-18 14:02:15 +08:00
|
|
|
if (Kind.isData())
|
2015-02-18 04:48:01 +08:00
|
|
|
return ".data";
|
2010-04-13 08:36:43 +08:00
|
|
|
assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
|
2015-02-18 04:48:01 +08:00
|
|
|
return ".data.rel.ro";
|
2010-04-13 08:36:43 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
static MCSectionELF *
|
2016-10-25 03:23:39 +08:00
|
|
|
selectELFSectionForGlobal(MCContext &Ctx, const GlobalObject *GO,
|
2015-04-05 02:02:01 +08:00
|
|
|
SectionKind Kind, Mangler &Mang,
|
|
|
|
const TargetMachine &TM, bool EmitUniqueSection,
|
|
|
|
unsigned Flags, unsigned *NextUniqueID) {
|
2015-02-25 08:52:15 +08:00
|
|
|
unsigned EntrySize = 0;
|
|
|
|
if (Kind.isMergeableCString()) {
|
|
|
|
if (Kind.isMergeable2ByteCString()) {
|
|
|
|
EntrySize = 2;
|
|
|
|
} else if (Kind.isMergeable4ByteCString()) {
|
|
|
|
EntrySize = 4;
|
|
|
|
} else {
|
|
|
|
EntrySize = 1;
|
|
|
|
assert(Kind.isMergeable1ByteCString() && "unknown string width");
|
|
|
|
}
|
|
|
|
} else if (Kind.isMergeableConst()) {
|
|
|
|
if (Kind.isMergeableConst4()) {
|
|
|
|
EntrySize = 4;
|
|
|
|
} else if (Kind.isMergeableConst8()) {
|
|
|
|
EntrySize = 8;
|
2016-02-23 06:23:11 +08:00
|
|
|
} else if (Kind.isMergeableConst16()) {
|
2015-02-25 08:52:15 +08:00
|
|
|
EntrySize = 16;
|
2016-02-23 06:23:11 +08:00
|
|
|
} else {
|
|
|
|
assert(Kind.isMergeableConst32() && "unknown data width");
|
|
|
|
EntrySize = 32;
|
2015-02-25 08:52:15 +08:00
|
|
|
}
|
|
|
|
}
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
StringRef Group = "";
|
2016-10-25 03:23:39 +08:00
|
|
|
if (const Comdat *C = getELFComdat(GO)) {
|
2015-02-25 08:52:15 +08:00
|
|
|
Flags |= ELF::SHF_GROUP;
|
|
|
|
Group = C->getName();
|
|
|
|
}
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
bool UniqueSectionNames = TM.getUniqueSectionNames();
|
|
|
|
SmallString<128> Name;
|
2015-01-29 01:54:19 +08:00
|
|
|
if (Kind.isMergeableCString()) {
|
2010-02-16 06:37:53 +08:00
|
|
|
// We also need alignment here.
|
|
|
|
// FIXME: this is getting the alignment of the character, not the
|
|
|
|
// alignment of the global!
|
2016-10-25 03:23:39 +08:00
|
|
|
unsigned Align = GO->getParent()->getDataLayout().getPreferredAlignment(
|
|
|
|
cast<GlobalVariable>(GO));
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2015-01-30 01:33:21 +08:00
|
|
|
std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
|
2015-02-25 08:52:15 +08:00
|
|
|
Name = SizeSpec + utostr(Align);
|
|
|
|
} else if (Kind.isMergeableConst()) {
|
|
|
|
Name = ".rodata.cst";
|
|
|
|
Name += utostr(EntrySize);
|
|
|
|
} else {
|
|
|
|
Name = getSectionPrefixForGlobal(Kind);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
2016-10-19 04:42:47 +08:00
|
|
|
|
2016-10-25 03:23:39 +08:00
|
|
|
if (const auto *F = dyn_cast<Function>(GO)) {
|
2016-10-19 04:42:47 +08:00
|
|
|
const auto &OptionalPrefix = F->getSectionPrefix();
|
|
|
|
if (OptionalPrefix)
|
|
|
|
Name += *OptionalPrefix;
|
|
|
|
}
|
2016-02-23 11:39:24 +08:00
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
if (EmitUniqueSection && UniqueSectionNames) {
|
|
|
|
Name.push_back('.');
|
2016-10-25 03:23:39 +08:00
|
|
|
TM.getNameWithPrefix(Name, GO, Mang, true);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
2016-05-03 07:22:18 +08:00
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
2015-04-05 02:02:01 +08:00
|
|
|
if (EmitUniqueSection && !UniqueSectionNames) {
|
|
|
|
UniqueID = *NextUniqueID;
|
|
|
|
(*NextUniqueID)++;
|
|
|
|
}
|
2016-12-15 15:59:08 +08:00
|
|
|
// Use 0 as the unique ID for execute-only text
|
|
|
|
if (Kind.isExecuteOnly())
|
|
|
|
UniqueID = 0;
|
2015-02-27 07:55:11 +08:00
|
|
|
return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
|
2015-04-05 02:02:01 +08:00
|
|
|
EntrySize, Group, UniqueID);
|
2015-02-27 07:55:11 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2015-02-27 07:55:11 +08:00
|
|
|
unsigned Flags = getELFSectionFlags(Kind);
|
|
|
|
|
|
|
|
// If we have -ffunction-section or -fdata-section then we should emit the
|
|
|
|
// global value to a uniqued section specifically for it.
|
|
|
|
bool EmitUniqueSection = false;
|
|
|
|
if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
|
|
|
|
if (Kind.isText())
|
|
|
|
EmitUniqueSection = TM.getFunctionSections();
|
|
|
|
else
|
|
|
|
EmitUniqueSection = TM.getDataSections();
|
|
|
|
}
|
2016-10-25 03:23:39 +08:00
|
|
|
EmitUniqueSection |= GO->hasComdat();
|
2015-02-27 07:55:11 +08:00
|
|
|
|
2016-10-25 03:23:39 +08:00
|
|
|
return selectELFSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
|
2015-04-05 02:02:01 +08:00
|
|
|
EmitUniqueSection, Flags, &NextUniqueID);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable(
|
2016-09-16 15:33:15 +08:00
|
|
|
const Function &F, const TargetMachine &TM) const {
|
2015-02-13 01:16:46 +08:00
|
|
|
// If the function can be removed, produce a unique section so that
|
|
|
|
// the table doesn't prevent the removal.
|
|
|
|
const Comdat *C = F.getComdat();
|
|
|
|
bool EmitUniqueSection = TM.getFunctionSections() || C;
|
|
|
|
if (!EmitUniqueSection)
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
2015-02-27 07:55:11 +08:00
|
|
|
return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
|
2016-09-16 15:33:15 +08:00
|
|
|
getMangler(), TM, EmitUniqueSection, ELF::SHF_ALLOC,
|
2015-04-05 02:02:01 +08:00
|
|
|
&NextUniqueID);
|
2015-02-13 01:16:46 +08:00
|
|
|
}
|
|
|
|
|
2015-02-18 07:34:51 +08:00
|
|
|
bool TargetLoweringObjectFileELF::shouldPutJumpTableInFunctionSection(
|
|
|
|
bool UsesLabelDifference, const Function &F) const {
|
|
|
|
// We can always create relative relocations, so use another section
|
|
|
|
// that can be marked non-executable.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
/// Given a mergeable constant with the specified size and relocation
|
|
|
|
/// information, return a section that it should be placed in.
|
2015-07-16 14:04:17 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getSectionForConstant(
|
2016-02-21 09:30:30 +08:00
|
|
|
const DataLayout &DL, SectionKind Kind, const Constant *C,
|
|
|
|
unsigned &Align) const {
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isMergeableConst4() && MergeableConst4Section)
|
|
|
|
return MergeableConst4Section;
|
|
|
|
if (Kind.isMergeableConst8() && MergeableConst8Section)
|
|
|
|
return MergeableConst8Section;
|
|
|
|
if (Kind.isMergeableConst16() && MergeableConst16Section)
|
|
|
|
return MergeableConst16Section;
|
2016-02-23 06:23:11 +08:00
|
|
|
if (Kind.isMergeableConst32() && MergeableConst32Section)
|
|
|
|
return MergeableConst32Section;
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isReadOnly())
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
|
|
assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
|
|
|
|
return DataRelROSection;
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
|
|
|
|
bool IsCtor, unsigned Priority,
|
|
|
|
const MCSymbol *KeySym) {
|
2014-09-05 07:03:58 +08:00
|
|
|
std::string Name;
|
|
|
|
unsigned Type;
|
|
|
|
unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
|
|
|
|
StringRef COMDAT = KeySym ? KeySym->getName() : "";
|
|
|
|
|
|
|
|
if (KeySym)
|
|
|
|
Flags |= ELF::SHF_GROUP;
|
2012-01-26 06:24:19 +08:00
|
|
|
|
2012-06-19 08:48:28 +08:00
|
|
|
if (UseInitArray) {
|
2014-09-05 08:02:50 +08:00
|
|
|
if (IsCtor) {
|
|
|
|
Type = ELF::SHT_INIT_ARRAY;
|
|
|
|
Name = ".init_array";
|
|
|
|
} else {
|
|
|
|
Type = ELF::SHT_FINI_ARRAY;
|
|
|
|
Name = ".fini_array";
|
|
|
|
}
|
2014-09-05 07:03:58 +08:00
|
|
|
if (Priority != 65535) {
|
|
|
|
Name += '.';
|
|
|
|
Name += utostr(Priority);
|
|
|
|
}
|
2012-06-19 08:48:28 +08:00
|
|
|
} else {
|
2014-09-05 07:03:58 +08:00
|
|
|
// The default scheme is .ctor / .dtor, so we have to invert the priority
|
|
|
|
// numbering.
|
2014-09-05 08:02:50 +08:00
|
|
|
if (IsCtor)
|
|
|
|
Name = ".ctors";
|
|
|
|
else
|
|
|
|
Name = ".dtors";
|
2014-09-05 07:03:58 +08:00
|
|
|
if (Priority != 65535) {
|
|
|
|
Name += '.';
|
|
|
|
Name += utostr(65535 - Priority);
|
|
|
|
}
|
|
|
|
Type = ELF::SHT_PROGBITS;
|
2012-06-19 08:48:28 +08:00
|
|
|
}
|
2014-09-05 07:03:58 +08:00
|
|
|
|
2015-01-30 01:33:21 +08:00
|
|
|
return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT);
|
2012-01-26 06:24:19 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getStaticCtorSection(
|
2014-06-07 03:26:12 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
2014-09-05 08:02:50 +08:00
|
|
|
return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
|
|
|
|
KeySym);
|
|
|
|
}
|
2014-09-05 07:03:58 +08:00
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
|
2014-09-05 08:02:50 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
|
|
|
return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
|
|
|
|
KeySym);
|
2012-06-19 08:48:28 +08:00
|
|
|
}
|
|
|
|
|
2016-04-23 04:40:10 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *LHS, const GlobalValue *RHS,
|
2016-04-23 04:40:10 +08:00
|
|
|
const TargetMachine &TM) const {
|
|
|
|
// We may only use a PLT-relative relocation to refer to unnamed_addr
|
|
|
|
// functions.
|
2016-06-15 05:01:22 +08:00
|
|
|
if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
|
2016-04-23 04:40:10 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Basic sanity checks.
|
|
|
|
if (LHS->getType()->getPointerAddressSpace() != 0 ||
|
|
|
|
RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
|
|
|
|
RHS->isThreadLocal())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
return MCBinaryExpr::createSub(
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbolRefExpr::create(TM.getSymbol(LHS), PLTRelativeVariantKind,
|
2016-04-23 04:40:10 +08:00
|
|
|
getContext()),
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
|
2016-04-23 04:40:10 +08:00
|
|
|
}
|
|
|
|
|
2012-06-19 08:48:28 +08:00
|
|
|
void
|
|
|
|
TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
|
|
|
|
UseInitArray = UseInitArray_;
|
2016-08-29 20:33:42 +08:00
|
|
|
MCContext &Ctx = getContext();
|
|
|
|
if (!UseInitArray) {
|
|
|
|
StaticCtorSection = Ctx.getELFSection(".ctors", ELF::SHT_PROGBITS,
|
|
|
|
ELF::SHF_ALLOC | ELF::SHF_WRITE);
|
|
|
|
|
|
|
|
StaticDtorSection = Ctx.getELFSection(".dtors", ELF::SHT_PROGBITS,
|
|
|
|
ELF::SHF_ALLOC | ELF::SHF_WRITE);
|
2012-06-19 08:48:28 +08:00
|
|
|
return;
|
2016-08-29 20:33:42 +08:00
|
|
|
}
|
2012-06-19 08:48:28 +08:00
|
|
|
|
2016-08-29 20:33:42 +08:00
|
|
|
StaticCtorSection = Ctx.getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
|
|
|
|
ELF::SHF_WRITE | ELF::SHF_ALLOC);
|
|
|
|
StaticDtorSection = Ctx.getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
|
|
|
|
ELF::SHF_WRITE | ELF::SHF_ALLOC);
|
2012-01-26 06:24:19 +08:00
|
|
|
}
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// MachO
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-03-06 21:49:05 +08:00
|
|
|
TargetLoweringObjectFileMachO::TargetLoweringObjectFileMachO()
|
|
|
|
: TargetLoweringObjectFile() {
|
|
|
|
SupportIndirectSymViaGOTPCRel = true;
|
|
|
|
}
|
|
|
|
|
2016-08-29 20:33:42 +08:00
|
|
|
void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
|
|
|
|
const TargetMachine &TM) {
|
|
|
|
TargetLoweringObjectFile::Initialize(Ctx, TM);
|
2016-08-29 20:47:22 +08:00
|
|
|
if (TM.getRelocationModel() == Reloc::Static) {
|
2016-08-29 20:33:42 +08:00
|
|
|
StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
|
|
|
|
SectionKind::getData());
|
|
|
|
StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
|
|
|
|
SectionKind::getData());
|
|
|
|
} else {
|
|
|
|
StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
|
|
|
|
MachO::S_MOD_INIT_FUNC_POINTERS,
|
|
|
|
SectionKind::getData());
|
|
|
|
StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
|
|
|
|
MachO::S_MOD_TERM_FUNC_POINTERS,
|
|
|
|
SectionKind::getData());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-19 03:37:00 +08:00
|
|
|
/// emitModuleFlags - Perform code emission for module flags.
|
2016-09-16 15:33:15 +08:00
|
|
|
void TargetLoweringObjectFileMachO::emitModuleFlags(
|
|
|
|
MCStreamer &Streamer, ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
|
|
|
|
const TargetMachine &TM) const {
|
2012-02-15 05:28:13 +08:00
|
|
|
unsigned VersionVal = 0;
|
2012-04-24 19:03:50 +08:00
|
|
|
unsigned ImageInfoFlags = 0;
|
2014-04-14 08:51:57 +08:00
|
|
|
MDNode *LinkerOptions = nullptr;
|
2012-02-16 06:36:15 +08:00
|
|
|
StringRef SectionVal;
|
2012-02-15 05:28:13 +08:00
|
|
|
|
2016-05-01 02:15:34 +08:00
|
|
|
for (const auto &MFE : ModuleFlags) {
|
2012-02-15 05:28:13 +08:00
|
|
|
// Ignore flags with 'Require' behavior.
|
2012-02-16 06:36:15 +08:00
|
|
|
if (MFE.Behavior == Module::Require)
|
2012-02-15 05:28:13 +08:00
|
|
|
continue;
|
|
|
|
|
2012-02-16 06:36:15 +08:00
|
|
|
StringRef Key = MFE.Key->getString();
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
Metadata *Val = MFE.Val;
|
2012-02-15 05:28:13 +08:00
|
|
|
|
2013-01-19 03:37:00 +08:00
|
|
|
if (Key == "Objective-C Image Info Version") {
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
VersionVal = mdconst::extract<ConstantInt>(Val)->getZExtValue();
|
2013-01-19 03:37:00 +08:00
|
|
|
} else if (Key == "Objective-C Garbage Collection" ||
|
|
|
|
Key == "Objective-C GC Only" ||
|
2014-11-22 03:24:55 +08:00
|
|
|
Key == "Objective-C Is Simulated" ||
|
2016-01-30 07:51:00 +08:00
|
|
|
Key == "Objective-C Class Properties" ||
|
2014-11-22 03:24:55 +08:00
|
|
|
Key == "Objective-C Image Swift Version") {
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
ImageInfoFlags |= mdconst::extract<ConstantInt>(Val)->getZExtValue();
|
2013-01-19 03:37:00 +08:00
|
|
|
} else if (Key == "Objective-C Image Info Section") {
|
2012-02-16 06:36:15 +08:00
|
|
|
SectionVal = cast<MDString>(Val)->getString();
|
2013-01-19 03:37:00 +08:00
|
|
|
} else if (Key == "Linker Options") {
|
|
|
|
LinkerOptions = cast<MDNode>(Val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Emit the linker options if present.
|
|
|
|
if (LinkerOptions) {
|
2016-05-01 02:15:34 +08:00
|
|
|
for (const auto &Option : LinkerOptions->operands()) {
|
2013-01-19 03:37:00 +08:00
|
|
|
SmallVector<std::string, 4> StrOptions;
|
2016-05-01 02:15:34 +08:00
|
|
|
for (const auto &Piece : cast<MDNode>(Option)->operands())
|
|
|
|
StrOptions.push_back(cast<MDString>(Piece)->getString());
|
2013-01-19 03:37:00 +08:00
|
|
|
Streamer.EmitLinkerOptions(StrOptions);
|
|
|
|
}
|
2012-02-15 05:28:13 +08:00
|
|
|
}
|
|
|
|
|
2012-02-16 06:36:15 +08:00
|
|
|
// The section is mandatory. If we don't have it, then we don't have GC info.
|
|
|
|
if (SectionVal.empty()) return;
|
|
|
|
|
|
|
|
StringRef Segment, Section;
|
|
|
|
unsigned TAA = 0, StubSize = 0;
|
|
|
|
bool TAAParsed;
|
|
|
|
std::string ErrorCode =
|
|
|
|
MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
|
|
|
|
TAA, TAAParsed, StubSize);
|
2012-02-16 06:47:53 +08:00
|
|
|
if (!ErrorCode.empty())
|
2012-02-16 06:36:15 +08:00
|
|
|
// If invalid, report the error with report_fatal_error.
|
2012-02-16 06:47:53 +08:00
|
|
|
report_fatal_error("Invalid section specifier '" + Section + "': " +
|
|
|
|
ErrorCode + ".");
|
2012-02-15 05:28:13 +08:00
|
|
|
|
2012-02-16 06:36:15 +08:00
|
|
|
// Get the section.
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSectionMachO *S = getContext().getMachOSection(
|
2015-11-18 14:02:15 +08:00
|
|
|
Segment, Section, TAA, StubSize, SectionKind::getData());
|
2012-02-16 06:36:15 +08:00
|
|
|
Streamer.SwitchSection(S);
|
|
|
|
Streamer.EmitLabel(getContext().
|
2015-05-19 02:43:14 +08:00
|
|
|
getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
|
2012-02-15 05:28:13 +08:00
|
|
|
Streamer.EmitIntValue(VersionVal, 4);
|
2012-04-24 19:03:50 +08:00
|
|
|
Streamer.EmitIntValue(ImageInfoFlags, 4);
|
2012-02-15 05:28:13 +08:00
|
|
|
Streamer.AddBlankLine();
|
|
|
|
}
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
static void checkMachOComdat(const GlobalValue *GV) {
|
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
if (!C)
|
|
|
|
return;
|
|
|
|
|
|
|
|
report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
|
|
|
|
"' cannot be lowered.");
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2010-02-16 06:37:53 +08:00
|
|
|
// Parse the section specifier and create it if valid.
|
|
|
|
StringRef Segment, Section;
|
2011-03-19 10:42:31 +08:00
|
|
|
unsigned TAA = 0, StubSize = 0;
|
|
|
|
bool TAAParsed;
|
2014-06-28 02:19:56 +08:00
|
|
|
|
2016-10-25 03:23:39 +08:00
|
|
|
checkMachOComdat(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
std::string ErrorCode =
|
2016-10-25 03:23:39 +08:00
|
|
|
MCSectionMachO::ParseSectionSpecifier(GO->getSection(), Segment, Section,
|
2011-03-19 10:42:31 +08:00
|
|
|
TAA, TAAParsed, StubSize);
|
2010-02-16 06:37:53 +08:00
|
|
|
if (!ErrorCode.empty()) {
|
2010-04-08 06:58:41 +08:00
|
|
|
// If invalid, report the error with report_fatal_error.
|
2016-10-25 03:23:39 +08:00
|
|
|
report_fatal_error("Global variable '" + GO->getName() +
|
2011-11-16 00:27:03 +08:00
|
|
|
"' has an invalid section specifier '" +
|
2016-10-25 03:23:39 +08:00
|
|
|
GO->getSection() + "': " + ErrorCode + ".");
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Get the section.
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSectionMachO *S =
|
|
|
|
getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2011-02-22 01:27:17 +08:00
|
|
|
// If TAA wasn't set by ParseSectionSpecifier() above,
|
|
|
|
// use the value returned by getMachOSection() as a default.
|
2011-03-19 10:42:31 +08:00
|
|
|
if (!TAAParsed)
|
2011-02-22 01:27:17 +08:00
|
|
|
TAA = S->getTypeAndAttributes();
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
// Okay, now that we got the section, verify that the TAA & StubSize agree.
|
|
|
|
// If the user declared multiple globals with different section flags, we need
|
|
|
|
// to reject it here.
|
|
|
|
if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
|
2010-04-08 06:58:41 +08:00
|
|
|
// If invalid, report the error with report_fatal_error.
|
2016-10-25 03:23:39 +08:00
|
|
|
report_fatal_error("Global variable '" + GO->getName() +
|
2011-11-16 00:27:03 +08:00
|
|
|
"' section type or attributes does not match previous"
|
|
|
|
" section specifier");
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return S;
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileMachO::SelectSectionForGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
|
|
|
checkMachOComdat(GO);
|
2013-11-17 18:53:13 +08:00
|
|
|
|
|
|
|
// Handle thread local data.
|
|
|
|
if (Kind.isThreadBSS()) return TLSBSSSection;
|
|
|
|
if (Kind.isThreadData()) return TLSDataSection;
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isText())
|
2016-10-25 03:23:39 +08:00
|
|
|
return GO->isWeakForLinker() ? TextCoalSection : TextSection;
|
2013-08-09 05:04:16 +08:00
|
|
|
|
|
|
|
// If this is weak/linkonce, put this in a coalescable section, either in text
|
|
|
|
// or data depending on if it is writable.
|
2016-10-25 03:23:39 +08:00
|
|
|
if (GO->isWeakForLinker()) {
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isReadOnly())
|
2013-08-09 05:04:16 +08:00
|
|
|
return ConstTextCoalSection;
|
|
|
|
return DataCoalSection;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Alignment check should be handled by section classifier.
|
2010-03-07 12:28:09 +08:00
|
|
|
if (Kind.isMergeable1ByteCString() &&
|
2016-10-25 03:23:39 +08:00
|
|
|
GO->getParent()->getDataLayout().getPreferredAlignment(
|
|
|
|
cast<GlobalVariable>(GO)) < 32)
|
2010-03-07 12:28:09 +08:00
|
|
|
return CStringSection;
|
2010-10-28 02:52:20 +08:00
|
|
|
|
2010-03-07 12:28:09 +08:00
|
|
|
// Do not put 16-bit arrays in the UString section if they have an
|
|
|
|
// externally visible label, this runs into issues with certain linker
|
|
|
|
// versions.
|
2016-10-25 03:23:39 +08:00
|
|
|
if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
|
|
|
|
GO->getParent()->getDataLayout().getPreferredAlignment(
|
|
|
|
cast<GlobalVariable>(GO)) < 32)
|
2010-03-07 12:28:09 +08:00
|
|
|
return UStringSection;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2014-08-29 04:13:31 +08:00
|
|
|
// With MachO only variables whose corresponding symbol starts with 'l' or
|
|
|
|
// 'L' can be merged, so we only try merging GVs with private linkage.
|
2016-10-25 03:23:39 +08:00
|
|
|
if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isMergeableConst4())
|
|
|
|
return FourByteConstantSection;
|
|
|
|
if (Kind.isMergeableConst8())
|
|
|
|
return EightByteConstantSection;
|
2014-02-14 07:16:11 +08:00
|
|
|
if (Kind.isMergeableConst16())
|
2010-02-16 06:37:53 +08:00
|
|
|
return SixteenByteConstantSection;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, if it is readonly, but not something we can specially optimize,
|
|
|
|
// just drop it in .const.
|
|
|
|
if (Kind.isReadOnly())
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
|
|
// If this is marked const, put it into a const section. But if the dynamic
|
|
|
|
// linker needs to write to it, put it in the data segment.
|
|
|
|
if (Kind.isReadOnlyWithRel())
|
|
|
|
return ConstDataSection;
|
|
|
|
|
|
|
|
// Put zero initialized globals with strong external linkage in the
|
|
|
|
// DATA, __common section with the .zerofill directive.
|
|
|
|
if (Kind.isBSSExtern())
|
|
|
|
return DataCommonSection;
|
|
|
|
|
|
|
|
// Put zero initialized globals with local linkage in __DATA,__bss directive
|
|
|
|
// with the .zerofill directive (aka .lcomm).
|
|
|
|
if (Kind.isBSSLocal())
|
|
|
|
return DataBSSSection;
|
2010-10-28 02:52:20 +08:00
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
// Otherwise, just drop the variable in the normal data section.
|
|
|
|
return DataSection;
|
|
|
|
}
|
|
|
|
|
2015-07-16 14:04:17 +08:00
|
|
|
MCSection *TargetLoweringObjectFileMachO::getSectionForConstant(
|
2016-02-21 09:30:30 +08:00
|
|
|
const DataLayout &DL, SectionKind Kind, const Constant *C,
|
|
|
|
unsigned &Align) const {
|
2010-02-16 06:37:53 +08:00
|
|
|
// If this constant requires a relocation, we have to put it in the data
|
|
|
|
// segment, not in the text segment.
|
2015-11-18 14:02:15 +08:00
|
|
|
if (Kind.isData() || Kind.isReadOnlyWithRel())
|
2010-02-16 06:37:53 +08:00
|
|
|
return ConstDataSection;
|
|
|
|
|
|
|
|
if (Kind.isMergeableConst4())
|
|
|
|
return FourByteConstantSection;
|
|
|
|
if (Kind.isMergeableConst8())
|
|
|
|
return EightByteConstantSection;
|
2014-02-14 07:16:11 +08:00
|
|
|
if (Kind.isMergeableConst16())
|
2010-02-16 06:37:53 +08:00
|
|
|
return SixteenByteConstantSection;
|
|
|
|
return ReadOnlySection; // .const
|
|
|
|
}
|
|
|
|
|
2014-02-09 22:50:44 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
|
|
|
|
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
|
2010-02-16 06:37:53 +08:00
|
|
|
// The mach-o version of this method defaults to returning a stub reference.
|
|
|
|
|
2010-02-22 04:28:15 +08:00
|
|
|
if (Encoding & DW_EH_PE_indirect) {
|
|
|
|
MachineModuleInfoMachO &MachOMMI =
|
|
|
|
MMI->getObjFileInfo<MachineModuleInfoMachO>();
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
|
2010-02-22 04:28:15 +08:00
|
|
|
|
|
|
|
// Add information about the stub reference to MachOMMI so that the stub
|
|
|
|
// gets emitted by the asmprinter.
|
2016-05-18 00:01:32 +08:00
|
|
|
MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!StubSym.getPointer()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(GV);
|
2010-03-16 04:37:38 +08:00
|
|
|
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
|
2010-02-22 04:28:15 +08:00
|
|
|
}
|
2010-02-16 06:37:53 +08:00
|
|
|
|
|
|
|
return TargetLoweringObjectFile::
|
2015-05-30 09:25:56 +08:00
|
|
|
getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
|
2012-11-14 09:47:00 +08:00
|
|
|
Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
|
|
|
|
MMI, Streamer);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2014-02-20 01:23:20 +08:00
|
|
|
MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol(
|
2016-09-16 15:33:15 +08:00
|
|
|
const GlobalValue *GV, const TargetMachine &TM,
|
2014-02-20 01:23:20 +08:00
|
|
|
MachineModuleInfo *MMI) const {
|
2011-04-28 07:08:15 +08:00
|
|
|
// The mach-o version of this method defaults to returning a stub reference.
|
|
|
|
MachineModuleInfoMachO &MachOMMI =
|
|
|
|
MMI->getObjFileInfo<MachineModuleInfoMachO>();
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
|
2011-04-28 07:08:15 +08:00
|
|
|
|
|
|
|
// Add information about the stub reference to MachOMMI so that the stub
|
|
|
|
// gets emitted by the asmprinter.
|
2011-11-29 09:43:20 +08:00
|
|
|
MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!StubSym.getPointer()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(GV);
|
2011-04-28 07:08:15 +08:00
|
|
|
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
|
|
|
|
}
|
|
|
|
|
|
|
|
return SSym;
|
|
|
|
}
|
|
|
|
|
2015-03-06 21:49:05 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel(
|
|
|
|
const MCSymbol *Sym, const MCValue &MV, int64_t Offset,
|
|
|
|
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
|
2015-08-09 02:27:36 +08:00
|
|
|
// Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
|
2015-03-06 21:49:05 +08:00
|
|
|
// as 64-bit do, we replace the GOT equivalent by accessing the final symbol
|
|
|
|
// through a non_lazy_ptr stub instead. One advantage is that it allows the
|
|
|
|
// computation of deltas to final external symbols. Example:
|
|
|
|
//
|
|
|
|
// _extgotequiv:
|
|
|
|
// .long _extfoo
|
|
|
|
//
|
|
|
|
// _delta:
|
|
|
|
// .long _extgotequiv-_delta
|
|
|
|
//
|
|
|
|
// is transformed to:
|
|
|
|
//
|
|
|
|
// _delta:
|
|
|
|
// .long L_extfoo$non_lazy_ptr-(_delta+0)
|
|
|
|
//
|
|
|
|
// .section __IMPORT,__pointers,non_lazy_symbol_pointers
|
|
|
|
// L_extfoo$non_lazy_ptr:
|
|
|
|
// .indirect_symbol _extfoo
|
|
|
|
// .long 0
|
|
|
|
//
|
|
|
|
MachineModuleInfoMachO &MachOMMI =
|
|
|
|
MMI->getObjFileInfo<MachineModuleInfoMachO>();
|
|
|
|
MCContext &Ctx = getContext();
|
|
|
|
|
|
|
|
// The offset must consider the original displacement from the base symbol
|
|
|
|
// since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
|
|
|
|
Offset = -MV.getConstant();
|
|
|
|
const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
|
|
|
|
|
|
|
|
// Access the final symbol via sym$non_lazy_ptr and generate the appropriated
|
|
|
|
// non_lazy_ptr stubs.
|
|
|
|
SmallString<128> Name;
|
|
|
|
StringRef Suffix = "$non_lazy_ptr";
|
2015-07-16 14:04:17 +08:00
|
|
|
Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
|
2015-03-06 21:49:05 +08:00
|
|
|
Name += Sym->getName();
|
|
|
|
Name += Suffix;
|
2015-05-19 02:43:14 +08:00
|
|
|
MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
|
2015-03-06 21:49:05 +08:00
|
|
|
|
|
|
|
MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
|
|
|
|
if (!StubSym.getPointer())
|
|
|
|
StubSym = MachineModuleInfoImpl::
|
|
|
|
StubValueTy(const_cast<MCSymbol *>(Sym), true /* access indirectly */);
|
|
|
|
|
|
|
|
const MCExpr *BSymExpr =
|
2015-05-30 09:25:56 +08:00
|
|
|
MCSymbolRefExpr::create(BaseSym, MCSymbolRefExpr::VK_None, Ctx);
|
2015-03-06 21:49:05 +08:00
|
|
|
const MCExpr *LHS =
|
2015-05-30 09:25:56 +08:00
|
|
|
MCSymbolRefExpr::create(Stub, MCSymbolRefExpr::VK_None, Ctx);
|
2015-03-06 21:49:05 +08:00
|
|
|
|
|
|
|
if (!Offset)
|
2015-05-30 09:25:56 +08:00
|
|
|
return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
|
2015-03-06 21:49:05 +08:00
|
|
|
|
|
|
|
const MCExpr *RHS =
|
2015-05-30 09:25:56 +08:00
|
|
|
MCBinaryExpr::createAdd(BSymExpr, MCConstantExpr::create(Offset, Ctx), Ctx);
|
|
|
|
return MCBinaryExpr::createSub(LHS, RHS, Ctx);
|
2015-03-06 21:49:05 +08:00
|
|
|
}
|
|
|
|
|
2015-11-04 07:40:03 +08:00
|
|
|
static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
|
|
|
|
const MCSection &Section) {
|
|
|
|
if (!AsmInfo.isSectionAtomizableBySymbols(Section))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// If it is not dead stripped, it is safe to use private labels.
|
|
|
|
const MCSectionMachO &SMO = cast<MCSectionMachO>(Section);
|
|
|
|
if (SMO.hasAttribute(MachO::S_ATTR_NO_DEAD_STRIP))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TargetLoweringObjectFileMachO::getNameWithPrefix(
|
2016-09-16 15:33:15 +08:00
|
|
|
SmallVectorImpl<char> &OutName, const GlobalValue *GV,
|
2015-11-04 07:40:03 +08:00
|
|
|
const TargetMachine &TM) const {
|
2016-10-25 03:23:39 +08:00
|
|
|
bool CannotUsePrivateLabel = true;
|
|
|
|
if (auto *GO = GV->getBaseObject()) {
|
|
|
|
SectionKind GOKind = TargetLoweringObjectFile::getKindForGlobal(GO, TM);
|
|
|
|
const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
|
|
|
|
CannotUsePrivateLabel =
|
|
|
|
!canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
|
|
|
|
}
|
2016-09-16 15:33:15 +08:00
|
|
|
getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
|
2015-11-04 07:40:03 +08:00
|
|
|
}
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// COFF
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-05-08 01:17:41 +08:00
|
|
|
static unsigned
|
2016-06-27 22:42:20 +08:00
|
|
|
getCOFFSectionFlags(SectionKind K, const TargetMachine &TM) {
|
2010-05-08 01:17:41 +08:00
|
|
|
unsigned Flags = 0;
|
2016-06-27 22:42:20 +08:00
|
|
|
bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
|
2010-05-08 01:17:41 +08:00
|
|
|
|
2010-07-06 23:24:56 +08:00
|
|
|
if (K.isMetadata())
|
2010-05-08 05:49:09 +08:00
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_MEM_DISCARDABLE;
|
2010-05-08 01:17:41 +08:00
|
|
|
else if (K.isText())
|
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_MEM_EXECUTE |
|
2010-10-28 02:52:29 +08:00
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
2016-06-27 22:42:20 +08:00
|
|
|
COFF::IMAGE_SCN_CNT_CODE |
|
|
|
|
(isThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0);
|
2014-09-20 15:31:46 +08:00
|
|
|
else if (K.isBSS())
|
2010-05-08 05:49:09 +08:00
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
COFF::IMAGE_SCN_MEM_WRITE;
|
2012-02-12 01:26:53 +08:00
|
|
|
else if (K.isThreadLocal())
|
|
|
|
Flags |=
|
|
|
|
COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
COFF::IMAGE_SCN_MEM_WRITE;
|
2014-09-20 15:31:46 +08:00
|
|
|
else if (K.isReadOnly() || K.isReadOnlyWithRel())
|
2010-05-08 01:17:41 +08:00
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ;
|
2010-05-08 01:17:41 +08:00
|
|
|
else if (K.isWriteable())
|
|
|
|
Flags |=
|
2010-07-02 04:07:24 +08:00
|
|
|
COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
COFF::IMAGE_SCN_MEM_WRITE;
|
2010-05-08 01:17:41 +08:00
|
|
|
|
|
|
|
return Flags;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2014-07-07 22:47:51 +08:00
|
|
|
static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
|
2014-06-28 02:19:56 +08:00
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
assert(C && "expected GV to have a Comdat!");
|
|
|
|
|
|
|
|
StringRef ComdatGVName = C->getName();
|
|
|
|
const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
|
|
|
|
if (!ComdatGV)
|
|
|
|
report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
|
|
|
|
"' does not exist.");
|
|
|
|
|
|
|
|
if (ComdatGV->getComdat() != C)
|
|
|
|
report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
|
2014-09-19 09:14:56 +08:00
|
|
|
"' is not a key for its COMDAT.");
|
2014-06-28 02:19:56 +08:00
|
|
|
|
|
|
|
return ComdatGV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int getSelectionForCOFF(const GlobalValue *GV) {
|
|
|
|
if (const Comdat *C = GV->getComdat()) {
|
|
|
|
const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
|
|
|
|
if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
|
|
|
|
ComdatKey = GA->getBaseObject();
|
|
|
|
if (ComdatKey == GV) {
|
|
|
|
switch (C->getSelectionKind()) {
|
|
|
|
case Comdat::Any:
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_ANY;
|
|
|
|
case Comdat::ExactMatch:
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
|
|
|
|
case Comdat::Largest:
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_LARGEST;
|
|
|
|
case Comdat::NoDuplicates:
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
|
|
|
|
case Comdat::SameSize:
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-02-03 07:00:49 +08:00
|
|
|
void llvm::emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV,
|
|
|
|
const Triple &TT, Mangler &Mangler) {
|
|
|
|
if (!GV->hasDLLExportStorageClass() || GV->isDeclaration())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (TT.isKnownWindowsMSVCEnvironment())
|
|
|
|
OS << " /EXPORT:";
|
|
|
|
else
|
|
|
|
OS << " -export:";
|
|
|
|
|
|
|
|
if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {
|
|
|
|
std::string Flag;
|
|
|
|
raw_string_ostream FlagOS(Flag);
|
|
|
|
Mangler.getNameWithPrefix(FlagOS, GV, false);
|
|
|
|
FlagOS.flush();
|
|
|
|
if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
|
|
|
|
OS << Flag.substr(1);
|
|
|
|
else
|
|
|
|
OS << Flag;
|
|
|
|
} else {
|
|
|
|
Mangler.getNameWithPrefix(OS, GV, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!GV->getValueType()->isFunctionTy()) {
|
|
|
|
if (TT.isKnownWindowsMSVCEnvironment())
|
|
|
|
OS << ",DATA";
|
|
|
|
else
|
|
|
|
OS << ",data";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2012-11-14 06:04:09 +08:00
|
|
|
int Selection = 0;
|
2016-06-27 22:42:20 +08:00
|
|
|
unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
|
2016-10-25 03:23:39 +08:00
|
|
|
StringRef Name = GO->getSection();
|
2013-11-27 09:18:37 +08:00
|
|
|
StringRef COMDATSymName = "";
|
2016-10-25 03:23:39 +08:00
|
|
|
if (GO->hasComdat()) {
|
|
|
|
Selection = getSelectionForCOFF(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
const GlobalValue *ComdatGV;
|
|
|
|
if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
|
2016-10-25 03:23:39 +08:00
|
|
|
ComdatGV = getComdatGVForCOFF(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
else
|
2016-10-25 03:23:39 +08:00
|
|
|
ComdatGV = GO;
|
2014-06-28 02:19:56 +08:00
|
|
|
|
|
|
|
if (!ComdatGV->hasPrivateLinkage()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(ComdatGV);
|
2014-06-28 02:19:56 +08:00
|
|
|
COMDATSymName = Sym->getName();
|
|
|
|
Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
|
|
|
|
} else {
|
|
|
|
Selection = 0;
|
|
|
|
}
|
2012-11-14 06:04:09 +08:00
|
|
|
}
|
2016-05-03 07:22:18 +08:00
|
|
|
|
|
|
|
return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
|
2013-07-06 20:13:10 +08:00
|
|
|
Selection);
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2013-11-27 09:18:37 +08:00
|
|
|
static const char *getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Kind.isText())
|
2013-11-27 09:18:37 +08:00
|
|
|
return ".text";
|
2014-04-09 06:33:40 +08:00
|
|
|
if (Kind.isBSS())
|
2013-11-27 09:18:37 +08:00
|
|
|
return ".bss";
|
|
|
|
if (Kind.isThreadLocal())
|
2013-11-27 23:52:11 +08:00
|
|
|
return ".tls$";
|
2014-09-23 04:39:23 +08:00
|
|
|
if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
|
|
|
|
return ".rdata";
|
|
|
|
return ".data";
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal(
|
2016-10-25 03:23:39 +08:00
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2014-03-24 01:47:39 +08:00
|
|
|
// If we have -ffunction-sections then we should emit the global value to a
|
|
|
|
// uniqued section specifically for it.
|
2014-03-25 14:14:26 +08:00
|
|
|
bool EmitUniquedSection;
|
|
|
|
if (Kind.isText())
|
|
|
|
EmitUniquedSection = TM.getFunctionSections();
|
|
|
|
else
|
|
|
|
EmitUniquedSection = TM.getDataSections();
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2016-10-25 03:23:39 +08:00
|
|
|
if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
|
2013-11-27 09:18:37 +08:00
|
|
|
const char *Name = getCOFFSectionNameForUniqueGlobal(Kind);
|
2016-06-27 22:42:20 +08:00
|
|
|
unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
|
2010-05-08 05:49:09 +08:00
|
|
|
|
2010-07-02 04:07:24 +08:00
|
|
|
Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
|
2016-10-25 03:23:39 +08:00
|
|
|
int Selection = getSelectionForCOFF(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
if (!Selection)
|
|
|
|
Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
|
|
|
|
const GlobalValue *ComdatGV;
|
2016-10-25 03:23:39 +08:00
|
|
|
if (GO->hasComdat())
|
|
|
|
ComdatGV = getComdatGVForCOFF(GO);
|
2014-06-28 02:19:56 +08:00
|
|
|
else
|
2016-10-25 03:23:39 +08:00
|
|
|
ComdatGV = GO;
|
2014-06-28 02:19:56 +08:00
|
|
|
|
2016-05-03 07:22:18 +08:00
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
|
|
|
if (EmitUniquedSection)
|
|
|
|
UniqueID = NextUniqueID++;
|
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
if (!ComdatGV->hasPrivateLinkage()) {
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(ComdatGV);
|
2014-06-28 02:19:56 +08:00
|
|
|
StringRef COMDATSymName = Sym->getName();
|
|
|
|
return getContext().getCOFFSection(Name, Characteristics, Kind,
|
2016-05-03 07:22:18 +08:00
|
|
|
COMDATSymName, Selection, UniqueID);
|
2015-03-18 07:54:51 +08:00
|
|
|
} else {
|
|
|
|
SmallString<256> TmpData;
|
2016-10-25 03:23:39 +08:00
|
|
|
getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true);
|
2015-03-18 07:54:51 +08:00
|
|
|
return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
|
2016-05-03 07:22:18 +08:00
|
|
|
Selection, UniqueID);
|
2014-06-28 02:19:56 +08:00
|
|
|
}
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Kind.isText())
|
2013-08-13 09:23:53 +08:00
|
|
|
return TextSection;
|
2010-02-16 06:37:53 +08:00
|
|
|
|
2012-02-12 01:26:53 +08:00
|
|
|
if (Kind.isThreadLocal())
|
2013-08-13 09:23:53 +08:00
|
|
|
return TLSDataSection;
|
2012-02-12 01:26:53 +08:00
|
|
|
|
2014-09-23 04:39:23 +08:00
|
|
|
if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
|
2013-08-08 09:50:52 +08:00
|
|
|
return ReadOnlySection;
|
|
|
|
|
2014-04-09 06:33:40 +08:00
|
|
|
// Note: we claim that common symbols are put in BSSSection, but they are
|
|
|
|
// really emitted with the magic .comm directive, which creates a symbol table
|
|
|
|
// entry but not a section.
|
|
|
|
if (Kind.isBSS() || Kind.isCommon())
|
2013-08-13 09:23:53 +08:00
|
|
|
return BSSSection;
|
|
|
|
|
|
|
|
return DataSection;
|
2010-02-16 06:37:53 +08:00
|
|
|
}
|
|
|
|
|
2015-03-18 07:54:51 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::getNameWithPrefix(
|
2016-09-16 15:33:15 +08:00
|
|
|
SmallVectorImpl<char> &OutName, const GlobalValue *GV,
|
2015-11-04 07:40:03 +08:00
|
|
|
const TargetMachine &TM) const {
|
|
|
|
bool CannotUsePrivateLabel = false;
|
2015-03-18 07:54:51 +08:00
|
|
|
if (GV->hasPrivateLinkage() &&
|
|
|
|
((isa<Function>(GV) && TM.getFunctionSections()) ||
|
|
|
|
(isa<GlobalVariable>(GV) && TM.getDataSections())))
|
|
|
|
CannotUsePrivateLabel = true;
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
|
2015-03-18 07:54:51 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
|
2016-09-16 15:33:15 +08:00
|
|
|
const Function &F, const TargetMachine &TM) const {
|
2015-03-12 03:58:37 +08:00
|
|
|
// If the function can be removed, produce a unique section so that
|
|
|
|
// the table doesn't prevent the removal.
|
|
|
|
const Comdat *C = F.getComdat();
|
|
|
|
bool EmitUniqueSection = TM.getFunctionSections() || C;
|
|
|
|
if (!EmitUniqueSection)
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
|
|
|
// FIXME: we should produce a symbol for F instead.
|
|
|
|
if (F.hasPrivateLinkage())
|
|
|
|
return ReadOnlySection;
|
|
|
|
|
2016-11-23 00:17:20 +08:00
|
|
|
MCSymbol *Sym = TM.getSymbol(&F);
|
2015-03-12 03:58:37 +08:00
|
|
|
StringRef COMDATSymName = Sym->getName();
|
|
|
|
|
|
|
|
SectionKind Kind = SectionKind::getReadOnly();
|
|
|
|
const char *Name = getCOFFSectionNameForUniqueGlobal(Kind);
|
2016-06-27 22:42:20 +08:00
|
|
|
unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
|
2015-03-12 03:58:37 +08:00
|
|
|
Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
|
2016-05-03 07:22:18 +08:00
|
|
|
unsigned UniqueID = NextUniqueID++;
|
2015-03-12 03:58:37 +08:00
|
|
|
|
|
|
|
return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
|
2016-05-03 07:22:18 +08:00
|
|
|
COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
|
2015-03-12 03:58:37 +08:00
|
|
|
}
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::emitModuleFlags(
|
|
|
|
MCStreamer &Streamer, ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
|
|
|
|
const TargetMachine &TM) const {
|
2014-04-14 08:51:57 +08:00
|
|
|
MDNode *LinkerOptions = nullptr;
|
2013-04-26 03:34:41 +08:00
|
|
|
|
2016-05-01 02:15:34 +08:00
|
|
|
for (const auto &MFE : ModuleFlags) {
|
2013-04-26 03:34:41 +08:00
|
|
|
StringRef Key = MFE.Key->getString();
|
2016-05-01 02:15:34 +08:00
|
|
|
if (Key == "Linker Options")
|
|
|
|
LinkerOptions = cast<MDNode>(MFE.Val);
|
2013-04-26 03:34:41 +08:00
|
|
|
}
|
|
|
|
|
2016-05-01 02:15:34 +08:00
|
|
|
if (LinkerOptions) {
|
|
|
|
// Emit the linker options to the linker .drectve section. According to the
|
|
|
|
// spec, this section is a space-separated string containing flags for
|
|
|
|
// linker.
|
|
|
|
MCSection *Sec = getDrectveSection();
|
|
|
|
Streamer.SwitchSection(Sec);
|
|
|
|
for (const auto &Option : LinkerOptions->operands()) {
|
|
|
|
for (const auto &Piece : cast<MDNode>(Option)->operands()) {
|
|
|
|
// Lead with a space for consistency with our dllexport implementation.
|
|
|
|
std::string Directive(" ");
|
|
|
|
Directive.append(cast<MDString>(Piece)->getString());
|
|
|
|
Streamer.EmitBytes(Directive);
|
|
|
|
}
|
2013-04-26 03:34:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-05-17 04:39:27 +08:00
|
|
|
|
2016-08-29 20:33:42 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
|
|
|
|
const TargetMachine &TM) {
|
|
|
|
TargetLoweringObjectFile::Initialize(Ctx, TM);
|
|
|
|
const Triple &T = TM.getTargetTriple();
|
|
|
|
if (T.isKnownWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
|
|
|
|
StaticCtorSection =
|
|
|
|
Ctx.getCOFFSection(".CRT$XCU", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ,
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
StaticDtorSection =
|
|
|
|
Ctx.getCOFFSection(".CRT$XTX", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ,
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
} else {
|
|
|
|
StaticCtorSection = Ctx.getCOFFSection(
|
|
|
|
".ctors", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE,
|
|
|
|
SectionKind::getData());
|
|
|
|
StaticDtorSection = Ctx.getCOFFSection(
|
|
|
|
".dtors", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE,
|
|
|
|
SectionKind::getData());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection(
|
2014-06-07 03:26:12 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
2014-09-05 01:42:03 +08:00
|
|
|
return getContext().getAssociativeCOFFSection(
|
2016-05-03 07:22:18 +08:00
|
|
|
cast<MCSectionCOFF>(StaticCtorSection), KeySym, 0);
|
2014-05-17 04:39:27 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 03:20:38 +08:00
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
|
2014-06-07 03:26:12 +08:00
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
2014-09-05 01:42:03 +08:00
|
|
|
return getContext().getAssociativeCOFFSection(
|
2016-05-03 07:22:18 +08:00
|
|
|
cast<MCSectionCOFF>(StaticDtorSection), KeySym, 0);
|
2014-05-17 04:39:27 +08:00
|
|
|
}
|
2015-06-30 06:04:09 +08:00
|
|
|
|
|
|
|
void TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal(
|
2016-09-16 15:33:15 +08:00
|
|
|
raw_ostream &OS, const GlobalValue *GV) const {
|
2017-02-03 07:00:49 +08:00
|
|
|
emitLinkerFlagsForGlobalCOFF(OS, GV, getTargetTriple(), getMangler());
|
2015-06-30 06:04:09 +08:00
|
|
|
}
|
2017-02-22 09:23:18 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Wasm
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-02-25 07:18:00 +08:00
|
|
|
static const Comdat *getWasmComdat(const GlobalValue *GV) {
|
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
if (!C)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (C->getSelectionKind() != Comdat::Any)
|
|
|
|
report_fatal_error("Wasm COMDATs only support SelectionKind::Any, '" +
|
|
|
|
C->getName() + "' cannot be lowered.");
|
|
|
|
|
|
|
|
return C;
|
|
|
|
}
|
|
|
|
|
2017-02-22 09:23:18 +08:00
|
|
|
MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
|
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
|
|
|
llvm_unreachable("getExplicitSectionGlobal not yet implemented");
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2017-02-25 07:18:00 +08:00
|
|
|
static MCSectionWasm *
|
|
|
|
selectWasmSectionForGlobal(MCContext &Ctx, const GlobalObject *GO,
|
|
|
|
SectionKind Kind, Mangler &Mang,
|
|
|
|
const TargetMachine &TM, bool EmitUniqueSection,
|
|
|
|
unsigned Flags, unsigned *NextUniqueID) {
|
|
|
|
StringRef Group = "";
|
|
|
|
if (getWasmComdat(GO))
|
|
|
|
llvm_unreachable("comdat not yet supported for wasm");
|
|
|
|
|
|
|
|
bool UniqueSectionNames = TM.getUniqueSectionNames();
|
|
|
|
SmallString<128> Name = getSectionPrefixForGlobal(Kind);
|
|
|
|
|
|
|
|
if (const auto *F = dyn_cast<Function>(GO)) {
|
|
|
|
const auto &OptionalPrefix = F->getSectionPrefix();
|
|
|
|
if (OptionalPrefix)
|
|
|
|
Name += *OptionalPrefix;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (EmitUniqueSection && UniqueSectionNames) {
|
|
|
|
Name.push_back('.');
|
|
|
|
TM.getNameWithPrefix(Name, GO, Mang, true);
|
|
|
|
}
|
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
|
|
|
if (EmitUniqueSection && !UniqueSectionNames) {
|
|
|
|
UniqueID = *NextUniqueID;
|
|
|
|
(*NextUniqueID)++;
|
|
|
|
}
|
|
|
|
return Ctx.getWasmSection(Name, /*Type=*/0, Flags,
|
|
|
|
Group, UniqueID);
|
|
|
|
}
|
|
|
|
|
2017-02-22 09:23:18 +08:00
|
|
|
MCSection *TargetLoweringObjectFileWasm::SelectSectionForGlobal(
|
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2017-02-25 07:18:00 +08:00
|
|
|
|
|
|
|
if (Kind.isCommon())
|
|
|
|
report_fatal_error("mergable sections not supported yet on wasm");
|
|
|
|
|
|
|
|
// If we have -ffunction-section or -fdata-section then we should emit the
|
|
|
|
// global value to a uniqued section specifically for it.
|
|
|
|
bool EmitUniqueSection = false;
|
2017-02-22 09:23:18 +08:00
|
|
|
if (Kind.isText())
|
2017-02-25 07:18:00 +08:00
|
|
|
EmitUniqueSection = TM.getFunctionSections();
|
|
|
|
else
|
|
|
|
EmitUniqueSection = TM.getDataSections();
|
|
|
|
EmitUniqueSection |= GO->hasComdat();
|
|
|
|
|
|
|
|
return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
|
|
|
|
EmitUniqueSection, /*Flags=*/0,
|
|
|
|
&NextUniqueID);
|
2017-02-22 09:23:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool TargetLoweringObjectFileWasm::shouldPutJumpTableInFunctionSection(
|
|
|
|
bool UsesLabelDifference, const Function &F) const {
|
|
|
|
// We can always create relative relocations, so use another section
|
|
|
|
// that can be marked non-executable.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const MCExpr *TargetLoweringObjectFileWasm::lowerRelativeReference(
|
|
|
|
const GlobalValue *LHS, const GlobalValue *RHS,
|
|
|
|
const TargetMachine &TM) const {
|
|
|
|
// We may only use a PLT-relative relocation to refer to unnamed_addr
|
|
|
|
// functions.
|
|
|
|
if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Basic sanity checks.
|
|
|
|
if (LHS->getType()->getPointerAddressSpace() != 0 ||
|
|
|
|
RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
|
|
|
|
RHS->isThreadLocal())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
return MCBinaryExpr::createSub(
|
|
|
|
MCSymbolRefExpr::create(TM.getSymbol(LHS), MCSymbolRefExpr::VK_None,
|
|
|
|
getContext()),
|
|
|
|
MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
TargetLoweringObjectFileWasm::InitializeWasm() {
|
|
|
|
// TODO: Initialize StaticCtorSection and StaticDtorSection.
|
|
|
|
}
|