llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-modules 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 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
