reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

  370     max(const _Tp&, const _Tp&);

References

  885     size_t NewCapacity = std::max<size_t>(NumBitWords(NewSize), Bits.size() * 2);

  776     allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
  798       NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
 1010       AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));

  509     resize(std::max(size(), RHS.size()));
  558     resize(std::max(size(), RHS.size()));
  571     resize(std::max(size(), RHS.size()));

  239   NewCapacity = std::min(std::max(NewCapacity, MinSize), size_t(UINT32_MAX));

  701       End = std::min(std::max(Start, End), Length);

 1395             std::max(MaxFrequency, Graph->getBlockFreq(N).getFrequency());

  122     return upperBound(std::max(getValue(), Other.getValue()));

  657     ReservedSpace = std::max(E + E / 2, 2u);

  632           MinRequiredSize = std::max(MinRequiredSize, ElementMinRequiredSize);

 1184         ScalarCalls = std::max(ScalarCalls, RetTy->getVectorNumElements());
 1193           ScalarCalls = std::max(ScalarCalls, Ty->getVectorNumElements());
 1524           ScalarCalls = std::max(ScalarCalls, Tys[i]->getVectorNumElements());

  431     MaxStackArgAlign = std::max(CheckedAlignment, MaxStackArgAlign);

  371       MaxMOV = std::max(MaxMOV, SSD->getMOV(SU));
  372       MaxDepth = std::max(MaxDepth, SSD->getDepth(SU));

  712     return std::max(ExpectedLatency, CurrCycle);
  735     return std::max(CurrCycle * SchedModel->getLatencyFactor(),

  113       NumStages = std::max(NumStages, KV.second);

   68       WorstRow = std::max(WorstRow, RowCount);
   72     WorstCol = std::max(WorstCol, WorstColCountForCurRow);

  257             std::max(MaxEncodingStringLength,

   67     addNode(std::max(AllocUnit, Size));
   86     addNode(std::max(AllocUnit, Size));

   78     Hotness = std::max(Hotness, static_cast<uint32_t>(OtherHotness));

  156       Latency = std::max(Latency, StartCycle + IS->getCycles());

   74     return std::max(Quantity, 1U);

  780   return std::max(X, Y) - std::min(X, Y);

   77     IndentLevel = std::max(0, IndentLevel - Levels);

 1219     Assumed = std::max(std::min(Assumed, Value), Known);
 1226     Assumed = std::max(Value, Assumed);
 1227     Known = std::max(Value, Known);
 1237     Known = std::max(Known, KnownValue);
 1238     Assumed = std::max(Assumed, AssumedValue);

  252     DerefBytes = std::max(DerefBytes, LocSize.getValue());
 1117     unsigned BitWidth = std::max(C1->getBitWidth(), C2->getBitWidth());

  261     W.Amount = std::max(UINT64_C(1), shiftRightAndRound(W.Amount, Shift));
  488     BFI.Freqs[Index].Integer = std::max(UINT64_C(1), Scaled.toInt<uint64_t>());
  538     Max = std::max(Max, Freqs[Index].Scaled);

  876     return B ? std::max(A, B.getValue()) : A;
 1328     Cost -= std::max(0, CA.getThreshold() - CA.getCost());
 1937   return Cost < std::max(1, Threshold);

 1559   unsigned MinNumIter = std::max(ForcedFactor * ForcedUnroll, 2U);

 3113           for (int z = std::max(y-x, y-(int)AddRec->getNumOperands()+1),
 8497     unsigned W = std::max(X->getBitWidth(), Y->getBitWidth());

  356   unsigned LeadZ =  std::max(Known.countMinLeadingZeros() +
 1076             std::max(Known.countMinLeadingOnes(), Known2.countMinLeadingOnes());
 1085         MaxHighZeros = std::max(Known.countMinLeadingZeros(),
 1094           std::max(Known.countMinLeadingOnes(), Known2.countMinLeadingOnes());
 1099           std::max(Known.countMinLeadingZeros(), Known2.countMinLeadingZeros());
 1285         std::max(Known.countMinLeadingZeros(), Known2.countMinLeadingZeros());
 1548           LeadingKnown = std::max(Known.countMinLeadingOnes(),
 1551           LeadingKnown = std::max(Known.countMinLeadingZeros(),
 2449         return std::max(NumrBits, ResBits);
 2660   return std::max(FirstAnswer, Known.countMinSignBits());

 7369     Max = std::max(Max, Index);

 1170     MaxAlignment = std::max(MaxAlignment, GV.getAlignment());
 1171     MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV.getValueType()));
 1183     MaxAlignment = std::max(MaxAlignment, F.getAlignment());

   51     BucketCount = std::max<uint32_t>(UniqueHashCount, 1);

  206     Asm->EmitAlignment(std::max(Asm->MF->getAlignment(), MBB.getAlignment()),

 5164         std::max((long long)0, (TotalCreatedInstsCost - ExtCost));
 5852     uint64_t Max = std::max(TrueWeight, FalseWeight);

  248         std::max(Known.countMinLeadingZeros() + Known2.countMinLeadingZeros(),

  232   Size = std::max(Size, 1u);
  429     auto SuccSize = std::max<uint32_t>(succ_size(SrcBB), 1);
 1137     DstAlign = std::max<unsigned>(MCI->getDestAlignment(), 1);
 1138     SrcAlign = std::max<unsigned>(MCI->getSourceAlignment(), 1);
 1140     DstAlign = std::max<unsigned>(MMI->getDestAlignment(), 1);
 1141     SrcAlign = std::max<unsigned>(MMI->getSourceAlignment(), 1);
 1144     DstAlign = std::max<unsigned>(MSI->getDestAlignment(), 1);
 1805       std::max((unsigned)DL->getPrefTypeAlignment(Ty), AI.getAlignment());

   51         std::max(1u << Log2_32_Ceil(Ty.getScalarSizeInBits()), Min);
   61         std::max(1u << Log2_32_Ceil(VecTy.getNumElements()), Min);

  698                      ? std::max(OpInfo.getGenericTypeIndex() + 1U, Acc)
  705                      ? std::max(OpInfo.getGenericImmIndex() + 1U, Acc)

  553         std::max(OrigValueBitWidth, PartMap.getHighBitIdx() + 1);

  481       MaxAlign = std::max(MaxAlign, Alignment);

  551     return Polynomial(A - o.A, std::max(ErrorMSBs, o.ErrorMSBs));

  169     S->end = std::max(NewEnd, std::prev(MergeTo)->end);
  467       SlotIndex Def = std::max(I->start, J->start);
 1221     Seg.end = std::max(Seg.end, ReadI->end);
 1228     Seg.end = std::max(Spills.back().end, Seg.end);
 1234     WriteI[-1].end = std::max(WriteI[-1].end, Seg.end);

 1240         = std::max(OldIdxIn->start.getDeadSlot(),

  154   MaxAlign = std::max(MaxAlign, Align);

  158   Align MaxAlignment(std::max(DL.getABITypeAlignment(WordType),

  832     BlockFrequency DupCost = Qout + QinU + std::max(Qin, F) * VProb;
  874         (P + V), (Qout + std::max(Qin, F) * VProb + std::min(Qin, F) * UProb),
  879                           std::max(Qin, F) * UProb),
 2322       HeaderFallThroughCost = std::max(HeaderFallThroughCost, FallThruCost);
 2338         LargestExitEdgeProb = std::max(LargestExitEdgeProb, SuccProb);

  199       IDepth = std::max(IDepth, DepthOp + LatencyOp);
  244     NewRootLatency = std::max(NewRootLatency, LatencyOp);

  162     MaxAlign = std::max(Align, MaxAlign);
  182   StackAlign = std::max(StackAlign, MaxAlign);
  202         MaxCallFrameSize = std::max(MaxCallFrameSize, Size);

  181     Alignment = std::max(Alignment,

 1255     int64_t MaxOffset = std::max(OffsetA, OffsetB);

  413     MII = std::max(ResMII, RecMII);
 1389             std::max(zeroLatencyDepth, getZeroLatencyDepth(pred) + 1);
 1392       asap = std::max(asap, (int)(getASAP(pred) + IP->getLatency() -
 1395     maxASAP = std::max(maxASAP, asap);
 1413             std::max(zeroLatencyHeight, getZeroLatencyHeight(succ) + 1);
 2008         SchedStart = std::max(SchedStart, LateStart - (int)II + 1);
 2375     LateCycle = std::max(LateCycle, it->second);
 2416             *MaxEarlyStart = std::max(*MaxEarlyStart, EarlyStart);
 2443               *MaxStart = std::max(*MaxStart, Start);
 2448             *MaxEarlyStart = std::max(*MaxEarlyStart, EarlyStart);

 2026         MaxObservedStall = std::max(Cycles, MaxObservedStall);
 2096     MaxObservedStall = std::max(ReadyCycle - CurrCycle, MaxObservedStall);
 2285                 std::max(ReservedUntil, NextCycle + PI->Cycles);
 2483   RemLatency = std::max(RemLatency,
 2485   RemLatency = std::max(RemLatency,
 2819     std::max(Rem.CyclicCritPath * SchedModel->getLatencyFactor(),
 3286     SU->TopReadyCycle = std::max(SU->TopReadyCycle, Top.getCurrCycle());
 3291     SU->BotReadyCycle = std::max(SU->BotReadyCycle, Bot.getCurrCycle());
 3449   SU->TopReadyCycle = std::max(SU->TopReadyCycle, Top.getCurrCycle());

  776     MaxLen = std::max(MaxLen, Len);
  805     Cycle = std::max(Cycle, DepCycle);
  813     TBI.CriticalPath = std::max(TBI.CriticalPath, Cycle + MICycles.Height);
  925       Height = std::max(Height, DepHeight);
 1127       TBI.CriticalPath = std::max(TBI.CriticalPath, Cycle + MICycles.Depth);
 1152     TBI.CriticalPath = std::max(TBI.CriticalPath,
 1204       PRMax = std::max(PRMax, PRDepths[K] + PRCycles[K]);
 1207       PRMax = std::max(PRMax, PRDepths[K]);
 1220   return std::max(Instrs, PRMax);
 1259     PRMax = std::max(PRMax, PRCycles);
 1274   return std::max(Instrs, PRMax);

  933     Types.resize(std::max(TypeIdx + 1, Types.size()));

   99         MaxDiff = std::max(Diff, MaxDiff);
  416       MaxPhis = std::max((int)MaxPhis - (int)LoopValStage, 1);

  645   MaxAlign = std::max(MaxAlign, Align);
  919     MaxAlign = std::max(Align, MaxAlign);
 1079     StackAlign = std::max(StackAlign, MaxAlign);

   66       LiveRegs[Unit] = std::max(LiveRegs[Unit], Incoming[Unit]);
  187     LatestDef = std::max(LatestDef, DefRes);

  937       Cost.MaxWeight = std::max(Cost.MaxWeight, Intf->weight);
  997       Cost.MaxWeight = std::max(Cost.MaxWeight, Intf->weight);
 2192         GapWeight[Gap] = std::max(GapWeight[Gap], weight);
 2395               MaxGap = std::max(MaxGap, GapWeight[i]);
 2409       MaxGap = std::max(MaxGap, GapWeight[SplitAfter++]);
 2848       std::max((unsigned)CSRFirstTimeCost, TRI->getCSRFirstUseCost()));

  375         IEdgeKey EK(std::min(NId, MId), std::max(NId, MId));

 3165             LE = LE.isValid() ? std::max(LE, I->end) : I->end;

  166         std::max(P.MaxSetPressure[*PSetI], CurrSetPressure[*PSetI]);

  504         std::max(DL.getPrefTypeAlignment(Ty), StackGuardSlot->getAlignment());
  516     unsigned Align = std::max((unsigned)DL.getPrefTypeAlignment(Ty),
  529         std::max((unsigned)DL.getPrefTypeAlignment(Ty), AI->getAlignment());
  660     unsigned Align = std::max(
  661         std::max((unsigned)DL.getPrefTypeAlignment(Ty), AI->getAlignment()),

   45   MaxAlignment = std::max(MaxAlignment, Alignment);

  275         MaxPredDepth = std::max(MaxPredDepth,
  306         MaxSuccHeight = std::max(MaxSuccHeight,

 1389           C.Level = std::max(C.Level, Depth);
 1491       std::max(SubtreeConnectLevels[C.TreeID], C.Level);

  797   unsigned Bits = Offset + std::max(LHS.getBitWidth(), RHS.getBitWidth());
15904           std::max(LastLegalVectorType, LastLegalIntegerType);
17454       MaxIndex = std::max(MaxIndex, Index);

  138           std::max((unsigned)MF->getDataLayout().getPrefTypeAlignment(Ty),

  516         MaxNest = std::max(MaxNest, NestLevel);
 1628       AdvanceToCycle(std::max(CurCycle + 1, MinAvailableCycle));

 1949       std::max((unsigned)getDataLayout().getPrefTypeAlignment(Ty), minAlign);
 1956   unsigned Bytes = std::max(VT1.getStoreSize(), VT2.getStoreSize());
 1961       std::max(DL.getPrefTypeAlignment(Ty1), DL.getPrefTypeAlignment(Ty2));
 2727     unsigned LeadZ =  std::max(Known.countMinLeadingZeros() +
 3133         std::max(Known.countMinLeadingZeros(), Known2.countMinLeadingZeros());
 3249     LeadZero = std::max(LeadZero, Known2.countMinLeadingZeros());
 3263     LeadOne = std::max(LeadOne, Known2.countMinLeadingOnes());
 3547     return std::max(Tmp, Tmp2);
 3757     return std::max(std::min(KnownSign - rIndex * BitWidth, BitWidth), 0);
 3942       FirstAnswer = std::max(FirstAnswer, NumBits);
 3965   return std::max(FirstAnswer, std::min(VTBits, Mask.countLeadingZeros()));

 1196                           std::max(DbgSDNodeOrder, ValSDNodeOrder));
 1994     auto SuccSize = std::max<uint32_t>(succ_size(SrcBB), 1);
 3957       std::max((unsigned)DL.getPrefTypeAlignment(Ty), I.getAlignment());
 5706     unsigned DstAlign = std::max<unsigned>(MCI.getDestAlignment(), 1);
 5707     unsigned SrcAlign = std::max<unsigned>(MCI.getSourceAlignment(), 1);
 5726     unsigned Align = std::max<unsigned>(MSI.getDestAlignment(), 1);
 5740     unsigned DstAlign = std::max<unsigned>(MMI.getDestAlignment(), 1);
 5741     unsigned SrcAlign = std::max<unsigned>(MMI.getSourceAlignment(), 1);
 8592   unsigned Bits = std::max(Hi.getActiveBits(),
10329     if (std::min(NumLeft, NumRight) < 3 && std::max(NumLeft, NumRight) > 3) {
10433   return BranchProbability(Numerator, std::max(Numerator, Denominator));

 5444     char V01 = std::max(V0, V1);
 5445     return V01 ? std::max(V01, V2) : 0;

  258   Threshold = std::max(UINT64_C(1), Scaled);

 1271           unsigned MaxAlignment = std::max(MFI->getObjectAlignment(FirstSlot),

  282       I->Size = std::max(I->Size, II->Size);

  563       MemSize = std::max(MemSize, OpSize);

  213         std::max(InstrLatency, TII->defaultDefLatency(SchedModel, *DefMI));

  250     LargestTypeIndex = std::max(LargestTypeIndex, CurrentTI);
  271     LargestTypeIndex = std::max(LargestTypeIndex, Begin);

  310           std::max(MaxEncodingStringLength,

 1069     NextUncovered = std::max(NextUncovered, Idx);

   29     Range.End = std::max(Range.End, It2[-1].End);
   33     It[-1].End = std::max(It[-1].End, Range.End);

   57                     std::max(MinBlockCount, msf::getMinimumBlockCount()),

   41   return std::make_pair(std::max(I1.first, I2.first),

   45       std::max(static_cast<int64_t>(1), Line - PrintSourceContext / 2);

 1027   unsigned MemToAlloc = std::max(1U, NumElements * TypeSize);

  197       SegAlign = std::max(SegAlign, B->getAlignment());
  206       SegAlign = std::max(SegAlign, B->getAlignment());

   47         SlabEnd = std::max(SlabEnd, (char *)(KV.second.base()) +

  570         CodeAlign = std::max(CodeAlign, Alignment);
  573         RODataAlign = std::max(RODataAlign, Alignment);
  576         RWDataAlign = std::max(RWDataAlign, Alignment);
  587     RWDataAlign = std::max<uint32_t>(RWDataAlign, getGOTEntrySize());
  609     RWDataAlign = std::max(RWDataAlign, CommonAlign);
  790   Alignment = std::max(1u, Alignment);
  826     Alignment = std::max(Alignment, getStubAlignment());

 1115     MaxSize = std::max(MaxSize, List.getNumAttrSets());

 1328   return Builder.CreateBitCast(Vec, Builder.getIntNTy(std::max(NumElts, 8U)));

 2269                 std::max(IdxTy->getIntegerBitWidth(),
 2271             CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
 2430         std::max(PrevIdx->getType()->getScalarSizeInBits(),
 2432     CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);

   64     StructAlignment = std::max(TyAlign, StructAlignment);
  666     MaxPointerSize = std::max(MaxPointerSize, P.TypeByteWidth);
  726     return std::max(Align, Layout->getAlignment());
  855     Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));

  243   ReservedSpace = (std::max(e, 1U) + Size / 2) * 2;

  244         NameRef.substr(0, std::max(1u, (unsigned)NonGlobalValueMaxNameSize));
  683         return std::max(FunctionPtrAlign, MaybeAlign(GO->getAlignment()));

 4462         std::max(uint64_t(Entry.second), IdxArg->getLimitedValue(~0U) + 1));

  764       CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
  766           std::max(CommonRes.Align, MaybeAlign(Sym.getCommonAlignment()));

  355             std::max(DGVar->getAlignment(), SGVar->getAlignment()));

  198       MaxFragmentSize = std::max(MaxFragmentSize, Policy->getWindowSize());
  248       SizeWeight = std::max(SizeWeight, OffsetWeight);

  473     LocEnd = std::max(LocEnd, Extent.second);

  186     Latency = std::max(Latency, IID.getOperandCycle(SCClass, OpIdx));
  222     Latency = std::max(Latency, WLEntry->Cycles);

   51     Latency = std::max(Latency, static_cast<int>(WLEntry->Cycles));

   91     MaxLen = std::max(MaxLen, std::strlen(I.Key));

  275     Size = std::max(Size, static_cast<uint64_t>(ByteAlignment));

  825     VMSize = std::max(VMSize, Address + Size);
  830     SectionDataSize = std::max(SectionDataSize, Address + Size);
  831     SectionDataFileSize = std::max(SectionDataFileSize, Address + FileSize);

   32       LQSize = std::max(0, LdQDesc.BufferSize);
   37       SQSize = std::max(0, StQDesc.BufferSize);
   89         std::max(CurrentLoadGroupID, CurrentLoadBarrierGroupID);

   48   NextAvailableSlotIdx += std::max(1U, Entries);
   66   unsigned NextSlotIdx = CurrentInstructionSlotIdx + std::max(1U, Current.NumSlots);
   79   CurrentInstructionSlotIdx += std::max(1U, Current.NumSlots);

   62     unsigned ReadCycles = std::max(0, CyclesLeft - User.second);
   76     unsigned ReadCycles = std::max(0, CyclesLeft - ReadAdvance);
   86     User->writeStartEvent(IID, RegisterID, std::max(0, CyclesLeft));

  100     Max = std::max(Max, Throughput);

  682       MemOffset = std::max(MemOffset, End);
  685         FileOffset = std::max(FileOffset, End);
  702         PHeader.p_align = std::max(PHeader.p_align, SHeader->sh_addralign);

   64       R.second = std::max(R.second, I->second.second);

  497       OptionFieldWidth = std::max(OptionFieldWidth, Length);

  774       ExecutionCount = std::max(ExecutionCount, LS->Count);

  584     MaxCount = std::max(Other.Counts[I], MaxCount);

  791     FileSize = std::max(Entry.Offset + Entry.Size, FileSize);

 3859   X.exponent += std::min(std::max(Exp, -MaxIncrement - 1), MaxIncrement);

 1850       Size = std::max(Size, NameSize + OptionPrefixesSize);
 1856       BaseSize = std::max(BaseSize, getOption(i).size() + 8);
 2133         MaxSubLen = std::max(MaxSubLen, strlen(Subs[i].first));
 2149       MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
 2356     MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());

 1661           Block->End = std::max(Block->End, M.End);

   72   indent(std::max(int(NewCol - getColumn()), 1));

  146       std::max(static_cast<unsigned>(W), std::max(1u, Nibbles) + PrefixChars);
  146       std::max(static_cast<unsigned>(W), std::max(1u, Nibbles) + PrefixChars);

  286       std::max(Str.size() - (DigitsOut - Precision), AfterDot + 1);

   50       std::min(std::max(NewCapacity, MinCapacity), size_t(UINT32_MAX));

  176     MaxValLen = std::max(MaxValLen,
  178     MaxDebugTypeLen = std::max(MaxDebugTypeLen,

  122     Width = std::max(Width, Targets.back().first.size());

  516   return std::max(Entries, 0);

  420     OffsetWidth = std::max<uint64_t>(4, llvm::alignTo(Power, 4) / 4);

  166       MaxSize = std::max(MaxSize, unsigned(Args[i].size()));

   67     StackUsed = std::max(StackUsed, Size + Offset);

   50         Size, std::max((unsigned)Align.value(), SlotAlign)));

  104     MaxOffset = std::max(MaxOffset, BlockOffset);

 1184   RetVT.SimpleTy = std::max(RetVT.SimpleTy, MVT::i32);
 1682   MVT VT = std::max(MVT::i32, RetVT.SimpleTy);

 5474     ArgSize = std::max(ArgSize, MinSlotSize);
 6309     Source->MaxElt = std::max(Source->MaxElt, EltNo);

  757                                ValSize, std::max(Align, PtrSize)));

  203         MaxOffset = std::max<int64_t>(Offset + ObjSize, MaxOffset);

   80   return std::max(1, Cost);

  269     DisasmLineMaxLen = std::max(DisasmLineMaxLen, DisasmLines.back().size());
  282     DisasmLineMaxLen = std::max(DisasmLineMaxLen, DisasmLines.back().size());
  610   return std::max(NumVGPR, NumAGPR);
  867           MaxSGPR = std::max(MaxSGPR, MaxSGPRGuess);
  868           MaxVGPR = std::max(MaxVGPR, 23);
  869           MaxAGPR = std::max(MaxAGPR, 23);
  871           CalleeFrameSize = std::max(CalleeFrameSize, UINT64_C(16384));
  892           MaxSGPR = std::max(I->second.NumExplicitSGPR - 1, MaxSGPR);
  893           MaxVGPR = std::max(I->second.NumVGPR - 1, MaxVGPR);
  894           MaxAGPR = std::max(I->second.NumAGPR - 1, MaxAGPR);
  896             = std::max(I->second.PrivateSegmentSize, CalleeFrameSize);
  975   ProgInfo.NumSGPR = std::max(ProgInfo.NumSGPR, WaveDispatchNumSGPR);
  976   ProgInfo.NumVGPR = std::max(ProgInfo.NumVGPR, WaveDispatchNumVGPR);
  980   ProgInfo.NumSGPRsForWavesPerEU = std::max(
  981     std::max(ProgInfo.NumSGPR, 1u), STM.getMinNumSGPRs(MFI->getMaxWavesPerEU()));
  982   ProgInfo.NumVGPRsForWavesPerEU = std::max(
  983     std::max(ProgInfo.NumVGPR, 1u), STM.getMinNumVGPRs(MFI->getMaxWavesPerEU()));
 1273   Out.kernarg_segment_alignment = Log2(std::max(Align(16), MaxKernArgAlign));

   90     StackUsed = std::max(StackUsed, Size + Offset);

  227       std::max(MaxKernArgAlign, Align(4)).value();
  895       Kern.getDocument()->getNode(std::max(Align(4), MaxKernArgAlign).value());

  927     MaxAlign = std::max(Align, MaxAlign);
 4550     return std::max(SignBits, Op0SignBits);

  804             MemSize = std::max(MemSize, Align);

   62    int maxLeadIndex() const { return (std::max)(Lead[0], Lead[1]); }

  224       Attribute::getWithAlignment(Ctx, std::max(KernArgBaseAlign, MaxAlign)));

  366       DisasmLineMaxLen = std::max(DisasmLineMaxLen, DisasmLine.size());

  333   NumWaves = std::max(NumWaves, 1u);
  350                           std::max(getWavefrontSize() * 4, 256u));
  509     MaxAlign = std::max(MaxAlign, Alignment);
  602   return std::min(std::max(getTotalNumVGPRs() / RoundedRegs, 1u), MaxWaves);

  103   unsigned MaxBoost = std::max(ThresholdPrivate, ThresholdLocal);

  529   unsigned DstSize = IsGather4 ? 4 : std::max(countPopulation(DMask), 1u);

  249   int WaitStates = std::max(0, checkAnyInstHazards(MI));
  252     return std::max(WaitStates, checkSMRDHazards(MI));
  255     WaitStates = std::max(WaitStates, checkVMEMHazards(MI));
  258     WaitStates = std::max(WaitStates, checkNSAtoVMEMHazard(MI));
  260   WaitStates = std::max(WaitStates, checkFPAtomicToDenormModeHazard(MI));
  266     WaitStates = std::max(WaitStates, checkVALUHazards(MI));
  269     WaitStates = std::max(WaitStates, checkDPPHazards(MI));
  272     WaitStates = std::max(WaitStates, checkDivFMasHazards(MI));
  275     WaitStates = std::max(WaitStates, checkRWLaneHazards(MI));
  278     return std::max(WaitStates, checkInlineAsmHazards(MI));
  281     return std::max(WaitStates, checkGetRegHazards(MI));
  284     return std::max(WaitStates, checkSetRegHazards(MI));
  287     return std::max(WaitStates, checkRFEHazards(MI));
  291     return std::max(WaitStates, checkReadM0Hazards(MI));
  294     return std::max(WaitStates, checkReadM0Hazards(MI));
  297     return std::max(WaitStates, checkMAIHazards(MI));
  300     return std::max(WaitStates, checkMAILdStHazards(MI));
  560     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
  574       WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
  598     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
  620     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
  623   WaitStatesNeeded = std::max(
  737   WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForDef);
  752     WaitStatesNeeded = std::max(WaitStatesNeeded, checkVALUHazardsHelper(Def, MRI));
  777       WaitStatesNeeded = std::max(WaitStatesNeeded, checkVALUHazardsHelper(Op, MRI));
  843     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
 1214     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
 1225         WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
 1265       HazardDefLatency = std::max(HazardDefLatency,
 1300     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
 1323     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
 1342       HazardDefLatency = std::max(HazardDefLatency,
 1360     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
 1388     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);
 1405     WaitStatesNeeded = std::max(WaitStatesNeeded, WaitStatesNeededForUse);

  322       advanceToCycle(std::max(CurCycle + 1, EarliestSU->getHeight()));

   70   MaxInstNum = std::max(MaxInstNum, 1u);
  484   return std::max(NewOcc, Occ);

  289       MaxInd = I ? std::max(MaxInd, LI->endIndex()) : LI->endIndex();

   48   unsigned getVGPRNum() const { return std::max(Value[VGPR32], Value[AGPR32]); }
   50   unsigned getVGPRTuplesWeight() const { return std::max(Value[VGPR_TUPLE],
   94     Res.Value[I] = std::max(P1.Value[I], P2.Value[I]);

  375   unsigned NewOccupancy = std::max(WavesAfter, WavesBefore);

   65         MaxGPR = std::max(MaxGPR, HWReg);

  164   MaxStackSize = std::max(CurrentStackSize, MaxStackSize);

 1205     Offset = std::max(Offset, (int)RegIndex);

  774     setScoreLB(T, std::max(getScoreLB(T), UB - Count));
 1296   Score = std::max(MyShifted, OtherShifted);
 1338     for (int J = 0, E = std::max(getMaxVGPR(), Other.getMaxVGPR()) + 1; J != E;
 1344       for (int J = 0, E = std::max(getMaxSGPR(), Other.getMaxSGPR()) + 1;
 1354   VgprUB = std::max(getMaxVGPR(), Other.getMaxVGPR());
 1355   SgprUB = std::max(getMaxSGPR(), Other.getMaxSGPR());

  663   unsigned MaxMask = std::max(CI.DMask0, CI.DMask1);

   88       MaxKernArgAlign = std::max(ST.getAlignmentForImplicitArgPtr(),

 1440         Height = std::max(Height, Succ.first->Height + Succ.first->getCost());
 1653       (unsigned int) std::max<int> (0,

  421   NumSGPRs = alignTo(std::max(1u, NumSGPRs), getSGPREncodingGranule(STI));
  471   NumVGPRs = alignTo(std::max(1u, NumVGPRs),

  566       unsigned Align = std::max(StackSlotSize, ArgDI.Flags.getByValAlign());

   92     const Align PA = std::max(PostAlign, Alignment);
  105     return std::max(Log2(std::max(PostAlign, Align)), internalKnownBits());
  105     return std::max(Log2(std::max(PostAlign, Align)), internalKnownBits());

  180         std::max(StackSize, static_cast<uint64_t>(State.getNextStackOffset()));

 1352         std::max(UserBBI.postOffset() - UPad - 8,
 1373           std::max(BaseInsertOffset, Offset + TII->getInstSizeInBytes(*I) + 1);

 1803     MaxFixedOffset = std::max(MaxFixedOffset, MaxObjectOffset);
 1940       int RegDeficit = std::max(EntryRegDeficit, ExitRegDeficit);

 2457   Align = std::max(Align, 4U);
 2501   Size = std::max<int>(Size - Excess, 0);
 3947                                   std::max(4U, TotalArgRegsSaveSize));
 4803   int64_t PosVal = std::max(Val1, Val2);
 7384     Source->MaxElt = std::max(Source->MaxElt, EltNo);
 9498         MaxCSNum = std::max(MaxCSNum, *CSI);
14903   unsigned NumBytes = std::max(VT.getSizeInBits() / 8, 1U);

  425       return std::max(BaseT::getVectorInstrCost(Opcode, ValTy, Index), 2U);
  434     return std::max(BaseT::getVectorInstrCost(Opcode, ValTy, Index),

 1567     regs = std::max( 1u, regs);
 1591     regs = std::max( 1u, regs);

  146         resize(std::max(Idx+1, 32U));

   72         Min = adjustUp(std::max(Min, A.Min), Align, Offset);
  171       N->Height = 1 + std::max(height(N->Left), height(N->Right));
  173         N->MaxEnd = std::max(N->MaxEnd, N->Left->MaxEnd);
  175         N->MaxEnd = std::max(N->MaxEnd, N->Right->MaxEnd);

  591   unsigned MaxAlign = std::max(MFI.getMaxAlignment(), getStackAlignment());
 1373     unsigned A = std::max(MFI.getObjectAlignment(i), 8U);

  183   uint32_t U = BW - std::max(SL, SR);

  162         resize(std::max(Idx+1, 32U));
  273         CVect.resize(std::max(RInd+16, 32U), nullptr);

  280     unsigned MaxX = std::max(CI.TrueX, CI.FalseX);

 1910     RootHeights[N] = std::max(getHeight(N->getOperand(0).getNode()),
 2034         NodeHeights[Child] = std::max(NodeHeights[Op1],
 2050     int Height = std::max(NodeHeights[Mul1.Value], NodeHeights[Mul2.Value]) + 1;
 2113       int Height = std::max(NodeHeights[GA.Value], NodeHeights[SHL.Value]) + 1;
 2172     int Height = std::max(NodeHeights[V0], NodeHeights[V1]) + 1;

  768       MaxSrc = (MaxSrc == -1) ? M : std::max(MaxSrc, M);

  415         LargestAlignSeen = std::max(LargestAlignSeen,
  440     LargestAlignSeen = std::max(LargestAlignSeen, VecAlign);

  296     Top.MaxMinLatency = std::max(MinLatency, Top.MaxMinLatency);
  315     Bot.MaxMinLatency = std::max(MinLatency, Bot.MaxMinLatency);
  368   unsigned NextCycle = std::max(CurrCycle + 1, MinReadyCycle);

  186           MaxPath = std::max(MaxPath, isTop() ? SU.getHeight() : SU.getDepth());
  187         CriticalPathLength = std::max(CriticalPathLength, MaxPath) + 1;

  359     DLatency = std::max(DLatency, 0);
  441         Latency = std::max(Latency, 0);

  260     return std::max(SrcLT.first, DstLT.first) + FloatFactor * (SrcN + DstN);

  110       int HighOffset = std::max(OffsetA, OffsetB);

  904   TextSection.setAlignment(Align(std::max(16u, TextSection.getAlignment())));
  905   DataSection.setAlignment(Align(std::max(16u, DataSection.getAlignment())));
  906   BSSSection.setAlignment(Align(std::max(16u, BSSSection.getAlignment())));

  403     EmitAlignment(std::max(MF->getAlignment(), MIPS_NACL_BUNDLE_ALIGN));

  128     return std::max((VT.getSizeInBits() / (Subtarget.isABI_O32() ? 32 : 64)),
 4184   unsigned FrameObjSize = std::max(Flags.getByValSize(), RegAreaSize);

  888   unsigned fromTypeWidth = std::max(8U, ScalarVT.getSizeInBits());
 1033   unsigned FromTypeWidth = std::max(8U, ScalarVT.getSizeInBits());

  112   MaxAlign = std::max(MaxAlign, Align);
  199     MaxAlign = std::max(Align, MaxAlign);
  239     StackAlign = std::max(StackAlign, MaxAlign);

  188     MaxAlign = std::max(MaxAlign, Src->getAlignment());
  194       MaxAlign = std::max(MaxAlign, Fn.getBlockNumbered(i)->getAlignment());
  205     MaxAlign = std::max(MaxAlign, Dest->getAlignment());
  208       MaxAlign = std::max(MaxAlign, Fn.getBlockNumbered(i)->getAlignment());

 1416   NumBytes = std::max(NumBytes, LinkageSize + 64);

  484   unsigned AlignMask = std::max(MaxAlign, TargetAlign) - 1;
  511   maxCallFrameSize = std::max(maxCallFrameSize, minCallFrameSize);

  547   if (std::max(TProb, FProb) / Threshold < std::min(TProb, FProb))
 1047         std::max(MaxTruncation, Use->getValueType(0).getSizeInBits());
 1056       MaxTruncation = std::max(MaxTruncation, MemVTSize);
 1065       MaxTruncation = std::max(MaxTruncation, 32u);
 1073       MaxTruncation = std::max(MaxTruncation, 16u);
 1081       MaxTruncation = std::max(MaxTruncation, 8u);

 3585   MinReservedArea = std::max(MinReservedArea, LinkageSize);
 4059     MinReservedArea = std::max(ArgOffset, LinkageSize + 8 * PtrByteSize);
 4415   MinReservedArea = std::max(MinReservedArea, LinkageSize + 8 * PtrByteSize);
 5827     NumBytes = std::max(NumBytes, LinkageSize + 8 * PtrByteSize);
 6393   NumBytes = std::max(NumBytes, LinkageSize + 8 * PtrByteSize);

  169     Latency = std::max(Latency, (unsigned) Cycle);
 3410   unsigned MaxOp = std::max(Op1, Op2);
 3414   MI.RemoveOperand(std::max(Op1, Op2));
 4308       int HighOffset = std::max(OffsetA, OffsetB);

   46     unsigned MaxStackAlign = std::max(StackAlign, MFI.getMaxAlignment());

 1421     unsigned StackAlign = std::max(XLenInBytes, ArgFlags1.getOrigAlign());

   90   return std::max(1, Cost);

 1113   unsigned ArgsSize = std::max(6*8u, CCInfo.getNextStackOffset());

  298       MaxArgOffset = std::max(MaxArgOffset, ArgOffset);

 3223   uint64_t RequiredAlign = std::max(AlignVal, StackAlign);

  749         return VF / 2 /*vledb*/ + std::max(1U, VF / 4 /*vperm*/);
 1107       NumPermutes += std::max(1U, NumSrcVecs - NumDstVecs);

  750       unsigned Align = std::max(Out.Flags.getOrigAlign(),

   34     Result = std::max(Result, 16u);

  444             MIDepth = std::max(MIDepth, Info.Depth);
  446               MIDepthOpt = std::max(MIDepthOpt, Info.OptDepth);
  465         MaxDepth.Depth = std::max(MaxDepth.Depth, MIDepth);
  466         MaxDepth.OptDepth = std::max(MaxDepth.OptDepth, MIDepthOpt);

  117           std::max(MemOpDiscriminators[Loc], DI->getBaseDiscriminator());

 1046     StackSize = std::max(MinSize, StackSize > 128 ? StackSize - 128 : 0);
 2647           MoreStackForCalls = std::max(MoreStackForCalls,

 3806     ZExtWidth = PowerOf2Ceil(std::max(ZExtWidth, 8U));

 3797             Flags.getByValSize(), std::max(16, (int)Flags.getByValAlign()),
 5853                           std::max(128U, VT.getSizeInBits() / Scale));
 6955     size_t MaskSize = std::max(SrcMask0.size(), SrcMask1.size());
 8492   MVT VT = MVT::getIntegerVT(std::max((int)Op.getValueSizeInBits(), 8));
 8555       MVT ImmVT = MVT::getIntegerVT(std::max(VT.getSizeInBits(), 8U));
10607       MVT::getIntegerVT(std::max((int)VT.getVectorNumElements(), 8));
11110           MVT::getIntegerVT(std::max((int)VT.getVectorNumElements(), 8));
11174         MVT::getIntegerVT(std::max((int)VT.getVectorNumElements(), 8));
11322         Range1.second = std::max(Range1.second, M);
11329         Range2.second = std::max(Range2.second, M);
13011         std::max(Mask[0], 0) * 2, std::max(Mask[0], 0) * 2 + 1,
13011         std::max(Mask[0], 0) * 2, std::max(Mask[0], 0) * 2 + 1,
13012         std::max(Mask[1], 0) * 2, std::max(Mask[1], 0) * 2 + 1};
13012         std::max(Mask[1], 0) * 2, std::max(Mask[1], 0) * 2 + 1};
15425       TopSrcSubLane = std::max(TopSrcSubLane, SrcSubLane);
21621     In = extractSubVector(In, 0, DAG, dl, std::max(InSize, 128));
30965       MaxCSNum = std::max(MaxCSNum, CSI);
31457   Width = PowerOf2Ceil(std::max(Width, 8U));
31849         unsigned SrcSize = std::max(128u, NumDstElts * MaskEltSize);
32837     WideSizeInBits = std::max(WideSizeInBits, Src.getValueSizeInBits());
33102   unsigned MaskWidth = std::max<unsigned>(OpMask.size(), RootMask.size());
33103   unsigned RootRatio = std::max<unsigned>(1, OpMask.size() >> RootMaskSizeLog2);
33104   unsigned OpRatio = std::max<unsigned>(1, RootMask.size() >> OpMaskSizeLog2);
35720   unsigned RegSize = std::max(128u, InVT.getSizeInBits());

  145       max_index = std::max(max_index, static_cast<int16_t>(index));

 3252   unsigned Alignment = std::max<uint32_t>(TRI->getSpillSize(*RC), 16);
 3267   unsigned Alignment = std::max<uint32_t>(TRI->getSpillSize(*RC), 16);
 5504       unsigned Alignment = std::max<uint32_t>(TRI.getSpillSize(*RC), 16);
 5581     unsigned Alignment = std::max<uint32_t>(TRI.getSpillSize(*DstRC), 16);
 5648       unsigned Alignment = std::max<uint32_t>(TRI.getSpillSize(*RC), 16);
 5714     unsigned Alignment = std::max<uint32_t>(TRI.getSpillSize(*RC), 16);

  439   int LaneCount = std::max(VectorSize / 128, 1);
  451   int VF = VT.getVectorNumElements() / std::max(VectorSize / 128, 1);
  476   unsigned NumLanes = std::max((int)VT.getSizeInBits() / 128, 1);

  151     ReturnBBs[MBB] = std::max(ReturnBBs[MBB], Cycles);

  229       unsigned OpMinSize = std::max(Op1MinSize, Op2MinSize);
 2957   return std::max(1, Cost);
 3154   int SplitFactor = std::max(IdxsLT.first, SrcLT.first);
 3672         std::max((unsigned)1, (unsigned)(NumOfMemOps - 1));

  151       Offset = std::max(Offset, OutOffset[Pred]);

  146   EmitAlignment(std::max(Alignment, Align(4)), GV);

  286     int64_t FoldedOffset = std::max(Offset & ~3, (int64_t)0);
 1393       unsigned Align = std::max(StackSlotSize, ArgDI->Flags.getByValAlign());

  177               std::max(Info.MinBitWidth, InstInfoMap[IOp].MinBitWidth);
  187     Info.MinBitWidth = std::max(Info.MinBitWidth, Info.ValidBitWidth);
  197         InstInfoMap[IOp].ValidBitWidth = std::max(ValidBitWidth, IOpBitwidth);

  371       return std::max(Natural, Forced) - StructSize;
  414     unsigned IndexBits = std::max(1U, Log2_64_Ceil(Shape.CoroSuspends.size()));

 1571     return std::max(int64_t(0), DerefBytes - Offset);
 2562           std::max(int64_t(0), DerefBytes - OffsetSExt));
 2568               std::max(int64_t(0), DerefBytes - OffsetSExt));

  123     New->setAlignment(Align(std::max(getAlignment(Old), getAlignment(New))));

  448                 std::max(FailureInfo->MaxHotness, Edge.second.getHotness());

  833     MaxAlign = std::max(MaxAlign, *Alignment);
 2085         MaxUniqueId = std::max(MaxUniqueId, TypeIdInfo[MD].UniqueId);
 2087         MaxUniqueId = std::max(MaxUniqueId, BF->UniqueId);

  772   F->setAlignment(MaybeAlign(std::max(F->getAlignment(), G->getAlignment())));
  819     MaybeAlign MaxAlignment(std::max(G->getAlignment(), NewF->getAlignment()));

  754   OutlineRegionRelFreq = std::max(

  727       Max = std::max(Max, R.get());
 1064       Weight = std::max(Weight, BlockWeights[BB2]);

  145       MinByte = std::max(MinByte, Target.minAfterBytes());
  147       MinByte = std::max(MinByte, Target.minBeforeBytes());
 1446       TotalPaddingBefore += std::max<int64_t>(
 1448       TotalPaddingAfter += std::max<int64_t>(

  792     const unsigned MaxAmt = SExtSize - std::max(CISize, ASize);
 1541     unsigned SrcWidth = std::max(LHSWidth, RHSWidth);

  386             std::max(EntryAI->getAlignment(), AI.getAlignment()));

 2621   unsigned NewWidth = Known.getBitWidth() - std::max(LeadingKnownZeros, LeadingKnownOnes);

  537   return std::max(32U, 1U << MappingScale);
 1033     StackAlignment = std::max(StackAlignment, AI.getAlignment());
 1696       IntegerType::get(*C, std::max(8U, TypeSize >> Mapping.Scale));
 2273     uint64_t RZ = std::max(
 2943   size_t FrameAlignment = std::max(L.FrameAlignment, (size_t)ClRealignStack);
 3026   size_t MinHeaderSize = std::max((size_t)ASan.LongSize / 2, Granularity);
 3263   const unsigned Align = std::max(kAllocaRzSize, AI->getAlignment());

 1187         MaybeAlign(std::max(AI->getAlignment(), Mapping.getObjectAlignment())));
 1268       MaybeAlign(std::max(GV->getAlignment(), Mapping.getObjectAlignment())));

  359           std::min(MaxProm, std::max(MaxPromForTarget, PendingCandsInTarget) -
  892     NumCounters = std::max(INSTR_PROF_MIN_VAL_COUNTS, (int)NumCounters * 2);

 1122     unsigned OriginAlignment = std::max(kMinOriginAlignment, Alignment);
 1168       unsigned OriginAlignment = std::max(kMinOriginAlignment, Alignment);
 1804         unsigned OriginAlignment = std::max(kMinOriginAlignment, Alignment);
 2932                   std::max(Align, kMinOriginAlignment));
 3874                           std::max(kShadowTLSAlignment, kMinOriginAlignment));

 1276     FuncMaxCount = std::max(FuncMaxCount, BI->CountValue);
 1374   uint64_t MaxCount = std::max(SCounts[0], SCounts[1]);

  163   Options.CoverageType = std::max(Options.CoverageType, CLOpts.CoverageType);

  634   unsigned NewWidth = std::max<unsigned>(

  449       LaterIntEnd = std::max(LaterIntEnd, ILI->first);
  460         LaterIntEnd = std::max(LaterIntEnd, ILI->first);

  400     unsigned MinBW = std::max(R.getLower().getMinSignedBits(),

  902           MaybeAlign(std::max(ReplacementAlloca->getAlignment(),

 1988             Alignment = std::max(Alignment, InstAlignment);
 2016             Alignment = std::max(Alignment, InstAlignment);

  268   RSD.UsedByIndices.resize(std::max(RSD.UsedByIndices.size(), LUIdx + 1));
 1782     return std::max(ScaleCostMinOffset, ScaleCostMaxOffset);

  658   LoopSize = std::max(LoopSize, BEInsns + 1);
  780     UP.Threshold = std::max<unsigned>(UP.Threshold, PragmaUnrollThreshold);
  782         std::max<unsigned>(UP.PartialThreshold, PragmaUnrollThreshold);
  865             (std::max(UP.PartialThreshold, UP.BEInsns + 1) - UP.BEInsns) /
 1071     UP.Threshold = std::max(UP.Threshold, LoopSize + 1);

 1037       std::max(MemSet->getDestAlignment(), MemCpy->getDestAlignment());

 3400   NumGVNMaxIterations = std::max(NumGVNMaxIterations.getValue(), Iterations);

  205     Rank = std::max(Rank, getRank(I->getOperand(i)));
 2303         unsigned MaxRank = std::max(Ops[i].Rank, Ops[j].Rank);

  507               std::max(S.endOffset(), MaxSplitSliceEndOffset);
  551           P.EndOffset = std::max(P.EndOffset, P.SJ->endOffset());
  568       P.EndOffset = std::max(P.EndOffset, P.SJ->endOffset());
  962         Size = std::max(Size,
  970         Size = std::max(Size,
 1224     MaxAlign = std::max(MaxAlign, MaybeAlign(LI->getAlignment()));
 1816       std::max(S.beginOffset(), P.beginOffset()) - P.beginOffset();
 2363     NewBeginOffset = std::max(BeginOffset, NewAllocaBeginOffset);

 2499       std::max(UnswitchedClones - (int)UnswitchNumInitialUnscaledCandidates, 0);
 2503       std::max((ParentL ? SiblingsCount

   50   return alignTo(std::max(Res, 2 * Granularity), Alignment);
   63     Vars[i].Alignment = std::max(Vars[i].Alignment, kMinAlignment);
   69   Layout.FrameAlignment = std::max(Granularity, Vars[0].Alignment);
   70   size_t Offset = std::max(std::max(MinHeaderSize, Granularity),
   70   size_t Offset = std::max(std::max(MinHeaderSize, Granularity),
   75     size_t Alignment = std::max(Granularity, Vars[i].Alignment);
   83                    : std::max(Granularity, Vars[i + 1].Alignment);

   38   return (AtomicOrdering)std::max((unsigned)X, (unsigned)Y);

 1149     Alignment = std::max(AI->getAlignment(), Alignment);
 1163     Alignment = std::max(GO->getAlignment(), Alignment);

  316         DesiredPeelCount = std::max(DesiredPeelCount, ToInvariance);
  323     DesiredPeelCount = std::max(DesiredPeelCount,

 5444     uint64_t TableSizePowOf2 = NextPowerOf2(std::max(7ULL, TableSize - 1ULL));

  201       DerefBytes = std::max(CI->getDereferenceableOrNullBytes(
  949     unsigned char Width = NextPowerOf2(std::max((unsigned char)7, Max));

 5116       MaxWidth = std::max(MaxWidth,
 5157     pair.second = std::max(pair.second, 1U);
 5195                         std::max(1U, (MaxLocalUsers - 1)));
 5274         std::max(StoresIC, LoadsIC) > SmallIC) {
 5277       return std::max(StoresIC, LoadsIC);
 5388     return std::max<unsigned>(1, VF * TypeSize / WidestRegister);
 5444           MaxUsages[j][pair.first] = std::max(MaxUsages[j][pair.first], pair.second);

  882       return std::max(CntTrue, CntFalse);
 4955       MaxWidth = std::max<unsigned>(MaxWidth, DL->getTypeSizeInBits(Ty));
 5108     MaxBitWidth = std::max<unsigned>(
 5145       MaxBitWidth = std::max<unsigned>(NumTypeBits - NumSignBits, MaxBitWidth);
 5422     for (int Offset = 1, F = std::max(E - Idx, Idx + 1); Offset < F; ++Offset)
 5518   unsigned MinVF = std::max(2U, R.getMinVecRegSize() / Sz);
 5519   unsigned MaxVF = std::max<unsigned>(PowerOf2Floor(VL.size()), MinVF);

   67     WidestBundleBits = std::max(WidestBundleBits, BundleSize);

  375     return std::max(unsigned(alignof(LocalData)),
  565       BuiltinRange.setEnd(std::max(Range.getEnd(), BuiltinRange.getEnd()));

  555     return NewAlign ? NewAlign : std::max(LongDoubleAlign, LongLongAlign);

  307       S = static_cast<State>(std::max<int>(S, 0) + 1);
  311       S = static_cast<State>(std::max<int>(S, 1) - 1);

 1645             Align = std::max(Align, Target->getLargeArrayAlign());
 1648             Align = std::max(Align, Target->getLargeArrayAlign());
 1651       Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
 1657           Align = std::max(Align, getTargetInfo().getMinGlobalAlign(TypeSize));
 2311       return std::max(ABIAlign, (unsigned)getTypeSize(T));
 2327   return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign(TypeSize));
 6280     sz = std::max(sz, getTypeSizeInChars(IntTy));

 2193     Kind = std::max(Kind, I->isThisDeclarationADefinition(C));

  394     Align = std::max(Align, I->getAlignment(Ctx));

 1343   NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
 1385   unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);

  699   unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
 1735   unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);

  470         N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
 2991   unsigned NewElts = std::max(Index+1, OldElts * 2);
 2992   NewElts = std::min(Size, std::max(NewElts, 8u));
 8562           std::max(CAT->getSize().getBitWidth(), ArrayBound.getBitWidth());
10994       uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize);
10994       uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize);

  220       AllocSize(std::max<size_t>(alignof(void *), Size)), ElemDesc(Elem),
  238     : Source(D), ElemSize(std::max<size_t>(alignof(void *), R->getFullSize())),

  481     unsigned NewCapacity = std::max(

  417                   std::max<int>(static_cast<int>(IndentColumn) - TokColumn, 0));

 1210     setSize(std::max(getSize(), Layout.getSize()));
 1246     setSize(std::max(getSize(), getDataSize()));
 1248     setSize(std::max(getSize(), Offset + Layout.getSize()));
 1435     setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize));
 1456   setSize(std::max(getSizeInBits(), getDataSizeInBits()));
 1565       FieldAlign = std::max(FieldAlign, ZeroLengthBitfieldBoundary);
 1583     FieldAlign = std::max(FieldAlign, ExplicitFieldAlign);
 1584     UnpackedFieldAlign = std::max(UnpackedFieldAlign, ExplicitFieldAlign);
 1695     setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize));
 1725   setSize(std::max(getSizeInBits(), getDataSizeInBits()));
 1729       std::max(UnadjustedAlignment, Context.toCharUnitsFromBits(FieldAlign));
 1787           std::max(Layout.getNonVirtualSize(), Layout.getDataSize());
 1841   FieldAlign = std::max(FieldAlign, MaxAlignmentInChars);
 1842   UnpackedFieldAlign = std::max(UnpackedFieldAlign, MaxAlignmentInChars);
 1900       setDataSize(std::max(getDataSizeInBits(), EffectiveFieldSizeInBits));
 1904     PaddedFieldSize = std::max(PaddedFieldSize, FieldOffset + FieldSize);
 1905     setSize(std::max(getSizeInBits(), getDataSizeInBits()));
 1907     setSize(std::max(getSizeInBits(),
 1912   UnadjustedAlignment = std::max(UnadjustedAlignment, FieldAlign);
 1932   setSize(std::max(getSizeInBits(), (uint64_t)Context.toBits(PaddedFieldSize)));
 2428   Alignment = std::max(Alignment, Info.Alignment);
 2429   RequiredAlignment = std::max(RequiredAlignment, Layout.getRequiredAlignment());
 2430   Info.Alignment = std::max(Info.Alignment, Layout.getRequiredAlignment());
 2448     FieldRequiredAlignment = std::max(
 2454     Info.Alignment = std::max(Info.Alignment, FieldRequiredAlignment);
 2460       FieldRequiredAlignment = std::max(FieldRequiredAlignment,
 2464     RequiredAlignment = std::max(RequiredAlignment, FieldRequiredAlignment);
 2471   Info.Alignment = std::max(Info.Alignment, FieldRequiredAlignment);
 2481   RequiredAlignment = std::max(
 2496     Alignment = std::max(Alignment, PointerInfo.Alignment);
 2503   RequiredAlignment = std::max(
 2702   Alignment = std::max(Alignment, Info.Alignment);
 2712   Size = std::max(Size, FieldOffset + Info.Size);
 2743     Size = std::max(Size, NewSize);
 2744     Alignment = std::max(Alignment, Info.Alignment);
 2747     Size = std::max(Size, Info.Size);
 2754     Alignment = std::max(Alignment, Info.Alignment);
 2773     Size = std::max(Size, Info.Size);
 2780     Alignment = std::max(Alignment, Info.Alignment);
 2805                          .alignTo(std::max(RequiredAlignment, Alignment));
 2820       PointerInfo.Size.alignTo(std::max(RequiredAlignment, Alignment));
 2861         std::max(RequiredAlignment, BaseLayout.getRequiredAlignment());
 2863   VtorDispAlignment = std::max(VtorDispAlignment, RequiredAlignment);
 2882       Alignment = std::max(VtorDispAlignment, Alignment);
 2909     Alignment = std::max(Alignment, RequiredAlignment);
 2913     RoundingAlignment = std::max(RoundingAlignment, RequiredAlignment);

  165   SizeExtended = SizeExtended.extend(std::max(SizeTypeBits,

   97     MaxAlign = std::max(Align, MaxAlign);

  169         MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);
  435     MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);

  428     Classification[DRE] = std::max(Classification[DRE], C);

  451     Result = std::max(Result, State->ExtBehavior);

   71   unsigned CommonWidth = std::max(Val.getBitWidth(), OtherWidth);
   80   unsigned CommonScale = std::max(getScale(), OtherScale);
  129   unsigned CommonScale = std::max(getScale(), Other.getScale());
  131       std::max(getIntegralBits(), Other.getIntegralBits()) + CommonScale;

  615     Align = std::max(Align, 128u);    // align type at least 16 bytes
  617     Align = std::max(Align, 64u);     // align type at least 8 butes
  619     Align = std::max(Align, 32u);     // align type at least 4 bytes

  326         DspRev = std::max(DspRev, DSP1);
  328         DspRev = std::max(DspRev, DSP2);

  137       SIMDLevel = std::max(SIMDLevel, SIMD128);
  145       SIMDLevel = std::max(SIMDLevel, SIMDEnum(UnimplementedSIMD128));

  868     SSELevel = std::max(SSELevel, Level);
  875     MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
  882     XOPLevel = std::max(XOPLevel, XLevel);

  561     maxFieldAlign = std::max(maxFieldAlign, tinfo.second);
  578       maxFieldAlign = std::max(maxFieldAlign, align);
  654     maxFieldAlign = std::max(maxFieldAlign, align);
  681   info.BlockAlign = std::max(maxFieldAlign, info.BlockAlign);
 2809   info.ByrefAlignment = std::max(varAlign, getPointerAlign());

   45   return std::min(High, std::max(Low, Value));
 1302          std::max(Op1Info.Width, Op2Info.Width) >= ResultInfo.Width &&
 1336   unsigned OpWidth = std::max(Op1Info.Width, Op2Info.Width);
 4130     LargestVectorWidth = std::max(LargestVectorWidth, VectorWidth);
 9703                                                     std::max(NumElts, 8U)));

  257       llvm::ConstantInt::get(SizeTy, std::max<size_t>(1, Args.size())));

 1117   CharUnits Align = std::max(MinAlign, CharUnits::fromQuantity(PrefAlign));
 4154             CharUnits::fromQuantity(std::max(
 4297       LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,
 4381     LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,

 1564       unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
 4270       std::max(lhs->getBaseInfo().getAlignmentSource(),

  533     CharUnits Align = std::max(Layout.getNonVirtualAlignment(),
 1597       allocAlign = std::max(allocAlign, cookieAlign);
 1635       allocationAlign = std::max(

  174   Size = std::max(Size, Offset + CSize);
  435     Align = std::max(Align, Utils.getAlignment(C));

 1468       ResultWidth = std::max(SrcWidth + DstScale - SrcScale, DstWidth);

  240         CharUnits::fromQuantity(std::max(
  291       llvm::APInt Align(32, std::max(C.getDeclAlign(VD).getQuantity(),
 5077         RecAlignment = std::max(RecAlignment, Alignment);

  631       NVAlignment = std::max(NVAlignment, getAlignment(Member->Data));
  632     Alignment = std::max(Alignment, getAlignment(Member->Data));

 2087         LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,
 2112         LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,
 2199       LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,

  434       LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,
  439     LargestVectorWidth = std::max((uint64_t)LargestVectorWidth,
 1548   uint64_t CurrentCount = std::max(getCurrentProfileCount(), TrueCount);

 2845     Priority = std::max(Priority, TI.multiVersionSortPriority(Feat));
 2848     Priority = std::max(

 1018   uint64_t Scale = calculateWeightScale(std::max(TrueCount, FalseCount));
 1057                               std::max(*CondCount, LoopCount) - LoopCount);

  283           std::max(FileLineRanges[R.FileID].second, R.LineEnd);

 1989   return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
 2007     std::max(SizeSize, Ctx.getTypeAlignInChars(ElementType));
 2074   return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),

 2222   return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()),

 2958   unsigned Align = std::max(getContext().getTypeAlign(Ty) / 8, 8U);
 4650                  std::max(Members, FldMembers) : Members + FldMembers);
 5440                                        std::max(TyAlign, BaseTyInfo.second));
 5503                       std::max(CharUnits::fromQuantity(8), TyAlign));
 5946     ABIAlign = std::min(std::max(TyAlign, (uint64_t)4), (uint64_t)8);
 6319     TyAlignForABI = std::max(TyAlignForABI, CharUnits::fromQuantity(4));
 6323     TyAlignForABI = std::max(TyAlignForABI, CharUnits::fromQuantity(4));
 7112   Align = std::min(std::max(Align, (uint64_t)MinABIStackAlignInBytes),

 2484           std::max<unsigned>(LangOptions::SSPOn, DefaultStackProtectorLevel);

  117         Blanks, std::max<unsigned>(MaxSplitBytes, FirstNonWhitespace));
  425           std::min<int>(IndentAtLineBreak, std::max(0, ContentColumn[i]));
  427   IndentAtLineBreak = std::max<unsigned>(IndentAtLineBreak, Decoration.size());
  540   return std::max(0, ContentColumn[LineIndex]);

  597         std::max(State.FirstIndent + Style.ContinuationIndentWidth,
  789                  ? std::max(State.Stack.back().Indent,
  792             std::max(NextNonComment->LongestObjCSelectorName,
  812           std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
  843         std::max(1u, std::min(Current.NewlinesBefore, MaxEmptyLinesToKeep));
  924       std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
  934     return std::max(State.Stack.back().LastSpace,
 1011     return std::max(State.Stack.back().LastSpace, State.Stack.back().Indent);
 1016         MinIndent = std::max(MinIndent,
 1028              std::max(NextNonComment->LongestObjCSelectorName,
 1263           std::max(std::max(State.Column, NewParenState.Indent),
 1263           std::max(std::max(State.Column, NewParenState.Indent),
 1273       NewParenState.LastSpace = std::max(NewParenState.LastSpace, State.Column);
 1320   unsigned NestedBlockIndent = std::max(State.Stack.back().StartOfFunctionCall,
 1343       NestedBlockIndent = std::max(NestedBlockIndent, State.Column + 1);
 1346                 std::max(State.Stack.back().LastSpace,
 1354       NewIndent = std::max(NewIndent, State.Stack.back().Indent);
 1355       LastSpace = std::max(LastSpace, State.Stack.back().Indent);

  258       Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], Length);

 2041     Result = std::max(Result, Tok->NestingLevel);

   84              std::max(0, Spaces), Newlines, PreviousPostfix, CurrentPrefix,
  423     MinColumn = std::max(MinColumn, ChangeMinColumn);
  547     MinColumn = std::max(MinColumn, ChangeMinColumn);
  680       MinColumn = std::max(MinColumn, ChangeMinColumn);
  723         MaxEndOfLine = std::max(C.PreviousEndOfTokenColumn + 2, MaxEndOfLine);
  765                        std::max(0, C.Spaces),
  766                        C.StartOfTokenColumn - std::max(0, C.Spaces));
  801         std::max<int>(1, EscapedNewlineColumn - PreviousEndOfTokenColumn - 1);
  805       Spaces = std::max<int>(0, EscapedNewlineColumn - 1);

  328   unsigned MaxColumns = std::max(static_cast<unsigned>(map.columns()),
  329                                  std::max(CaretColumns, FixItColumns));
  372     CaretEnd = std::max(FixItEndCol, CaretEnd);
  961   unsigned Max = std::max(A.second, B.second);
  979   A.first = std::max(Min + Slack, A.first) - Slack;

 2038     FileCharacter = std::max(HeaderInfo.getFileDirFlavor(&File->getFileEntry()),

  353             const size_t MaxHalfLength = std::max(ControllingMacroName.size(),

 2200             std::max(MaxUninitAnalysisVariablesPerFunction,
 2203             std::max(MaxUninitAnalysisBlockVisitsPerFunction,
 2250       MaxCFGBlocksPerFunction = std::max(MaxCFGBlocksPerFunction,

  666     AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability());

  970       PathAccess = std::max(PathAccess, BaseAccess);

 8789   size_t StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, StrRef.size());
 8852   size_t StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, StrRef.size());
10108         return IntRange(std::max(NumPositive + 1, NumNegative),
10143     return IntRange(std::max(L.Width, R.Width),
10975       unsigned BitsNeeded = SignedEnum ? std::max(ED->getNumPositiveBits() + 1,
14742           std::max(CompleteObjectAlignment, Context.getDeclAlign(VD));

17392       NumPositiveBits = std::max(NumPositiveBits,
17395       NumNegativeBits = std::max(NumNegativeBits,

 3788     Align = std::max(Align, I->getAlignment(Context));

 5912     TheCall->setNumArgsUnsafe(std::max<unsigned>(Args.size(), NumParams));

 6940       std::max(OrderedLoopCount, NestedLoopCount));
 6945             std::max(OrderedLoopCount, NestedLoopCount), CollapseLoopCountExpr,
 6965             std::max(OrderedLoopCount, NestedLoopCount), CollapseLoopCountExpr,

13782   unsigned NumArgsSlots = 1 + std::max<unsigned>(Args.size(), NumParams);

 1886   HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),

  255         RetVal.Align = std::max(Ctx.toCharUnitsFromBits(Max), RetVal.Align);

   85   APSIntType ComparisonType = std::max(WraparoundType, APSIntType(From));
  152   APSIntType ComparisonType = std::max(WraparoundType, APSIntType(Int));

  607           APSIntType CompareType = std::max(APSIntType(LHSValue),

  521       OptionFieldWidth = std::max(OptionFieldWidth, NameLength);

  229       N.Height = std::max(N.Height, 1 + Tree.getNode(Child).Height);
  785   if (std::max(T1.getNumberOfDescendants(Id1), T2.getNumberOfDescendants(Id2)) >

  497           std::max(Result.back().getOffset() + Result.back().getLength(),

  109   NumShards = std::max(2u, llvm::hardware_concurrency() / 4);

   93               return std::max(InitialOffset, Consume(SM, Lex, Tok));
   96   return std::max(

  138   auto End = Begin.getLocWithOffset(std::max(0, (int)Placed.getLength() - 1));

   43     MaxSegments = std::max(Segments, MaxSegments);
   57     S = std::max(S, NewScore);

   65       return std::max(LHSWidth, RHSWidth) + 1;

  140     return std::max(calcMagnitudeBits(Context, LHSEType),

  149         std::max(Opts.AsyncThreadsCount, 1u));

  208     Param.MaxUpTraversals = std::max(Path.second - 1, 0);

  264     FormatLimit = std::max(FormatLimit, R.getOffset() + R.getLength());

   80     MaxBackticks = std::max(MaxBackticks, Backticks);
   83   MaxBackticks = std::max(Backticks, MaxBackticks);
   85   std::string BlockMarker(/*Repeat=*/std::max(3u, MaxBackticks + 1), '`');

   98   auto Best = std::max(Scores[PatN][WordN][Miss].Score,
  103       ScoreScale * std::min(PerfectBonus * PatN, std::max<int>(0, Best));
  323   } else if (isAwful(std::max(Scores[PatN][WordN][Match].Score,

  195   References = std::max(IndexResult.References, References);
  307     SemaFileProximityScore = std::max(DeclProximity, SemaFileProximityScore);
  335   return std::max(0.65, 2.0 * std::pow(0.6, D / 2.0));
  357   Score *= 1 + 2 * std::max(uriProximity(SymbolURI, FileProximityMatch).first,

  105       Result = std::max(Result, PartialSelection ? SelectionTree::Partial

   70     T.QueuePri = std::max(T.QueuePri, Boosts.lookup(T.Tag));
   81       T.QueuePri = std::max(T.QueuePri, Boosts.lookup(T.Tag));

  187         Boost = std::max(Boost, Child->consume());
  194       Size = std::max(Size, Child->estimateSize());

  782     Width = std::max(Width, I->size());
 1456     MaxLen = std::max(MaxLen, (unsigned)I.first.size());

  438       Idx += std::max(1U, getParamType(I).getNumVectors());

  107   this->HighPc = std::max(HighPc, FuncHighPc + PcOffset);

   71     MaxDwarfVersion = std::max(MaxDwarfVersion, Version);

  268       std::max<uint64_t>(PrevEndAddress, Segment.vmaddr + Segment.vmsize);

  632   p2Align = std::max(p2Align, other->p2Align);

  705     maxOrdinal = std::max(maxOrdinal, e.ordinal);

 1937     c->setAlignment(std::max(c->getAlignment(), alignment));

  223   config->alignComm[name] = std::max(config->alignComm[name], 1 << v);
  676     max = std::max(max, e.ordinal);

   76   uint32_t v = std::max<uint32_t>(alignment, 1);
  254     alignment = std::max<uint32_t>(hdr->ch_addralign, 1);
  272   alignment = std::max<uint32_t>(hdr->ch_addralign, 1);
 1141   alignment = std::max(alignment, other->alignment);

  940           std::max<uint32_t>(sec->alignment, sec->alignExpr().getValue());

  146   alignment = std::max(alignment, isec->alignment);

  514       max = std::max(max, cast<OutputSection>(cmd)->size);
  770     uint64_t alignment = std::max((uint64_t)1, e().getValue());
 1194       return alignTo(script->getDot(), std::max((uint64_t)1, e().getValue()));
 1244     return [=] { return std::max(a().getValue(), b().getValue()); };

  612   oldSym->alignment = std::max(oldSym->alignment, other.alignment);

  131     flags.isa_level = std::max(flags.isa_level, s->isa_level);
  132     flags.isa_rev = std::max(flags.isa_rev, s->isa_rev);
  133     flags.isa_ext = std::max(flags.isa_ext, s->isa_ext);
  134     flags.gpr_size = std::max(flags.gpr_size, s->gpr_size);
  135     flags.cpr1_size = std::max(flags.cpr1_size, s->cpr1_size);
  136     flags.cpr2_size = std::max(flags.cpr2_size, s->cpr2_size);
  441   alignment = std::max(alignment, sec->alignment);
 2381   nBuckets = std::max<size_t>((v.end() - mid) / 4, 1);
 2526   return std::max<size_t>(NextPowerOf2(symbols.size() * 4 / 3), 1024);
 3034   alignment = std::max(alignment, ms->alignment);

  984   p_align = std::max(p_align, sec->alignment);

  556       segFileSize = std::max(segFileSize, sectOffset + sectFileSize);

  416       _minVersion = std::max(_minVersion, v);
 1606     normFile.minOSverson = std::max(context.osMinVersion(), util.minVersion());

   26     alignment = std::max(alignment, inSeg->getAlignment());

  241     out.dylinkSec->memAlign = std::max(out.dylinkSec->memAlign, seg->alignment);

   54       auto new_end = std::max<BaseType>(GetRangeEnd(), rhs.GetRangeEnd());
  197                 std::max<BaseType>(prev->GetRangeEnd(), pos->GetRangeEnd()));

  276       std::max(3, (int)line_number_stream.str().length() + 1);

   55     std::max(1u, std::thread::hardware_concurrency());

  628       max_name_len = std::max<size_t>(property->GetName().size(), max_name_len);

 1687           llvm::alignTo(NextVMAddress, std::max<addr_t>(H.sh_addralign, 1));
 1779     uint32_t Log2Align = llvm::Log2_64(std::max<elf_xword>(PHdr.p_align, 1));

 1715                 std::max(section_max_file_offset, segment_max_file_offset) -

  291   return std::max<std::size_t>(ecx, sizeof(FPR));

   61   numpages = std::max<uint64_t>(1, numpages);

  211     ScopedTimeout timeout(*this, std::max(GetPacketTimeout(), seconds(6)));

 1321       range_size = std::max<addr_t>(exe_byte_size, oso_byte_size);

   90     vold = std::max(*vold, vnew);

   33   CurrentIndent = std::max<int>(0, CurrentIndent - Amount);

  962   addr_t EndOfRegion = Addr + std::max<size_t>(Size, 1);

  543       const uint32_t comment_row = std::max(line_strm.str().size(), (size_t)60);

   73   for (unsigned i = std::max<size_t>(1, LineInfo.Line - Context);

  331           Line = std::max(CR.LineEnd, Line);
  947         std::max(1U, std::min(llvm::heavyweight_hardware_concurrency(),

  157     NumThreads = std::max(1U, std::min(llvm::heavyweight_hardware_concurrency(),

   97     FileReportColumns[0] = std::max(FileReportColumns[0], Filename.size());
  100         std::max(FunctionReportColumns[0], Funcname.size());
  360         std::max(1U, std::min(llvm::heavyweight_hardware_concurrency(),

   45     Covered = std::max(Covered, RHS.Covered);
   46     NumRegions = std::max(NumRegions, RHS.NumRegions);
   86     Covered = std::max(Covered, RHS.Covered);
   87     NumLines = std::max(NumLines, RHS.NumLines);

  162     BucketVal = std::max(BucketVal, (uint64_t)Val);

  421   MaxValue = std::max(MaxValue, BM.PerInstructionValue);

  275           std::max<double>(LatencyMeasure.PerInstructionValue, WLE->Cycles);

  122         P2CurrentAlignment = std::max(P2CurrentAlignment,
  134   return std::max(

   38   unsigned NumRegFiles = std::max(PI.NumRegisterFiles, 1U);
   55         std::max(RFU.MaxUsedMappings, RFU.CurrentlyUsedMappings);
   98     CurrentMax = std::max(CurrentMax, MEI.CurrentMovesEliminated);

   51   MaxUsedEntries = std::max(MaxUsedEntries, EntriesInUse);

   95     BU.MaxUsedSlots = std::max(BU.MaxUsedSlots, BU.SlotsInUse);

  104     LastCycle = std::max(LastCycle, CurrentCycle);

  520         std::max(std::max(sizeof(object::Elf_Chdr_Impl<object::ELF64LE>),
  520         std::max(std::max(sizeof(object::Elf_Chdr_Impl<object::ELF64LE>),
  522                  std::max(sizeof(object::Elf_Chdr_Impl<object::ELF32LE>),
  733       MaxLocalIndex = std::max(MaxLocalIndex, Sym->Index);
 1910           alignTo(Offset, std::max<uint64_t>(Seg->Align, 1), Seg->VAddr);
 1912     Offset = std::max(Offset, Seg->Offset + Seg->FileSize);
 2177       Offset = std::max(Offset, Segment->Offset + Segment->FileSize);
 2190       TotalSize = std::max(TotalSize, Sec.Offset + Sec.Size);

  154         VMSize = std::max(VMSize, Sec.Addr + Sec.Size);
  163           SegFileSize = std::max(SegFileSize, SectOffset + Sec.Size);
  164           VMSize = std::max(VMSize, SegFileSize);

 1357         Index = std::max<uint64_t>(Index, StartAddress - SectionAddr);
 1703     MaxWidth = std::max(MaxWidth, Name.size());

  110       std::max(VectorizationFactor, RHS.VectorizationFactor);
  111     InterleaveCount = std::max(InterleaveCount, RHS.InterleaveCount);
  112     UnrollCount = std::max(UnrollCount, RHS.UnrollCount);

  329                  fmt_align(I, AlignStyle::Right, std::max(Digits, 4U)));
  335                fmt_align(I, AlignStyle::Right, std::max(Digits, 4U)),

  765     L = std::max(L, Label.size());
  817     LongestNamespace = std::max(LongestNamespace, Scope.size());
  850   size_t FieldWidth = std::max(LongestNamespace, LongestTypeLeafKind);
  858   CD = std::max(CD, CountHeader.size());
  862   SD = std::max(SD, SizeHeader.size());

   79   CurrentIndent = std::max<int>(0, CurrentIndent - Amount);

  880       FuncMax = std::max(FuncMax, Func.Counts[I]);

  395       max_name_len = std::max(max_name_len, name_or_err->size());
  396       max_size_len = std::max(max_size_len, getNumLengthAsString(size));
  397       max_addr_len = std::max(max_addr_len, getNumLengthAsString(addr));

  129     MM = std::make_pair(std::min(MM.first, V), std::max(MM.second, V));
  132 template <class T> T diff(T L, T R) { return std::max(L, R) - std::min(L, R); }

  113   double n = std::max(std::min(B, 1.0), 0.0);

  279   double CappedRelDiff = std::min(1.0, std::max(-1.0, RelDiff));
  300   double CappedRelDiff = std::min(1.0, std::max(-1.0, RelDiff));

  161 template <class T> T diff(T L, T R) { return std::max(L, R) - std::min(L, R); }
  273   M.Count = std::max(M.Count, S.Count);
  274   M.Min = std::max(M.Min, S.Min);
  275   M.Median = std::max(M.Median, S.Median);
  276   M.Pct90 = std::max(M.Pct90, S.Pct90);
  277   M.Pct99 = std::max(M.Pct99, S.Pct99);
  278   M.Max = std::max(M.Max, S.Max);
  279   M.Sum = std::max(M.Sum, S.Sum);

  433             std::max(E.second, R.TSC) - std::min(E.second, R.TSC));
  437             std::max(Deepest.second, R.TSC) - std::min(Deepest.second, R.TSC));
  440             std::max(Deepest.second, R.TSC) - std::min(Deepest.second, R.TSC));

 2536     MaxLoopDepth = std::max(MaxLoopDepth, Depth);

 1353     MaxLoopDepth = std::max(MaxLoopDepth, Stats.MaxDepth + 1);
 1382       MaxLoopDepth = std::max(MaxLoopDepth, Stats.MaxDepth);
 1787         std::max(MaxNumLoopsInScop.getValue(), (unsigned)Stats.NumLoops);
 1805         std::max(MaxNumLoopsInProfScop.getValue(), (unsigned)Stats.NumLoops);

  129       End = End ? std::max(End, DL) : DL;

 2636       std::max(MaxNumLoopsInScop.getValue(), (unsigned)Stats.NumLoops);

  194       ConstantInt::get(LongType, std::max<int>(PollyChunkSize, 1));

  163     Dims = std::max(Dims, Map.dim(isl::dim::out));

   93     Type = std::max(Type, ToMerge.Type);

   40       LineEnd = std::max(LineEnd, NewLine);

  135     Dims = std::max(Dims, Map.dim(isl::dim::out));

  569   auto MaxDim = std::max(DstPos, SrcPos);
  812              std::max(FirstDim, SecondDim));

  256     EXPECT_EQ(std::max(A, B), B);
  279     EXPECT_EQ(std::max(A, B), B);
  302   EXPECT_EQ(max(Align(2), Align(4)), Align(4));
  303   EXPECT_EQ(max(MaybeAlign(2), MaybeAlign(4)), MaybeAlign(4));
  304   EXPECT_EQ(max(MaybeAlign(), MaybeAlign()), MaybeAlign());

  942 	                             + std::max(this->_M_impl._M_map_size,

  967 	    std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),
 2049 	= std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),

  603 	      _M_next_bkt(std::max<std::size_t>(__builtin_floor(__min_bkts) + 1,

 1256 	  _M_d = std::round(std::max<double>(6.0, std::min(__m, __dx)));
 1464 	  _M_d1 = std::round(std::max<double>(1.0, __d1x));
 1468 	  _M_d2 = std::round(std::max<double>(1.0, __d2x));
 3268       const size_t __m = std::max(size_t(__s + 1), __n);
 3323       const size_t __m = std::max<size_t>(1UL,

 1261       const size_type __len = size() + std::max(size(), __n);

  687       this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,

 1507 	const size_type __len = size() + std::max(size(), __n);

  322     LabelWidth = std::max((std::string::size_type)LabelWidth, A.Label.size());
  337           std::max(DiagItr->InputStartCol + 1, DiagItr->InputEndCol);
  423   LabelWidth = std::max(LabelWidth, LineNoWidth) + 3;

 1969       MaxNumOperands = std::max(MaxNumOperands, MI->AsmOperands.size());
 2076     MaxRowLength = std::max(MaxRowLength, II->ResOperands.size()*2 + 1 );
 3322     MaxNumOperands = std::max(MaxNumOperands, MI->AsmOperands.size());
 3327     MaxMnemonicIndex = std::max(MaxMnemonicIndex,

  318       MaxStringIdx = std::max(MaxStringIdx, Idx);

  414           BitWidth = std::max(BitWidth, BI->getNumBits());
  421     BitWidth = std::max(BitWidth, BI->getNumBits());

 1763         NumResults = std::max(NumResults, T->getNumTypes());
 1776       NumResults = std::max(NumResults, GetNumNodeResults(Op, CDP));

  656         CostPerUse = std::max(CostPerUse,
 1707   NormalRegs.resize(std::max(Reg->EnumValue + 1, NormalRegs.size()));

 5067     MaxTemporaries = std::max(MaxTemporaries, Rule.countRendererFns());

  606       std::max(maxArgAttrs, unsigned(intrinsic.ArgumentAttributes.size()));

  261     MaxRegUnitWeight = std::max(MaxRegUnitWeight, RegUnits.Weight);
  380     maxLength = std::max((size_t)maxLength, RegNums.size());
  512     maxLength = std::max((size_t)maxLength,

  647         std::max(ReorderBufferSize, RCU->getValueAsInt("ReorderBufferSize"));
  649         std::max(MaxRetirePerCycle, RCU->getValueAsInt("MaxRetirePerCycle"));

  259       double multiplier = min_time * 1.4 / std::max(seconds, 1e-9);
  268       double next_iters = std::max(multiplier * iters, iters + 1.0);
  401         std::max<size_t>(name_field_width, benchmark.name.size());
  405       stat_field_width = std::max<size_t>(stat_field_width, Stat.name_.size());

  151     const std::size_t cNameLen = std::max(std::string::size_type(10),

   43       std::max(thresh, 1.0 / std::pow(10.0, precision));

  410         MaxID = std::max(CurID, MaxID);

   28     cpu_time_used_ += std::max<double>(ThreadCPUUsage() - start_cpu_time_, 0);