mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-11-23 13:50:11 +00:00
Use llvm::endianness::{big,little,native} (NFC)
Note that llvm::support::endianness has been renamed to
llvm::endianness while becoming an enum class. This patch replaces
{big,little,native} with llvm::endianness::{big,little,native}.
This patch completes the migration to llvm::endianness and
llvm::endianness::{big,little,native}. I'll post a separate patch to
remove the migration helpers in llvm/Support/Endian.h:
using endianness = llvm::endianness;
constexpr llvm::endianness big = llvm::endianness::big;
constexpr llvm::endianness little = llvm::endianness::little;
constexpr llvm::endianness native = llvm::endianness::native;
This commit is contained in:
Kazu Hirata
parent
514381840c
commit
02f67c097d
@ -755,7 +755,8 @@ void PGOHash::combine(HashType Type) {
|
||||
// Pass through MD5 if enough work has built up.
|
||||
if (Count && Count % NumTypesPerWord == 0) {
|
||||
using namespace llvm::support;
|
||||
uint64_t Swapped = endian::byte_swap<uint64_t, little>(Working);
|
||||
uint64_t Swapped =
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(Working);
|
||||
MD5.update(llvm::ArrayRef((uint8_t *)&Swapped, sizeof(Swapped)));
|
||||
Working = 0;
|
||||
}
|
||||
@ -781,7 +782,8 @@ uint64_t PGOHash::finalize() {
|
||||
MD5.update({(uint8_t)Working});
|
||||
} else {
|
||||
using namespace llvm::support;
|
||||
uint64_t Swapped = endian::byte_swap<uint64_t, little>(Working);
|
||||
uint64_t Swapped =
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(Working);
|
||||
MD5.update(llvm::ArrayRef((uint8_t *)&Swapped, sizeof(Swapped)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -912,9 +912,10 @@ ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
|
||||
using namespace llvm::support;
|
||||
|
||||
SelectorTable &SelTable = Reader.getContext().Selectors;
|
||||
unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
|
||||
unsigned N =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
|
||||
IdentifierInfo *FirstII = Reader.getLocalIdentifier(
|
||||
F, endian::readNext<uint32_t, little, unaligned>(d));
|
||||
F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
|
||||
if (N == 0)
|
||||
return SelTable.getNullarySelector(FirstII);
|
||||
else if (N == 1)
|
||||
@ -924,7 +925,7 @@ ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
|
||||
Args.push_back(FirstII);
|
||||
for (unsigned I = 1; I != N; ++I)
|
||||
Args.push_back(Reader.getLocalIdentifier(
|
||||
F, endian::readNext<uint32_t, little, unaligned>(d)));
|
||||
F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)));
|
||||
|
||||
return SelTable.getSelector(N, Args.data());
|
||||
}
|
||||
@ -937,9 +938,11 @@ ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
|
||||
data_type Result;
|
||||
|
||||
Result.ID = Reader.getGlobalSelectorID(
|
||||
F, endian::readNext<uint32_t, little, unaligned>(d));
|
||||
unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
|
||||
unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
|
||||
F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
|
||||
unsigned FullInstanceBits =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
|
||||
unsigned FullFactoryBits =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
|
||||
Result.InstanceBits = FullInstanceBits & 0x3;
|
||||
Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
|
||||
Result.FactoryBits = FullFactoryBits & 0x3;
|
||||
@ -950,14 +953,16 @@ ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
|
||||
// Load instance methods
|
||||
for (unsigned I = 0; I != NumInstanceMethods; ++I) {
|
||||
if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
|
||||
F, endian::readNext<uint32_t, little, unaligned>(d)))
|
||||
F,
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)))
|
||||
Result.Instance.push_back(Method);
|
||||
}
|
||||
|
||||
// Load factory methods
|
||||
for (unsigned I = 0; I != NumFactoryMethods; ++I) {
|
||||
if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
|
||||
F, endian::readNext<uint32_t, little, unaligned>(d)))
|
||||
F,
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)))
|
||||
Result.Factory.push_back(Method);
|
||||
}
|
||||
|
||||
@ -998,7 +1003,8 @@ static bool readBit(unsigned &Bits) {
|
||||
IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
|
||||
using namespace llvm::support;
|
||||
|
||||
unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
|
||||
unsigned RawID =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
|
||||
return Reader.getGlobalIdentifierID(F, RawID >> 1);
|
||||
}
|
||||
|
||||
@ -1016,7 +1022,8 @@ IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
|
||||
unsigned DataLen) {
|
||||
using namespace llvm::support;
|
||||
|
||||
unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
|
||||
unsigned RawID =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
|
||||
bool IsInteresting = RawID & 0x01;
|
||||
|
||||
// Wipe out the "is interesting" bit.
|
||||
@ -1039,8 +1046,10 @@ IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
|
||||
return II;
|
||||
}
|
||||
|
||||
unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
|
||||
unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
|
||||
unsigned ObjCOrBuiltinID =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
|
||||
unsigned Bits =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
|
||||
bool CPlusPlusOperatorKeyword = readBit(Bits);
|
||||
bool HasRevertedTokenIDToIdentifier = readBit(Bits);
|
||||
bool Poisoned = readBit(Bits);
|
||||
@ -1069,7 +1078,7 @@ IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
|
||||
// definition.
|
||||
if (HadMacroDefinition) {
|
||||
uint32_t MacroDirectivesOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(d);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
|
||||
DataLen -= 4;
|
||||
|
||||
Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
|
||||
@ -1083,7 +1092,8 @@ IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
|
||||
SmallVector<uint32_t, 4> DeclIDs;
|
||||
for (; DataLen > 0; DataLen -= 4)
|
||||
DeclIDs.push_back(Reader.getGlobalDeclID(
|
||||
F, endian::readNext<uint32_t, little, unaligned>(d)));
|
||||
F,
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)));
|
||||
Reader.SetGloballyVisibleDecls(II, DeclIDs);
|
||||
}
|
||||
|
||||
@ -1152,7 +1162,8 @@ ModuleFile *
|
||||
ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
|
||||
using namespace llvm::support;
|
||||
|
||||
uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
|
||||
uint32_t ModuleFileID =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
|
||||
return Reader.getLocalModuleFile(F, ModuleFileID);
|
||||
}
|
||||
|
||||
@ -1172,15 +1183,18 @@ ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
|
||||
case DeclarationName::CXXLiteralOperatorName:
|
||||
case DeclarationName::CXXDeductionGuideName:
|
||||
Data = (uint64_t)Reader.getLocalIdentifier(
|
||||
F, endian::readNext<uint32_t, little, unaligned>(d));
|
||||
F, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
|
||||
break;
|
||||
case DeclarationName::ObjCZeroArgSelector:
|
||||
case DeclarationName::ObjCOneArgSelector:
|
||||
case DeclarationName::ObjCMultiArgSelector:
|
||||
Data =
|
||||
(uint64_t)Reader.getLocalSelector(
|
||||
F, endian::readNext<uint32_t, little, unaligned>(
|
||||
d)).getAsOpaquePtr();
|
||||
(uint64_t)Reader
|
||||
.getLocalSelector(
|
||||
F,
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
|
||||
d))
|
||||
.getAsOpaquePtr();
|
||||
break;
|
||||
case DeclarationName::CXXOperatorName:
|
||||
Data = *d++; // OverloadedOperatorKind
|
||||
@ -1203,7 +1217,8 @@ void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
|
||||
using namespace llvm::support;
|
||||
|
||||
for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
|
||||
uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
|
||||
uint32_t LocalID =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
|
||||
Val.insert(Reader.getGlobalDeclID(F, LocalID));
|
||||
}
|
||||
}
|
||||
@ -2010,8 +2025,10 @@ HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
|
||||
using namespace llvm::support;
|
||||
|
||||
internal_key_type ikey;
|
||||
ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
|
||||
ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
|
||||
ikey.Size =
|
||||
off_t(endian::readNext<uint64_t, llvm::endianness::little, unaligned>(d));
|
||||
ikey.ModTime = time_t(
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(d));
|
||||
ikey.Filename = (const char *)d;
|
||||
ikey.Imported = true;
|
||||
return ikey;
|
||||
@ -2039,9 +2056,9 @@ HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
|
||||
HFI.DirInfo = (Flags >> 1) & 0x07;
|
||||
HFI.IndexHeaderMapHeader = Flags & 0x01;
|
||||
HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
|
||||
M, endian::readNext<uint32_t, little, unaligned>(d));
|
||||
M, endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d));
|
||||
if (unsigned FrameworkOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(d)) {
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d)) {
|
||||
// The framework offset is 1 greater than the actual offset,
|
||||
// since 0 is used as an indicator for "no framework name".
|
||||
StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
|
||||
@ -2051,7 +2068,8 @@ HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
|
||||
assert((End - d) % 4 == 0 &&
|
||||
"Wrong data length in HeaderFileInfo deserialization");
|
||||
while (d != End) {
|
||||
uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
|
||||
uint32_t LocalSMID =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
|
||||
auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 7);
|
||||
LocalSMID >>= 3;
|
||||
|
||||
@ -4030,8 +4048,9 @@ void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
|
||||
// how it goes...
|
||||
using namespace llvm::support;
|
||||
ModuleKind Kind = static_cast<ModuleKind>(
|
||||
endian::readNext<uint8_t, little, unaligned>(Data));
|
||||
uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
|
||||
endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data));
|
||||
uint16_t Len =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
|
||||
StringRef Name = StringRef((const char*)Data, Len);
|
||||
Data += Len;
|
||||
ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule ||
|
||||
@ -4047,21 +4066,21 @@ void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
|
||||
}
|
||||
|
||||
SourceLocation::UIntTy SLocOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(Data);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
|
||||
uint32_t IdentifierIDOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(Data);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
|
||||
uint32_t MacroIDOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(Data);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
|
||||
uint32_t PreprocessedEntityIDOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(Data);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
|
||||
uint32_t SubmoduleIDOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(Data);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
|
||||
uint32_t SelectorIDOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(Data);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
|
||||
uint32_t DeclIDOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(Data);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
|
||||
uint32_t TypeIndexOffset =
|
||||
endian::readNext<uint32_t, little, unaligned>(Data);
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
|
||||
|
||||
auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
|
||||
RemapBuilder &Remap) {
|
||||
|
||||
@ -1873,7 +1873,7 @@ namespace {
|
||||
void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) {
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
LE.write<uint64_t>(key.Size);
|
||||
KeyLen -= 8;
|
||||
LE.write<uint64_t>(key.ModTime);
|
||||
@ -1885,7 +1885,7 @@ namespace {
|
||||
data_type_ref Data, unsigned DataLen) {
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
uint64_t Start = Out.tell(); (void)Start;
|
||||
|
||||
unsigned char Flags = (Data.AlreadyIncluded << 6)
|
||||
@ -2053,7 +2053,7 @@ void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) {
|
||||
|
||||
llvm::raw_svector_ostream Out(TableData);
|
||||
// Make sure that no bucket is at offset 0
|
||||
endian::write<uint32_t>(Out, 0, little);
|
||||
endian::write<uint32_t>(Out, 0, llvm::endianness::little);
|
||||
BucketOffset = Generator.Emit(Out, GeneratorTrait);
|
||||
}
|
||||
|
||||
@ -3313,7 +3313,7 @@ public:
|
||||
void EmitKey(raw_ostream& Out, Selector Sel, unsigned) {
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
uint64_t Start = Out.tell();
|
||||
assert((Start >> 32) == 0 && "Selector key offset too large");
|
||||
Writer.SetSelectorOffset(Sel, Start);
|
||||
@ -3330,7 +3330,7 @@ public:
|
||||
data_type_ref Methods, unsigned DataLen) {
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
uint64_t Start = Out.tell(); (void)Start;
|
||||
LE.write<uint32_t>(Methods.ID);
|
||||
unsigned NumInstanceMethods = 0;
|
||||
@ -3453,7 +3453,7 @@ void ASTWriter::WriteSelectors(Sema &SemaRef) {
|
||||
ASTMethodPoolTrait Trait(*this);
|
||||
llvm::raw_svector_ostream Out(MethodPool);
|
||||
// Make sure that no bucket is at offset 0
|
||||
endian::write<uint32_t>(Out, 0, little);
|
||||
endian::write<uint32_t>(Out, 0, llvm::endianness::little);
|
||||
BucketOffset = Generator.Emit(Out, Trait);
|
||||
}
|
||||
|
||||
@ -3650,7 +3650,7 @@ public:
|
||||
IdentID ID, unsigned) {
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
|
||||
auto MacroOffset = Writer.getMacroDirectivesOffset(II);
|
||||
if (!isInterestingIdentifier(II, MacroOffset)) {
|
||||
@ -3749,7 +3749,7 @@ void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
|
||||
|
||||
llvm::raw_svector_ostream Out(IdentifierTable);
|
||||
// Make sure that no bucket is at offset 0
|
||||
endian::write<uint32_t>(Out, 0, little);
|
||||
endian::write<uint32_t>(Out, 0, llvm::endianness::little);
|
||||
BucketOffset = Generator.Emit(Out, Trait);
|
||||
}
|
||||
|
||||
@ -3844,7 +3844,8 @@ public:
|
||||
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::write<uint32_t>(Out, Writer.getChain()->getModuleFileID(F), little);
|
||||
endian::write<uint32_t>(Out, Writer.getChain()->getModuleFileID(F),
|
||||
llvm::endianness::little);
|
||||
}
|
||||
|
||||
std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
|
||||
@ -3879,7 +3880,7 @@ public:
|
||||
void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) {
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
LE.write<uint8_t>(Name.getKind());
|
||||
switch (Name.getKind()) {
|
||||
case DeclarationName::Identifier:
|
||||
@ -3911,7 +3912,7 @@ public:
|
||||
unsigned DataLen) {
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
uint64_t Start = Out.tell(); (void)Start;
|
||||
for (unsigned I = Lookup.first, N = Lookup.second; I != N; ++I)
|
||||
LE.write<uint32_t>(DeclIDs[I]);
|
||||
@ -5024,7 +5025,7 @@ ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot,
|
||||
for (ModuleFile &M : Chain->ModuleMgr) {
|
||||
using namespace llvm::support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
LE.write<uint8_t>(static_cast<uint8_t>(M.Kind));
|
||||
StringRef Name = M.isModule() ? M.ModuleName : M.FileName;
|
||||
LE.write<uint16_t>(Name.size());
|
||||
|
||||
@ -89,8 +89,10 @@ public:
|
||||
static std::pair<unsigned, unsigned>
|
||||
ReadKeyDataLength(const unsigned char*& d) {
|
||||
using namespace llvm::support;
|
||||
unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
|
||||
unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
|
||||
unsigned KeyLen =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
|
||||
unsigned DataLen =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(d);
|
||||
return std::make_pair(KeyLen, DataLen);
|
||||
}
|
||||
|
||||
@ -111,7 +113,8 @@ public:
|
||||
|
||||
data_type Result;
|
||||
while (DataLen > 0) {
|
||||
unsigned ID = endian::readNext<uint32_t, little, unaligned>(d);
|
||||
unsigned ID =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
|
||||
Result.push_back(ID);
|
||||
DataLen -= 4;
|
||||
}
|
||||
@ -511,7 +514,8 @@ namespace {
|
||||
// The first bit indicates whether this identifier is interesting.
|
||||
// That's all we care about.
|
||||
using namespace llvm::support;
|
||||
unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
|
||||
unsigned RawID =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(d);
|
||||
bool IsInteresting = RawID & 0x01;
|
||||
return std::make_pair(k, IsInteresting);
|
||||
}
|
||||
@ -729,7 +733,7 @@ public:
|
||||
std::pair<unsigned,unsigned>
|
||||
EmitKeyDataLength(raw_ostream& Out, key_type_ref Key, data_type_ref Data) {
|
||||
using namespace llvm::support;
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
unsigned KeyLen = Key.size();
|
||||
unsigned DataLen = Data.size() * 4;
|
||||
LE.write<uint16_t>(KeyLen);
|
||||
@ -745,7 +749,7 @@ public:
|
||||
unsigned DataLen) {
|
||||
using namespace llvm::support;
|
||||
for (unsigned I = 0, N = Data.size(); I != N; ++I)
|
||||
endian::write<uint32_t>(Out, Data[I], little);
|
||||
endian::write<uint32_t>(Out, Data[I], llvm::endianness::little);
|
||||
}
|
||||
};
|
||||
|
||||
@ -824,7 +828,7 @@ bool GlobalModuleIndexBuilder::writeIndex(llvm::BitstreamWriter &Stream) {
|
||||
using namespace llvm::support;
|
||||
llvm::raw_svector_ostream Out(IdentifierTable);
|
||||
// Make sure that no bucket is at offset 0
|
||||
endian::write<uint32_t>(Out, 0, little);
|
||||
endian::write<uint32_t>(Out, 0, llvm::endianness::little);
|
||||
BucketOffset = Generator.Emit(Out, Trait);
|
||||
}
|
||||
|
||||
|
||||
@ -199,10 +199,12 @@ public:
|
||||
|
||||
storage_type Ptr = Data;
|
||||
|
||||
uint32_t BucketOffset = endian::readNext<uint32_t, little, unaligned>(Ptr);
|
||||
uint32_t BucketOffset =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
|
||||
// Read the list of overridden files.
|
||||
uint32_t NumFiles = endian::readNext<uint32_t, little, unaligned>(Ptr);
|
||||
uint32_t NumFiles =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
// FIXME: Add a reserve() to TinyPtrVector so that we don't need to make
|
||||
// an additional copy.
|
||||
llvm::SmallVector<file_type, 16> OverriddenFiles;
|
||||
@ -311,7 +313,7 @@ public:
|
||||
|
||||
// Write our header information.
|
||||
{
|
||||
endian::Writer Writer(OutStream, little);
|
||||
endian::Writer Writer(OutStream, llvm::endianness::little);
|
||||
|
||||
// Reserve four bytes for the bucket offset.
|
||||
Writer.write<uint32_t>(0);
|
||||
|
||||
@ -139,10 +139,11 @@ public:
|
||||
uint64_t NumOfFlushedBytes = GetNumOfFlushedBytes();
|
||||
|
||||
if (ByteNo >= NumOfFlushedBytes) {
|
||||
assert((!endian::readAtBitAlignment<uint8_t, little, unaligned>(
|
||||
assert((!endian::readAtBitAlignment<uint8_t, llvm::endianness::little,
|
||||
unaligned>(
|
||||
&Out[ByteNo - NumOfFlushedBytes], StartBit)) &&
|
||||
"Expected to be patching over 0-value placeholders");
|
||||
endian::writeAtBitAlignment<uint8_t, little, unaligned>(
|
||||
endian::writeAtBitAlignment<uint8_t, llvm::endianness::little, unaligned>(
|
||||
&Out[ByteNo - NumOfFlushedBytes], NewByte, StartBit);
|
||||
return;
|
||||
}
|
||||
@ -171,14 +172,14 @@ public:
|
||||
assert(BytesRead >= 0 && static_cast<size_t>(BytesRead) == BytesFromDisk);
|
||||
for (size_t i = 0; i < BytesFromBuffer; ++i)
|
||||
Bytes[BytesFromDisk + i] = Out[i];
|
||||
assert((!endian::readAtBitAlignment<uint8_t, little, unaligned>(
|
||||
Bytes, StartBit)) &&
|
||||
assert((!endian::readAtBitAlignment<uint8_t, llvm::endianness::little,
|
||||
unaligned>(Bytes, StartBit)) &&
|
||||
"Expected to be patching over 0-value placeholders");
|
||||
}
|
||||
|
||||
// Update Bytes in terms of bit offset and value.
|
||||
endian::writeAtBitAlignment<uint8_t, little, unaligned>(Bytes, NewByte,
|
||||
StartBit);
|
||||
endian::writeAtBitAlignment<uint8_t, llvm::endianness::little, unaligned>(
|
||||
Bytes, NewByte, StartBit);
|
||||
|
||||
// Copy updated data back to the file FS and the buffer Out.
|
||||
FS->seek(ByteNo);
|
||||
|
||||
@ -500,8 +500,10 @@ public:
|
||||
ReadKeyDataLength(const unsigned char *&D) {
|
||||
using namespace support;
|
||||
|
||||
offset_type KeyLen = endian::readNext<offset_type, little, unaligned>(D);
|
||||
offset_type DataLen = endian::readNext<offset_type, little, unaligned>(D);
|
||||
offset_type KeyLen =
|
||||
endian::readNext<offset_type, llvm::endianness::little, unaligned>(D);
|
||||
offset_type DataLen =
|
||||
endian::readNext<offset_type, llvm::endianness::little, unaligned>(D);
|
||||
return std::make_pair(KeyLen, DataLen);
|
||||
}
|
||||
|
||||
|
||||
@ -50,7 +50,7 @@ struct PortableMemInfoBlock {
|
||||
switch (Id) {
|
||||
#define MIBEntryDef(NameTag, Name, Type) \
|
||||
case Meta::Name: { \
|
||||
Name = endian::readNext<Type, little, unaligned>(Ptr); \
|
||||
Name = endian::readNext<Type, llvm::endianness::little, unaligned>(Ptr); \
|
||||
} break;
|
||||
#include "llvm/ProfileData/MIBEntryDef.inc"
|
||||
#undef MIBEntryDef
|
||||
@ -66,7 +66,7 @@ struct PortableMemInfoBlock {
|
||||
void serialize(const MemProfSchema &Schema, raw_ostream &OS) const {
|
||||
using namespace support;
|
||||
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
for (const Meta Id : Schema) {
|
||||
switch (Id) {
|
||||
#define MIBEntryDef(NameTag, Name, Type) \
|
||||
@ -187,7 +187,7 @@ struct Frame {
|
||||
void serialize(raw_ostream &OS) const {
|
||||
using namespace support;
|
||||
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
|
||||
// If the type of the GlobalValue::GUID changes, then we need to update
|
||||
// the reader and the writer.
|
||||
@ -204,10 +204,14 @@ struct Frame {
|
||||
static Frame deserialize(const unsigned char *Ptr) {
|
||||
using namespace support;
|
||||
|
||||
const uint64_t F = endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
const uint32_t L = endian::readNext<uint32_t, little, unaligned>(Ptr);
|
||||
const uint32_t C = endian::readNext<uint32_t, little, unaligned>(Ptr);
|
||||
const bool I = endian::readNext<bool, little, unaligned>(Ptr);
|
||||
const uint64_t F =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
const uint32_t L =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
const uint32_t C =
|
||||
endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
const bool I =
|
||||
endian::readNext<bool, llvm::endianness::little, unaligned>(Ptr);
|
||||
return Frame(/*Function=*/F, /*LineOffset=*/L, /*Column=*/C,
|
||||
/*IsInlineFrame=*/I);
|
||||
}
|
||||
@ -466,14 +470,17 @@ public:
|
||||
ReadKeyDataLength(const unsigned char *&D) {
|
||||
using namespace support;
|
||||
|
||||
offset_type KeyLen = endian::readNext<offset_type, little, unaligned>(D);
|
||||
offset_type DataLen = endian::readNext<offset_type, little, unaligned>(D);
|
||||
offset_type KeyLen =
|
||||
endian::readNext<offset_type, llvm::endianness::little, unaligned>(D);
|
||||
offset_type DataLen =
|
||||
endian::readNext<offset_type, llvm::endianness::little, unaligned>(D);
|
||||
return std::make_pair(KeyLen, DataLen);
|
||||
}
|
||||
|
||||
uint64_t ReadKey(const unsigned char *D, offset_type /*Unused*/) {
|
||||
using namespace support;
|
||||
return endian::readNext<external_key_type, little, unaligned>(D);
|
||||
return endian::readNext<external_key_type, llvm::endianness::little,
|
||||
unaligned>(D);
|
||||
}
|
||||
|
||||
data_type ReadData(uint64_t K, const unsigned char *D,
|
||||
@ -514,7 +521,7 @@ public:
|
||||
EmitKeyDataLength(raw_ostream &Out, key_type_ref K, data_type_ref V) {
|
||||
using namespace support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
offset_type N = sizeof(K);
|
||||
LE.write<offset_type>(N);
|
||||
offset_type M = V.serializedSize();
|
||||
@ -524,7 +531,7 @@ public:
|
||||
|
||||
void EmitKey(raw_ostream &Out, key_type_ref K, offset_type /*Unused*/) {
|
||||
using namespace support;
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
LE.write<uint64_t>(K);
|
||||
}
|
||||
|
||||
@ -552,7 +559,7 @@ public:
|
||||
static std::pair<offset_type, offset_type>
|
||||
EmitKeyDataLength(raw_ostream &Out, key_type_ref K, data_type_ref V) {
|
||||
using namespace support;
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
offset_type N = sizeof(K);
|
||||
LE.write<offset_type>(N);
|
||||
offset_type M = V.serializedSize();
|
||||
@ -562,7 +569,7 @@ public:
|
||||
|
||||
void EmitKey(raw_ostream &Out, key_type_ref K, offset_type /*Unused*/) {
|
||||
using namespace support;
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
LE.write<key_type>(K);
|
||||
}
|
||||
|
||||
@ -593,14 +600,17 @@ public:
|
||||
ReadKeyDataLength(const unsigned char *&D) {
|
||||
using namespace support;
|
||||
|
||||
offset_type KeyLen = endian::readNext<offset_type, little, unaligned>(D);
|
||||
offset_type DataLen = endian::readNext<offset_type, little, unaligned>(D);
|
||||
offset_type KeyLen =
|
||||
endian::readNext<offset_type, llvm::endianness::little, unaligned>(D);
|
||||
offset_type DataLen =
|
||||
endian::readNext<offset_type, llvm::endianness::little, unaligned>(D);
|
||||
return std::make_pair(KeyLen, DataLen);
|
||||
}
|
||||
|
||||
uint64_t ReadKey(const unsigned char *D, offset_type /*Unused*/) {
|
||||
using namespace support;
|
||||
return endian::readNext<external_key_type, little, unaligned>(D);
|
||||
return endian::readNext<external_key_type, llvm::endianness::little,
|
||||
unaligned>(D);
|
||||
}
|
||||
|
||||
data_type ReadData(uint64_t K, const unsigned char *D,
|
||||
|
||||
@ -53,7 +53,7 @@ constexpr endianness system_endianness() { return llvm::endianness::native; }
|
||||
|
||||
template <typename value_type>
|
||||
[[nodiscard]] inline value_type byte_swap(value_type value, endianness endian) {
|
||||
if (endian != native)
|
||||
if (endian != llvm::endianness::native)
|
||||
sys::swapByteOrder(value);
|
||||
return value;
|
||||
}
|
||||
@ -273,85 +273,120 @@ public:
|
||||
} // end namespace detail
|
||||
|
||||
using ulittle16_t =
|
||||
detail::packed_endian_specific_integral<uint16_t, little, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint16_t, llvm::endianness::little,
|
||||
unaligned>;
|
||||
using ulittle32_t =
|
||||
detail::packed_endian_specific_integral<uint32_t, little, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint32_t, llvm::endianness::little,
|
||||
unaligned>;
|
||||
using ulittle64_t =
|
||||
detail::packed_endian_specific_integral<uint64_t, little, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint64_t, llvm::endianness::little,
|
||||
unaligned>;
|
||||
|
||||
using little16_t =
|
||||
detail::packed_endian_specific_integral<int16_t, little, unaligned>;
|
||||
detail::packed_endian_specific_integral<int16_t, llvm::endianness::little,
|
||||
unaligned>;
|
||||
using little32_t =
|
||||
detail::packed_endian_specific_integral<int32_t, little, unaligned>;
|
||||
detail::packed_endian_specific_integral<int32_t, llvm::endianness::little,
|
||||
unaligned>;
|
||||
using little64_t =
|
||||
detail::packed_endian_specific_integral<int64_t, little, unaligned>;
|
||||
detail::packed_endian_specific_integral<int64_t, llvm::endianness::little,
|
||||
unaligned>;
|
||||
|
||||
using aligned_ulittle16_t =
|
||||
detail::packed_endian_specific_integral<uint16_t, little, aligned>;
|
||||
detail::packed_endian_specific_integral<uint16_t, llvm::endianness::little,
|
||||
aligned>;
|
||||
using aligned_ulittle32_t =
|
||||
detail::packed_endian_specific_integral<uint32_t, little, aligned>;
|
||||
detail::packed_endian_specific_integral<uint32_t, llvm::endianness::little,
|
||||
aligned>;
|
||||
using aligned_ulittle64_t =
|
||||
detail::packed_endian_specific_integral<uint64_t, little, aligned>;
|
||||
detail::packed_endian_specific_integral<uint64_t, llvm::endianness::little,
|
||||
aligned>;
|
||||
|
||||
using aligned_little16_t =
|
||||
detail::packed_endian_specific_integral<int16_t, little, aligned>;
|
||||
detail::packed_endian_specific_integral<int16_t, llvm::endianness::little,
|
||||
aligned>;
|
||||
using aligned_little32_t =
|
||||
detail::packed_endian_specific_integral<int32_t, little, aligned>;
|
||||
detail::packed_endian_specific_integral<int32_t, llvm::endianness::little,
|
||||
aligned>;
|
||||
using aligned_little64_t =
|
||||
detail::packed_endian_specific_integral<int64_t, little, aligned>;
|
||||
detail::packed_endian_specific_integral<int64_t, llvm::endianness::little,
|
||||
aligned>;
|
||||
|
||||
using ubig16_t =
|
||||
detail::packed_endian_specific_integral<uint16_t, big, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint16_t, llvm::endianness::big,
|
||||
unaligned>;
|
||||
using ubig32_t =
|
||||
detail::packed_endian_specific_integral<uint32_t, big, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint32_t, llvm::endianness::big,
|
||||
unaligned>;
|
||||
using ubig64_t =
|
||||
detail::packed_endian_specific_integral<uint64_t, big, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint64_t, llvm::endianness::big,
|
||||
unaligned>;
|
||||
|
||||
using big16_t =
|
||||
detail::packed_endian_specific_integral<int16_t, big, unaligned>;
|
||||
detail::packed_endian_specific_integral<int16_t, llvm::endianness::big,
|
||||
unaligned>;
|
||||
using big32_t =
|
||||
detail::packed_endian_specific_integral<int32_t, big, unaligned>;
|
||||
detail::packed_endian_specific_integral<int32_t, llvm::endianness::big,
|
||||
unaligned>;
|
||||
using big64_t =
|
||||
detail::packed_endian_specific_integral<int64_t, big, unaligned>;
|
||||
detail::packed_endian_specific_integral<int64_t, llvm::endianness::big,
|
||||
unaligned>;
|
||||
|
||||
using aligned_ubig16_t =
|
||||
detail::packed_endian_specific_integral<uint16_t, big, aligned>;
|
||||
detail::packed_endian_specific_integral<uint16_t, llvm::endianness::big,
|
||||
aligned>;
|
||||
using aligned_ubig32_t =
|
||||
detail::packed_endian_specific_integral<uint32_t, big, aligned>;
|
||||
detail::packed_endian_specific_integral<uint32_t, llvm::endianness::big,
|
||||
aligned>;
|
||||
using aligned_ubig64_t =
|
||||
detail::packed_endian_specific_integral<uint64_t, big, aligned>;
|
||||
detail::packed_endian_specific_integral<uint64_t, llvm::endianness::big,
|
||||
aligned>;
|
||||
|
||||
using aligned_big16_t =
|
||||
detail::packed_endian_specific_integral<int16_t, big, aligned>;
|
||||
detail::packed_endian_specific_integral<int16_t, llvm::endianness::big,
|
||||
aligned>;
|
||||
using aligned_big32_t =
|
||||
detail::packed_endian_specific_integral<int32_t, big, aligned>;
|
||||
detail::packed_endian_specific_integral<int32_t, llvm::endianness::big,
|
||||
aligned>;
|
||||
using aligned_big64_t =
|
||||
detail::packed_endian_specific_integral<int64_t, big, aligned>;
|
||||
detail::packed_endian_specific_integral<int64_t, llvm::endianness::big,
|
||||
aligned>;
|
||||
|
||||
using unaligned_uint16_t =
|
||||
detail::packed_endian_specific_integral<uint16_t, native, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint16_t, llvm::endianness::native,
|
||||
unaligned>;
|
||||
using unaligned_uint32_t =
|
||||
detail::packed_endian_specific_integral<uint32_t, native, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint32_t, llvm::endianness::native,
|
||||
unaligned>;
|
||||
using unaligned_uint64_t =
|
||||
detail::packed_endian_specific_integral<uint64_t, native, unaligned>;
|
||||
detail::packed_endian_specific_integral<uint64_t, llvm::endianness::native,
|
||||
unaligned>;
|
||||
|
||||
using unaligned_int16_t =
|
||||
detail::packed_endian_specific_integral<int16_t, native, unaligned>;
|
||||
detail::packed_endian_specific_integral<int16_t, llvm::endianness::native,
|
||||
unaligned>;
|
||||
using unaligned_int32_t =
|
||||
detail::packed_endian_specific_integral<int32_t, native, unaligned>;
|
||||
detail::packed_endian_specific_integral<int32_t, llvm::endianness::native,
|
||||
unaligned>;
|
||||
using unaligned_int64_t =
|
||||
detail::packed_endian_specific_integral<int64_t, native, unaligned>;
|
||||
detail::packed_endian_specific_integral<int64_t, llvm::endianness::native,
|
||||
unaligned>;
|
||||
|
||||
template <typename T>
|
||||
using little_t = detail::packed_endian_specific_integral<T, little, unaligned>;
|
||||
using little_t =
|
||||
detail::packed_endian_specific_integral<T, llvm::endianness::little,
|
||||
unaligned>;
|
||||
template <typename T>
|
||||
using big_t = detail::packed_endian_specific_integral<T, big, unaligned>;
|
||||
using big_t = detail::packed_endian_specific_integral<T, llvm::endianness::big,
|
||||
unaligned>;
|
||||
|
||||
template <typename T>
|
||||
using aligned_little_t =
|
||||
detail::packed_endian_specific_integral<T, little, aligned>;
|
||||
detail::packed_endian_specific_integral<T, llvm::endianness::little,
|
||||
aligned>;
|
||||
template <typename T>
|
||||
using aligned_big_t = detail::packed_endian_specific_integral<T, big, aligned>;
|
||||
using aligned_big_t =
|
||||
detail::packed_endian_specific_integral<T, llvm::endianness::big, aligned>;
|
||||
|
||||
namespace endian {
|
||||
|
||||
@ -380,17 +415,23 @@ template <endianness E> [[nodiscard]] inline uint64_t read64(const void *P) {
|
||||
}
|
||||
|
||||
[[nodiscard]] inline uint16_t read16le(const void *P) {
|
||||
return read16<little>(P);
|
||||
return read16<llvm::endianness::little>(P);
|
||||
}
|
||||
[[nodiscard]] inline uint32_t read32le(const void *P) {
|
||||
return read32<little>(P);
|
||||
return read32<llvm::endianness::little>(P);
|
||||
}
|
||||
[[nodiscard]] inline uint64_t read64le(const void *P) {
|
||||
return read64<little>(P);
|
||||
return read64<llvm::endianness::little>(P);
|
||||
}
|
||||
[[nodiscard]] inline uint16_t read16be(const void *P) {
|
||||
return read16<llvm::endianness::big>(P);
|
||||
}
|
||||
[[nodiscard]] inline uint32_t read32be(const void *P) {
|
||||
return read32<llvm::endianness::big>(P);
|
||||
}
|
||||
[[nodiscard]] inline uint64_t read64be(const void *P) {
|
||||
return read64<llvm::endianness::big>(P);
|
||||
}
|
||||
[[nodiscard]] inline uint16_t read16be(const void *P) { return read16<big>(P); }
|
||||
[[nodiscard]] inline uint32_t read32be(const void *P) { return read32<big>(P); }
|
||||
[[nodiscard]] inline uint64_t read64be(const void *P) { return read64<big>(P); }
|
||||
|
||||
template <typename T, endianness E> inline void write(void *P, T V) {
|
||||
*(detail::packed_endian_specific_integral<T, E, unaligned> *)P = V;
|
||||
@ -416,12 +457,24 @@ template <endianness E> inline void write64(void *P, uint64_t V) {
|
||||
write<uint64_t, E>(P, V);
|
||||
}
|
||||
|
||||
inline void write16le(void *P, uint16_t V) { write16<little>(P, V); }
|
||||
inline void write32le(void *P, uint32_t V) { write32<little>(P, V); }
|
||||
inline void write64le(void *P, uint64_t V) { write64<little>(P, V); }
|
||||
inline void write16be(void *P, uint16_t V) { write16<big>(P, V); }
|
||||
inline void write32be(void *P, uint32_t V) { write32<big>(P, V); }
|
||||
inline void write64be(void *P, uint64_t V) { write64<big>(P, V); }
|
||||
inline void write16le(void *P, uint16_t V) {
|
||||
write16<llvm::endianness::little>(P, V);
|
||||
}
|
||||
inline void write32le(void *P, uint32_t V) {
|
||||
write32<llvm::endianness::little>(P, V);
|
||||
}
|
||||
inline void write64le(void *P, uint64_t V) {
|
||||
write64<llvm::endianness::little>(P, V);
|
||||
}
|
||||
inline void write16be(void *P, uint16_t V) {
|
||||
write16<llvm::endianness::big>(P, V);
|
||||
}
|
||||
inline void write32be(void *P, uint32_t V) {
|
||||
write32<llvm::endianness::big>(P, V);
|
||||
}
|
||||
inline void write64be(void *P, uint64_t V) {
|
||||
write64<llvm::endianness::big>(P, V);
|
||||
}
|
||||
|
||||
} // end namespace endian
|
||||
|
||||
|
||||
@ -47,12 +47,12 @@ public:
|
||||
// Our MD5 implementation returns the result in little endian, so the low
|
||||
// word is first.
|
||||
using namespace support;
|
||||
return endian::read<uint64_t, little>(data());
|
||||
return endian::read<uint64_t, llvm::endianness::little>(data());
|
||||
}
|
||||
|
||||
uint64_t high() const {
|
||||
using namespace support;
|
||||
return endian::read<uint64_t, little>(data() + 8);
|
||||
return endian::read<uint64_t, llvm::endianness::little>(data() + 8);
|
||||
}
|
||||
std::pair<uint64_t, uint64_t> words() const {
|
||||
using namespace support;
|
||||
|
||||
@ -149,7 +149,7 @@ public:
|
||||
/// Uses the provided Info instead of a stack allocated one.
|
||||
offset_type Emit(raw_ostream &Out, Info &InfoObj) {
|
||||
using namespace llvm::support;
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
|
||||
// Now we're done adding entries, resize the bucket list if it's
|
||||
// significantly too large. (This only happens if the number of
|
||||
@ -304,9 +304,11 @@ public:
|
||||
"buckets should be 4-byte aligned.");
|
||||
using namespace llvm::support;
|
||||
offset_type NumBuckets =
|
||||
endian::readNext<offset_type, little, aligned>(Buckets);
|
||||
endian::readNext<offset_type, llvm::endianness::little, aligned>(
|
||||
Buckets);
|
||||
offset_type NumEntries =
|
||||
endian::readNext<offset_type, little, aligned>(Buckets);
|
||||
endian::readNext<offset_type, llvm::endianness::little, aligned>(
|
||||
Buckets);
|
||||
return std::make_pair(NumBuckets, NumEntries);
|
||||
}
|
||||
|
||||
@ -357,19 +359,23 @@ public:
|
||||
offset_type Idx = KeyHash & (NumBuckets - 1);
|
||||
const unsigned char *Bucket = Buckets + sizeof(offset_type) * Idx;
|
||||
|
||||
offset_type Offset = endian::readNext<offset_type, little, aligned>(Bucket);
|
||||
offset_type Offset =
|
||||
endian::readNext<offset_type, llvm::endianness::little, aligned>(
|
||||
Bucket);
|
||||
if (Offset == 0)
|
||||
return iterator(); // Empty bucket.
|
||||
const unsigned char *Items = Base + Offset;
|
||||
|
||||
// 'Items' starts with a 16-bit unsigned integer representing the
|
||||
// number of items in this bucket.
|
||||
unsigned Len = endian::readNext<uint16_t, little, unaligned>(Items);
|
||||
unsigned Len =
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Items);
|
||||
|
||||
for (unsigned i = 0; i < Len; ++i) {
|
||||
// Read the hash.
|
||||
hash_value_type ItemHash =
|
||||
endian::readNext<hash_value_type, little, unaligned>(Items);
|
||||
endian::readNext<hash_value_type, llvm::endianness::little,
|
||||
unaligned>(Items);
|
||||
|
||||
// Determine the length of the key and the data.
|
||||
const std::pair<offset_type, offset_type> &L =
|
||||
@ -467,7 +473,8 @@ private:
|
||||
// 'Items' starts with a 16-bit unsigned integer representing the
|
||||
// number of items in this bucket.
|
||||
NumItemsInBucketLeft =
|
||||
endian::readNext<uint16_t, little, unaligned>(Ptr);
|
||||
endian::readNext<uint16_t, llvm::endianness::little, unaligned>(
|
||||
Ptr);
|
||||
}
|
||||
Ptr += sizeof(hash_value_type); // Skip the hash.
|
||||
// Determine the length of the key and the data.
|
||||
|
||||
@ -405,10 +405,10 @@ Error applyFixupData(LinkGraph &G, Block &B, const Edge &E) {
|
||||
auto Write32 = [FixupPtr, Endian = G.getEndianness()](int64_t Value) {
|
||||
assert(isInt<32>(Value) && "Must be in signed 32-bit range");
|
||||
uint32_t Imm = static_cast<int32_t>(Value);
|
||||
if (LLVM_LIKELY(Endian == little))
|
||||
endian::write32<little>(FixupPtr, Imm);
|
||||
if (LLVM_LIKELY(Endian == llvm::endianness::little))
|
||||
endian::write32<llvm::endianness::little>(FixupPtr, Imm);
|
||||
else
|
||||
endian::write32<big>(FixupPtr, Imm);
|
||||
endian::write32<llvm::endianness::big>(FixupPtr, Imm);
|
||||
};
|
||||
|
||||
Edge::Kind Kind = E.getKind();
|
||||
|
||||
@ -343,7 +343,7 @@ template <typename T> ErrorOr<T> MCPseudoProbeDecoder::readUnencodedNumber() {
|
||||
if (Data + sizeof(T) > End) {
|
||||
return std::error_code();
|
||||
}
|
||||
T Val = endian::readNext<T, little, unaligned>(Data);
|
||||
T Val = endian::readNext<T, llvm::endianness::little, unaligned>(Data);
|
||||
return ErrorOr<T>(Val);
|
||||
}
|
||||
|
||||
|
||||
@ -1022,10 +1022,10 @@ template <class T>
|
||||
static T swapToHostOrder(const unsigned char *&D, llvm::endianness Orig) {
|
||||
using namespace support;
|
||||
|
||||
if (Orig == little)
|
||||
return endian::readNext<T, little, unaligned>(D);
|
||||
if (Orig == llvm::endianness::little)
|
||||
return endian::readNext<T, llvm::endianness::little, unaligned>(D);
|
||||
else
|
||||
return endian::readNext<T, big, unaligned>(D);
|
||||
return endian::readNext<T, llvm::endianness::big, unaligned>(D);
|
||||
}
|
||||
|
||||
static std::unique_ptr<ValueProfData> allocValueProfData(uint32_t TotalSize) {
|
||||
@ -1449,7 +1449,7 @@ static inline uint64_t read(const unsigned char *Buffer, size_t Offset) {
|
||||
|
||||
uint64_t Header::formatVersion() const {
|
||||
using namespace support;
|
||||
return endian::byte_swap<uint64_t, little>(Version);
|
||||
return endian::byte_swap<uint64_t, llvm::endianness::little>(Version);
|
||||
}
|
||||
|
||||
Expected<Header> Header::readFromBuffer(const unsigned char *Buffer) {
|
||||
@ -1461,7 +1461,8 @@ Expected<Header> Header::readFromBuffer(const unsigned char *Buffer) {
|
||||
|
||||
H.Magic = read(Buffer, offsetOf(&Header::Magic));
|
||||
// Check the magic number.
|
||||
uint64_t Magic = endian::byte_swap<uint64_t, little>(H.Magic);
|
||||
uint64_t Magic =
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(H.Magic);
|
||||
if (Magic != IndexedInstrProf::Magic)
|
||||
return make_error<InstrProfError>(instrprof_error::bad_magic);
|
||||
|
||||
|
||||
@ -112,10 +112,11 @@ readBinaryIdsInternal(const MemoryBuffer &DataBuffer,
|
||||
"not enough data to read binary id length");
|
||||
|
||||
uint64_t BILen = 0;
|
||||
if (Endian == little)
|
||||
BILen = endian::readNext<uint64_t, little, unaligned>(BI);
|
||||
if (Endian == llvm::endianness::little)
|
||||
BILen =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(BI);
|
||||
else
|
||||
BILen = endian::readNext<uint64_t, big, unaligned>(BI);
|
||||
BILen = endian::readNext<uint64_t, llvm::endianness::big, unaligned>(BI);
|
||||
|
||||
if (BILen == 0)
|
||||
return make_error<InstrProfError>(instrprof_error::malformed,
|
||||
@ -800,7 +801,8 @@ data_type InstrProfLookupTrait::ReadData(StringRef K, const unsigned char *D,
|
||||
// Read hash.
|
||||
if (D + sizeof(uint64_t) >= End)
|
||||
return data_type();
|
||||
uint64_t Hash = endian::readNext<uint64_t, little, unaligned>(D);
|
||||
uint64_t Hash =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(D);
|
||||
|
||||
// Initialize number of counters for GET_VERSION(FormatVersion) == 1.
|
||||
uint64_t CountsSize = N / sizeof(uint64_t) - 1;
|
||||
@ -808,7 +810,8 @@ data_type InstrProfLookupTrait::ReadData(StringRef K, const unsigned char *D,
|
||||
if (GET_VERSION(FormatVersion) != IndexedInstrProf::ProfVersion::Version1) {
|
||||
if (D + sizeof(uint64_t) > End)
|
||||
return data_type();
|
||||
CountsSize = endian::readNext<uint64_t, little, unaligned>(D);
|
||||
CountsSize =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(D);
|
||||
}
|
||||
// Read counter values.
|
||||
if (D + CountsSize * sizeof(uint64_t) > End)
|
||||
@ -817,7 +820,8 @@ data_type InstrProfLookupTrait::ReadData(StringRef K, const unsigned char *D,
|
||||
CounterBuffer.clear();
|
||||
CounterBuffer.reserve(CountsSize);
|
||||
for (uint64_t J = 0; J < CountsSize; ++J)
|
||||
CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));
|
||||
CounterBuffer.push_back(
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(D));
|
||||
|
||||
DataBuffer.emplace_back(K, Hash, std::move(CounterBuffer));
|
||||
|
||||
@ -1001,8 +1005,8 @@ bool IndexedInstrProfReader::hasFormat(const MemoryBuffer &DataBuffer) {
|
||||
|
||||
if (DataBuffer.getBufferSize() < 8)
|
||||
return false;
|
||||
uint64_t Magic =
|
||||
endian::read<uint64_t, little, aligned>(DataBuffer.getBufferStart());
|
||||
uint64_t Magic = endian::read<uint64_t, llvm::endianness::little, aligned>(
|
||||
DataBuffer.getBufferStart());
|
||||
// Verify that it's magical.
|
||||
return Magic == IndexedInstrProf::Magic;
|
||||
}
|
||||
@ -1016,10 +1020,10 @@ IndexedInstrProfReader::readSummary(IndexedInstrProf::ProfVersion Version,
|
||||
if (Version >= IndexedInstrProf::Version4) {
|
||||
const IndexedInstrProf::Summary *SummaryInLE =
|
||||
reinterpret_cast<const IndexedInstrProf::Summary *>(Cur);
|
||||
uint64_t NFields =
|
||||
endian::byte_swap<uint64_t, little>(SummaryInLE->NumSummaryFields);
|
||||
uint64_t NEntries =
|
||||
endian::byte_swap<uint64_t, little>(SummaryInLE->NumCutoffEntries);
|
||||
uint64_t NFields = endian::byte_swap<uint64_t, llvm::endianness::little>(
|
||||
SummaryInLE->NumSummaryFields);
|
||||
uint64_t NEntries = endian::byte_swap<uint64_t, llvm::endianness::little>(
|
||||
SummaryInLE->NumCutoffEntries);
|
||||
uint32_t SummarySize =
|
||||
IndexedInstrProf::Summary::getSize(NFields, NEntries);
|
||||
std::unique_ptr<IndexedInstrProf::Summary> SummaryData =
|
||||
@ -1028,7 +1032,7 @@ IndexedInstrProfReader::readSummary(IndexedInstrProf::ProfVersion Version,
|
||||
const uint64_t *Src = reinterpret_cast<const uint64_t *>(SummaryInLE);
|
||||
uint64_t *Dst = reinterpret_cast<uint64_t *>(SummaryData.get());
|
||||
for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
|
||||
Dst[I] = endian::byte_swap<uint64_t, little>(Src[I]);
|
||||
Dst[I] = endian::byte_swap<uint64_t, llvm::endianness::little>(Src[I]);
|
||||
|
||||
SummaryEntryVector DetailedSummary;
|
||||
for (unsigned I = 0; I < SummaryData->NumCutoffEntries; I++) {
|
||||
@ -1085,11 +1089,12 @@ Error IndexedInstrProfReader::readHeader() {
|
||||
/* UseCS */ true);
|
||||
// Read the hash type and start offset.
|
||||
IndexedInstrProf::HashT HashType = static_cast<IndexedInstrProf::HashT>(
|
||||
endian::byte_swap<uint64_t, little>(Header->HashType));
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(Header->HashType));
|
||||
if (HashType > IndexedInstrProf::HashT::Last)
|
||||
return error(instrprof_error::unsupported_hash_type);
|
||||
|
||||
uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
|
||||
uint64_t HashOffset =
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(Header->HashOffset);
|
||||
|
||||
// The hash table with profile counts comes next.
|
||||
auto IndexPtr = std::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
|
||||
@ -1100,19 +1105,23 @@ Error IndexedInstrProfReader::readHeader() {
|
||||
if (GET_VERSION(Header->formatVersion()) >= 8 &&
|
||||
Header->formatVersion() & VARIANT_MASK_MEMPROF) {
|
||||
uint64_t MemProfOffset =
|
||||
endian::byte_swap<uint64_t, little>(Header->MemProfOffset);
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(
|
||||
Header->MemProfOffset);
|
||||
|
||||
const unsigned char *Ptr = Start + MemProfOffset;
|
||||
// The value returned from RecordTableGenerator.Emit.
|
||||
const uint64_t RecordTableOffset =
|
||||
support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
// The offset in the stream right before invoking
|
||||
// FrameTableGenerator.Emit.
|
||||
const uint64_t FramePayloadOffset =
|
||||
support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
// The value returned from FrameTableGenerator.Emit.
|
||||
const uint64_t FrameTableOffset =
|
||||
support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
|
||||
// Read the schema.
|
||||
auto SchemaOr = memprof::readMemProfSchema(Ptr);
|
||||
@ -1137,10 +1146,13 @@ Error IndexedInstrProfReader::readHeader() {
|
||||
// is higher than 9 (when it was introduced).
|
||||
if (GET_VERSION(Header->formatVersion()) >= 9) {
|
||||
uint64_t BinaryIdOffset =
|
||||
endian::byte_swap<uint64_t, little>(Header->BinaryIdOffset);
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(
|
||||
Header->BinaryIdOffset);
|
||||
const unsigned char *Ptr = Start + BinaryIdOffset;
|
||||
// Read binary ids size.
|
||||
BinaryIdsSize = support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
BinaryIdsSize =
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
if (BinaryIdsSize % sizeof(uint64_t))
|
||||
return error(instrprof_error::bad_header);
|
||||
// Set the binary ids start.
|
||||
@ -1153,31 +1165,37 @@ Error IndexedInstrProfReader::readHeader() {
|
||||
if (GET_VERSION(Header->formatVersion()) >= 10 &&
|
||||
Header->formatVersion() & VARIANT_MASK_TEMPORAL_PROF) {
|
||||
uint64_t TemporalProfTracesOffset =
|
||||
endian::byte_swap<uint64_t, little>(Header->TemporalProfTracesOffset);
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(
|
||||
Header->TemporalProfTracesOffset);
|
||||
const unsigned char *Ptr = Start + TemporalProfTracesOffset;
|
||||
const auto *PtrEnd = (const unsigned char *)DataBuffer->getBufferEnd();
|
||||
// Expect at least two 64 bit fields: NumTraces, and TraceStreamSize
|
||||
if (Ptr + 2 * sizeof(uint64_t) > PtrEnd)
|
||||
return error(instrprof_error::truncated);
|
||||
const uint64_t NumTraces =
|
||||
support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
TemporalProfTraceStreamSize =
|
||||
support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
for (unsigned i = 0; i < NumTraces; i++) {
|
||||
// Expect at least two 64 bit fields: Weight and NumFunctions
|
||||
if (Ptr + 2 * sizeof(uint64_t) > PtrEnd)
|
||||
return error(instrprof_error::truncated);
|
||||
TemporalProfTraceTy Trace;
|
||||
Trace.Weight =
|
||||
support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
const uint64_t NumFunctions =
|
||||
support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
// Expect at least NumFunctions 64 bit fields
|
||||
if (Ptr + NumFunctions * sizeof(uint64_t) > PtrEnd)
|
||||
return error(instrprof_error::truncated);
|
||||
for (unsigned j = 0; j < NumFunctions; j++) {
|
||||
const uint64_t NameRef =
|
||||
support::endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
support::endian::readNext<uint64_t, llvm::endianness::little,
|
||||
unaligned>(Ptr);
|
||||
Trace.FunctionNameRefs.push_back(NameRef);
|
||||
}
|
||||
TemporalProfTraces.push_back(std::move(Trace));
|
||||
|
||||
@ -80,7 +80,8 @@ public:
|
||||
std::string &Data = SOStream.str(); // with flush
|
||||
for (int K = 0; K < NItems; K++) {
|
||||
for (int I = 0; I < P[K].N; I++) {
|
||||
uint64_t Bytes = endian::byte_swap<uint64_t, little>(P[K].D[I]);
|
||||
uint64_t Bytes =
|
||||
endian::byte_swap<uint64_t, llvm::endianness::little>(P[K].D[I]);
|
||||
Data.replace(P[K].Pos + I * sizeof(uint64_t), sizeof(uint64_t),
|
||||
(const char *)&Bytes, sizeof(uint64_t));
|
||||
}
|
||||
@ -120,7 +121,7 @@ public:
|
||||
EmitKeyDataLength(raw_ostream &Out, key_type_ref K, data_type_ref V) {
|
||||
using namespace support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
|
||||
offset_type N = K.size();
|
||||
LE.write<offset_type>(N);
|
||||
@ -147,7 +148,7 @@ public:
|
||||
void EmitData(raw_ostream &Out, key_type_ref, data_type_ref V, offset_type) {
|
||||
using namespace support;
|
||||
|
||||
endian::Writer LE(Out, little);
|
||||
endian::Writer LE(Out, llvm::endianness::little);
|
||||
for (const auto &ProfileData : *V) {
|
||||
const InstrProfRecord &ProfRecord = ProfileData.second;
|
||||
if (NamedInstrProfRecord::hasCSFlagInHash(ProfileData.first))
|
||||
|
||||
@ -13,7 +13,7 @@ void IndexedMemProfRecord::serialize(const MemProfSchema &Schema,
|
||||
raw_ostream &OS) {
|
||||
using namespace support;
|
||||
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
|
||||
LE.write<uint64_t>(AllocSites.size());
|
||||
for (const IndexedAllocationInfo &N : AllocSites) {
|
||||
@ -40,13 +40,15 @@ IndexedMemProfRecord::deserialize(const MemProfSchema &Schema,
|
||||
IndexedMemProfRecord Record;
|
||||
|
||||
// Read the meminfo nodes.
|
||||
const uint64_t NumNodes = endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
const uint64_t NumNodes =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
for (uint64_t I = 0; I < NumNodes; I++) {
|
||||
IndexedAllocationInfo Node;
|
||||
const uint64_t NumFrames =
|
||||
endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
for (uint64_t J = 0; J < NumFrames; J++) {
|
||||
const FrameId Id = endian::readNext<FrameId, little, unaligned>(Ptr);
|
||||
const FrameId Id =
|
||||
endian::readNext<FrameId, llvm::endianness::little, unaligned>(Ptr);
|
||||
Node.CallStack.push_back(Id);
|
||||
}
|
||||
Node.Info.deserialize(Schema, Ptr);
|
||||
@ -55,14 +57,16 @@ IndexedMemProfRecord::deserialize(const MemProfSchema &Schema,
|
||||
}
|
||||
|
||||
// Read the callsite information.
|
||||
const uint64_t NumCtxs = endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
const uint64_t NumCtxs =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
for (uint64_t J = 0; J < NumCtxs; J++) {
|
||||
const uint64_t NumFrames =
|
||||
endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
llvm::SmallVector<FrameId> Frames;
|
||||
Frames.reserve(NumFrames);
|
||||
for (uint64_t K = 0; K < NumFrames; K++) {
|
||||
const FrameId Id = endian::readNext<FrameId, little, unaligned>(Ptr);
|
||||
const FrameId Id =
|
||||
endian::readNext<FrameId, llvm::endianness::little, unaligned>(Ptr);
|
||||
Frames.push_back(Id);
|
||||
}
|
||||
Record.CallSites.push_back(Frames);
|
||||
@ -90,7 +94,7 @@ Expected<MemProfSchema> readMemProfSchema(const unsigned char *&Buffer) {
|
||||
|
||||
const unsigned char *Ptr = Buffer;
|
||||
const uint64_t NumSchemaIds =
|
||||
endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
if (NumSchemaIds > static_cast<uint64_t>(Meta::Size)) {
|
||||
return make_error<InstrProfError>(instrprof_error::malformed,
|
||||
"memprof schema invalid");
|
||||
@ -98,7 +102,8 @@ Expected<MemProfSchema> readMemProfSchema(const unsigned char *&Buffer) {
|
||||
|
||||
MemProfSchema Result;
|
||||
for (size_t I = 0; I < NumSchemaIds; I++) {
|
||||
const uint64_t Tag = endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
const uint64_t Tag =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
if (Tag >= static_cast<uint64_t>(Meta::Size)) {
|
||||
return make_error<InstrProfError>(instrprof_error::malformed,
|
||||
"memprof schema invalid");
|
||||
|
||||
@ -87,7 +87,7 @@ llvm::SmallVector<SegmentEntry> readSegmentEntries(const char *Ptr) {
|
||||
using namespace support;
|
||||
|
||||
const uint64_t NumItemsToRead =
|
||||
endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
llvm::SmallVector<SegmentEntry> Items;
|
||||
for (uint64_t I = 0; I < NumItemsToRead; I++) {
|
||||
Items.push_back(*reinterpret_cast<const SegmentEntry *>(
|
||||
@ -101,10 +101,11 @@ readMemInfoBlocks(const char *Ptr) {
|
||||
using namespace support;
|
||||
|
||||
const uint64_t NumItemsToRead =
|
||||
endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
llvm::SmallVector<std::pair<uint64_t, MemInfoBlock>> Items;
|
||||
for (uint64_t I = 0; I < NumItemsToRead; I++) {
|
||||
const uint64_t Id = endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
const uint64_t Id =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
const MemInfoBlock MIB = *reinterpret_cast<const MemInfoBlock *>(Ptr);
|
||||
Items.push_back({Id, MIB});
|
||||
// Only increment by size of MIB since readNext implicitly increments.
|
||||
@ -117,16 +118,19 @@ CallStackMap readStackInfo(const char *Ptr) {
|
||||
using namespace support;
|
||||
|
||||
const uint64_t NumItemsToRead =
|
||||
endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
CallStackMap Items;
|
||||
|
||||
for (uint64_t I = 0; I < NumItemsToRead; I++) {
|
||||
const uint64_t StackId = endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
const uint64_t NumPCs = endian::readNext<uint64_t, little, unaligned>(Ptr);
|
||||
const uint64_t StackId =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
const uint64_t NumPCs =
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
|
||||
|
||||
SmallVector<uint64_t> CallStack;
|
||||
for (uint64_t J = 0; J < NumPCs; J++) {
|
||||
CallStack.push_back(endian::readNext<uint64_t, little, unaligned>(Ptr));
|
||||
CallStack.push_back(
|
||||
endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr));
|
||||
}
|
||||
|
||||
Items[StackId] = CallStack;
|
||||
|
||||
@ -502,7 +502,7 @@ ErrorOr<T> SampleProfileReaderBinary::readUnencodedNumber() {
|
||||
}
|
||||
|
||||
using namespace support;
|
||||
T Val = endian::readNext<T, little, unaligned>(Data);
|
||||
T Val = endian::readNext<T, llvm::endianness::little, unaligned>(Data);
|
||||
return Val;
|
||||
}
|
||||
|
||||
@ -531,8 +531,8 @@ SampleProfileReaderBinary::readStringFromTable(size_t *RetIdx) {
|
||||
if (!SR.data()) {
|
||||
assert(MD5NameMemStart);
|
||||
using namespace support;
|
||||
uint64_t FID = endian::read<uint64_t, little>(MD5NameMemStart +
|
||||
(*Idx) * sizeof(uint64_t));
|
||||
uint64_t FID = endian::read<uint64_t, llvm::endianness::little>(
|
||||
MD5NameMemStart + (*Idx) * sizeof(uint64_t));
|
||||
SR = MD5StringBuf.emplace_back(std::to_string(FID));
|
||||
}
|
||||
if (RetIdx)
|
||||
|
||||
@ -34,7 +34,9 @@ public:
|
||||
uint32_t block_size() const { return 1; }
|
||||
uint32_t block_count() const { return Blocks.size(); }
|
||||
|
||||
endianness getEndian() const override { return little; }
|
||||
llvm::endianness getEndian() const override {
|
||||
return llvm::endianness::little;
|
||||
}
|
||||
|
||||
Error readBytes(uint64_t Offset, uint64_t Size,
|
||||
ArrayRef<uint8_t> &Buffer) override {
|
||||
@ -412,7 +414,7 @@ TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) {
|
||||
F.block_size(), F.layout(), F, F.Allocator);
|
||||
|
||||
// First write "Test Str" into the source stream.
|
||||
MutableBinaryByteStream SourceStream(SrcData, little);
|
||||
MutableBinaryByteStream SourceStream(SrcData, llvm::endianness::little);
|
||||
BinaryStreamWriter SourceWriter(SourceStream);
|
||||
EXPECT_THAT_ERROR(SourceWriter.writeCString("Test Str"), Succeeded());
|
||||
EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
|
||||
|
||||
@ -147,7 +147,7 @@ TEST(HashTableTest, Serialization) {
|
||||
}
|
||||
|
||||
std::vector<uint8_t> Buffer(Table.calculateSerializedLength());
|
||||
MutableBinaryByteStream Stream(Buffer, little);
|
||||
MutableBinaryByteStream Stream(Buffer, llvm::endianness::little);
|
||||
BinaryStreamWriter Writer(Stream);
|
||||
EXPECT_THAT_ERROR(Table.commit(Writer), Succeeded());
|
||||
// We should have written precisely the number of bytes we calculated earlier.
|
||||
@ -251,7 +251,7 @@ TEST(HashTableTest, NonTrivialValueType) {
|
||||
}
|
||||
|
||||
std::vector<uint8_t> Buffer(Table.calculateSerializedLength());
|
||||
MutableBinaryByteStream Stream(Buffer, little);
|
||||
MutableBinaryByteStream Stream(Buffer, llvm::endianness::little);
|
||||
BinaryStreamWriter Writer(Stream);
|
||||
EXPECT_THAT_ERROR(Table.commit(Writer), Succeeded());
|
||||
// We should have written precisely the number of bytes we calculated earlier.
|
||||
|
||||
@ -47,12 +47,12 @@ TEST(StringTableBuilderTest, Simple) {
|
||||
EXPECT_EQ(6U, Distinct.size());
|
||||
|
||||
std::vector<uint8_t> Buffer(Builder.calculateSerializedSize());
|
||||
MutableBinaryByteStream OutStream(Buffer, little);
|
||||
MutableBinaryByteStream OutStream(Buffer, llvm::endianness::little);
|
||||
BinaryStreamWriter Writer(OutStream);
|
||||
EXPECT_THAT_ERROR(Builder.commit(Writer), Succeeded());
|
||||
|
||||
// Reads the contents back.
|
||||
BinaryByteStream InStream(Buffer, little);
|
||||
BinaryByteStream InStream(Buffer, llvm::endianness::little);
|
||||
BinaryStreamReader Reader(InStream);
|
||||
PDBStringTable Table;
|
||||
EXPECT_THAT_ERROR(Table.reload(Reader), Succeeded());
|
||||
|
||||
@ -110,9 +110,11 @@ TEST(AArch32_Relocations, Thumb_Call_J1J2) {
|
||||
constexpr HalfWords ImmMask = FixupInfo<Thumb_Call>::ImmMask;
|
||||
|
||||
static std::array<HalfWords, 3> MemPresets{
|
||||
makeHalfWords<little>({0xff, 0xf7, 0xfe, 0xef}), // common
|
||||
makeHalfWords<little>({0x00, 0x00, 0x00, 0x00}), // zeros
|
||||
makeHalfWords<little>({0xff, 0xff, 0xff, 0xff}), // ones
|
||||
makeHalfWords<llvm::endianness::little>(
|
||||
{0xff, 0xf7, 0xfe, 0xef}), // common
|
||||
makeHalfWords<llvm::endianness::little>(
|
||||
{0x00, 0x00, 0x00, 0x00}), // zeros
|
||||
makeHalfWords<llvm::endianness::little>({0xff, 0xff, 0xff, 0xff}), // ones
|
||||
};
|
||||
|
||||
auto EncodeDecode = [ImmMask](int64_t In, MutableHalfWords &Mem) {
|
||||
@ -146,9 +148,11 @@ TEST(AArch32_Relocations, Thumb_Call_Bare) {
|
||||
constexpr HalfWords ImmMask = FixupInfo<Thumb_Call>::ImmMask;
|
||||
|
||||
static std::array<HalfWords, 3> MemPresets{
|
||||
makeHalfWords<little>({0xff, 0xf7, 0xfe, 0xef}), // common
|
||||
makeHalfWords<little>({0x00, 0x00, 0x00, 0x00}), // zeros
|
||||
makeHalfWords<little>({0xff, 0xff, 0xff, 0xff}), // ones
|
||||
makeHalfWords<llvm::endianness::little>(
|
||||
{0xff, 0xf7, 0xfe, 0xef}), // common
|
||||
makeHalfWords<llvm::endianness::little>(
|
||||
{0x00, 0x00, 0x00, 0x00}), // zeros
|
||||
makeHalfWords<llvm::endianness::little>({0xff, 0xff, 0xff, 0xff}), // ones
|
||||
};
|
||||
|
||||
auto EncodeDecode = [ImmMask](int64_t In, MutableHalfWords &Mem) {
|
||||
@ -217,9 +221,11 @@ TEST(AArch32_Relocations, Thumb_MovtAbs) {
|
||||
|
||||
static std::array<uint8_t, 3> Registers{0, 5, 12};
|
||||
static std::array<HalfWords, 3> MemPresets{
|
||||
makeHalfWords<little>({0xff, 0xf7, 0xfe, 0xef}), // common
|
||||
makeHalfWords<little>({0x00, 0x00, 0x00, 0x00}), // zeros
|
||||
makeHalfWords<little>({0xff, 0xff, 0xff, 0xff}), // ones
|
||||
makeHalfWords<llvm::endianness::little>(
|
||||
{0xff, 0xf7, 0xfe, 0xef}), // common
|
||||
makeHalfWords<llvm::endianness::little>(
|
||||
{0x00, 0x00, 0x00, 0x00}), // zeros
|
||||
makeHalfWords<llvm::endianness::little>({0xff, 0xff, 0xff, 0xff}), // ones
|
||||
};
|
||||
|
||||
auto EncodeDecode = [ImmMask](uint32_t In, MutableHalfWords &Mem) {
|
||||
|
||||
@ -102,7 +102,8 @@ private:
|
||||
BumpPtrAllocator Allocator;
|
||||
};
|
||||
|
||||
constexpr endianness Endians[] = {big, little, native};
|
||||
constexpr llvm::endianness Endians[] = {
|
||||
llvm::endianness::big, llvm::endianness::little, llvm::endianness::native};
|
||||
constexpr uint32_t NumEndians = std::size(Endians);
|
||||
constexpr uint32_t NumStreams = 2 * NumEndians;
|
||||
|
||||
@ -931,7 +932,7 @@ TEST_F(BinaryStreamTest, BinaryItemStream) {
|
||||
Objects.push_back(BinaryItemStreamObject(Buffer));
|
||||
}
|
||||
|
||||
BinaryItemStream<BinaryItemStreamObject> ItemStream(big);
|
||||
BinaryItemStream<BinaryItemStreamObject> ItemStream(llvm::endianness::big);
|
||||
ItemStream.setItems(Objects);
|
||||
BinaryStreamReader Reader(ItemStream);
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@ TEST(EndianStream, WriteInt32LE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(data);
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
LE.write(static_cast<int32_t>(-1362446643));
|
||||
}
|
||||
|
||||
@ -35,7 +35,7 @@ TEST(EndianStream, WriteInt32BE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(data);
|
||||
endian::Writer BE(OS, big);
|
||||
endian::Writer BE(OS, llvm::endianness::big);
|
||||
BE.write(static_cast<int32_t>(-1362446643));
|
||||
}
|
||||
|
||||
@ -51,7 +51,7 @@ TEST(EndianStream, WriteFloatLE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(data);
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
LE.write(12345.0f);
|
||||
}
|
||||
|
||||
@ -66,7 +66,7 @@ TEST(EndianStream, WriteFloatBE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(data);
|
||||
endian::Writer BE(OS, big);
|
||||
endian::Writer BE(OS, llvm::endianness::big);
|
||||
BE.write(12345.0f);
|
||||
}
|
||||
|
||||
@ -81,7 +81,7 @@ TEST(EndianStream, WriteInt64LE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(data);
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
LE.write(static_cast<int64_t>(-136244664332342323));
|
||||
}
|
||||
|
||||
@ -100,7 +100,7 @@ TEST(EndianStream, WriteInt64BE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(data);
|
||||
endian::Writer BE(OS, big);
|
||||
endian::Writer BE(OS, llvm::endianness::big);
|
||||
BE.write(static_cast<int64_t>(-136244664332342323));
|
||||
}
|
||||
|
||||
@ -119,7 +119,7 @@ TEST(EndianStream, WriteDoubleLE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(data);
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
LE.write(-2349214918.58107);
|
||||
}
|
||||
|
||||
@ -138,7 +138,7 @@ TEST(EndianStream, WriteDoubleBE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(data);
|
||||
endian::Writer BE(OS, big);
|
||||
endian::Writer BE(OS, llvm::endianness::big);
|
||||
BE.write(-2349214918.58107);
|
||||
}
|
||||
|
||||
@ -157,7 +157,7 @@ TEST(EndianStream, WriteArrayLE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(Data);
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
LE.write<uint16_t>({0x1234, 0x5678});
|
||||
}
|
||||
|
||||
@ -172,7 +172,7 @@ TEST(EndianStream, WriteVectorLE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(Data);
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
std::vector<uint16_t> Vec{0x1234, 0x5678};
|
||||
LE.write<uint16_t>(Vec);
|
||||
}
|
||||
@ -188,7 +188,7 @@ TEST(EndianStream, WriteFloatArrayLE) {
|
||||
|
||||
{
|
||||
raw_svector_ostream OS(Data);
|
||||
endian::Writer LE(OS, little);
|
||||
endian::Writer LE(OS, llvm::endianness::little);
|
||||
LE.write<float>({12345.0f, 12346.0f});
|
||||
}
|
||||
|
||||
|
||||
@ -23,12 +23,17 @@ TEST(Endian, Read) {
|
||||
unsigned char bigval[] = {0x00, 0x01, 0x02, 0x03, 0x04};
|
||||
unsigned char littleval[] = {0x00, 0x04, 0x03, 0x02, 0x01};
|
||||
int32_t BigAsHost = 0x00010203;
|
||||
EXPECT_EQ(BigAsHost, (endian::read<int32_t, big, unaligned>(bigval)));
|
||||
EXPECT_EQ(BigAsHost,
|
||||
(endian::read<int32_t, llvm::endianness::big, unaligned>(bigval)));
|
||||
int32_t LittleAsHost = 0x02030400;
|
||||
EXPECT_EQ(LittleAsHost,(endian::read<int32_t, little, unaligned>(littleval)));
|
||||
EXPECT_EQ(
|
||||
LittleAsHost,
|
||||
(endian::read<int32_t, llvm::endianness::little, unaligned>(littleval)));
|
||||
|
||||
EXPECT_EQ((endian::read<int32_t, big, unaligned>(bigval + 1)),
|
||||
(endian::read<int32_t, little, unaligned>(littleval + 1)));
|
||||
EXPECT_EQ(
|
||||
(endian::read<int32_t, llvm::endianness::big, unaligned>(bigval + 1)),
|
||||
(endian::read<int32_t, llvm::endianness::little, unaligned>(littleval +
|
||||
1)));
|
||||
}
|
||||
|
||||
TEST(Endian, ReadBitAligned) {
|
||||
@ -36,35 +41,43 @@ TEST(Endian, ReadBitAligned) {
|
||||
unsigned char littleval[] = {0x3f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff};
|
||||
unsigned char bigval[] = {0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0};
|
||||
EXPECT_EQ(
|
||||
(endian::readAtBitAlignment<int, little, unaligned>(&littleval[0], 6)),
|
||||
(endian::readAtBitAlignment<int, llvm::endianness::little, unaligned>(
|
||||
&littleval[0], 6)),
|
||||
0x0);
|
||||
EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval[0], 6)),
|
||||
EXPECT_EQ((endian::readAtBitAlignment<int, llvm::endianness::big, unaligned>(
|
||||
&bigval[0], 6)),
|
||||
0x0);
|
||||
// Test to make sure that signed right shift of 0xf0000000 is masked
|
||||
// properly.
|
||||
unsigned char littleval2[] = {0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00};
|
||||
unsigned char bigval2[] = {0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
||||
EXPECT_EQ(
|
||||
(endian::readAtBitAlignment<int, little, unaligned>(&littleval2[0], 4)),
|
||||
(endian::readAtBitAlignment<int, llvm::endianness::little, unaligned>(
|
||||
&littleval2[0], 4)),
|
||||
0x0f000000);
|
||||
EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval2[0], 4)),
|
||||
EXPECT_EQ((endian::readAtBitAlignment<int, llvm::endianness::big, unaligned>(
|
||||
&bigval2[0], 4)),
|
||||
0x0f000000);
|
||||
// Test to make sure left shift of start bit doesn't overflow.
|
||||
EXPECT_EQ(
|
||||
(endian::readAtBitAlignment<int, little, unaligned>(&littleval2[0], 1)),
|
||||
(endian::readAtBitAlignment<int, llvm::endianness::little, unaligned>(
|
||||
&littleval2[0], 1)),
|
||||
0x78000000);
|
||||
EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval2[0], 1)),
|
||||
EXPECT_EQ((endian::readAtBitAlignment<int, llvm::endianness::big, unaligned>(
|
||||
&bigval2[0], 1)),
|
||||
0x78000000);
|
||||
// Test to make sure 64-bit int doesn't overflow.
|
||||
unsigned char littleval3[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
||||
unsigned char bigval3[] = {0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
||||
EXPECT_EQ((endian::readAtBitAlignment<int64_t, little, unaligned>(
|
||||
&littleval3[0], 4)),
|
||||
0x0f00000000000000);
|
||||
EXPECT_EQ(
|
||||
(endian::readAtBitAlignment<int64_t, big, unaligned>(&bigval3[0], 4)),
|
||||
(endian::readAtBitAlignment<int64_t, llvm::endianness::little, unaligned>(
|
||||
&littleval3[0], 4)),
|
||||
0x0f00000000000000);
|
||||
EXPECT_EQ(
|
||||
(endian::readAtBitAlignment<int64_t, llvm::endianness::big, unaligned>(
|
||||
&bigval3[0], 4)),
|
||||
0x0f00000000000000);
|
||||
}
|
||||
|
||||
@ -72,8 +85,8 @@ TEST(Endian, WriteBitAligned) {
|
||||
// This test ensures that signed right shift of 0xffffaa is masked
|
||||
// properly.
|
||||
unsigned char bigval[8] = {0x00};
|
||||
endian::writeAtBitAlignment<int32_t, big, unaligned>(bigval, (int)0xffffaaaa,
|
||||
4);
|
||||
endian::writeAtBitAlignment<int32_t, llvm::endianness::big, unaligned>(
|
||||
bigval, (int)0xffffaaaa, 4);
|
||||
EXPECT_EQ(bigval[0], 0xff);
|
||||
EXPECT_EQ(bigval[1], 0xfa);
|
||||
EXPECT_EQ(bigval[2], 0xaa);
|
||||
@ -84,8 +97,8 @@ TEST(Endian, WriteBitAligned) {
|
||||
EXPECT_EQ(bigval[7], 0x0f);
|
||||
|
||||
unsigned char littleval[8] = {0x00};
|
||||
endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval,
|
||||
(int)0xffffaaaa, 4);
|
||||
endian::writeAtBitAlignment<int32_t, llvm::endianness::little, unaligned>(
|
||||
littleval, (int)0xffffaaaa, 4);
|
||||
EXPECT_EQ(littleval[0], 0xa0);
|
||||
EXPECT_EQ(littleval[1], 0xaa);
|
||||
EXPECT_EQ(littleval[2], 0xfa);
|
||||
@ -98,8 +111,8 @@ TEST(Endian, WriteBitAligned) {
|
||||
// This test makes sure 1<<31 doesn't overflow.
|
||||
// Test to make sure left shift of start bit doesn't overflow.
|
||||
unsigned char bigval2[8] = {0x00};
|
||||
endian::writeAtBitAlignment<int32_t, big, unaligned>(bigval2, (int)0xffffffff,
|
||||
1);
|
||||
endian::writeAtBitAlignment<int32_t, llvm::endianness::big, unaligned>(
|
||||
bigval2, (int)0xffffffff, 1);
|
||||
EXPECT_EQ(bigval2[0], 0xff);
|
||||
EXPECT_EQ(bigval2[1], 0xff);
|
||||
EXPECT_EQ(bigval2[2], 0xff);
|
||||
@ -110,8 +123,8 @@ TEST(Endian, WriteBitAligned) {
|
||||
EXPECT_EQ(bigval2[7], 0x01);
|
||||
|
||||
unsigned char littleval2[8] = {0x00};
|
||||
endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval2,
|
||||
(int)0xffffffff, 1);
|
||||
endian::writeAtBitAlignment<int32_t, llvm::endianness::little, unaligned>(
|
||||
littleval2, (int)0xffffffff, 1);
|
||||
EXPECT_EQ(littleval2[0], 0xfe);
|
||||
EXPECT_EQ(littleval2[1], 0xff);
|
||||
EXPECT_EQ(littleval2[2], 0xff);
|
||||
@ -123,7 +136,7 @@ TEST(Endian, WriteBitAligned) {
|
||||
|
||||
// Test to make sure 64-bit int doesn't overflow.
|
||||
unsigned char bigval64[16] = {0x00};
|
||||
endian::writeAtBitAlignment<int64_t, big, unaligned>(
|
||||
endian::writeAtBitAlignment<int64_t, llvm::endianness::big, unaligned>(
|
||||
bigval64, (int64_t)0xffffffffffffffff, 1);
|
||||
EXPECT_EQ(bigval64[0], 0xff);
|
||||
EXPECT_EQ(bigval64[1], 0xff);
|
||||
@ -143,7 +156,7 @@ TEST(Endian, WriteBitAligned) {
|
||||
EXPECT_EQ(bigval64[15], 0x01);
|
||||
|
||||
unsigned char littleval64[16] = {0x00};
|
||||
endian::writeAtBitAlignment<int64_t, little, unaligned>(
|
||||
endian::writeAtBitAlignment<int64_t, llvm::endianness::little, unaligned>(
|
||||
littleval64, (int64_t)0xffffffffffffffff, 1);
|
||||
EXPECT_EQ(littleval64[0], 0xfe);
|
||||
EXPECT_EQ(littleval64[1], 0xff);
|
||||
@ -165,23 +178,26 @@ TEST(Endian, WriteBitAligned) {
|
||||
|
||||
TEST(Endian, Write) {
|
||||
unsigned char data[5];
|
||||
endian::write<int32_t, big, unaligned>(data, -1362446643);
|
||||
endian::write<int32_t, llvm::endianness::big, unaligned>(data, -1362446643);
|
||||
EXPECT_EQ(data[0], 0xAE);
|
||||
EXPECT_EQ(data[1], 0xCA);
|
||||
EXPECT_EQ(data[2], 0xB6);
|
||||
EXPECT_EQ(data[3], 0xCD);
|
||||
endian::write<int32_t, big, unaligned>(data + 1, -1362446643);
|
||||
endian::write<int32_t, llvm::endianness::big, unaligned>(data + 1,
|
||||
-1362446643);
|
||||
EXPECT_EQ(data[1], 0xAE);
|
||||
EXPECT_EQ(data[2], 0xCA);
|
||||
EXPECT_EQ(data[3], 0xB6);
|
||||
EXPECT_EQ(data[4], 0xCD);
|
||||
|
||||
endian::write<int32_t, little, unaligned>(data, -1362446643);
|
||||
endian::write<int32_t, llvm::endianness::little, unaligned>(data,
|
||||
-1362446643);
|
||||
EXPECT_EQ(data[0], 0xCD);
|
||||
EXPECT_EQ(data[1], 0xB6);
|
||||
EXPECT_EQ(data[2], 0xCA);
|
||||
EXPECT_EQ(data[3], 0xAE);
|
||||
endian::write<int32_t, little, unaligned>(data + 1, -1362446643);
|
||||
endian::write<int32_t, llvm::endianness::little, unaligned>(data + 1,
|
||||
-1362446643);
|
||||
EXPECT_EQ(data[1], 0xCD);
|
||||
EXPECT_EQ(data[2], 0xB6);
|
||||
EXPECT_EQ(data[3], 0xCA);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user