[AST] Use correct APSInt width when evaluating string literals

[barannikov88]

Summary

The width of the APSInt values should be the width of an element.
getCharByteWidth returns the size of an element in _host_ bytes, which
makes the width N times greater, where N is the ratio between target's
CHAR_BIT and host's CHAR_BIT.
This is NFC for in-tree targets because all of them have CHAR_BIT == 8.

[cor3ntin]

I think this is fine, and it's a nice simplification.

However it doesn't seem to do much of anything in practice: if you look at StringLiteral::mapCharByteWidth, supporting different CHAR_BIT would be more involved. And that's just part of the front end.
I really don't how much effort would be involved for complete support, and... well, as you say, we have no way to test anything.

So my feeling is that we can land that because it simplifies the code, but further work into non 8-bits platforms probably require the input of more folks
and a RFC may be warranted.

Looking around non 8 bits CHAR_BIT seems to have been discussed before https://discourse.llvm.org/t/rfc-on-non-8-bit-bytes-and-the-target-for-it/53455
but i don't know if a conclusion was reached. Maybe worth poking that thread if you are interested?

WDYT @aaron.ballman ?

[aaron.ballman]

I think this is a good NFC change as it brings us one TINY step closer towards supporting platforms where CHAR_BIT != 8. But I agree with Corentin that a lot more work needs to happen to support that kind of target; restarting the discussion on the linked RFC would be a good idea if you plan to aim for full support.

[cor3ntin]

@barannikov88 Don't forget to land this!

clang/lib/AST/ExprConstant.cpp

static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
   if (auto PE = dyn_cast<PredefinedExpr>(Lit))
     Lit = PE->getFunctionName();
   const StringLiteral *S = cast<StringLiteral>(Lit);
   const ConstantArrayType *CAT =
       Info.Ctx.getAsConstantArrayType(S->getType());
   assert(CAT && "string literal isn't an array");
   QualType CharType = CAT->getElementType();
   assert(CharType->isIntegerType() && "unexpected character type");
-
-  APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
+  APSInt Value(Info.Ctx.getTypeSize(CharType),
                CharType->isUnsignedIntegerType());
   if (Index < S->getLength())
     Value = S->getCodeUnit(Index);
   return Value;
 }
 
 // Expand a string literal into an array of characters.
 //
 // FIXME: This is inefficient; we should probably introduce something similar
 // to the LLVM ConstantDataArray to make this cheaper.
 static void expandStringLiteral(EvalInfo &Info, const StringLiteral *S,
                                 APValue &Result,
                                 QualType AllocType = QualType()) {
   const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(
       AllocType.isNull() ? S->getType() : AllocType);
   assert(CAT && "string literal isn't an array");
   QualType CharType = CAT->getElementType();
   assert(CharType->isIntegerType() && "unexpected character type");
 
   unsigned Elts = CAT->getSize().getZExtValue();
   Result = APValue(APValue::UninitArray(),
                    std::min(S->getLength(), Elts), Elts);
-  APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
+  APSInt Value(Info.Ctx.getTypeSize(CharType),
                CharType->isUnsignedIntegerType());
   if (Result.hasArrayFiller())
     Result.getArrayFiller() = APValue(Value);
   for (unsigned I = 0, N = Result.getArrayInitializedElts(); I != N; ++I) {
     Value = S->getCodeUnit(I);
     Result.getArrayInitializedElt(I) = APValue(Value);
   }
 }