Make abbreviations explicit in pnacl-freeze/thaw.

lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp

 //===- NaClBitcodeReader.cpp ----------------------------------------------===//
 //     Internal NaClBitcodeReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#define DEBUG_TYPE "NaClBitcodeReader"
+
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "NaClBitcodeReader.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/AutoUpgrade.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/Operator.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/DataStream.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 using namespace llvm;
 
 enum {
   SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
 };
 
 void NaClBitcodeReader::materializeForwardReferencedFunctions() {
@@ skipping 410 matching lines @@
   assert((!Alignment || isPowerOf2_32(Alignment)) &&
          "Alignment must be a power of two.");
 
   if (Alignment)
     B.addAlignmentAttr(Alignment);
   B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) |
                 (EncodedAttrs & 0xffff));
 }
 
 bool NaClBitcodeReader::ParseAttributeBlock() {
+  DEBUG(dbgs() << "-> ParseAttributeBlock\n");
   if (Stream.EnterSubBlock(naclbitc::PARAMATTR_BLOCK_ID))
     return Error("Malformed block record");
 
   if (!MAttributes.empty())
     return Error("Multiple PARAMATTR blocks found!");
 
   SmallVector<uint64_t, 64> Record;
 
   SmallVector<AttributeSet, 8> Attrs;
 
   // Read all the records.
   while (1) {
     NaClBitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::SubBlock: // Handled for us already.
     case NaClBitstreamEntry::Error:
       return Error("Error at end of PARAMATTR block");
     case NaClBitstreamEntry::EndBlock:
+      DEBUG(dbgs() << "<- ParseAttributeBlock\n");
       return false;
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read a record.
     Record.clear();
     switch (Stream.readRecord(Entry.ID, Record)) {
     default:  // Default behavior: ignore.
@@ skipping 19 matching lines @@
 
       MAttributes.push_back(AttributeSet::get(Context, Attrs));
       Attrs.clear();
       break;
     }
     }
   }
 }
 
 bool NaClBitcodeReader::ParseAttributeGroupBlock() {
+  DEBUG(dbgs() << "-> ParseAttributeGroupBlock\n");
   if (Stream.EnterSubBlock(naclbitc::PARAMATTR_GROUP_BLOCK_ID))
     return Error("Malformed block record");
 
   if (!MAttributeGroups.empty())
     return Error("Multiple PARAMATTR_GROUP blocks found!");
 
   SmallVector<uint64_t, 64> Record;
 
   // Read all the records.
   while (1) {
     NaClBitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::SubBlock: // Handled for us already.
     case NaClBitstreamEntry::Error:
       return Error("Error at end of PARAMATTR_GROUP block");
     case NaClBitstreamEntry::EndBlock:
+      DEBUG(dbgs() << "<- ParseAttributeGroupBlock\n");
       return false;
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read a record.
     Record.clear();
     switch (Stream.readRecord(Entry.ID, Record)) {
     default:  // Default behavior: ignore.
@@ skipping 39 matching lines @@
       }
 
       MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B);
       break;
     }
     }
   }
 }
 
 bool NaClBitcodeReader::ParseTypeTable() {
+  DEBUG(dbgs() << "-> ParseTypeTable\n");
   if (Stream.EnterSubBlock(naclbitc::TYPE_BLOCK_ID_NEW))
     return Error("Malformed block record");
 
-  return ParseTypeTableBody();
+  bool result = ParseTypeTableBody();
+  if (!result)
+    DEBUG(dbgs() << "<- ParseTypeTable\n");
+  return result;
 }
 
 bool NaClBitcodeReader::ParseTypeTableBody() {
   if (!TypeList.empty())
     return Error("Multiple TYPE_BLOCKs found!");
 
   SmallVector<uint64_t, 64> Record;
   unsigned NumRecords = 0;
 
   SmallString<64> TypeName;
@@ skipping 202 matching lines @@
 
     if (NumRecords >= TypeList.size())
       return Error("invalid TYPE table");
     assert(ResultTy && "Didn't read a type?");
     assert(TypeList[NumRecords] == 0 && "Already read type?");
     TypeList[NumRecords++] = ResultTy;
   }
 }
 
 bool NaClBitcodeReader::ParseValueSymbolTable() {
+  DEBUG(dbgs() << "-> ParseValueSymbolTable\n");
   if (Stream.EnterSubBlock(naclbitc::VALUE_SYMTAB_BLOCK_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
 
   // Read all the records for this value table.
   SmallString<128> ValueName;
   while (1) {
     NaClBitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::SubBlock: // Handled for us already.
     case NaClBitstreamEntry::Error:
       return Error("malformed value symbol table block");
     case NaClBitstreamEntry::EndBlock:
+      DEBUG(dbgs() << "<- ParseValueSymbolTable\n");
       return false;
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read a record.
     Record.clear();
     switch (Stream.readRecord(Entry.ID, Record)) {
     default:  // Default behavior: unknown type.
@@ skipping 21 matching lines @@
       ValueName.clear();
       break;
     }
     }
   }
 }
 
 bool NaClBitcodeReader::ParseMetadata() {
   unsigned NextMDValueNo = MDValueList.size();
 
+  DEBUG(dbgs() << "-> ParseMetadata\n");
   if (Stream.EnterSubBlock(naclbitc::METADATA_BLOCK_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
 
   // Read all the records.
   while (1) {
     NaClBitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::SubBlock: // Handled for us already.
     case NaClBitstreamEntry::Error:
       Error("malformed metadata block");
       return true;
     case NaClBitstreamEntry::EndBlock:
+      DEBUG(dbgs() << "<- ParseMetadata\n");
       return false;
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     bool IsFunctionLocal = false;
     // Read a record.
     Record.clear();
     unsigned Code = Stream.readRecord(Entry.ID, Record);
@@ skipping 60 matching lines @@
 
       unsigned NewKind = TheModule->getMDKindID(Name.str());
       if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
         return Error("Conflicting METADATA_KIND records");
       break;
     }
     }
   }
 }
 
-/// decodeSignRotatedValue - Decode a signed value stored with the sign bit in
-/// the LSB for dense VBR encoding.
-uint64_t NaClBitcodeReader::decodeSignRotatedValue(uint64_t V) {
-  if ((V & 1) == 0)
-    return V >> 1;
-  if (V != 1)
-    return -(V >> 1);
-  // There is no such thing as -0 with integers.  "-0" really means MININT.
-  return 1ULL << 63;
-}
-
 /// ResolveGlobalAndAliasInits - Resolve all of the initializers for global
 /// values and aliases that we can.
 bool NaClBitcodeReader::ResolveGlobalAndAliasInits() {
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
 
   GlobalInitWorklist.swap(GlobalInits);
   AliasInitWorklist.swap(AliasInits);
 
   while (!GlobalInitWorklist.empty()) {
@@ skipping 21 matching lines @@
         return Error("Alias initializer is not a constant!");
     }
     AliasInitWorklist.pop_back();
   }
   return false;
 }
 
 static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) {
   SmallVector<uint64_t, 8> Words(Vals.size());
   std::transform(Vals.begin(), Vals.end(), Words.begin(),
-                 NaClBitcodeReader::decodeSignRotatedValue);
+                 NaClDecodeSignRotatedValue);
 
   return APInt(TypeBits, Words);
 }
 
 bool NaClBitcodeReader::ParseConstants() {
+  DEBUG(dbgs() << "-> ParseConstants\n");
   if (Stream.EnterSubBlock(naclbitc::CONSTANTS_BLOCK_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
 
   // Read all the records for this value table.
   Type *CurTy = Type::getInt32Ty(Context);
   unsigned NextCstNo = ValueList.size();
   while (1) {
     NaClBitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::SubBlock: // Handled for us already.
     case NaClBitstreamEntry::Error:
       return Error("malformed block record in AST file");
     case NaClBitstreamEntry::EndBlock:
       if (NextCstNo != ValueList.size())
         return Error("Invalid constant reference!");
 
       // Once all the constants have been read, go through and resolve forward
       // references.
       ValueList.ResolveConstantForwardRefs();
+      DEBUG(dbgs() << "<- ParseConstants\n");
       return false;
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read a record.
     Record.clear();
     Value *V = 0;
     unsigned BitCode = Stream.readRecord(Entry.ID, Record);
     switch (BitCode) {
     default:  // Default behavior: unknown constant
     case naclbitc::CST_CODE_UNDEF:     // UNDEF
       V = UndefValue::get(CurTy);
       break;
     case naclbitc::CST_CODE_SETTYPE:   // SETTYPE: [typeid]
       if (Record.empty())
         return Error("Malformed CST_SETTYPE record");
       if (Record[0] >= TypeList.size())
         return Error("Invalid Type ID in CST_SETTYPE record");
       CurTy = TypeList[Record[0]];
       continue;  // Skip the ValueList manipulation.
     case naclbitc::CST_CODE_NULL:      // NULL
       V = Constant::getNullValue(CurTy);
       break;
     case naclbitc::CST_CODE_INTEGER:   // INTEGER: [intval]
       if (!CurTy->isIntegerTy() || Record.empty())
         return Error("Invalid CST_INTEGER record");
-      V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
+      V = ConstantInt::get(CurTy, NaClDecodeSignRotatedValue(Record[0]));
       break;
     case naclbitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
       if (!CurTy->isIntegerTy() || Record.empty())
         return Error("Invalid WIDE_INTEGER record");
 
       APInt VInt = ReadWideAPInt(Record,
                                  cast<IntegerType>(CurTy)->getBitWidth());
       V = ConstantInt::get(Context, VInt);
 
       break;
@@ skipping 325 matching lines @@
       break;
     }
     }
 
     ValueList.AssignValue(V, NextCstNo);
     ++NextCstNo;
   }
 }
 
 bool NaClBitcodeReader::ParseUseLists() {
+  DEBUG(dbgs() << "-> ParseUseLists\n");
   if (Stream.EnterSubBlock(naclbitc::USELIST_BLOCK_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
 
   // Read all the records.
   while (1) {
     NaClBitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::SubBlock: // Handled for us already.
     case NaClBitstreamEntry::Error:
       return Error("malformed use list block");
     case NaClBitstreamEntry::EndBlock:
+      DEBUG(dbgs() << "<- ParseUseLists\n");
       return false;
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read a use list record.
     Record.clear();
     switch (Stream.readRecord(Entry.ID, Record)) {
     default:  // Default behavior: unknown type.
       break;
     case naclbitc::USELIST_CODE_ENTRY: { // USELIST_CODE_ENTRY: TBD.
       unsigned RecordLength = Record.size();
       if (RecordLength < 1)
         return Error ("Invalid UseList reader!");
       UseListRecords.push_back(Record);
       break;
     }
     }
   }
 }
 
 /// RememberAndSkipFunctionBody - When we see the block for a function body,
 /// remember where it is and then skip it.  This lets us lazily deserialize the
 /// functions.
 bool NaClBitcodeReader::RememberAndSkipFunctionBody() {
+  DEBUG(dbgs() << "-> RememberAndSkipFunctionBody\n");
   // Get the function we are talking about.
   if (FunctionsWithBodies.empty())
     return Error("Insufficient function protos");
 
   Function *Fn = FunctionsWithBodies.back();
   FunctionsWithBodies.pop_back();
 
   // Save the current stream state.
   uint64_t CurBit = Stream.GetCurrentBitNo();
   DeferredFunctionInfo[Fn] = CurBit;
 
   // Skip over the function block for now.
   if (Stream.SkipBlock())
     return Error("Malformed block record");
+  DEBUG(dbgs() << "<- RememberAndSkipFunctionBody\n");
   return false;
 }
 
 bool NaClBitcodeReader::GlobalCleanup() {
   // Patch the initializers for globals and aliases up.
   ResolveGlobalAndAliasInits();
   if (!GlobalInits.empty() || !AliasInits.empty())
     return Error("Malformed global initializer set");
 
   // Look for intrinsic functions which need to be upgraded at some point
@@ skipping 10 matching lines @@
        GI != GE; ++GI)
     UpgradeGlobalVariable(GI);
   // Force deallocation of memory for these vectors to favor the client that
   // want lazy deserialization.
   std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
   std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
   return false;
 }
 
 bool NaClBitcodeReader::ParseModule(bool Resume) {
+  DEBUG(dbgs() << "-> ParseModule\n");
   if (Resume)
     Stream.JumpToBit(NextUnreadBit);
   else if (Stream.EnterSubBlock(naclbitc::MODULE_BLOCK_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
   std::vector<std::string> SectionTable;
   std::vector<std::string> GCTable;
 
   // Read all the records for this module.
   while (1) {
     NaClBitstreamEntry Entry = Stream.advance();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::Error:
       Error("malformed module block");
       return true;
     case NaClBitstreamEntry::EndBlock:
+      DEBUG(dbgs() << "<- ParseModule\n");
       return GlobalCleanup();
 
     case NaClBitstreamEntry::SubBlock:
       switch (Entry.ID) {
       default:  // Skip unknown content.
+        DEBUG(dbgs() << "Skip unknown context\n");
         if (Stream.SkipBlock())
           return Error("Malformed block record");
         break;
       case naclbitc::BLOCKINFO_BLOCK_ID:
         if (Stream.ReadBlockInfoBlock())
           return Error("Malformed BlockInfoBlock");
         break;
       case naclbitc::PARAMATTR_BLOCK_ID:
         if (ParseAttributeBlock())
           return true;
@@ skipping 24 matching lines @@
         // FunctionsWithBodies list.
         if (!SeenFirstFunctionBody) {
           std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
           if (GlobalCleanup())
             return true;
           SeenFirstFunctionBody = true;
         }
 
         if (RememberAndSkipFunctionBody())
           return true;
+
         // For streaming bitcode, suspend parsing when we reach the function
         // bodies. Subsequent materialization calls will resume it when
         // necessary. For streaming, the function bodies must be at the end of
         // the bitcode. If the bitcode file is old, the symbol table will be
         // at the end instead and will not have been seen yet. In this case,
         // just finish the parse now.
         if (LazyStreamer && SeenValueSymbolTable) {
           NextUnreadBit = Stream.GetCurrentBitNo();
+          DEBUG(dbgs() << "<- ParseModule\n");
           return false;
         }
         break;
       case naclbitc::USELIST_BLOCK_ID:
         if (ParseUseLists())
           return true;
         break;
       }
       continue;
 
@@ skipping 267 matching lines @@
           Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a &&
           Stream.AtEndOfStream())
         return false;
 
       return Error("Invalid record at top-level");
     }
   }
 }
 
 bool NaClBitcodeReader::ParseModuleTriple(std::string &Triple) {
+  DEBUG(dbgs() << "-> ParseModuleTriple\n");
   if (Stream.EnterSubBlock(naclbitc::MODULE_BLOCK_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
 
   // Read all the records for this module.
   while (1) {
     NaClBitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::SubBlock: // Handled for us already.
     case NaClBitstreamEntry::Error:
       return Error("malformed module block");
     case NaClBitstreamEntry::EndBlock:
+      DEBUG(dbgs() << "<- ParseModuleTriple\n");
       return false;
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read a record.
     switch (Stream.readRecord(Entry.ID, Record)) {
     default: break;  // Default behavior, ignore unknown content.
     case naclbitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strchr x N]
@@ skipping 45 matching lines @@
 
     case NaClBitstreamEntry::Record:
       Stream.skipRecord(Entry.ID);
       continue;
     }
   }
 }
 
 /// ParseMetadataAttachment - Parse metadata attachments.
 bool NaClBitcodeReader::ParseMetadataAttachment() {
+  DEBUG(dbgs() << "-> ParseMetadataAttachment\n");
   if (Stream.EnterSubBlock(naclbitc::METADATA_ATTACHMENT_ID))
     return Error("Malformed block record");
 
   SmallVector<uint64_t, 64> Record;
   while (1) {
     NaClBitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::SubBlock: // Handled for us already.
     case NaClBitstreamEntry::Error:
       return Error("malformed metadata block");
     case NaClBitstreamEntry::EndBlock:
+      DEBUG(dbgs() << "<- ParseMetadataAttachment\n");
       return false;
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read a metadata attachment record.
     Record.clear();
     switch (Stream.readRecord(Entry.ID, Record)) {
     default:  // Default behavior: ignore.
@@ skipping 13 matching lines @@
         Inst->setMetadata(I->second, cast<MDNode>(Node));
       }
       break;
     }
     }
   }
 }
 
 /// ParseFunctionBody - Lazily parse the specified function body block.
 bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
+  DEBUG(dbgs() << "-> ParseFunctionBody\n");
   if (Stream.EnterSubBlock(naclbitc::FUNCTION_BLOCK_ID))
     return Error("Malformed block record");
 
   InstructionList.clear();
   unsigned ModuleValueListSize = ValueList.size();
   unsigned ModuleMDValueListSize = MDValueList.size();
 
   // Add all the function arguments to the value table.
   for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
     ValueList.push_back(I);
@@ skipping 11 matching lines @@
 
     switch (Entry.Kind) {
     case NaClBitstreamEntry::Error:
       return Error("Bitcode error in function block");
     case NaClBitstreamEntry::EndBlock:
       goto OutOfRecordLoop;
 
     case NaClBitstreamEntry::SubBlock:
       switch (Entry.ID) {
       default:  // Skip unknown content.
+        dbgs() << "default skip block\n";
         if (Stream.SkipBlock())
           return Error("Malformed block record");
         break;
       case naclbitc::CONSTANTS_BLOCK_ID:
-        if (ParseConstants()) return true;
+        if (ParseConstants())
+          return true;
         NextValueNo = ValueList.size();
         break;
       case naclbitc::VALUE_SYMTAB_BLOCK_ID:
-        if (ParseValueSymbolTable()) return true;
+        if (ParseValueSymbolTable())
+          return true;
         break;
       case naclbitc::METADATA_ATTACHMENT_ID:
-        if (ParseMetadataAttachment()) return true;
+        if (ParseMetadataAttachment())
+          return true;
         break;
       case naclbitc::METADATA_BLOCK_ID:
-        if (ParseMetadata()) return true;
+        if (ParseMetadata())
+          return true;
         break;
       }
       continue;
 
     case NaClBitstreamEntry::Record:
       // The interesting case.
       break;
     }
 
     // Read a record.
@@ skipping 811 matching lines @@
       FwdRef->eraseFromParent();
     }
 
     BlockAddrFwdRefs.erase(BAFRI);
   }
 
   // Trim the value list down to the size it was before we parsed this function.
   ValueList.shrinkTo(ModuleValueListSize);
   MDValueList.shrinkTo(ModuleMDValueListSize);
   std::vector<BasicBlock*>().swap(FunctionBBs);
+  DEBUG(dbgs() << "-> ParseFunctionBody\n");
   return false;
 }
 
 /// FindFunctionInStream - Find the function body in the bitcode stream
 bool NaClBitcodeReader::FindFunctionInStream(Function *F,
        DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator) {
   while (DeferredFunctionInfoIterator->second == 0) {
     if (Stream.AtEndOfStream())
       return Error("Could not find Function in stream");
     // ParseModule will parse the next body in the stream and set its
@@ skipping 240 matching lines @@
   if (M->MaterializeAllPermanently(ErrMsg)) {
     delete M;
     return 0;
   }
 
   // TODO: Restore the use-lists to the in-memory state when the bitcode was
   // written.  We must defer until the Module has been fully materialized.
 
   return M;
 }