commit 6e9b49664357bf970ebabc94ce3295ec5f41413b
author Ted Kremenek <kremenek@apple.com> Wed Oct 24 19:06:40 2007 +0000
committer Ted Kremenek <kremenek@apple.com> Wed Oct 24 19:06:40 2007 +0000
tree 1ce826794cbe38fce1c7bb292dc5bae94731ff18
parent be3e348c7ccf0158d91fe4c9497a94c59dd5c025

Split Serialization.h into separate headers: Serialize.h and
Deserialize.h Serialization.h now includes trait speciailizations for
unsigned long, etc.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@43307 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Bitcode/Reader/Deserialize.cpp

diff --git a/lib/Bitcode/Reader/Deserialize.cpp b/lib/Bitcode/Reader/Deserialize.cpp
index ccd929a..cf5fe20 100644
--- a/lib/Bitcode/Reader/Deserialize.cpp
+++ b/lib/Bitcode/Reader/Deserialize.cpp
@@ -11,7 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Bitcode/Serialization.h"
+#include "llvm/Bitcode/Deserialize.h"
 
 using namespace llvm;
 
@@ -27,31 +27,29 @@
 void Deserializer::ReadRecord() {
   // FIXME: Check if we haven't run off the edge of the stream.
   // FIXME: Handle abbreviations.
-  unsigned Code = Stream.ReadCode();
+
   // FIXME: Check for the correct code.
-  assert (Record.size() == 0);
-  
-  Stream.ReadRecord(Code,Record);
-  
+  unsigned Code = Stream.ReadCode();
+
+  assert (Record.size() == 0);  
+  Stream.ReadRecord(Code,Record);  
   assert (Record.size() > 0);
 }
 
-uint64_t Deserializer::ReadInt(unsigned Bits) {
+uint64_t Deserializer::ReadInt() {
   // FIXME: Any error recovery/handling with incomplete or bad files?
   if (!inRecord())
     ReadRecord();
 
-  // FIXME: check for loss of precision in read (compare to Bits)
   return Record[RecIdx++];
 }
 
-char* Deserializer::ReadCString(char* cstr, unsigned MaxLen, bool isNullTerm) {
+char* Deserializer::ReadCStr(char* cstr, unsigned MaxLen, bool isNullTerm) {
   if (cstr == NULL)
     MaxLen = 0; // Zero this just in case someone does something funny.
   
-  unsigned len = ReadInt(32);
+  unsigned len = ReadInt();
 
-  // FIXME: perform dynamic checking of lengths?
   assert (MaxLen == 0 || (len + (isNullTerm ? 1 : 0)) <= MaxLen);
 
   if (!cstr)
@@ -60,7 +58,7 @@
   assert (cstr != NULL);
   
   for (unsigned i = 0; i < len; ++i)
-    cstr[i] = ReadInt(8);
+    cstr[i] = (char) ReadInt();
   
   if (isNullTerm)
     cstr[len+1] = '\0';
@@ -68,16 +66,27 @@
   return cstr;
 }
 
-void Deserializer::ReadCString(std::vector<char>& buff, bool isNullTerm) {
-  buff.clear();
+void Deserializer::ReadCStr(std::vector<char>& buff, bool isNullTerm) {
+  unsigned len = ReadInt();
 
-  unsigned len = ReadInt(32);
-  
+  buff.clear();  
   buff.reserve(len);
   
   for (unsigned i = 0; i < len; ++i)
-    buff.push_back(ReadInt(8));
+    buff.push_back((char) ReadInt());
   
   if (isNullTerm)
     buff.push_back('\0');
 }
+
+
+#define INT_READ(TYPE)\
+void SerializeTrait<TYPE>::Read(Deserializer& D, TYPE& X) {\
+  X = (TYPE) D.ReadInt(); }
+
+INT_READ(bool)
+INT_READ(unsigned char)
+INT_READ(unsigned short)
+INT_READ(unsigned int)
+INT_READ(unsigned long)
+INT_READ(unsigned long long)

lib/Bitcode/Writer/Serialize.cpp

diff --git a/lib/Bitcode/Writer/Serialize.cpp b/lib/Bitcode/Writer/Serialize.cpp
index 9fbb97d..7293933 100644
--- a/lib/Bitcode/Writer/Serialize.cpp
+++ b/lib/Bitcode/Writer/Serialize.cpp
@@ -11,7 +11,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Bitcode/Serialization.h"
+#include "llvm/Bitcode/Serialize.h"
+#include "string.h"
 
 using namespace llvm;
 
@@ -37,16 +38,31 @@
   Record.clear();
 }
 
-void Serializer::EmitInt(unsigned X, unsigned bits) {
+void Serializer::EmitInt(unsigned X) {
   Record.push_back(X);
 }
 
-void Serializer::EmitCString(const char* cstr) {
-  unsigned l = strlen(cstr);
-  Record.push_back(l);
+void Serializer::EmitCStr(const char* s, const char* end) {
+  Record.push_back(end - s);
   
-  for (unsigned i = 0; i < l; i++)
-    Record.push_back(cstr[i]);
+  while(s != end) {
+    Record.push_back(*s);
+    ++s;
+  }
 
   EmitRecord();
 }
+
+void Serializer::EmitCStr(const char* s) {
+  EmitCStr(s,s+strlen(s));
+}
+
+#define INT_EMIT(TYPE)\
+void SerializeTrait<TYPE>::Emit(Serializer&S, TYPE X) { S.EmitInt(X); }
+
+INT_EMIT(bool)
+INT_EMIT(unsigned char)
+INT_EMIT(unsigned short)
+INT_EMIT(unsigned int)
+INT_EMIT(unsigned long)
+INT_EMIT(unsigned long long)