X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=include%2Fllvm%2FBitcode%2FBitstreamWriter.h;h=fcbcbbf0fb4c25edccb17ba384ea8c61df7ed2da;hb=a727d5502c8e23c090da658bf14c5ebc1169a070;hp=4aef53bf7c335d38b5a2796084fd70b218b3fa8e;hpb=b35ca9db9ce25e6b61aa3eaee41464f647d34899;p=oota-llvm.git

diff --git a/include/llvm/Bitcode/BitstreamWriter.h b/include/llvm/Bitcode/BitstreamWriter.h
index 4aef53bf7c3..fcbcbbf0fb4 100644
--- a/include/llvm/Bitcode/BitstreamWriter.h
+++ b/include/llvm/Bitcode/BitstreamWriter.h
@@ -16,8 +16,6 @@
 #define BITSTREAM_WRITER_H
 
 #include "llvm/Bitcode/BitCodes.h"
-#include "llvm/ADT/SmallVector.h"
-#include <cassert>
 #include <vector>
 
 namespace llvm {
@@ -34,22 +32,27 @@ class BitstreamWriter {
   // CurCodeSize - This is the declared size of code values used for the current
   // block, in bits.
   unsigned CurCodeSize;
-  
+
+  /// CurAbbrevs - Abbrevs installed at in this block.
+  std::vector<BitCodeAbbrev*> CurAbbrevs;
+
   struct Block {
     unsigned PrevCodeSize;
     unsigned StartSizeWord;
+    std::vector<BitCodeAbbrev*> PrevAbbrevs;
     Block(unsigned PCS, unsigned SSW) : PrevCodeSize(PCS), StartSizeWord(SSW) {}
   };
   
   /// BlockScope - This tracks the current blocks that we have entered.
   std::vector<Block> BlockScope;
+  
 public:
   BitstreamWriter(std::vector<unsigned char> &O) 
     : Out(O), CurBit(0), CurValue(0), CurCodeSize(2) {}
 
   ~BitstreamWriter() {
     assert(CurBit == 0 && "Unflused data remaining");
-    assert(BlockScope.empty() && "Block imbalance");
+    assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");
   }
   //===--------------------------------------------------------------------===//
   // Basic Primitives for emitting bits to the stream.
@@ -72,7 +75,7 @@ public:
     Out.push_back((unsigned char)(V >> 24));
     
     if (CurBit)
-      CurValue = Val >> 32-CurBit;
+      CurValue = Val >> (32-CurBit);
     else
       CurValue = 0;
     CurBit = (CurBit+NumBits) & 31;
@@ -144,6 +147,8 @@ public:
     EmitVBR(CodeLen, bitc::CodeLenWidth);
     FlushToWord();
     BlockScope.push_back(Block(CurCodeSize, Out.size()/4));
+    BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
+    
     // Emit a placeholder, which will be replaced when the block is popped.
     Emit(0, bitc::BlockSizeWidth);
     
@@ -152,8 +157,12 @@ public:
   
   void ExitBlock() {
     assert(!BlockScope.empty() && "Block scope imbalance!");
-    Block B = BlockScope.back();
-    BlockScope.pop_back();
+    
+    // Delete all abbrevs.
+    for (unsigned i = 0, e = CurAbbrevs.size(); i != e; ++i)
+      CurAbbrevs[i]->dropRef();
+    
+    const Block &B = BlockScope.back();
     
     // Block tail:
     //    [END_BLOCK, <align4bytes>]
@@ -170,8 +179,10 @@ public:
     Out[ByteNo++] = (unsigned char)(SizeInWords >> 16);
     Out[ByteNo++] = (unsigned char)(SizeInWords >> 24);
     
-    // Restore the outer block's code size.
+    // Restore the inner block's code size and abbrev table.
     CurCodeSize = B.PrevCodeSize;
+    BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
+    BlockScope.pop_back();
   }
   
   //===--------------------------------------------------------------------===//
@@ -183,7 +194,43 @@ public:
   void EmitRecord(unsigned Code, SmallVectorImpl<uint64_t> &Vals,
                   unsigned Abbrev = 0) {
     if (Abbrev) {
-      assert(0 && "abbrevs not implemented yet!");
+      unsigned AbbrevNo = Abbrev-bitc::FIRST_APPLICATION_ABBREV;
+      assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
+      BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo];
+      
+      EmitCode(Abbrev);
+      
+      // Insert the code into Vals to treat it uniformly.
+      Vals.insert(Vals.begin(), Code);
+      
+      unsigned RecordIdx = 0;
+      for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) {
+        assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
+        const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
+        uint64_t RecordVal = Vals[RecordIdx];
+        
+        if (Op.isLiteral()) {
+          // If the abbrev specifies the literal value to use, don't emit
+          // anything.
+          assert(RecordVal == Op.getLiteralValue() &&
+                 "Invalid abbrev for record!");
+          ++RecordIdx;
+        } else {
+          // Encode the value as we are commanded.
+          switch (Op.getEncoding()) {
+          default: assert(0 && "Unknown encoding!");
+          case BitCodeAbbrevOp::FixedWidth:
+            Emit64(RecordVal, Op.getEncodingData());
+            ++RecordIdx;
+            break;
+          case BitCodeAbbrevOp::VBR:
+            EmitVBR64(RecordVal, Op.getEncodingData());
+            ++RecordIdx;
+            break;
+          }
+        }
+      }
+      assert(RecordIdx == Vals.size() && "Not all record operands emitted!");
     } else {
       // If we don't have an abbrev to use, emit this in its fully unabbreviated
       // form.
@@ -200,7 +247,43 @@ public:
   void EmitRecord(unsigned Code, SmallVectorImpl<unsigned> &Vals,
                   unsigned Abbrev = 0) {
     if (Abbrev) {
-      assert(0 && "abbrevs not implemented yet!");
+      unsigned AbbrevNo = Abbrev-bitc::FIRST_APPLICATION_ABBREV;
+      assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
+      BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo];
+      
+      EmitCode(Abbrev);
+
+      // Insert the code into Vals to treat it uniformly.
+      Vals.insert(Vals.begin(), Code);
+      
+      unsigned RecordIdx = 0;
+      for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) {
+        assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
+        const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
+        unsigned RecordVal = Vals[RecordIdx];
+        
+        if (Op.isLiteral()) {
+          // If the abbrev specifies the literal value to use, don't emit
+          // anything.
+          assert(RecordVal == Op.getLiteralValue() &&
+                 "Invalid abbrev for record!");
+          ++RecordIdx;
+        } else {
+          // Encode the value as we are commanded.
+          switch (Op.getEncoding()) {
+          default: assert(0 && "Unknown encoding!");
+          case BitCodeAbbrevOp::FixedWidth:
+            Emit(RecordVal, Op.getEncodingData());
+            ++RecordIdx;
+            break;
+          case BitCodeAbbrevOp::VBR:
+            EmitVBR(RecordVal, Op.getEncodingData());
+            ++RecordIdx;
+            break;
+          }
+        }
+      }
+      assert(RecordIdx == Vals.size() && "Not all record operands emitted!");
     } else {
       // If we don't have an abbrev to use, emit this in its fully unabbreviated
       // form.
@@ -211,6 +294,32 @@ public:
         EmitVBR(Vals[i], 6);
     }
   }
+  
+  //===--------------------------------------------------------------------===//
+  // Abbrev Emission
+  //===--------------------------------------------------------------------===//
+  
+  /// EmitAbbrev - This emits an abbreviation to the stream.  Note that this
+  /// method takes ownership of the specified abbrev.
+  unsigned EmitAbbrev(BitCodeAbbrev *Abbv) {
+    // Emit the abbreviation as a record.
+    EmitCode(bitc::DEFINE_ABBREV);
+    EmitVBR(Abbv->getNumOperandInfos(), 5);
+    for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) {
+      const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
+      Emit(Op.isLiteral(), 1);
+      if (Op.isLiteral()) {
+        EmitVBR64(Op.getLiteralValue(), 8);
+      } else {
+        Emit(Op.getEncoding(), 3);
+        if (Op.hasEncodingData())
+          EmitVBR64(Op.getEncodingData(), 5);
+      }
+    }
+    
+    CurAbbrevs.push_back(Abbv);
+    return CurAbbrevs.size()-1+bitc::FIRST_APPLICATION_ABBREV;
+  }
 };