[clang] [clang] Fix handling of asm string literals (PR #169803)
Abhina Sree via cfe-commits
cfe-commits at lists.llvm.org
Mon Nov 2 10:58:33 PST 2026
https://github.com/abhina-sree updated https://github.com/llvm/llvm-project/pull/169803
>From 428436d0c27c5108d4a9245c6a4f7ead1e676cd7 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Fri, 8 May 2026 12:17:22 -0400
Subject: [PATCH 01/15] add ParserConversionAction, do not translate
unevaluated strings
---
clang/include/clang/Parse/Parser.h | 1 +
clang/include/clang/Sema/Sema.h | 4 +++-
clang/lib/Parse/ParseDecl.cpp | 9 +++++++++
clang/lib/Parse/ParseExpr.cpp | 6 +++---
clang/lib/Parse/Parser.cpp | 4 ++++
clang/lib/Sema/SemaExpr.cpp | 8 ++++----
clang/test/CodeGen/systemz-charset-diag.cpp | 8 ++++++++
clang/test/CodeGen/systemz-charset.c | 5 +++++
8 files changed, 37 insertions(+), 8 deletions(-)
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index 5237d767affdd0..24b012b0503523 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -5762,6 +5762,7 @@ class Parser : public CodeCompletionHandler {
bool Finished;
};
ObjCImplParsingDataRAII *CurParsedObjCImpl;
+ ConversionAction ParserConversionAction;
/// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them
/// for later parsing.
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 0d207679d1f4d8..a15811c40f2237 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -54,6 +54,7 @@
#include "clang/Basic/StackExhaustionHandler.h"
#include "clang/Basic/TemplateKinds.h"
#include "clang/Basic/TokenKinds.h"
+#include "clang/Lex/TextEncoding.h"
#include "clang/Sema/AnalysisBasedWarnings.h"
#include "clang/Sema/Attr.h"
#include "clang/Sema/CleanupInfo.h"
@@ -7439,7 +7440,8 @@ class Sema final : public SemaBase {
/// from multiple tokens. However, the common case is that StringToks points
/// to one string.
ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks,
- Scope *UDLScope = nullptr);
+ Scope *UDLScope = nullptr,
+ ConversionAction Action = CA_ToLiteralEncoding);
ExprResult ActOnUnevaluatedStringLiteral(ArrayRef<Token> StringToks);
diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
index ada54c85695c34..e5fee9f956d211 100644
--- a/clang/lib/Parse/ParseDecl.cpp
+++ b/clang/lib/Parse/ParseDecl.cpp
@@ -586,6 +586,9 @@ unsigned Parser::ParseAttributeArgsCommon(
nullptr,
Sema::ExpressionEvaluationContextRecord::EK_AttrArgument);
+ SaveAndRestore<ConversionAction> SavedTranslationState(
+ ParserConversionAction, CA_NoConversion);
+
ExprResult ArgExpr = ParseAssignmentExpression();
if (ArgExpr.isInvalid()) {
SkipUntil(tok::r_paren, StopAtSemi);
@@ -666,6 +669,9 @@ void Parser::ParseGNUAttributeArgs(
ParsedAttr::Kind AttrKind =
ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
+ SaveAndRestore<ConversionAction> SavedTranslationState(ParserConversionAction,
+ CA_NoConversion);
+
if (AttrKind == ParsedAttr::AT_Availability) {
ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
ScopeLoc, Form);
@@ -745,6 +751,9 @@ unsigned Parser::ParseClangAttributeArgs(
ParsedAttr::Kind AttrKind =
ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
+ SaveAndRestore<ConversionAction> SavedTranslationState(ParserConversionAction,
+ CA_NoConversion);
+
switch (AttrKind) {
default:
return ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc,
diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp
index d42ffc2ccf0a65..68af97fad5c4ae 100644
--- a/clang/lib/Parse/ParseExpr.cpp
+++ b/clang/lib/Parse/ParseExpr.cpp
@@ -3044,9 +3044,9 @@ ExprResult Parser::ParseStringLiteralExpression(bool AllowUserDefinedLiteral,
}
// Pass the set of string tokens, ready for concatenation, to the actions.
- return Actions.ActOnStringLiteral(StringToks,
- AllowUserDefinedLiteral ? getCurScope()
- : nullptr);
+ return Actions.ActOnStringLiteral(
+ StringToks, AllowUserDefinedLiteral ? getCurScope() : nullptr,
+ ParserConversionAction);
}
ExprResult Parser::ParseGenericSelectionExpression() {
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index f0f4c7195381e5..c334cd62ee256e 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -82,6 +82,8 @@ Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies)
NumCachedScopes = 0;
CurParsedObjCImpl = nullptr;
+ ParserConversionAction = CA_ToLiteralEncoding;
+
// Add #pragma handlers. These are removed and destroyed in the
// destructor.
initializePragmaHandlers();
@@ -1564,6 +1566,8 @@ void Parser::ParseKNRParamDeclarations(Declarator &D) {
}
ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
+ SaveAndRestore<ConversionAction> SavedTranslationState(ParserConversionAction,
+ CA_NoConversion);
ExprResult AsmString;
if (isTokenStringLiteral()) {
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 00dd8acf1f68dd..cd1416a724e754 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -2264,8 +2264,8 @@ Sema::ExpandFunctionLocalPredefinedMacros(ArrayRef<Token> Toks) {
return ExpandedToks;
}
-ExprResult
-Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
+ExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope,
+ ConversionAction Action) {
assert(!StringToks.empty() && "Must have at least one string!");
// StringToks needs backing storage as it doesn't hold array elements itself
@@ -2273,8 +2273,8 @@ Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
if (getLangOpts().MicrosoftExt)
StringToks = ExpandedToks = ExpandFunctionLocalPredefinedMacros(StringToks);
- StringLiteralParser Literal(
- StringToks, PP, StringLiteralEvalMethod::Evaluated, CA_ToLiteralEncoding);
+ StringLiteralParser Literal(StringToks, PP,
+ StringLiteralEvalMethod::Evaluated, Action);
if (Literal.hadError)
return ExprError();
diff --git a/clang/test/CodeGen/systemz-charset-diag.cpp b/clang/test/CodeGen/systemz-charset-diag.cpp
index 4ed94810150a3a..ad08e1f3912149 100644
--- a/clang/test/CodeGen/systemz-charset-diag.cpp
+++ b/clang/test/CodeGen/systemz-charset-diag.cpp
@@ -1,3 +1,11 @@
// RUN: %clang_cc1 -triple s390x-none-zos -fexec-charset IBM-1047 %s -std=c++17 -emit-llvm -o - -verify
const char* Computer = "🖥️"; // expected-error-re {{conversion to literal encoding failed: {{.*}}}}
+
+static_assert(false, "Error string"); // expected-error {{static assertion failed: Error string}}
+
+[[deprecated("message")]] void test_deprecated() {return;} // expected-note {{'test_deprecated' has been explicitly marked deprecated here}}
+
+int main() {
+ test_deprecated(); // expected-warning {{'test_deprecated' is deprecated: message}}
+}
diff --git a/clang/test/CodeGen/systemz-charset.c b/clang/test/CodeGen/systemz-charset.c
index e1dc1ec2dc23a9..fd81110f5f6c70 100644
--- a/clang/test/CodeGen/systemz-charset.c
+++ b/clang/test/CodeGen/systemz-charset.c
@@ -66,3 +66,8 @@ const char* hello_macro = HELLO;
const char* preprocessor_concatenation = HELLO_WORLD;
//CHECK: c"\C8\85\93\93\96@\E6\96\99\93\84Z\00"
//CHECK-UTF8: c"Hello World!\00"
+
+void asm_labeled_fn(void) __asm__("asm_sym");
+void asm_labeled_fn(void) {}
+//CHECK: define{{.*}} void @asm_sym(
+//CHECK-UTF8: define{{.*}} void @asm_sym(
>From 275e5eb1aac06849962a6d43b73a5b7b0b86f4ff Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Fri, 3 Jul 2026 14:52:22 -0400
Subject: [PATCH 02/15] remove unnecessary changes
---
clang/lib/Parse/ParseDecl.cpp | 9 ---------
1 file changed, 9 deletions(-)
diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
index e5fee9f956d211..ada54c85695c34 100644
--- a/clang/lib/Parse/ParseDecl.cpp
+++ b/clang/lib/Parse/ParseDecl.cpp
@@ -586,9 +586,6 @@ unsigned Parser::ParseAttributeArgsCommon(
nullptr,
Sema::ExpressionEvaluationContextRecord::EK_AttrArgument);
- SaveAndRestore<ConversionAction> SavedTranslationState(
- ParserConversionAction, CA_NoConversion);
-
ExprResult ArgExpr = ParseAssignmentExpression();
if (ArgExpr.isInvalid()) {
SkipUntil(tok::r_paren, StopAtSemi);
@@ -669,9 +666,6 @@ void Parser::ParseGNUAttributeArgs(
ParsedAttr::Kind AttrKind =
ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
- SaveAndRestore<ConversionAction> SavedTranslationState(ParserConversionAction,
- CA_NoConversion);
-
if (AttrKind == ParsedAttr::AT_Availability) {
ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
ScopeLoc, Form);
@@ -751,9 +745,6 @@ unsigned Parser::ParseClangAttributeArgs(
ParsedAttr::Kind AttrKind =
ParsedAttr::getParsedKind(AttrName, ScopeName, Form.getSyntax());
- SaveAndRestore<ConversionAction> SavedTranslationState(ParserConversionAction,
- CA_NoConversion);
-
switch (AttrKind) {
default:
return ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc,
>From e2bc4da52621b79a237622f95f26aa319715a389 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Thu, 9 Jul 2026 13:25:39 -0400
Subject: [PATCH 03/15] remove ParserConversionAction, add paramter to
ParseStringLiteralExpression instead, add conversion to SystemCharset then
back to UTF8 to handle escape sequences in system encoding
---
clang/include/clang/Basic/TargetInfo.h | 3 ++
clang/include/clang/Lex/TextEncoding.h | 11 ++++++--
clang/include/clang/Parse/Parser.h | 6 ++--
clang/lib/Basic/TargetInfo.cpp | 2 ++
clang/lib/Frontend/CompilerInstance.cpp | 4 +--
clang/lib/Lex/TextEncoding.cpp | 37 +++++++++++++++++++++----
clang/lib/Parse/ParseExpr.cpp | 6 ++--
clang/lib/Parse/Parser.cpp | 8 ++----
clang/lib/Sema/SemaStmtAsm.cpp | 8 ++++++
clang/test/CodeGen/systemz-charset.c | 6 ++--
10 files changed, 67 insertions(+), 24 deletions(-)
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index a6523e8eaaa437..f073d98408b211 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -37,6 +37,7 @@
#include "llvm/Frontend/OpenMP/OMPGridValues.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Error.h"
+#include "llvm/Support/TextEncoding.h"
#include "llvm/Support/VersionTuple.h"
#include "llvm/TargetParser/Triple.h"
#include <cassert>
@@ -330,6 +331,8 @@ class TargetInfo : public TransferrableTargetInfo,
virtual ~TargetInfo();
+ std::unique_ptr<llvm::TextEncodingConverter> TargetStrConverter;
+
/// Retrieve the target options.
TargetOptions &getTargetOpts() const {
assert(TargetOpts && "Missing target options");
diff --git a/clang/include/clang/Lex/TextEncoding.h b/clang/include/clang/Lex/TextEncoding.h
index 55663cdc072daa..02cb16cef9f1ba 100644
--- a/clang/include/clang/Lex/TextEncoding.h
+++ b/clang/include/clang/Lex/TextEncoding.h
@@ -10,6 +10,7 @@
#define LLVM_CLANG_LEX_TEXTENCODING_H
#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/TargetInfo.h"
#include "llvm/ADT/StringRef.h"
namespace llvm {
@@ -17,16 +18,22 @@ class TextEncodingConverter;
} // namespace llvm
namespace clang {
-enum ConversionAction { CA_NoConversion, CA_ToLiteralEncoding };
+enum ConversionAction {
+ CA_NoConversion,
+ CA_ToSystemEncoding,
+ CA_ToLiteralEncoding
+};
class TextEncoding {
llvm::StringRef LiteralEncoding;
std::unique_ptr<llvm::TextEncodingConverter> ToLiteralEncodingConverter;
+ std::unique_ptr<llvm::TextEncodingConverter> ToSystemEncodingConverter;
public:
llvm::TextEncodingConverter *getConverter(ConversionAction Action) const;
static std::error_code
- setConvertersFromOptions(TextEncoding &TE, const clang::LangOptions &Opts);
+ setConvertersFromOptions(TextEncoding &TE, const clang::LangOptions &Opts,
+ clang::TargetInfo &TInfo);
llvm::StringRef getLiteralEncoding() { return LiteralEncoding; }
};
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index 24b012b0503523..5268a7eeb911ea 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -3893,8 +3893,9 @@ class Parser : public CodeCompletionHandler {
/// associated with the class's definition.
void PopParsingClass(Sema::ParsingClassState);
- ExprResult ParseStringLiteralExpression(bool AllowUserDefinedLiteral,
- bool Unevaluated);
+ ExprResult
+ ParseStringLiteralExpression(bool AllowUserDefinedLiteral, bool Unevaluated,
+ ConversionAction CA = CA_ToLiteralEncoding);
/// This routine is called when the '@' is seen and consumed.
/// Current token is an Identifier and is not a 'try'. This
@@ -5762,7 +5763,6 @@ class Parser : public CodeCompletionHandler {
bool Finished;
};
ObjCImplParsingDataRAII *CurParsedObjCImpl;
- ConversionAction ParserConversionAction;
/// StashAwayMethodOrFunctionBodyTokens - Consume the tokens and store them
/// for later parsing.
diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
index 6e390226d2e4b8..488c3c5c28a74f 100644
--- a/clang/lib/Basic/TargetInfo.cpp
+++ b/clang/lib/Basic/TargetInfo.cpp
@@ -201,6 +201,8 @@ TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
MaxOpenCLWorkGroupSize = 1024;
MaxBitIntWidth.reset();
+
+ TargetStrConverter = nullptr;
}
// Out of line virtual dtor for TargetInfo.
diff --git a/clang/lib/Frontend/CompilerInstance.cpp b/clang/lib/Frontend/CompilerInstance.cpp
index f122208d6b4c8b..8c255c317f0a1e 100644
--- a/clang/lib/Frontend/CompilerInstance.cpp
+++ b/clang/lib/Frontend/CompilerInstance.cpp
@@ -568,8 +568,8 @@ void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
if (GetDependencyDirectives)
PP->setDependencyDirectivesGetter(*GetDependencyDirectives);
- if (auto EC = TextEncoding::setConvertersFromOptions(PP->getTextEncoding(),
- getLangOpts()))
+ if (auto EC = TextEncoding::setConvertersFromOptions(
+ PP->getTextEncoding(), getLangOpts(), getTarget()))
PP->getDiagnostics().Report(clang::diag::err_fe_text_encoding_config)
<< PP->getTextEncoding().getLiteralEncoding();
}
diff --git a/clang/lib/Lex/TextEncoding.cpp b/clang/lib/Lex/TextEncoding.cpp
index eb4fde8928a688..effd05185faf7f 100644
--- a/clang/lib/Lex/TextEncoding.cpp
+++ b/clang/lib/Lex/TextEncoding.cpp
@@ -17,6 +17,8 @@ TextEncoding::getConverter(ConversionAction Action) const {
switch (Action) {
case CA_ToLiteralEncoding:
return ToLiteralEncodingConverter.get();
+ case CA_ToSystemEncoding:
+ return ToSystemEncodingConverter.get();
default:
return nullptr;
}
@@ -24,23 +26,46 @@ TextEncoding::getConverter(ConversionAction Action) const {
std::error_code
TextEncoding::setConvertersFromOptions(TextEncoding &TE,
- const clang::LangOptions &Opts) {
+ const clang::LangOptions &Opts,
+ clang::TargetInfo &TInfo) {
using namespace llvm;
const char *UTF8 = "UTF-8";
TE.LiteralEncoding =
Opts.LiteralEncoding.empty() ? UTF8 : Opts.LiteralEncoding.c_str();
- // Create converter between internal and literal encoding specified
- // in fexec-charset option.
- if (TE.LiteralEncoding == UTF8)
+ if (TE.LiteralEncoding != UTF8) {
+ ErrorOr<TextEncodingConverter> ErrorOrLiteralConverter =
+ llvm::TextEncodingConverter::create(UTF8, TE.LiteralEncoding);
+ if (ErrorOrLiteralConverter)
+ TE.ToLiteralEncodingConverter = std::make_unique<TextEncodingConverter>(
+ std::move(*ErrorOrLiteralConverter));
+ else
+ return ErrorOrLiteralConverter.getError();
+ }
+
+ if (TInfo.getDefaultOrdinaryLiteralEncoding() == UTF8)
return std::error_code();
+
+ // Create converter between internal and default ordinary encoding for the
+ // target
ErrorOr<TextEncodingConverter> ErrorOrConverter =
- llvm::TextEncodingConverter::create(UTF8, TE.LiteralEncoding);
+ llvm::TextEncodingConverter::create(
+ UTF8, TInfo.getDefaultOrdinaryLiteralEncoding());
+ if (ErrorOrConverter)
+ TE.ToSystemEncodingConverter =
+ std::make_unique<TextEncodingConverter>(std::move(*ErrorOrConverter));
+ else
+ return ErrorOrConverter.getError();
+
+ ErrorOrConverter = llvm::TextEncodingConverter::create(
+ TInfo.getDefaultOrdinaryLiteralEncoding(), UTF8);
+
if (ErrorOrConverter)
- TE.ToLiteralEncodingConverter =
+ TInfo.TargetStrConverter =
std::make_unique<TextEncodingConverter>(std::move(*ErrorOrConverter));
else
return ErrorOrConverter.getError();
+
return std::error_code();
}
diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp
index 68af97fad5c4ae..45c4988f671dfd 100644
--- a/clang/lib/Parse/ParseExpr.cpp
+++ b/clang/lib/Parse/ParseExpr.cpp
@@ -3024,7 +3024,8 @@ ExprResult Parser::ParseUnevaluatedStringLiteralExpression() {
}
ExprResult Parser::ParseStringLiteralExpression(bool AllowUserDefinedLiteral,
- bool Unevaluated) {
+ bool Unevaluated,
+ ConversionAction CA) {
assert(tokenIsLikeStringLiteral(Tok, getLangOpts()) &&
"Not a string-literal-like token!");
@@ -3045,8 +3046,7 @@ ExprResult Parser::ParseStringLiteralExpression(bool AllowUserDefinedLiteral,
// Pass the set of string tokens, ready for concatenation, to the actions.
return Actions.ActOnStringLiteral(
- StringToks, AllowUserDefinedLiteral ? getCurScope() : nullptr,
- ParserConversionAction);
+ StringToks, AllowUserDefinedLiteral ? getCurScope() : nullptr, CA);
}
ExprResult Parser::ParseGenericSelectionExpression() {
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index c334cd62ee256e..0eb02a45d89066 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -82,8 +82,6 @@ Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies)
NumCachedScopes = 0;
CurParsedObjCImpl = nullptr;
- ParserConversionAction = CA_ToLiteralEncoding;
-
// Add #pragma handlers. These are removed and destroyed in the
// destructor.
initializePragmaHandlers();
@@ -1566,12 +1564,12 @@ void Parser::ParseKNRParamDeclarations(Declarator &D) {
}
ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
- SaveAndRestore<ConversionAction> SavedTranslationState(ParserConversionAction,
- CA_NoConversion);
ExprResult AsmString;
if (isTokenStringLiteral()) {
- AsmString = ParseStringLiteralExpression();
+ AsmString = ParseStringLiteralExpression(/*AllowUserDefinedLiteral=*/false,
+ /*Unevaluated=*/false,
+ CA_ToSystemEncoding);
if (AsmString.isInvalid())
return AsmString;
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index bf460ebe75ef10..bf11f9f5151097 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -245,6 +245,14 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel) {
Diag(Expr->getBeginLoc(), diag::err_asm_operand_empty_string)
<< SL->getSourceRange();
}
+ if (Context.getTargetInfo().TargetStrConverter) {
+ SmallString<16> ConvertedAsm;
+ Context.getTargetInfo().TargetStrConverter->convert(SL->getString(),
+ ConvertedAsm);
+ return StringLiteral::Create(Context, ConvertedAsm,
+ StringLiteralKind::Ordinary,
+ /*Pascal*/ false, {}, SL->getBeginLoc());
+ }
return SL;
}
if (DiagnoseUnexpandedParameterPack(Expr))
diff --git a/clang/test/CodeGen/systemz-charset.c b/clang/test/CodeGen/systemz-charset.c
index fd81110f5f6c70..eaa2747d9ce5f0 100644
--- a/clang/test/CodeGen/systemz-charset.c
+++ b/clang/test/CodeGen/systemz-charset.c
@@ -67,7 +67,7 @@ const char* preprocessor_concatenation = HELLO_WORLD;
//CHECK: c"\C8\85\93\93\96@\E6\96\99\93\84Z\00"
//CHECK-UTF8: c"Hello World!\00"
-void asm_labeled_fn(void) __asm__("asm_sym");
+void asm_labeled_fn(void) __asm__("\174asm_sym");
void asm_labeled_fn(void) {}
-//CHECK: define{{.*}} void @asm_sym(
-//CHECK-UTF8: define{{.*}} void @asm_sym(
+//CHECK: define{{.*}}void @"@asm_sym"(
+//CHECK-UTF8: define{{.*}}void @"@asm_sym"(
>From d664432d978c226dabbc470ebae76d7614139992 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Fri, 10 Jul 2026 15:07:07 -0400
Subject: [PATCH 04/15] address comments, attempt to fix CI
---
clang/include/clang/Basic/TargetInfo.h | 2 +-
clang/lib/Basic/TargetInfo.cpp | 2 +-
clang/lib/Lex/TextEncoding.cpp | 2 +-
clang/lib/Sema/SemaStmtAsm.cpp | 10 ++++++----
clang/test/CodeGen/systemz-charset.c | 4 ++++
5 files changed, 13 insertions(+), 7 deletions(-)
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index f073d98408b211..3c906d870e576e 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -331,7 +331,7 @@ class TargetInfo : public TransferrableTargetInfo,
virtual ~TargetInfo();
- std::unique_ptr<llvm::TextEncodingConverter> TargetStrConverter;
+ std::unique_ptr<llvm::TextEncodingConverter> FromSystemEncodingConverter;
/// Retrieve the target options.
TargetOptions &getTargetOpts() const {
diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
index 488c3c5c28a74f..09365d4f01b892 100644
--- a/clang/lib/Basic/TargetInfo.cpp
+++ b/clang/lib/Basic/TargetInfo.cpp
@@ -202,7 +202,7 @@ TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
MaxBitIntWidth.reset();
- TargetStrConverter = nullptr;
+ FromSystemEncodingConverter = nullptr;
}
// Out of line virtual dtor for TargetInfo.
diff --git a/clang/lib/Lex/TextEncoding.cpp b/clang/lib/Lex/TextEncoding.cpp
index effd05185faf7f..fd59f3df59bdfb 100644
--- a/clang/lib/Lex/TextEncoding.cpp
+++ b/clang/lib/Lex/TextEncoding.cpp
@@ -62,7 +62,7 @@ TextEncoding::setConvertersFromOptions(TextEncoding &TE,
TInfo.getDefaultOrdinaryLiteralEncoding(), UTF8);
if (ErrorOrConverter)
- TInfo.TargetStrConverter =
+ TInfo.FromSystemEncodingConverter =
std::make_unique<TextEncodingConverter>(std::move(*ErrorOrConverter));
else
return ErrorOrConverter.getError();
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index bf11f9f5151097..1399191418fcd5 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -245,13 +245,15 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel) {
Diag(Expr->getBeginLoc(), diag::err_asm_operand_empty_string)
<< SL->getSourceRange();
}
- if (Context.getTargetInfo().TargetStrConverter) {
+ if (Context.getTargetInfo().FromSystemEncodingConverter) {
SmallString<16> ConvertedAsm;
- Context.getTargetInfo().TargetStrConverter->convert(SL->getString(),
- ConvertedAsm);
+ Context.getTargetInfo().FromSystemEncodingConverter->convert(
+ SL->getString(), ConvertedAsm);
+ QualType StrTy = Context.getStringLiteralArrayType(Context.CharTy,
+ ConvertedAsm.size());
return StringLiteral::Create(Context, ConvertedAsm,
StringLiteralKind::Ordinary,
- /*Pascal*/ false, {}, SL->getBeginLoc());
+ /*Pascal*/ false, StrTy, SL->getBeginLoc());
}
return SL;
}
diff --git a/clang/test/CodeGen/systemz-charset.c b/clang/test/CodeGen/systemz-charset.c
index eaa2747d9ce5f0..db5a99b5eb3b72 100644
--- a/clang/test/CodeGen/systemz-charset.c
+++ b/clang/test/CodeGen/systemz-charset.c
@@ -71,3 +71,7 @@ void asm_labeled_fn(void) __asm__("\174asm_sym");
void asm_labeled_fn(void) {}
//CHECK: define{{.*}}void @"@asm_sym"(
//CHECK-UTF8: define{{.*}}void @"@asm_sym"(
+
+void asm_stmt_fn(void) { __asm__("\225\226\227nop"); }
+//CHECK: call void asm{{.*}}"nopnop"
+//CHECK-UTF8: call void asm{{.*}}"nopnop"
>From f03fd41cb059a525e846cec2f7dc7938daf5ec2f Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Fri, 17 Jul 2026 14:31:50 -0400
Subject: [PATCH 05/15] check for UTF-8 to avoid conversion codepath if no
conversion is needed
---
clang/lib/Sema/SemaStmtAsm.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index 1399191418fcd5..3ec75dab8d84e4 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -245,7 +245,7 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel) {
Diag(Expr->getBeginLoc(), diag::err_asm_operand_empty_string)
<< SL->getSourceRange();
}
- if (Context.getTargetInfo().FromSystemEncodingConverter) {
+ if (Context.getTargetInfo().FromSystemEncodingConverter != nullptr) {
SmallString<16> ConvertedAsm;
Context.getTargetInfo().FromSystemEncodingConverter->convert(
SL->getString(), ConvertedAsm);
>From 96837dfd7036f28fdf40eee09b3920f4567f272c Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Tue, 11 Aug 2026 09:02:17 -0400
Subject: [PATCH 06/15] Remove unrelated testcases
---
clang/test/CodeGen/systemz-charset-diag.cpp | 8 --------
1 file changed, 8 deletions(-)
diff --git a/clang/test/CodeGen/systemz-charset-diag.cpp b/clang/test/CodeGen/systemz-charset-diag.cpp
index ad08e1f3912149..4ed94810150a3a 100644
--- a/clang/test/CodeGen/systemz-charset-diag.cpp
+++ b/clang/test/CodeGen/systemz-charset-diag.cpp
@@ -1,11 +1,3 @@
// RUN: %clang_cc1 -triple s390x-none-zos -fexec-charset IBM-1047 %s -std=c++17 -emit-llvm -o - -verify
const char* Computer = "🖥️"; // expected-error-re {{conversion to literal encoding failed: {{.*}}}}
-
-static_assert(false, "Error string"); // expected-error {{static assertion failed: Error string}}
-
-[[deprecated("message")]] void test_deprecated() {return;} // expected-note {{'test_deprecated' has been explicitly marked deprecated here}}
-
-int main() {
- test_deprecated(); // expected-warning {{'test_deprecated' is deprecated: message}}
-}
>From 84b75379950aa969912714ee27e653c2e5dc8c04 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Thu, 13 Aug 2026 14:18:12 -0400
Subject: [PATCH 07/15] constexpr in asm strings will be in fexec-charset, do
not do backwards conversion for those strings
---
clang/include/clang/Sema/Sema.h | 3 ++-
clang/lib/Parse/Parser.cpp | 5 ++++-
clang/lib/Sema/SemaStmtAsm.cpp | 6 ++++--
clang/test/CodeGen/systemz-charset.cpp | 24 ++++++++++++++++++++++++
4 files changed, 34 insertions(+), 4 deletions(-)
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index a15811c40f2237..778478f4723234 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -11489,7 +11489,8 @@ class Sema final : public SemaBase {
///@{
public:
- ExprResult ActOnGCCAsmStmtString(Expr *Stm, bool ForAsmLabel);
+ ExprResult ActOnGCCAsmStmtString(Expr *Stm, bool ForAsmLabel,
+ bool IsConstExpr = false);
StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
bool IsVolatile, unsigned NumOutputs,
unsigned NumInputs, IdentifierInfo **Names,
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 0eb02a45d89066..7fd9fe9dee0c76 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -1566,6 +1566,7 @@ void Parser::ParseKNRParamDeclarations(Declarator &D) {
ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
ExprResult AsmString;
+ bool IsConstExpr = false;
if (isTokenStringLiteral()) {
AsmString = ParseStringLiteralExpression(/*AllowUserDefinedLiteral=*/false,
/*Unevaluated=*/false,
@@ -1581,6 +1582,7 @@ ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
}
} else if (!ForAsmLabel && getLangOpts().CPlusPlus11 &&
Tok.is(tok::l_paren)) {
+ IsConstExpr = true;
ParenParseOption ExprType = ParenParseOption::SimpleExpr;
SourceLocation RParenLoc;
ParsedType CastTy;
@@ -1600,7 +1602,8 @@ ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
(getLangOpts().CPlusPlus11 && !ForAsmLabel) ? 0 : 1);
}
- return Actions.ActOnGCCAsmStmtString(AsmString.get(), ForAsmLabel);
+ return Actions.ActOnGCCAsmStmtString(AsmString.get(), ForAsmLabel,
+ IsConstExpr);
}
ExprResult Parser::ParseSimpleAsm(bool ForAsmLabel, SourceLocation *EndLoc) {
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index 3ec75dab8d84e4..5a376a21e84733 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -235,7 +235,8 @@ getClobberConflictLocation(MultiExprArg Exprs, Expr **Constraints,
return SourceLocation();
}
-ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel) {
+ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
+ bool IsConstExpr) {
if (!Expr)
return ExprError();
@@ -245,7 +246,8 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel) {
Diag(Expr->getBeginLoc(), diag::err_asm_operand_empty_string)
<< SL->getSourceRange();
}
- if (Context.getTargetInfo().FromSystemEncodingConverter != nullptr) {
+ if (!IsConstExpr &&
+ Context.getTargetInfo().FromSystemEncodingConverter != nullptr) {
SmallString<16> ConvertedAsm;
Context.getTargetInfo().FromSystemEncodingConverter->convert(
SL->getString(), ConvertedAsm);
diff --git a/clang/test/CodeGen/systemz-charset.cpp b/clang/test/CodeGen/systemz-charset.cpp
index 41674e9c11a640..6348fb72dac9a0 100644
--- a/clang/test/CodeGen/systemz-charset.cpp
+++ b/clang/test/CodeGen/systemz-charset.cpp
@@ -72,3 +72,27 @@ const char16_t *UnicodeUCNString16 = u"\u00E2\u00AC\U000000DF";
const char32_t *UnicodeUCNString32 = U"\u00E2\u00AC\U000000DF";
//CHECK: [4 x i32] [i32 226, i32 172, i32 223, i32 0]
//CHECK-UTF8: [4 x i32] [i32 226, i32 172, i32 223, i32 0]
+
+
+struct string_view {
+ int S;
+ const char* D;
+ constexpr string_view() : S(0), D(0){}
+ constexpr string_view(const char* Str) : S(__builtin_strlen(Str)), D(Str) {}
+ constexpr string_view(int Size, const char* Str) : S(Size), D(Str) {}
+ constexpr int size() const {
+ return S;
+ }
+ constexpr const char* data() const {
+ return D;
+ }
+};
+
+constexpr string_view getfoo() { return "\174foo"; }
+
+void function()
+{
+ asm((getfoo()));
+}
+// CHECK: asm{{.*}}|\86\96\96
+// CHECK-UTF8: asm{{.*}}|foo
>From 897d1978004be27dc60cb932fd2efa812a05717c Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Wed, 30 Sep 2026 11:52:59 -0400
Subject: [PATCH 08/15] rename FromSystemEncodingConverter and move out of
TargetInfo
---
clang/include/clang/Basic/TargetInfo.h | 3 ---
clang/include/clang/Lex/TextEncoding.h | 14 +++++++++++++-
clang/lib/Basic/TargetInfo.cpp | 2 --
clang/lib/Lex/TextEncoding.cpp | 19 +++++++++++++------
clang/lib/Sema/SemaStmtAsm.cpp | 8 +++++---
5 files changed, 31 insertions(+), 15 deletions(-)
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index 3c906d870e576e..a6523e8eaaa437 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -37,7 +37,6 @@
#include "llvm/Frontend/OpenMP/OMPGridValues.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Error.h"
-#include "llvm/Support/TextEncoding.h"
#include "llvm/Support/VersionTuple.h"
#include "llvm/TargetParser/Triple.h"
#include <cassert>
@@ -331,8 +330,6 @@ class TargetInfo : public TransferrableTargetInfo,
virtual ~TargetInfo();
- std::unique_ptr<llvm::TextEncodingConverter> FromSystemEncodingConverter;
-
/// Retrieve the target options.
TargetOptions &getTargetOpts() const {
assert(TargetOpts && "Missing target options");
diff --git a/clang/include/clang/Lex/TextEncoding.h b/clang/include/clang/Lex/TextEncoding.h
index 02cb16cef9f1ba..ec826ec6615922 100644
--- a/clang/include/clang/Lex/TextEncoding.h
+++ b/clang/include/clang/Lex/TextEncoding.h
@@ -27,10 +27,22 @@ enum ConversionAction {
class TextEncoding {
llvm::StringRef LiteralEncoding;
std::unique_ptr<llvm::TextEncodingConverter> ToLiteralEncodingConverter;
- std::unique_ptr<llvm::TextEncodingConverter> ToSystemEncodingConverter;
+
+ // Only non-null on z/OS, where the system default encoding is IBM-1047.
+ // This converts UTF-8 to IBM-1047 for asm string literals so that
+ // octal/hex escape sequences are interpreted as IBM-1047 code points,
+ // regardless of -fexec-charset.
+ std::unique_ptr<llvm::TextEncodingConverter> ToIBM1047Converter;
+ std::unique_ptr<llvm::TextEncodingConverter> FromIBM1047Converter;
public:
llvm::TextEncodingConverter *getConverter(ConversionAction Action) const;
+
+ /// Returns the converter from IBM-1047 to UTF-8, or nullptr if not on z/OS.
+ llvm::TextEncodingConverter *getFromIBM1047Converter() const {
+ return FromIBM1047Converter.get();
+ }
+
static std::error_code
setConvertersFromOptions(TextEncoding &TE, const clang::LangOptions &Opts,
clang::TargetInfo &TInfo);
diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
index 09365d4f01b892..6e390226d2e4b8 100644
--- a/clang/lib/Basic/TargetInfo.cpp
+++ b/clang/lib/Basic/TargetInfo.cpp
@@ -201,8 +201,6 @@ TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
MaxOpenCLWorkGroupSize = 1024;
MaxBitIntWidth.reset();
-
- FromSystemEncodingConverter = nullptr;
}
// Out of line virtual dtor for TargetInfo.
diff --git a/clang/lib/Lex/TextEncoding.cpp b/clang/lib/Lex/TextEncoding.cpp
index fd59f3df59bdfb..6ee6f8a0ef2666 100644
--- a/clang/lib/Lex/TextEncoding.cpp
+++ b/clang/lib/Lex/TextEncoding.cpp
@@ -18,7 +18,8 @@ TextEncoding::getConverter(ConversionAction Action) const {
case CA_ToLiteralEncoding:
return ToLiteralEncodingConverter.get();
case CA_ToSystemEncoding:
- return ToSystemEncodingConverter.get();
+ // return null for non-z/OS targets
+ return ToIBM1047Converter.get();
default:
return nullptr;
}
@@ -34,6 +35,8 @@ TextEncoding::setConvertersFromOptions(TextEncoding &TE,
TE.LiteralEncoding =
Opts.LiteralEncoding.empty() ? UTF8 : Opts.LiteralEncoding.c_str();
+ // Create converter between internal and literal encoding specified
+ // in fexec-charset option.
if (TE.LiteralEncoding != UTF8) {
ErrorOr<TextEncodingConverter> ErrorOrLiteralConverter =
llvm::TextEncodingConverter::create(UTF8, TE.LiteralEncoding);
@@ -47,22 +50,26 @@ TextEncoding::setConvertersFromOptions(TextEncoding &TE,
if (TInfo.getDefaultOrdinaryLiteralEncoding() == UTF8)
return std::error_code();
- // Create converter between internal and default ordinary encoding for the
- // target
+ // The IBM-1047 converters are only needed on z/OS, where the system
+ // (assembler/linker) default encoding is IBM-1047 rather than UTF-8.
+ assert((TInfo.getTriple().getOS() == llvm::Triple::ZOS) &&
+ "Non-UTF-8 system encoding is only expected on z/OS");
+
+ // Create a converter from UTF-8 to IBM-1047 for use when parsing asm string
+ // literals on z/OS, where escape sequences are IBM-1047 code points.
ErrorOr<TextEncodingConverter> ErrorOrConverter =
llvm::TextEncodingConverter::create(
UTF8, TInfo.getDefaultOrdinaryLiteralEncoding());
if (ErrorOrConverter)
- TE.ToSystemEncodingConverter =
+ TE.ToIBM1047Converter =
std::make_unique<TextEncodingConverter>(std::move(*ErrorOrConverter));
else
return ErrorOrConverter.getError();
ErrorOrConverter = llvm::TextEncodingConverter::create(
TInfo.getDefaultOrdinaryLiteralEncoding(), UTF8);
-
if (ErrorOrConverter)
- TInfo.FromSystemEncodingConverter =
+ TE.FromIBM1047Converter =
std::make_unique<TextEncodingConverter>(std::move(*ErrorOrConverter));
else
return ErrorOrConverter.getError();
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index 5a376a21e84733..1746604f61378c 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -15,6 +15,7 @@
#include "clang/AST/TypeLoc.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/TextEncoding.h"
#include "clang/Sema/Initialization.h"
#include "clang/Sema/Lookup.h"
#include "clang/Sema/Ownership.h"
@@ -24,6 +25,7 @@
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/MC/MCParser/MCAsmParser.h"
+#include "llvm/Support/TextEncoding.h"
#include <optional>
using namespace clang;
using namespace sema;
@@ -247,10 +249,10 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
<< SL->getSourceRange();
}
if (!IsConstExpr &&
- Context.getTargetInfo().FromSystemEncodingConverter != nullptr) {
+ PP.getTextEncoding().getFromIBM1047Converter() != nullptr) {
SmallString<16> ConvertedAsm;
- Context.getTargetInfo().FromSystemEncodingConverter->convert(
- SL->getString(), ConvertedAsm);
+ PP.getTextEncoding().getFromIBM1047Converter()->convert(SL->getString(),
+ ConvertedAsm);
QualType StrTy = Context.getStringLiteralArrayType(Context.CharTy,
ConvertedAsm.size());
return StringLiteral::Create(Context, ConvertedAsm,
>From 16870c5a2529f0b39667bbda6cfb8a34f58e02c9 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Mon, 5 Oct 2026 10:13:37 -0400
Subject: [PATCH 09/15] rename CA_ToSystemEncoding to
CA_ToLiteralEncodingForAsm
---
clang/include/clang/Lex/TextEncoding.h | 2 +-
clang/lib/Lex/TextEncoding.cpp | 2 +-
clang/lib/Parse/Parser.cpp | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/clang/include/clang/Lex/TextEncoding.h b/clang/include/clang/Lex/TextEncoding.h
index ec826ec6615922..46903a53610591 100644
--- a/clang/include/clang/Lex/TextEncoding.h
+++ b/clang/include/clang/Lex/TextEncoding.h
@@ -20,7 +20,7 @@ class TextEncodingConverter;
namespace clang {
enum ConversionAction {
CA_NoConversion,
- CA_ToSystemEncoding,
+ CA_ToLiteralEncodingForAsm, // IBM-1047 on z/OS, UTF-8 on other platforms
CA_ToLiteralEncoding
};
diff --git a/clang/lib/Lex/TextEncoding.cpp b/clang/lib/Lex/TextEncoding.cpp
index 6ee6f8a0ef2666..afb5130ece88e4 100644
--- a/clang/lib/Lex/TextEncoding.cpp
+++ b/clang/lib/Lex/TextEncoding.cpp
@@ -17,7 +17,7 @@ TextEncoding::getConverter(ConversionAction Action) const {
switch (Action) {
case CA_ToLiteralEncoding:
return ToLiteralEncodingConverter.get();
- case CA_ToSystemEncoding:
+ case CA_ToLiteralEncodingForAsm:
// return null for non-z/OS targets
return ToIBM1047Converter.get();
default:
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 7fd9fe9dee0c76..3f6776d72d5372 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -1570,7 +1570,7 @@ ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
if (isTokenStringLiteral()) {
AsmString = ParseStringLiteralExpression(/*AllowUserDefinedLiteral=*/false,
/*Unevaluated=*/false,
- CA_ToSystemEncoding);
+ CA_ToLiteralEncodingForAsm);
if (AsmString.isInvalid())
return AsmString;
>From c6201b8bddf321d6d603dff89ad6372c56eb49b6 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Wed, 7 Oct 2026 10:56:26 -0400
Subject: [PATCH 10/15] add more testcases, make diagnostic message generic
---
clang/include/clang/Basic/DiagnosticLexKinds.td | 2 +-
clang/test/CodeGen/systemz-charset-diag.cpp | 2 +-
clang/test/CodeGen/systemz-charset.cpp | 8 ++++++--
clang/test/Sema/systemz-charset-asm.cpp | 11 +++++++++++
4 files changed, 19 insertions(+), 4 deletions(-)
create mode 100644 clang/test/Sema/systemz-charset-asm.cpp
diff --git a/clang/include/clang/Basic/DiagnosticLexKinds.td b/clang/include/clang/Basic/DiagnosticLexKinds.td
index ee3fb0e74d2209..d6d94005e57df3 100644
--- a/clang/include/clang/Basic/DiagnosticLexKinds.td
+++ b/clang/include/clang/Basic/DiagnosticLexKinds.td
@@ -301,7 +301,7 @@ def ext_string_too_long : Extension<"string literal of length %0 exceeds "
def err_character_too_large : Error<
"character too large for enclosing character literal type">;
def err_exec_charset_conversion_failed
- : Error<"conversion to literal encoding failed: '%0'">;
+ : Error<"encoding conversion failed: '%0'">;
def warn_c99_compat_unicode_literal : Warning<
"unicode literals are incompatible with C99">,
InGroup<C99Compat>, DefaultIgnore;
diff --git a/clang/test/CodeGen/systemz-charset-diag.cpp b/clang/test/CodeGen/systemz-charset-diag.cpp
index 4ed94810150a3a..a59a5ef4f0604c 100644
--- a/clang/test/CodeGen/systemz-charset-diag.cpp
+++ b/clang/test/CodeGen/systemz-charset-diag.cpp
@@ -1,3 +1,3 @@
// RUN: %clang_cc1 -triple s390x-none-zos -fexec-charset IBM-1047 %s -std=c++17 -emit-llvm -o - -verify
-const char* Computer = "🖥️"; // expected-error-re {{conversion to literal encoding failed: {{.*}}}}
+const char* Computer = "🖥️"; // expected-error-re {{encoding conversion failed: {{.*}}}}
diff --git a/clang/test/CodeGen/systemz-charset.cpp b/clang/test/CodeGen/systemz-charset.cpp
index 6348fb72dac9a0..b6b79842468c15 100644
--- a/clang/test/CodeGen/systemz-charset.cpp
+++ b/clang/test/CodeGen/systemz-charset.cpp
@@ -92,7 +92,11 @@ constexpr string_view getfoo() { return "\174foo"; }
void function()
{
+ asm("\174foo");
+ // CHECK: asm{{.*}}@foo
+ // CHECK-UTF8: asm{{.*}}@foo
asm((getfoo()));
+ // CHECK: asm{{.*}}|\86\96\96
+ // CHECK-UTF8: asm{{.*}}|foo
}
-// CHECK: asm{{.*}}|\86\96\96
-// CHECK-UTF8: asm{{.*}}|foo
+
diff --git a/clang/test/Sema/systemz-charset-asm.cpp b/clang/test/Sema/systemz-charset-asm.cpp
new file mode 100644
index 00000000000000..b3c27cc53638e6
--- /dev/null
+++ b/clang/test/Sema/systemz-charset-asm.cpp
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -triple s390x-none-zos -fexec-charset IBM-1047 %s -std=c++23 -fsyntax-only -verify
+// RUN: %clang_cc1 -triple s390x-none-zos -fexec-charset UTF-8 %s -std=c++23 -fsyntax-only -verify
+
+long inline_asm_ucn_named_operand(long a, long b) {
+ // The \N{...} escape encodes to U+0130. IBM-1047 has no code point for
+ // U+0130, so the conversion reports an error.
+ asm("\tLGR %0, %[\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}]\n" // expected-error-re {{encoding conversion failed: {{.*}}}}
+ : "=r"(a)
+ : [\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}] "r"(b));
+ return a;
+}
>From 29f61ad886c78e05f4c4f11dff11603c60a3f0c0 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Fri, 9 Oct 2026 13:29:51 -0400
Subject: [PATCH 11/15] Add some documentation
---
clang/docs/LanguageExtensions.md | 47 ++++++++++++++++++++++++++++++++
1 file changed, 47 insertions(+)
diff --git a/clang/docs/LanguageExtensions.md b/clang/docs/LanguageExtensions.md
index 3db8d083c40756..4b0a39a37159ed 100644
--- a/clang/docs/LanguageExtensions.md
+++ b/clang/docs/LanguageExtensions.md
@@ -2263,6 +2263,45 @@ int foo() {
}
```
+### String literal encoding in ASM statements
+
+On targets where the platform's default ordinary literal encoding differs from
+UTF-8 (such as z/OS, where the system default encoding is IBM-1047):
+
+* **Direct ASM string literals**: Direct string literals used in `asm` statements
+ or `asm` labels (such as `asm("...")` or `__asm__("...")`) are parsed and
+ interpreted using the target system's default encoding (such as IBM-1047 on
+ z/OS) rather than the literal encoding specified by `-fexec-charset`. This
+ ensures that escape sequences (such as octal or hexadecimal byte escapes)
+ are interpreted as system/assembler code points.
+
+* **Constexpr string expressions in ASM statements**: When a parenthesized
+ constant expression is provided in place of an `asm` string, string literals
+ within that constant expression are encoded according to the execution
+ character set specified by `-fexec-charset` (the literal encoding), as
+ constant expression evaluation expects `char` sequences to operate in the
+ literal encoding. The system encoding conversion applied to direct `asm`
+ string literals is restricted to the direct string literal case and does not
+ extend to string literals within constant expressions.
+
+For example, on z/OS compiled with `-fexec-charset UTF-8`:
+
+```c++
+constexpr std::string_view takeStringAndReturnEmptyStringView(const char *str) {
+ return std::string_view();
+}
+
+int main(void) {
+ // Direct string literals in asm statements are interpreted in the system encoding (IBM-1047).
+ asm("nop");
+
+ // String literals within the constexpr expression are encoded in the execution charset (UTF-8).
+ // Characters not representable in IBM-1047 (such as "\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}")
+ // are valid here because constant evaluation evaluates the string literal in UTF-8.
+ asm((takeStringAndReturnEmptyStringView("\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}")));
+}
+```
+
## Objective-C Features
### Related result types
@@ -5650,6 +5689,14 @@ The builtins return 0 if the values are equal, or 1 if they are unequal.
Generates a 16-byte compare-and-swap using the CDSG instruction.
+#### ASM string literal encoding
+
+On z/OS, the system default encoding is IBM-1047. Direct string literals in
+`asm` statements and `asm` labels are interpreted using IBM-1047 regardless of
+`-fexec-charset`. When using parenthesized constant expressions in `asm`
+statements, string literals within the constant expression are instead encoded
+using the execution character set specified by `-fexec-charset`.
+
## Extensions for Static Analysis
Clang supports additional attributes that are useful for documenting program
>From 864d56b11b9c0e2be9e156077e321e51ec25c936 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Tue, 13 Oct 2026 15:26:03 -0400
Subject: [PATCH 12/15] address comments on document
---
clang/docs/LanguageExtensions.md | 41 ++++++++++++++++----------------
1 file changed, 21 insertions(+), 20 deletions(-)
diff --git a/clang/docs/LanguageExtensions.md b/clang/docs/LanguageExtensions.md
index 4b0a39a37159ed..3c4fd93bdc45dd 100644
--- a/clang/docs/LanguageExtensions.md
+++ b/clang/docs/LanguageExtensions.md
@@ -2268,23 +2268,21 @@ int foo() {
On targets where the platform's default ordinary literal encoding differs from
UTF-8 (such as z/OS, where the system default encoding is IBM-1047):
-* **Direct ASM string literals**: Direct string literals used in `asm` statements
- or `asm` labels (such as `asm("...")` or `__asm__("...")`) are parsed and
+* **ASM template strings**: Asm template strings used in `asm` statements or
+ `asm` labels (such as `asm("...")` or `__asm__("...")`) are parsed and
interpreted using the target system's default encoding (such as IBM-1047 on
- z/OS) rather than the literal encoding specified by `-fexec-charset`. This
- ensures that escape sequences (such as octal or hexadecimal byte escapes)
- are interpreted as system/assembler code points.
+ z/OS) rather than the literal encoding specified by `-fexec-charset=`. This
+ ensures that escape sequences (such as octal or hexadecimal byte escapes) are
+ interpreted as system/assembler code points.
* **Constexpr string expressions in ASM statements**: When a parenthesized
constant expression is provided in place of an `asm` string, string literals
within that constant expression are encoded according to the execution
- character set specified by `-fexec-charset` (the literal encoding), as
+ character set specified by `-fexec-charset=` (the literal encoding), as
constant expression evaluation expects `char` sequences to operate in the
- literal encoding. The system encoding conversion applied to direct `asm`
- string literals is restricted to the direct string literal case and does not
- extend to string literals within constant expressions.
+ literal encoding.
-For example, on z/OS compiled with `-fexec-charset UTF-8`:
+For example, on z/OS compiled with `-fexec-charset=UTF-8`:
```c++
constexpr std::string_view takeStringAndReturnEmptyStringView(const char *str) {
@@ -2292,12 +2290,15 @@ constexpr std::string_view takeStringAndReturnEmptyStringView(const char *str) {
}
int main(void) {
- // Direct string literals in asm statements are interpreted in the system encoding (IBM-1047).
- asm("nop");
-
- // String literals within the constexpr expression are encoded in the execution charset (UTF-8).
- // Characters not representable in IBM-1047 (such as "\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}")
- // are valid here because constant evaluation evaluates the string literal in UTF-8.
+ // Template strings in asm statements are interpreted in the system encoding
+ // (IBM-1047).
+ asm("\t\x95\x96\x97");
+
+ // String literals within the constexpr expression are encoded in the
+ // execution character set specified by -fexec-charset=.
+ // With -fexec-charset=IBM-1047, the string below is diagnosed as invalid
+ // because U+0130 cannot be represented in IBM-1047.
+ // With -fexec-charset=UTF-8, the string below is valid.
asm((takeStringAndReturnEmptyStringView("\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}")));
}
```
@@ -5691,11 +5692,11 @@ The builtins return 0 if the values are equal, or 1 if they are unequal.
#### ASM string literal encoding
-On z/OS, the system default encoding is IBM-1047. Direct string literals in
-`asm` statements and `asm` labels are interpreted using IBM-1047 regardless of
-`-fexec-charset`. When using parenthesized constant expressions in `asm`
+On z/OS, the system default encoding is IBM-1047. Template strings in `asm`
+statements and `asm` labels are interpreted using IBM-1047 regardless of
+`-fexec-charset=`. When using parenthesized constant expressions in `asm`
statements, string literals within the constant expression are instead encoded
-using the execution character set specified by `-fexec-charset`.
+using the execution character set specified by `-fexec-charset=`.
## Extensions for Static Analysis
>From 44385fbf7c329442d62eaca043680d3d3edac152 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Wed, 14 Oct 2026 09:04:23 -0400
Subject: [PATCH 13/15] address comments in LanguageExtensions.md
---
clang/docs/LanguageExtensions.md | 29 ++++++++++++++++-------------
1 file changed, 16 insertions(+), 13 deletions(-)
diff --git a/clang/docs/LanguageExtensions.md b/clang/docs/LanguageExtensions.md
index 3c4fd93bdc45dd..9e19cc8c34d3e4 100644
--- a/clang/docs/LanguageExtensions.md
+++ b/clang/docs/LanguageExtensions.md
@@ -2268,12 +2268,15 @@ int foo() {
On targets where the platform's default ordinary literal encoding differs from
UTF-8 (such as z/OS, where the system default encoding is IBM-1047):
-* **ASM template strings**: Asm template strings used in `asm` statements or
- `asm` labels (such as `asm("...")` or `__asm__("...")`) are parsed and
- interpreted using the target system's default encoding (such as IBM-1047 on
- z/OS) rather than the literal encoding specified by `-fexec-charset=`. This
- ensures that escape sequences (such as octal or hexadecimal byte escapes) are
- interpreted as system/assembler code points.
+* **String literals**: A string literal used as the template string in an
+ extended asm statement, as the instruction string in a basic asm statement,
+ or as the string specifying the assembler name or register in an asm label or
+ a global/local register variable declaration (such as `asm("...")` or
+ `__asm__("...")`) is parsed and interpreted using the target system's default
+ encoding (such as IBM-1047 on z/OS) rather than the literal encoding
+ specified by `-fexec-charset=`. This ensures that escape sequences (such as
+ octal or hexadecimal byte escapes) are interpreted as system/assembler code
+ points.
* **Constexpr string expressions in ASM statements**: When a parenthesized
constant expression is provided in place of an `asm` string, string literals
@@ -2291,8 +2294,8 @@ constexpr std::string_view takeStringAndReturnEmptyStringView(const char *str) {
int main(void) {
// Template strings in asm statements are interpreted in the system encoding
- // (IBM-1047).
- asm("\t\x95\x96\x97");
+ // (IBM-1047 on z/OS).
+ asm("\t\x95\x96\x97"); // This generates a "nop" in IBM-1047
// String literals within the constexpr expression are encoded in the
// execution character set specified by -fexec-charset=.
@@ -5692,11 +5695,11 @@ The builtins return 0 if the values are equal, or 1 if they are unequal.
#### ASM string literal encoding
-On z/OS, the system default encoding is IBM-1047. Template strings in `asm`
-statements and `asm` labels are interpreted using IBM-1047 regardless of
-`-fexec-charset=`. When using parenthesized constant expressions in `asm`
-statements, string literals within the constant expression are instead encoded
-using the execution character set specified by `-fexec-charset=`.
+On z/OS, the system default encoding is IBM-1047, which has implications for
+ASM strings. See
+[String literal encoding in ASM statements](#string-literal-encoding-in-asm-statements)
+for details.
+
## Extensions for Static Analysis
>From 569d5680bb14511afa810854ebdb4b22a71da54b Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Mon, 19 Oct 2026 15:06:11 -0400
Subject: [PATCH 14/15] reverse conversion from literal encoding for assembler
template string
---
clang/include/clang/Lex/TextEncoding.h | 7 +++++++
clang/lib/Lex/TextEncoding.cpp | 8 ++++++++
clang/lib/Sema/SemaStmtAsm.cpp | 27 ++++++++++++++++++++++++++
clang/test/CodeGen/systemz-charset.cpp | 6 +++++-
4 files changed, 47 insertions(+), 1 deletion(-)
diff --git a/clang/include/clang/Lex/TextEncoding.h b/clang/include/clang/Lex/TextEncoding.h
index 46903a53610591..ebfd537488a1cd 100644
--- a/clang/include/clang/Lex/TextEncoding.h
+++ b/clang/include/clang/Lex/TextEncoding.h
@@ -27,6 +27,7 @@ enum ConversionAction {
class TextEncoding {
llvm::StringRef LiteralEncoding;
std::unique_ptr<llvm::TextEncodingConverter> ToLiteralEncodingConverter;
+ std::unique_ptr<llvm::TextEncodingConverter> FromLiteralEncodingConverter;
// Only non-null on z/OS, where the system default encoding is IBM-1047.
// This converts UTF-8 to IBM-1047 for asm string literals so that
@@ -38,6 +39,12 @@ class TextEncoding {
public:
llvm::TextEncodingConverter *getConverter(ConversionAction Action) const;
+ /// Returns the converter from the literal encoding (-fexec-charset) to UTF-8,
+ /// or nullptr if the literal encoding is UTF-8.
+ llvm::TextEncodingConverter *getFromLiteralEncodingConverter() const {
+ return FromLiteralEncodingConverter.get();
+ }
+
/// Returns the converter from IBM-1047 to UTF-8, or nullptr if not on z/OS.
llvm::TextEncodingConverter *getFromIBM1047Converter() const {
return FromIBM1047Converter.get();
diff --git a/clang/lib/Lex/TextEncoding.cpp b/clang/lib/Lex/TextEncoding.cpp
index afb5130ece88e4..32613199187100 100644
--- a/clang/lib/Lex/TextEncoding.cpp
+++ b/clang/lib/Lex/TextEncoding.cpp
@@ -45,6 +45,14 @@ TextEncoding::setConvertersFromOptions(TextEncoding &TE,
std::move(*ErrorOrLiteralConverter));
else
return ErrorOrLiteralConverter.getError();
+
+ ErrorOrLiteralConverter =
+ llvm::TextEncodingConverter::create(TE.LiteralEncoding, UTF8);
+ if (ErrorOrLiteralConverter)
+ TE.FromLiteralEncodingConverter = std::make_unique<TextEncodingConverter>(
+ std::move(*ErrorOrLiteralConverter));
+ else
+ return ErrorOrLiteralConverter.getError();
}
if (TInfo.getDefaultOrdinaryLiteralEncoding() == UTF8)
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index 1746604f61378c..b2d95a739c1c36 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -13,6 +13,7 @@
#include "clang/AST/ExprCXX.h"
#include "clang/AST/RecordLayout.h"
#include "clang/AST/TypeLoc.h"
+#include "clang/Basic/DiagnosticLex.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Lex/TextEncoding.h"
@@ -248,6 +249,7 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
Diag(Expr->getBeginLoc(), diag::err_asm_operand_empty_string)
<< SL->getSourceRange();
}
+
if (!IsConstExpr &&
PP.getTextEncoding().getFromIBM1047Converter() != nullptr) {
SmallString<16> ConvertedAsm;
@@ -274,6 +276,31 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
Diag(Expr->getBeginLoc(), diag::err_asm_operand_empty_string);
}
+ // The evaluated string is in the literal encoding (-fexec-charset).
+ // Convert it back to UTF-8
+ if (llvm::TextEncodingConverter *FromLiteral =
+ PP.getTextEncoding().getFromLiteralEncodingConverter()) {
+ unsigned Size = V.getArraySize();
+ std::string Raw;
+ Raw.reserve(Size);
+ for (unsigned I = 0; I < Size; ++I)
+ Raw.push_back(static_cast<char>(
+ V.getArrayInitializedElt(I).getInt().getExtValue()));
+ SmallString<16> Converted;
+ if (std::error_code EC = FromLiteral->convert(Raw, Converted)) {
+ Diag(Expr->getBeginLoc(), diag::err_exec_charset_conversion_failed)
+ << EC.message();
+ return ExprError();
+ }
+ llvm::APSInt Proto(Context.getTypeSize(Context.CharTy),
+ Context.CharTy->isUnsignedIntegerType());
+ V = APValue(APValue::UninitArray{}, Converted.size(), Converted.size());
+ for (unsigned I = 0; I < Converted.size(); ++I) {
+ Proto = static_cast<unsigned char>(Converted[I]);
+ V.getArrayInitializedElt(I) = APValue(Proto);
+ }
+ }
+
return ConstantExpr::Create(getASTContext(), Expr, V);
}
diff --git a/clang/test/CodeGen/systemz-charset.cpp b/clang/test/CodeGen/systemz-charset.cpp
index b6b79842468c15..b1c58b3336bb39 100644
--- a/clang/test/CodeGen/systemz-charset.cpp
+++ b/clang/test/CodeGen/systemz-charset.cpp
@@ -96,7 +96,11 @@ void function()
// CHECK: asm{{.*}}@foo
// CHECK-UTF8: asm{{.*}}@foo
asm((getfoo()));
- // CHECK: asm{{.*}}|\86\96\96
+ // CHECK: asm{{.*}}@foo
// CHECK-UTF8: asm{{.*}}|foo
+
+ asm((string_view("\tnop\n")));
+ // CHECK: asm{{.*}}\09nop\0A
+ // CHECK-UTF8: asm{{.*}}\09nop\0A
}
>From 7eb4aec053c9efe538641995ec3bdaeda7c91f34 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Mon, 2 Nov 2026 13:57:43 -0500
Subject: [PATCH 15/15] address latest comments
---
clang/docs/LanguageExtensions.md | 18 +++----
clang/include/clang/AST/APValue.h | 4 ++
.../include/clang/Basic/DiagnosticLexKinds.td | 3 +-
clang/include/clang/Lex/LiteralSupport.h | 9 ++--
clang/include/clang/Sema/Sema.h | 2 +-
clang/lib/AST/APValue.cpp | 11 ++++
clang/lib/Lex/LiteralSupport.cpp | 51 +++++++++----------
clang/lib/Parse/Parser.cpp | 6 +--
clang/lib/Sema/SemaStmtAsm.cpp | 13 ++---
clang/test/CodeGen/systemz-charset-diag.cpp | 2 +-
clang/test/Sema/systemz-charset-asm.cpp | 2 +-
11 files changed, 64 insertions(+), 57 deletions(-)
diff --git a/clang/docs/LanguageExtensions.md b/clang/docs/LanguageExtensions.md
index 9e19cc8c34d3e4..673cf45e130682 100644
--- a/clang/docs/LanguageExtensions.md
+++ b/clang/docs/LanguageExtensions.md
@@ -2265,10 +2265,9 @@ int foo() {
### String literal encoding in ASM statements
-On targets where the platform's default ordinary literal encoding differs from
-UTF-8 (such as z/OS, where the system default encoding is IBM-1047):
+On z/OS, where the system default encoding is IBM-1047 rather than UTF-8:
-* **String literals**: A string literal used as the template string in an
+* A string literal used as the template string in an
extended asm statement, as the instruction string in a basic asm statement,
or as the string specifying the assembler name or register in an asm label or
a global/local register variable declaration (such as `asm("...")` or
@@ -2276,14 +2275,11 @@ UTF-8 (such as z/OS, where the system default encoding is IBM-1047):
encoding (such as IBM-1047 on z/OS) rather than the literal encoding
specified by `-fexec-charset=`. This ensures that escape sequences (such as
octal or hexadecimal byte escapes) are interpreted as system/assembler code
- points.
-
-* **Constexpr string expressions in ASM statements**: When a parenthesized
- constant expression is provided in place of an `asm` string, string literals
- within that constant expression are encoded according to the execution
- character set specified by `-fexec-charset=` (the literal encoding), as
- constant expression evaluation expects `char` sequences to operate in the
- literal encoding.
+ points. This does **not** apply to parenthesized
+ constant expressions (see
+ [Constexpr strings in GNU ASM statements](#constexpr-strings-in-gnu-asm-statements)),
+ in which string literals are encoded according to the literal encoding
+ specified by `-fexec-charset=`.
For example, on z/OS compiled with `-fexec-charset=UTF-8`:
diff --git a/clang/include/clang/AST/APValue.h b/clang/include/clang/AST/APValue.h
index 7a69a98702a8cc..42e03c51533e89 100644
--- a/clang/include/clang/AST/APValue.h
+++ b/clang/include/clang/AST/APValue.h
@@ -570,6 +570,10 @@ class LLVM_ATTRIBUTE_WARN_UNUSED APValue {
std::string getAsString(const ASTContext &Ctx, QualType Ty) const;
+ /// Returns the contents of an array of integers (e.g. an evaluated character
+ /// array) as a string, with each element truncated to a char.
+ std::string getCharArrayAsString() const;
+
APSInt &getInt() {
assert(isInt() && "Invalid accessor");
return *(APSInt *)(char *)&Data;
diff --git a/clang/include/clang/Basic/DiagnosticLexKinds.td b/clang/include/clang/Basic/DiagnosticLexKinds.td
index d6d94005e57df3..a75c7ddd66cb87 100644
--- a/clang/include/clang/Basic/DiagnosticLexKinds.td
+++ b/clang/include/clang/Basic/DiagnosticLexKinds.td
@@ -301,7 +301,8 @@ def ext_string_too_long : Extension<"string literal of length %0 exceeds "
def err_character_too_large : Error<
"character too large for enclosing character literal type">;
def err_exec_charset_conversion_failed
- : Error<"encoding conversion failed: '%0'">;
+ : Error<"conversion %select{to literal encoding|to asm string encoding|"
+ "from literal encoding to UTF-8}1 failed: '%0'">;
def warn_c99_compat_unicode_literal : Warning<
"unicode literals are incompatible with C99">,
InGroup<C99Compat>, DefaultIgnore;
diff --git a/clang/include/clang/Lex/LiteralSupport.h b/clang/include/clang/Lex/LiteralSupport.h
index 9270190e024805..ac52c76db00564 100644
--- a/clang/include/clang/Lex/LiteralSupport.h
+++ b/clang/include/clang/Lex/LiteralSupport.h
@@ -247,6 +247,7 @@ class StringLiteralParser {
unsigned UDSuffixToken;
unsigned UDSuffixOffset;
StringLiteralEvalMethod EvalMethod;
+ ConversionAction Action;
public:
StringLiteralParser(
@@ -259,9 +260,9 @@ class StringLiteralParser {
: SM(sm), Features(features), Target(target), Diags(diags), TE(nullptr),
MaxTokenLength(0), SizeBound(0), CharByteWidth(0), Kind(tok::unknown),
ResultPtr(ResultBuf.data()),
- EvalMethod(StringLiteralEvalMethod::Evaluated), hadError(false),
- Pascal(false) {
- init(StringToks, CA_NoConversion);
+ EvalMethod(StringLiteralEvalMethod::Evaluated), Action(CA_NoConversion),
+ hadError(false), Pascal(false) {
+ init(StringToks);
}
bool hadError;
@@ -309,7 +310,7 @@ class StringLiteralParser {
static bool isValidUDSuffix(const LangOptions &LangOpts, StringRef Suffix);
private:
- void init(ArrayRef<Token> StringToks, ConversionAction Action);
+ void init(ArrayRef<Token> StringToks);
bool CopyStringFragment(const Token &Tok, const char *TokBegin,
StringRef Fragment,
llvm::TextEncodingConverter *Converter);
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 778478f4723234..a78e8bb94a1b91 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -11490,7 +11490,7 @@ class Sema final : public SemaBase {
public:
ExprResult ActOnGCCAsmStmtString(Expr *Stm, bool ForAsmLabel,
- bool IsConstExpr = false);
+ bool IsConstexpr = false);
StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
bool IsVolatile, unsigned NumOutputs,
unsigned NumInputs, IdentifierInfo **Names,
diff --git a/clang/lib/AST/APValue.cpp b/clang/lib/AST/APValue.cpp
index 97023be49c715b..51233d0a8fc416 100644
--- a/clang/lib/AST/APValue.cpp
+++ b/clang/lib/AST/APValue.cpp
@@ -1103,6 +1103,17 @@ std::string APValue::getAsString(const ASTContext &Ctx, QualType Ty) const {
return Result;
}
+std::string APValue::getCharArrayAsString() const {
+ assert(isArray() && "Invalid accessor");
+ unsigned Size = getArraySize();
+ std::string Result;
+ Result.reserve(Size);
+ for (unsigned I = 0; I < Size; ++I)
+ Result.push_back(
+ static_cast<char>(getArrayInitializedElt(I).getInt().getExtValue()));
+ return Result;
+}
+
bool APValue::toIntegralConstant(APSInt &Result, QualType SrcTy,
const ASTContext &Ctx) const {
if (isInt()) {
diff --git a/clang/lib/Lex/LiteralSupport.cpp b/clang/lib/Lex/LiteralSupport.cpp
index efb1138b466150..ca4c3574bd9972 100644
--- a/clang/lib/Lex/LiteralSupport.cpp
+++ b/clang/lib/Lex/LiteralSupport.cpp
@@ -139,14 +139,12 @@ convertCharacter(StringRef Char, const llvm::TextEncodingConverter &Converter) {
/// ProcessCharEscape - Parse a standard C escape sequence, which can occur in
/// either a character or a string literal.
-static unsigned ProcessCharEscape(const char *ThisTokBegin,
- const char *&ThisTokBuf,
- const char *ThisTokEnd, bool &HadError,
- FullSourceLoc Loc, unsigned CharWidth,
- DiagnosticsEngine *Diags,
- const LangOptions &Features,
- StringLiteralEvalMethod EvalMethod,
- llvm::TextEncodingConverter *Converter) {
+static unsigned ProcessCharEscape(
+ const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd,
+ bool &HadError, FullSourceLoc Loc, unsigned CharWidth,
+ DiagnosticsEngine *Diags, const LangOptions &Features,
+ StringLiteralEvalMethod EvalMethod, llvm::TextEncodingConverter *Converter,
+ ConversionAction Action) {
const char *EscapeBegin = ThisTokBuf;
bool Delimited = false;
bool EndDelimiterFound = false;
@@ -397,7 +395,8 @@ static unsigned ProcessCharEscape(const char *ThisTokBegin,
else {
Diag(Diags, Features, Loc, ThisTokBegin, EscapeBegin, ThisTokBuf,
diag::err_exec_charset_conversion_failed)
- << ErrorOrChar.getError().message();
+ << ErrorOrChar.getError().message()
+ << (Action == CA_ToLiteralEncodingForAsm ? 1 : 0);
HadError = true;
}
}
@@ -807,7 +806,8 @@ static void EncodeUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf,
bool &HadError, FullSourceLoc Loc,
unsigned CharByteWidth, DiagnosticsEngine *Diags,
const LangOptions &Features,
- llvm::TextEncodingConverter *Converter) {
+ llvm::TextEncodingConverter *Converter,
+ ConversionAction Action) {
typedef uint32_t UTF32;
UTF32 UcnVal = 0;
unsigned short UcnLen = 0;
@@ -904,7 +904,7 @@ static void EncodeUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf,
ResultBuf = Cp + CpConv.size();
} else {
Diags->Report(Loc, diag::err_exec_charset_conversion_failed)
- << EC.message();
+ << EC.message() << (Action == CA_ToLiteralEncodingForAsm ? 1 : 0);
HadError = true;
}
}
@@ -1943,7 +1943,7 @@ CharLiteralParser::CharLiteralParser(const char *begin, const char *end,
} else {
HadError = true;
PP.Diag(Loc, diag::err_exec_charset_conversion_failed)
- << ErrorOrChar.message();
+ << ErrorOrChar.message() << 0;
}
}
}
@@ -1968,7 +1968,7 @@ CharLiteralParser::CharLiteralParser(const char *begin, const char *end,
EncodeUCNEscape(TokBegin, begin, end, ResultPtr, HadError,
FullSourceLoc(Loc, PP.getSourceManager()),
/*CharByteWidth=*/1u, &PP.getDiagnostics(),
- PP.getLangOpts(), Converter);
+ PP.getLangOpts(), Converter, CA_ToLiteralEncoding);
if (!HadError)
*buffer_begin = *Cp;
}
@@ -1976,11 +1976,11 @@ CharLiteralParser::CharLiteralParser(const char *begin, const char *end,
continue;
}
unsigned CharWidth = getCharWidth(Kind, PP.getTargetInfo());
- uint64_t result =
- ProcessCharEscape(TokBegin, begin, end, HadError,
- FullSourceLoc(Loc, PP.getSourceManager()), CharWidth,
- &PP.getDiagnostics(), PP.getLangOpts(),
- StringLiteralEvalMethod::Evaluated, nullptr);
+ uint64_t result = ProcessCharEscape(
+ TokBegin, begin, end, HadError,
+ FullSourceLoc(Loc, PP.getSourceManager()), CharWidth,
+ &PP.getDiagnostics(), PP.getLangOpts(),
+ StringLiteralEvalMethod::Evaluated, nullptr, CA_NoConversion);
*buffer_begin++ = result;
}
@@ -2096,12 +2096,11 @@ StringLiteralParser::StringLiteralParser(ArrayRef<Token> StringToks,
Target(PP.getTargetInfo()), Diags(&PP.getDiagnostics()),
TE(&PP.getTextEncoding()), MaxTokenLength(0), SizeBound(0),
CharByteWidth(0), Kind(tok::unknown), ResultPtr(ResultBuf.data()),
- EvalMethod(EvalMethod), hadError(false), Pascal(false) {
- init(StringToks, Action);
+ EvalMethod(EvalMethod), Action(Action), hadError(false), Pascal(false) {
+ init(StringToks);
}
-void StringLiteralParser::init(ArrayRef<Token> StringToks,
- ConversionAction Action) {
+void StringLiteralParser::init(ArrayRef<Token> StringToks) {
// The literal token may have come from an invalid source location (e.g. due
// to a PCH error), in which case the token length will be 0.
if (StringToks.empty() || StringToks[0].getLength() < 2)
@@ -2358,14 +2357,14 @@ void StringLiteralParser::init(ArrayRef<Token> StringToks,
EncodeUCNEscape(ThisTokBegin, ThisTokBuf, ThisTokEnd, ResultPtr,
hadError,
FullSourceLoc(StringToks[i].getLocation(), SM),
- CharByteWidth, Diags, Features, Converter);
+ CharByteWidth, Diags, Features, Converter, Action);
continue;
}
// Otherwise, this is a non-UCN escape character. Process it.
unsigned ResultChar = ProcessCharEscape(
ThisTokBegin, ThisTokBuf, ThisTokEnd, hadError,
FullSourceLoc(StringToks[i].getLocation(), SM), CharByteWidth * 8,
- Diags, Features, EvalMethod, Converter);
+ Diags, Features, EvalMethod, Converter, Action);
if (CharByteWidth == 4) {
// FIXME: Make the type of the result buffer correct instead of
@@ -2459,7 +2458,7 @@ bool StringLiteralParser::CopyStringFragment(
if (Diags)
Diags->Report(Tok.getLocation(),
diag::err_exec_charset_conversion_failed)
- << EC.message();
+ << EC.message() << (Action == CA_ToLiteralEncodingForAsm ? 1 : 0);
return true;
}
}
@@ -2582,7 +2581,7 @@ unsigned StringLiteralParser::getOffsetOfStringByte(const Token &Tok,
ProcessCharEscape(SpellingStart, SpellingPtr, SpellingEnd, HadError,
FullSourceLoc(Tok.getLocation(), SM), CharByteWidth * 8,
Diags, Features, StringLiteralEvalMethod::Evaluated,
- /*TextEncoding=*/nullptr);
+ /*TextEncoding=*/nullptr, CA_NoConversion);
--ByteNo;
}
assert(!HadError && "This method isn't valid on erroneous strings");
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 3f6776d72d5372..230363d98c985e 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -1566,7 +1566,7 @@ void Parser::ParseKNRParamDeclarations(Declarator &D) {
ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
ExprResult AsmString;
- bool IsConstExpr = false;
+ bool IsConstexpr = false;
if (isTokenStringLiteral()) {
AsmString = ParseStringLiteralExpression(/*AllowUserDefinedLiteral=*/false,
/*Unevaluated=*/false,
@@ -1582,7 +1582,7 @@ ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
}
} else if (!ForAsmLabel && getLangOpts().CPlusPlus11 &&
Tok.is(tok::l_paren)) {
- IsConstExpr = true;
+ IsConstexpr = true;
ParenParseOption ExprType = ParenParseOption::SimpleExpr;
SourceLocation RParenLoc;
ParsedType CastTy;
@@ -1603,7 +1603,7 @@ ExprResult Parser::ParseAsmStringLiteral(bool ForAsmLabel) {
}
return Actions.ActOnGCCAsmStmtString(AsmString.get(), ForAsmLabel,
- IsConstExpr);
+ IsConstexpr);
}
ExprResult Parser::ParseSimpleAsm(bool ForAsmLabel, SourceLocation *EndLoc) {
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index b2d95a739c1c36..0f9b3e2fe1d079 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -239,7 +239,7 @@ getClobberConflictLocation(MultiExprArg Exprs, Expr **Constraints,
}
ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
- bool IsConstExpr) {
+ bool IsConstexpr) {
if (!Expr)
return ExprError();
@@ -250,7 +250,7 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
<< SL->getSourceRange();
}
- if (!IsConstExpr &&
+ if (!IsConstexpr &&
PP.getTextEncoding().getFromIBM1047Converter() != nullptr) {
SmallString<16> ConvertedAsm;
PP.getTextEncoding().getFromIBM1047Converter()->convert(SL->getString(),
@@ -280,16 +280,11 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
// Convert it back to UTF-8
if (llvm::TextEncodingConverter *FromLiteral =
PP.getTextEncoding().getFromLiteralEncodingConverter()) {
- unsigned Size = V.getArraySize();
- std::string Raw;
- Raw.reserve(Size);
- for (unsigned I = 0; I < Size; ++I)
- Raw.push_back(static_cast<char>(
- V.getArrayInitializedElt(I).getInt().getExtValue()));
+ std::string Raw = V.getCharArrayAsString();
SmallString<16> Converted;
if (std::error_code EC = FromLiteral->convert(Raw, Converted)) {
Diag(Expr->getBeginLoc(), diag::err_exec_charset_conversion_failed)
- << EC.message();
+ << EC.message() << /*from literal encoding to UTF-8*/ 2;
return ExprError();
}
llvm::APSInt Proto(Context.getTypeSize(Context.CharTy),
diff --git a/clang/test/CodeGen/systemz-charset-diag.cpp b/clang/test/CodeGen/systemz-charset-diag.cpp
index a59a5ef4f0604c..4ed94810150a3a 100644
--- a/clang/test/CodeGen/systemz-charset-diag.cpp
+++ b/clang/test/CodeGen/systemz-charset-diag.cpp
@@ -1,3 +1,3 @@
// RUN: %clang_cc1 -triple s390x-none-zos -fexec-charset IBM-1047 %s -std=c++17 -emit-llvm -o - -verify
-const char* Computer = "🖥️"; // expected-error-re {{encoding conversion failed: {{.*}}}}
+const char* Computer = "🖥️"; // expected-error-re {{conversion to literal encoding failed: {{.*}}}}
diff --git a/clang/test/Sema/systemz-charset-asm.cpp b/clang/test/Sema/systemz-charset-asm.cpp
index b3c27cc53638e6..3b7067bde2bf90 100644
--- a/clang/test/Sema/systemz-charset-asm.cpp
+++ b/clang/test/Sema/systemz-charset-asm.cpp
@@ -4,7 +4,7 @@
long inline_asm_ucn_named_operand(long a, long b) {
// The \N{...} escape encodes to U+0130. IBM-1047 has no code point for
// U+0130, so the conversion reports an error.
- asm("\tLGR %0, %[\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}]\n" // expected-error-re {{encoding conversion failed: {{.*}}}}
+ asm("\tLGR %0, %[\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}]\n" // expected-error-re {{conversion to asm string encoding failed: {{.*}}}}
: "=r"(a)
: [\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}] "r"(b));
return a;
More information about the cfe-commits
mailing list