[SystemZ] Emit .gnu_attribute for an externally visible vector abi.

[jonpa]

Summary

This is the SystemZ part originally part of https://reviews.llvm.org/D102894.

On SystemZ, the vector ABI changes depending on the presence of hardware vector support. Therefore, each binary compiled with a visible vector ABI (e.g. calling an external function with a vector argument) should be marked with a .gnu_attribute describing this.

This adds support on SystemZ to emit a gnu attribute for the vector abi both to asm and object files.

[jonpa]

This is missing some cases. We need to catch any type that contains a vector type somewhere, which includes in particular aggregate types like array and structs, since the different alignment of the member may in turn trigger a different alignment of the aggregate. E.g. a struct that contains a member of vector type should trigger the attribute.

right... added recursive handling for array/struct types.

We also possibly need to catch function pointer types where the pointed-to function has a vector (or derived) type as argument or return value. (However, that may be overkill: it really only "counts" if such a type is *used* either to perform a call via function pointer, or else if the address of a local function is passed as pointer to some external user. If this is too difficult to determine, then I guess it's OK to just count all function pointer types.)

Added handling for FunctionType. In both these cases the globally called function is found to have a user and then inspected for the function type.

[uweigand]

llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp

800

Now that isVectorTypeBased supports function types, I think the code below can be replaced by a single call to isVectorTypeBased(FTy).

810

I don't think this implementation of vararg support is quite complete. On the caller side, you check for variable arguments to any direct function with a prototype. However, this misses the case where an *indirect* function call (using a function pointer) has variable arguments.

This also completely misses the *callee* side: every function that takes variable arguments and uses va_arg with a vector type is also dependent on the vector ABI.

[jonpa]

I don't think this implementation of vararg support is quite complete. On the caller side, you check for variable arguments to any direct function with a prototype. However, this misses the case where an *indirect* function call (using a function pointer) has variable arguments.

This also completely misses the *callee* side: every function that takes variable arguments and uses va_arg with a vector type is also dependent on the vector ABI.

Patch updated to address these cases as well.

[uweigand]

In D105067#2857971, @jonpa wrote:

I don't think this implementation of vararg support is quite complete. On the caller side, you check for variable arguments to any direct function with a prototype. However, this misses the case where an *indirect* function call (using a function pointer) has variable arguments.

This also completely misses the *callee* side: every function that takes variable arguments and uses va_arg with a vector type is also dependent on the vector ABI.

Patch updated to address these cases as well.

Unfortunately I think this still catches only a subset of those cases. For the indirect calls, you now check those using a global function pointer variable. But calls via a local function pointer (e.g. a callback argument) have the same problem. For the callee side, you now check exported functions that use va_start - but we also need to handle functions that get a va_list as argument, as well as non-exported functions (you can pass va_list through to other routines).

GCC checks every call instruction in the whole compilation unit that uses variable argument lists, and it also checks every use of va_arg. I believe we may have to do the same. (This is a problem since va_arg is already expanded by the front-end. I'm starting to think this whole logic might be better placed in clang; we can just set a flag there when we expand a call or a va_arg, and don't have to scan everything after the fact ...)

[jonpa]

we also need to handle functions that get a va_list as argument, as well as non-exported functions (you can pass va_list through to other routines).

Patch updated per review.

Callee:

• if va_arg with vector type is lowered in a global function, VecABI is visible. Needs to be checked in FE (SystemZABIInfo::EmitVAArg).
• FunctionType of global function is checked in SystemZAsmPrinter.

Caller:

Since we need to inspect all calls (not just to globally declared/defined functions), I thought we either need to do a scan over all functions/instructions in AsmPrinter, or we could check all calls during isel in LowerCall() (Doing it in the FE seems worse as no optimizations at all have taken place yet). I tried now to do it in LowerCall(), but as I did not find any way to set a flag at Module scope each new function has still calls checked until the function attribute is added. Scanning everything in AsmPrinter would stop at the first occurrence on the other hand...

I hope all calls of interest have the CLI.CB pointer (Instruction*) set. The one case I have seen where this is null is for an intrinsic (patch-point)...

It seems that gcc emits attribute if va_start is used, even if va_list is not used. I have simplified this a bit to assume that va_start is always present in a var-arg function.

It seems that gcc is conservative about the va_list being passed on to other functions: As soon as a vector vararg argument is passed, it seems the vector ABI becomes visible, even if calling a static function, and I did the same.

isVectorTypeBased() now moved into SystemZ namespace so that it can be used also in LowerCall().

[uweigand]

I tried now to do it in LowerCall(), but as I did not find any way to set a flag at Module scope

You might want to look at the module flags metadata mechanism: https://llvm.org/docs/LangRef.html#module-flags-metadata
See the addModuleFlag / getModuleFlag routines.

[jonpa]

Updated per review to use a module flag instead of function attribute.

No other function changes, but some thoughts:

Not sure if SystemZMachineFunctionInfo.h is the right place for isVectorTypeBased()... It could simply be local to SystemZAsmPrinter.cpp if we scanned for all call instructions there instead of checking them in SystemZISelLowering::LowerCall(). I would feel just slightly more comfortable with that rather than relying on the presence of CLI.CB in detectVisibleVectorABI(), although I guess that should be ok... It might also be slightly more readable to not handle the call sites in a different place, but rather do all the back-end checking in AsmPrinter.

hasVisibleVectorABI() checks varargs also when calling a local function (see comment there). It would have been nice to instead identify va_list in isVectorTypeBased(), but I don't think that's possible. Another way might be to check in the front-end when a va_list is passed to a global function... Not sure how much it matters - I think GCC is being overconservative here.

[jonpa]

Patch rebased.

[jonpa]

Patch rebased with needed changes in order to build with passing tests:

• Use PTy->getPointerElementType() and not PTy->getElementType().

• Use CLI.CB->arg_size() instead of CLI.CB->getNumArgOperands().

• Check for existing module flag before adding "visible-vector-ABI" flag in SystemZABIInfo::EmitVAArg(). This seems to have been needed before as well, but the assertion for this did not trigger (now triggered by systemz-abi-vector.c, not changed by this patch).

[jonpa]

We also need to think about "opaque pointers" at some point...

[jonpa]

Tried to rebase today, but got some build error. I also think we probably should consider opaque pointers now as it has become the default, by going through the tests and also type handling of pointers in the patch, I would guess.

First question though is if this patch became so complex that it is more reasonable to abandon it, or is this still under review?

[jonpa]

Patch reworked to support opaque pointers which are now the default and soon mandatory. This was not just a syntactic change, but as far as I understand we have to respect that it is legal to use pointer in any arbitrary way. For example, this program now compiles without warning:

define void @fun(ptr %Src, ptr %Dst) {
  %L1 = load <4 x i32>, ptr %Src
  store <4 x i32> %L1, ptr %Dst
  %L2 = load i32, ptr %Src
  store i32 %L2, ptr %Dst

  call void %Src()

  ret void
}

I have updated the patch according to the conservative assumption that a pointer could always potentially expose the vector ABI. This seems necessary when handling this in the backend at least. This leads to a somewhat more simple handling, but I am not sure if this is acceptable. I guess the only alternative would be to handle everything in the front end instead, where hopefully these things are known. Then again, as I believe we have discussed before, that has the drawback of deciding on this before optimizations have run, which also could mean over-conservative results.

[jonpa]

Patch reworked to do the visible vector ABI detection in the Clang FE instead, which is necessary after the move to opaque pointers.

• The recursive search of the type is basically moved to the frontend. A set has to be used to avoid revisiting the same type again which is catastrophic in compile time.

• Tried to ignore unused pointers, but it seems that with C++ isUsed() always returns false, which means the patch is acting conservatively with pointers by assuming they always expose the ABI.

• Did not find a possible way to check vararg arguments when passed via funtion pointer: The check in CodeGenFunction::EmitCall() with checkFunctionCallABI() does not work for calls via function pointer. I think that either a similar method could be called here as well for the case where only a function prototype is available (and not a declaration), or it could be checked in CodeGenFunction::getVarArgType(). As long as it's only needed for varargs I guess its easier to do it in getVarArgType() (which the patch now does), but on the other hand it might make sense to have the check done in one place regardless of declaration/funptr.

• Would like to avoid looking up with getModuleFlag() extensively (only based on reasoning, not any compile time measurements), so added a mutable internal flag in SystemZTargetCodeGenInfo as setTargetAttributes() is const. Not sure if that makes a difference...

• Tried to get some suggestions on the name of the new module flag on Discourse a while ago, but without any replies.

• In the last minute I noticed that three regression tests are failing. They all fail at the same point when SystemZTargetCodeGenInfo::setTargetAttributes() calls GetGVALinkageForFunction() on a function with the 'inline' keyword without a function body, which triggers an assertion. Not sure if this is a bug in GetGVALinkageForFunction() or if this is a call that should never be made.

clang/test/CodeGen/PR2743-reference-missing-static.c
clang/test/CodeGen/unique-internal-linkage-names.c
clang/test/CoverageMapping/decl.c

[jonpa]

Avoid the problem with GetGVALinkageForFunction() by calling isExternallyVisible() instead, which seems to be the better alternative as well.

[jonpa]

I tried to move the handling of functions into computeInfo(), but found that it is not possible to know from a CGFunctionInfo if the function is externally visible or not. It does however seem like all vararg calls go through here (for normal functions only the declaration/definition is processed), which is fortunate as it happens that even a local vararg call should be regarded (the va_list could be passed to another global function potentially). I could therefore remove the new target hook I had added for the purpose of checking varargs.

[uweigand]

clang/lib/CodeGen/TargetInfo.cpp

7394

I'm wondering if it wouldn't be preferable to move those (and the functions operating on them) to SystemZTargetCodeGenInfo instead? There is precedent for mutable members in XCodeTargetCodeGenInfo.

7516

I think this will also have to look into C++ base classes, similar to what is done in isSingleElementStruct, doesn't it?

7628

Not sure about this. I think we need to do this unconditionally. Think e.g. of a global function that gets called with a va_list argument, passes that va_list to another *local* function, which invokes the va_arg on it. This would not be caught by your current code.

[jonpa]

Thanks for review - patch updated. Tests vec-abi-gnuattr-14.c and vec-abi-gnuattr-20.cpp strengthened accordingly.

[uweigand]

See one inline comment, otherwise LGTM now. Thanks!

clang/lib/CodeGen/TargetInfo.cpp

7628

Just one minor nit: why use CGF.CGM in some places and CGT.getCGM() in others? These should be the same, but it would be clearer to use the same expression everywhere.

clang/lib/CodeGen/CodeGenTypes.h

 
 public:
   CodeGenTypes(CodeGenModule &cgm);
   ~CodeGenTypes();
 
   const llvm::DataLayout &getDataLayout() const {
     return TheModule.getDataLayout();
   }
+  CodeGenModule &getCGM() const { return CGM; }
   ASTContext &getContext() const { return Context; }
   const ABIInfo &getABIInfo() const { return TheABIInfo; }
   const TargetInfo &getTarget() const { return Target; }
   CGCXXABI &getCXXABI() const { return TheCXXABI; }
   llvm::LLVMContext &getLLVMContext() { return TheModule.getContext(); }
   const CodeGenOptions &getCodeGenOpts() const;
 
   /// Convert clang calling convention to LLVM callilng convention.

clang/lib/CodeGen/TargetInfo.cpp

 namespace {
 
 class SystemZABIInfo : public ABIInfo {
   bool HasVector;
   bool IsSoftFloatABI;
 
 public:
   SystemZABIInfo(CodeGenTypes &CGT, bool HV, bool SF)
       : ABIInfo(CGT), HasVector(HV), IsSoftFloatABI(SF) {}
 
   bool isPromotableIntegerTypeForABI(QualType Ty) const;
   bool isCompoundType(QualType Ty) const;
   bool isVectorArgumentType(QualType Ty) const;
   bool isFPArgumentType(QualType Ty) const;
   QualType GetSingleElementType(QualType Ty) const;
 
   ABIArgInfo classifyReturnType(QualType RetTy) const;
   ABIArgInfo classifyArgumentType(QualType ArgTy) const;
 
-  void computeInfo(CGFunctionInfo &FI) const override {
-    if (!getCXXABI().classifyReturnType(FI))
-      FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
-    for (auto &I : FI.arguments())
-      I.info = classifyArgumentType(I.type);
-  }
-
+  void computeInfo(CGFunctionInfo &FI) const override;
   Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
                     QualType Ty) const override;
 };
 
 class SystemZTargetCodeGenInfo : public TargetCodeGenInfo {
+  // These are used for speeding up the search for a visible vector ABI.
+  mutable bool HasVisibleVecABIFlag = false;
+  mutable std::set<const Type *> SeenTypes;
+
+  // Returns true (the first time) if Ty is or found to make use of a vector
+  // type (e.g. as a function argument).
+  bool isVectorTypeBased(const Type *Ty) const;
+
 public:
   SystemZTargetCodeGenInfo(CodeGenTypes &CGT, bool HasVector, bool SoftFloatABI)
       : TargetCodeGenInfo(
             std::make_unique<SystemZABIInfo>(CGT, HasVector, SoftFloatABI)) {
     SwiftInfo =
         std::make_unique<SwiftABIInfo>(CGT, /*SwiftErrorInRegister=*/false);
   }
 
+  // The vector ABI is different when the vector facility is present and when
+  // a module e.g. defines an externally visible vector variable, a flag
+  // indicating a visible vector ABI is added. Eventually this will result in
+  // a GNU attribute indicating the vector ABI of the module.  Ty is the type
+  // of a variable or function parameter that is globally visible.
+  void handleExternallyVisibleObjABI(const Type *Ty,
+                                     CodeGen::CodeGenModule &M) const {
+    if (!HasVisibleVecABIFlag && isVectorTypeBased(Ty)) {
+      M.getModule().addModuleFlag(llvm::Module::Warning,
+                                  "s390x-visible-vector-ABI", 1);
+      HasVisibleVecABIFlag = true;
+    }
+  }
+
+  void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
+                           CodeGen::CodeGenModule &M) const override {
+    if (!D)
+      return;
+
+    // Check if the vector ABI becomes visible by an externally visible
+    // variable or function.
+    if (const auto *VD = dyn_cast<VarDecl>(D)) {
+      if (VD->isExternallyVisible())
+        handleExternallyVisibleObjABI(VD->getType().getTypePtr(), M);
+    }
+    else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+      if (FD->isExternallyVisible())
+        handleExternallyVisibleObjABI(FD->getType().getTypePtr(), M);
+    }
+  }
+
   llvm::Value *testFPKind(llvm::Value *V, unsigned BuiltinID,
                           CGBuilderTy &Builder,
                           CodeGenModule &CGM) const override {
     assert(V->getType()->isFloatingPointTy() && "V should have an FP type.");
     // Only use TDC in constrained FP mode.
     if (!Builder.getIsFPConstrained())
       return nullptr;
 
bool SystemZABIInfo::isPromotableIntegerTypeForABI(QualType Ty) const {
   if (ABIInfo::isPromotableIntegerTypeForABI(Ty))
     return true;
 
   if (const auto *EIT = Ty->getAs<BitIntType>())
     if (EIT->getNumBits() < 64)
       return true;
 
   // 32-bit values must also be promoted.
   if (const BuiltinType *BT = Ty->getAs<BuiltinType>())
     switch (BT->getKind()) {
     case BuiltinType::Int:
     case BuiltinType::UInt:
       return true;
     default:
       return false;
     }
   return false;
Address SystemZABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
   //   i64 __fpr;
   //   i8 *__overflow_arg_area;
   //   i8 *__reg_save_area;
   // };
 
   // Every non-vector argument occupies 8 bytes and is passed by preference
   // in either GPRs or FPRs.  Vector arguments occupy 8 or 16 bytes and are
   // always passed on the stack.
+  const SystemZTargetCodeGenInfo &SZCGI =
+      static_cast<const SystemZTargetCodeGenInfo &>(
+          CGT.getCGM().getTargetCodeGenInfo());
   Ty = getContext().getCanonicalType(Ty);
   auto TyInfo = getContext().getTypeInfoInChars(Ty);
   llvm::Type *ArgTy = CGF.ConvertTypeForMem(Ty);
   llvm::Type *DirectTy = ArgTy;
   ABIArgInfo AI = classifyArgumentType(Ty);
   bool IsIndirect = AI.isIndirect();
   bool InFPRs = false;
   bool IsVector = false;
   CharUnits UnpaddedSize;
   CharUnits DirectAlign;
+  SZCGI.handleExternallyVisibleObjABI(Ty.getTypePtr(), CGT.getCGM());
   if (IsIndirect) {
     DirectTy = llvm::PointerType::getUnqual(DirectTy);
     UnpaddedSize = DirectAlign = CharUnits::fromQuantity(8);
   } else {
     if (AI.getCoerceToType())
       ArgTy = AI.getCoerceToType();
     InFPRs = (!IsSoftFloatABI && (ArgTy->isFloatTy() || ArgTy->isDoubleTy()));
     IsVector = ArgTy->isVectorTy();
ABIArgInfo SystemZABIInfo::classifyArgumentType(QualType Ty) const {
 
   // Non-structure compounds are passed indirectly.
   if (isCompoundType(Ty))
     return getNaturalAlignIndirect(Ty, /*ByVal=*/false);
 
   return ABIArgInfo::getDirect(nullptr);
 }
 
+void SystemZABIInfo::computeInfo(CGFunctionInfo &FI) const {
+  const SystemZTargetCodeGenInfo &SZCGI =
+      static_cast<const SystemZTargetCodeGenInfo &>(
+          CGT.getCGM().getTargetCodeGenInfo());
+  if (!getCXXABI().classifyReturnType(FI))
+    FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
+  unsigned Idx = 0;
+  for (auto &I : FI.arguments()) {
+    I.info = classifyArgumentType(I.type);
+    if (FI.isVariadic() && Idx++ >= FI.getNumRequiredArgs())
+      // Check if a vararg vector argument is passed, in which case the
+      // vector ABI becomes visible as the va_list could be passed on to
+      // other functions.
+      SZCGI.handleExternallyVisibleObjABI(I.type.getTypePtr(), CGT.getCGM());
+  }
+}
+
+bool SystemZTargetCodeGenInfo::isVectorTypeBased(const Type *Ty) const {
+  while (Ty->isPointerType() || Ty->isArrayType())
+    Ty = Ty->getPointeeOrArrayElementType();
+  if (!SeenTypes.insert(Ty).second)
+    return false;
+  if (Ty->isVectorType())
+    return true;
+  if (const auto *RecordTy = Ty->getAs<RecordType>()) {
+    const RecordDecl *RD = RecordTy->getDecl();
+    if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD))
+      if (CXXRD->hasDefinition())
+        for (const auto &I : CXXRD->bases())
+          if (isVectorTypeBased(I.getType().getTypePtr()))
+            return true;
+    for (const auto *FD : RD->fields())
+      if (isVectorTypeBased(FD->getType().getTypePtr()))
+        return true;
+  }
+  if (const auto *FT = Ty->getAs<FunctionType>())
+    if (isVectorTypeBased(FT->getReturnType().getTypePtr()))
+      return true;
+  if (const FunctionProtoType *Proto = Ty->getAs<FunctionProtoType>())
+    for (auto ParamType : Proto->getParamTypes())
+      if (isVectorTypeBased(ParamType.getTypePtr()))
+        return true;
+  return false;
+}
+
 //===----------------------------------------------------------------------===//
 // MSP430 ABI Implementation
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class MSP430ABIInfo : public DefaultABIInfo {
   static ABIArgInfo complexArgInfo() {

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-00.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -target-cpu arch10 -emit-llvm \
+// RUN:   -fzvector -o - %s 2>&1 | FileCheck  %s --check-prefix=MODFLAG
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// RUN: %clang_cc1 -triple s390x-ibm-linux -target-cpu arch10 -S \
+// RUN:   -fzvector -o - %s 2>&1 | FileCheck  %s --check-prefix=ARCH10-ASM
+// RUN: %clang_cc1 -triple s390x-ibm-linux -target-cpu arch13 -S \
+// RUN:   -fzvector -o - %s 2>&1 | FileCheck  %s --check-prefix=ARCH13-ASM
+//
+// Test the emission of a gnu attribute describing the vector ABI.
+
+// Call to external function with vector argument.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void bar(v4i32 Arg);
+
+void foo() {
+  v4i32 Var = {0, 0, 0, 0};
+  bar(Var);
+}
+
+//MODFLAG: !llvm.module.flags = !{!0, !1}
+//MODFLAG: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}
+
+//ARCH10-ASM: .gnu_attribute 8, 1
+//ARCH13-ASM: .gnu_attribute 8, 2

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-01.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -target-cpu arch13 -emit-llvm \
+// RUN:   -fzvector -o - %s 2>&1 | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Call to external function with vector return value.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+v4i32 bar(void);
+
+void foo(v4i32 *Dst) {
+  v4i32 Var = bar();
+  *Dst = Var;
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-02.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test that the "s390x-visible-vector-ABI" module flag is not emitted.
+
+// Call to external function *without* vector argument.
+
+void bar(int arg);
+
+void foo() {
+  int Var = 0;
+  bar(Var);
+}
+
+//CHECK-NOT: !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-03.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s \
+// RUN:   -Wno-undefined-internal 2>&1 | FileCheck  %s
+//
+// Test that the "s390x-visible-vector-ABI" module flag is not emitted.
+
+// Calling *local* function with vector argument.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+static void bar(v4i32 arg);
+
+void foo() {
+  v4i32 Var = {0, 0, 0, 0};
+  bar(Var);
+}
+
+//CHECK-NOT: !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-04.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Call via global function pointer in internal function, with vector argument.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void (*bar)(v4i32 Arg);
+
+static void foo() {
+  v4i32 Var = {0, 0, 0, 0};
+  (*bar)(Var);
+}
+
+void fun() { foo(); }
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-05.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Call via global function pointer in internal function, with vector return
+// value.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+v4i32 (*bar)(int);
+
+static int foo() {
+  (*bar)(0)[0];
+}
+
+int fun() { return foo(); }
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-06.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Passing address of local function with vector arg to global function.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void GlobFun(v4i32 (*f)(v4i32));
+
+static v4i32 foo(v4i32 Arg) {
+  return Arg;
+}
+
+void fun() {
+  GlobFun(foo);
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-07.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Passing an array of vectors.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void bar(v4i32 Arg[2]);
+
+void foo() {
+  v4i32 Var[2] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+  bar(Var);
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-08.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Passing a struct containing a vector element.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+struct S {
+  int A;
+  v4i32 B;
+};
+
+void bar(struct S Arg);
+
+void foo() {
+  struct S Var = {0, {0, 0, 0, 0}};
+  bar(Var);
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-09.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Call to vararg function with a vector argument.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void bar(int N, ...);
+
+void foo() {
+  v4i32 Var = {0, 0, 0, 0};
+  bar(0, Var);
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-10.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Call to vararg function *without* any vector argument.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void bar(int N, ...);
+
+void foo() {
+  int Var = 0;
+  bar(0, Var);
+}
+
+//CHECK-NOT: !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-11.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Call to varargs function via global pointer to pointer to function.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void (**bar)(int N, ...);
+
+void foo() {
+  v4i32 Var = {0, 0, 0, 0};
+  (**bar)(0, Var);
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-12.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Passing vector argument to varargs function via local function pointer.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void foo(void (*bar)(int, ...)) {
+  v4i32 Var = {0, 0, 0, 0};
+  (*bar)(0, Var);
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-13.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s \
+// RUN:   -Wno-undefined-internal 2>&1 | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Passing vector argument to varargs function between static functions. This
+// also potentially exposes the vector ABI as the va_list may be passed on to
+// another (global) function.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+static int bar(int N, ...);
+
+static void foo() {
+  v4i32 Var = {0, 0, 0, 0};
+  bar(0, Var);
+}
+
+void fun() { foo(); }
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-14.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Use of va_arg with a vector type exposes the vector ABI.
+
+#include <stdarg.h>
+
+static int bar(va_list vl) {
+  return va_arg(vl, vector int)[0];
+}
+
+int foo(va_list vl) {
+  return bar(vl);
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}
+

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-15.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Defining globally visible function with vector argument.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+void fun(v4i32 Arg, v4i32 *Dst) {
+  *Dst = Arg;
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-16.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Defining globally visible function with vector return value.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+v4i32 fun(int v) {
+  v4i32 Val = {v, v, v, v};
+  return Val;
+}
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-17.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Globally visible vector variable.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+v4i32 Var;
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-18.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Globally visible struct array with vector element.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+struct S {
+  int i;
+  v4i32 Var;
+};
+
+struct S Arr[16];
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-19.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Globally visible struct with function pointer array member with vector
+// return values.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+struct S {
+  int i;
+  v4i32 (*funcptr[4])(int);
+};
+
+struct S Arr[16];
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-20.cpp

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Globally visible C++ object with vector member.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+class Base {
+protected:
+  v4i32 v;
+};
+
+class C : public Base {
+  int i;
+
+public:
+  C() {
+    i = 1;
+    v = {1, 2, 3, 4};
+  }
+};
+
+C Obj;
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-21.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Globally visible struct with a zero (variable) length array of vector values.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+struct S {
+  int A;
+  v4i32 B[0];
+} s;
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-22.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Globally visible pointer to a vector variable. An unused pointer doesn't
+// really expose the vector ABI, but as there seems to be no easy way to
+// check if a pointer is dereferenced or not (when compiling C++ at least),
+// this is treated conservatively.
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+v4i32 *VecPtr;
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-23.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test the emission of the "s390x-visible-vector-ABI" module flag.
+
+// Using external vector variable (twice to test that the module flag is only
+// added once, which would be an error).
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+extern v4i32 Var;
+
+static void foo() {
+  v4i32 Loc = {1, 1, 1, 1};
+  Var = Var + Loc;
+}
+
+static void bar() {
+  v4i32 Loc = {1, 2, 3, 4};
+  Var = Var + Loc;
+}
+
+void fun1() { foo(); }
+void fun2() { bar(); }
+
+//CHECK: !llvm.module.flags = !{!0, !1}
+//CHECK: !0 = !{i32 2, !"s390x-visible-vector-ABI", i32 1}

clang/test/CodeGen/SystemZ/vec-abi-gnuattr-24.c

+// RUN: %clang_cc1 -triple s390x-ibm-linux -emit-llvm -fzvector -o - %s 2>&1 \
+// RUN:   | FileCheck  %s
+//
+// Test that the "s390x-visible-vector-ABI" module flag is not emitted.
+
+// Use of va_arg with a scalar type.
+#include <stdarg.h>
+int fun0(va_list vl) {
+  return va_arg(vl, int);
+}
+
+typedef __attribute__((vector_size(16))) int v4i32;
+
+// Declaring unused global function with vector argument and return values;
+v4i32 globfun(v4i32 Arg);
+
+// Declaring global scalar variable used below.
+int GlobVal;
+
+// Declaring extern global scalar variable used below.
+extern int GlobExtVar;
+
+// Local vector variable used below.
+static v4i32 Var;
+
+// Local function with vector argument and return values;
+static v4i32 foo(v4i32 Arg) {
+  Var = Var + Arg;
+  return Var;
+}
+
+int fun1() {
+  v4i32 V = {1, 2, 3, 4};
+  return foo(V)[0] + GlobVal + GlobExtVar;
+}
+
+//CHECK-NOT: !{i32 2, !"s390x-visible-vector-ABI", i32 1}

llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp

private:
 
   bool parseAddress(bool &HaveReg1, Register &Reg1, bool &HaveReg2,
                     Register &Reg2, const MCExpr *&Disp, const MCExpr *&Length,
                     bool HasLength = false, bool HasVectorIndex = false);
   bool parseAddressRegister(Register &Reg);
 
   bool ParseDirectiveInsn(SMLoc L);
   bool ParseDirectiveMachine(SMLoc L);
+  bool ParseGNUAttribute(SMLoc L);
 
   OperandMatchResultTy parseAddress(OperandVector &Operands,
                                     MemoryKind MemKind,
                                     RegisterKind RegKind);
 
   OperandMatchResultTy parsePCRel(OperandVector &Operands, int64_t MinVal,
                                   int64_t MaxVal, bool AllowTLS);
 

 
 bool SystemZAsmParser::ParseDirective(AsmToken DirectiveID) {
   StringRef IDVal = DirectiveID.getIdentifier();
 
   if (IDVal == ".insn")
     return ParseDirectiveInsn(DirectiveID.getLoc());
   if (IDVal == ".machine")
     return ParseDirectiveMachine(DirectiveID.getLoc());
+  if (IDVal.startswith(".gnu_attribute"))
+    return ParseGNUAttribute(DirectiveID.getLoc());
 
   return true;
 }
 
 /// ParseDirectiveInsn
 /// ::= .insn [ format, encoding, (operands (, operands)*) ]
 bool SystemZAsmParser::ParseDirectiveInsn(SMLoc L) {
   MCAsmParser &Parser = getParser();
bool SystemZAsmParser::ParseDirectiveMachine(SMLoc L) {
   STI.setDefaultFeatures(CPU, /*TuneCPU*/ CPU, "");
   setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 
   getTargetStreamer().emitMachine(CPU);
 
   return false;
 }
 
+bool SystemZAsmParser::ParseGNUAttribute(SMLoc L) {
+  int64_t Tag;
+  int64_t IntegerValue;
+  if (!Parser.parseGNUAttribute(L, Tag, IntegerValue))
+    return false;
+
+  // Tag_GNU_S390_ABI_Vector tag is '8' and can be 0, 1, or 2.
+  if (Tag != 8 || (IntegerValue < 0 || IntegerValue > 2)) {
+    Error(Parser.getTok().getLoc(),
+          "Unrecognized .gnu_attribute tag/value pair.");
+    return false;
+  }
+
+  Parser.getStreamer().emitGNUAttribute(Tag, IntegerValue);
+
+  return true;
+}
+
 bool SystemZAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
                                      SMLoc &EndLoc, bool RestoreOnFailure) {
   Register Reg;
   if (parseRegister(Reg, RestoreOnFailure))
     return true;
   if (Reg.Group == RegGR)
     RegNo = SystemZMC::GR64Regs[Reg.Num];
   else if (Reg.Group == RegFP)

llvm/lib/Target/SystemZ/SystemZAsmPrinter.h

public:
   SystemZAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
       : AsmPrinter(TM, std::move(Streamer)), CurrentFnPPA1Sym(nullptr),
         CurrentFnEPMarkerSym(nullptr) {}
 
   // Override AsmPrinter.
   StringRef getPassName() const override { return "SystemZ Assembly Printer"; }
   void emitInstruction(const MachineInstr *MI) override;
   void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) override;
+  void emitEndOfAsmFile(Module &M) override;
   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                        const char *ExtraCode, raw_ostream &OS) override;
   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
                              const char *ExtraCode, raw_ostream &OS) override;
 
   bool doInitialization(Module &M) override {
     SM.reset();
     return AsmPrinter::doInitialization(M);
   }
   void emitFunctionEntryLabel() override;
   void emitFunctionBodyEnd() override;
 
 private:
   void emitCallInformation(CallType CT);
   void LowerFENTRY_CALL(const MachineInstr &MI, SystemZMCInstLower &MCIL);
   void LowerSTACKMAP(const MachineInstr &MI);
   void LowerPATCHPOINT(const MachineInstr &MI, SystemZMCInstLower &Lower);
+  void emitAttributes(Module &M);
 };
 } // end namespace llvm
 
 #endif

llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp

assert(NumBytes >= EncodedBytes &&
          "Patchpoint can't request size less than the length of a call.");
   assert((NumBytes - EncodedBytes) % 2 == 0 &&
          "Invalid number of NOP bytes requested!");
   while (EncodedBytes < NumBytes)
     EncodedBytes += EmitNop(OutContext, *OutStreamer, NumBytes - EncodedBytes,
                             getSubtargetInfo());
 }
 
+// The *alignment* of 128-bit vector types is different between the software
+// and hardware vector ABIs. If the there is an externally visible use of a
+// vector type in the module it should be annotated with an attribute.
+void SystemZAsmPrinter::emitAttributes(Module &M) {
+  if (M.getModuleFlag("s390x-visible-vector-ABI")) {
+    bool HasVectorFeature =
+      TM.getMCSubtargetInfo()->getFeatureBits()[SystemZ::FeatureVector];
+    OutStreamer->emitGNUAttribute(8, HasVectorFeature ? 2 : 1);
+  }
+}
+
 // Convert a SystemZ-specific constant pool modifier into the associated
 // MCSymbolRefExpr variant kind.
 static MCSymbolRefExpr::VariantKind
 getModifierVariantKind(SystemZCP::SystemZCPModifier Modifier) {
   switch (Modifier) {
   case SystemZCP::TLSGD: return MCSymbolRefExpr::VK_TLSGD;
   case SystemZCP::TLSLDM: return MCSymbolRefExpr::VK_TLSLDM;
   case SystemZCP::DTPOFF: return MCSymbolRefExpr::VK_DTPOFF;
MCSymbolRefExpr::create(getSymbol(ZCPV->getGlobalValue()),
                             getModifierVariantKind(ZCPV->getModifier()),
                             OutContext);
   uint64_t Size = getDataLayout().getTypeAllocSize(ZCPV->getType());
 
   OutStreamer->emitValue(Expr, Size);
 }
 
 static void printFormattedRegName(const MCAsmInfo *MAI, unsigned RegNo,
                                   raw_ostream &OS) {
   const char *RegName = SystemZInstPrinter::getRegisterName(RegNo);
   if (MAI->getAssemblerDialect() == AD_HLASM) {
     // Skip register prefix so that only register number is left
     assert(isalpha(RegName[0]) && isdigit(RegName[1]));
     OS << (RegName + 1);
   } else
     OS << '%' << RegName;
 }
 
 static void printOperand(const MCOperand &MCOp, const MCAsmInfo *MAI,
                          raw_ostream &OS) {
   if (MCOp.isReg()) {
     if (!MCOp.getReg())
       OS << '0';
     else
       printFormattedRegName(MAI, MCOp.getReg(), OS);
   } else if (MCOp.isImm())
     OS << MCOp.getImm();
bool SystemZAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
                                               const char *ExtraCode,
                                               raw_ostream &OS) {
   printAddress(MAI, MI->getOperand(OpNo).getReg(),
                MCOperand::createImm(MI->getOperand(OpNo + 1).getImm()),
                MI->getOperand(OpNo + 2).getReg(), OS);
   return false;
 }
 
+void SystemZAsmPrinter::emitEndOfAsmFile(Module &M) {
+  emitAttributes(M);
+}
+
 void SystemZAsmPrinter::emitFunctionBodyEnd() {
   if (TM.getTargetTriple().isOSzOS()) {
     // Emit symbol for the end of function if the z/OS target streamer
     // is used. This is needed to calculate the size of the function.
     MCSymbol *FnEndSym = createTempSymbol("func_end");
     OutStreamer->emitLabel(FnEndSym);
 
     OutStreamer->pushSection();

llvm/test/MC/SystemZ/gnu-attributes.s

+# RUN: llvm-mc -triple s390x-linux-gnu -filetype=asm %s | \
+# RUN: FileCheck %s --check-prefix=ASM
+# RUN: llvm-mc -triple s390x-linux-gnu -filetype=obj %s | \
+# RUN: llvm-objdump --mcpu=z14 -D - | FileCheck %s --check-prefix=OBJ
+
+#ASM:      .text
+#ASM:      .gnu_attribute 8, 2
+
+#OBJ:  0000000000000000 <.gnu.attributes>:
+#OBJ:       0: 41 00 00 00
+#OBJ:       4: 0f 67
+#OBJ:       6: 6e 75 00 01
+#OBJ:       a: 00 00
+#OBJ:       c: 00 07
+#OBJ:       e: 08 02
+
+  .gnu_attribute 8, 2