maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "OnDiskHashTable: Use EndianStream.h to write little endian ostreams" 

This reverts commit r205044.

llvm-svn: 205047
This commit is contained in:
Justin Bogner 2014-03-28 20:32:11 +00:00
parent 2583b06310
commit d42773bcc8
5 changed files with 128 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
clang/include/clang/Basic/OnDiskHashTable.h
View File

@ -17,7 +17,6 @@
#include "clang/Basic/LLVM.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/EndianStream.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
@ -30,11 +29,45 @@ namespace io {
typedef uint32_t Offset;
inline void Emit8(raw_ostream& Out, uint32_t V) {
Out << (unsigned char)(V);
}
inline void Emit16(raw_ostream& Out, uint32_t V) {
Out << (unsigned char)(V);
Out << (unsigned char)(V >> 8);
assert((V >> 16) == 0);
}
inline void Emit24(raw_ostream& Out, uint32_t V) {
Out << (unsigned char)(V);
Out << (unsigned char)(V >> 8);
Out << (unsigned char)(V >> 16);
assert((V >> 24) == 0);
}
inline void Emit32(raw_ostream& Out, uint32_t V) {
Out << (unsigned char)(V);
Out << (unsigned char)(V >> 8);
Out << (unsigned char)(V >> 16);
Out << (unsigned char)(V >> 24);
}
inline void Emit64(raw_ostream& Out, uint64_t V) {
Out << (unsigned char)(V);
Out << (unsigned char)(V >> 8);
Out << (unsigned char)(V >> 16);
Out << (unsigned char)(V >> 24);
Out << (unsigned char)(V >> 32);
Out << (unsigned char)(V >> 40);
Out << (unsigned char)(V >> 48);
Out << (unsigned char)(V >> 56);
}
inline void Pad(raw_ostream& Out, unsigned A) {
using namespace llvm::support;
Offset off = (Offset) Out.tell();
for (uint32_t n = llvm::OffsetToAlignment(off, A); n; --n)
endian::Writer<little>(Out).write<uint8_t>(0);
Emit8(Out, 0);
}
} // end namespace io
@ -116,8 +149,7 @@ public:
}
io::Offset Emit(raw_ostream &out, Info &InfoObj) {
using namespace llvm::support;
endian::Writer<little> LE(out);
using namespace clang::io;
// Emit the payload of the table.
for (unsigned i = 0; i < NumBuckets; ++i) {
@ -129,12 +161,12 @@ public:
assert(B.off && "Cannot write a bucket at offset 0. Please add padding.");
// Write out the number of items in the bucket.
LE.write<uint16_t>(B.length);
Emit16(out, B.length);
assert(B.length != 0 && "Bucket has a head but zero length?");
// Write out the entries in the bucket.
for (Item *I = B.head; I ; I = I->next) {
LE.write<uint32_t>(I->hash);
Emit32(out, I->hash);
const std::pair<unsigned, unsigned>& Len =
InfoObj.EmitKeyDataLength(out, I->key, I->data);
InfoObj.EmitKey(out, I->key, Len.first);
@ -143,12 +175,11 @@ public:
}
// Emit the hashtable itself.
io::Pad(out, 4);
Pad(out, 4);
io::Offset TableOff = out.tell();
LE.write<uint32_t>(NumBuckets);
LE.write<uint32_t>(NumEntries);
for (unsigned i = 0; i < NumBuckets; ++i)
LE.write<uint32_t>(Buckets[i].off);
Emit32(out, NumBuckets);
Emit32(out, NumEntries);
for (unsigned i = 0; i < NumBuckets; ++i) Emit32(out, Buckets[i].off);
return TableOff;
}

59
clang/lib/Frontend/CacheTokens.cpp
View File

@ -23,7 +23,6 @@
#include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Support/EndianStream.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
@ -79,23 +78,21 @@ public:
unsigned getKind() const { return (unsigned) Kind; }
void EmitData(raw_ostream& Out) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
switch (Kind) {
case IsFE: {
// Emit stat information.
llvm::sys::fs::UniqueID UID = FE->getUniqueID();
LE.write<uint64_t>(UID.getFile());
LE.write<uint64_t>(UID.getDevice());
LE.write<uint64_t>(FE->getModificationTime());
LE.write<uint64_t>(FE->getSize());
::Emit64(Out, UID.getFile());
::Emit64(Out, UID.getDevice());
::Emit64(Out, FE->getModificationTime());
::Emit64(Out, FE->getSize());
} break;
case IsDE:
// Emit stat information.
LE.write<uint64_t>(Data->UniqueID.getFile());
LE.write<uint64_t>(Data->UniqueID.getDevice());
LE.write<uint64_t>(Data->ModTime);
LE.write<uint64_t>(Data->Size);
::Emit64(Out, Data->UniqueID.getFile());
::Emit64(Out, Data->UniqueID.getDevice());
::Emit64(Out, Data->ModTime);
::Emit64(Out, Data->Size);
delete Data;
break;
default:
@ -123,36 +120,32 @@ public:
static std::pair<unsigned,unsigned>
EmitKeyDataLength(raw_ostream& Out, PTHEntryKeyVariant V,
const PTHEntry& E) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
unsigned n = V.getString().size() + 1 + 1;
LE.write<uint16_t>(n);
::Emit16(Out, n);
unsigned m = V.getRepresentationLength() + (V.isFile() ? 4 + 4 : 0);
LE.write<uint8_t>(m);
::Emit8(Out, m);
return std::make_pair(n, m);
}
static void EmitKey(raw_ostream& Out, PTHEntryKeyVariant V, unsigned n){
using namespace llvm::support;
// Emit the entry kind.
endian::Writer<little>(Out).write<uint8_t>((unsigned)V.getKind());
::Emit8(Out, (unsigned) V.getKind());
// Emit the string.
Out.write(V.getString().data(), n - 1);
}
static void EmitData(raw_ostream& Out, PTHEntryKeyVariant V,
const PTHEntry& E, unsigned) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
// For file entries emit the offsets into the PTH file for token data
// and the preprocessor blocks table.
if (V.isFile()) {
LE.write<uint32_t>(E.getTokenOffset());
LE.write<uint32_t>(E.getPPCondTableOffset());
::Emit32(Out, E.getTokenOffset());
::Emit32(Out, E.getPPCondTableOffset());
}
// Emit any other data associated with the key (i.e., stat information).
@ -193,28 +186,18 @@ class PTHWriter {
/// Emit a token to the PTH file.
void EmitToken(const Token& T);
void Emit8(uint32_t V) {
using namespace llvm::support;
endian::Writer<little>(Out).write<uint8_t>(V);
}
void Emit8(uint32_t V) { ::Emit8(Out, V); }
void Emit16(uint32_t V) {
using namespace llvm::support;
endian::Writer<little>(Out).write<uint16_t>(V);
}
void Emit16(uint32_t V) { ::Emit16(Out, V); }
void Emit32(uint32_t V) {
using namespace llvm::support;
endian::Writer<little>(Out).write<uint32_t>(V);
}
void Emit32(uint32_t V) { ::Emit32(Out, V); }
void EmitBuf(const char *Ptr, unsigned NumBytes) {
Out.write(Ptr, NumBytes);
}
void EmitString(StringRef V) {
using namespace llvm::support;
endian::Writer<little>(Out).write<uint16_t>(V.size());
::Emit16(Out, V.size());
EmitBuf(V.data(), V.size());
}
@ -601,9 +584,8 @@ public:
static std::pair<unsigned,unsigned>
EmitKeyDataLength(raw_ostream& Out, const PTHIdKey* key, uint32_t) {
using namespace llvm::support;
unsigned n = key->II->getLength() + 1;
endian::Writer<little>(Out).write<uint16_t>(n);
::Emit16(Out, n);
return std::make_pair(n, sizeof(uint32_t));
}
@ -616,8 +598,7 @@ public:
static void EmitData(raw_ostream& Out, PTHIdKey*, uint32_t pID,
unsigned) {
using namespace llvm::support;
endian::Writer<little>(Out).write<uint32_t>(pID);
::Emit32(Out, pID);
}
};
} // end anonymous namespace

1
clang/lib/Lex/PTHLexer.cpp
View File

@ -23,7 +23,6 @@
#include "clang/Lex/Token.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Support/EndianStream.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/system_error.h"
#include <memory>

154
clang/lib/Serialization/ASTWriter.cpp
View File

@ -46,7 +46,6 @@
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Bitcode/BitstreamWriter.h"
#include "llvm/Support/EndianStream.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
@ -1466,31 +1465,26 @@ namespace {
std::pair<unsigned,unsigned>
EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) {
using namespace llvm::support;
endian::Writer<little> Writer(Out);
unsigned KeyLen = strlen(key.Filename) + 1 + 8 + 8;
Writer.write<uint16_t>(KeyLen);
clang::io::Emit16(Out, KeyLen);
unsigned DataLen = 1 + 2 + 4 + 4;
if (Data.isModuleHeader)
DataLen += 4;
Writer.write<uint16_t>(DataLen);
clang::io::Emit8(Out, DataLen);
return std::make_pair(KeyLen, DataLen);
}
void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
LE.write<uint64_t>(key.FE->getSize());
clang::io::Emit64(Out, key.FE->getSize());
KeyLen -= 8;
LE.write<uint64_t>(key.FE->getModificationTime());
clang::io::Emit64(Out, key.FE->getModificationTime());
KeyLen -= 8;
Out.write(key.Filename, KeyLen);
}
void EmitData(raw_ostream &Out, key_type_ref key,
data_type_ref Data, unsigned DataLen) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
using namespace clang::io;
uint64_t Start = Out.tell(); (void)Start;
unsigned char Flags = (Data.HeaderRole << 6)
@ -1499,13 +1493,13 @@ namespace {
| (Data.DirInfo << 2)
| (Data.Resolved << 1)
| Data.IndexHeaderMapHeader;
LE.write<uint8_t>(Flags);
LE.write<uint16_t>(Data.NumIncludes);
Emit8(Out, (uint8_t)Flags);
Emit16(Out, (uint16_t) Data.NumIncludes);
if (!Data.ControllingMacro)
LE.write<uint32_t>(Data.ControllingMacroID);
Emit32(Out, (uint32_t)Data.ControllingMacroID);
else
LE.write<uint32_t>(Writer.getIdentifierRef(Data.ControllingMacro));
Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro));
unsigned Offset = 0;
if (!Data.Framework.empty()) {
@ -1522,11 +1516,11 @@ namespace {
} else
Offset = Pos->second;
}
LE.write<uint32_t>(Offset);
Emit32(Out, Offset);
if (Data.isModuleHeader) {
Module *Mod = HS.findModuleForHeader(key.FE).getModule();
LE.write<uint32_t>(Writer.getExistingSubmoduleID(Mod));
Emit32(Out, Writer.getExistingSubmoduleID(Mod));
}
assert(Out.tell() - Start == DataLen && "Wrong data length");
@ -1584,10 +1578,9 @@ void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) {
SmallString<4096> TableData;
uint32_t BucketOffset;
{
using namespace llvm::support;
llvm::raw_svector_ostream Out(TableData);
// Make sure that no bucket is at offset 0
endian::Writer<little>(Out).write(0);
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, GeneratorTrait);
}
@ -1842,14 +1835,12 @@ public:
}
static void EmitKey(raw_ostream& Out, key_type_ref Key, unsigned KeyLen) {
using namespace llvm::support;
endian::Writer<little>(Out).write<uint32_t>(Key);
clang::io::Emit32(Out, Key);
}
static void EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref Data,
unsigned) {
using namespace llvm::support;
endian::Writer<little>(Out).write<uint32_t>(Data.MacroDirectivesOffset);
clang::io::Emit32(Out, Data.MacroDirectivesOffset);
}
};
} // end anonymous namespace
@ -2045,10 +2036,9 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
SmallString<4096> MacroTable;
uint32_t BucketOffset;
{
using namespace llvm::support;
llvm::raw_svector_ostream Out(MacroTable);
// Make sure that no bucket is at offset 0
endian::Writer<little>(Out).write(0);
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out);
}
@ -2719,10 +2709,8 @@ public:
std::pair<unsigned,unsigned>
EmitKeyDataLength(raw_ostream& Out, Selector Sel,
data_type_ref Methods) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4);
LE.write<uint16_t>(KeyLen);
clang::io::Emit16(Out, KeyLen);
unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts
for (const ObjCMethodList *Method = &Methods.Instance; Method;
Method = Method->getNext())
@ -2732,31 +2720,27 @@ public:
Method = Method->getNext())
if (Method->Method)
DataLen += 4;
LE.write<uint16_t>(DataLen);
clang::io::Emit16(Out, DataLen);
return std::make_pair(KeyLen, DataLen);
}
void EmitKey(raw_ostream& Out, Selector Sel, unsigned) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
uint64_t Start = Out.tell();
assert((Start >> 32) == 0 && "Selector key offset too large");
Writer.SetSelectorOffset(Sel, Start);
unsigned N = Sel.getNumArgs();
LE.write<uint16_t>(N);
clang::io::Emit16(Out, N);
if (N == 0)
N = 1;
for (unsigned I = 0; I != N; ++I)
LE.write<uint32_t>(
Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I)));
clang::io::Emit32(Out,
Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I)));
}
void EmitData(raw_ostream& Out, key_type_ref,
data_type_ref Methods, unsigned DataLen) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
uint64_t Start = Out.tell(); (void)Start;
LE.write<uint32_t>(Methods.ID);
clang::io::Emit32(Out, Methods.ID);
unsigned NumInstanceMethods = 0;
for (const ObjCMethodList *Method = &Methods.Instance; Method;
Method = Method->getNext())
@ -2776,16 +2760,16 @@ public:
unsigned FactoryBits = Methods.Factory.getBits();
assert(FactoryBits < 4);
unsigned NumFactoryMethodsAndBits = (NumFactoryMethods << 2) | FactoryBits;
LE.write<uint16_t>(NumInstanceMethodsAndBits);
LE.write<uint16_t>(NumFactoryMethodsAndBits);
clang::io::Emit16(Out, NumInstanceMethodsAndBits);
clang::io::Emit16(Out, NumFactoryMethodsAndBits);
for (const ObjCMethodList *Method = &Methods.Instance; Method;
Method = Method->getNext())
if (Method->Method)
LE.write<uint32_t>(Writer.getDeclID(Method->Method));
clang::io::Emit32(Out, Writer.getDeclID(Method->Method));
for (const ObjCMethodList *Method = &Methods.Factory; Method;
Method = Method->getNext())
if (Method->Method)
LE.write<uint32_t>(Writer.getDeclID(Method->Method));
clang::io::Emit32(Out, Writer.getDeclID(Method->Method));
assert(Out.tell() - Start == DataLen && "Data length is wrong");
}
@ -2854,11 +2838,10 @@ void ASTWriter::WriteSelectors(Sema &SemaRef) {
SmallString<4096> MethodPool;
uint32_t BucketOffset;
{
using namespace llvm::support;
ASTMethodPoolTrait Trait(*this);
llvm::raw_svector_ostream Out(MethodPool);
// Make sure that no bucket is at offset 0
endian::Writer<little>(Out).write<uint32_t>(0);
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, Trait);
}
@ -3103,14 +3086,11 @@ public:
D != DEnd; ++D)
DataLen += sizeof(DeclID);
}
using namespace llvm::support;
endian::Writer<little> LE(Out);
LE.write<uint16_t>(DataLen);
clang::io::Emit16(Out, DataLen);
// We emit the key length after the data length so that every
// string is preceded by a 16-bit length. This matches the PTH
// format for storing identifiers.
LE.write<uint16_t>(KeyLen);
clang::io::Emit16(Out, KeyLen);
return std::make_pair(KeyLen, DataLen);
}
@ -3125,28 +3105,24 @@ public:
static void emitMacroOverrides(raw_ostream &Out,
llvm::ArrayRef<SubmoduleID> Overridden) {
if (!Overridden.empty()) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
LE.write<uint32_t>(Overridden.size() | 0x80000000U);
clang::io::Emit32(Out, Overridden.size() | 0x80000000U);
for (unsigned I = 0, N = Overridden.size(); I != N; ++I)
LE.write<uint32_t>(Overridden[I]);
clang::io::Emit32(Out, Overridden[I]);
}
}
void EmitData(raw_ostream& Out, IdentifierInfo* II,
IdentID ID, unsigned) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
MacroDirective *Macro = 0;
if (!isInterestingIdentifier(II, Macro)) {
LE.write<uint32_t>(ID << 1);
clang::io::Emit32(Out, ID << 1);
return;
}
LE.write<uint32_t>((ID << 1) | 0x01);
clang::io::Emit32(Out, (ID << 1) | 0x01);
uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID();
assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader.");
LE.write<uint16_t>(Bits);
clang::io::Emit16(Out, Bits);
Bits = 0;
bool HadMacroDefinition = hadMacroDefinition(II, Macro);
Bits = (Bits << 1) | unsigned(HadMacroDefinition);
@ -3155,10 +3131,10 @@ public:
Bits = (Bits << 1) | unsigned(II->isPoisoned());
Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier());
Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword());
LE.write<uint16_t>(Bits);
clang::io::Emit16(Out, Bits);
if (HadMacroDefinition) {
LE.write<uint32_t>(Writer.getMacroDirectivesOffset(II));
clang::io::Emit32(Out, Writer.getMacroDirectivesOffset(II));
if (IsModule) {
// Write the IDs of macros coming from different submodules.
SubmoduleID ModID;
@ -3171,14 +3147,14 @@ public:
if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD)) {
InfoID = Writer.getMacroID(DefMD->getInfo());
assert(InfoID);
LE.write<uint32_t>(InfoID << 1);
clang::io::Emit32(Out, InfoID << 1);
} else {
assert(isa<UndefMacroDirective>(MD));
LE.write<uint32_t>((ModID << 1) | 1);
clang::io::Emit32(Out, (ModID << 1) | 1);
}
}
emitMacroOverrides(Out, Overridden);
LE.write<uint32_t>(0);
clang::io::Emit32(Out, 0);
}
}
@ -3193,7 +3169,7 @@ public:
for (SmallVectorImpl<Decl *>::reverse_iterator D = Decls.rbegin(),
DEnd = Decls.rend();
D != DEnd; ++D)
LE.write<uint32_t>(Writer.getDeclID(getMostRecentLocalDecl(*D)));
clang::io::Emit32(Out, Writer.getDeclID(getMostRecentLocalDecl(*D)));
}
/// \brief Returns the most recent local decl or the given decl if there are
@ -3262,11 +3238,10 @@ void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
SmallString<4096> IdentifierTable;
uint32_t BucketOffset;
{
using namespace llvm::support;
ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule);
llvm::raw_svector_ostream Out(IdentifierTable);
// Make sure that no bucket is at offset 0
endian::Writer<little>(Out).write<uint32_t>(0);
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, Trait);
}
@ -3355,8 +3330,6 @@ public:
std::pair<unsigned,unsigned>
EmitKeyDataLength(raw_ostream& Out, DeclarationName Name,
data_type_ref Lookup) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
unsigned KeyLen = 1;
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
@ -3375,35 +3348,35 @@ public:
case DeclarationName::CXXUsingDirective:
break;
}
LE.write<uint16_t>(KeyLen);
clang::io::Emit16(Out, KeyLen);
// 2 bytes for num of decls and 4 for each DeclID.
unsigned DataLen = 2 + 4 * Lookup.size();
LE.write<uint16_t>(DataLen);
clang::io::Emit16(Out, DataLen);
return std::make_pair(KeyLen, DataLen);
}
void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
LE.write<uint8_t>(Name.getNameKind());
using namespace clang::io;
Emit8(Out, Name.getNameKind());
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
LE.write<uint32_t>(Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
return;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
LE.write<uint32_t>(Writer.getSelectorRef(Name.getObjCSelector()));
Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector()));
return;
case DeclarationName::CXXOperatorName:
assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS &&
"Invalid operator?");
LE.write<uint8_t>(Name.getCXXOverloadedOperator());
Emit8(Out, Name.getCXXOverloadedOperator());
return;
case DeclarationName::CXXLiteralOperatorName:
LE.write<uint32_t>(Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
return;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
@ -3417,13 +3390,11 @@ public:
void EmitData(raw_ostream& Out, key_type_ref,
data_type Lookup, unsigned DataLen) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
uint64_t Start = Out.tell(); (void)Start;
LE.write<uint16_t>(Lookup.size());
clang::io::Emit16(Out, Lookup.size());
for (DeclContext::lookup_iterator I = Lookup.begin(), E = Lookup.end();
I != E; ++I)
LE.write<uint32_t>(Writer.GetDeclRef(*I));
clang::io::Emit32(Out, Writer.GetDeclRef(*I));
assert(Out.tell() - Start == DataLen && "Data length is wrong");
}
@ -3516,8 +3487,7 @@ ASTWriter::GenerateNameLookupTable(const DeclContext *DC,
// Create the on-disk hash table in a buffer.
llvm::raw_svector_ostream Out(LookupTable);
// Make sure that no bucket is at offset 0
using namespace llvm::support;
endian::Writer<little>(Out).write<uint32_t>(0);
clang::io::Emit32(Out, 0);
return Generator.Emit(Out, Trait);
}
@ -4217,19 +4187,17 @@ void ASTWriter::WriteASTCore(Sema &SemaRef,
for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(),
MEnd = Chain->ModuleMgr.end();
M != MEnd; ++M) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
StringRef FileName = (*M)->FileName;
LE.write<uint16_t>(FileName.size());
io::Emit16(Out, FileName.size());
Out.write(FileName.data(), FileName.size());
LE.write<uint32_t>((*M)->SLocEntryBaseOffset);
LE.write<uint32_t>((*M)->BaseIdentifierID);
LE.write<uint32_t>((*M)->BaseMacroID);
LE.write<uint32_t>((*M)->BasePreprocessedEntityID);
LE.write<uint32_t>((*M)->BaseSubmoduleID);
LE.write<uint32_t>((*M)->BaseSelectorID);
LE.write<uint32_t>((*M)->BaseDeclID);
LE.write<uint32_t>((*M)->BaseTypeIndex);
io::Emit32(Out, (*M)->SLocEntryBaseOffset);
io::Emit32(Out, (*M)->BaseIdentifierID);
io::Emit32(Out, (*M)->BaseMacroID);
io::Emit32(Out, (*M)->BasePreprocessedEntityID);
io::Emit32(Out, (*M)->BaseSubmoduleID);
io::Emit32(Out, (*M)->BaseSelectorID);
io::Emit32(Out, (*M)->BaseDeclID);
io::Emit32(Out, (*M)->BaseTypeIndex);
}
}
Record.clear();

12
clang/lib/Serialization/GlobalModuleIndex.cpp
View File

@ -631,12 +631,10 @@ public:
std::pair<unsigned,unsigned>
EmitKeyDataLength(raw_ostream& Out, key_type_ref Key, data_type_ref Data) {
using namespace llvm::support;
endian::Writer<little> LE(Out);
unsigned KeyLen = Key.size();
unsigned DataLen = Data.size() * 4;
LE.write<uint16_t>(KeyLen);
LE.write<uint16_t>(DataLen);
clang::io::Emit16(Out, KeyLen);
clang::io::Emit16(Out, DataLen);
return std::make_pair(KeyLen, DataLen);
}
@ -646,9 +644,8 @@ public:
void EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref Data,
unsigned DataLen) {
using namespace llvm::support;
for (unsigned I = 0, N = Data.size(); I != N; ++I)
endian::Writer<little>(Out).write<uint32_t>(Data[I]);
clang::io::Emit32(Out, Data[I]);
}
};
@ -710,10 +707,9 @@ void GlobalModuleIndexBuilder::writeIndex(llvm::BitstreamWriter &Stream) {
SmallString<4096> IdentifierTable;
uint32_t BucketOffset;
{
using namespace llvm::support;
llvm::raw_svector_ostream Out(IdentifierTable);
// Make sure that no bucket is at offset 0
endian::Writer<little>(Out).write<uint32_t>(0);
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, Trait);
}