[clang] [SystemZ][Clang] Add support for the z/OS va_list type (PR #202397)
via cfe-commits
cfe-commits at lists.llvm.org
Mon Jun 8 10:52:01 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Sean Perry (perry-ca)
<details>
<summary>Changes</summary>
On z/OS, the user has a choice between two different va_list formats.
1. (default) uses the __builtin_zos_va_list typedef for va_list, being added in this change
2. (-D_VARARG_EXT_) uses __builtin_va_list typedef for va_list.
The __builtin_zos_va_list type is `char * [2]`.
This PR adds this type along with the __builtin_zos_va_start(), __builtin_zos_va_end() & __builtin_zos_va_copy() functions to go with it.
---
Patch is 33.56 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/202397.diff
23 Files Affected:
- (modified) clang/include/clang/AST/ASTContext.h (+14)
- (modified) clang/include/clang/AST/DeclID.h (+3)
- (modified) clang/include/clang/AST/Expr.h (+15-6)
- (modified) clang/include/clang/Basic/Builtins.td (+19)
- (modified) clang/include/clang/Basic/TargetInfo.h (+7)
- (modified) clang/lib/AST/ASTContext.cpp (+16)
- (modified) clang/lib/AST/ASTImporter.cpp (+3-3)
- (modified) clang/lib/Basic/TargetInfo.cpp (+1)
- (modified) clang/lib/Basic/Targets/SystemZ.h (+4)
- (modified) clang/lib/CodeGen/ABIInfo.cpp (+5)
- (modified) clang/lib/CodeGen/ABIInfo.h (+6)
- (modified) clang/lib/CodeGen/CGBuiltin.cpp (+30)
- (modified) clang/lib/CodeGen/CGCall.cpp (+6-2)
- (modified) clang/lib/CodeGen/CodeGenFunction.cpp (+4)
- (modified) clang/lib/CodeGen/CodeGenFunction.h (+5)
- (modified) clang/lib/CodeGen/Targets/SystemZ.cpp (+42)
- (modified) clang/lib/Sema/Sema.cpp (+8)
- (modified) clang/lib/Sema/SemaChecking.cpp (+1)
- (modified) clang/lib/Sema/SemaExpr.cpp (+23-5)
- (modified) clang/lib/Serialization/ASTReader.cpp (+6)
- (modified) clang/lib/Serialization/ASTReaderStmt.cpp (+1-1)
- (modified) clang/lib/Serialization/ASTWriter.cpp (+2)
- (modified) clang/test/CodeGen/SystemZ/zos-abi.c (+154)
``````````diff
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 54c046f5fab4a..0f196c6de1976 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -442,6 +442,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
/// The typedef for the predefined \c __builtin_ms_va_list type.
mutable TypedefDecl *BuiltinMSVaListDecl = nullptr;
+ /// The typedef for the predefined \c __builtin_zos_va_list type.
+ mutable TypedefDecl *BuiltinZOSVaListDecl = nullptr;
+
/// The typedef for the predefined \c id type.
mutable TypedefDecl *ObjCIdDecl = nullptr;
@@ -2523,6 +2526,17 @@ class ASTContext : public RefCountedBase<ASTContext> {
return MSTypeInfoTagDecl;
}
+ /// Retrieve the C type declaration corresponding to the predefined
+ /// \c __builtin_zos_va_list type.
+ TypedefDecl *getBuiltinZOSVaListDecl() const;
+
+ /// Retrieve the type of the \c __builtin_zos_va_list type.
+ QualType getBuiltinZOSVaListType() const {
+ return getTypedefType(ElaboratedTypeKeyword::None,
+ /*Qualifier=*/std::nullopt,
+ getBuiltinZOSVaListDecl());
+ }
+
/// Return whether a declaration to a builtin is allowed to be
/// overloaded/redeclared.
bool canBuiltinBeRedeclared(const FunctionDecl *) const;
diff --git a/clang/include/clang/AST/DeclID.h b/clang/include/clang/AST/DeclID.h
index 8a173e3d96349..b38875afeee84 100644
--- a/clang/include/clang/AST/DeclID.h
+++ b/clang/include/clang/AST/DeclID.h
@@ -80,6 +80,9 @@ enum PredefinedDeclIDs {
/// The predeclared 'type_info' struct.
PREDEF_DECL_BUILTIN_MS_TYPE_INFO_TAG_ID,
+ /// The internal '__builtin_zos_va_list' typedef.
+ PREDEF_DECL_BUILTIN_ZOS_VA_LIST_ID,
+
#define BuiltinTemplate(BTName) PREDEF_DECL##BTName##_ID,
#include "clang/Basic/BuiltinTemplates.inc"
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index b91bf4a5375fb..dd96f7f1bf02e 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -4958,28 +4958,37 @@ class GNUNullExpr : public Expr {
/// Represents a call to the builtin function \c __builtin_va_arg.
class VAArgExpr : public Expr {
+public:
+ enum VarArgKind { VA_Std = 0, VA_MS, VA_ZOS };
+
+private:
Stmt *Val;
- llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfo;
+ llvm::PointerIntPair<TypeSourceInfo *, 2, VarArgKind> TInfo;
SourceLocation BuiltinLoc, RParenLoc;
public:
VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo,
- SourceLocation RPLoc, QualType t, bool IsMS)
+ SourceLocation RPLoc, QualType t, VarArgKind VaKind)
: Expr(VAArgExprClass, t, VK_PRValue, OK_Ordinary), Val(e),
- TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) {
+ TInfo(TInfo, VaKind), BuiltinLoc(BLoc), RParenLoc(RPLoc) {
setDependence(computeDependence(this));
}
/// Create an empty __builtin_va_arg expression.
explicit VAArgExpr(EmptyShell Empty)
- : Expr(VAArgExprClass, Empty), Val(nullptr), TInfo(nullptr, false) {}
+ : Expr(VAArgExprClass, Empty), Val(nullptr), TInfo(nullptr, VA_Std) {}
const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }
+ VarArgKind getVarargABI() { return TInfo.getInt(); }
+ void setVarargABI(int Kind) { TInfo.setInt(static_cast<VarArgKind>(Kind)); }
+
/// Returns whether this is really a Win64 ABI va_arg expression.
- bool isMicrosoftABI() const { return TInfo.getInt(); }
- void setIsMicrosoftABI(bool IsMS) { TInfo.setInt(IsMS); }
+ bool isMicrosoftABI() const { return TInfo.getInt() == VA_MS; }
+
+ /// Returns whether this is really a z/OS ABI va_arg expression.
+ bool isZOSABI() const { return TInfo.getInt() == VA_ZOS; }
TypeSourceInfo *getWrittenTypeInfo() const { return TInfo.getPointer(); }
void setWrittenTypeInfo(TypeSourceInfo *TI) { TInfo.setPointer(TI); }
diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td
index 8d2a824ef5610..8f62f1e995f32 100644
--- a/clang/include/clang/Basic/Builtins.td
+++ b/clang/include/clang/Basic/Builtins.td
@@ -5809,6 +5809,25 @@ def MSVaCopy : Builtin {
let Prototype = "void(char*&, char*&)";
}
+// z/OS-compatible va_list functions.
+def ZOSVaStart : Builtin {
+ let Spellings = ["__builtin_zos_va_start"];
+ let Attributes = [NoThrow, CustomTypeChecking];
+ let Prototype = "void(char**, ...)";
+}
+
+def ZOSVaEnd : Builtin {
+ let Spellings = ["__builtin_zos_va_end"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(char**)";
+}
+
+def ZOSVaCopy : Builtin {
+ let Spellings = ["__builtin_zos_va_copy"];
+ let Attributes = [NoThrow];
+ let Prototype = "void(char**, char**)";
+}
+
// Arithmetic Fence: to prevent FP reordering and reassociation optimizations
// FIXME: Should this just be a Builtin?
def ArithmeticFence : LangBuiltin<"ALL_LANGUAGES"> {
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index cc226403877e2..4f30408b2f0ef 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -272,6 +272,9 @@ class TargetInfo : public TransferrableTargetInfo,
LLVM_PREFERRED_TYPE(bool)
unsigned HasBuiltinMSVaList : 1;
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasBuiltinZOSVaList : 1;
+
LLVM_PREFERRED_TYPE(bool)
unsigned HasAArch64ACLETypes : 1;
@@ -1072,6 +1075,10 @@ class TargetInfo : public TransferrableTargetInfo,
/// available on this target.
bool hasBuiltinMSVaList() const { return HasBuiltinMSVaList; }
+ /// Returns whether or not type \c __builtin_zos_va_list type is
+ /// available on this target.
+ bool hasBuiltinZOSVaList() const { return HasBuiltinZOSVaList; }
+
/// Returns whether or not the AArch64 ACLE built-in types are
/// available on this target.
bool hasAArch64ACLETypes() const { return HasAArch64ACLETypes; }
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index d7e2a0f9c4803..06af5261ed894 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -9995,6 +9995,15 @@ static TypedefDecl *CreateMSVaListDecl(const ASTContext *Context) {
return CreateCharPtrNamedVaListDecl(Context, "__builtin_ms_va_list");
}
+static TypedefDecl *CreateZOSVaListDecl(const ASTContext *Context) {
+ // typedef char *__builtin_zos_va_list[2];
+ llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 2);
+ QualType T = Context->getPointerType(Context->CharTy);
+ QualType ArrayType = Context->getConstantArrayType(
+ T, Size, nullptr, ArraySizeModifier::Normal, 0);
+ return Context->buildImplicitTypedef(ArrayType, "__builtin_zos_va_list");
+}
+
static TypedefDecl *CreateCharPtrBuiltinVaListDecl(const ASTContext *Context) {
return CreateCharPtrNamedVaListDecl(Context, "__builtin_va_list");
}
@@ -10422,6 +10431,13 @@ TypedefDecl *ASTContext::getBuiltinMSVaListDecl() const {
return BuiltinMSVaListDecl;
}
+TypedefDecl *ASTContext::getBuiltinZOSVaListDecl() const {
+ if (!BuiltinZOSVaListDecl)
+ BuiltinZOSVaListDecl = CreateZOSVaListDecl(this);
+
+ return BuiltinZOSVaListDecl;
+}
+
bool ASTContext::canBuiltinBeRedeclared(const FunctionDecl *FD) const {
// Allow redecl custom type checking builtin for HLSL.
if (LangOpts.HLSL && FD->getBuiltinID() != Builtin::NotBuiltin &&
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index f8c641789bd10..221b2bb401fa0 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -7625,9 +7625,9 @@ ExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
if (Err)
return std::move(Err);
- return new (Importer.getToContext()) VAArgExpr(
- ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
- E->isMicrosoftABI());
+ return new (Importer.getToContext())
+ VAArgExpr(ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
+ E->getVarargABI());
}
ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) {
diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
index 854d23cadaea2..4c48a97b45951 100644
--- a/clang/lib/Basic/TargetInfo.cpp
+++ b/clang/lib/Basic/TargetInfo.cpp
@@ -164,6 +164,7 @@ TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
SSERegParmMax = 0;
HasAlignMac68kSupport = false;
HasBuiltinMSVaList = false;
+ HasBuiltinZOSVaList = false;
HasAArch64ACLETypes = false;
HasRISCVVTypes = false;
AllowAMDGPUUnsafeFPAtomics = false;
diff --git a/clang/lib/Basic/Targets/SystemZ.h b/clang/lib/Basic/Targets/SystemZ.h
index 00f7d7a055b24..74ad7d722a43f 100644
--- a/clang/lib/Basic/Targets/SystemZ.h
+++ b/clang/lib/Basic/Targets/SystemZ.h
@@ -83,6 +83,8 @@ class LLVM_LIBRARY_VISIBILITY SystemZTargetInfo : public TargetInfo {
AddrSpaceMap = &ZOSAddressMap;
}
TLSSupported = false;
+ HasBuiltinZOSVaList = true;
+
// All vector types are default aligned on an 8-byte boundary, even if the
// vector facility is not available. That is different from Linux.
MaxVectorAlign = 64;
@@ -166,6 +168,8 @@ class LLVM_LIBRARY_VISIBILITY SystemZTargetInfo : public TargetInfo {
}
BuiltinVaListKind getBuiltinVaListKind() const override {
+ if (getTriple().isOSzOS())
+ return TargetInfo::CharPtrBuiltinVaList;
return TargetInfo::SystemZBuiltinVaList;
}
diff --git a/clang/lib/CodeGen/ABIInfo.cpp b/clang/lib/CodeGen/ABIInfo.cpp
index 16005890a0708..eede3b54d7b4a 100644
--- a/clang/lib/CodeGen/ABIInfo.cpp
+++ b/clang/lib/CodeGen/ABIInfo.cpp
@@ -44,6 +44,11 @@ RValue ABIInfo::EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
return RValue::getIgnored();
}
+RValue ABIInfo::EmitZOSVAArg(CodeGenFunction &CGF, Address VAListAddr,
+ QualType Ty, AggValueSlot Slot) const {
+ return RValue::getIgnored();
+}
+
bool ABIInfo::isHomogeneousAggregateBaseType(QualType Ty) const {
return false;
}
diff --git a/clang/lib/CodeGen/ABIInfo.h b/clang/lib/CodeGen/ABIInfo.h
index 576cf8f742446..4563154d50960 100644
--- a/clang/lib/CodeGen/ABIInfo.h
+++ b/clang/lib/CodeGen/ABIInfo.h
@@ -91,6 +91,12 @@ class ABIInfo {
CodeGen::Address VAListAddr, QualType Ty,
AggValueSlot Slot) const;
+ /// Emit the target dependent code to load a value of
+ /// \arg Ty from the \c __builtin_zos_va_list pointed to by \arg VAListAddr.
+ virtual RValue EmitZOSVAArg(CodeGen::CodeGenFunction &CGF,
+ CodeGen::Address VAListAddr, QualType Ty,
+ AggValueSlot Slot) const;
+
virtual bool isHomogeneousAggregateBaseType(QualType Ty) const;
virtual bool isHomogeneousAggregateSmallEnough(const Type *Base,
diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp
index 0cb5f95049789..4083c1f34e413 100644
--- a/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/clang/lib/CodeGen/CGBuiltin.cpp
@@ -6976,6 +6976,36 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
return RValue::get(Builder.CreateStore(ArgPtr, DestAddr));
}
+ case Builtin::BI__builtin_zos_va_start:
+ case Builtin::BI__builtin_zos_va_end: {
+ // The va_list is an array with 2 elements, called curr and next.
+ // Element curr is set to 0. For builtin_zos_va_start, next is initialized
+ // with a call to @llvm.va_start. Otherwise, next is passed to @llvm.va_end.
+ Address VAList = EmitZOSVAListRef(E->getArg(0));
+ llvm::Type *VAListTy = ConvertType(getContext().getBuiltinZOSVaListType());
+ VAList = VAList.withElementType(VAListTy);
+ Address Curr = Builder.CreateConstArrayGEP(VAList, 0, "curr");
+ Value *Zero = llvm::Constant::getNullValue(VoidPtrTy);
+ Builder.CreateStore(Zero, Curr);
+ Address Next = Builder.CreateConstArrayGEP(VAList, 1, "next");
+ return RValue::get(
+ EmitVAStartEnd(Next.emitRawPointer(*this),
+ BuiltinID == Builtin::BI__builtin_zos_va_start));
+ }
+ case Builtin::BI__builtin_zos_va_copy: {
+ // Lower this manually because later can't reliably determine the type.
+ Address Dest = EmitZOSVAListRef(E->getArg(0));
+ Address Src = EmitZOSVAListRef(E->getArg(1));
+ // Value *SizeVal = llvm::ConstantInt::get(Int64Ty, 2 *
+ // getPointerSize().getQuantity());
+ llvm::Type *VAListTy = ConvertType(getContext().getBuiltinZOSVaListType());
+ uint64_t SizeBytes =
+ CGM.getDataLayout().getTypeAllocSize(VAListTy).getFixedValue();
+ Value *SizeVal = llvm::ConstantInt::get(Int64Ty, SizeBytes);
+ Builder.CreateMemCpy(Dest, Src, SizeVal, false);
+ return RValue::get(Dest.emitRawPointer(*this));
+ }
+
case Builtin::BI__builtin_get_device_side_mangled_name: {
auto Name = CGM.getCUDARuntime().getDeviceSideName(
cast<DeclRefExpr>(E->getArg(0)->IgnoreImpCasts())->getDecl());
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 40cc275d40273..d2d6179b0616d 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -6584,13 +6584,17 @@ CGCallee CGCallee::prepareConcreteCallee(CodeGenFunction &CGF) const {
RValue CodeGenFunction::EmitVAArg(VAArgExpr *VE, Address &VAListAddr,
AggValueSlot Slot) {
- VAListAddr = VE->isMicrosoftABI() ? EmitMSVAListRef(VE->getSubExpr())
- : EmitVAListRef(VE->getSubExpr());
+ VAListAddr = VE->isMicrosoftABI()
+ ? EmitMSVAListRef(VE->getSubExpr())
+ : (VE->isZOSABI() ? EmitZOSVAListRef(VE->getSubExpr())
+ : EmitVAListRef(VE->getSubExpr()));
QualType Ty = VE->getType();
if (Ty->isVariablyModifiedType())
EmitVariablyModifiedType(Ty);
if (VE->isMicrosoftABI())
return CGM.getABIInfo().EmitMSVAArg(*this, VAListAddr, Ty, Slot);
+ if (VE->isZOSABI())
+ return CGM.getABIInfo().EmitZOSVAArg(*this, VAListAddr, Ty, Slot);
return CGM.getABIInfo().EmitVAArg(*this, VAListAddr, Ty, Slot);
}
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index b920266b59808..80c5268495fe6 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -2700,6 +2700,10 @@ Address CodeGenFunction::EmitMSVAListRef(const Expr *E) {
return EmitLValue(E).getAddress();
}
+Address CodeGenFunction::EmitZOSVAListRef(const Expr *E) {
+ return EmitPointerWithAlignment(E);
+}
+
void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E,
const APValue &Init) {
assert(Init.hasValue() && "Invalid DeclRefExpr initializer!");
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index 6bb9f285ebcfd..ddf00c1860fb0 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -3013,6 +3013,11 @@ class CodeGenFunction : public CodeGenTypeCache {
/// pointer to a char.
Address EmitMSVAListRef(const Expr *E);
+ /// Emit a "reference" to a __builtin_zos_va_list; this is always the
+ /// address of the expression, because a __builtin_zos_va_list is an
+ /// array of pointer to a char.
+ Address EmitZOSVAListRef(const Expr *E);
+
/// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will
/// always be accessible even if no aggregate location is provided.
RValue EmitAnyExprToTemp(const Expr *E);
diff --git a/clang/lib/CodeGen/Targets/SystemZ.cpp b/clang/lib/CodeGen/Targets/SystemZ.cpp
index 5c7485ed0944f..0ea918411509e 100644
--- a/clang/lib/CodeGen/Targets/SystemZ.cpp
+++ b/clang/lib/CodeGen/Targets/SystemZ.cpp
@@ -586,6 +586,9 @@ class ZOSXPLinkABIInfo : public ABIInfo {
RValue EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
AggValueSlot Slot) const override;
+
+ RValue EmitZOSVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
+ AggValueSlot Slot) const override;
};
class ZOSXPLinkTargetCodeGenInfo : public TargetCodeGenInfo {
@@ -907,6 +910,45 @@ RValue ZOSXPLinkABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
/*allowHigherAlign*/ false, Slot);
}
+RValue ZOSXPLinkABIInfo::EmitZOSVAArg(CodeGenFunction &CGF, Address VAListAddr,
+ QualType ArgTy, AggValueSlot Slot) const {
+ // Assume that va_list type is correct; should be pointer
+ // to LLVM type: [2 x i8*].
+ llvm::Type *VAListTy =
+ CGF.ConvertType(getContext().getBuiltinZOSVaListType());
+ VAListAddr = VAListAddr.withElementType(VAListTy);
+ Address Curr = CGF.Builder.CreateConstArrayGEP(VAListAddr, 0, "va_list.curr");
+ Address Next = CGF.Builder.CreateConstArrayGEP(VAListAddr, 1, "va_list.next");
+
+ // Get information about the argument type.
+ auto ArgTyInfo = CGF.getContext().getTypeInfoInChars(ArgTy);
+ CharUnits ArgTySize = ArgTyInfo.Width;
+
+ llvm::Type *Ty = CGF.ConvertTypeForMem(ArgTy);
+
+ // Slot size is the same as the size of a pointer.
+ CharUnits SlotSize = CGF.getPointerSize();
+
+ // Align next and copy to curr.
+ CharUnits PtrAlign = CGF.getPointerAlign();
+ llvm::Value *OldNext = CGF.Builder.CreateLoad(Next, "arg.next");
+ Address Addr = Address(emitRoundPointerUpToAlignment(CGF, OldNext, PtrAlign),
+ CGF.Int8Ty, PtrAlign);
+ CGF.Builder.CreateStore(Addr.emitRawPointer(CGF), Curr);
+
+ // Advance next and store.
+ Address NextPtr = CGF.Builder.CreateConstInBoundsByteGEP(
+ Addr, ArgTySize.isZero() ? SlotSize : ArgTySize, "arg.next.next");
+ CGF.Builder.CreateStore(NextPtr.emitRawPointer(CGF), Next);
+
+ // Fetch next arg
+ if (ArgTySize < SlotSize && !isAggregateTypeForABI(ArgTy))
+ Addr = CGF.Builder.CreateConstInBoundsByteGEP(Addr, SlotSize - ArgTySize);
+
+ return CGF.EmitLoadOfAnyValue(
+ CGF.MakeAddrLValue(Addr.withElementType(Ty), ArgTy), Slot);
+}
+
std::unique_ptr<TargetCodeGenInfo>
CodeGen::createSystemZTargetCodeGenInfo(CodeGenModule &CGM, bool HasVector,
bool SoftFloatABI) {
diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp
index 78fbc9e31842d..ad24957feaae0 100644
--- a/clang/lib/Sema/Sema.cpp
+++ b/clang/lib/Sema/Sema.cpp
@@ -375,6 +375,8 @@ void Sema::Initialize() {
// name mangling. And the name mangling uses BuiltinVaListDecl.
if (Context.getTargetInfo().hasBuiltinMSVaList())
(void)Context.getBuiltinMSVaListDecl();
+ if (Context.getTargetInfo().hasBuiltinZOSVaList())
+ (void)Context.getBuiltinZOSVaListDecl();
(void)Context.getBuiltinVaListDecl();
if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
@@ -586,6 +588,12 @@ void Sema::Initialize() {
PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
}
+ if (Context.getTargetInfo().hasBuiltinZOSVaList()) {
+ DeclarationName ZOSVaList = &Context.Idents.get("__builtin_zos_va_list");
+ if (IdResolver.begin(ZOSVaList) == IdResolver.end())
+ PushOnScopeChains(Context.getBuiltinZOSVaListDecl(), TUScope);
+ }
+
DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 8a8c9cc9d2c23..ef4306f1d74c6 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -2946,6 +2946,7 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
return ExprError();
break;
case Builtin::BI__builtin_ms_va_start:
+ case Builtin::BI__builtin_zos_va_start:
case Builtin::BI__builtin_stdarg_start:
case Builtin::BI__builtin_va_start:
case Builtin::BI__builtin_c23_va_start:
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index ad6e7183cb3a4..d34e68ebd4906 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -17203,7 +17203,7 @@ ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
Expr *E, TypeSourceInfo *TInfo,
SourceLocation RPLoc) {
Expr *OrigExpr ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/202397
More information about the cfe-commits
mailing list