# 22859423 llvm CodeGen on Intel emits a bogus .ctors section
# 22902339 memory corruption caused by undefined behavior in LLVM IR Module
--- include/llvm/CodeGen/CommandFlags.h 2015-12-16 14:58:30.000000000 -0500
+++ include/llvm/CodeGen/CommandFlags.h 2016-05-08 23:19:20.514430315 -0400
@@ -38,7 +38,7 @@
MCPU("mcpu",
cl::desc("Target a specific cpu type (-mcpu=help for details)"),
cl::value_desc("cpu-name"),
- cl::init(""));
+ cl::init(std::string("")));
cl::list<std::string>
MAttrs("mattr",
@@ -190,7 +190,7 @@
cl::opt<std::string>
TrapFuncName("trap-func", cl::Hidden,
cl::desc("Emit a call to trap function rather than a trap instruction"),
- cl::init(""));
+ cl::init(std::string("")));
cl::opt<bool>
EnablePIE("enable-pie",
@@ -202,35 +202,42 @@
cl::desc("Use .ctors instead of .init_array."),
cl::init(false));
-cl::opt<std::string> StopAfter("stop-after",
- cl::desc("Stop compilation after a specific pass"),
- cl::value_desc("pass-name"),
- cl::init(""));
-cl::opt<std::string> StartAfter("start-after",
- cl::desc("Resume compilation after a specific pass"),
- cl::value_desc("pass-name"),
- cl::init(""));
+cl::opt<std::string>
+StopAfter("stop-after",
+ cl::desc("Stop compilation after a specific pass"),
+ cl::value_desc("pass-name"),
+ cl::init(std::string("")));
+
+cl::opt<std::string>
+StartAfter("start-after",
+ cl::desc("Resume compilation after a specific pass"),
+ cl::value_desc("pass-name"),
+ cl::init(std::string("")));
cl::opt<std::string>
- RunPass("run-pass", cl::desc("Run compiler only for one specific pass"),
- cl::value_desc("pass-name"), cl::init(""));
+RunPass("run-pass", cl::desc("Run compiler only for one specific pass"),
+ cl::value_desc("pass-name"),
+ cl::init(std::string("")));
-cl::opt<bool> DataSections("data-sections",
- cl::desc("Emit data into separate sections"),
- cl::init(false));
+cl::opt<bool>
+DataSections("data-sections",
+ cl::desc("Emit data into separate sections"),
+ cl::init(false));
cl::opt<bool>
FunctionSections("function-sections",
cl::desc("Emit functions into separate sections"),
cl::init(false));
-cl::opt<bool> EmulatedTLS("emulated-tls",
- cl::desc("Use emulated TLS model"),
- cl::init(false));
-
-cl::opt<bool> UniqueSectionNames("unique-section-names",
- cl::desc("Give unique names to every section"),
- cl::init(true));
+cl::opt<bool>
+EmulatedTLS("emulated-tls",
+ cl::desc("Use emulated TLS model"),
+ cl::init(false));
+
+cl::opt<bool>
+UniqueSectionNames("unique-section-names",
+ cl::desc("Give unique names to every section"),
+ cl::init(true));
cl::opt<llvm::JumpTable::JumpTableType>
JTableType("jump-table-type",
@@ -269,7 +276,9 @@
// Common utility function tightly tied to the options listed here. Initializes
// a TargetOptions object with CodeGen flags and returns it.
-static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
+static inline
+__attribute__((used))
+TargetOptions InitTargetOptionsFromCodeGenFlags() {
TargetOptions Options;
Options.LessPreciseFPMADOption = EnableFPMAD;
Options.AllowFPOpFusion = FuseFPOps;
###
--- include/llvm/CodeGen/LiveInterval.h 2016-02-17 10:41:44.000000000 -0800
+++ include/llvm/CodeGen/LiveInterval.h 2016-07-08 16:53:26.422739200 -0700
@@ -43,7 +43,7 @@
/// This class holds information about a machine level values, including
/// definition and use points.
///
- class VNInfo {
+ class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) VNInfo {
public:
typedef BumpPtrAllocator Allocator;
@@ -55,13 +55,11 @@
/// VNInfo constructor.
VNInfo(unsigned i, SlotIndex d)
- : id(i), def(d)
- { }
+ : id(i), def(d) { }
/// VNInfo construtor, copies values from orig, except for the value number.
VNInfo(unsigned i, const VNInfo &orig)
- : id(i), def(orig.def)
- { }
+ : id(i), def(orig.def) { }
/// Copy from the parameter into this VNInfo.
void copyFrom(VNInfo &src) {
@@ -85,16 +83,15 @@
/// of live ranges, and it should be used as the primary interface for
/// examining live ranges around instructions.
class LiveQueryResult {
+ private:
VNInfo *const EarlyVal;
VNInfo *const LateVal;
const SlotIndex EndPoint;
const bool Kill;
public:
- LiveQueryResult(VNInfo *EarlyVal, VNInfo *LateVal, SlotIndex EndPoint,
- bool Kill)
- : EarlyVal(EarlyVal), LateVal(LateVal), EndPoint(EndPoint), Kill(Kill)
- {}
+ LiveQueryResult(VNInfo *EV, VNInfo *LV, SlotIndex EP, bool K)
+ : EarlyVal(EV), LateVal(LV), EndPoint(EP), Kill(K) { }
/// Return the value that is live-in to the instruction. This is the value
/// that will be read by the instruction's use operands. Return NULL if no
@@ -157,12 +154,13 @@
/// This represents a simple continuous liveness interval for a value.
/// The start point is inclusive, the end point exclusive. These intervals
/// are rendered as [start,end).
- struct Segment {
+ class Segment {
+ public:
SlotIndex start; // Start point of the interval (inclusive)
SlotIndex end; // End point of the interval (exclusive)
VNInfo *valno; // identifier for the value contained in this segment.
- Segment() : valno(nullptr) {}
+ Segment() : start(), end(), valno(nullptr) { }
Segment(SlotIndex S, SlotIndex E, VNInfo *V)
: start(S), end(E), valno(V) {
@@ -190,8 +188,9 @@
void dump() const;
};
- typedef SmallVector<Segment,4> Segments;
- typedef SmallVector<VNInfo*,4> VNInfoList;
+ typedef std::vector<Segment> Segments;
+ typedef std::vector<VNInfo*> VNInfoList;
+ typedef std::set<Segment> SegmentSet;
Segments segments; // the liveness segments
VNInfoList valnos; // value#'s
@@ -199,7 +198,6 @@
// The segment set is used temporarily to accelerate initial computation
// of live ranges of physical registers in computeRegUnitRange.
// After that the set is flushed to the segment vector and deleted.
- typedef std::set<Segment> SegmentSet;
std::unique_ptr<SegmentSet> segmentSet;
typedef Segments::iterator iterator;
@@ -219,13 +217,14 @@
const_vni_iterator vni_end() const { return valnos.end(); }
/// Constructs a new LiveRange object.
- LiveRange(bool UseSegmentSet = false)
- : segmentSet(UseSegmentSet ? llvm::make_unique<SegmentSet>()
- : nullptr) {}
+ explicit LiveRange(bool UseSegmentSet = false)
+ : segments(), valnos(),
+ segmentSet(UseSegmentSet ? llvm::make_unique<SegmentSet>() : nullptr) { }
/// Constructs a new LiveRange object by copying segments and valnos from
/// another LiveRange.
- LiveRange(const LiveRange &Other, BumpPtrAllocator &Allocator) {
+ LiveRange(const LiveRange &Other, BumpPtrAllocator &Allocator)
+ : segments(), valnos(), segmentSet() {
assert(Other.segmentSet == nullptr &&
"Copying of LiveRanges with active SegmentSets is not supported");
@@ -305,8 +304,15 @@
/// getNextValue - Create a new value number and return it. MIIdx specifies
/// the instruction that defines the value number.
VNInfo *getNextValue(SlotIndex def, VNInfo::Allocator &VNInfoAllocator) {
- VNInfo *VNI =
- new (VNInfoAllocator) VNInfo((unsigned)valnos.size(), def);
+ size_t Size = sizeof(VNInfo) + valnos.size();
+ size_t Alignment = llvm::AlignOf<llvm::VNInfo>::Alignment;
+ void *Mem = VNInfoAllocator.Allocate(Size, Alignment);
+ assert(Mem && "VNInfoAllocator memory allocation failed!");
+
+ VNInfo *VNI = new (reinterpret_cast<VNInfo*>(Mem))
+ VNInfo(static_cast<unsigned>(valnos.size()), def);
+ assert(VNI && "VNInfo placement construction failed!");
+
valnos.push_back(VNI);
return VNI;
}
@@ -320,8 +326,15 @@
/// for the Value number.
VNInfo *createValueCopy(const VNInfo *orig,
VNInfo::Allocator &VNInfoAllocator) {
- VNInfo *VNI =
- new (VNInfoAllocator) VNInfo((unsigned)valnos.size(), *orig);
+ size_t Size = sizeof(VNInfo) + valnos.size();
+ size_t Alignment = llvm::AlignOf<llvm::VNInfo>::Alignment;
+ void *Mem = VNInfoAllocator.Allocate(Size, Alignment);
+ assert(Mem && "VNInfoAllocator memory allocation failed!");
+
+ VNInfo *VNI = new (reinterpret_cast<VNInfo*>(Mem))
+ VNInfo(static_cast<unsigned>(valnos.size()), *orig);
+ assert(VNI && "VNInfo placement construction failed!");
+
valnos.push_back(VNI);
return VNI;
}
@@ -591,28 +604,26 @@
/// LiveInterval - This class represents the liveness of a register,
/// or stack slot.
- class LiveInterval : public LiveRange {
+ class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) LiveInterval : public LiveRange {
public:
typedef LiveRange super;
/// A live range for subregisters. The LaneMask specifies which parts of the
/// super register are covered by the interval.
/// (@sa TargetRegisterInfo::getSubRegIndexLaneMask()).
- class SubRange : public LiveRange {
+ class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) SubRange : public LiveRange {
public:
SubRange *Next;
LaneBitmask LaneMask;
/// Constructs a new SubRange object.
- SubRange(LaneBitmask LaneMask)
- : Next(nullptr), LaneMask(LaneMask) {
- }
+ explicit SubRange(LaneBitmask Mask = 0U)
+ : LiveRange(), Next(nullptr), LaneMask(Mask) { }
/// Constructs a new SubRange object by copying liveness from @p Other.
- SubRange(LaneBitmask LaneMask, const LiveRange &Other,
+ SubRange(LaneBitmask Mask, const LiveRange &Other,
BumpPtrAllocator &Allocator)
- : LiveRange(Other, Allocator), Next(nullptr), LaneMask(LaneMask) {
- }
+ : LiveRange(Other, Allocator), Next(nullptr), LaneMask(Mask) { }
};
private:
@@ -623,7 +634,7 @@
float weight; // weight of this interval
LiveInterval(unsigned Reg, float Weight)
- : SubRanges(nullptr), reg(Reg), weight(Weight) {}
+ : LiveRange(), SubRanges(nullptr), reg(Reg), weight(Weight) { }
~LiveInterval() {
clearSubRanges();
@@ -787,13 +798,14 @@
SlotIndex LastStart;
LiveRange::iterator WriteI;
LiveRange::iterator ReadI;
- SmallVector<LiveRange::Segment, 16> Spills;
+ std::vector<LiveRange::Segment> Spills;
void mergeSpills();
public:
/// Create a LiveRangeUpdater for adding segments to LR.
/// LR will temporarily be in an invalid state until flush() is called.
- LiveRangeUpdater(LiveRange *lr = nullptr) : LR(lr) {}
+ explicit LiveRangeUpdater(LiveRange *lr = nullptr)
+ : LR(lr), LastStart(), WriteI(), ReadI(), Spills() { }
~LiveRangeUpdater() { flush(); }
###
--- lib/CodeGen/LiveInterval.cpp 2016-02-17 10:41:44.000000000 -0800
+++ lib/CodeGen/LiveInterval.cpp 2016-05-25 10:21:23.432898762 -0700
@@ -320,10 +320,16 @@
VNInfo *LiveRange::createDeadDef(SlotIndex Def,
VNInfo::Allocator &VNInfoAllocator) {
// Use the segment set, if it is available.
- if (segmentSet != nullptr)
- return CalcLiveRangeUtilSet(this).createDeadDef(Def, VNInfoAllocator);
+ if (segmentSet != nullptr) {
+ CalcLiveRangeUtilSet CLR(this);
+ VNInfo *VNI = CLR.createDeadDef(Def, VNInfoAllocator);
+ return VNI;
+ }
+
// Otherwise use the segment vector.
- return CalcLiveRangeUtilVector(this).createDeadDef(Def, VNInfoAllocator);
+ CalcLiveRangeUtilVector CLR(this);
+ VNInfo *VNI = CLR.createDeadDef(Def, VNInfoAllocator);
+ return VNI;
}
// overlaps - Return true if the intersection of the two live ranges is
@@ -740,10 +746,12 @@
void LiveRange::flushSegmentSet() {
assert(segmentSet != nullptr && "segment set must have been created");
- assert(
- segments.empty() &&
- "segment set can be used only initially before switching to the array");
- segments.append(segmentSet->begin(), segmentSet->end());
+ assert(segments.empty() &&
+ "segment set can be used only initially before "
+ "switching to the array");
+
+ segmentSet->begin(), segmentSet->end());
segmentSet = nullptr;
verify();
}
###
--- lib/CodeGen/LiveIntervalAnalysis.cpp 2016-01-07 17:16:35.000000000 -0800
+++ lib/CodeGen/LiveIntervalAnalysis.cpp 2016-05-25 08:48:39.699849409 -0700
@@ -185,12 +185,19 @@
}
#endif
-LiveInterval* LiveIntervals::createInterval(unsigned reg) {
- float Weight = TargetRegisterInfo::isPhysicalRegister(reg) ?
+LiveInterval* LiveIntervals::createInterval(unsigned Reg) {
+ float Weight = TargetRegisterInfo::isPhysicalRegister(Reg) ?
llvm::huge_valf : 0.0F;
- return new LiveInterval(reg, Weight);
-}
+ void *Mem;
+ size_t Alignment = llvm::AlignOf<uint64_t>::Alignment;
+ if (posix_memalign(&Mem, Alignment, sizeof(LiveInterval)) != 0)
+ return nullptr;
+
+ (void) std::memset(Mem, 0, sizeof(LiveInterval));
+ LiveInterval *LI = new (Mem) LiveInterval(Reg, Weight);
+ return LI;
+}
/// computeVirtRegInterval - Compute the live interval of a virtual register,
/// based on defs and uses.
###
--- lib/CodeGen/MachineBasicBlock.cpp 2016-01-07 01:26:32.000000000 -0900
+++ lib/CodeGen/MachineBasicBlock.cpp 2016-07-07 10:45:17.893185995 -0800
@@ -40,12 +40,16 @@
#define DEBUG_TYPE "codegen"
MachineBasicBlock::MachineBasicBlock(MachineFunction &MF, const BasicBlock *B)
- : BB(B), Number(-1), xParent(&MF) {
- Insts.Parent = this;
+ : ilist_node_with_parent<MachineBasicBlock, MachineFunction>(),
+ BB(B), Number(-1), xParent(&MF),
+ Predecessors(), Successors(), Probs(), LiveIns(),
+ Alignment(0U), IsEHPad(false), AddressTaken(false),
+ IsEHFuncletEntry(false), IsCleanupFuncletEntry(false),
+ CachedMCSymbol(nullptr) {
+ Insts.Parent = this;
}
-MachineBasicBlock::~MachineBasicBlock() {
-}
+MachineBasicBlock::~MachineBasicBlock() { }
/// Return the MCSymbol for this basic block.
MCSymbol *MachineBasicBlock::getSymbol() const {
@@ -525,8 +529,9 @@
BranchProbability Prob) {
// Probability list is either empty (if successor list isn't empty, this means
// disabled optimization) or has the same size as successor list.
- if (!(Probs.empty() && !Successors.empty()))
Probs.push_back(Prob);
+
Successors.push_back(Succ);
Succ->addPredecessor(this);
}
###.
--- include/llvm/CodeGen/MachineBasicBlock.h 2015-12-13 00:26:17.000000000 -0900
+++ include/llvm/CodeGen/MachineBasicBlock.h 2016-07-07 10:24:28.207403130 -0800
@@ -125,7 +125,15 @@
mutable MCSymbol *CachedMCSymbol = nullptr;
// Intrusive list support
- MachineBasicBlock() {}
+ MachineBasicBlock()
+ : ilist_node_with_parent<MachineBasicBlock, MachineFunction>(),
+ Insts(), BB(nullptr), Number(-1), xParent(nullptr),
+ Predecessors(), Successors(), Probs(), LiveIns(),
+ Alignment(0U), IsEHPad(false), AddressTaken(false),
+ IsEHFuncletEntry(false), IsCleanupFuncletEntry(false),
+ CachedMCSymbol(nullptr) {
+ Insts.Parent = this;
+ }
explicit MachineBasicBlock(MachineFunction &MF, const BasicBlock *BB);
###
--- lib/CodeGen/AsmPrinter/AsmPrinter.cpp 2016-01-12 17:18:13.000000000 -0800
+++ lib/CodeGen/AsmPrinter/AsmPrinter.cpp 2016-05-25 14:27:34.764865039 -0700
@@ -1614,6 +1614,7 @@
};
} // end namespace
+
/// EmitXXStructorList - Emit the ctor or dtor list taking into account the init
/// priority.
void AsmPrinter::EmitXXStructorList(const DataLayout &DL, const Constant *List,
@@ -1667,13 +1668,14 @@
KeySym = getSymbol(GV);
}
- MCSection *OutputSection =
- (isCtor ? Obj.getStaticCtorSection(S.Priority, KeySym)
- : Obj.getStaticDtorSection(S.Priority, KeySym));
- OutStreamer->SwitchSection(OutputSection);
- if (OutStreamer->getCurrentSection() != OutStreamer->getPreviousSection())
- EmitAlignment(Align);
- EmitXXStructor(DL, S.Func);
+
+ // Why is this even necessary?
+ // Constructors for global statics are emitted in
+ // Destructors for global statics register themselves with __cxa_atexit.
+ // I.e. they do not need any kind of additional special handling.
+ // The only thing this does is duplicate constructor calls for
+ // global static initializations.
}
}
###
--- lib/CodeGen/CodeGenPrepare.cpp 2016-01-22 13:26:38.000000000 -0500
+++ lib/CodeGen/CodeGenPrepare.cpp 2016-05-28 13:01:43.647551022 -0400
@@ -2445,59 +2445,67 @@
private:
/// The ordered list of actions made so far.
- SmallVector<std::unique_ptr<TypePromotionAction>, 16> Actions;
- typedef SmallVectorImpl<std::unique_ptr<TypePromotionAction>>::iterator CommitPt;
+ /// You cannot use a SmallVector here because of copy vs. move
+ /// semantics. You can't use a std::unique_ptr eiter, for the
+ /// same exact reasons.
+ std::vector<std::shared_ptr<TypePromotionAction> > Actions;
+ typedef std::vector<std::shared_ptr<TypePromotionAction>>::iterator CommitPt;
};
void TypePromotionTransaction::setOperand(Instruction *Inst, unsigned Idx,
Value *NewVal) {
- make_unique<TypePromotionTransaction::OperandSetter>(Inst, Idx, NewVal));
+ std::make_shared<TypePromotionTransaction::OperandSetter>(Inst,
+ Idx, NewVal));
}
void TypePromotionTransaction::eraseInstruction(Instruction *Inst,
Value *NewVal) {
- make_unique<TypePromotionTransaction::InstructionRemover>(Inst, NewVal));
+ std::make_shared<TypePromotionTransaction::InstructionRemover>(Inst,
+ NewVal));
}
void TypePromotionTransaction::replaceAllUsesWith(Instruction *Inst,
Value *New) {
- Actions.push_back(make_unique<TypePromotionTransaction::UsesReplacer>(Inst, New));
+ std::make_shared<TypePromotionTransaction::UsesReplacer>(Inst, New));
}
void TypePromotionTransaction::mutateType(Instruction *Inst, Type *NewTy) {
- Actions.push_back(make_unique<TypePromotionTransaction::TypeMutator>(Inst, NewTy));
+ std::make_shared<TypePromotionTransaction::TypeMutator>(Inst, NewTy));
}
Value *TypePromotionTransaction::createTrunc(Instruction *Opnd,
Type *Ty) {
- std::unique_ptr<TruncBuilder> Ptr(new TruncBuilder(Opnd, Ty));
+ std::shared_ptr<TruncBuilder> Ptr(new TruncBuilder(Opnd, Ty));
Value *Val = Ptr->getBuiltValue();
- Actions.push_back(std::move(Ptr));
+ Actions.push_back(Ptr);
return Val;
}
Value *TypePromotionTransaction::createSExt(Instruction *Inst,
Value *Opnd, Type *Ty) {
- std::unique_ptr<SExtBuilder> Ptr(new SExtBuilder(Inst, Opnd, Ty));
+ std::shared_ptr<SExtBuilder> Ptr(new SExtBuilder(Inst, Opnd, Ty));
Value *Val = Ptr->getBuiltValue();
- Actions.push_back(std::move(Ptr));
+ Actions.push_back(Ptr);
return Val;
}
Value *TypePromotionTransaction::createZExt(Instruction *Inst,
Value *Opnd, Type *Ty) {
- std::unique_ptr<ZExtBuilder> Ptr(new ZExtBuilder(Inst, Opnd, Ty));
+ std::shared_ptr<ZExtBuilder> Ptr(new ZExtBuilder(Inst, Opnd, Ty));
Value *Val = Ptr->getBuiltValue();
- Actions.push_back(std::move(Ptr));
+ Actions.push_back(Ptr);
return Val;
}
void TypePromotionTransaction::moveBefore(Instruction *Inst,
Instruction *Before) {
- make_unique<TypePromotionTransaction::InstructionMoveBefore>(Inst, Before));
+ std::make_shared<TypePromotionTransaction::InstructionMoveBefore>(Inst,
+ Before));
}
TypePromotionTransaction::ConstRestorationPt
@@ -2515,8 +2523,9 @@
void TypePromotionTransaction::rollback(
TypePromotionTransaction::ConstRestorationPt Point) {
while (!Actions.empty() && Point != Actions.back().get()) {
- std::unique_ptr<TypePromotionAction> Curr = Actions.pop_back_val();
+ std::shared_ptr<TypePromotionAction> Curr = Actions.back();
Curr->undo();
+ Actions.pop_back();
}
}
###
--- lib/CodeGen/Passes.cpp 2015-12-16 03:09:48.000000000 -0800
+++ lib/CodeGen/Passes.cpp 2016-05-13 17:38:47.747582295 -0700
@@ -31,9 +31,17 @@
#include "llvm/Transforms/Instrumentation.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/SymbolRewriter.h"
-
+#include "llvm/LinkAllPasses.h"
using namespace llvm;
+//===----------------------------------------------------------------------===//
+/// See the file ${top_srcdir}/include/llvm/LinkAllPasses.h for the
+/// explanation of this hack.
+namespace llvm {
+ ForcePassLinking* ForcePassLinking::FPL = new llvm::ForcePassLinking();
+} // namespace llvm
+//===----------------------------------------------------------------------===//
+
static cl::opt<bool> DisablePostRA("disable-post-ra", cl::Hidden,
cl::desc("Disable Post Regalloc"));
static cl::opt<bool> DisableBranchFold("disable-branch-fold", cl::Hidden,
###
--- lib/CodeGen/TargetLoweringObjectFileImpl.cpp 2015-11-17 22:02:15.000000000 -0800
+++ lib/CodeGen/TargetLoweringObjectFileImpl.cpp 2016-05-25 14:26:17.415867207 -0700
@@ -360,8 +360,10 @@
return DataRelROSection;
}
-static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
- bool IsCtor, unsigned Priority,
+static MCSectionELF *getStaticStructorSection(MCContext &Ctx,
+ bool UseInitArray,
+ bool IsCtor,
+ unsigned Priority,
const MCSymbol *KeySym) {
std::string Name;
unsigned Type;
@@ -379,21 +381,34 @@
Type = ELF::SHT_FINI_ARRAY;
Name = ".fini_array";
}
+
if (Priority != 65535) {
Name += '.';
- Name += utostr(Priority);
+ Name += std::to_string(Priority);
}
} else {
- // The default scheme is .ctor / .dtor, so we have to invert the priority
- // numbering.
- if (IsCtor)
- Name = ".ctors";
- else
- Name = ".dtors";
+ if (Ctx.getObjectFileInfo()->getTargetTriple().getOS() ==
+ llvm::Triple::Solaris) {
+ // on Solaris we use .inift/.fini because the Solaris linker
+ // can't handle .ctors/.dtors.
+ if (IsCtor)
+ Name = ".init";
+ else
+ Name = ".fini";
+ } else {
+ // The default scheme is .ctor / .dtor, so we have to invert the priority
+ // numbering.
+ if (IsCtor)
+ Name = ".ctors";
+ else
+ Name = ".dtors";
+ }
+
if (Priority != 65535) {
Name += '.';
- Name += utostr(65535 - Priority);
+ Name += std::to_string(65535 - Priority);
}
+
Type = ELF::SHT_PROGBITS;
}
###