Make pnacl-bccompress add abbreviations for obvious constants.

include/llvm/Bitcode/NaCl/NaClBitCodes.h

 //===- NaClBitCodes.h - Enum values for the bitcode format ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This header Bitcode enum values.
 //
 // The enum values defined in this file should be considered permanent.  If
 // new features are added, they should have values added at the end of the
 // respective lists.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BITCODE_NACL_NACLBITCODES_H
 #define LLVM_BITCODE_NACL_NACLBITCODES_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
 
 namespace llvm {
+class raw_ostream;
+
 namespace naclbitc {
   enum StandardWidths {
     BlockIDWidth   = 8,  // We use VBR-8 for block IDs.
     CodeLenWidth   = 4,  // Codelen are VBR-4.
     BlockSizeWidth = 32  // BlockSize up to 2^32 32-bit words = 16GB per block.
   };
 
   // The standard abbrev namespace always has a way to exit a block, enter a
   // nested block, define abbrevs, and define an unabbreviated record.
   enum FixedAbbrevIDs {
@@ skipping 102 matching lines @@
       return true;
     case Array:
     case Char6:
       return false;
     default:
       break;
     }
     report_fatal_error("Invalid encoding");
   }
 
+  bool isArrayOp() const {
+    return isEncoding() && Enc == Array;
+  }
+
+  /// Returns the number of arguments expected by this abbrevation operator.
+  unsigned NumArguments() const {
+    if (isArrayOp())
+      return 1;
+    else
+      return 0;
+  }
+
+  /// Prints out the abbreviation operator to the given stream.
+  void Print(raw_ostream &Stream) const;
+
   /// isChar6 - Return true if this character is legal in the Char6 encoding.
   static bool isChar6(char C) {
     if (C >= 'a' && C <= 'z') return true;
     if (C >= 'A' && C <= 'Z') return true;
     if (C >= '0' && C <= '9') return true;
     if (C == '.' || C == '_') return true;
     return false;
   }
   static unsigned EncodeChar6(char C) {
     if (C >= 'a' && C <= 'z') return C-'a';
@@ skipping 96 matching lines @@
     return static_cast<unsigned>(OperandList.size());
   }
   const NaClBitCodeAbbrevOp &getOperandInfo(unsigned N) const {
     return OperandList[N];
   }
 
   void Add(const NaClBitCodeAbbrevOp &OpInfo) {
     OperandList.push_back(OpInfo);
   }
 
+  // Returns a simplified version of the abbreviation. Used
+  // to recognize equivalent abbrevations.
+  NaClBitCodeAbbrev *Simplify() const;
+
   int Compare(const NaClBitCodeAbbrev &Abbrev) const {
     // First order based on number of operands.
     size_t OperandListSize = OperandList.size();
     size_t AbbrevOperandListSize = Abbrev.OperandList.size();
     if (OperandListSize < AbbrevOperandListSize)
       return -1;
     else if (OperandListSize > AbbrevOperandListSize)
       return 1;
 
     // Same number of operands, so compare element by element.
     for (size_t I = 0; I < OperandListSize; ++I) {
       if (int Diff = OperandList[I].Compare(Abbrev.OperandList[I]))
         return Diff;
     }
     return 0;
   }
 
+  void Print(raw_ostream &Stream) const;
+
   NaClBitCodeAbbrev *Copy() const {
     NaClBitCodeAbbrev *AbbrevCopy = new NaClBitCodeAbbrev();
     for (unsigned I = 0, IEnd = getNumOperandInfos();
          I != IEnd; ++I) {
       AbbrevCopy->Add(NaClBitCodeAbbrevOp(getOperandInfo(I)));
     }
     return AbbrevCopy;
   }
 };
 
@@ skipping 73 matching lines @@
 
   // Creates a selector range to handle fixed abbrevations up to
   // the specified value.
   explicit NaClBitcodeSelectorAbbrev(unsigned MaxAbbrev)
       : IsFixed(true),
         NumBits(NaClBitsNeededForValue(MaxAbbrev)) {}
 };
 } // End llvm namespace
 
 #endif