From 3277b69d734b9c90b44ebde4ede005717e2c3b2e Mon Sep 17 00:00:00 2001 From: ed Date: Tue, 2 Jun 2009 17:52:33 +0000 Subject: Import LLVM, at r72732. --- include/llvm/Bitcode/Serialize.h | 211 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 211 insertions(+) create mode 100644 include/llvm/Bitcode/Serialize.h (limited to 'include/llvm/Bitcode/Serialize.h') diff --git a/include/llvm/Bitcode/Serialize.h b/include/llvm/Bitcode/Serialize.h new file mode 100644 index 0000000..6fe4f02 --- /dev/null +++ b/include/llvm/Bitcode/Serialize.h @@ -0,0 +1,211 @@ +//==- Serialize.h - Generic Object Serialization to Bitcode -------*- C++ -*-=// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the interface for generic object serialization to +// LLVM bitcode. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_BITCODE_SERIALIZE_OUTPUT +#define LLVM_BITCODE_SERIALIZE_OUTPUT + +#include "llvm/Bitcode/Serialization.h" +#include "llvm/Bitcode/BitstreamWriter.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/DenseMap.h" + +namespace llvm { + +class Serializer { + BitstreamWriter& Stream; + SmallVector Record; + unsigned BlockLevel; + + typedef DenseMap MapTy; + MapTy PtrMap; + +public: + explicit Serializer(BitstreamWriter& stream); + ~Serializer(); + + //==------------------------------------------------==// + // Template-based dispatch to emit arbitrary types. + //==------------------------------------------------==// + + template + inline void Emit(const T& X) { SerializeTrait::Emit(*this,X); } + + //==------------------------------------------------==// + // Methods to emit primitive types. + //==------------------------------------------------==// + + void EmitInt(uint64_t X); + void EmitSInt(int64_t X); + + inline void EmitBool(bool X) { EmitInt(X); } + void EmitCStr(const char* beg, const char* end); + void EmitCStr(const char* cstr); + + void EmitPtr(const void* ptr) { EmitInt(getPtrId(ptr)); } + + template + inline void EmitRef(const T& ref) { EmitPtr(&ref); } + + // Emit a pointer and the object pointed to. (This has no relation to the + // OwningPtr<> class.) + template + inline void EmitOwnedPtr(T* ptr) { + EmitPtr(ptr); + if (ptr) SerializeTrait::Emit(*this,*ptr); + } + + + //==------------------------------------------------==// + // Batch emission of pointers. + //==------------------------------------------------==// + + template + void BatchEmitOwnedPtrs(T1* p1, T2* p2) { + EmitPtr(p1); + EmitPtr(p2); + if (p1) SerializeTrait::Emit(*this,*p1); + if (p2) SerializeTrait::Emit(*this,*p2); + } + + template + void BatchEmitOwnedPtrs(T1* p1, T2* p2, T3* p3) { + EmitPtr(p1); + EmitPtr(p2); + EmitPtr(p3); + if (p1) SerializeTrait::Emit(*this,*p1); + if (p2) SerializeTrait::Emit(*this,*p2); + if (p3) SerializeTrait::Emit(*this,*p3); + } + + template + void BatchEmitOwnedPtrs(T1* p1, T2* p2, T3* p3, T4& p4) { + EmitPtr(p1); + EmitPtr(p2); + EmitPtr(p3); + EmitPtr(p4); + if (p1) SerializeTrait::Emit(*this,*p1); + if (p2) SerializeTrait::Emit(*this,*p2); + if (p3) SerializeTrait::Emit(*this,*p3); + if (p4) SerializeTrait::Emit(*this,*p4); + } + + template + void BatchEmitOwnedPtrs(unsigned NumPtrs, T* const * Ptrs) { + for (unsigned i = 0; i < NumPtrs; ++i) + EmitPtr(Ptrs[i]); + + for (unsigned i = 0; i < NumPtrs; ++i) + if (Ptrs[i]) SerializeTrait::Emit(*this,*Ptrs[i]); + } + + template + void BatchEmitOwnedPtrs(unsigned NumT1Ptrs, T1* const * Ptrs, T2* p2) { + + for (unsigned i = 0; i < NumT1Ptrs; ++i) + EmitPtr(Ptrs[i]); + + EmitPtr(p2); + + for (unsigned i = 0; i < NumT1Ptrs; ++i) + if (Ptrs[i]) SerializeTrait::Emit(*this,*Ptrs[i]); + + if (p2) SerializeTrait::Emit(*this,*p2); + } + + template + void BatchEmitOwnedPtrs(unsigned NumT1Ptrs, T1* const * Ptrs, + T2* p2, T3* p3) { + + for (unsigned i = 0; i < NumT1Ptrs; ++i) + EmitPtr(Ptrs[i]); + + EmitPtr(p2); + EmitPtr(p3); + + for (unsigned i = 0; i < NumT1Ptrs; ++i) + if (Ptrs[i]) SerializeTrait::Emit(*this,*Ptrs[i]); + + if (p2) SerializeTrait::Emit(*this,*p2); + if (p3) SerializeTrait::Emit(*this,*p3); + } + + //==------------------------------------------------==// + // Emitter Functors + //==------------------------------------------------==// + + template + struct Emitter0 { + Serializer& S; + Emitter0(Serializer& s) : S(s) {} + void operator()(const T& x) const { + SerializeTrait::Emit(S,x); + } + }; + + template + struct Emitter1 { + Serializer& S; + Arg1 A1; + + Emitter1(Serializer& s, Arg1 a1) : S(s), A1(a1) {} + void operator()(const T& x) const { + SerializeTrait::Emit(S,x,A1); + } + }; + + template + struct Emitter2 { + Serializer& S; + Arg1 A1; + Arg2 A2; + + Emitter2(Serializer& s, Arg1 a1, Arg2 a2) : S(s), A1(a1), A2(a2) {} + void operator()(const T& x) const { + SerializeTrait::Emit(S,x,A1,A2); + } + }; + + template + Emitter0 MakeEmitter() { + return Emitter0(*this); + } + + template + Emitter1 MakeEmitter(Arg1 a1) { + return Emitter1(*this,a1); + } + + template + Emitter2 MakeEmitter(Arg1 a1, Arg2 a2) { + return Emitter2(*this,a1,a2); + } + + //==------------------------------------------------==// + // Misc. query and block/record manipulation methods. + //==------------------------------------------------==// + + bool isRegistered(const void* p) const; + + void FlushRecord() { if (inRecord()) EmitRecord(); } + void EnterBlock(unsigned BlockID = 8, unsigned CodeLen = 3); + void ExitBlock(); + +private: + void EmitRecord(); + inline bool inRecord() { return Record.size() > 0; } + SerializedPtrID getPtrId(const void* ptr); +}; + +} // end namespace llvm +#endif -- cgit v1.1