Back out r54608 (inline string literals were getting an extra '\0')

  temporarily, I assumed GetAddrForConstantString literal was being
  used consistently but it doesn't look like it is.

Factored out a CodeGenModule::getStringForStringLiteral which handles
  extracting a std::string for the bytes of a StringLiteral, padded to
  match the type.

Update EmitLValue to use getStringForStringLiteral, this was
  previously not padding strings correctly. Good thing we only emit
  strings in 4 different places!

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@54621 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 091001e734e4967aa3a581e919b149702faad8ef..19ac711f79be1f560131ba876a02f20639b69fa0 100644 (file)
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -492,19 +492,10 @@ LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
 }
 
 LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
-  assert(!E->isWide() && "FIXME: Wide strings not supported yet!");
-  // Get the string data
-  const char *StrData = E->getStrData();
-  unsigned Len = E->getByteLength();
-  std::string StringLiteral(StrData, StrData+Len);
-
-  // Resize the string to the right size
-  const ConstantArrayType *CAT =
-    getContext().getAsConstantArrayType(E->getType());
-  uint64_t RealLen = CAT->getSize().getZExtValue();
-  StringLiteral.resize(RealLen, '\0');
-
-  return LValue::MakeAddr(CGM.GetAddrOfConstantString(StringLiteral),0);
+  llvm::Constant *C = 
+    CGM.GetAddrOfConstantString(CGM.getStringForStringLiteral(E));
+
+  return LValue::MakeAddr(C,0);
 }
 
 LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {

diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp
index 095153229e644090c3fb515bd0780730facc8a6d..db8003e43e03034b5f679c408b1b1b4f080d6580 100644 (file)
--- a/lib/CodeGen/CGExprConstant.cpp
+++ b/lib/CodeGen/CGExprConstant.cpp
@@ -354,28 +354,12 @@ public:
   }
 
   llvm::Constant *VisitStringLiteral(StringLiteral *E) {
-    const char *StrData = E->getStrData();
-    unsigned Len = E->getByteLength();
     assert(!E->getType()->isPointerType() && "Strings are always arrays");
     
     // Otherwise this must be a string initializing an array in a static
     // initializer.  Don't emit it as the address of the string, emit the string
     // data itself as an inline array.
-    const ConstantArrayType *CAT =
-      CGM.getContext().getAsConstantArrayType(E->getType());
-    assert(CAT && "String isn't pointer or array!");
-    
-    std::string Str(StrData, StrData + Len);
-    // Null terminate the string before potentially truncating it.
-    // FIXME: What about wchar_t strings?
-    Str.push_back(0);
-    
-    uint64_t RealLen = CAT->getSize().getZExtValue();
-    // String or grow the initializer to the required size.
-    if (RealLen != Str.size())
-      Str.resize(RealLen);
-    
-    return llvm::ConstantArray::get(Str, false);
+    return llvm::ConstantArray::get(CGM.getStringForStringLiteral(E), false);
   }
 
   llvm::Constant *VisitDeclRefExpr(DeclRefExpr *E) {
@@ -775,12 +759,8 @@ public:
       return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1);
     }
     case Expr::StringLiteralClass: {
-      StringLiteral *String = cast<StringLiteral>(E);
-      assert(!String->isWide() && "Cannot codegen wide strings yet");
-      const char *StrData = String->getStrData();
-      unsigned Len = String->getByteLength();
-
-      return CGM.GetAddrOfConstantString(std::string(StrData, StrData + Len));
+      StringLiteral *S = cast<StringLiteral>(E);
+      return CGM.GetAddrOfConstantString(CGM.getStringForStringLiteral(S));
     }
     case Expr::UnaryOperatorClass: {
       UnaryOperator *Exp = cast<UnaryOperator>(E);

diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp
index 2d7e41c334c1f761d7ce96acce9d4f5bbbd9ed62..d17a6c88e41a1ba9c7f668ea479fd5c395a7b63c 100644 (file)
--- a/lib/CodeGen/CodeGenModule.cpp
+++ b/lib/CodeGen/CodeGenModule.cpp
@@ -902,12 +902,32 @@ GetAddrOfConstantCFString(const std::string &str) {
   return GV;
 }
 
+/// getStringForStringLiteral - Return the appropriate bytes for a
+/// string literal, properly padded to match the literal type.
+std::string CodeGenModule::getStringForStringLiteral(const StringLiteral *E) {
+  assert(!E->isWide() && "FIXME: Wide strings not supported yet!");
+  const char *StrData = E->getStrData();
+  unsigned Len = E->getByteLength();
+
+  const ConstantArrayType *CAT =
+    getContext().getAsConstantArrayType(E->getType());
+  assert(CAT && "String isn't pointer or array!");
+  
+  // Resize the string to the right size
+  // FIXME: What about wchar_t strings?
+  std::string Str(StrData, StrData+Len);
+  uint64_t RealLen = CAT->getSize().getZExtValue();
+  Str.resize(RealLen, '\0');
+  
+  return Str;
+}
+
 /// GenerateWritableString -- Creates storage for a string literal.
 static llvm::Constant *GenerateStringLiteral(const std::string &str, 
                                              bool constant,
                                              CodeGenModule &CGM) {
   // Create Constant for this string literal
-  llvm::Constant *C = llvm::ConstantArray::get(str, false);
+  llvm::Constant *C = llvm::ConstantArray::get(str);
   
   // Create a global variable for this string
   C = new llvm::GlobalVariable(C->getType(), constant, 

diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h
index d90ebb4b361be1a7939d6e989cac11145680290d..8e7bb405a1be37e331512906307c455a99c4e303 100644 (file)
--- a/lib/CodeGen/CodeGenModule.h
+++ b/lib/CodeGen/CodeGenModule.h
@@ -39,6 +39,7 @@ namespace clang {
   class Decl;
   class Expr;
   class Stmt;
+  class StringLiteral;
   class NamedDecl;
   class ValueDecl;
   class VarDecl;
@@ -134,6 +135,10 @@ public:
   llvm::Function *getBuiltinLibFunction(unsigned BuiltinID);
   llvm::Constant *GetAddrOfConstantCFString(const std::string& str);
 
+  /// getStringForStringLiteral - Return the appropriate bytes for a
+  /// string literal, properly padded to match the literal type.
+  std::string getStringForStringLiteral(const StringLiteral *E);
+
   /// GetAddrOfConstantString -- returns a pointer to the character
   /// array containing the literal.  The result is pointer to array type.
   llvm::Constant *GetAddrOfConstantString(const std::string& str);