[MCStreamer] Move emission of attributes section into MCELFStreamer

[jonpa]

Summary

Enable the emission of a gnu attributes section by reusing the code for emitting the ARM build attributes section.

The gnu attributes follow the exact same section format as the ARM BuildAttributes section, so this can be factored out and reused for gnu attributes generally.

The immediate motivation for this is to emit a gnu attributes section for the vector abi on SystemZ (https://reviews.llvm.org/D105067).

[uweigand]

Function return value / parameters: A C function with a vector parameter will be lowered by Clang differently depending on the subtarget vector support. On z13 it may be a <4 x i32>, while on zEC12 it is instead <4 x i32>*. When running instruction selection there would be then no way of telling if <4 x i32>* was a pointer argument or if it was a software ABI vector variable argument. Therefore a function attribute is emitted for each function "has-vector-arg" where as applicable. I guess the alternative might be to actually do this during instruction selection while considering the subtarget vector support presence - if using clang (and not llc), this might be enough. (E.g. if subtarget has vector support, then <4 x i32>* is really a pointer...)

This is probably not even necessary, since even a pointer to a vector would still trigger the emission of the gnu_attribute, for the same reason as:

Global Variables: the lowered types are the same regardless of subtarget, so it is simple to check them late during output.

It seems that GCC emits the vector ABI for global variables. Does this mean that they are stored differently in memory? Should e.g. variable arguments, stack arguments also be considered?

Yes, indeed. The alignment of 128-bit vector types is different between the two ABIs, which means that any use of such types, even via pointers or as struct elements, will trigger ABI differences.

Emission of the attribute: Managed to do this now as a raw text, which actually works, except with the integrated assembler... Should a new section be created for this somehow..?

For an example of how to handle such things, you might look at emitLocalEntry in the PowerPC target. You'll need a virtual function in TargetStreamer.h that can be called by the AsmPrinter.cpp code. Then there need to be two implementations of the virtual function, one for emitting assembler text, and one when directly emitting object files. Finally, you'll need to handle reading the directive in assembler code in the AsmParser.

As to how the actual implementation in object files goes, the "GNU attribute" is a flavor of the ELF "object attribute" feature. See the documentation here:
https://sourceware.org/binutils/docs-2.36/as/Object-Attributes.html
which refers to the initial specification of the build attribute section in the ARM ELF ABI document, see section "Build Attributes" here:
https://developer.arm.com/documentation/ihi0044/h/?lang=en

This isn't really Z specific, so it should probably be implemented somewhere in common code, if it isn't already ...

[jonpa]

Patch updated - in progress.

This is probably not even necessary, since even a pointer to a vector would still trigger the emission of the gnu_attribute...
Yes, indeed. The alignment of 128-bit vector types is different between the two ABIs, which means that any use of such types, even via pointers or as struct elements, will trigger ABI differences.

Aha... I removed the function attribute emission from clang and now do all the work in SystemZAsmPrinter instead. Added a check for actually passed arguments to a vararg function.

For an example of how to handle such things, you might look at emitLocalEntry in the PowerPC target. You'll need a virtual function in TargetStreamer.h that can be called by the AsmPrinter.cpp code. Then there need to be two implementations of the virtual function, one for emitting assembler text, and one when directly emitting object files. Finally, you'll need to handle reading the directive in assembler code in the AsmParser.

I did an attempt at this except for the parser part, which seems to work. The bytes in SystemZTargetELFStreamer are simply copied from GCC output - I have no idea about the actual layout/meaing of that, except for the last two bytes...

This isn't really Z specific, so it should probably be implemented somewhere in common code, if it isn't already ...

Actually not sure what should go into common code... ARM defines ARMTargetStreamer with some attribute emission methods, but none for .gnu_attr that I can see.

[uweigand]

In D102894#2786239, @jonpa wrote:

Patch updated - in progress.

This is probably not even necessary, since even a pointer to a vector would still trigger the emission of the gnu_attribute...
Yes, indeed. The alignment of 128-bit vector types is different between the two ABIs, which means that any use of such types, even via pointers or as struct elements, will trigger ABI differences.

Aha... I removed the function attribute emission from clang and now do all the work in SystemZAsmPrinter instead. Added a check for actually passed arguments to a vararg function.

For an example of how to handle such things, you might look at emitLocalEntry in the PowerPC target. You'll need a virtual function in TargetStreamer.h that can be called by the AsmPrinter.cpp code. Then there need to be two implementations of the virtual function, one for emitting assembler text, and one when directly emitting object files. Finally, you'll need to handle reading the directive in assembler code in the AsmParser.

I did an attempt at this except for the parser part, which seems to work.

Missing parser support is what caused this error:

./bin/clang -o b.o -c -O3 ./b.c -march=z13 -mzvector -save-temps
b.s:27:2: error: unknown directive

which you'll only see with -save-temps (because then it reads back from the assembler file it just wrote).

The bytes in SystemZTargetELFStreamer are simply copied from GCC output - I have no idea about the actual layout/meaing of that, except for the last two bytes...

The layout is documented in the ARM ABI I refered to above. See in particular here:

The overall syntactic structure of an attributes section is:

<format-version>
[ <section-length> "vendor-name"
      [ <file-tag> <size> <attribute>*
      | <section-tag> <size> <section-number>* 0 <attribute>*
      | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
      ]+
]*

Looking at your example, the bytes you output match the above format:

0x41 - format-version
0x00 0x00 0x00 0x0f - section-length
0x67 0x6e 0x75 0x00 - vendor-name ("gnu")
0x01 - file-tag
0x00 0x00 0x00 0x07 - size
Value Tag - attribute

Note that in order to properly emit this section, you cannot emit the attributes one by one, but you need to collect them somewhere and emit the whole section at the end of the file, otherwise you e.g. cannot get the section-length correct.

This isn't really Z specific, so it should probably be implemented somewhere in common code, if it isn't already ...

Actually not sure what should go into common code... ARM defines ARMTargetStreamer with some attribute emission methods, but none for .gnu_attr that I can see.

The ARM attributes go into a different section, and use a different vendor name (not "gnu"), but otherwise the format is the same as described above. So maybe the code that generates this format can be even shared between the ARM attribute section and the GNU attribute section. But in any case, the GNU attribute section in itself is common across all (ELF) platforms that use the GNU tool chain, so this part should definitely go to common code.

[jonpa]

A new class MCTargetELFAttributesStreamer which contains parts taken from ARMTargetELFStreamer for emitting an attributes section. This works by using multiple inheritance so that the MCTargetStreamers that need this can derive from this new class as well (is multiple inheritance ok to use, or should it be avoided?)

SystemZAsmParser extended to handle .gnu_attribute 8, ...

This does not care about the Tag value in any other way than integer '8'. For ARM build-attributes, it e.g. is possible to do

bin/llvm-readelf --arch-specific tc_arm.s.o -

File: tc_arm.s.o
BuildAttributes {
  FormatVersion: 0x41
  Section 1 {
    SectionLength: 17
    Vendor: aeabi
    Tag: Tag_File (0x1)
    Size: 7
    FileAttributes {
      Attribute {
        Tag: 23
        Value: 3
        TagName: ABI_FP_number_model
        Description: IEEE-754
      }
    }
  }
}

Should this also be implemented for SystemZ/GNU-attributes now?

Adding more reviers with the hope to get feedback on the common code changes...

[uweigand]

I haven't looked at the code in detail yet, but just a couple of general comments:

• The GNU attribute support should probably just go into the generic ELF target streamer. This concept is supported in principle on all ELF targets. (That might also avoid the need for multiple inheritance.)
• If we support the GNU attribute generally in the ELF streamer, then we should also support it generally in the asm streamer (and then also the common asm parser, I guess)
• ASM parser support for .gnu_attribute should support any tag&value just like GAS does.

[jonpa]

The GNU attribute support should probably just go into the generic ELF target streamer. This concept is supported in principle on all ELF targets. (That might also avoid the need for multiple inheritance.)

I tried now to put it into the ELFMCStreamer class, which seems to work fine.

Is static_cast<MCELFStreamer &> safe in SystemZTargetELFStreamer (we could first check that the ObjectFormat is ELF)?

This seems possibly also interesting to RISCV which has similar code?

If we support the GNU attribute generally in the ELF streamer, then we should also support it generally in the asm streamer (and then also the common asm parser, I guess)

MCStreamer now has a virtual function emitGNUAttribute() which is implemented by both MCELFStreamer and MCAsmStreamer.

I am not quite sure how it works when ARM switches attributes sections/vendors, which seems possible but not sure it is yet used. Right now it is up to the caller to use emitGNUAttribute() / finishAttributeSection() in a sensible way...

ASM parser support for .gnu_attribute should support any tag&value just like GAS does.

MCAsmParser can now parse a .gnu_attribute in parseGNUAttribute(), which is used by SystemZAsmParser::ParseGNUAttribute() which then also checks for proper tag/value. This could perhaps be part of MCTargetAsmParser instead - although that is more "target specific"...

Not quite sure here if we should check the tag/value, or if bad .gnu_attribute directives should be reported to user. I see some errors caught:

error: Unrecognized .gnu_directive tag/value pair.
  .gnu_attribute 8, 3
                     ^

error: unknown token in expression
  .gnu_attribute bla, 2
                    ^

.gnu_attribute 9

(No error message / .gnu_attribute emitted - line ignored)

[jonpa]

Move the handling of GNU attributes into MCELFStreamer. This way the target only has to call emitGNUAttribute(), and the section will later be created at the end of the file by MCELFStreamer.

Since I am not quite sure how a target might handle attributes in multiple sections (like ARM seems to do), I kept the GNU attributes separate from the other ones, so that the target can handle the Contents vector as before, while GNU attributes are collected independently of them and emitted after all else.

Nit: could createAttributesSection() take a reference of a template without the size specification? I don't think there will be 64 gnu attributes...

[uweigand]

The SystemZ part now looks good to me, except for the point made inline. It still would be good if the rest of the patch could be looked at by someone familiar with ARM. (Maybe it would make sense to split the patch two parts?)

llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp

709

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.

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.)

[jonpa]

SystemZ specific parts moved to https://reviews.llvm.org/D105067.

This is the common-code changes that basically should be an NFC refactoring with the purpose of moving the emission of the ELF attributes section from ARM into common code, and then also reusing that for emission of a GNU section. There are still some loose ends regarding this part - see previous post.

At this point a review by someone knowledgeable with ARM is needed for this part.

[logan]

It has been a while since I wrote the ARM attribute emitter, but anyway this commit makes sense to me and I think this is the right direction. Other than the Lint problems, I don't see other problems in this commit.

[jonpa]

clang-format:ed

OK to commit?

llvm/include/llvm/MC/MCELFStreamer.h

 //===- MCELFStreamer.h - MCStreamer ELF Object File Interface ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCELFSTREAMER_H
 #define LLVM_MC_MCELFSTREAMER_H
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCObjectStreamer.h"
 
 namespace llvm {
 
 class MCAsmBackend;
 class MCCodeEmitter;
 class MCExpr;
void emitCGProfileEntry(const MCSymbolRefExpr *From,
                           const MCSymbolRefExpr *To, uint64_t Count) override;
 
   void finishImpl() override;
 
   void emitBundleAlignMode(unsigned AlignPow2) override;
   void emitBundleLock(bool AlignToEnd) override;
   void emitBundleUnlock() override;
 
+  /// ELF object attributes section emission support:
+public:
+  struct AttributeItem {
+    // This structure holds all attributes, accounting for their string /
+    // numeric value, so we can later emit them in declaration order, keeping
+    // all in the same vector.
+    enum {
+      HiddenAttribute = 0,
+      NumericAttribute,
+      TextAttribute,
+      NumericAndTextAttributes
+    } Type;
+    unsigned Tag;
+    unsigned IntValue;
+    std::string StringValue;
+  };
+
+  SmallVector<AttributeItem, 64> Contents;
+
+  void setAttributeItem(unsigned Attribute, unsigned Value,
+                        bool OverwriteExisting);
+  void setAttributeItem(unsigned Attribute, StringRef Value,
+                        bool OverwriteExisting);
+  void setAttributeItems(unsigned Attribute, unsigned IntValue,
+                         StringRef StringValue, bool OverwriteExisting);
+  void emitAttributesSection(StringRef &Vendor, const Twine &Section,
+                             unsigned Type, MCSection *&AttributeSection);
+  void emitGNUAttributesSection(MCSection *&AttributeSection) {
+    StringRef Vendor("gnu");
+    emitAttributesSection(Vendor, ".gnu.attributes", ELF::SHT_GNU_ATTRIBUTES,
+                          AttributeSection);
+  }
+
+  void emitGNUAttribute(unsigned Tag, unsigned Value) override {
+    setAttributeItem(Tag, Value, /* OverwriteExisting= */ false);
+  }
+
+private:
+  AttributeItem *getAttributeItem(unsigned Attribute);
+  size_t calculateContentSize();
+
 private:
   bool isBundleLocked() const;
   void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
   void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
 
   void fixSymbolsInTLSFixups(const MCExpr *expr);
   void finalizeCGProfileEntry(const MCSymbolRefExpr *&S);
   void finalizeCGProfile();

llvm/include/llvm/MC/MCParser/MCAsmParser.h

public:
   ///
   /// \param ParenDepth - Specifies how many trailing expressions outside the
   /// current parentheses we have to parse.
   /// \param Res - The value of the expression. The result is undefined
   /// on error.
   /// \return - False on success.
   virtual bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
                                      SMLoc &EndLoc) = 0;
+
+  /// Parse a .gnu_attribute.
+  bool parseGNUAttribute(SMLoc L, int64_t &Tag, int64_t &IntegerValue);
 };
 
 /// Create an MCAsmParser instance for parsing assembly similar to gas syntax
 MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &, MCStreamer &,
                                const MCAsmInfo &, unsigned CB = 0);
 
 /// Create an MCAsmParser instance for parsing Microsoft MASM-style assembly
 MCAsmParser *createMCMasmParser(SourceMgr &, MCContext &, MCStreamer &,
                                 const MCAsmInfo &, unsigned CB = 0);
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCPARSER_MCASMPARSER_H

llvm/include/llvm/MC/MCStreamer.h

public:
   ///  .symver _start, foo@@SOME_VERSION
   virtual void emitELFSymverDirective(const MCSymbol *OriginalSym,
                                       StringRef Name, bool KeepOriginalSym);
 
   /// Emit a Linker Optimization Hint (LOH) directive.
   /// \param Args - Arguments of the LOH.
   virtual void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {}
 
+  /// Emit a .gnu_attribute directive.
+  virtual void emitGNUAttribute(unsigned Tag, unsigned Value) {}
+
   /// Emit a common symbol.
   ///
   /// \param Symbol - The common symbol to emit.
   /// \param Size - The size of the common symbol.
   /// \param ByteAlignment - The alignment of the symbol if
   /// non-zero. This must be a power of 2.
   virtual void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                 unsigned ByteAlignment) = 0;

llvm/lib/MC/MCAsmStreamer.cpp

public:
 
   void changeSection(MCSection *Section, const MCExpr *Subsection) override;
 
   void emitELFSymverDirective(const MCSymbol *OriginalSym, StringRef Name,
                               bool KeepOriginalSym) override;
 
   void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override;
 
+  void emitGNUAttribute(unsigned Tag, unsigned Value) override;
+
   StringRef getMnemonic(MCInst &MI) override {
     return InstPrinter->getMnemonic(&MI).first;
   }
 
   void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
 
   void emitAssemblerFlag(MCAssemblerFlag Flag) override;
   void emitLinkerOptions(ArrayRef<std::string> Options) override;
for (const MCSymbol *Arg : Args) {
     if (!IsFirst)
       OS << ", ";
     IsFirst = false;
     Arg->print(OS, MAI);
   }
   EmitEOL();
 }
 
+void MCAsmStreamer::emitGNUAttribute(unsigned Tag, unsigned Value) {
+    OS << "\t.gnu_attribute " << Tag << ", " << Value << "\n";
+}
+
 void MCAsmStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) {
   switch (Flag) {
   case MCAF_SyntaxUnified:         OS << "\t.syntax unified"; break;
   case MCAF_SubsectionsViaSymbols: OS << ".subsections_via_symbols"; break;
   case MCAF_Code16:                OS << '\t'<< MAI->getCode16Directive();break;
   case MCAF_Code32:                OS << '\t'<< MAI->getCode32Directive();break;
   case MCAF_Code64:                OS << '\t'<< MAI->getCode64Directive();break;
   }

llvm/lib/MC/MCELFStreamer.cpp

 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 
 using namespace llvm;
 
 MCELFStreamer::MCELFStreamer(MCContext &Context,
void MCELFStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
   llvm_unreachable("ELF doesn't support this directive");
 }
 
 void MCELFStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
                                    uint64_t Size, unsigned ByteAlignment) {
   llvm_unreachable("ELF doesn't support this directive");
 }
 
+MCELFStreamer::AttributeItem* MCELFStreamer::
+getAttributeItem(unsigned Attribute) {
+  for (size_t i = 0; i < Contents.size(); ++i)
+    if (Contents[i].Tag == Attribute)
+      return &Contents[i];
+  return nullptr;
+}
+
+size_t MCELFStreamer::calculateContentSize()  {
+  size_t Result = 0;
+  for (size_t i = 0; i < Contents.size(); ++i) {
+    AttributeItem item = Contents[i];
+    switch (item.Type) {
+    case AttributeItem::HiddenAttribute:
+      break;
+    case AttributeItem::NumericAttribute:
+      Result += getULEB128Size(item.Tag);
+      Result += getULEB128Size(item.IntValue);
+      break;
+    case AttributeItem::TextAttribute:
+      Result += getULEB128Size(item.Tag);
+      Result += item.StringValue.size() + 1; // string + '\0'
+      break;
+    case AttributeItem::NumericAndTextAttributes:
+      Result += getULEB128Size(item.Tag);
+      Result += getULEB128Size(item.IntValue);
+      Result += item.StringValue.size() + 1; // string + '\0';
+      break;
+    }
+  }
+  return Result;
+}
+
+void MCELFStreamer::setAttributeItem(unsigned Attribute, unsigned Value,
+                                     bool OverwriteExisting) {
+  // Look for existing attribute item
+  if (AttributeItem *Item = getAttributeItem(Attribute)) {
+    if (!OverwriteExisting)
+      return;
+    Item->Type = AttributeItem::NumericAttribute;
+    Item->IntValue = Value;
+    return;
+  }
+
+  // Create new attribute item
+  AttributeItem Item = {AttributeItem::NumericAttribute, Attribute, Value,
+    std::string(StringRef(""))};
+  Contents.push_back(Item);
+}
+
+void MCELFStreamer::setAttributeItem(unsigned Attribute, StringRef Value,
+                                     bool OverwriteExisting) {
+  // Look for existing attribute item
+  if (AttributeItem *Item = getAttributeItem(Attribute)) {
+    if (!OverwriteExisting)
+      return;
+    Item->Type = AttributeItem::TextAttribute;
+    Item->StringValue = std::string(Value);
+    return;
+  }
+
+  // Create new attribute item
+  AttributeItem Item = {AttributeItem::TextAttribute, Attribute, 0,
+    std::string(Value)};
+  Contents.push_back(Item);
+}
+
+void MCELFStreamer::
+setAttributeItems(unsigned Attribute, unsigned IntValue,
+                  StringRef StringValue, bool OverwriteExisting) {
+  // Look for existing attribute item
+  if (AttributeItem *Item = getAttributeItem(Attribute)) {
+    if (!OverwriteExisting)
+      return;
+    Item->Type = AttributeItem::NumericAndTextAttributes;
+    Item->IntValue = IntValue;
+    Item->StringValue = std::string(StringValue);
+    return;
+  }
+
+  // Create new attribute item
+  AttributeItem Item = {AttributeItem::NumericAndTextAttributes, Attribute,
+    IntValue, std::string(StringValue)};
+  Contents.push_back(Item);
+}
+
+void MCELFStreamer::
+emitAttributesSection(StringRef &Vendor, const Twine &Section,
+                      unsigned Type, MCSection *&AttributeSection) {
+  // <format-version>
+  // [ <section-length> "vendor-name"
+  // [ <file-tag> <size> <attribute>*
+  //   | <section-tag> <size> <section-number>* 0 <attribute>*
+  //   | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
+  //   ]+
+  // ]*
+
+  // Switch section to AttributeSection or get/create the section.
+  if (AttributeSection) {
+    SwitchSection(AttributeSection);
+  } else {
+    AttributeSection = getContext().getELFSection(Section, Type, 0);
+    SwitchSection(AttributeSection);
+
+    // Format version
+    emitInt8(0x41);
+  }
+
+  // Vendor size + Vendor name + '\0'
+  const size_t VendorHeaderSize = 4 + Vendor.size() + 1;
+
+  // Tag + Tag Size
+  const size_t TagHeaderSize = 1 + 4;
+
+  const size_t ContentsSize = calculateContentSize();
+
+  emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
+  emitBytes(Vendor);
+  emitInt8(0); // '\0'
+
+  emitInt8(ARMBuildAttrs::File);
+  emitInt32(TagHeaderSize + ContentsSize);
+
+  // Size should have been accounted for already, now
+  // emit each field as its type (ULEB or String)
+  for (size_t i = 0; i < Contents.size(); ++i) {
+    AttributeItem item = Contents[i];
+    emitULEB128IntValue(item.Tag);
+    switch (item.Type) {
+    default: llvm_unreachable("Invalid attribute type");
+    case AttributeItem::NumericAttribute:
+      emitULEB128IntValue(item.IntValue);
+      break;
+    case AttributeItem::TextAttribute:
+      emitBytes(item.StringValue);
+      emitInt8(0); // '\0'
+      break;
+    case AttributeItem::NumericAndTextAttributes:
+      emitULEB128IntValue(item.IntValue);
+      emitBytes(item.StringValue);
+      emitInt8(0); // '\0'
+      break;
+    }
+  }
+
+  Contents.clear();
+}
+
 MCStreamer *llvm::createELFStreamer(MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                     std::unique_ptr<MCObjectWriter> &&OW,
                                     std::unique_ptr<MCCodeEmitter> &&CE,
                                     bool RelaxAll) {
   MCELFStreamer *S =
       new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;
 }

llvm/lib/MC/MCParser/MCAsmParser.cpp

bool MCAsmParser::parseMany(function_ref<bool()> parseOne, bool hasComma) {
   return false;
 }
 
 bool MCAsmParser::parseExpression(const MCExpr *&Res) {
   SMLoc L;
   return parseExpression(Res, L);
 }
 
+bool MCAsmParser::parseGNUAttribute(SMLoc L, int64_t &Tag,
+                                    int64_t &IntegerValue) {
+  // Parse a .gnu_attribute with numerical tag and value.
+  StringRef S(L.getPointer());
+  SMLoc TagLoc;
+  TagLoc = getTok().getLoc();
+  const AsmToken &Tok = getTok();
+  if (Tok.isNot(AsmToken::Integer))
+    return false;
+  Tag = Tok.getIntVal();
+  Lex(); // Eat the Tag
+  Lex(); // Eat the comma
+  if (Tok.isNot(AsmToken::Integer))
+    return false;
+  IntegerValue = Tok.getIntVal();
+  Lex(); // Eat the IntegerValue
+  return true;
+}
+
 void MCParsedAsmOperand::dump() const {
   // Cannot completely remove virtual function even in release mode.
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   dbgs() << "  " << *this;
 #endif
 }

llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/ARMEHABI.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
-#include "llvm/Support/LEB128.h"
 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <climits>
 #include <cstddef>
 #include <cstdint>
 #include <string>
for (SmallVectorImpl<uint8_t>::const_iterator OCI = Opcodes.begin(),
                                                 OCE = Opcodes.end();
        OCI != OCE; ++OCI)
     OS << ", 0x" << Twine::utohexstr(*OCI);
   OS << '\n';
 }
 
 class ARMTargetELFStreamer : public ARMTargetStreamer {
 private:
-  // This structure holds all attributes, accounting for
-  // their string/numeric value, so we can later emit them
-  // in declaration order, keeping all in the same vector
-  struct AttributeItem {
-    enum {
-      HiddenAttribute = 0,
-      NumericAttribute,
-      TextAttribute,
-      NumericAndTextAttributes
-    } Type;
-    unsigned Tag;
-    unsigned IntValue;
-    std::string StringValue;
-
-    static bool LessTag(const AttributeItem &LHS, const AttributeItem &RHS) {
-      // The conformance tag must be emitted first when serialised
-      // into an object file. Specifically, the addenda to the ARM ABI
-      // states that (2.3.7.4):
-      //
-      // "To simplify recognition by consumers in the common case of
-      // claiming conformity for the whole file, this tag should be
-      // emitted first in a file-scope sub-subsection of the first
-      // public subsection of the attributes section."
-      //
-      // So it is special-cased in this comparison predicate when the
-      // attributes are sorted in finishAttributeSection().
-      return (RHS.Tag != ARMBuildAttrs::conformance) &&
-             ((LHS.Tag == ARMBuildAttrs::conformance) || (LHS.Tag < RHS.Tag));
-    }
-  };
-
   StringRef CurrentVendor;
   unsigned FPU = ARM::FK_INVALID;
   ARM::ArchKind Arch = ARM::ArchKind::INVALID;
   ARM::ArchKind EmittedArch = ARM::ArchKind::INVALID;
-  SmallVector<AttributeItem, 64> Contents;
 
   MCSection *AttributeSection = nullptr;
 
-  AttributeItem *getAttributeItem(unsigned Attribute) {
-    for (size_t i = 0; i < Contents.size(); ++i)
-      if (Contents[i].Tag == Attribute)
-        return &Contents[i];
-    return nullptr;
-  }
-
-  void setAttributeItem(unsigned Attribute, unsigned Value,
-                        bool OverwriteExisting) {
-    // Look for existing attribute item
-    if (AttributeItem *Item = getAttributeItem(Attribute)) {
-      if (!OverwriteExisting)
-        return;
-      Item->Type = AttributeItem::NumericAttribute;
-      Item->IntValue = Value;
-      return;
-    }
-
-    // Create new attribute item
-    AttributeItem Item = {AttributeItem::NumericAttribute, Attribute, Value,
-                          std::string(StringRef(""))};
-    Contents.push_back(Item);
-  }
-
-  void setAttributeItem(unsigned Attribute, StringRef Value,
-                        bool OverwriteExisting) {
-    // Look for existing attribute item
-    if (AttributeItem *Item = getAttributeItem(Attribute)) {
-      if (!OverwriteExisting)
-        return;
-      Item->Type = AttributeItem::TextAttribute;
-      Item->StringValue = std::string(Value);
-      return;
-    }
-
-    // Create new attribute item
-    AttributeItem Item = {AttributeItem::TextAttribute, Attribute, 0,
-                          std::string(Value)};
-    Contents.push_back(Item);
-  }
-
-  void setAttributeItems(unsigned Attribute, unsigned IntValue,
-                         StringRef StringValue, bool OverwriteExisting) {
-    // Look for existing attribute item
-    if (AttributeItem *Item = getAttributeItem(Attribute)) {
-      if (!OverwriteExisting)
-        return;
-      Item->Type = AttributeItem::NumericAndTextAttributes;
-      Item->IntValue = IntValue;
-      Item->StringValue = std::string(StringValue);
-      return;
-    }
-
-    // Create new attribute item
-    AttributeItem Item = {AttributeItem::NumericAndTextAttributes, Attribute,
-                          IntValue, std::string(StringValue)};
-    Contents.push_back(Item);
-  }
-
   void emitArchDefaultAttributes();
   void emitFPUDefaultAttributes();
 
   ARMELFStreamer &getStreamer();
 
   void emitFnStart() override;
   void emitFnEnd() override;
   void emitCantUnwind() override;
private:
   void emitFPU(unsigned FPU) override;
   void emitInst(uint32_t Inst, char Suffix = '\0') override;
   void finishAttributeSection() override;
   void emitLabel(MCSymbol *Symbol) override;
 
   void AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
   void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
 
-  size_t calculateContentSize() const;
-
   // Reset state between object emissions
   void reset() override;
 
 public:
   ARMTargetELFStreamer(MCStreamer &S)
     : ARMTargetStreamer(S), CurrentVendor("aeabi") {}
 };
 
void ARMTargetELFStreamer::switchVendor(StringRef Vendor) {
   assert(!Vendor.empty() && "Vendor cannot be empty.");
 
   if (CurrentVendor == Vendor)
     return;
 
   if (!CurrentVendor.empty())
     finishAttributeSection();
 
-  assert(Contents.empty() &&
+  assert(getStreamer().Contents.empty() &&
          ".ARM.attributes should be flushed before changing vendor");
   CurrentVendor = Vendor;
 
 }
 
 void ARMTargetELFStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
-  setAttributeItem(Attribute, Value, /* OverwriteExisting= */ true);
+  getStreamer().setAttributeItem(Attribute, Value,
+                                 /* OverwriteExisting= */ true);
 }
 
 void ARMTargetELFStreamer::emitTextAttribute(unsigned Attribute,
                                              StringRef Value) {
-  setAttributeItem(Attribute, Value, /* OverwriteExisting= */ true);
+  getStreamer().setAttributeItem(Attribute, Value,
+                                 /* OverwriteExisting= */ true);
 }
 
 void ARMTargetELFStreamer::emitIntTextAttribute(unsigned Attribute,
                                                 unsigned IntValue,
                                                 StringRef StringValue) {
-  setAttributeItems(Attribute, IntValue, StringValue,
+  getStreamer().setAttributeItems(Attribute, IntValue, StringValue,
                     /* OverwriteExisting= */ true);
 }
 
 void ARMTargetELFStreamer::emitArch(ARM::ArchKind Value) {
   Arch = Value;
 }
 
 void ARMTargetELFStreamer::emitObjectArch(ARM::ArchKind Value) {
   EmittedArch = Value;
 }
 
 void ARMTargetELFStreamer::emitArchDefaultAttributes() {
   using namespace ARMBuildAttrs;
+  ARMELFStreamer &S = getStreamer();
 
-  setAttributeItem(CPU_name,
+  S.setAttributeItem(CPU_name,
                      ARM::getCPUAttr(Arch),
                      false);
 
   if (EmittedArch == ARM::ArchKind::INVALID)
-    setAttributeItem(CPU_arch,
+    S.setAttributeItem(CPU_arch,
                        ARM::getArchAttr(Arch),
                        false);
   else
-    setAttributeItem(CPU_arch,
+    S.setAttributeItem(CPU_arch,
                        ARM::getArchAttr(EmittedArch),
                        false);
 
   switch (Arch) {
   case ARM::ArchKind::ARMV2:
   case ARM::ArchKind::ARMV2A:
   case ARM::ArchKind::ARMV3:
   case ARM::ArchKind::ARMV3M:
   case ARM::ArchKind::ARMV4:
-    setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
     break;
 
   case ARM::ArchKind::ARMV4T:
   case ARM::ArchKind::ARMV5T:
   case ARM::ArchKind::ARMV5TE:
   case ARM::ArchKind::ARMV6:
-    setAttributeItem(ARM_ISA_use, Allowed, false);
-    setAttributeItem(THUMB_ISA_use, Allowed, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, Allowed, false);
     break;
 
   case ARM::ArchKind::ARMV6T2:
-    setAttributeItem(ARM_ISA_use, Allowed, false);
-    setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
     break;
 
   case ARM::ArchKind::ARMV6K:
   case ARM::ArchKind::ARMV6KZ:
-    setAttributeItem(ARM_ISA_use, Allowed, false);
-    setAttributeItem(THUMB_ISA_use, Allowed, false);
-    setAttributeItem(Virtualization_use, AllowTZ, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, Allowed, false);
+    S.setAttributeItem(Virtualization_use, AllowTZ, false);
     break;
 
   case ARM::ArchKind::ARMV6M:
-    setAttributeItem(THUMB_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, Allowed, false);
     break;
 
   case ARM::ArchKind::ARMV7A:
-    setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
-    setAttributeItem(ARM_ISA_use, Allowed, false);
-    setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
+    S.setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
     break;
 
   case ARM::ArchKind::ARMV7R:
-    setAttributeItem(CPU_arch_profile, RealTimeProfile, false);
-    setAttributeItem(ARM_ISA_use, Allowed, false);
-    setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
+    S.setAttributeItem(CPU_arch_profile, RealTimeProfile, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
     break;
 
   case ARM::ArchKind::ARMV7EM:
   case ARM::ArchKind::ARMV7M:
-    setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
-    setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
+    S.setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
+    S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
     break;
 
   case ARM::ArchKind::ARMV8A:
   case ARM::ArchKind::ARMV8_1A:
   case ARM::ArchKind::ARMV8_2A:
   case ARM::ArchKind::ARMV8_3A:
   case ARM::ArchKind::ARMV8_4A:
   case ARM::ArchKind::ARMV8_5A:
   case ARM::ArchKind::ARMV8_6A:
-    setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
-    setAttributeItem(ARM_ISA_use, Allowed, false);
-    setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
-    setAttributeItem(MPextension_use, Allowed, false);
-    setAttributeItem(Virtualization_use, AllowTZVirtualization, false);
+    S.setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
+    S.setAttributeItem(MPextension_use, Allowed, false);
+    S.setAttributeItem(Virtualization_use, AllowTZVirtualization, false);
     break;
 
   case ARM::ArchKind::ARMV8MBaseline:
   case ARM::ArchKind::ARMV8MMainline:
-    setAttributeItem(THUMB_ISA_use, AllowThumbDerived, false);
-    setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
+    S.setAttributeItem(THUMB_ISA_use, AllowThumbDerived, false);
+    S.setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
     break;
 
   case ARM::ArchKind::IWMMXT:
-    setAttributeItem(ARM_ISA_use, Allowed, false);
-    setAttributeItem(THUMB_ISA_use, Allowed, false);
-    setAttributeItem(WMMX_arch, AllowWMMXv1, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, Allowed, false);
+    S.setAttributeItem(WMMX_arch, AllowWMMXv1, false);
     break;
 
   case ARM::ArchKind::IWMMXT2:
-    setAttributeItem(ARM_ISA_use, Allowed, false);
-    setAttributeItem(THUMB_ISA_use, Allowed, false);
-    setAttributeItem(WMMX_arch, AllowWMMXv2, false);
+    S.setAttributeItem(ARM_ISA_use, Allowed, false);
+    S.setAttributeItem(THUMB_ISA_use, Allowed, false);
+    S.setAttributeItem(WMMX_arch, AllowWMMXv2, false);
     break;
 
   default:
     report_fatal_error("Unknown Arch: " + Twine(ARM::getArchName(Arch)));
     break;
   }
 }
 
 void ARMTargetELFStreamer::emitFPU(unsigned Value) {
   FPU = Value;
 }
 
 void ARMTargetELFStreamer::emitFPUDefaultAttributes() {
+  ARMELFStreamer &S = getStreamer();
+
   switch (FPU) {
   case ARM::FK_VFP:
   case ARM::FK_VFPV2:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv2,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_VFPV3:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv3A,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_VFPV3_FP16:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv3A,
                        /* OverwriteExisting= */ false);
-    setAttributeItem(ARMBuildAttrs::FP_HP_extension,
+    S.setAttributeItem(ARMBuildAttrs::FP_HP_extension,
                        ARMBuildAttrs::AllowHPFP,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_VFPV3_D16:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv3B,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_VFPV3_D16_FP16:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv3B,
                        /* OverwriteExisting= */ false);
-    setAttributeItem(ARMBuildAttrs::FP_HP_extension,
+    S.setAttributeItem(ARMBuildAttrs::FP_HP_extension,
                        ARMBuildAttrs::AllowHPFP,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_VFPV3XD:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv3B,
                        /* OverwriteExisting= */ false);
     break;
   case ARM::FK_VFPV3XD_FP16:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv3B,
                        /* OverwriteExisting= */ false);
-    setAttributeItem(ARMBuildAttrs::FP_HP_extension,
+    S.setAttributeItem(ARMBuildAttrs::FP_HP_extension,
                        ARMBuildAttrs::AllowHPFP,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_VFPV4:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv4A,
                        /* OverwriteExisting= */ false);
     break;
 
   // ABI_HardFP_use is handled in ARMAsmPrinter, so _SP_D16 is treated the same
   // as _D16 here.
   case ARM::FK_FPV4_SP_D16:
   case ARM::FK_VFPV4_D16:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv4B,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_FP_ARMV8:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPARMv8A,
                        /* OverwriteExisting= */ false);
     break;
 
   // FPV5_D16 is identical to FP_ARMV8 except for the number of D registers, so
   // uses the FP_ARMV8_D16 build attribute.
   case ARM::FK_FPV5_SP_D16:
   case ARM::FK_FPV5_D16:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPARMv8B,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_NEON:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv3A,
                        /* OverwriteExisting= */ false);
-    setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
+    S.setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
                        ARMBuildAttrs::AllowNeon,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_NEON_FP16:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv3A,
                        /* OverwriteExisting= */ false);
-    setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
+    S.setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
                        ARMBuildAttrs::AllowNeon,
                        /* OverwriteExisting= */ false);
-    setAttributeItem(ARMBuildAttrs::FP_HP_extension,
+    S.setAttributeItem(ARMBuildAttrs::FP_HP_extension,
                        ARMBuildAttrs::AllowHPFP,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_NEON_VFPV4:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPv4A,
                        /* OverwriteExisting= */ false);
-    setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
+    S.setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
                        ARMBuildAttrs::AllowNeon2,
                        /* OverwriteExisting= */ false);
     break;
 
   case ARM::FK_NEON_FP_ARMV8:
   case ARM::FK_CRYPTO_NEON_FP_ARMV8:
-    setAttributeItem(ARMBuildAttrs::FP_arch,
+    S.setAttributeItem(ARMBuildAttrs::FP_arch,
                        ARMBuildAttrs::AllowFPARMv8A,
                        /* OverwriteExisting= */ false);
     // 'Advanced_SIMD_arch' must be emitted not here, but within
     // ARMAsmPrinter::emitAttributes(), depending on hasV8Ops() and hasV8_1a()
     break;
 
   case ARM::FK_SOFTVFP:
   case ARM::FK_NONE:
     break;
 
   default:
     report_fatal_error("Unknown FPU: " + Twine(FPU));
     break;
   }
 }
 
-size_t ARMTargetELFStreamer::calculateContentSize() const {
-  size_t Result = 0;
-  for (size_t i = 0; i < Contents.size(); ++i) {
-    AttributeItem item = Contents[i];
-    switch (item.Type) {
-    case AttributeItem::HiddenAttribute:
-      break;
-    case AttributeItem::NumericAttribute:
-      Result += getULEB128Size(item.Tag);
-      Result += getULEB128Size(item.IntValue);
-      break;
-    case AttributeItem::TextAttribute:
-      Result += getULEB128Size(item.Tag);
-      Result += item.StringValue.size() + 1; // string + '\0'
-      break;
-    case AttributeItem::NumericAndTextAttributes:
-      Result += getULEB128Size(item.Tag);
-      Result += getULEB128Size(item.IntValue);
-      Result += item.StringValue.size() + 1; // string + '\0';
-      break;
-    }
-  }
-  return Result;
-}
-
 void ARMTargetELFStreamer::finishAttributeSection() {
-  // <format-version>
-  // [ <section-length> "vendor-name"
-  // [ <file-tag> <size> <attribute>*
-  //   | <section-tag> <size> <section-number>* 0 <attribute>*
-  //   | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
-  //   ]+
-  // ]*
+  ARMELFStreamer &S = getStreamer();
 
   if (FPU != ARM::FK_INVALID)
     emitFPUDefaultAttributes();
 
   if (Arch != ARM::ArchKind::INVALID)
     emitArchDefaultAttributes();
 
-  if (Contents.empty())
+  if (S.Contents.empty())
     return;
 
-  llvm::sort(Contents, AttributeItem::LessTag);
-
-  ARMELFStreamer &Streamer = getStreamer();
-
-  // Switch to .ARM.attributes section
-  if (AttributeSection) {
-    Streamer.SwitchSection(AttributeSection);
-  } else {
-    AttributeSection = Streamer.getContext().getELFSection(
-        ".ARM.attributes", ELF::SHT_ARM_ATTRIBUTES, 0);
-    Streamer.SwitchSection(AttributeSection);
-
-    // Format version
-    Streamer.emitInt8(0x41);
-  }
-
-  // Vendor size + Vendor name + '\0'
-  const size_t VendorHeaderSize = 4 + CurrentVendor.size() + 1;
-
-  // Tag + Tag Size
-  const size_t TagHeaderSize = 1 + 4;
-
-  const size_t ContentsSize = calculateContentSize();
-
-  Streamer.emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
-  Streamer.emitBytes(CurrentVendor);
-  Streamer.emitInt8(0); // '\0'
-
-  Streamer.emitInt8(ARMBuildAttrs::File);
-  Streamer.emitInt32(TagHeaderSize + ContentsSize);
+  auto LessTag = [](const MCELFStreamer::AttributeItem &LHS,
+                    const MCELFStreamer::AttributeItem &RHS) -> bool {
+    // The conformance tag must be emitted first when serialised into an
+    // object file. Specifically, the addenda to the ARM ABI states that
+    // (2.3.7.4):
+    //
+    // "To simplify recognition by consumers in the common case of claiming
+    // conformity for the whole file, this tag should be emitted first in a
+    // file-scope sub-subsection of the first public subsection of the
+    // attributes section."
+    //
+    // So it is special-cased in this comparison predicate when the
+    // attributes are sorted in finishAttributeSection().
+    return (RHS.Tag != ARMBuildAttrs::conformance) &&
+      ((LHS.Tag == ARMBuildAttrs::conformance) || (LHS.Tag < RHS.Tag));
+  };
+  llvm::sort(S.Contents, LessTag);
 
-  // Size should have been accounted for already, now
-  // emit each field as its type (ULEB or String)
-  for (size_t i = 0; i < Contents.size(); ++i) {
-    AttributeItem item = Contents[i];
-    Streamer.emitULEB128IntValue(item.Tag);
-    switch (item.Type) {
-    default: llvm_unreachable("Invalid attribute type");
-    case AttributeItem::NumericAttribute:
-      Streamer.emitULEB128IntValue(item.IntValue);
-      break;
-    case AttributeItem::TextAttribute:
-      Streamer.emitBytes(item.StringValue);
-      Streamer.emitInt8(0); // '\0'
-      break;
-    case AttributeItem::NumericAndTextAttributes:
-      Streamer.emitULEB128IntValue(item.IntValue);
-      Streamer.emitBytes(item.StringValue);
-      Streamer.emitInt8(0); // '\0'
-      break;
-    }
-  }
+  S.emitAttributesSection(CurrentVendor, ".ARM.attributes",
+                          ELF::SHT_ARM_ATTRIBUTES, AttributeSection);
 
-  Contents.clear();
   FPU = ARM::FK_INVALID;
 }
 
 void ARMTargetELFStreamer::emitLabel(MCSymbol *Symbol) {
   ARMELFStreamer &Streamer = getStreamer();
   if (!Streamer.IsThumb)
     return;
 

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

 //===-- SystemZAsmParser.cpp - Parse SystemZ assembly instructions --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "SystemZTargetStreamer.h"
 #include "MCTargetDesc/SystemZInstPrinter.h"
 #include "MCTargetDesc/SystemZMCAsmInfo.h"
 #include "MCTargetDesc/SystemZMCTargetDesc.h"
 #include "TargetInfo/SystemZTargetInfo.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
enum RegisterGroup {
     RegCR
   };
   struct Register {
     RegisterGroup Group;
     unsigned Num;
     SMLoc StartLoc, EndLoc;
   };
 
+  SystemZTargetStreamer &getTargetStreamer() {
+    assert(getParser().getStreamer().getTargetStreamer() &&
+           "do not have a target streamer");
+    MCTargetStreamer &TS = *getParser().getStreamer().getTargetStreamer();
+    return static_cast<SystemZTargetStreamer &>(TS);
+  }
+
   bool parseRegister(Register &Reg, bool RestoreOnFailure = false);
 
   bool parseIntegerRegister(Register &Reg, RegisterGroup Group);
 
   OperandMatchResultTy parseRegister(OperandVector &Operands,
                                      RegisterKind Kind);
 
   OperandMatchResultTy parseAnyRegister(OperandVector &Operands);
 
   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 ParseGNUAttribute(SMLoc L);
 
   OperandMatchResultTy parseAddress(OperandVector &Operands,
                                     MemoryKind MemKind,
                                     RegisterKind RegKind);
 
   OperandMatchResultTy parsePCRel(OperandVector &Operands, int64_t MinVal,
                                   int64_t MaxVal, bool AllowTLS);
 
SystemZAsmParser::parseAddress(OperandVector &Operands, MemoryKind MemKind,
   return MatchOperand_Success;
 }
 
 bool SystemZAsmParser::ParseDirective(AsmToken DirectiveID) {
   StringRef IDVal = DirectiveID.getIdentifier();
 
   if (IDVal == ".insn")
     return ParseDirectiveInsn(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::ParseDirectiveInsn(SMLoc L) {
   }
 
   // Emit as a regular instruction.
   Parser.getStreamer().emitInstruction(Inst, getSTI());
 
   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/MCTargetDesc/SystemZMCTargetDesc.cpp

 //===-- SystemZMCTargetDesc.cpp - SystemZ target descriptions -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SystemZMCTargetDesc.h"
 #include "SystemZInstPrinter.h"
 #include "SystemZMCAsmInfo.h"
+#include "SystemZTargetStreamer.h"
 #include "TargetInfo/SystemZTargetInfo.h"
 #include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/TargetRegistry.h"
 
 using namespace llvm;
 

 static MCInstPrinter *createSystemZMCInstPrinter(const Triple &T,
                                                  unsigned SyntaxVariant,
                                                  const MCAsmInfo &MAI,
                                                  const MCInstrInfo &MII,
                                                  const MCRegisterInfo &MRI) {
   return new SystemZInstPrinter(MAI, MII, MRI);
 }
 
+class SystemZTargetAsmStreamer : public SystemZTargetStreamer {
+  formatted_raw_ostream &OS;
+
+public:
+  SystemZTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS)
+    : SystemZTargetStreamer(S), OS(OS) {}
+  void finishAttributeSection() override {}
+};
+
+class SystemZTargetELFStreamer : public SystemZTargetStreamer {
+  MCELFStreamer &getStreamer() { return static_cast<MCELFStreamer &>(Streamer); }
+
+public:
+  SystemZTargetELFStreamer(MCStreamer &S) : SystemZTargetStreamer(S) {}
+  void finishAttributeSection() override {
+    MCSection *AttributeSection = nullptr;
+    getStreamer().emitGNUAttributesSection(AttributeSection);
+  }
+  void finish() override { finishAttributeSection(); }
+};
+
+static MCTargetStreamer *
+createAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS,
+                        MCInstPrinter *InstPrint, bool isVerboseAsm) {
+  return new SystemZTargetAsmStreamer(S, OS);
+}
+
+static MCTargetStreamer *
+createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
+    return new SystemZTargetELFStreamer(S);
+}
+
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSystemZTargetMC() {
   // Register the MCAsmInfo.
   TargetRegistry::RegisterMCAsmInfo(getTheSystemZTarget(),
                                     createSystemZMCAsmInfo);
 
   // Register the MCCodeEmitter.
   TargetRegistry::RegisterMCCodeEmitter(getTheSystemZTarget(),
                                         createSystemZMCCodeEmitter);
extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSystemZTargetMC() {
 
   // Register the MCAsmBackend.
   TargetRegistry::RegisterMCAsmBackend(getTheSystemZTarget(),
                                        createSystemZMCAsmBackend);
 
   // Register the MCInstPrinter.
   TargetRegistry::RegisterMCInstPrinter(getTheSystemZTarget(),
                                         createSystemZMCInstPrinter);
+
+  // Register the asm streamer.
+  TargetRegistry::RegisterAsmTargetStreamer(getTheSystemZTarget(),
+                                            createAsmTargetStreamer);
+
+  // Register the obj streamer
+  TargetRegistry::RegisterObjectTargetStreamer(getTheSystemZTarget(),
+                                               createObjectTargetStreamer);
 }

llvm/lib/Target/SystemZ/SystemZAsmPrinter.h

bool doInitialization(Module &M) override {
     SM.reset();
     return AsmPrinter::doInitialization(M);
   }
 
 private:
   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

 // MCInsts and MCExprs respectively.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SystemZAsmPrinter.h"
 #include "MCTargetDesc/SystemZInstPrinter.h"
 #include "SystemZConstantPoolValue.h"
 #include "SystemZMCInstLower.h"
+#include "SystemZTargetStreamer.h"
 #include "TargetInfo/SystemZTargetInfo.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/MCSectionELF.h"
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/hardware vector ABIs.
+bool static isVectorOrVectorPtrType(Type *Ty) {
+  if (Ty->isVectorTy())
+    return true;
+  if (auto *PTy = dyn_cast<PointerType>(Ty))
+    return isVectorOrVectorPtrType(PTy->getElementType());
+  return false;
+}
+
+void SystemZAsmPrinter::emitAttributes(Module &M) {
+  bool HasVectorABI = false;
+  for (const GlobalValue &GV : M.global_values()) {
+    if (!GV.hasLocalLinkage() && (!GV.isDeclaration() || !GV.use_empty())) {
+      if (const Function *F = dyn_cast<Function>(&GV)) {
+        FunctionType *FTy = F->getFunctionType();
+        if (isVectorOrVectorPtrType(FTy->getReturnType()))
+          HasVectorABI = true;
+        else {
+          for (auto ParamTy : FTy->params())
+            if (isVectorOrVectorPtrType(ParamTy)) {
+              HasVectorABI = true;
+              break;
+            }
+        }
+        if (!HasVectorABI && FTy->isVarArg()) {
+          for (auto U : F->users()) {
+            if (auto *CI = dyn_cast<CallInst>(&*U)) {
+              for (const Use &Arg : CI->args())
+                if (isVectorOrVectorPtrType(Arg->getType())) {
+                  HasVectorABI = true;
+                  break;
+                }
+            }
+            if (HasVectorABI)
+              break;
+          }
+        }
+      }
+      else if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV))
+        if (isVectorOrVectorPtrType(GVar->getValueType()))
+          HasVectorABI = true;
+
+      if (HasVectorABI)
+        break;
+    }
+  }
+
+  if (HasVectorABI) {
+    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;
bool SystemZAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
                                               raw_ostream &OS) {
   SystemZInstPrinter::printAddress(MAI, MI->getOperand(OpNo).getReg(),
                                    MI->getOperand(OpNo + 1).getImm(),
                                    MI->getOperand(OpNo + 2).getReg(), OS);
   return false;
 }
 
 void SystemZAsmPrinter::emitEndOfAsmFile(Module &M) {
+  emitAttributes(M);
   emitStackMaps(SM);
 }
 
 // Force static initialization.
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSystemZAsmPrinter() {
   RegisterAsmPrinter<SystemZAsmPrinter> X(getTheSystemZTarget());
 }

llvm/lib/Target/SystemZ/SystemZTargetStreamer.h

+//=- SystemZTargetStreamer.h - SystemZ Target Streamer ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZTARGETSTREAMER_H
+#define LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZTARGETSTREAMER_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCStreamer.h"
+
+namespace llvm {
+
+class SystemZTargetStreamer : public MCTargetStreamer {
+public:
+  SystemZTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
+
+  virtual void finishAttributeSection() = 0;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZTARGETSTREAMER_H

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-00.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch13 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Call to external function with vector argument.
+define internal void @fun() {
+entry:
+  tail call void @foo(<4 x i32> zeroinitializer)
+  ret void
+}
+
+declare void @foo(<4 x i32>)
+
+; CHECK: .gnu_attribute 8, 2

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-01.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch13 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Call to external function with vector return value.
+define internal void @fun() {
+entry:
+  %indirect-arg-temp = alloca <4 x i32>, align 16
+  %C = call <4 x i32> @foo()
+  store <4 x i32> %C, <4 x i32>* %indirect-arg-temp
+  ret void
+}
+
+declare <4 x i32> @foo()
+
+; CHECK: .gnu_attribute 8, 2

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-02.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch13 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Call to external function *without* vector arguments.
+define internal void @fun() {
+entry:
+  tail call void @foo(i64 0)
+  ret void
+}
+
+declare void @foo(i64)
+
+; CHECK-NOT: .gnu_attribute 8

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-03.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch13 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Defining globally visible function with vector arguments.
+define <4 x i32> @fun(<4 x i32> %Arg) {
+entry:
+  ret <4 x i32> %Arg
+}
+
+; CHECK: .gnu_attribute 8, 2

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-04.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch13 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Calling globally visible function with vector parameter.
+define void @fun() {
+entry:
+  tail call void @foo(<4 x i32> zeroinitializer)
+  ret void
+}
+
+declare void @foo(<4 x i32>)
+
+; CHECK: .gnu_attribute 8, 2

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-05.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch10 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Globally visible vector variable.
+@VisibleVector = global <4 x i32> zeroinitializer
+
+; CHECK: .gnu_attribute 8, 1

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-06.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch13 < %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Using external vector variable.
+@ExtVector = external global <4 x i32>
+
+define void @fun() {
+entry:
+  store <4 x i32> zeroinitializer, <4 x i32>* @ExtVector
+  ret void
+}
+
+; CHECK: .gnu_attribute 8, 2

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-07.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch13 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Using local vector variable.
+@LocVector = internal global <4 x i32> zeroinitializer
+
+define void @fun() {
+entry:
+  store volatile <4 x i32> zeroinitializer, <4 x i32>* @LocVector
+  ret void
+}
+
+; CHECK-NOT: .gnu_attribute 8

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-08.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch10 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Calling local function with vector return value.
+define void @fun() {
+entry:
+  %indirect-arg-temp = alloca <4 x i32>, align 16
+  store <4 x i32> zeroinitializer, <4 x i32>* %indirect-arg-temp
+  call void @foo(<4 x i32>* nonnull %indirect-arg-temp)
+  ret void
+}
+
+define internal void @foo(<4 x i32>*) { ret void }
+
+; CHECK-LABEL: fun:
+; CHECK-NOT: .gnu_attribute 8

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-09.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch10 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Call to vararg function *without* any vector argument.
+define internal void @fun() {
+entry:
+  call void (...) @foo()
+  ret void
+}
+
+declare void @foo(...)
+
+; CHECK-NOT: .gnu_attribute 8

llvm/test/CodeGen/SystemZ/vec-abi-gnuattr-10.ll

+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=arch13 < %s | FileCheck %s
+;
+; Test the emission of a .gnu_attribute describing the vector abi.
+
+; Call to vararg function with a vector argument.
+define internal void @fun() {
+entry:
+  call void (...) @foo(<2 x i64> zeroinitializer)
+  ret void
+}
+
+declare void @foo(...)
+
+; CHECK: .gnu_attribute 8, 2

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