2017-02-28 06:45:06 +08:00
|
|
|
//===- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info ---===//
|
2010-02-16 06:37:53 +08:00
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/ADT/StringRef.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2017-06-07 11:48:56 +08:00
|
|
|
#include "llvm/BinaryFormat/COFF.h"
|
|
|
|
#include "llvm/BinaryFormat/Dwarf.h"
|
|
|
|
#include "llvm/BinaryFormat/ELF.h"
|
|
|
|
#include "llvm/BinaryFormat/MachO.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/CodeGen/MachineModuleInfo.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/CodeGen/MachineModuleInfoImpls.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/IR/Comdat.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"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/IR/GlobalAlias.h"
|
|
|
|
#include "llvm/IR/GlobalObject.h"
|
|
|
|
#include "llvm/IR/GlobalValue.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
2014-01-08 05:19:40 +08:00
|
|
|
#include "llvm/IR/Mangler.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/IR/Metadata.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/IR/Type.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"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/MC/MCSymbol.h"
|
2015-06-02 08:25:12 +08:00
|
|
|
#include "llvm/MC/MCSymbolELF.h"
|
2015-03-06 21:49:05 +08:00
|
|
|
#include "llvm/MC/MCValue.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/MC/SectionKind.h"
|
2016-01-15 02:09:45 +08:00
|
|
|
#include "llvm/ProfileData/InstrProf.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
#include "llvm/Support/CodeGen.h"
|
2017-11-28 16:07:18 +08:00
|
|
|
#include "llvm/Support/Format.h"
|
2010-02-16 06:37:53 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2014-03-04 18:07:28 +08:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2017-02-28 06:45:06 +08:00
|
|
|
#include <cassert>
|
|
|
|
#include <string>
|
|
|
|
|
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
|
|
|
|
2017-06-13 04:10:48 +08:00
|
|
|
static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
|
2017-06-06 05:26:39 +08:00
|
|
|
StringRef &Section) {
|
2017-06-13 04:10:48 +08:00
|
|
|
SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
|
|
|
|
M.getModuleFlagsMetadata(ModuleFlags);
|
|
|
|
|
2017-06-06 05:26:39 +08:00
|
|
|
for (const auto &MFE: ModuleFlags) {
|
|
|
|
// Ignore flags with 'Require' behaviour.
|
|
|
|
if (MFE.Behavior == Module::Require)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
StringRef Key = MFE.Key->getString();
|
|
|
|
if (Key == "Objective-C Image Info Version") {
|
|
|
|
Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
|
|
|
|
} else if (Key == "Objective-C Garbage Collection" ||
|
|
|
|
Key == "Objective-C GC Only" ||
|
|
|
|
Key == "Objective-C Is Simulated" ||
|
|
|
|
Key == "Objective-C Class Properties" ||
|
|
|
|
Key == "Objective-C Image Swift Version") {
|
|
|
|
Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
|
|
|
|
} else if (Key == "Objective-C Image Info Section") {
|
|
|
|
Section = cast<MDString>(MFE.Val)->getString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ELF
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2018-07-16 08:28:24 +08:00
|
|
|
void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
|
|
|
|
const TargetMachine &TgtM) {
|
|
|
|
TargetLoweringObjectFile::Initialize(Ctx, TgtM);
|
|
|
|
TM = &TgtM;
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
|
2018-08-13 14:06:53 +08:00
|
|
|
CodeModel::Model CM = TgtM.getCodeModel();
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
|
|
|
|
switch (TgtM.getTargetTriple().getArch()) {
|
|
|
|
case Triple::arm:
|
|
|
|
case Triple::armeb:
|
|
|
|
case Triple::thumb:
|
|
|
|
case Triple::thumbeb:
|
|
|
|
if (Ctx.getAsmInfo()->getExceptionHandlingType() == ExceptionHandling::ARM)
|
|
|
|
break;
|
|
|
|
// Fallthrough if not using EHABI
|
|
|
|
LLVM_FALLTHROUGH;
|
|
|
|
case Triple::ppc:
|
|
|
|
case Triple::x86:
|
|
|
|
PersonalityEncoding = isPositionIndependent()
|
|
|
|
? dwarf::DW_EH_PE_indirect |
|
|
|
|
dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4
|
|
|
|
: dwarf::DW_EH_PE_absptr;
|
|
|
|
LSDAEncoding = isPositionIndependent()
|
|
|
|
? dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4
|
|
|
|
: dwarf::DW_EH_PE_absptr;
|
|
|
|
TTypeEncoding = isPositionIndependent()
|
|
|
|
? dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4
|
|
|
|
: dwarf::DW_EH_PE_absptr;
|
|
|
|
break;
|
|
|
|
case Triple::x86_64:
|
|
|
|
if (isPositionIndependent()) {
|
2018-08-13 14:06:53 +08:00
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
((CM == CodeModel::Small || CM == CodeModel::Medium)
|
|
|
|
? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel |
|
2018-08-13 14:06:53 +08:00
|
|
|
(CM == CodeModel::Small
|
|
|
|
? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
2018-08-13 14:06:53 +08:00
|
|
|
((CM == CodeModel::Small || CM == CodeModel::Medium)
|
|
|
|
? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4);
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
} else {
|
|
|
|
PersonalityEncoding =
|
2018-08-13 14:06:53 +08:00
|
|
|
(CM == CodeModel::Small || CM == CodeModel::Medium)
|
|
|
|
? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
|
|
|
|
LSDAEncoding = (CM == CodeModel::Small)
|
|
|
|
? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
|
|
|
|
TTypeEncoding = (CM == CodeModel::Small)
|
|
|
|
? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Triple::hexagon:
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
PersonalityEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
|
|
|
|
LSDAEncoding |= dwarf::DW_EH_PE_pcrel;
|
|
|
|
TTypeEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Triple::aarch64:
|
|
|
|
case Triple::aarch64_be:
|
|
|
|
// The small model guarantees static code/data size < 4GB, but not where it
|
|
|
|
// will be in memory. Most of these could end up >2GB away so even a signed
|
|
|
|
// pc-relative 32-bit address is insufficient, theoretically.
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata8;
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata8;
|
|
|
|
} else {
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Triple::lanai:
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
break;
|
|
|
|
case Triple::mips:
|
|
|
|
case Triple::mipsel:
|
|
|
|
case Triple::mips64:
|
|
|
|
case Triple::mips64el:
|
|
|
|
// MIPS uses indirect pointer to refer personality functions and types, so
|
|
|
|
// that the eh_frame section can be read-only. DW.ref.personality will be
|
|
|
|
// generated for relocation.
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect;
|
|
|
|
// FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
|
|
|
|
// identify N64 from just a triple.
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
// We don't support PC-relative LSDA references in GAS so we use the default
|
|
|
|
// DW_EH_PE_absptr for those.
|
|
|
|
|
|
|
|
// FreeBSD must be explicit about the data size and using pcrel since it's
|
|
|
|
// assembler/linker won't do the automatic conversion that the Linux tools
|
|
|
|
// do.
|
|
|
|
if (TgtM.getTargetTriple().isOSFreeBSD()) {
|
|
|
|
PersonalityEncoding |= dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Triple::ppc64:
|
|
|
|
case Triple::ppc64le:
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_udata8;
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_udata8;
|
|
|
|
break;
|
|
|
|
case Triple::sparcel:
|
|
|
|
case Triple::sparc:
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
} else {
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Triple::sparcv9:
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
} else {
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Triple::systemz:
|
|
|
|
// All currently-defined code models guarantee that 4-byte PC-relative
|
|
|
|
// values will be in range.
|
|
|
|
if (isPositionIndependent()) {
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
|
|
|
|
dwarf::DW_EH_PE_sdata4;
|
|
|
|
} else {
|
|
|
|
PersonalityEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2018-07-16 08:28:24 +08:00
|
|
|
}
|
|
|
|
|
2018-04-21 03:07:57 +08:00
|
|
|
void TargetLoweringObjectFileELF::emitModuleMetadata(MCStreamer &Streamer,
|
|
|
|
Module &M) const {
|
2018-01-31 00:29:29 +08:00
|
|
|
auto &C = getContext();
|
|
|
|
|
|
|
|
if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
|
|
|
|
auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
|
|
|
|
ELF::SHF_EXCLUDE);
|
|
|
|
|
|
|
|
Streamer.SwitchSection(S);
|
|
|
|
|
|
|
|
for (const auto &Operand : LinkerOptions->operands()) {
|
|
|
|
if (cast<MDNode>(Operand)->getNumOperands() != 2)
|
|
|
|
report_fatal_error("invalid llvm.linker.options");
|
|
|
|
for (const auto &Option : cast<MDNode>(Operand)->operands()) {
|
|
|
|
Streamer.EmitBytes(cast<MDString>(Option)->getString());
|
|
|
|
Streamer.EmitIntValue(0, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-06 05:26:39 +08:00
|
|
|
unsigned Version = 0;
|
|
|
|
unsigned Flags = 0;
|
|
|
|
StringRef Section;
|
|
|
|
|
2017-06-13 04:10:48 +08:00
|
|
|
GetObjCImageInfo(M, Version, Flags, Section);
|
2018-07-16 08:28:24 +08:00
|
|
|
if (!Section.empty()) {
|
|
|
|
auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
|
|
|
|
Streamer.SwitchSection(S);
|
|
|
|
Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
|
|
|
|
Streamer.EmitIntValue(Version, 4);
|
|
|
|
Streamer.EmitIntValue(Flags, 4);
|
|
|
|
Streamer.AddBlankLine();
|
|
|
|
}
|
|
|
|
|
|
|
|
SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
|
|
|
|
M.getModuleFlagsMetadata(ModuleFlags);
|
|
|
|
|
|
|
|
MDNode *CFGProfile = nullptr;
|
|
|
|
|
|
|
|
for (const auto &MFE : ModuleFlags) {
|
|
|
|
StringRef Key = MFE.Key->getString();
|
|
|
|
if (Key == "CG Profile") {
|
|
|
|
CFGProfile = cast<MDNode>(MFE.Val);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CFGProfile)
|
2017-06-06 05:26:39 +08:00
|
|
|
return;
|
|
|
|
|
2018-07-16 08:28:24 +08:00
|
|
|
auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
|
|
|
|
if (!MDO)
|
|
|
|
return nullptr;
|
|
|
|
auto V = cast<ValueAsMetadata>(MDO);
|
|
|
|
const Function *F = cast<Function>(V->getValue());
|
|
|
|
return TM->getSymbol(F);
|
|
|
|
};
|
|
|
|
|
|
|
|
for (const auto &Edge : CFGProfile->operands()) {
|
|
|
|
MDNode *E = cast<MDNode>(Edge);
|
|
|
|
const MCSymbol *From = GetSym(E->getOperand(0));
|
|
|
|
const MCSymbol *To = GetSym(E->getOperand(1));
|
|
|
|
// Skip null functions. This can happen if functions are dead stripped after
|
|
|
|
// the CGProfile pass has been run.
|
|
|
|
if (!From || !To)
|
|
|
|
continue;
|
|
|
|
uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
|
|
|
|
->getValue()
|
|
|
|
->getUniqueInteger()
|
|
|
|
.getZExtValue();
|
|
|
|
Streamer.emitCGProfileEntry(
|
|
|
|
MCSymbolRefExpr::create(From, MCSymbolRefExpr::VK_None, C),
|
|
|
|
MCSymbolRefExpr::create(To, MCSymbolRefExpr::VK_None, C), Count);
|
|
|
|
}
|
2017-06-06 05:26:39 +08:00
|
|
|
}
|
|
|
|
|
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();
|
2017-02-28 06:45:06 +08:00
|
|
|
if ((Encoding & 0x80) == 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());
|
2017-02-28 06:45:06 +08:00
|
|
|
if ((Encoding & 0x70) == 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);
|
2017-11-15 14:17:32 +08:00
|
|
|
Streamer.EmitValueToAlignment(DL.getPointerABIAlignment(0));
|
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 {
|
2017-02-28 06:45:06 +08:00
|
|
|
if (Encoding & DW_EH_PE_indirect) {
|
2012-11-14 09:47:00 +08:00
|
|
|
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()),
|
2017-02-28 06:45:06 +08:00
|
|
|
Encoding & ~DW_EH_PE_indirect, Streamer);
|
2012-11-14 09:47:00 +08:00
|
|
|
}
|
|
|
|
|
2016-09-16 15:33:15 +08:00
|
|
|
return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
|
|
|
|
MMI, Streamer);
|
2012-11-14 09:47:00 +08:00
|
|
|
}
|
|
|
|
|
2017-10-21 05:28:38 +08:00
|
|
|
static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) {
|
2018-05-17 04:34:00 +08:00
|
|
|
// N.B.: The defaults used in here are not the same ones used in MC.
|
2011-05-24 11:10:31 +08:00
|
|
|
// 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
|
2017-04-15 01:48:40 +08:00
|
|
|
|
2017-04-15 08:09:57 +08:00
|
|
|
if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
|
|
|
|
/*AddSegmentInfo=*/false))
|
2016-01-15 02:09:45 +08:00
|
|
|
return SectionKind::getMetadata();
|
|
|
|
|
2010-02-16 06:37:53 +08:00
|
|
|
if (Name.empty() || Name[0] != '.') return K;
|
|
|
|
|
2018-05-18 10:39:57 +08:00
|
|
|
// Default implementation based on some magic section names.
|
2010-02-16 06:37:53 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-03-18 06:17:24 +08:00
|
|
|
static const MCSymbolELF *getAssociatedSymbol(const GlobalObject *GO,
|
|
|
|
const TargetMachine &TM) {
|
|
|
|
MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
|
|
|
|
if (!MD)
|
|
|
|
return nullptr;
|
|
|
|
|
2017-05-09 07:46:20 +08:00
|
|
|
const MDOperand &Op = MD->getOperand(0);
|
|
|
|
if (!Op.get())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
auto *VM = dyn_cast<ValueAsMetadata>(Op);
|
2017-03-18 06:17:24 +08:00
|
|
|
if (!VM)
|
|
|
|
report_fatal_error("MD_associated operand is not ValueAsMetadata");
|
|
|
|
|
|
|
|
GlobalObject *OtherGO = dyn_cast<GlobalObject>(VM->getValue());
|
|
|
|
return OtherGO ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGO)) : nullptr;
|
|
|
|
}
|
|
|
|
|
[MC][ELF] fix newly added test
Summary:
Reland of
- r344197 "[MC][ELF] compute entity size for explicit sections"
- r344206 "[MC][ELF] Fix section_mergeable_size.ll"
after being reverted in r344278 due to build breakages from not
specifying a target triple.
Move test from test/CodeGen/Generic/ to test/MC/ELF/.
Add explicit target triple so we don't try to run
this test on non ELF targets.
Reported: https://reviews.llvm.org/D53056#1261707
Reviewers: fhahn, rnk, espindola, NoQ
Reviewed By: fhahn, rnk
Subscribers: NoQ, MaskRay, rengolin, emaste, arichardson, llvm-commits, pirama, srhines
Differential Revision: https://reviews.llvm.org/D53146
llvm-svn: 344360
2018-10-13 00:35:44 +08:00
|
|
|
static unsigned getEntrySizeForKind(SectionKind Kind) {
|
|
|
|
if (Kind.isMergeable1ByteCString())
|
|
|
|
return 1;
|
|
|
|
else if (Kind.isMergeable2ByteCString())
|
|
|
|
return 2;
|
|
|
|
else if (Kind.isMergeable4ByteCString())
|
|
|
|
return 4;
|
|
|
|
else if (Kind.isMergeableConst4())
|
|
|
|
return 4;
|
|
|
|
else if (Kind.isMergeableConst8())
|
|
|
|
return 8;
|
|
|
|
else if (Kind.isMergeableConst16())
|
|
|
|
return 16;
|
|
|
|
else if (Kind.isMergeableConst32())
|
|
|
|
return 32;
|
|
|
|
else {
|
|
|
|
// We shouldn't have mergeable C strings or mergeable constants that we
|
|
|
|
// didn't handle above.
|
|
|
|
assert(!Kind.isMergeableCString() && "unknown string width");
|
|
|
|
assert(!Kind.isMergeableConst() && "unknown data width");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2017-06-05 18:09:13 +08:00
|
|
|
// Check if '#pragma clang section' name is applicable.
|
|
|
|
// Note that pragma directive overrides -ffunction-section, -fdata-section
|
|
|
|
// and so section name is exactly as user specified and not uniqued.
|
|
|
|
const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
|
|
|
|
if (GV && GV->hasImplicitSection()) {
|
|
|
|
auto Attrs = GV->getAttributes();
|
|
|
|
if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
|
|
|
|
SectionName = Attrs.getAttribute("bss-section").getValueAsString();
|
|
|
|
} else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
|
|
|
|
SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
|
|
|
|
} else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
|
|
|
|
SectionName = Attrs.getAttribute("data-section").getValueAsString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
const Function *F = dyn_cast<Function>(GO);
|
|
|
|
if (F && F->hasFnAttribute("implicit-section-name")) {
|
|
|
|
SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
2017-03-18 06:17:24 +08:00
|
|
|
|
|
|
|
// A section can have at most one associated section. Put each global with
|
|
|
|
// MD_associated in a unique section.
|
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
|
|
|
const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
|
|
|
|
if (AssociatedSymbol) {
|
|
|
|
UniqueID = NextUniqueID++;
|
|
|
|
Flags |= ELF::SHF_LINK_ORDER;
|
|
|
|
}
|
|
|
|
|
|
|
|
MCSectionELF *Section = getContext().getELFSection(
|
|
|
|
SectionName, getELFSectionType(SectionName, Kind), Flags,
|
[MC][ELF] fix newly added test
Summary:
Reland of
- r344197 "[MC][ELF] compute entity size for explicit sections"
- r344206 "[MC][ELF] Fix section_mergeable_size.ll"
after being reverted in r344278 due to build breakages from not
specifying a target triple.
Move test from test/CodeGen/Generic/ to test/MC/ELF/.
Add explicit target triple so we don't try to run
this test on non ELF targets.
Reported: https://reviews.llvm.org/D53056#1261707
Reviewers: fhahn, rnk, espindola, NoQ
Reviewed By: fhahn, rnk
Subscribers: NoQ, MaskRay, rengolin, emaste, arichardson, llvm-commits, pirama, srhines
Differential Revision: https://reviews.llvm.org/D53146
llvm-svn: 344360
2018-10-13 00:35:44 +08:00
|
|
|
getEntrySizeForKind(Kind), Group, UniqueID, AssociatedSymbol);
|
2017-03-18 06:17:24 +08:00
|
|
|
// Make sure that we did not get some other section with incompatible sh_link.
|
|
|
|
// This should not be possible due to UniqueID code above.
|
2018-06-21 15:15:14 +08:00
|
|
|
assert(Section->getAssociatedSymbol() == AssociatedSymbol &&
|
|
|
|
"Associated symbol mismatch between sections");
|
2017-03-18 06:17:24 +08:00
|
|
|
return Section;
|
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
|
|
|
}
|
|
|
|
|
2017-03-18 06:17:24 +08:00
|
|
|
static MCSectionELF *selectELFSectionForGlobal(
|
|
|
|
MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
|
|
|
|
const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
|
|
|
|
unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
|
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
|
|
|
|
2018-08-01 09:29:30 +08:00
|
|
|
// Get the section entry size based on the kind.
|
|
|
|
unsigned EntrySize = getEntrySizeForKind(Kind);
|
|
|
|
|
2015-02-25 08:52:15 +08:00
|
|
|
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
|
|
|
|
2016-05-03 07:22:18 +08:00
|
|
|
unsigned UniqueID = MCContext::GenericSectionID;
|
2018-08-01 09:03:34 +08:00
|
|
|
if (EmitUniqueSection) {
|
|
|
|
if (TM.getUniqueSectionNames()) {
|
|
|
|
Name.push_back('.');
|
|
|
|
TM.getNameWithPrefix(Name, GO, Mang, true /*MayAlwaysUsePrivate*/);
|
|
|
|
} else {
|
|
|
|
UniqueID = *NextUniqueID;
|
|
|
|
(*NextUniqueID)++;
|
|
|
|
}
|
2015-04-05 02:02:01 +08:00
|
|
|
}
|
2018-08-01 09:03:34 +08:00
|
|
|
// Use 0 as the unique ID for execute-only text.
|
2016-12-15 15:59:08 +08:00
|
|
|
if (Kind.isExecuteOnly())
|
|
|
|
UniqueID = 0;
|
2015-02-27 07:55:11 +08:00
|
|
|
return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
|
2017-03-18 06:17:24 +08:00
|
|
|
EntrySize, Group, UniqueID, AssociatedSymbol);
|
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
|
|
|
|
2017-03-18 06:17:24 +08:00
|
|
|
const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
|
|
|
|
if (AssociatedSymbol) {
|
|
|
|
EmitUniqueSection = true;
|
|
|
|
Flags |= ELF::SHF_LINK_ORDER;
|
|
|
|
}
|
|
|
|
|
|
|
|
MCSectionELF *Section = selectELFSectionForGlobal(
|
|
|
|
getContext(), GO, Kind, getMangler(), TM, EmitUniqueSection, Flags,
|
|
|
|
&NextUniqueID, AssociatedSymbol);
|
|
|
|
assert(Section->getAssociatedSymbol() == AssociatedSymbol);
|
|
|
|
return Section;
|
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(),
|
2017-03-18 06:17:24 +08:00
|
|
|
getMangler(), TM, EmitUniqueSection,
|
|
|
|
ELF::SHF_ALLOC, &NextUniqueID,
|
|
|
|
/* AssociatedSymbol */ nullptr);
|
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";
|
2017-11-28 16:07:18 +08:00
|
|
|
if (Priority != 65535)
|
|
|
|
raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
|
2014-09-05 07:03:58 +08:00
|
|
|
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());
|
|
|
|
}
|
[MC] Move EH DWARF encodings from MC to CodeGen, NFC
Summary:
The TType encoding, LSDA encoding, and personality encoding are all
passed explicitly by CodeGen to the assembler through .cfi_* directives,
so only the AsmPrinter needs to know about them.
The FDE CFI encoding however, controls the encoding of the label
implicitly created by the .cfi_startproc directive. That directive seems
to be special in that it doesn't take an encoding, so the assembler just
has to know how to encode one DSO-local label reference from .eh_frame
to .text.
As a result, it looks like MC will continue to have to know when the
large code model is in use. Perhaps we could invent a '.cfi_startproc
[large]' flag so that this knowledge doesn't need to pollute the
assembler.
Reviewers: davide, lliu0, JDevlieghere
Subscribers: hiraditya, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D50533
llvm-svn: 339397
2018-08-10 06:24:04 +08:00
|
|
|
|
|
|
|
PersonalityEncoding =
|
|
|
|
dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
|
|
|
LSDAEncoding = dwarf::DW_EH_PE_pcrel;
|
|
|
|
TTypeEncoding =
|
|
|
|
dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
|
2016-08-29 20:33:42 +08:00
|
|
|
}
|
|
|
|
|
2018-04-21 03:07:57 +08:00
|
|
|
void TargetLoweringObjectFileMachO::emitModuleMetadata(MCStreamer &Streamer,
|
|
|
|
Module &M) const {
|
2013-01-19 03:37:00 +08:00
|
|
|
// Emit the linker options if present.
|
2017-06-13 04:10:48 +08:00
|
|
|
if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
|
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
|
|
|
}
|
|
|
|
|
2017-06-06 05:26:39 +08:00
|
|
|
unsigned VersionVal = 0;
|
|
|
|
unsigned ImageInfoFlags = 0;
|
|
|
|
StringRef SectionVal;
|
2017-06-13 04:10:48 +08:00
|
|
|
|
|
|
|
GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
|
2017-06-06 05:26:39 +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.
|
2017-06-06 05:26:39 +08:00
|
|
|
if (SectionVal.empty())
|
|
|
|
return;
|
2012-02-16 06:36:15 +08:00
|
|
|
|
|
|
|
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;
|
2018-04-11 04:16:35 +08:00
|
|
|
if (Kind.isReadOnlyWithRel())
|
|
|
|
return ConstDataCoalSection;
|
2013-08-09 05:04:16 +08:00
|
|
|
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()),
|
2017-02-28 06:45:06 +08:00
|
|
|
Encoding & ~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
|
|
|
|
//
|
2018-12-14 01:23:30 +08:00
|
|
|
// The indirect symbol table (and sections of non_lazy_symbol_pointers type)
|
|
|
|
// may point to both local (same translation unit) and global (other
|
|
|
|
// translation units) symbols. Example:
|
|
|
|
//
|
|
|
|
// .section __DATA,__pointers,non_lazy_symbol_pointers
|
|
|
|
// L1:
|
|
|
|
// .indirect_symbol _myGlobal
|
|
|
|
// .long 0
|
|
|
|
// L2:
|
|
|
|
// .indirect_symbol _myLocal
|
|
|
|
// .long _myLocal
|
|
|
|
//
|
|
|
|
// If the symbol is local, instead of the symbol's index, the assembler
|
|
|
|
// places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
|
|
|
|
// Then the linker will notice the constant in the table and will look at the
|
|
|
|
// content of the symbol.
|
2015-03-06 21:49:05 +08:00
|
|
|
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);
|
2018-12-14 01:23:30 +08:00
|
|
|
if (!StubSym.getPointer()) {
|
|
|
|
bool IsIndirectLocal = Sym->isDefined() && !Sym->isExternal();
|
|
|
|
// With the assumption that IsIndirectLocal == GV->hasLocalLinkage().
|
|
|
|
StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
|
|
|
|
!IsIndirectLocal);
|
|
|
|
}
|
2015-03-06 21:49:05 +08:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
[mingw] Fix GCC ABI compatibility for comdat things
Summary:
GCC and the binutils COFF linker do comdats differently from MSVC.
If we want to be ABI compatible, we have to do what they do, which is to
emit unique section names like ".text$_Z3foov" instead of short section
names like ".text". Otherwise, the binutils linker gets confused and
reports multiple definition errors when two object files from GCC and
Clang containing the same inline function are linked together.
The best description of the issue is probably at
https://github.com/Alexpux/MINGW-packages/issues/1677, we don't seem to
have a good one in our tracker.
I fixed up the .pdata and .xdata sections needed everywhere other than
32-bit x86. GCC doesn't use associative comdats for those, it appears to
rely on the section name.
Reviewers: smeenai, compnerd, mstorsjo, martell, mati865
Subscribers: llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D48402
llvm-svn: 335286
2018-06-22 04:27:38 +08:00
|
|
|
static StringRef 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()) {
|
[mingw] Fix GCC ABI compatibility for comdat things
Summary:
GCC and the binutils COFF linker do comdats differently from MSVC.
If we want to be ABI compatible, we have to do what they do, which is to
emit unique section names like ".text$_Z3foov" instead of short section
names like ".text". Otherwise, the binutils linker gets confused and
reports multiple definition errors when two object files from GCC and
Clang containing the same inline function are linked together.
The best description of the issue is probably at
https://github.com/Alexpux/MINGW-packages/issues/1677, we don't seem to
have a good one in our tracker.
I fixed up the .pdata and .xdata sections needed everywhere other than
32-bit x86. GCC doesn't use associative comdats for those, it appears to
rely on the section name.
Reviewers: smeenai, compnerd, mstorsjo, martell, mati865
Subscribers: llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D48402
llvm-svn: 335286
2018-06-22 04:27:38 +08:00
|
|
|
SmallString<256> 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();
|
2018-06-22 07:06:33 +08:00
|
|
|
|
2018-11-22 06:01:10 +08:00
|
|
|
// Append "$symbol" to the section name *before* IR-level mangling is
|
|
|
|
// applied when targetting mingw. This is what GCC does, and the ld.bfd
|
2018-06-22 07:06:33 +08:00
|
|
|
// COFF linker will not properly handle comdats otherwise.
|
|
|
|
if (getTargetTriple().isWindowsGNUEnvironment())
|
2018-11-22 06:01:10 +08:00
|
|
|
raw_svector_ostream(Name) << '$' << ComdatGV->getName();
|
2018-06-22 07:06:33 +08:00
|
|
|
|
2014-06-28 02:19:56 +08:00
|
|
|
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();
|
[mingw] Fix GCC ABI compatibility for comdat things
Summary:
GCC and the binutils COFF linker do comdats differently from MSVC.
If we want to be ABI compatible, we have to do what they do, which is to
emit unique section names like ".text$_Z3foov" instead of short section
names like ".text". Otherwise, the binutils linker gets confused and
reports multiple definition errors when two object files from GCC and
Clang containing the same inline function are linked together.
The best description of the issue is probably at
https://github.com/Alexpux/MINGW-packages/issues/1677, we don't seem to
have a good one in our tracker.
I fixed up the .pdata and .xdata sections needed everywhere other than
32-bit x86. GCC doesn't use associative comdats for those, it appears to
rely on the section name.
Reviewers: smeenai, compnerd, mstorsjo, martell, mati865
Subscribers: llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D48402
llvm-svn: 335286
2018-06-22 04:27:38 +08:00
|
|
|
StringRef SecName = 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
|
|
|
|
[mingw] Fix GCC ABI compatibility for comdat things
Summary:
GCC and the binutils COFF linker do comdats differently from MSVC.
If we want to be ABI compatible, we have to do what they do, which is to
emit unique section names like ".text$_Z3foov" instead of short section
names like ".text". Otherwise, the binutils linker gets confused and
reports multiple definition errors when two object files from GCC and
Clang containing the same inline function are linked together.
The best description of the issue is probably at
https://github.com/Alexpux/MINGW-packages/issues/1677, we don't seem to
have a good one in our tracker.
I fixed up the .pdata and .xdata sections needed everywhere other than
32-bit x86. GCC doesn't use associative comdats for those, it appears to
rely on the section name.
Reviewers: smeenai, compnerd, mstorsjo, martell, mati865
Subscribers: llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D48402
llvm-svn: 335286
2018-06-22 04:27:38 +08:00
|
|
|
return getContext().getCOFFSection(
|
|
|
|
SecName, Characteristics, Kind, COMDATSymName,
|
|
|
|
COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
|
2015-03-12 03:58:37 +08:00
|
|
|
}
|
|
|
|
|
2018-04-21 03:07:57 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::emitModuleMetadata(MCStreamer &Streamer,
|
|
|
|
Module &M) const {
|
2017-06-13 04:10:48 +08:00
|
|
|
if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
|
2016-05-01 02:15:34 +08:00
|
|
|
// 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
|
|
|
}
|
|
|
|
}
|
2017-06-06 05:26:39 +08:00
|
|
|
|
|
|
|
unsigned Version = 0;
|
|
|
|
unsigned Flags = 0;
|
|
|
|
StringRef Section;
|
|
|
|
|
2017-06-13 04:10:48 +08:00
|
|
|
GetObjCImageInfo(M, Version, Flags, Section);
|
2017-06-06 05:26:39 +08:00
|
|
|
if (Section.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
auto &C = getContext();
|
|
|
|
auto *S = C.getCOFFSection(
|
|
|
|
Section, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ,
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
Streamer.SwitchSection(S);
|
|
|
|
Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
|
|
|
|
Streamer.EmitIntValue(Version, 4);
|
|
|
|
Streamer.EmitIntValue(Flags, 4);
|
|
|
|
Streamer.AddBlankLine();
|
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());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-28 16:07:18 +08:00
|
|
|
static MCSectionCOFF *getCOFFStaticStructorSection(MCContext &Ctx,
|
|
|
|
const Triple &T, bool IsCtor,
|
|
|
|
unsigned Priority,
|
|
|
|
const MCSymbol *KeySym,
|
|
|
|
MCSectionCOFF *Default) {
|
2018-09-08 07:07:55 +08:00
|
|
|
if (T.isKnownWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
|
|
|
|
// If the priority is the default, use .CRT$XCU, possibly associative.
|
|
|
|
if (Priority == 65535)
|
|
|
|
return Ctx.getAssociativeCOFFSection(Default, KeySym, 0);
|
|
|
|
|
|
|
|
// Otherwise, we need to compute a new section name. Low priorities should
|
|
|
|
// run earlier. The linker will sort sections ASCII-betically, and we need a
|
|
|
|
// string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
|
|
|
|
// make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
|
|
|
|
// low priorities need to sort before 'L', since the CRT uses that
|
|
|
|
// internally, so we use ".CRT$XCA00001" for them.
|
|
|
|
SmallString<24> Name;
|
|
|
|
raw_svector_ostream OS(Name);
|
|
|
|
OS << ".CRT$XC" << (Priority < 200 ? 'A' : 'T') << format("%05u", Priority);
|
|
|
|
MCSectionCOFF *Sec = Ctx.getCOFFSection(
|
|
|
|
Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ,
|
|
|
|
SectionKind::getReadOnly());
|
|
|
|
return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
|
|
|
|
}
|
2017-11-28 16:07:18 +08:00
|
|
|
|
|
|
|
std::string Name = IsCtor ? ".ctors" : ".dtors";
|
|
|
|
if (Priority != 65535)
|
|
|
|
raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
|
|
|
|
|
|
|
|
return Ctx.getAssociativeCOFFSection(
|
|
|
|
Ctx.getCOFFSection(Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
COFF::IMAGE_SCN_MEM_WRITE,
|
|
|
|
SectionKind::getData()),
|
|
|
|
KeySym, 0);
|
|
|
|
}
|
|
|
|
|
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 {
|
2017-11-28 16:07:18 +08:00
|
|
|
return getCOFFStaticStructorSection(getContext(), getTargetTriple(), true,
|
|
|
|
Priority, KeySym,
|
|
|
|
cast<MCSectionCOFF>(StaticCtorSection));
|
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 {
|
2017-11-28 16:07:18 +08:00
|
|
|
return getCOFFStaticStructorSection(getContext(), getTargetTriple(), false,
|
|
|
|
Priority, KeySym,
|
|
|
|
cast<MCSectionCOFF>(StaticDtorSection));
|
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
|
|
|
|
2018-01-20 08:28:02 +08:00
|
|
|
void TargetLoweringObjectFileCOFF::emitLinkerFlagsForUsed(
|
|
|
|
raw_ostream &OS, const GlobalValue *GV) const {
|
|
|
|
emitLinkerFlagsForUsedCOFF(OS, GV, getTargetTriple(), getMangler());
|
|
|
|
}
|
|
|
|
|
2018-06-13 02:56:05 +08:00
|
|
|
const MCExpr *TargetLoweringObjectFileCOFF::lowerRelativeReference(
|
|
|
|
const GlobalValue *LHS, const GlobalValue *RHS,
|
|
|
|
const TargetMachine &TM) const {
|
|
|
|
const Triple &T = TM.getTargetTriple();
|
|
|
|
if (!T.isKnownWindowsMSVCEnvironment() &&
|
|
|
|
!T.isWindowsItaniumEnvironment() &&
|
|
|
|
!T.isWindowsCoreCLREnvironment())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Our symbols should exist in address space zero, cowardly no-op if
|
|
|
|
// otherwise.
|
|
|
|
if (LHS->getType()->getPointerAddressSpace() != 0 ||
|
|
|
|
RHS->getType()->getPointerAddressSpace() != 0)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Both ptrtoint instructions must wrap global objects:
|
|
|
|
// - Only global variables are eligible for image relative relocations.
|
|
|
|
// - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
|
|
|
|
// We expect __ImageBase to be a global variable without a section, externally
|
|
|
|
// defined.
|
|
|
|
//
|
|
|
|
// It should look something like this: @__ImageBase = external constant i8
|
|
|
|
if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) ||
|
|
|
|
LHS->isThreadLocal() || RHS->isThreadLocal() ||
|
|
|
|
RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
|
|
|
|
cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
return MCSymbolRefExpr::create(TM.getSymbol(LHS),
|
|
|
|
MCSymbolRefExpr::VK_COFF_IMGREL32,
|
|
|
|
getContext());
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::string APIntToHexString(const APInt &AI) {
|
|
|
|
unsigned Width = (AI.getBitWidth() / 8) * 2;
|
|
|
|
std::string HexString = utohexstr(AI.getLimitedValue(), /*LowerCase=*/true);
|
|
|
|
unsigned Size = HexString.size();
|
|
|
|
assert(Width >= Size && "hex string is too large!");
|
|
|
|
HexString.insert(HexString.begin(), Width - Size, '0');
|
|
|
|
|
|
|
|
return HexString;
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::string scalarConstantToHexString(const Constant *C) {
|
|
|
|
Type *Ty = C->getType();
|
|
|
|
if (isa<UndefValue>(C)) {
|
|
|
|
return APIntToHexString(APInt::getNullValue(Ty->getPrimitiveSizeInBits()));
|
|
|
|
} else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
|
|
|
|
return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
|
|
|
|
} else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
|
|
|
|
return APIntToHexString(CI->getValue());
|
|
|
|
} else {
|
|
|
|
unsigned NumElements;
|
|
|
|
if (isa<VectorType>(Ty))
|
|
|
|
NumElements = Ty->getVectorNumElements();
|
|
|
|
else
|
|
|
|
NumElements = Ty->getArrayNumElements();
|
|
|
|
std::string HexString;
|
|
|
|
for (int I = NumElements - 1, E = -1; I != E; --I)
|
|
|
|
HexString += scalarConstantToHexString(C->getAggregateElement(I));
|
|
|
|
return HexString;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileCOFF::getSectionForConstant(
|
|
|
|
const DataLayout &DL, SectionKind Kind, const Constant *C,
|
|
|
|
unsigned &Align) const {
|
2018-07-26 18:48:20 +08:00
|
|
|
if (Kind.isMergeableConst() && C &&
|
|
|
|
getContext().getAsmInfo()->hasCOFFComdatConstants()) {
|
|
|
|
// This creates comdat sections with the given symbol name, but unless
|
|
|
|
// AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
|
|
|
|
// will be created with a null storage class, which makes GNU binutils
|
|
|
|
// error out.
|
2018-06-13 02:56:05 +08:00
|
|
|
const unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
|
|
COFF::IMAGE_SCN_MEM_READ |
|
|
|
|
COFF::IMAGE_SCN_LNK_COMDAT;
|
|
|
|
std::string COMDATSymName;
|
|
|
|
if (Kind.isMergeableConst4()) {
|
|
|
|
if (Align <= 4) {
|
|
|
|
COMDATSymName = "__real@" + scalarConstantToHexString(C);
|
|
|
|
Align = 4;
|
|
|
|
}
|
|
|
|
} else if (Kind.isMergeableConst8()) {
|
|
|
|
if (Align <= 8) {
|
|
|
|
COMDATSymName = "__real@" + scalarConstantToHexString(C);
|
|
|
|
Align = 8;
|
|
|
|
}
|
|
|
|
} else if (Kind.isMergeableConst16()) {
|
|
|
|
// FIXME: These may not be appropriate for non-x86 architectures.
|
|
|
|
if (Align <= 16) {
|
|
|
|
COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
|
|
|
|
Align = 16;
|
|
|
|
}
|
|
|
|
} else if (Kind.isMergeableConst32()) {
|
|
|
|
if (Align <= 32) {
|
|
|
|
COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
|
|
|
|
Align = 32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!COMDATSymName.empty())
|
|
|
|
return getContext().getCOFFSection(".rdata", Characteristics, Kind,
|
|
|
|
COMDATSymName,
|
|
|
|
COFF::IMAGE_COMDAT_SELECT_ANY);
|
|
|
|
}
|
|
|
|
|
|
|
|
return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C, Align);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-02-22 09:23:18 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Wasm
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2018-01-10 07:43:14 +08:00
|
|
|
static const Comdat *getWasmComdat(const GlobalValue *GV) {
|
2017-02-25 07:18:00 +08:00
|
|
|
const Comdat *C = GV->getComdat();
|
|
|
|
if (!C)
|
2018-01-10 07:43:14 +08:00
|
|
|
return nullptr;
|
2017-02-25 07:18:00 +08:00
|
|
|
|
2018-01-10 07:43:14 +08:00
|
|
|
if (C->getSelectionKind() != Comdat::Any)
|
|
|
|
report_fatal_error("WebAssembly COMDATs only support "
|
|
|
|
"SelectionKind::Any, '" + C->getName() + "' cannot be "
|
|
|
|
"lowered.");
|
|
|
|
|
|
|
|
return C;
|
2017-02-25 07:18:00 +08:00
|
|
|
}
|
|
|
|
|
2017-12-07 10:55:51 +08:00
|
|
|
static SectionKind getWasmKindForNamedSection(StringRef Name, SectionKind K) {
|
|
|
|
// If we're told we have function data, then use that.
|
|
|
|
if (K.isText())
|
|
|
|
return SectionKind::getText();
|
|
|
|
|
|
|
|
// Otherwise, ignore whatever section type the generic impl detected and use
|
|
|
|
// a plain data section.
|
|
|
|
return SectionKind::getData();
|
|
|
|
}
|
|
|
|
|
2017-02-22 09:23:18 +08:00
|
|
|
MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
|
|
|
|
const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
|
2018-06-15 02:48:19 +08:00
|
|
|
// We don't support explict section names for functions in the wasm object
|
|
|
|
// format. Each function has to be in its own unique section.
|
|
|
|
if (isa<Function>(GO)) {
|
|
|
|
return SelectSectionForGlobal(GO, Kind, TM);
|
|
|
|
}
|
|
|
|
|
2017-09-16 04:54:59 +08:00
|
|
|
StringRef Name = GO->getSection();
|
2018-01-10 07:43:14 +08:00
|
|
|
|
2017-12-07 10:55:51 +08:00
|
|
|
Kind = getWasmKindForNamedSection(Name, Kind);
|
2018-01-10 07:43:14 +08:00
|
|
|
|
|
|
|
StringRef Group = "";
|
|
|
|
if (const Comdat *C = getWasmComdat(GO)) {
|
|
|
|
Group = C->getName();
|
|
|
|
}
|
|
|
|
|
|
|
|
return getContext().getWasmSection(Name, Kind, Group,
|
|
|
|
MCContext::GenericSectionID);
|
2017-02-22 09:23:18 +08:00
|
|
|
}
|
|
|
|
|
2017-09-13 02:31:24 +08:00
|
|
|
static MCSectionWasm *selectWasmSectionForGlobal(
|
|
|
|
MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
|
|
|
|
const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
|
2017-02-25 07:18:00 +08:00
|
|
|
StringRef Group = "";
|
2018-01-10 07:43:14 +08:00
|
|
|
if (const Comdat *C = getWasmComdat(GO)) {
|
|
|
|
Group = C->getName();
|
|
|
|
}
|
2017-02-25 07:18:00 +08:00
|
|
|
|
|
|
|
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)++;
|
|
|
|
}
|
2017-10-21 05:28:38 +08:00
|
|
|
return Ctx.getWasmSection(Name, Kind, Group, UniqueID);
|
2017-02-25 07:18:00 +08:00
|
|
|
}
|
|
|
|
|
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,
|
2017-09-13 02:31:24 +08:00
|
|
|
EmitUniqueSection, &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());
|
|
|
|
}
|
|
|
|
|
2017-10-03 19:20:28 +08:00
|
|
|
void TargetLoweringObjectFileWasm::InitializeWasm() {
|
|
|
|
StaticCtorSection =
|
2017-10-21 05:28:38 +08:00
|
|
|
getContext().getWasmSection(".init_array", SectionKind::getData());
|
Reland "[WebAssembly] LSDA info generation"
Summary:
This adds support for LSDA (exception table) generation for wasm EH.
Wasm EH mostly follows the structure of Itanium-style exception tables,
with one exception: a call site table entry in wasm EH corresponds to
not a call site but a landing pad.
In wasm EH, the VM is responsible for stack unwinding. After an
exception occurs and the stack is unwound, the control flow is
transferred to wasm 'catch' instruction by the VM, after which the
personality function is called from the compiler-generated code. (Refer
to WasmEHPrepare pass for more information on this part.)
This patch:
- Changes wasm.landingpad.index intrinsic to take a token argument, to
make this 1:1 match with a catchpad instruction
- Stores landingpad index info and catch type info MachineFunction in
before instruction selection
- Lowers wasm.lsda intrinsic to an MCSymbol pointing to the start of an
exception table
- Adds WasmException class with overridden methods for table generation
- Adds support for LSDA section in Wasm object writer
Reviewers: dschuff, sbc100, rnk
Subscribers: mgorny, jgravelle-google, sunfish, llvm-commits
Differential Revision: https://reviews.llvm.org/D52748
llvm-svn: 345345
2018-10-26 07:55:10 +08:00
|
|
|
|
|
|
|
// We don't use PersonalityEncoding and LSDAEncoding because we don't emit
|
|
|
|
// .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
|
|
|
|
TTypeEncoding = dwarf::DW_EH_PE_absptr;
|
2017-12-15 08:17:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileWasm::getStaticCtorSection(
|
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
|
|
|
return Priority == UINT16_MAX ?
|
|
|
|
StaticCtorSection :
|
|
|
|
getContext().getWasmSection(".init_array." + utostr(Priority),
|
|
|
|
SectionKind::getData());
|
|
|
|
}
|
|
|
|
|
|
|
|
MCSection *TargetLoweringObjectFileWasm::getStaticDtorSection(
|
|
|
|
unsigned Priority, const MCSymbol *KeySym) const {
|
|
|
|
llvm_unreachable("@llvm.global_dtors should have been lowered already");
|
|
|
|
return nullptr;
|
2017-02-22 09:23:18 +08:00
|
|
|
}
|