Upgrade our copies of clang, llvm, lld and lldb to r309439 from the
upstream release_50 branch. This is just after upstream's 5.0.0-rc1. MFC after: 2 months X-MFC-with: r321369
This commit is contained in:
Dimitry Andric
commit
37cd60a321
@ -40,7 +40,8 @@ class TargetRegisterInfo;
|
||||
/// This is convenient because std::bitset does not have a constructor
|
||||
/// with an initializer list of set bits.
|
||||
///
|
||||
/// Each InstructionSelector subclass should define a PredicateBitset class with:
|
||||
/// Each InstructionSelector subclass should define a PredicateBitset class
|
||||
/// with:
|
||||
/// const unsigned MAX_SUBTARGET_PREDICATES = 192;
|
||||
/// using PredicateBitset = PredicateBitsetImpl<MAX_SUBTARGET_PREDICATES>;
|
||||
/// and updating the constant to suit the target. Tablegen provides a suitable
|
||||
@ -102,7 +103,8 @@ enum {
|
||||
/// - OpIdx - Operand index
|
||||
/// - Expected integer
|
||||
GIM_CheckConstantInt,
|
||||
/// Check the operand is a specific literal integer (i.e. MO.isImm() or MO.isCImm() is true).
|
||||
/// Check the operand is a specific literal integer (i.e. MO.isImm() or
|
||||
/// MO.isCImm() is true).
|
||||
/// - InsnID - Instruction ID
|
||||
/// - OpIdx - Operand index
|
||||
/// - Expected integer
|
||||
|
||||
@ -66,15 +66,12 @@ bool ParseCommandLineOptions(int argc, const char *const *argv,
|
||||
void ParseEnvironmentOptions(const char *progName, const char *envvar,
|
||||
const char *Overview = "");
|
||||
|
||||
// Function pointer type for printing version information.
|
||||
using VersionPrinterTy = std::function<void(raw_ostream &)>;
|
||||
|
||||
///===---------------------------------------------------------------------===//
|
||||
/// SetVersionPrinter - Override the default (LLVM specific) version printer
|
||||
/// used to print out the version when --version is given
|
||||
/// on the command line. This allows other systems using the
|
||||
/// CommandLine utilities to print their own version string.
|
||||
void SetVersionPrinter(VersionPrinterTy func);
|
||||
void SetVersionPrinter(void (*func)());
|
||||
|
||||
///===---------------------------------------------------------------------===//
|
||||
/// AddExtraVersionPrinter - Add an extra printer to use in addition to the
|
||||
@ -83,7 +80,7 @@ void SetVersionPrinter(VersionPrinterTy func);
|
||||
/// which will be called after the basic LLVM version
|
||||
/// printing is complete. Each can then add additional
|
||||
/// information specific to the tool.
|
||||
void AddExtraVersionPrinter(VersionPrinterTy func);
|
||||
void AddExtraVersionPrinter(void (*func)());
|
||||
|
||||
// PrintOptionValues - Print option values.
|
||||
// With -print-options print the difference between option values and defaults.
|
||||
|
||||
@ -599,7 +599,7 @@ struct TargetRegistry {
|
||||
|
||||
/// printRegisteredTargetsForVersion - Print the registered targets
|
||||
/// appropriately for inclusion in a tool's version output.
|
||||
static void printRegisteredTargetsForVersion(raw_ostream &OS);
|
||||
static void printRegisteredTargetsForVersion();
|
||||
|
||||
/// @name Registry Access
|
||||
/// @{
|
||||
|
||||
@ -531,8 +531,10 @@ Value *createTargetReduction(IRBuilder<> &B, const TargetTransformInfo *TTI,
|
||||
|
||||
/// Get the intersection (logical and) of all of the potential IR flags
|
||||
/// of each scalar operation (VL) that will be converted into a vector (I).
|
||||
/// If OpValue is non-null, we only consider operations similar to OpValue
|
||||
/// when intersecting.
|
||||
/// Flag set: NSW, NUW, exact, and all of fast-math.
|
||||
void propagateIRFlags(Value *I, ArrayRef<Value *> VL);
|
||||
void propagateIRFlags(Value *I, ArrayRef<Value *> VL, Value *OpValue = nullptr);
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
|
||||
@ -643,8 +643,11 @@ void InlineSpiller::reMaterializeAll() {
|
||||
Edit->eraseVirtReg(Reg);
|
||||
continue;
|
||||
}
|
||||
assert((LIS.hasInterval(Reg) && !LIS.getInterval(Reg).empty()) &&
|
||||
"Reg with empty interval has reference");
|
||||
|
||||
assert(LIS.hasInterval(Reg) &&
|
||||
(!LIS.getInterval(Reg).empty() || !MRI.reg_nodbg_empty(Reg)) &&
|
||||
"Empty and not used live-range?!");
|
||||
|
||||
RegsToSpill[ResultPos++] = Reg;
|
||||
}
|
||||
RegsToSpill.erase(RegsToSpill.begin() + ResultPos, RegsToSpill.end());
|
||||
|
||||
@ -133,18 +133,19 @@ void RegAllocBase::allocatePhysRegs() {
|
||||
if (AvailablePhysReg)
|
||||
Matrix->assign(*VirtReg, AvailablePhysReg);
|
||||
|
||||
for (VirtRegVec::iterator I = SplitVRegs.begin(), E = SplitVRegs.end();
|
||||
I != E; ++I) {
|
||||
LiveInterval *SplitVirtReg = &LIS->getInterval(*I);
|
||||
for (unsigned Reg : SplitVRegs) {
|
||||
assert(LIS->hasInterval(Reg));
|
||||
|
||||
LiveInterval *SplitVirtReg = &LIS->getInterval(Reg);
|
||||
assert(!VRM->hasPhys(SplitVirtReg->reg) && "Register already assigned");
|
||||
if (MRI->reg_nodbg_empty(SplitVirtReg->reg)) {
|
||||
assert(SplitVirtReg->empty() && "Non-empty but used interval");
|
||||
DEBUG(dbgs() << "not queueing unused " << *SplitVirtReg << '\n');
|
||||
aboutToRemoveInterval(*SplitVirtReg);
|
||||
LIS->removeInterval(SplitVirtReg->reg);
|
||||
continue;
|
||||
}
|
||||
DEBUG(dbgs() << "queuing new interval: " << *SplitVirtReg << "\n");
|
||||
assert(!SplitVirtReg->empty() && "expecting non-empty interval");
|
||||
assert(TargetRegisterInfo::isVirtualRegister(SplitVirtReg->reg) &&
|
||||
"expect split value in virtual register");
|
||||
enqueue(SplitVirtReg);
|
||||
|
||||
@ -2965,7 +2965,12 @@ static inline bool isSETCCorConvertedSETCC(SDValue N) {
|
||||
else if (N.getOpcode() == ISD::SIGN_EXTEND)
|
||||
N = N.getOperand(0);
|
||||
|
||||
return (N.getOpcode() == ISD::SETCC);
|
||||
if (isLogicalMaskOp(N.getOpcode()))
|
||||
return isSETCCorConvertedSETCC(N.getOperand(0)) &&
|
||||
isSETCCorConvertedSETCC(N.getOperand(1));
|
||||
|
||||
return (N.getOpcode() == ISD::SETCC ||
|
||||
ISD::isBuildVectorOfConstantSDNodes(N.getNode()));
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -2973,28 +2978,20 @@ static inline bool isSETCCorConvertedSETCC(SDValue N) {
|
||||
// to ToMaskVT if needed with vector extension or truncation.
|
||||
SDValue DAGTypeLegalizer::convertMask(SDValue InMask, EVT MaskVT,
|
||||
EVT ToMaskVT) {
|
||||
LLVMContext &Ctx = *DAG.getContext();
|
||||
|
||||
// Currently a SETCC or a AND/OR/XOR with two SETCCs are handled.
|
||||
unsigned InMaskOpc = InMask->getOpcode();
|
||||
|
||||
// FIXME: This code seems to be too restrictive, we might consider
|
||||
// generalizing it or dropping it.
|
||||
assert((InMaskOpc == ISD::SETCC ||
|
||||
ISD::isBuildVectorOfConstantSDNodes(InMask.getNode()) ||
|
||||
(isLogicalMaskOp(InMaskOpc) &&
|
||||
isSETCCorConvertedSETCC(InMask->getOperand(0)) &&
|
||||
isSETCCorConvertedSETCC(InMask->getOperand(1)))) &&
|
||||
"Unexpected mask argument.");
|
||||
assert(isSETCCorConvertedSETCC(InMask) && "Unexpected mask argument.");
|
||||
|
||||
// Make a new Mask node, with a legal result VT.
|
||||
SmallVector<SDValue, 4> Ops;
|
||||
for (unsigned i = 0; i < InMask->getNumOperands(); ++i)
|
||||
Ops.push_back(InMask->getOperand(i));
|
||||
SDValue Mask = DAG.getNode(InMaskOpc, SDLoc(InMask), MaskVT, Ops);
|
||||
SDValue Mask = DAG.getNode(InMask->getOpcode(), SDLoc(InMask), MaskVT, Ops);
|
||||
|
||||
// If MaskVT has smaller or bigger elements than ToMaskVT, a vector sign
|
||||
// extend or truncate is needed.
|
||||
LLVMContext &Ctx = *DAG.getContext();
|
||||
unsigned MaskScalarBits = MaskVT.getScalarSizeInBits();
|
||||
unsigned ToMaskScalBits = ToMaskVT.getScalarSizeInBits();
|
||||
if (MaskScalarBits < ToMaskScalBits) {
|
||||
|
||||
@ -235,7 +235,9 @@ OptTable::findByPrefix(StringRef Cur, unsigned short DisableFlags) const {
|
||||
continue;
|
||||
|
||||
for (int I = 0; In.Prefixes[I]; I++) {
|
||||
std::string S = std::string(In.Prefixes[I]) + std::string(In.Name);
|
||||
std::string S = std::string(In.Prefixes[I]) + std::string(In.Name) + "\t";
|
||||
if (In.HelpText)
|
||||
S += In.HelpText;
|
||||
if (StringRef(S).startswith(Cur))
|
||||
Ret.push_back(S);
|
||||
}
|
||||
|
||||
@ -2039,9 +2039,9 @@ void CommandLineParser::printOptionValues() {
|
||||
Opts[i].second->printOptionValue(MaxArgLen, PrintAllOptions);
|
||||
}
|
||||
|
||||
static VersionPrinterTy OverrideVersionPrinter = nullptr;
|
||||
static void (*OverrideVersionPrinter)() = nullptr;
|
||||
|
||||
static std::vector<VersionPrinterTy> *ExtraVersionPrinters = nullptr;
|
||||
static std::vector<void (*)()> *ExtraVersionPrinters = nullptr;
|
||||
|
||||
namespace {
|
||||
class VersionPrinter {
|
||||
@ -2081,7 +2081,7 @@ class VersionPrinter {
|
||||
return;
|
||||
|
||||
if (OverrideVersionPrinter != nullptr) {
|
||||
OverrideVersionPrinter(outs());
|
||||
(*OverrideVersionPrinter)();
|
||||
exit(0);
|
||||
}
|
||||
print();
|
||||
@ -2090,8 +2090,10 @@ class VersionPrinter {
|
||||
// information.
|
||||
if (ExtraVersionPrinters != nullptr) {
|
||||
outs() << '\n';
|
||||
for (auto I : *ExtraVersionPrinters)
|
||||
I(outs());
|
||||
for (std::vector<void (*)()>::iterator I = ExtraVersionPrinters->begin(),
|
||||
E = ExtraVersionPrinters->end();
|
||||
I != E; ++I)
|
||||
(*I)();
|
||||
}
|
||||
|
||||
exit(0);
|
||||
@ -2129,11 +2131,11 @@ void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
|
||||
/// Utility function for printing version number.
|
||||
void cl::PrintVersionMessage() { VersionPrinterInstance.print(); }
|
||||
|
||||
void cl::SetVersionPrinter(VersionPrinterTy func) { OverrideVersionPrinter = func; }
|
||||
void cl::SetVersionPrinter(void (*func)()) { OverrideVersionPrinter = func; }
|
||||
|
||||
void cl::AddExtraVersionPrinter(VersionPrinterTy func) {
|
||||
void cl::AddExtraVersionPrinter(void (*func)()) {
|
||||
if (!ExtraVersionPrinters)
|
||||
ExtraVersionPrinters = new std::vector<VersionPrinterTy>;
|
||||
ExtraVersionPrinters = new std::vector<void (*)()>;
|
||||
|
||||
ExtraVersionPrinters->push_back(func);
|
||||
}
|
||||
|
||||
@ -169,7 +169,8 @@ void llvm::report_bad_alloc_error(const char *Reason, bool GenCrashDiag) {
|
||||
// Don't call the normal error handler. It may allocate memory. Directly write
|
||||
// an OOM to stderr and abort.
|
||||
char OOMMessage[] = "LLVM ERROR: out of memory\n";
|
||||
(void)::write(2, OOMMessage, strlen(OOMMessage));
|
||||
ssize_t written = ::write(2, OOMMessage, strlen(OOMMessage));
|
||||
(void)written;
|
||||
abort();
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -114,7 +114,7 @@ static int TargetArraySortFn(const std::pair<StringRef, const Target *> *LHS,
|
||||
return LHS->first.compare(RHS->first);
|
||||
}
|
||||
|
||||
void TargetRegistry::printRegisteredTargetsForVersion(raw_ostream &OS) {
|
||||
void TargetRegistry::printRegisteredTargetsForVersion() {
|
||||
std::vector<std::pair<StringRef, const Target*> > Targets;
|
||||
size_t Width = 0;
|
||||
for (const auto &T : TargetRegistry::targets()) {
|
||||
@ -123,6 +123,7 @@ void TargetRegistry::printRegisteredTargetsForVersion(raw_ostream &OS) {
|
||||
}
|
||||
array_pod_sort(Targets.begin(), Targets.end(), TargetArraySortFn);
|
||||
|
||||
raw_ostream &OS = outs();
|
||||
OS << " Registered Targets:\n";
|
||||
for (unsigned i = 0, e = Targets.size(); i != e; ++i) {
|
||||
OS << " " << Targets[i].first;
|
||||
|
||||
@ -2889,9 +2889,12 @@ void AArch64TargetLowering::saveVarArgRegisters(CCState &CCInfo,
|
||||
unsigned GPRSaveSize = 8 * (NumGPRArgRegs - FirstVariadicGPR);
|
||||
int GPRIdx = 0;
|
||||
if (GPRSaveSize != 0) {
|
||||
if (IsWin64)
|
||||
if (IsWin64) {
|
||||
GPRIdx = MFI.CreateFixedObject(GPRSaveSize, -(int)GPRSaveSize, false);
|
||||
else
|
||||
if (GPRSaveSize & 15)
|
||||
// The extra size here, if triggered, will always be 8.
|
||||
MFI.CreateFixedObject(16 - (GPRSaveSize & 15), -(int)alignTo(GPRSaveSize, 16), false);
|
||||
} else
|
||||
GPRIdx = MFI.CreateStackObject(GPRSaveSize, 8, false);
|
||||
|
||||
SDValue FIN = DAG.getFrameIndex(GPRIdx, PtrVT);
|
||||
|
||||
@ -297,6 +297,11 @@ void AMDGPUInstPrinter::printRegOperand(unsigned RegNo, raw_ostream &O,
|
||||
case AMDGPU::FLAT_SCR_HI:
|
||||
O << "flat_scratch_hi";
|
||||
return;
|
||||
case AMDGPU::FP_REG:
|
||||
case AMDGPU::SP_REG:
|
||||
case AMDGPU::SCRATCH_WAVE_OFFSET_REG:
|
||||
case AMDGPU::PRIVATE_RSRC_REG:
|
||||
llvm_unreachable("pseudo-register should not ever be emitted");
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
@ -274,8 +274,7 @@ def VGPR_512 : RegisterTuples<[sub0, sub1, sub2, sub3, sub4, sub5, sub6, sub7,
|
||||
def SReg_32_XM0_XEXEC : RegisterClass<"AMDGPU", [i32, f32, i16, f16, v2i16, v2f16], 32,
|
||||
(add SGPR_32, VCC_LO, VCC_HI, FLAT_SCR_LO, FLAT_SCR_HI,
|
||||
TTMP_32, TMA_LO, TMA_HI, TBA_LO, TBA_HI, SRC_SHARED_BASE, SRC_SHARED_LIMIT,
|
||||
SRC_PRIVATE_BASE, SRC_PRIVATE_LIMIT,
|
||||
FP_REG, SP_REG, SCRATCH_WAVE_OFFSET_REG)> {
|
||||
SRC_PRIVATE_BASE, SRC_PRIVATE_LIMIT)> {
|
||||
let AllocationPriority = 7;
|
||||
}
|
||||
|
||||
|
||||
@ -61,14 +61,6 @@ static unsigned adjustFixupValue(unsigned Kind, uint64_t Value) {
|
||||
case Sparc::fixup_sparc_lo10:
|
||||
return Value & 0x3ff;
|
||||
|
||||
case Sparc::fixup_sparc_tls_ldo_hix22:
|
||||
case Sparc::fixup_sparc_tls_le_hix22:
|
||||
return (~Value >> 10) & 0x3fffff;
|
||||
|
||||
case Sparc::fixup_sparc_tls_ldo_lox10:
|
||||
case Sparc::fixup_sparc_tls_le_lox10:
|
||||
return (~(~Value & 0x3ff)) & 0x1fff;
|
||||
|
||||
case Sparc::fixup_sparc_h44:
|
||||
return (Value >> 22) & 0x3fffff;
|
||||
|
||||
@ -84,6 +76,13 @@ static unsigned adjustFixupValue(unsigned Kind, uint64_t Value) {
|
||||
case Sparc::fixup_sparc_hm:
|
||||
return (Value >> 32) & 0x3ff;
|
||||
|
||||
case Sparc::fixup_sparc_tls_ldo_hix22:
|
||||
case Sparc::fixup_sparc_tls_le_hix22:
|
||||
case Sparc::fixup_sparc_tls_ldo_lox10:
|
||||
case Sparc::fixup_sparc_tls_le_lox10:
|
||||
assert(Value == 0 && "Sparc TLS relocs expect zero Value");
|
||||
return 0;
|
||||
|
||||
case Sparc::fixup_sparc_tls_gd_add:
|
||||
case Sparc::fixup_sparc_tls_gd_call:
|
||||
case Sparc::fixup_sparc_tls_ldm_add:
|
||||
|
||||
@ -455,10 +455,10 @@ def : InstRW<[FXa, LSU, Lat8], (instregex "MH(Y)?$")>;
|
||||
def : InstRW<[FXa2, Lat6, GroupAlone], (instregex "M(L)?R$")>;
|
||||
def : InstRW<[FXa2, LSU, Lat10, GroupAlone], (instregex "M(FY|L)?$")>;
|
||||
def : InstRW<[FXa, LSU, Lat8], (instregex "MGH$")>;
|
||||
def : InstRW<[FXa, LSU, Lat12, GroupAlone], (instregex "MG$")>;
|
||||
def : InstRW<[FXa, Lat8, GroupAlone], (instregex "MGRK$")>;
|
||||
def : InstRW<[FXa, LSU, Lat9, GroupAlone], (instregex "MSC$")>;
|
||||
def : InstRW<[FXa, LSU, Lat11, GroupAlone], (instregex "MSGC$")>;
|
||||
def : InstRW<[FXa, FXa, LSU, Lat12, GroupAlone], (instregex "MG$")>;
|
||||
def : InstRW<[FXa, FXa, Lat8, GroupAlone], (instregex "MGRK$")>;
|
||||
def : InstRW<[FXa, LSU, Lat9], (instregex "MSC$")>;
|
||||
def : InstRW<[FXa, LSU, Lat11], (instregex "MSGC$")>;
|
||||
def : InstRW<[FXa, Lat5], (instregex "MSRKC$")>;
|
||||
def : InstRW<[FXa, Lat7], (instregex "MSGRKC$")>;
|
||||
|
||||
@ -620,7 +620,7 @@ def : InstRW<[FXa, Lat30], (instregex "(PCC|PPNO|PRNO)$")>;
|
||||
|
||||
def : InstRW<[LSU], (instregex "LGG$")>;
|
||||
def : InstRW<[LSU, Lat5], (instregex "LLGFSG$")>;
|
||||
def : InstRW<[LSU, Lat30, GroupAlone], (instregex "(L|ST)GSC$")>;
|
||||
def : InstRW<[LSU, Lat30], (instregex "(L|ST)GSC$")>;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Decimal arithmetic
|
||||
@ -708,7 +708,7 @@ def : InstRW<[FXb, LSU, Lat5], (instregex "NTSTG$")>;
|
||||
// Processor assist
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
def : InstRW<[FXb], (instregex "PPA$")>;
|
||||
def : InstRW<[FXb, GroupAlone], (instregex "PPA$")>;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Miscellaneous Instructions.
|
||||
@ -1276,9 +1276,9 @@ def : InstRW<[VecXsPm], (instregex "VESRL(B|F|G|H)?$")>;
|
||||
def : InstRW<[VecXsPm], (instregex "VESRLV(B|F|G|H)?$")>;
|
||||
|
||||
def : InstRW<[VecXsPm], (instregex "VSL(DB)?$")>;
|
||||
def : InstRW<[VecXsPm, VecXsPm, Lat8], (instregex "VSLB$")>;
|
||||
def : InstRW<[VecXsPm], (instregex "VSLB$")>;
|
||||
def : InstRW<[VecXsPm], (instregex "VSR(A|L)$")>;
|
||||
def : InstRW<[VecXsPm, VecXsPm, Lat8], (instregex "VSR(A|L)B$")>;
|
||||
def : InstRW<[VecXsPm], (instregex "VSR(A|L)B$")>;
|
||||
|
||||
def : InstRW<[VecXsPm], (instregex "VSB(I|IQ|CBI|CBIQ)?$")>;
|
||||
def : InstRW<[VecXsPm], (instregex "VSCBI(B|F|G|H|Q)?$")>;
|
||||
@ -1435,9 +1435,9 @@ def : InstRW<[VecStr, Lat5], (instregex "VSTRCZ(B|F|H)S$")>;
|
||||
// Vector: Packed-decimal instructions
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
def : InstRW<[VecDF, VecDF, Lat10, GroupAlone], (instregex "VLIP$")>;
|
||||
def : InstRW<[VecDFX, LSU, Lat12, GroupAlone], (instregex "VPKZ$")>;
|
||||
def : InstRW<[VecDFX, FXb, LSU, Lat12, GroupAlone], (instregex "VUPKZ$")>;
|
||||
def : InstRW<[VecDF, VecDF, Lat10], (instregex "VLIP$")>;
|
||||
def : InstRW<[VecDFX, LSU, GroupAlone], (instregex "VPKZ$")>;
|
||||
def : InstRW<[VecDFX, FXb, LSU, Lat12, BeginGroup], (instregex "VUPKZ$")>;
|
||||
def : InstRW<[VecDF, VecDF, FXb, Lat20, GroupAlone], (instregex "VCVB(G)?$")>;
|
||||
def : InstRW<[VecDF, VecDF, FXb, Lat20, GroupAlone], (instregex "VCVD(G)?$")>;
|
||||
def : InstRW<[VecDFX], (instregex "V(A|S)P$")>;
|
||||
|
||||
@ -1055,7 +1055,10 @@ static bool foldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N,
|
||||
|
||||
// Scale the leading zero count down based on the actual size of the value.
|
||||
// Also scale it down based on the size of the shift.
|
||||
MaskLZ -= (64 - X.getSimpleValueType().getSizeInBits()) + ShiftAmt;
|
||||
unsigned ScaleDown = (64 - X.getSimpleValueType().getSizeInBits()) + ShiftAmt;
|
||||
if (MaskLZ < ScaleDown)
|
||||
return true;
|
||||
MaskLZ -= ScaleDown;
|
||||
|
||||
// The final check is to ensure that any masked out high bits of X are
|
||||
// already known to be zero. Otherwise, the mask has a semantic impact
|
||||
|
||||
@ -22022,8 +22022,9 @@ static SDValue LowerScalarImmediateShift(SDValue Op, SelectionDAG &DAG,
|
||||
return getTargetVShiftByConstNode(X86Opc, dl, VT, R, ShiftAmt, DAG);
|
||||
|
||||
// i64 SRA needs to be performed as partial shifts.
|
||||
if ((VT == MVT::v2i64 || (Subtarget.hasInt256() && VT == MVT::v4i64)) &&
|
||||
Op.getOpcode() == ISD::SRA && !Subtarget.hasXOP())
|
||||
if (((!Subtarget.hasXOP() && VT == MVT::v2i64) ||
|
||||
(Subtarget.hasInt256() && VT == MVT::v4i64)) &&
|
||||
Op.getOpcode() == ISD::SRA)
|
||||
return ArithmeticShiftRight64(ShiftAmt);
|
||||
|
||||
if (VT == MVT::v16i8 ||
|
||||
|
||||
@ -64,6 +64,11 @@ ImplicationSearchThreshold(
|
||||
"condition to use to thread over a weaker condition"),
|
||||
cl::init(3), cl::Hidden);
|
||||
|
||||
static cl::opt<bool> PrintLVIAfterJumpThreading(
|
||||
"print-lvi-after-jump-threading",
|
||||
cl::desc("Print the LazyValueInfo cache after JumpThreading"), cl::init(false),
|
||||
cl::Hidden);
|
||||
|
||||
namespace {
|
||||
/// This pass performs 'jump threading', which looks at blocks that have
|
||||
/// multiple predecessors and multiple successors. If one or more of the
|
||||
@ -93,9 +98,10 @@ namespace {
|
||||
bool runOnFunction(Function &F) override;
|
||||
|
||||
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
||||
if (PrintLVIAfterJumpThreading)
|
||||
AU.addRequired<DominatorTreeWrapperPass>();
|
||||
AU.addRequired<AAResultsWrapperPass>();
|
||||
AU.addRequired<LazyValueInfoWrapperPass>();
|
||||
AU.addPreserved<LazyValueInfoWrapperPass>();
|
||||
AU.addPreserved<GlobalsAAWrapperPass>();
|
||||
AU.addRequired<TargetLibraryInfoWrapperPass>();
|
||||
}
|
||||
@ -137,8 +143,14 @@ bool JumpThreading::runOnFunction(Function &F) {
|
||||
BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
|
||||
}
|
||||
|
||||
return Impl.runImpl(F, TLI, LVI, AA, HasProfileData, std::move(BFI),
|
||||
std::move(BPI));
|
||||
bool Changed = Impl.runImpl(F, TLI, LVI, AA, HasProfileData, std::move(BFI),
|
||||
std::move(BPI));
|
||||
if (PrintLVIAfterJumpThreading) {
|
||||
dbgs() << "LVI for function '" << F.getName() << "':\n";
|
||||
LVI->printLVI(F, getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
|
||||
dbgs());
|
||||
}
|
||||
return Changed;
|
||||
}
|
||||
|
||||
PreservedAnalyses JumpThreadingPass::run(Function &F,
|
||||
@ -231,13 +243,15 @@ bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_,
|
||||
// Can't thread an unconditional jump, but if the block is "almost
|
||||
// empty", we can replace uses of it with uses of the successor and make
|
||||
// this dead.
|
||||
// We should not eliminate the loop header either, because eliminating
|
||||
// a loop header might later prevent LoopSimplify from transforming nested
|
||||
// loops into simplified form.
|
||||
// We should not eliminate the loop header or latch either, because
|
||||
// eliminating a loop header or latch might later prevent LoopSimplify
|
||||
// from transforming nested loops into simplified form. We will rely on
|
||||
// later passes in backend to clean up empty blocks.
|
||||
if (BI && BI->isUnconditional() &&
|
||||
BB != &BB->getParent()->getEntryBlock() &&
|
||||
// If the terminator is the only non-phi instruction, try to nuke it.
|
||||
BB->getFirstNonPHIOrDbg()->isTerminator() && !LoopHeaders.count(BB)) {
|
||||
BB->getFirstNonPHIOrDbg()->isTerminator() && !LoopHeaders.count(BB) &&
|
||||
!LoopHeaders.count(BI->getSuccessor(0))) {
|
||||
// FIXME: It is always conservatively correct to drop the info
|
||||
// for a block even if it doesn't get erased. This isn't totally
|
||||
// awesome, but it allows us to use AssertingVH to prevent nasty
|
||||
|
||||
@ -1376,16 +1376,21 @@ Value *llvm::createTargetReduction(IRBuilder<> &Builder,
|
||||
}
|
||||
}
|
||||
|
||||
void llvm::propagateIRFlags(Value *I, ArrayRef<Value *> VL) {
|
||||
if (auto *VecOp = dyn_cast<Instruction>(I)) {
|
||||
if (auto *I0 = dyn_cast<Instruction>(VL[0])) {
|
||||
// VecOVp is initialized to the 0th scalar, so start counting from index
|
||||
// '1'.
|
||||
VecOp->copyIRFlags(I0);
|
||||
for (int i = 1, e = VL.size(); i < e; ++i) {
|
||||
if (auto *Scalar = dyn_cast<Instruction>(VL[i]))
|
||||
VecOp->andIRFlags(Scalar);
|
||||
}
|
||||
}
|
||||
void llvm::propagateIRFlags(Value *I, ArrayRef<Value *> VL, Value *OpValue) {
|
||||
auto *VecOp = dyn_cast<Instruction>(I);
|
||||
if (!VecOp)
|
||||
return;
|
||||
auto *Intersection = (OpValue == nullptr) ? dyn_cast<Instruction>(VL[0])
|
||||
: dyn_cast<Instruction>(OpValue);
|
||||
if (!Intersection)
|
||||
return;
|
||||
const unsigned Opcode = Intersection->getOpcode();
|
||||
VecOp->copyIRFlags(Intersection);
|
||||
for (auto *V : VL) {
|
||||
auto *Instr = dyn_cast<Instruction>(V);
|
||||
if (!Instr)
|
||||
continue;
|
||||
if (OpValue == nullptr || Opcode == Instr->getOpcode())
|
||||
VecOp->andIRFlags(V);
|
||||
}
|
||||
}
|
||||
|
||||
@ -5656,20 +5656,22 @@ static bool TryToMergeLandingPad(LandingPadInst *LPad, BranchInst *BI,
|
||||
bool SimplifyCFGOpt::SimplifyUncondBranch(BranchInst *BI,
|
||||
IRBuilder<> &Builder) {
|
||||
BasicBlock *BB = BI->getParent();
|
||||
BasicBlock *Succ = BI->getSuccessor(0);
|
||||
|
||||
if (SinkCommon && SinkThenElseCodeToEnd(BI))
|
||||
return true;
|
||||
|
||||
// If the Terminator is the only non-phi instruction, simplify the block.
|
||||
// if LoopHeader is provided, check if the block is a loop header
|
||||
// (This is for early invocations before loop simplify and vectorization
|
||||
// to keep canonical loop forms for nested loops.
|
||||
// These blocks can be eliminated when the pass is invoked later
|
||||
// in the back-end.)
|
||||
// if LoopHeader is provided, check if the block or its successor is a loop
|
||||
// header (This is for early invocations before loop simplify and
|
||||
// vectorization to keep canonical loop forms for nested loops. These blocks
|
||||
// can be eliminated when the pass is invoked later in the back-end.)
|
||||
bool NeedCanonicalLoop =
|
||||
!LateSimplifyCFG &&
|
||||
(LoopHeaders && (LoopHeaders->count(BB) || LoopHeaders->count(Succ)));
|
||||
BasicBlock::iterator I = BB->getFirstNonPHIOrDbg()->getIterator();
|
||||
if (I->isTerminator() && BB != &BB->getParent()->getEntryBlock() &&
|
||||
(!LoopHeaders || !LoopHeaders->count(BB)) &&
|
||||
TryToSimplifyUncondBranchFromEmptyBlock(BB))
|
||||
!NeedCanonicalLoop && TryToSimplifyUncondBranchFromEmptyBlock(BB))
|
||||
return true;
|
||||
|
||||
// If the only instruction in the block is a seteq/setne comparison
|
||||
|
||||
@ -1752,6 +1752,7 @@ class Type : public ExtQualsTypeCommonBase {
|
||||
bool isTemplateTypeParmType() const; // C++ template type parameter
|
||||
bool isNullPtrType() const; // C++11 std::nullptr_t
|
||||
bool isAlignValT() const; // C++17 std::align_val_t
|
||||
bool isStdByteType() const; // C++17 std::byte
|
||||
bool isAtomicType() const; // C11 _Atomic()
|
||||
|
||||
#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
|
||||
|
||||
@ -1388,6 +1388,15 @@ static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
|
||||
llvm_unreachable("Invalid overloaded operator expression");
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#if _MSC_VER == 1911
|
||||
// Work around https://developercommunity.visualstudio.com/content/problem/84002/clang-cl-when-built-with-vc-2017-crashes-cause-vc.html
|
||||
// MSVC 2017 update 3 miscompiles this function, and a clang built with it
|
||||
// will crash in stage 2 of a bootstrap build.
|
||||
#pragma optimize("", off)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) {
|
||||
if (S->isTypeDependent()) {
|
||||
// Type-dependent operator calls are profiled like their underlying
|
||||
@ -1420,6 +1429,12 @@ void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) {
|
||||
ID.AddInteger(S->getOperator());
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#if _MSC_VER == 1911
|
||||
#pragma optimize("", on)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) {
|
||||
VisitCallExpr(S);
|
||||
}
|
||||
|
||||
@ -2313,6 +2313,15 @@ bool Type::isAlignValT() const {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Type::isStdByteType() const {
|
||||
if (auto *ET = getAs<EnumType>()) {
|
||||
auto *II = ET->getDecl()->getIdentifier();
|
||||
if (II && II->isStr("byte") && ET->getDecl()->isInStdNamespace())
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Type::isPromotableIntegerType() const {
|
||||
if (const BuiltinType *BT = getAs<BuiltinType>())
|
||||
switch (BT->getKind()) {
|
||||
|
||||
@ -516,7 +516,7 @@ std::vector<std::string> DiagnosticIDs::getDiagnosticFlags() {
|
||||
std::string Diag(DiagGroupNames + I + 1, DiagGroupNames[I]);
|
||||
I += DiagGroupNames[I] + 1;
|
||||
Res.push_back("-W" + Diag);
|
||||
Res.push_back("-Wno" + Diag);
|
||||
Res.push_back("-Wno-" + Diag);
|
||||
}
|
||||
|
||||
return Res;
|
||||
|
||||
@ -36,7 +36,7 @@ std::string getClangRepositoryPath() {
|
||||
|
||||
// If the SVN_REPOSITORY is empty, try to use the SVN keyword. This helps us
|
||||
// pick up a tag in an SVN export, for example.
|
||||
StringRef SVNRepository("$URL: https://llvm.org/svn/llvm-project/cfe/trunk/lib/Basic/Version.cpp $");
|
||||
StringRef SVNRepository("$URL: https://llvm.org/svn/llvm-project/cfe/branches/release_50/lib/Basic/Version.cpp $");
|
||||
if (URL.empty()) {
|
||||
URL = SVNRepository.slice(SVNRepository.find(':'),
|
||||
SVNRepository.find("/lib/Basic"));
|
||||
|
||||
@ -139,6 +139,12 @@ CodeGenTBAA::getTBAAInfo(QualType QTy) {
|
||||
}
|
||||
}
|
||||
|
||||
// C++1z [basic.lval]p10: "If a program attempts to access the stored value of
|
||||
// an object through a glvalue of other than one of the following types the
|
||||
// behavior is undefined: [...] a char, unsigned char, or std::byte type."
|
||||
if (Ty->isStdByteType())
|
||||
return MetadataCache[Ty] = getChar();
|
||||
|
||||
// Handle pointers.
|
||||
// TODO: Implement C++'s type "similarity" and consider dis-"similar"
|
||||
// pointers distinct.
|
||||
|
||||
@ -69,7 +69,6 @@
|
||||
#include "llvm/Support/PrettyStackTrace.h"
|
||||
#include "llvm/Support/Process.h"
|
||||
#include "llvm/Support/Program.h"
|
||||
#include "llvm/Support/TargetRegistry.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include <map>
|
||||
#include <memory>
|
||||
@ -1193,10 +1192,6 @@ bool Driver::HandleImmediateArgs(const Compilation &C) {
|
||||
if (C.getArgs().hasArg(options::OPT__version)) {
|
||||
// Follow gcc behavior and use stdout for --version and stderr for -v.
|
||||
PrintVersion(C, llvm::outs());
|
||||
|
||||
// Print registered targets.
|
||||
llvm::outs() << '\n';
|
||||
llvm::TargetRegistry::printRegisteredTargetsForVersion(llvm::outs());
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -1299,7 +1294,7 @@ bool Driver::HandleImmediateArgs(const Compilation &C) {
|
||||
std::sort(SuggestedCompletions.begin(), SuggestedCompletions.end(),
|
||||
[](StringRef A, StringRef B) { return A.compare_lower(B) < 0; });
|
||||
|
||||
llvm::outs() << llvm::join(SuggestedCompletions, " ") << '\n';
|
||||
llvm::outs() << llvm::join(SuggestedCompletions, "\n") << '\n';
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -76,7 +76,13 @@ typedef intptr_t _sleb128_t;
|
||||
typedef uintptr_t _uleb128_t;
|
||||
|
||||
struct _Unwind_Context;
|
||||
#if defined(__arm__) && !(defined(__USING_SJLJ_EXCEPTIONS__) || defined(__ARM_DWARF_EH___))
|
||||
struct _Unwind_Control_Block;
|
||||
typedef struct _Unwind_Control_Block _Unwind_Exception; /* Alias */
|
||||
#else
|
||||
struct _Unwind_Exception;
|
||||
typedef struct _Unwind_Exception _Unwind_Exception;
|
||||
#endif
|
||||
typedef enum {
|
||||
_URC_NO_REASON = 0,
|
||||
#if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) && \
|
||||
@ -109,8 +115,42 @@ typedef enum {
|
||||
} _Unwind_Action;
|
||||
|
||||
typedef void (*_Unwind_Exception_Cleanup_Fn)(_Unwind_Reason_Code,
|
||||
struct _Unwind_Exception *);
|
||||
_Unwind_Exception *);
|
||||
|
||||
#if defined(__arm__) && !(defined(__USING_SJLJ_EXCEPTIONS__) || defined(__ARM_DWARF_EH___))
|
||||
typedef struct _Unwind_Control_Block _Unwind_Control_Block;
|
||||
typedef uint32_t _Unwind_EHT_Header;
|
||||
|
||||
struct _Unwind_Control_Block {
|
||||
uint64_t exception_class;
|
||||
void (*exception_cleanup)(_Unwind_Reason_Code, _Unwind_Control_Block *);
|
||||
/* unwinder cache (private fields for the unwinder's use) */
|
||||
struct {
|
||||
uint32_t reserved1; /* forced unwind stop function, 0 if not forced */
|
||||
uint32_t reserved2; /* personality routine */
|
||||
uint32_t reserved3; /* callsite */
|
||||
uint32_t reserved4; /* forced unwind stop argument */
|
||||
uint32_t reserved5;
|
||||
} unwinder_cache;
|
||||
/* propagation barrier cache (valid after phase 1) */
|
||||
struct {
|
||||
uint32_t sp;
|
||||
uint32_t bitpattern[5];
|
||||
} barrier_cache;
|
||||
/* cleanup cache (preserved over cleanup) */
|
||||
struct {
|
||||
uint32_t bitpattern[4];
|
||||
} cleanup_cache;
|
||||
/* personality cache (for personality's benefit) */
|
||||
struct {
|
||||
uint32_t fnstart; /* function start address */
|
||||
_Unwind_EHT_Header *ehtp; /* pointer to EHT entry header word */
|
||||
uint32_t additional; /* additional data */
|
||||
uint32_t reserved1;
|
||||
} pr_cache;
|
||||
long long int : 0; /* force alignment of next item to 8-byte boundary */
|
||||
};
|
||||
#else
|
||||
struct _Unwind_Exception {
|
||||
_Unwind_Exception_Class exception_class;
|
||||
_Unwind_Exception_Cleanup_Fn exception_cleanup;
|
||||
@ -120,23 +160,24 @@ struct _Unwind_Exception {
|
||||
* aligned". GCC has interpreted this to mean "use the maximum useful
|
||||
* alignment for the target"; so do we. */
|
||||
} __attribute__((__aligned__));
|
||||
#endif
|
||||
|
||||
typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)(int, _Unwind_Action,
|
||||
_Unwind_Exception_Class,
|
||||
struct _Unwind_Exception *,
|
||||
_Unwind_Exception *,
|
||||
struct _Unwind_Context *,
|
||||
void *);
|
||||
|
||||
typedef _Unwind_Reason_Code (*_Unwind_Personality_Fn)(
|
||||
int, _Unwind_Action, _Unwind_Exception_Class, struct _Unwind_Exception *,
|
||||
struct _Unwind_Context *);
|
||||
typedef _Unwind_Reason_Code (*_Unwind_Personality_Fn)(int, _Unwind_Action,
|
||||
_Unwind_Exception_Class,
|
||||
_Unwind_Exception *,
|
||||
struct _Unwind_Context *);
|
||||
typedef _Unwind_Personality_Fn __personality_routine;
|
||||
|
||||
typedef _Unwind_Reason_Code (*_Unwind_Trace_Fn)(struct _Unwind_Context *,
|
||||
void *);
|
||||
|
||||
#if defined(__arm__) && !defined(__APPLE__)
|
||||
|
||||
#if defined(__arm__) && !(defined(__USING_SJLJ_EXCEPTIONS__) || defined(__ARM_DWARF_EH___))
|
||||
typedef enum {
|
||||
_UVRSC_CORE = 0, /* integer register */
|
||||
_UVRSC_VFP = 1, /* vfp */
|
||||
@ -158,14 +199,12 @@ typedef enum {
|
||||
_UVRSR_FAILED = 2
|
||||
} _Unwind_VRS_Result;
|
||||
|
||||
#if !defined(__USING_SJLJ_EXCEPTIONS__) && !defined(__ARM_DWARF_EH__)
|
||||
typedef uint32_t _Unwind_State;
|
||||
#define _US_VIRTUAL_UNWIND_FRAME ((_Unwind_State)0)
|
||||
#define _US_UNWIND_FRAME_STARTING ((_Unwind_State)1)
|
||||
#define _US_UNWIND_FRAME_RESUME ((_Unwind_State)2)
|
||||
#define _US_ACTION_MASK ((_Unwind_State)3)
|
||||
#define _US_FORCE_UNWIND ((_Unwind_State)8)
|
||||
#endif
|
||||
|
||||
_Unwind_VRS_Result _Unwind_VRS_Get(struct _Unwind_Context *__context,
|
||||
_Unwind_VRS_RegClass __regclass,
|
||||
@ -224,13 +263,12 @@ _Unwind_Ptr _Unwind_GetRegionStart(struct _Unwind_Context *);
|
||||
|
||||
/* DWARF EH functions; currently not available on Darwin/ARM */
|
||||
#if !defined(__APPLE__) || !defined(__arm__)
|
||||
|
||||
_Unwind_Reason_Code _Unwind_RaiseException(struct _Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_ForcedUnwind(struct _Unwind_Exception *,
|
||||
_Unwind_Stop_Fn, void *);
|
||||
void _Unwind_DeleteException(struct _Unwind_Exception *);
|
||||
void _Unwind_Resume(struct _Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_Resume_or_Rethrow(struct _Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_ForcedUnwind(_Unwind_Exception *, _Unwind_Stop_Fn,
|
||||
void *);
|
||||
void _Unwind_DeleteException(_Unwind_Exception *);
|
||||
void _Unwind_Resume(_Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_Resume_or_Rethrow(_Unwind_Exception *);
|
||||
|
||||
#endif
|
||||
|
||||
@ -241,11 +279,11 @@ typedef struct SjLj_Function_Context *_Unwind_FunctionContext_t;
|
||||
|
||||
void _Unwind_SjLj_Register(_Unwind_FunctionContext_t);
|
||||
void _Unwind_SjLj_Unregister(_Unwind_FunctionContext_t);
|
||||
_Unwind_Reason_Code _Unwind_SjLj_RaiseException(struct _Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_SjLj_ForcedUnwind(struct _Unwind_Exception *,
|
||||
_Unwind_Reason_Code _Unwind_SjLj_RaiseException(_Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_SjLj_ForcedUnwind(_Unwind_Exception *,
|
||||
_Unwind_Stop_Fn, void *);
|
||||
void _Unwind_SjLj_Resume(struct _Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_SjLj_Resume_or_Rethrow(struct _Unwind_Exception *);
|
||||
void _Unwind_SjLj_Resume(_Unwind_Exception *);
|
||||
_Unwind_Reason_Code _Unwind_SjLj_Resume_or_Rethrow(_Unwind_Exception *);
|
||||
|
||||
void *_Unwind_FindEnclosingFunction(void *);
|
||||
|
||||
|
||||
@ -2398,6 +2398,37 @@ formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
|
||||
return Result;
|
||||
}
|
||||
|
||||
static std::string GetDefaultValueString(const ParmVarDecl *Param,
|
||||
const SourceManager &SM,
|
||||
const LangOptions &LangOpts) {
|
||||
const Expr *defaultArg = Param->getDefaultArg();
|
||||
if (!defaultArg)
|
||||
return "";
|
||||
const SourceRange SrcRange = defaultArg->getSourceRange();
|
||||
CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
|
||||
bool Invalid = CharSrcRange.isInvalid();
|
||||
if (Invalid)
|
||||
return "";
|
||||
StringRef srcText = Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
|
||||
if (Invalid)
|
||||
return "";
|
||||
|
||||
if (srcText.empty() || srcText == "=") {
|
||||
// Lexer can't determine the value.
|
||||
// This happens if the code is incorrect (for example class is forward declared).
|
||||
return "";
|
||||
}
|
||||
std::string DefValue(srcText.str());
|
||||
// FIXME: remove this check if the Lexer::getSourceText value is fixed and
|
||||
// this value always has (or always does not have) '=' in front of it
|
||||
if (DefValue.at(0) != '=') {
|
||||
// If we don't have '=' in front of value.
|
||||
// Lexer returns built-in types values without '=' and user-defined types values with it.
|
||||
return " = " + DefValue;
|
||||
}
|
||||
return " " + DefValue;
|
||||
}
|
||||
|
||||
/// \brief Add function parameter chunks to the given code completion string.
|
||||
static void AddFunctionParameterChunks(Preprocessor &PP,
|
||||
const PrintingPolicy &Policy,
|
||||
@ -2431,6 +2462,8 @@ static void AddFunctionParameterChunks(Preprocessor &PP,
|
||||
|
||||
// Format the placeholder string.
|
||||
std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
|
||||
if (Param->hasDefaultArg())
|
||||
PlaceholderStr += GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
|
||||
|
||||
if (Function->isVariadic() && P == N - 1)
|
||||
PlaceholderStr += ", ...";
|
||||
@ -3012,10 +3045,14 @@ static void AddOverloadParameterChunks(ASTContext &Context,
|
||||
|
||||
// Format the placeholder string.
|
||||
std::string Placeholder;
|
||||
if (Function)
|
||||
Placeholder = FormatFunctionParameter(Policy, Function->getParamDecl(P));
|
||||
else
|
||||
if (Function) {
|
||||
const ParmVarDecl *Param = Function->getParamDecl(P);
|
||||
Placeholder = FormatFunctionParameter(Policy, Param);
|
||||
if (Param->hasDefaultArg())
|
||||
Placeholder += GetDefaultValueString(Param, Context.getSourceManager(), Context.getLangOpts());
|
||||
} else {
|
||||
Placeholder = Prototype->getParamType(P).getAsString(Policy);
|
||||
}
|
||||
|
||||
if (P == CurrentArg)
|
||||
Result.AddCurrentParameterChunk(
|
||||
|
||||
@ -328,7 +328,8 @@ static bool format(StringRef FileName) {
|
||||
} // namespace format
|
||||
} // namespace clang
|
||||
|
||||
static void PrintVersion(raw_ostream &OS) {
|
||||
static void PrintVersion() {
|
||||
raw_ostream &OS = outs();
|
||||
OS << clang::getClangToolFullVersion("clang-format") << '\n';
|
||||
}
|
||||
|
||||
|
||||
@ -130,7 +130,7 @@ struct Configuration {
|
||||
std::map<StringRef, uint32_t> Section;
|
||||
|
||||
// Options for manifest files.
|
||||
ManifestKind Manifest = SideBySide;
|
||||
ManifestKind Manifest = No;
|
||||
int ManifestID = 1;
|
||||
StringRef ManifestDependency;
|
||||
bool ManifestUAC = true;
|
||||
|
||||
@ -899,18 +899,25 @@ void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
|
||||
for (auto *Arg : Args.filtered(OPT_section))
|
||||
parseSection(Arg->getValue());
|
||||
|
||||
// Handle /manifest
|
||||
if (auto *Arg = Args.getLastArg(OPT_manifest_colon))
|
||||
parseManifest(Arg->getValue());
|
||||
// Handle /manifestdependency. This enables /manifest unless /manifest:no is
|
||||
// also passed.
|
||||
if (auto *Arg = Args.getLastArg(OPT_manifestdependency)) {
|
||||
Config->ManifestDependency = Arg->getValue();
|
||||
Config->Manifest = Configuration::SideBySide;
|
||||
}
|
||||
|
||||
// Handle /manifest and /manifest:
|
||||
if (auto *Arg = Args.getLastArg(OPT_manifest, OPT_manifest_colon)) {
|
||||
if (Arg->getOption().getID() == OPT_manifest)
|
||||
Config->Manifest = Configuration::SideBySide;
|
||||
else
|
||||
parseManifest(Arg->getValue());
|
||||
}
|
||||
|
||||
// Handle /manifestuac
|
||||
if (auto *Arg = Args.getLastArg(OPT_manifestuac))
|
||||
parseManifestUAC(Arg->getValue());
|
||||
|
||||
// Handle /manifestdependency
|
||||
if (auto *Arg = Args.getLastArg(OPT_manifestdependency))
|
||||
Config->ManifestDependency = Arg->getValue();
|
||||
|
||||
// Handle /manifestfile
|
||||
if (auto *Arg = Args.getLastArg(OPT_manifestfile))
|
||||
Config->ManifestFile = Arg->getValue();
|
||||
@ -919,6 +926,11 @@ void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
|
||||
for (auto *Arg : Args.filtered(OPT_manifestinput))
|
||||
Config->ManifestInput.push_back(Arg->getValue());
|
||||
|
||||
if (!Config->ManifestInput.empty() &&
|
||||
Config->Manifest != Configuration::Embed) {
|
||||
fatal("/MANIFESTINPUT: requires /MANIFEST:EMBED");
|
||||
}
|
||||
|
||||
// Handle miscellaneous boolean flags.
|
||||
if (Args.hasArg(OPT_allowisolation_no))
|
||||
Config->AllowIsolation = false;
|
||||
|
||||
@ -91,8 +91,7 @@ template <class ELFT> void elf::ObjectFile<ELFT>::initializeDwarfLine() {
|
||||
template <class ELFT>
|
||||
Optional<DILineInfo> elf::ObjectFile<ELFT>::getDILineInfo(InputSectionBase *S,
|
||||
uint64_t Offset) {
|
||||
if (!DwarfLine)
|
||||
initializeDwarfLine();
|
||||
llvm::call_once(InitDwarfLine, [this]() { initializeDwarfLine(); });
|
||||
|
||||
// The offset to CU is 0.
|
||||
const DWARFDebugLine::LineTable *Tbl = DwarfLine->getLineTable(0);
|
||||
|
||||
@ -24,6 +24,7 @@
|
||||
#include "llvm/Object/Archive.h"
|
||||
#include "llvm/Object/ELF.h"
|
||||
#include "llvm/Object/IRObjectFile.h"
|
||||
#include "llvm/Support/Threading.h"
|
||||
|
||||
#include <map>
|
||||
|
||||
@ -211,6 +212,7 @@ template <class ELFT> class ObjectFile : public ELFFileBase<ELFT> {
|
||||
// single object file, so we cache debugging information in order to
|
||||
// parse it only once for each object file we link.
|
||||
std::unique_ptr<llvm::DWARFDebugLine> DwarfLine;
|
||||
llvm::once_flag InitDwarfLine;
|
||||
};
|
||||
|
||||
// LazyObjectFile is analogous to ArchiveFile in the sense that
|
||||
|
||||
@ -211,6 +211,12 @@ static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
|
||||
// Find an existing symbol or create and insert a new one.
|
||||
template <class ELFT>
|
||||
std::pair<Symbol *, bool> SymbolTable<ELFT>::insert(StringRef Name) {
|
||||
// <name>@@<version> means the symbol is the default version. In that
|
||||
// case <name>@@<version> will be used to resolve references to <name>.
|
||||
size_t Pos = Name.find("@@");
|
||||
if (Pos != StringRef::npos)
|
||||
Name = Name.take_front(Pos);
|
||||
|
||||
auto P = Symtab.insert(
|
||||
{CachedHashStringRef(Name), SymIndex((int)SymVector.size(), false)});
|
||||
SymIndex &V = P.first->second;
|
||||
@ -312,15 +318,36 @@ Symbol *SymbolTable<ELFT>::addUndefined(StringRef Name, bool IsLocal,
|
||||
return S;
|
||||
}
|
||||
|
||||
// Using .symver foo,foo@@VER unfortunately creates two symbols: foo and
|
||||
// foo@@VER. We want to effectively ignore foo, so give precedence to
|
||||
// foo@@VER.
|
||||
// FIXME: If users can transition to using
|
||||
// .symver foo,foo@@@VER
|
||||
// we can delete this hack.
|
||||
static int compareVersion(Symbol *S, StringRef Name) {
|
||||
if (Name.find("@@") != StringRef::npos &&
|
||||
S->body()->getName().find("@@") == StringRef::npos)
|
||||
return 1;
|
||||
if (Name.find("@@") == StringRef::npos &&
|
||||
S->body()->getName().find("@@") != StringRef::npos)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// We have a new defined symbol with the specified binding. Return 1 if the new
|
||||
// symbol should win, -1 if the new symbol should lose, or 0 if both symbols are
|
||||
// strong defined symbols.
|
||||
static int compareDefined(Symbol *S, bool WasInserted, uint8_t Binding) {
|
||||
static int compareDefined(Symbol *S, bool WasInserted, uint8_t Binding,
|
||||
StringRef Name) {
|
||||
if (WasInserted)
|
||||
return 1;
|
||||
SymbolBody *Body = S->body();
|
||||
if (!Body->isInCurrentDSO())
|
||||
return 1;
|
||||
|
||||
if (int R = compareVersion(S, Name))
|
||||
return R;
|
||||
|
||||
if (Binding == STB_WEAK)
|
||||
return -1;
|
||||
if (S->isWeak())
|
||||
@ -333,8 +360,9 @@ static int compareDefined(Symbol *S, bool WasInserted, uint8_t Binding) {
|
||||
// is a conflict. If the new symbol wins, also update the binding.
|
||||
template <typename ELFT>
|
||||
static int compareDefinedNonCommon(Symbol *S, bool WasInserted, uint8_t Binding,
|
||||
bool IsAbsolute, typename ELFT::uint Value) {
|
||||
if (int Cmp = compareDefined(S, WasInserted, Binding)) {
|
||||
bool IsAbsolute, typename ELFT::uint Value,
|
||||
StringRef Name) {
|
||||
if (int Cmp = compareDefined(S, WasInserted, Binding, Name)) {
|
||||
if (Cmp > 0)
|
||||
S->Binding = Binding;
|
||||
return Cmp;
|
||||
@ -362,7 +390,7 @@ Symbol *SymbolTable<ELFT>::addCommon(StringRef N, uint64_t Size,
|
||||
bool WasInserted;
|
||||
std::tie(S, WasInserted) = insert(N, Type, getVisibility(StOther),
|
||||
/*CanOmitFromDynSym*/ false, File);
|
||||
int Cmp = compareDefined(S, WasInserted, Binding);
|
||||
int Cmp = compareDefined(S, WasInserted, Binding, N);
|
||||
if (Cmp > 0) {
|
||||
S->Binding = Binding;
|
||||
replaceBody<DefinedCommon>(S, N, Size, Alignment, StOther, Type, File);
|
||||
@ -439,7 +467,7 @@ Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
|
||||
std::tie(S, WasInserted) = insert(Name, Type, getVisibility(StOther),
|
||||
/*CanOmitFromDynSym*/ false, File);
|
||||
int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, Binding,
|
||||
Section == nullptr, Value);
|
||||
Section == nullptr, Value, Name);
|
||||
if (Cmp > 0)
|
||||
replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type,
|
||||
Value, Size, Section, File);
|
||||
@ -485,7 +513,7 @@ Symbol *SymbolTable<ELFT>::addBitcode(StringRef Name, uint8_t Binding,
|
||||
std::tie(S, WasInserted) =
|
||||
insert(Name, Type, getVisibility(StOther), CanOmitFromDynSym, F);
|
||||
int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, Binding,
|
||||
/*IsAbs*/ false, /*Value*/ 0);
|
||||
/*IsAbs*/ false, /*Value*/ 0, Name);
|
||||
if (Cmp > 0)
|
||||
replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type, 0, 0,
|
||||
nullptr, F);
|
||||
@ -717,32 +745,9 @@ void SymbolTable<ELFT>::assignWildcardVersion(SymbolVersion Ver,
|
||||
B->symbol()->VersionId = VersionId;
|
||||
}
|
||||
|
||||
static bool isDefaultVersion(SymbolBody *B) {
|
||||
return B->isInCurrentDSO() && B->getName().find("@@") != StringRef::npos;
|
||||
}
|
||||
|
||||
// This function processes version scripts by updating VersionId
|
||||
// member of symbols.
|
||||
template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
|
||||
// Symbol themselves might know their versions because symbols
|
||||
// can contain versions in the form of <name>@<version>.
|
||||
// Let them parse and update their names to exclude version suffix.
|
||||
for (Symbol *Sym : SymVector) {
|
||||
SymbolBody *Body = Sym->body();
|
||||
bool IsDefault = isDefaultVersion(Body);
|
||||
Body->parseSymbolVersion();
|
||||
|
||||
if (!IsDefault)
|
||||
continue;
|
||||
|
||||
// <name>@@<version> means the symbol is the default version. If that's the
|
||||
// case, the symbol is not used only to resolve <name> of version <version>
|
||||
// but also undefined unversioned symbols with name <name>.
|
||||
SymbolBody *S = find(Body->getName());
|
||||
if (S && S->isUndefined())
|
||||
S->copy(Body);
|
||||
}
|
||||
|
||||
// Handle edge cases first.
|
||||
handleAnonymousVersion();
|
||||
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
|
||||
#include "ArchHandler.h"
|
||||
#include "File.h"
|
||||
#include "MachONormalizedFileBinaryUtils.h"
|
||||
#include "MachOPasses.h"
|
||||
#include "lld/Core/DefinedAtom.h"
|
||||
#include "lld/Core/File.h"
|
||||
@ -29,7 +30,7 @@ namespace mach_o {
|
||||
///
|
||||
class ObjCImageInfoAtom : public SimpleDefinedAtom {
|
||||
public:
|
||||
ObjCImageInfoAtom(const File &file,
|
||||
ObjCImageInfoAtom(const File &file, bool isBig,
|
||||
MachOLinkingContext::ObjCConstraint objCConstraint,
|
||||
uint32_t swiftVersion)
|
||||
: SimpleDefinedAtom(file) {
|
||||
@ -54,6 +55,8 @@ class ObjCImageInfoAtom : public SimpleDefinedAtom {
|
||||
}
|
||||
|
||||
Data.info.flags |= (swiftVersion << 8);
|
||||
|
||||
normalized::write32(Data.bytes + 4, Data.info.flags, isBig);
|
||||
}
|
||||
|
||||
~ObjCImageInfoAtom() override = default;
|
||||
@ -109,7 +112,8 @@ class ObjCPass : public Pass {
|
||||
private:
|
||||
|
||||
const DefinedAtom* getImageInfo() {
|
||||
return new (_file.allocator()) ObjCImageInfoAtom(_file,
|
||||
bool IsBig = MachOLinkingContext::isBigEndian(_ctx.arch());
|
||||
return new (_file.allocator()) ObjCImageInfoAtom(_file, IsBig,
|
||||
_ctx.objcConstraint(),
|
||||
_ctx.swiftVersion());
|
||||
}
|
||||
|
||||
@ -162,7 +162,7 @@ class LLDB_API SBAttachInfo {
|
||||
/// Get the listener that will be used to receive process events.
|
||||
///
|
||||
/// If no listener has been set via a call to
|
||||
/// SBLaunchInfo::SetListener(), then an invalid SBListener will be
|
||||
/// SBAttachInfo::SetListener(), then an invalid SBListener will be
|
||||
/// returned (SBListener::IsValid() will return false). If a listener
|
||||
/// has been set, then the valid listener object will be returned.
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
@ -154,9 +154,9 @@ class LLDB_API SBBreakpointList {
|
||||
|
||||
SBBreakpoint FindBreakpointByID(lldb::break_id_t);
|
||||
|
||||
void Append(const SBBreakpoint &sb_file);
|
||||
void Append(const SBBreakpoint &sb_bkpt);
|
||||
|
||||
bool AppendIfUnique(const SBBreakpoint &sb_file);
|
||||
bool AppendIfUnique(const SBBreakpoint &sb_bkpt);
|
||||
|
||||
void AppendByID(lldb::break_id_t id);
|
||||
|
||||
|
||||
@ -350,7 +350,7 @@ class LLDB_API SBProcess {
|
||||
|
||||
bool IsInstrumentationRuntimePresent(InstrumentationRuntimeType type);
|
||||
|
||||
// Save the state of the process in a core file (or mini dump on Windows).
|
||||
/// Save the state of the process in a core file (or mini dump on Windows).
|
||||
lldb::SBError SaveCore(const char *file_name);
|
||||
|
||||
//------------------------------------------------------------------
|
||||
|
||||
@ -8,4 +8,4 @@
|
||||
|
||||
#define CLANG_VENDOR "FreeBSD "
|
||||
|
||||
#define SVN_REVISION "308421"
|
||||
#define SVN_REVISION "309439"
|
||||
|
||||
@ -57,4 +57,9 @@
|
||||
/* enable x86 relax relocations by default */
|
||||
#define ENABLE_X86_RELAX_RELOCATIONS 0
|
||||
|
||||
/* Enable each functionality of modules */
|
||||
/* #undef CLANG_ENABLE_ARCMT */
|
||||
/* #undef CLANG_ENABLE_OBJC_REWRITER */
|
||||
/* #undef CLANG_ENABLE_STATIC_ANALYZER */
|
||||
|
||||
#endif
|
||||
|
||||
@ -4,5 +4,5 @@
|
||||
#define LLD_VERSION_STRING "5.0.0"
|
||||
#define LLD_VERSION_MAJOR 5
|
||||
#define LLD_VERSION_MINOR 0
|
||||
#define LLD_REVISION_STRING "308421"
|
||||
#define LLD_REVISION_STRING "309439"
|
||||
#define LLD_REPOSITORY_STRING "FreeBSD"
|
||||
|
||||
@ -1,2 +1,2 @@
|
||||
/* $FreeBSD$ */
|
||||
#define LLVM_REVISION "svn-r308421"
|
||||
#define LLVM_REVISION "svn-r309439"
|
||||
|
||||
@ -1304,7 +1304,7 @@ CFLAGS.DlltoolDriver.cpp+= -I${.OBJDIR}/llvm-dlltool
|
||||
|
||||
beforebuild:
|
||||
# 20170724 remove stale Options.inc file, of which there are two different
|
||||
# versions after r308421, one for llvm-lib, one for llvm-dlltool
|
||||
# versions after upstream r308421, one for llvm-lib, one for llvm-dlltool
|
||||
.for f in Options.inc
|
||||
.if exists(${f}) || exists(${f}.d)
|
||||
@echo Removing stale generated ${f} files
|
||||
|
||||
Loading…
Reference in New Issue
Block a user