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

References

include/llvm/Bitstream/BitstreamReader.h

  175           support::endian::read<word_t, support::little, support::unaligned>(

include/llvm/Bitstream/BitstreamWriter.h

   70     Value = support::endian::byte_swap<uint32_t, support::little>(Value);
  107     assert((!endian::readAtBitAlignment<uint32_t, little, unaligned>(
  110     endian::writeAtBitAlignment<uint32_t, little, unaligned>(

include/llvm/CodeGen/FaultMaps.h

  102     return support::endian::read<T, support::little, 1>(P);

include/llvm/DebugInfo/CodeView/SymbolDeserializer.h

   27         : Stream(RecordData, llvm::support::little), Reader(Stream),

include/llvm/DebugInfo/CodeView/TypeDeserializer.h

   31         : Stream(RecordData, llvm::support::little), Reader(Stream),

include/llvm/DebugInfo/MSF/MappedBlockStream.h

   60     return support::little;
  127     return support::little;

include/llvm/MC/MCMachObjectWriter.h

  129         W(OS, IsLittleEndian ? support::little : support::big) {}

include/llvm/Object/COFF.h

 1208   explicit ResourceSectionRef(StringRef Ref) : BBS(Ref, support::little) {}

include/llvm/Object/ELFObjectFile.h

  383         Attributes.Parse(Contents, ELFT::TargetEndianness == support::little);
  435     return v->getType() == getELFType(ELFT::TargetEndianness == support::little,
  990           getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits),
 1055   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
 1121   bool IsLittleEndian = ELFT::TargetEndianness == support::little;

include/llvm/Object/ELFTypes.h

   94 using ELF32LE = ELFType<support::little, false>;
   96 using ELF64LE = ELFType<support::little, true>;

include/llvm/ProfileData/InstrProf.h

  923   return sys::IsLittleEndianHost ? support::little : support::big;

include/llvm/ProfileData/InstrProfReader.h

  245     if (HostEndian == support::little)
  248       return support::little;
  305   support::endianness ValueProfDataEndianness = support::little;
  328     offset_type KeyLen = endian::readNext<offset_type, little, unaligned>(D);
  329     offset_type DataLen = endian::readNext<offset_type, little, unaligned>(D);

include/llvm/Support/BinaryByteStream.h

  137   llvm::support::endianness Endian = llvm::support::little;

include/llvm/Support/Endian.h

   47   return sys::IsBigEndianHost ? big : little;
  272     detail::packed_endian_specific_integral<uint16_t, little, unaligned>;
  274     detail::packed_endian_specific_integral<uint32_t, little, unaligned>;
  276     detail::packed_endian_specific_integral<uint64_t, little, unaligned>;
  279     detail::packed_endian_specific_integral<int16_t, little, unaligned>;
  281     detail::packed_endian_specific_integral<int32_t, little, unaligned>;
  283     detail::packed_endian_specific_integral<int64_t, little, unaligned>;
  286     detail::packed_endian_specific_integral<uint16_t, little, aligned>;
  288     detail::packed_endian_specific_integral<uint32_t, little, aligned>;
  290     detail::packed_endian_specific_integral<uint64_t, little, aligned>;
  293     detail::packed_endian_specific_integral<int16_t, little, aligned>;
  295     detail::packed_endian_specific_integral<int32_t, little, aligned>;
  297     detail::packed_endian_specific_integral<int64_t, little, aligned>;
  342 using little_t = detail::packed_endian_specific_integral<T, little, unaligned>;
  348     detail::packed_endian_specific_integral<T, little, aligned>;
  382 inline uint16_t read16le(const void *P) { return read16<little>(P); }
  383 inline uint32_t read32le(const void *P) { return read32<little>(P); }
  384 inline uint64_t read64le(const void *P) { return read64<little>(P); }
  417 inline void write16le(void *P, uint16_t V) { write16<little>(P, V); }
  418 inline void write32le(void *P, uint32_t V) { write32<little>(P, V); }
  419 inline void write64le(void *P, uint64_t V) { write64<little>(P, V); }

include/llvm/Support/MD5.h

   69       return endian::read<uint64_t, little, unaligned>(Bytes.data());
   74       return endian::read<uint64_t, little, unaligned>(Bytes.data() + 8);

include/llvm/Support/OnDiskHashTable.h

  153     endian::Writer LE(Out, little);
  308         endian::readNext<offset_type, little, aligned>(Buckets);
  310         endian::readNext<offset_type, little, aligned>(Buckets);
  361     offset_type Offset = endian::readNext<offset_type, little, aligned>(Bucket);
  368     unsigned Len = endian::readNext<uint16_t, little, unaligned>(Items);
  373           endian::readNext<hash_value_type, little, unaligned>(Items);
  471             endian::readNext<uint16_t, little, unaligned>(Ptr);

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 3114     BinaryStreamWriter Writer(data, llvm::support::endianness::little);

lib/DebugInfo/CodeView/CVTypeVisitor.cpp

  187       : Stream(Data, llvm::support::little), Reader(Stream),

lib/DebugInfo/CodeView/LazyRandomTypeCollection.cpp

   73   BinaryStreamReader Reader(Data, support::little);
   79   BinaryStreamReader Reader(Data, support::little);

lib/DebugInfo/CodeView/RecordName.cpp

  321     BinaryStreamReader Reader(Sym.content(), llvm::support::little);

lib/DebugInfo/CodeView/RecordSerialization.cpp

  106   BinaryByteStream S(Bytes, llvm::support::little);
  132   BinaryByteStream S(Bytes, llvm::support::little);

lib/DebugInfo/CodeView/SimpleTypeSerializer.cpp

   25   BinaryStreamWriter Writer(ScratchBuffer, support::little);

lib/DebugInfo/CodeView/SymbolSerializer.cpp

   23     : Storage(Allocator), Stream(RecordBuffer, support::little), Writer(Stream),

lib/DebugInfo/CodeView/TypeIndexDiscovery.cpp

  471   BinaryStreamReader Reader(RecordData, support::little);

lib/DebugInfo/GSYM/GsymReader.cpp

   80       Endian = sys::IsBigEndianHost ? support::little : support::big;
   88   bool DataIsLittleEndian = HostByteOrder != support::little;

lib/DebugInfo/MSF/MSFBuilder.cpp

  352                               llvm::support::little);

lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp

  194                                            llvm::support::little);

lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp

  308   BinaryItemStream<CVSymbol> ItemStream(support::endianness::little);

lib/DebugInfo/PDB/Native/NativeSession.cpp

   63       std::move(Buffer), llvm::support::little);

lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp

  138         std::make_unique<BinaryByteStream>(Bytes, llvm::support::little);

lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp

   87   return Obj.isLittleEndian() ? support::little : support::big;

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

   38   isBE ? write<T, support::big>(P, V) : write<T, support::little>(P, V);

lib/MC/ELFObjectWriter.cpp

  169         W(OS, IsLittleEndian ? support::little : support::big), Mode(Mode) {}
  423   W.OS << char(W.Endian == support::little ? ELF::ELFDATA2LSB

lib/MC/MCAsmBackend.cpp

   37                                  Endian == support::little);
   40                                   OS, Endian == support::little);
   62                                   OS, DwoOS, Endian == support::little);

lib/MC/MCAssembler.cpp

  586       unsigned index = Endian == support::little ? I : (VSize - I - 1);

lib/MC/MCCodeView.cpp

  643     support::endian::Writer LEWriter(OS, support::little);

lib/MC/MCDwarf.cpp

 1910       Context.getAsmInfo()->isLittleEndian() ? support::little : support::big;

lib/MC/MachObjectWriter.cpp

  634       if (W.Endian == support::little)

lib/MC/WasmObjectWriter.cpp

  270       : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {}

lib/MC/WinCOFFObjectWriter.cpp

  237     : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {

lib/Object/ArchiveWriter.cpp

  147                          isBSDLike(Kind) ? support::little : support::big);

lib/Object/COFFObjectFile.cpp

 1767   BBS = BinaryByteStream(*Contents, support::little);

lib/Object/WindowsResource.cpp

   55                          support::little);

lib/ObjectYAML/COFFEmitter.cpp

  196   BinaryStreamWriter Writer(Output, support::little);
  322   support::endian::write<value_type, support::little, support::unaligned>(

lib/ObjectYAML/CodeViewYAMLDebugSections.cpp

  903   BinaryStreamReader Reader(Data, support::little);

lib/ObjectYAML/CodeViewYAMLTypeHashing.cpp

   52   BinaryStreamReader Reader(DebugH, llvm::support::little);
   72   BinaryStreamWriter Writer(Buffer, llvm::support::little);

lib/ObjectYAML/CodeViewYAMLTypes.cpp

  779   BinaryStreamReader Reader(DebugTorP, support::little);
  808   BinaryStreamWriter Writer(Output, support::little);

lib/ProfileData/Coverage/CoverageMappingReader.cpp

  595   if (BytesInAddress == 4 && Endian == support::endianness::little) {
  597             readCoverageMappingData<uint32_t, support::endianness::little>(
  606   } else if (BytesInAddress == 8 && Endian == support::endianness::little) {
  608             readCoverageMappingData<uint64_t, support::endianness::little>(
  625   support::endianness Endian = support::endianness::little;
  702                                    ? support::endianness::little

lib/ProfileData/InstrProf.cpp

  844   if (Orig == little)
  845     return endian::readNext<T, little, unaligned>(D);

lib/ProfileData/InstrProfReader.cpp

  543     uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D);
  551       CountsSize = endian::readNext<uint64_t, little, unaligned>(D);
  560       CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
  738       endian::read<uint64_t, little, aligned>(DataBuffer.getBufferStart());
  753         endian::byte_swap<uint64_t, little>(SummaryInLE->NumSummaryFields);
  755         endian::byte_swap<uint64_t, little>(SummaryInLE->NumCutoffEntries);
  764       Dst[I] = endian::byte_swap<uint64_t, little>(Src[I]);
  810   uint64_t Magic = endian::byte_swap<uint64_t, little>(Header->Magic);
  815   uint64_t FormatVersion = endian::byte_swap<uint64_t, little>(Header->Version);
  828       endian::byte_swap<uint64_t, little>(Header->HashType));
  832   uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);

lib/ProfileData/InstrProfWriter.cpp

   51       : IsFDOStream(true), OS(FD), LE(FD, support::little) {}
   53       : IsFDOStream(false), OS(STR), LE(STR, support::little) {}
   76           uint64_t Bytes = endian::byte_swap<uint64_t, little>(P[K].D[I]);
  102   support::endianness ValueProfDataEndianness = support::little;
  116     endian::Writer LE(Out, little);
  143     endian::Writer LE(Out, little);

lib/ProfileData/SampleProfReader.cpp

  334   T Val = endian::readNext<T, little, unaligned>(Data);

lib/ProfileData/SampleProfWriter.cpp

  335   support::endian::Writer Writer(*OutputStream, support::little);
  409   support::endian::Writer Writer(*OutputStream, support::little);
  428   support::endian::Writer Writer(*OutputStream, support::little);
  469   support::endian::Writer Writer(*OutputStream, support::little);

lib/Remarks/YAMLRemarkParser.cpp

   77       support::endian::read<uint64_t, support::little, support::unaligned>(
   93       support::endian::read<uint64_t, support::little, support::unaligned>(

lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

   40       : MCAsmBackend(IsLittleEndian ? support::little : support::big),
  332   if (Endian == support::little)

lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp

  610   support::endian::write<uint32_t>(OS, Binary, support::little);

lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.cpp

  236   const auto Res = support::endian::read<T, support::endianness::little>(Bytes.data());

lib/Target/AMDGPU/MCTargetDesc/AMDGPUAsmBackend.cpp

   30   AMDGPUAsmBackend(const Target &T) : MCAsmBackend(support::little) {}

lib/Target/AMDGPU/MCTargetDesc/R600MCCodeEmitter.cpp

  160   support::endian::write(OS, Value, support::little);
  164   support::endian::write(OS, Value, support::little);

lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.cpp

  610   support::endian::Writer EW(OS, support::endianness::little);

lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp

  180   return (Endian == support::little ? InfosLE
  478     return swapHalfWords(Value, Endian == support::little);
  501       return swapHalfWords(Value, Endian == support::little);
  534     return swapHalfWords(out, Endian == support::little);
  571     return swapHalfWords(out, Endian == support::little);
  589     return swapHalfWords(out, Endian == support::little);
  625     return joinHalfWords(FirstHalf, SecondHalf, Endian == support::little);
  661     return joinHalfWords(FirstHalf, SecondHalf, Endian == support::little);
  752       return swapHalfWords(Value, Endian == support::little);
  783       return swapHalfWords(Value, Endian == support::little);
  809     return swapHalfWords(EncValue, Endian == support::little);
  818     return swapHalfWords(out, Endian == support::little);
  834     return swapHalfWords(out, Endian == support::little);
  848     return swapHalfWords(out, Endian == support::little);
  863     return swapHalfWords(out, Endian == support::little);
 1061     unsigned Idx = Endian == support::little ? i : (FullSizeBytes - 1 - i);
 1336   return createARMAsmBackend(T, STI, MRI, Options, support::little);

lib/Target/ARM/MCTargetDesc/ARMAsmBackendDarwin.h

   23       : ARMAsmBackend(T, STI, support::little), MRI(MRI), Subtype(st) {}

lib/Target/ARM/MCTargetDesc/ARMAsmBackendWinCOFF.h

   20       : ARMAsmBackend(T, STI, support::little) {}

lib/Target/AVR/MCTargetDesc/AVRAsmBackend.h

   34       : MCAsmBackend(support::little), OSType(OSType) {}

lib/Target/BPF/MCTargetDesc/BPFAsmBackend.cpp

   87     if (Endian == support::little) {
  111   return new BPFAsmBackend(support::little);

lib/Target/BPF/MCTargetDesc/BPFMCCodeEmitter.cpp

  126                               IsLittleEndian ? support::little : support::big);

lib/Target/Hexagon/MCTargetDesc/HexagonAsmBackend.cpp

   63       : MCAsmBackend(support::little), OSABI(OSABI), CPU(CPU),

lib/Target/Hexagon/MCTargetDesc/HexagonMCCodeEmitter.cpp

  453   support::endian::write<uint32_t>(OS, Binary, support::little);

lib/Target/MSP430/MCTargetDesc/MSP430AsmBackend.cpp

   37       : MCAsmBackend(support::little), OSABI(OSABI) {}

lib/Target/MSP430/MCTargetDesc/MSP430MCCodeEmitter.cpp

   96     support::endian::write(OS, (uint16_t)BinaryOpCode, support::little);

lib/Target/Mips/MCTargetDesc/MipsAsmBackend.cpp

  284     unsigned Idx = Endian == support::little
  296     unsigned Idx = Endian == support::little
  511   if (Endian == support::little)

lib/Target/Mips/MCTargetDesc/MipsAsmBackend.h

   37       : MCAsmBackend(TT.isLittleEndian() ? support::little : support::big),

lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp

   83       : MCAsmBackend(TT.isLittleEndian() ? support::little : support::big),
  117     return (Endian == support::little
  136       unsigned Idx = Endian == support::little ? i : (NumBytes - 1 - i);

lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp

  292   support::endianness E = IsLittleEndian ? support::little : support::big;

lib/Target/RISCV/MCTargetDesc/RISCVAsmBackend.h

   35       : MCAsmBackend(support::little), STI(STI), OSABI(OSABI), Is64Bit(Is64Bit),

lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp

  126   support::endian::write(OS, Binary, support::little);
  135   support::endian::write(OS, Binary, support::little);
  173   support::endian::write(OS, Binary, support::little);
  202     support::endian::write<uint16_t>(OS, Bits, support::little);
  207     support::endian::write(OS, Bits, support::little);

lib/Target/Sparc/MCTargetDesc/SparcAsmBackend.cpp

  124         : MCAsmBackend(StringRef(T.getName()) == "sparcel" ? support::little
  220       if (Endian == support::little)
  312         unsigned Idx = Endian == support::little ? i : (NumBytes - 1) - i;

lib/Target/Sparc/MCTargetDesc/SparcMCCodeEmitter.cpp

  102                          Ctx.getAsmInfo()->isLittleEndian() ? support::little

lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

  113   T Val = support::endian::read<T, support::endianness::little, 1>(

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyAsmBackend.cpp

   38       : MCAsmBackend(support::little), Is64Bit(Is64Bit),

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCCodeEmitter.cpp

  108           support::endian::write<uint8_t>(OS, MO.getImm(), support::little);
  111           support::endian::write<uint16_t>(OS, MO.getImm(), support::little);
  114           support::endian::write<uint32_t>(OS, MO.getImm(), support::little);
  117           support::endian::write<uint64_t>(OS, MO.getImm(), support::little);
  134         support::endian::write<float>(OS, F, support::little);
  138         support::endian::write<double>(OS, D, support::little);

lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

   76       : MCAsmBackend(support::little), STI(STI) {}

tools/clang/lib/CodeGen/CodeGenPGO.cpp

  730     uint64_t Swapped = endian::byte_swap<uint64_t, little>(Working);

tools/clang/lib/Serialization/ASTReader.cpp

  822   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
  823   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
  832   unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
  834       F, endian::readNext<uint32_t, little, unaligned>(d));
  844         F, endian::readNext<uint32_t, little, unaligned>(d)));
  857       F, endian::readNext<uint32_t, little, unaligned>(d));
  858   unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
  859   unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
  870             F, endian::readNext<uint32_t, little, unaligned>(d)))
  877             F, endian::readNext<uint32_t, little, unaligned>(d)))
  892   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
  893   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
  923   unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
  941   unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
  964   unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
  965   unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
 1001         endian::readNext<uint32_t, little, unaligned>(d);
 1015           F, endian::readNext<uint32_t, little, unaligned>(d)));
 1084   uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
 1092   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
 1093   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
 1108         F, endian::readNext<uint32_t, little, unaligned>(d));
 1115                              F, endian::readNext<uint32_t, little, unaligned>(
 1139     uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
 1854   unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
 1864   ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
 1865   ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
 1886   HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
 1889       M, endian::readNext<uint32_t, little, unaligned>(d));
 1891           endian::readNext<uint32_t, little, unaligned>(d)) {
 1901     uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
 3806       endian::readNext<uint8_t, little, unaligned>(Data));
 3807     uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
 3822         endian::readNext<uint32_t, little, unaligned>(Data);
 3824         endian::readNext<uint32_t, little, unaligned>(Data);
 3826         endian::readNext<uint32_t, little, unaligned>(Data);
 3828         endian::readNext<uint32_t, little, unaligned>(Data);
 3830         endian::readNext<uint32_t, little, unaligned>(Data);
 3832         endian::readNext<uint32_t, little, unaligned>(Data);
 3834         endian::readNext<uint32_t, little, unaligned>(Data);
 3836         endian::readNext<uint32_t, little, unaligned>(Data);

tools/clang/lib/Serialization/ASTWriter.cpp

 2018       endian::Writer LE(Out, little);
 2034       endian::Writer LE(Out, little);
 2046       endian::Writer LE(Out, little);
 2216     endian::write<uint32_t>(Out, 0, little);
 3357     endian::Writer LE(Out, little);
 3376     endian::Writer LE(Out, little);
 3393     endian::Writer LE(Out, little);
 3505       endian::write<uint32_t>(Out, 0, little);
 3687     endian::Writer LE(Out, little);
 3716     endian::Writer LE(Out, little);
 3820       endian::write<uint32_t>(Out, 0, little);
 3916     endian::write<uint32_t>(Out, Writer.getChain()->getModuleFileID(F), little);
 3924     endian::Writer LE(Out, little);
 3958     endian::Writer LE(Out, little);
 3990     endian::Writer LE(Out, little);
 5038         endian::Writer LE(Out, little);

tools/clang/lib/Serialization/GlobalModuleIndex.cpp

   92     unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
   93     unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
  114       unsigned ID = endian::readNext<uint32_t, little, unaligned>(d);
  523       unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
  736     endian::Writer LE(Out, little);
  752       endian::write<uint32_t>(Out, Data[I], little);
  831       endian::write<uint32_t>(Out, 0, little);

tools/clang/lib/Serialization/MultiOnDiskHashTable.h

  202     uint32_t BucketOffset = endian::readNext<uint32_t, little, unaligned>(Ptr);
  205     uint32_t NumFiles = endian::readNext<uint32_t, little, unaligned>(Ptr);
  314       endian::Writer Writer(OutStream, little);

tools/lld/COFF/InputFiles.cpp

  703   BinaryStreamReader reader(data, support::little);
  761   BinaryStreamReader reader(data, support::little);

tools/lld/COFF/PDB.cpp

  992   BinaryStreamReader reader(relocatedDebugContents, support::little);
 1204       BinaryStreamReader reader(relocatedDebugContents, support::little);
 1739     BinaryStreamReader reader(contents, support::little);

tools/lld/ELF/Arch/Mips.cpp

  211   if (E == support::little)
  229   if (E == support::little)
  234   if (E == support::little)

tools/lld/ELF/DWARF.h

   69     return ELFT::TargetEndianness == llvm::support::little;

tools/lld/ELF/Driver.cpp

 1100   config->endianness = config->isLE ? endianness::little : endianness::big;

tools/lld/wasm/WriterUtils.cpp

  100   support::endian::write(os, number, support::little);

tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

   94       std::move(Buffer), llvm::support::little);

tools/lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp

   45     process_info.m_endian = support::little;
  220       Endian == support::little ? eByteOrderLittle : eByteOrderBig, ST);

tools/llvm-jitlink/llvm-jitlink.cpp

  741       S.TT.isLittleEndian() ? support::little : support::big,

tools/llvm-objdump/MachODump.cpp

 7761       support::endian::read<T, little, unaligned>(Contents.data() + Offset);

tools/llvm-objdump/llvm-objdump.cpp

  823                      support::endian::read32<support::little>(Bytes.data()));
 1051       Obj->isLittleEndian() ? support::little : support::big;

tools/llvm-pdbutil/DumpOutputStyle.cpp

 1391     BinaryStreamReader Reader(*ContentsOrErr, llvm::support::little);

tools/llvm-pdbutil/ExplainOutputStyle.cpp

   68                                           llvm::support::little);

tools/llvm-pdbutil/FormatUtil.h

  119           T, support::little, support::unaligned>> {
  121       support::detail::packed_endian_specific_integral<T, support::little,
  135 fmtle(support::detail::packed_endian_specific_integral<T, support::little,

tools/llvm-pdbutil/InputFile.cpp

   83   Reader = BinaryStreamReader(*ContentsOrErr, support::little);

tools/llvm-pdbutil/llvm-pdbutil.cpp

 1389   FileBufferByteStream DestStream(std::move(OutFile), llvm::support::little);

tools/llvm-rc/ResourceFileWriter.cpp

  889   BinaryStreamReader Reader((*File)->getBuffer(), support::little);

tools/llvm-rc/ResourceFileWriter.h

  180     support::detail::packed_endian_specific_integral<T, support::little,

tools/llvm-readobj/COFFDumper.cpp

  922     BinaryStreamRef ST(Contents, support::little);
  964   BinaryStreamReader FSReader(Data, support::little);
 1053       BinaryStreamReader SR(Contents, llvm::support::little);
 1118     BinaryStreamReader Reader(FunctionLineTables[Name], support::little);
 1170   BinaryStreamReader Reader(BinaryData, llvm::support::little);
 1185   BinaryStreamRef Stream(Subsection, llvm::support::little);
 1205   BinaryStreamReader SR(Subsection, llvm::support::little);
 1265       BinaryStreamReader Reader(Data, llvm::support::little);
 1909         W, StackMapParser<support::little>(StackMapContentsArray));

tools/llvm-readobj/DwarfCFIEHPrinter.h

  118                    ELFT::TargetEndianness == support::endianness::little,
  193       ELFT::TargetEndianness == support::endianness::little,

tools/llvm-readobj/ELFDumper.cpp

 4647                                     ELFT::TargetEndianness == support::little,
 5893                                     ELFT::TargetEndianness == support::little,

tools/llvm-readobj/MachODumper.cpp

  689         W, StackMapParser<support::little>(StackMapContentsArray));

tools/llvm-readobj/WindowsResourceDumper.cpp

   30     uint16_t ChValue = support::endian::byte_swap(Ch, support::little);

tools/llvm-rtdyld/llvm-rtdyld.cpp

  923           GetStubInfo, Obj.isLittleEndian() ? support::little : support::big,

tools/llvm-xray/xray-converter.cpp

  103   support::endian::Writer Writer(OS, support::endianness::little);

tools/obj2yaml/coff2yaml.cpp

  124     BinaryStreamReader Reader(sectionData, support::little);

unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp

  156     GlobalTestState() : Strings(Allocator), ItemStream(llvm::support::little) {}
  185     Storage = MutableBinaryByteStream(Bytes, support::little);
  374   BinaryItemStream<CVType> ItemStream(llvm::support::little);
  390   BinaryStreamReader Reader(Buffer, llvm::support::little);

unittests/DebugInfo/GSYM/GSYMTest.cpp

  165   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  176   const llvm::support::endianness ByteOrder = llvm::support::little;
  221   TestFunctionInfoEncodeError(llvm::support::little, InvalidNameFI,
  228   TestFunctionInfoEncodeError(llvm::support::little, InvalidLineTableFI,
  235   TestFunctionInfoEncodeError(llvm::support::little, InvalidInlineInfoFI,
  251   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  290   TestFunctionInfoEncodeDecode(llvm::support::little, FI);
  297   TestFunctionInfoEncodeDecode(llvm::support::little, FILines);
  304   TestFunctionInfoEncodeDecode(llvm::support::little, FIInline);
  312   TestFunctionInfoEncodeDecode(llvm::support::little, FIBoth);
  327   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  340   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  453   TestInlineInfoEncodeDecode(llvm::support::little, Root);
  464   TestInlineInfoEncodeError(llvm::support::little, Empty, EmptyErr);
  472   TestInlineInfoEncodeError(llvm::support::little, ContainsEmpty, EmptyErr);
  483   TestInlineInfoEncodeError(llvm::support::little, ChildNotContained,
  493   const llvm::support::endianness ByteOrder = llvm::support::little;
  713   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  729   TestFileWriterHelper(llvm::support::little);
  749   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  769   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  808   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  842   TestLineTableHelper(llvm::support::little, LT);
  877   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
  888   const llvm::support::endianness ByteOrder = llvm::support::little;
  924   const llvm::support::endianness ByteOrder = llvm::support::little;
  953   const support::endianness ByteOrder = llvm::support::little;
  963   const support::endianness ByteOrder = llvm::support::little;
  965   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
 1008   const llvm::support::endianness ByteOrder = llvm::support::little;
 1038   DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
 1048   TestHeaderEncodeDecode(H, llvm::support::little);
 1072   TestGsymCreatorEncodeError(llvm::support::little, GC,
 1080   TestGsymCreatorEncodeError(llvm::support::little, GC,
 1092   TestGsymCreatorEncodeError(llvm::support::little, GC,
 1101   TestGsymCreatorEncodeError(llvm::support::little, GC,
 1110   TestGsymCreatorEncodeError(llvm::support::little, GC,
 1158   TestEncodeDecode(GC, llvm::support::little,
 1184   TestEncodeDecode(GC, llvm::support::little,
 1210   TestEncodeDecode(GC, llvm::support::little,
 1236   TestEncodeDecode(GC, llvm::support::little,

unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp

   37   endianness getEndian() const override { return little; }
  415   MutableBinaryByteStream SourceStream(SrcData, little);
  514   MutableBinaryByteStream MsfStream(MsfBuffer, llvm::support::little);

unittests/DebugInfo/PDB/HashTableTest.cpp

  149   MutableBinaryByteStream Stream(Buffer, little);
  253   MutableBinaryByteStream Stream(Buffer, little);

unittests/DebugInfo/PDB/StringTableBuilderTest.cpp

   50   MutableBinaryByteStream OutStream(Buffer, little);
   55   BinaryByteStream InStream(Buffer, little);

unittests/MC/StringTableBuilderTest.cpp

   62       support::endian::byte_swap<uint32_t, support::little>(ExpectedSize);

unittests/ProfileData/InstrProfTest.cpp

  458   Writer.setValueProfDataEndianness(support::little);

unittests/Support/BinaryStreamTest.cpp

  105 constexpr endianness Endians[] = {big, little, native};
  269   AppendingBinaryByteStream Stream(support::little);
  323   BinaryStreamRef Original(InputData, support::little);
  396   AppendingBinaryByteStream Stream(llvm::support::little);
  836   AppendingBinaryByteStream Stream(support::little);

unittests/Support/EndianStreamTest.cpp

   23     endian::Writer LE(OS, little);
   54     endian::Writer LE(OS, little);
   84     endian::Writer LE(OS, little);
  122     endian::Writer LE(OS, little);
  160     endian::Writer LE(OS, little);
  175     endian::Writer LE(OS, little);
  191     endian::Writer LE(OS, little);

unittests/Support/EndianTest.cpp

   28   EXPECT_EQ(LittleAsHost,(endian::read<int32_t, little, unaligned>(littleval)));
   31             (endian::read<int32_t, little, unaligned>(littleval + 1)));
   39       (endian::readAtBitAlignment<int, little, unaligned>(&littleval[0], 6)),
   48       (endian::readAtBitAlignment<int, little, unaligned>(&littleval2[0], 4)),
   54       (endian::readAtBitAlignment<int, little, unaligned>(&littleval2[0], 1)),
   63   EXPECT_EQ((endian::readAtBitAlignment<int64_t, little, unaligned>(
   87   endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval,
  113   endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval2,
  146   endian::writeAtBitAlignment<int64_t, little, unaligned>(
  179   endian::write<int32_t, little, unaligned>(data, -1362446643);
  184   endian::write<int32_t, little, unaligned>(data + 1, -1362446643);

unittests/Support/YAMLIOTest.cpp

  484       float, llvm::support::little, llvm::support::unaligned>
  487       double, llvm::support::little, llvm::support::unaligned>