implement the 'string constant' optimization. This shrinks kc.bit from

2878544 to 2815788

llvm-svn: 36818

include/llvm/Bitcode/LLVMBitCodes.h

@@ -106,14 +106,15 @@ namespace bitc {
     CST_CODE_WIDE_INTEGER  =  5,  // WIDE_INTEGER:  [n x intval]
     CST_CODE_FLOAT         =  6,  // FLOAT:         [fpval]
     CST_CODE_AGGREGATE     =  7,  // AGGREGATE:     [n x value number]
-    CST_CODE_CE_BINOP      =  8,  // CE_BINOP:      [opcode, opval, opval]
+    CST_CODE_STRING        =  8,  // STRING:        [values]
-    CST_CODE_CE_CAST       =  9,  // CE_CAST:       [opcode, opty, opval]
+    CST_CODE_CE_BINOP      =  9,  // CE_BINOP:      [opcode, opval, opval]
-    CST_CODE_CE_GEP        = 10,  // CE_GEP:        [n x operands]
+    CST_CODE_CE_CAST       = 10,  // CE_CAST:       [opcode, opty, opval]
-    CST_CODE_CE_SELECT     = 11,  // CE_SELECT:     [opval, opval, opval]
+    CST_CODE_CE_GEP        = 11,  // CE_GEP:        [n x operands]
-    CST_CODE_CE_EXTRACTELT = 12,  // CE_EXTRACTELT: [opty, opval, opval]
+    CST_CODE_CE_SELECT     = 12,  // CE_SELECT:     [opval, opval, opval]
-    CST_CODE_CE_INSERTELT  = 13,  // CE_INSERTELT:  [opval, opval, opval]
+    CST_CODE_CE_EXTRACTELT = 13,  // CE_EXTRACTELT: [opty, opval, opval]
-    CST_CODE_CE_SHUFFLEVEC = 14,  // CE_SHUFFLEVEC: [opval, opval, opval]
+    CST_CODE_CE_INSERTELT  = 14,  // CE_INSERTELT:  [opval, opval, opval]
-    CST_CODE_CE_CMP        = 15   // CE_CMP:        [opty, opval, opval, pred]
+    CST_CODE_CE_SHUFFLEVEC = 15,  // CE_SHUFFLEVEC: [opval, opval, opval]
+    CST_CODE_CE_CMP        = 16   // CE_CMP:        [opty, opval, opval, pred]
   };
   
   /// CastOpcodes - These are values used in the bitcode files to encode which

lib/Bitcode/Reader/BitcodeReader.cpp

@@ -642,7 +642,21 @@ bool BitcodeReader::ParseConstants() {
       }
       break;
     }
+    case bitc::CST_CODE_STRING: { // STRING: [values]
+      if (Record.empty())
+        return Error("Invalid CST_AGGREGATE record");
 
+      const ArrayType *ATy = cast<ArrayType>(CurTy);
+      const Type *EltTy = ATy->getElementType();
+      
+      unsigned Size = Record.size();
+      std::vector<Constant*> Elts;
+      
+      for (unsigned i = 0; i != Size; ++i)
+        Elts.push_back(ConstantInt::get(EltTy, Record[i]));
+      V = ConstantArray::get(ATy, Elts);
+      break;
+    }
     case bitc::CST_CODE_CE_BINOP: {  // CE_BINOP: [opcode, opval, opval]
       if (Record.size() < 3) return Error("Invalid CE_BINOP record");
       int Opc = GetDecodedBinaryOpcode(Record[0], CurTy);

lib/Bitcode/Writer/BitcodeWriter.cpp

@@ -484,6 +484,12 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
         assert (CFP->getType() == Type::DoubleTy && "Unknown FP type!");
         Record.push_back(DoubleToBits((double)CFP->getValue()));
       }
+    } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
+      // Emit constant strings specially.
+      Code = bitc::CST_CODE_STRING;
+      for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
+        Record.push_back(cast<ConstantInt>(C->getOperand(i))->getZExtValue());
+      
     } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(V) ||
                isa<ConstantVector>(V)) {
       Code = bitc::CST_CODE_AGGREGATE;

lib/Bitcode/Writer/ValueEnumerator.cpp

@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "ValueEnumerator.h"
+#include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
 #include "llvm/TypeSymbolTable.h"
@@ -65,8 +66,6 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
        I != E; ++I)
     EnumerateValue(I->getAliasee());
   
-  // FIXME: Implement the 'string constant' optimization.
-
   // Enumerate types used by the type symbol table.
   EnumerateTypeSymbolTable(M->getTypeSymbolTable());
 
@@ -105,8 +104,6 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
   // Now that we rearranged the type table, rebuild TypeMap.
   for (unsigned i = 0, e = Types.size(); i != e; ++i)
     TypeMap[Types[i].first] = i+1;
-  
-  // FIXME: Sort value tables by frequency.
 }
 
 // Optimize constant ordering.
@@ -176,6 +173,10 @@ void ValueEnumerator::EnumerateValue(const Value *V) {
   if (const Constant *C = dyn_cast<Constant>(V)) {
     if (isa<GlobalValue>(C)) {
       // Initializers for globals are handled explicitly elsewhere.
+    } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
+      // Do not enumerate the initializers for an array of simple characters.
+      // The initializers just polute the value table, and we emit the strings
+      // specially.
     } else {
       // This makes sure that if a constant has uses (for example an array of
       // const ints), that they are inserted also.