File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/llvm/lib/Support

usr / src / contrib / llvm-project / llvm / lib / Support /

📁 ..
📄 AArch64TargetParser.cpp(8 KB)
📄 ABIBreak.cpp(811 B)
📄 AMDGPUMetadata.cpp(9.37 KB)
📄 APFloat.cpp(155.26 KB)
📄 APInt.cpp(98.08 KB)
📄 APSInt.cpp(1.44 KB)
📄 ARMAttributeParser.cpp(13.94 KB)
📄 ARMBuildAttrs.cpp(3.45 KB)
📄 ARMTargetParser.cpp(18.09 KB)
📄 ARMWinEH.cpp(1.08 KB)
📄 Allocator.cpp(1.35 KB)
📄 Atomic.cpp(1.6 KB)
📄 BinaryStreamError.cpp(1.76 KB)
📄 BinaryStreamReader.cpp(5.24 KB)
📄 BinaryStreamRef.cpp(4.76 KB)
📄 BinaryStreamWriter.cpp(3.36 KB)
📄 BlockFrequency.cpp(2.12 KB)
📄 BranchProbability.cpp(3.44 KB)
📄 BuryPointer.cpp(1.11 KB)
📄 COM.cpp(737 B)
📄 COPYRIGHT.regex(2.65 KB)
📄 CRC.cpp(5.23 KB)
📄 CachePruning.cpp(10.33 KB)
📄 Chrono.cpp(3.17 KB)
📄 CodeGenCoverage.cpp(3.61 KB)
📄 CommandLine.cpp(89.06 KB)
📄 Compression.cpp(3.84 KB)
📄 ConvertUTF.cpp(27.27 KB)
📄 ConvertUTFWrapper.cpp(8.66 KB)
📄 CrashRecoveryContext.cpp(15.45 KB)
📄 DAGDeltaAlgorithm.cpp(12.47 KB)
📄 DJB.cpp(2.71 KB)
📄 DataExtractor.cpp(7.25 KB)
📄 Debug.cpp(5.64 KB)
📄 DebugCounter.cpp(4.95 KB)
📄 DeltaAlgorithm.cpp(3.41 KB)
📄 DynamicLibrary.cpp(6.25 KB)
📄 ELFAttributeParser.cpp(7.27 KB)
📄 ELFAttributes.cpp(1.27 KB)
📄 Errno.cpp(2.18 KB)
📄 Error.cpp(4.72 KB)
📄 ErrorHandling.cpp(11.08 KB)
📄 ExtensibleRTTI.cpp(446 B)
📄 FileCheck.cpp(95.77 KB)
📄 FileCheckImpl.h(34.14 KB)
📄 FileCollector.cpp(9.01 KB)
📄 FileOutputBuffer.cpp(6.62 KB)
📄 FileUtilities.cpp(10.81 KB)
📄 FoldingSet.cpp(15.89 KB)
📄 FormatVariadic.cpp(5.17 KB)
📄 FormattedStream.cpp(5.29 KB)
📄 GlobPattern.cpp(5 KB)
📄 GraphWriter.cpp(9.21 KB)
📄 Hashing.cpp(1.16 KB)
📄 Host.cpp(51.63 KB)
📄 InitLLVM.cpp(1.92 KB)
📄 IntEqClasses.cpp(2.18 KB)
📄 IntervalMap.cpp(4.4 KB)
📄 ItaniumManglingCanonicalizer.cpp(10.77 KB)
📄 JSON.cpp(19.1 KB)
📄 KnownBits.cpp(3.78 KB)
📄 LEB128.cpp(1.19 KB)
📄 LineIterator.cpp(2.61 KB)
📄 Locale.cpp(377 B)
📄 LockFileManager.cpp(10.64 KB)
📄 LowLevelType.cpp(2.09 KB)
📄 MD5.cpp(8.99 KB)
📄 ManagedStatic.cpp(2.37 KB)
📄 MathExtras.cpp(913 B)
📄 MemAlloc.cpp(1.01 KB)
📄 Memory.cpp(1.57 KB)
📄 MemoryBuffer.cpp(18.99 KB)
📄 NativeFormatting.cpp(7.54 KB)
📄 OptimizedStructLayout.cpp(16.7 KB)
📄 Optional.cpp(530 B)
📄 Parallel.cpp(5.08 KB)
📄 Path.cpp(36.52 KB)
📄 PluginLoader.cpp(1.63 KB)
📄 PrettyStackTrace.cpp(10.33 KB)
📄 Process.cpp(3.27 KB)
📄 Program.cpp(3.54 KB)
📄 RISCVAttributeParser.cpp(2.06 KB)
📄 RISCVAttributes.cpp(970 B)
📄 RWMutex.cpp(3.23 KB)
📄 RandomNumberGenerator.cpp(2.86 KB)
📄 Regex.cpp(6.38 KB)
📄 SHA1.cpp(10.43 KB)
📄 ScaledNumber.cpp(9.09 KB)
📄 ScopedPrinter.cpp(1.19 KB)
📄 Signals.cpp(8.35 KB)
📄 Signposts.cpp(3.24 KB)
📄 SmallPtrSet.cpp(9.21 KB)
📄 SmallVector.cpp(3.99 KB)
📄 SourceMgr.cpp(20.08 KB)
📄 SpecialCaseList.cpp(7.48 KB)
📄 Statistic.cpp(8.85 KB)
📄 StringExtras.cpp(4.34 KB)
📄 StringMap.cpp(9.31 KB)
📄 StringRef.cpp(17.41 KB)
📄 StringSaver.cpp(882 B)
📄 SuffixTree.cpp(7.23 KB)
📄 SymbolRemappingReader.cpp(2.94 KB)
📄 SystemUtils.cpp(1.06 KB)
📄 TarWriter.cpp(7.23 KB)
📄 TargetParser.cpp(9.86 KB)
📄 TargetRegistry.cpp(4.6 KB)
📄 ThreadLocal.cpp(1.68 KB)
📄 ThreadPool.cpp(4.4 KB)
📄 Threading.cpp(4.55 KB)
📄 TimeProfiler.cpp(11.63 KB)
📄 Timer.cpp(14.14 KB)
📄 ToolOutputFile.cpp(1.83 KB)
📄 TrigramIndex.cpp(3.24 KB)
📄 Triple.cpp(53.17 KB)
📄 Twine.cpp(4.6 KB)
📄 Unicode.cpp(20.14 KB)
📄 UnicodeCaseFold.cpp(15.32 KB)
📁 Unix
📄 Valgrind.cpp(1.6 KB)
📄 VersionTuple.cpp(2.74 KB)
📄 VirtualFileSystem.cpp(74.17 KB)
📄 Watchdog.cpp(738 B)
📁 Windows
📄 WithColor.cpp(4.35 KB)
📄 X86TargetParser.cpp(27.21 KB)
📄 YAMLParser.cpp(68.53 KB)
📄 YAMLTraits.cpp(28.37 KB)
📄 Z3Solver.cpp(31.44 KB)
📄 circular_raw_ostream.cpp(1.3 KB)
📄 raw_os_ostream.cpp(995 B)
📄 raw_ostream.cpp(28.97 KB)
📄 regcomp.c(39.42 KB)
📄 regengine.inc(26.49 KB)
📄 regerror.c(4.42 KB)
📄 regex2.h(6.82 KB)
📄 regex_impl.h(3.63 KB)
📄 regexec.c(5.71 KB)
📄 regfree.c(2.49 KB)
📄 regstrlcpy.c(1.56 KB)
📄 regutils.h(2.25 KB)
📄 xxhash.cpp(4.07 KB)

Editing: IntervalMap.cpp

//===- lib/Support/IntervalMap.cpp - A sorted interval map ----------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the few non-templated functions in IntervalMap.
//
//===----------------------------------------------------------------------===//

#include "llvm/ADT/IntervalMap.h"
#include <cassert>

namespace llvm {
namespace IntervalMapImpl {

void Path::replaceRoot(void *Root, unsigned Size, IdxPair Offsets) {
  assert(!path.empty() && "Can't replace missing root");
  path.front() = Entry(Root, Size, Offsets.first);
  path.insert(path.begin() + 1, Entry(subtree(0), Offsets.second));
}

NodeRef Path::getLeftSibling(unsigned Level) const {
  // The root has no siblings.
  if (Level == 0)
    return NodeRef();

// Go up the tree until we can go left.
  unsigned l = Level - 1;
  while (l && path[l].offset == 0)
    --l;

// We can't go left.
  if (path[l].offset == 0)
    return NodeRef();

// NR is the subtree containing our left sibling.
  NodeRef NR = path[l].subtree(path[l].offset - 1);

// Keep right all the way down.
  for (++l; l != Level; ++l)
    NR = NR.subtree(NR.size() - 1);
  return NR;
}

void Path::moveLeft(unsigned Level) {
  assert(Level != 0 && "Cannot move the root node");

// Go up the tree until we can go left.
  unsigned l = 0;
  if (valid()) {
    l = Level - 1;
    while (path[l].offset == 0) {
      assert(l != 0 && "Cannot move beyond begin()");
      --l;
    }
  } else if (height() < Level)
    // end() may have created a height=0 path.
    path.resize(Level + 1, Entry(nullptr, 0, 0));

// NR is the subtree containing our left sibling.
  --path[l].offset;
  NodeRef NR = subtree(l);

// Get the rightmost node in the subtree.
  for (++l; l != Level; ++l) {
    path[l] = Entry(NR, NR.size() - 1);
    NR = NR.subtree(NR.size() - 1);
  }
  path[l] = Entry(NR, NR.size() - 1);
}

NodeRef Path::getRightSibling(unsigned Level) const {
  // The root has no siblings.
  if (Level == 0)
    return NodeRef();

// Go up the tree until we can go right.
  unsigned l = Level - 1;
  while (l && atLastEntry(l))
    --l;

// We can't go right.
  if (atLastEntry(l))
    return NodeRef();

// NR is the subtree containing our right sibling.
  NodeRef NR = path[l].subtree(path[l].offset + 1);

// Keep left all the way down.
  for (++l; l != Level; ++l)
    NR = NR.subtree(0);
  return NR;
}

void Path::moveRight(unsigned Level) {
  assert(Level != 0 && "Cannot move the root node");

// Go up the tree until we can go right.
  unsigned l = Level - 1;
  while (l && atLastEntry(l))
    --l;

// NR is the subtree containing our right sibling. If we hit end(), we have
  // offset(0) == node(0).size().
  if (++path[l].offset == path[l].size)
    return;
  NodeRef NR = subtree(l);

for (++l; l != Level; ++l) {
    path[l] = Entry(NR, 0);
    NR = NR.subtree(0);
  }
  path[l] = Entry(NR, 0);
}

IdxPair distribute(unsigned Nodes, unsigned Elements, unsigned Capacity,
                   const unsigned *CurSize, unsigned NewSize[],
                   unsigned Position, bool Grow) {
  assert(Elements + Grow <= Nodes * Capacity && "Not enough room for elements");
  assert(Position <= Elements && "Invalid position");
  if (!Nodes)
    return IdxPair();

// Trivial algorithm: left-leaning even distribution.
  const unsigned PerNode = (Elements + Grow) / Nodes;
  const unsigned Extra = (Elements + Grow) % Nodes;
  IdxPair PosPair = IdxPair(Nodes, 0);
  unsigned Sum = 0;
  for (unsigned n = 0; n != Nodes; ++n) {
    Sum += NewSize[n] = PerNode + (n < Extra);
    if (PosPair.first == Nodes && Sum > Position)
      PosPair = IdxPair(n, Position - (Sum - NewSize[n]));
  }
  assert(Sum == Elements + Grow && "Bad distribution sum");

// Subtract the Grow element that was added.
  if (Grow) {
    assert(PosPair.first < Nodes && "Bad algebra");
    assert(NewSize[PosPair.first] && "Too few elements to need Grow");
    --NewSize[PosPair.first];
  }

#ifndef NDEBUG
  Sum = 0;
  for (unsigned n = 0; n != Nodes; ++n) {
    assert(NewSize[n] <= Capacity && "Overallocated node");
    Sum += NewSize[n];
  }
  assert(Sum == Elements && "Bad distribution sum");
#endif

return PosPair;
}

} // namespace IntervalMapImpl
} // namespace llvm

003 File Manager

Editing: IntervalMap.cpp

Upload File

Create Folder