From ff7fc5dabef6931e7d23ee0613aa60e1d09dfbb0 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 6 May 2007 00:35:24 +0000 Subject: [PATCH] implement the 'string constant' optimization. This shrinks kc.bit from 2878544 to 2815788 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36818 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Bitcode/LLVMBitCodes.h | 17 +++++++++-------- lib/Bitcode/Reader/BitcodeReader.cpp | 14 ++++++++++++++ lib/Bitcode/Writer/BitcodeWriter.cpp | 6 ++++++ lib/Bitcode/Writer/ValueEnumerator.cpp | 9 +++++---- 4 files changed, 34 insertions(+), 12 deletions(-) diff --git a/include/llvm/Bitcode/LLVMBitCodes.h b/include/llvm/Bitcode/LLVMBitCodes.h index e00a71153d5..9850db4fcd2 100644 --- a/include/llvm/Bitcode/LLVMBitCodes.h +++ b/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_CE_CAST = 9, // CE_CAST: [opcode, opty, opval] - CST_CODE_CE_GEP = 10, // CE_GEP: [n x operands] - CST_CODE_CE_SELECT = 11, // CE_SELECT: [opval, opval, opval] - CST_CODE_CE_EXTRACTELT = 12, // CE_EXTRACTELT: [opty, opval, opval] - CST_CODE_CE_INSERTELT = 13, // CE_INSERTELT: [opval, opval, opval] - CST_CODE_CE_SHUFFLEVEC = 14, // CE_SHUFFLEVEC: [opval, opval, opval] - CST_CODE_CE_CMP = 15 // CE_CMP: [opty, opval, opval, pred] + CST_CODE_STRING = 8, // STRING: [values] + CST_CODE_CE_BINOP = 9, // CE_BINOP: [opcode, opval, opval] + CST_CODE_CE_CAST = 10, // CE_CAST: [opcode, opty, opval] + CST_CODE_CE_GEP = 11, // CE_GEP: [n x operands] + CST_CODE_CE_SELECT = 12, // CE_SELECT: [opval, opval, opval] + CST_CODE_CE_EXTRACTELT = 13, // CE_EXTRACTELT: [opty, opval, opval] + CST_CODE_CE_INSERTELT = 14, // CE_INSERTELT: [opval, opval, opval] + 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 diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 5a7c84da931..b1a001e1af4 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/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(CurTy); + const Type *EltTy = ATy->getElementType(); + + unsigned Size = Record.size(); + std::vector 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); diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index 7198bc0060f..a29f23ddfc1 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/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(C) && cast(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(C->getOperand(i))->getZExtValue()); + } else if (isa(C) || isa(V) || isa(V)) { Code = bitc::CST_CODE_AGGREGATE; diff --git a/lib/Bitcode/Writer/ValueEnumerator.cpp b/lib/Bitcode/Writer/ValueEnumerator.cpp index 6b753b23865..ae9e67c8266 100644 --- a/lib/Bitcode/Writer/ValueEnumerator.cpp +++ b/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(V)) { if (isa(C)) { // Initializers for globals are handled explicitly elsewhere. + } else if (isa(C) && cast(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. -- 2.34.1