Allow attributes with global variables

[javed.absar]

Summary

This patch extends llvm-ir to allow attributes to be set on global variables.

An RFC was sent out earlier by my colleague James Molloy: http://lists.llvm.org/pipermail/cfe-dev/2017-March/053100.html

A key part of that proposal was to extend LLVM-IR to carry attributes on global variables. This generic feature could be useful for multiple purposes. In our present context, it would be useful to carry user specified sections for bss/rodata/data.

[tobiasvk]

This is very useful, thanks for working on it!

I believe there are some passes that may not currently call GV::copyAttributesFrom when they probably should be (GlobalOpt has some cases IIRC), but that can be looked into when you actually implement the proposed section attributes.

include/llvm/IR/GlobalVariable.h

208

hasAttribute() functions would be useful here (I see you already have them in SingleSlotAttributeList).

[jroelofs]

include/llvm/IR/Attributes.h

567

I think autobrief has been turned on, so no need for \brief on any of these.

[jmolloy]

Hi,

It looks good to me, but it would as I wrote this particular patch originally :) For that reason I can't effectively review it, so I'll resign.

James

[javed.absar]

Thanks Jonathan/Tobias for the review.
I have removed 'brief' as suggested. Please have a look.
Best Regards, Javed.

[jroelofs]

Sorry I didn't spot these earlier, but...

include/llvm/IR/Attributes.h

568

Usage of this encourages a lot of: getAttributes().getAttributes() which seems odd. @jmolloy/@javed.absar did you consider making this an operator->()?

Either way, shouldn't this return by reference, and not value (avoiding the copy)?

include/llvm/IR/GlobalVariable.h

204

Should this be return by reference instead of value (avoiding the copy)?

[javed.absar]

include/llvm/IR/Attributes.h

568

The AttributeList is thin (containing pointer to impl), so should not be a problem passing around by value. Other usages e.g. class Function handles AttributeList similarly by passing it around by value.

include/llvm/IR/GlobalVariable.h

204

Same point as above.

208

Yes, sorry missed this. Will add them soon and send new patch

[jroelofs]

include/llvm/IR/Attributes.h

568

Oh, ok. Cool.

[javed.absar]

Hi.
I have now added the hasAttribute functions to GV as suggested. Thanks for catching this.
Best Regards
Javed

[jroelofs]

LGTM

[rnk]

I don't think we need a new SingleSlotAttributeList type, we already have AttributeSet for that. Feel free to add more helpers to that to implement addAttribute etc.

include/llvm/IR/Attributes.h

550

How is this not just an AttributeSet, now that we have that?

[pcc]

Could this help us solve PR31759? I think not, because for !type metadata, attributes as they are currently implemented would not be sufficient, because they cannot be used to represent entities with "internal linkage", as is currently possible with a distinct MDNode.

So I am mildly opposed to this as it stands, and would prefer that we come up with a single representation for non-opaque global attachments that would be sufficient for !type and !absolute_symbol as well as for sections.

[javed.absar]

Thanks Reid for the AttributeSet. I have added helpers to it and made changes to my implementation to use it. Please have a look.

[javed.absar]

ping!

[javed.absar]

Hi Reid:
Please could you have a look at the patch and let me know if its ok now.
Thanks.

[javed.absar]

ping!

[javed.absar]

ping! Reid/Jonathan?

[jroelofs]

A few nits, otherwise LGTM.

lib/AsmParser/LLParser.cpp

974

Too many spaces before this }

lib/Bitcode/Reader/BitcodeReader.cpp

2834

12 ) --> 12)

lib/Bitcode/Writer/BitcodeWriter.cpp

655

Delete the extra newline.

lib/Bitcode/Writer/ValueEnumerator.cpp

321

if ( GV --> if (GV

lib/IR/Attributes.cpp

619 ↗

(On Diff #97876)

The declaration for this one must have matching #if guards.

docs/LangRef.rst

 convenient. If an explicit alignment is specified, the global is forced
 to have exactly that alignment. Targets and optimizers are not allowed
 to over-align the global if the global has an assigned section. In this
 case, the extra alignment could be observable: for example, code could
 assume that the globals are densely packed in their section and try to
 iterate over them as an array, alignment padding would break this
 iteration. The maximum alignment is ``1 << 29``.
 
-Globals can also have a :ref:`DLL storage class <dllstorageclass>` and
-an optional list of attached :ref:`metadata <metadata>`,
+Globals can also have a :ref:`DLL storage class <dllstorageclass>`,
+an optional :ref:`global attributes <glattrs>`, and
+an optional list of attached :ref:`metadata <metadata>`.
 
 Variables and aliases can have a
 :ref:`Thread Local Storage Model <tls_model>`.
 
 Syntax::
 
       @<GlobalVarName> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
                          [(unnamed_addr|local_unnamed_addr)] [AddrSpace]
``"thunk"``
     match the thunk target prototype.
 ``uwtable``
     This attribute indicates that the ABI being targeted requires that
     an unwind table entry be produced for this function even if we can
     show that no exceptions passes by it. This is normally the case for
     the ELF x86-64 abi, but it can be disabled for some compilation
     units.
 
+.. _glattrs:
+
+Global Attributes
+-------------------
+
+Attributes may be set to communicate additional information about a global variable.
+Unlike :ref:`function attributes <fnattrs>`, attributes on a global variable
+are grouped into a single :ref:`attribute group <attrgrp>`.
 
 .. _opbundles:
 
 Operand Bundles
 ---------------
 
 Operand bundles are tagged sets of SSA values that can be associated
 with certain LLVM instructions (currently only ``call`` s and

include/llvm/IR/Attributes.h

template <> struct DenseMapInfo<AttributeList> {
 
   static bool isEqual(AttributeList LHS, AttributeList RHS) {
     return LHS == RHS;
   }
 };
 
 //===----------------------------------------------------------------------===//
 /// \class
+/// \brief This is a restricted interface to AttributeList for GlobalVariables.
+/// This allows reuse of the underlying AttributeList unification mechanisms
+/// but only supports one slot index.
+template<unsigned Idx>
+class SingleSlotAttributeList {
+  AttributeList Impl;
+
+public:
+  enum AttrIndex : unsigned {
+    Index = Idx
+  };
+
+  static SingleSlotAttributeList<Idx> get(LLVMContext &C, AttrBuilder &B) {
+    return AttributeList::get(C, Index, B);
+  }
+
+  SingleSlotAttributeList() = default;
+  SingleSlotAttributeList(AttributeList Impl) : Impl(Impl) {
+    assert(Impl.getNumSlots() <= 1 && "can contain only single slot");
+  }
+
+  /// \brief The function attributes are returned.
+  AttributeList getAttributes() const { return Impl; }
+
+  /// \brief Add an attribute to the attribute set at the given index. Because
+  /// attribute sets are immutable, this returns a new set.
+  SingleSlotAttributeList<Idx> addAttribute(LLVMContext &C,
+                                            Attribute::AttrKind Kind) const {
+    return Impl.addAttribute(C, Idx, Kind);
+  }
+
+  /// \brief Add an attribute to the attribute set at the given index. Because
+  /// attribute sets are immutable, this returns a new set.
+  SingleSlotAttributeList<Idx> addAttribute(LLVMContext &C, StringRef Kind,
+                             StringRef Value = StringRef()) const {
+    return Impl.addAttribute(C, Idx, Kind, Value);
+  }
+
+  /// Add an attribute to the attribute set at the given indices. Because
+  /// attribute sets are immutable, this returns a new set.
+  SingleSlotAttributeList<Idx> addAttribute(LLVMContext &C, Attribute A) const {
+    return Impl.addAttribute(C, makeArrayRef<unsigned>(Idx), A);
+  }
+
+  /// \brief Add attributes to the attribute set at the given index. Because
+  /// attribute sets are immutable, this returns a new set.
+  SingleSlotAttributeList<Idx> addAttributes(LLVMContext &C,
+                              AttributeList Attrs) const {
+    return Impl.addAttributes(C, Idx, Attrs);
+  }
+
+  /// \brief Return true if the attribute exists.
+  bool hasAttribute(Attribute::AttrKind Kind) const {
+    return Impl.hasAttribute(Idx, Kind);
+  }
+
+  /// \brief Return true if the attribute exists.
+  bool hasAttribute(StringRef Kind) const {
+    return Impl.hasAttribute(Idx, Kind);
+  }
+
+  /// \brief Return true if any attributes exist.
+  bool hasAttributes() const {
+    return Impl.hasAttributes(Idx);
+  }
+
+  /// \brief Return the given attribute object.
+  Attribute getAttribute(Attribute::AttrKind Kind) const {
+    return Impl.getAttribute(Idx, Kind);
+  }
+
+  /// \brief Return the given attribute object.
+  Attribute getAttribute(StringRef Kind) const {
+    return Impl.getAttribute(Idx, Kind);
+  }
+};
+
+//===----------------------------------------------------------------------===//
+/// \class
 /// \brief This class is used in conjunction with the Attribute::get method to
 /// create an Attribute object. The object itself is uniquified. The Builder's
 /// value, however, is not. So this can be used as a quick way to test for
 /// equality, presence of attributes, etc.
 class AttrBuilder {
   std::bitset<Attribute::EndAttrKinds> Attrs;
   std::map<std::string, std::string> TargetDepAttrs;
   uint64_t Alignment = 0;

include/llvm/IR/GlobalVariable.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_GLOBALVARIABLE_H
 #define LLVM_IR_GLOBALVARIABLE_H
 
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/ilist_node.h"
+#include "llvm/IR/Attributes.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/Value.h"
 #include <cassert>
 #include <cstddef>
 
 namespace llvm {
 
 class Constant;
 class Module;
 
 template <typename ValueSubClass> class SymbolTableListTraits;
 class DIGlobalVariable;
 class DIGlobalVariableExpression;
 
 class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> {
+public:
+  typedef SingleSlotAttributeList<AttributeList::FunctionIndex> AttributeListType;
+protected:
   friend class SymbolTableListTraits<GlobalVariable>;
 
+  AttributeListType Attrs;
   bool isConstantGlobal : 1;                   // Is this a global constant?
   bool isExternallyInitializedConstant : 1;    // Is this a global whose value
                                                // can change from its initial
                                                // value before global
                                                // initializers are run?
-
 public:
   /// GlobalVariable ctor - If a parent module is specified, the global is
   /// automatically inserted into the end of the specified modules global list.
   GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,
                  Constant *Initializer = nullptr, const Twine &Name = "",
                  ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
                  bool isExternallyInitialized = false);
   /// GlobalVariable ctor - This creates a global and inserts it before the
public:
   void dropAllReferences();
 
   /// Attach a DIGlobalVariableExpression.
   void addDebugInfo(DIGlobalVariableExpression *GV);
 
   /// Fill the vector with all debug info attachements.
   void getDebugInfo(SmallVectorImpl<DIGlobalVariableExpression *> &GVs) const;
 
+  /// Add attributes to this global.
+  void addAttribute(Attribute::AttrKind Kind) {
+    Attrs = Attrs.addAttribute(getContext(), Kind);
+  }
+
+  /// Add attributes to this global.
+  void addAttribute(StringRef Kind, StringRef Val = StringRef()) {
+    Attrs = Attrs.addAttribute(getContext(), Attribute::get(getContext(), Kind, Val));
+  }
+
+  Attribute getAttribute(Attribute::AttrKind Kind) const {
+    return Attrs.getAttribute(Kind);
+  }
+
+  Attribute getAttribute(StringRef Kind) const {
+    return Attrs.getAttribute(Kind);
+  }
+
+  /// Return the attribute list for this global
+  AttributeListType getAttributes() const { return Attrs; }
+
+  /// Set attribute list for this global
+  void setAttributes(AttributeListType A) { Attrs = A; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalVariableVal;
   }
 };
 
 template <>
 struct OperandTraits<GlobalVariable> :
   public OptionalOperandTraits<GlobalVariable> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalVariable, Value)
 
 } // end namespace llvm
 
 #endif // LLVM_IR_GLOBALVARIABLE_H

lib/AsmParser/LLParser.cpp

if (Function *Fn = dyn_cast<Function>(V)) {
       AttributeList AS = II->getAttributes();
       AttrBuilder FnAttrs(AS.getFnAttributes());
       AS = AS.removeAttributes(Context, AttributeList::FunctionIndex);
       FnAttrs.merge(B);
       AS = AS.addAttributes(
           Context, AttributeList::FunctionIndex,
           AttributeList::get(Context, AttributeList::FunctionIndex, FnAttrs));
       II->setAttributes(AS);
+   } else if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
+      auto OrigAS = GV->getAttributes();
+      GlobalVariable::AttributeListType NewAS;
+      const auto GlobalVariableIndex = GlobalVariable::AttributeListType::Index;
+
+      AttrBuilder Attrs(OrigAS.getAttributes(), GlobalVariableIndex);
+      Attrs.merge(B);
+      auto AL = AttributeList::get(Context, GlobalVariableIndex, Attrs);
+
+      GV->setAttributes(NewAS.addAttributes(Context, AL));
     } else {
       llvm_unreachable("invalid object with forward attribute group reference");
     }
   }
 
   // If there are entries in ForwardRefBlockAddresses at this point, the
   // function was never defined.
   if (!ForwardRefBlockAddresses.empty())
bool LLParser::parseIndirectSymbol(
   GA.release();
 
   return false;
 }
 
 /// ParseGlobal
 ///   ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
-///       OptionalExternallyInitialized GlobalType Type Const
+///       OptionalExternallyInitialized GlobalType Type Const OptionalAttrs
 ///   ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
-///       OptionalExternallyInitialized GlobalType Type Const
+///       OptionalExternallyInitialized GlobalType Type Const OptionalAttrs
 ///
 /// Everything up to and including OptionalUnnamedAddr has been parsed
 /// already.
 ///
 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
                            unsigned Linkage, bool HasLinkage,
                            unsigned Visibility, unsigned DLLStorageClass,
                            GlobalVariable::ThreadLocalMode TLM,
if (Lex.getKind() == lltok::kw_section) {
         return true;
       if (C)
         GV->setComdat(C);
       else
         return TokError("unknown global variable property!");
     }
   }
 
+  // Parse attributes
+  AttrBuilder Attrs;
+  LocTy BuiltinLoc;
+  std::vector<unsigned> FwdRefAttrGrps;
+  if (ParseFnAttributeValuePairs(Attrs, FwdRefAttrGrps, false, BuiltinLoc))
+    return true;
+
+  if (Attrs.hasAttributes() || !FwdRefAttrGrps.empty()) {
+    GV->setAttributes(GlobalVariable::AttributeListType::get(Context, Attrs));
+    ForwardRefAttrGroups[GV] = FwdRefAttrGrps;
+  }
+
   return false;
 }
 
 /// ParseUnnamedAttrGrp
 ///   ::= 'attributes' AttrGrpID '=' '{' AttrValPair+ '}'
 bool LLParser::ParseUnnamedAttrGrp() {
   assert(Lex.getKind() == lltok::kw_attributes);
   LocTy AttrGrpLoc = Lex.getLoc();

lib/Bitcode/Reader/BitcodeReader.cpp

       std::string ComdatName;
       ComdatName.reserve(ComdatNameSize);
       for (unsigned i = 0; i != ComdatNameSize; ++i)
         ComdatName += (char)Record[2 + i];
       Comdat *C = TheModule->getOrInsertComdat(ComdatName);
       C->setSelectionKind(SK);
       ComdatList.push_back(C);
       break;
     }
     // GLOBALVAR: [pointer type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
-    //             comdat]
+    //             comdat, attributes]
     case bitc::MODULE_CODE_GLOBALVAR: {
       if (Record.size() < 6)
         return error("Invalid record");
       Type *Ty = getTypeByID(Record[0]);
       if (!Ty)
         return error("Invalid record");
       bool isConstant = Record[1] & 1;
       bool explicitType = Record[1] & 2;

         if (unsigned ComdatID = Record[11]) {
           if (ComdatID > ComdatList.size())
             return error("Invalid global variable comdat ID");
           NewGV->setComdat(ComdatList[ComdatID - 1]);
         }
       } else if (hasImplicitComdat(RawLinkage)) {
         NewGV->setComdat(reinterpret_cast<Comdat *>(1));
       }
+      if (Record.size() > 12) {
+        NewGV->setAttributes(getAttributes(Record[12]));
+      }
 
       break;
     }
     // FUNCTION:  [type, callingconv, isproto, linkage, paramattr,
     //             alignment, section, visibility, gc, unnamed_addr,
     //             prologuedata, dllstorageclass, comdat, prefixdata]
     case bitc::MODULE_CODE_FUNCTION: {
       if (Record.size() < 8)

lib/Bitcode/Writer/BitcodeWriter.cpp

   case Attribute::NoDuplicate:
     return bitc::ATTR_KIND_NO_DUPLICATE;
   case Attribute::NoImplicitFloat:
     return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT;
   case Attribute::NoInline:
     return bitc::ATTR_KIND_NO_INLINE;
   case Attribute::NoRecurse:
     return bitc::ATTR_KIND_NO_RECURSE;
   case Attribute::NonLazyBind:
     return bitc::ATTR_KIND_NON_LAZY_BIND;
   case Attribute::NonNull:
     return bitc::ATTR_KIND_NON_NULL;
   case Attribute::Dereferenceable:
     return bitc::ATTR_KIND_DEREFERENCEABLE;
   case Attribute::DereferenceableOrNull:
     return bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL;
   case Attribute::NoRedZone:

   // Emit the global variable information.
   SmallVector<unsigned, 64> Vals;
   for (const GlobalVariable &GV : M.globals()) {
     unsigned AbbrevToUse = 0;
 
     // GLOBALVAR: [type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
-    //             comdat]
+    //             comdat, attributes]
     Vals.push_back(VE.getTypeID(GV.getValueType()));
     Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
     Vals.push_back(GV.isDeclaration() ? 0 :
                    (VE.getValueID(GV.getInitializer()) + 1));
     Vals.push_back(getEncodedLinkage(GV));
     Vals.push_back(Log2_32(GV.getAlignment())+1);
     Vals.push_back(GV.hasSection() ? SectionMap[GV.getSection()] : 0);
     if (GV.isThreadLocal() ||
         GV.getVisibility() != GlobalValue::DefaultVisibility ||
         GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||
         GV.isExternallyInitialized() ||
         GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
-        GV.hasComdat()) {
+        GV.hasComdat() ||
+        GV.getAttributes().hasAttributes()) {
       Vals.push_back(getEncodedVisibility(GV));
       Vals.push_back(getEncodedThreadLocalMode(GV));
       Vals.push_back(getEncodedUnnamedAddr(GV));
       Vals.push_back(GV.isExternallyInitialized());
       Vals.push_back(getEncodedDLLStorageClass(GV));
       Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
+      Vals.push_back(VE.getAttributeID(GV.getAttributes().getAttributes()));
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }
 
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
 

lib/Bitcode/Writer/ValueEnumerator.cpp

ValueEnumerator::ValueEnumerator(const Module &M,
   // Enumerate the ifuncs.
   for (const GlobalIFunc &GIF : M.ifuncs())
     EnumerateValue(&GIF);
 
   // Remember what is the cutoff between globalvalue's and other constants.
   unsigned FirstConstant = Values.size();
 
   // Enumerate the global variable initializers.
-  for (const GlobalVariable &GV : M.globals())
+  for (const GlobalVariable &GV : M.globals()) {
     if (GV.hasInitializer())
       EnumerateValue(GV.getInitializer());
+    EnumerateAttributes(GV.getAttributes().getAttributes());
+  }
 
   // Enumerate the aliasees.
   for (const GlobalAlias &GA : M.aliases())
     EnumerateValue(GA.getAliasee());
 
   // Enumerate the ifunc resolvers.
   for (const GlobalIFunc &GIF : M.ifuncs())
     EnumerateValue(GIF.getResolver());

lib/IR/AsmWriter.cpp

 void SlotTracker::processModule() {
   ST_DEBUG("begin processModule!\n");
 
   // Add all of the unnamed global variables to the value table.
   for (const GlobalVariable &Var : TheModule->globals()) {
     if (!Var.hasName())
       CreateModuleSlot(&Var);
     processGlobalObjectMetadata(Var);
+    auto Attrs = Var.getAttributes();
+    if (Attrs.hasAttributes())
+      CreateAttributeSetSlot(Attrs.getAttributes().getFnAttributes());
   }
 
   for (const GlobalAlias &A : TheModule->aliases()) {
     if (!A.hasName())
       CreateModuleSlot(&A);
   }
 
   for (const GlobalIFunc &I : TheModule->ifuncs()) {
void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
   maybePrintComdat(Out, *GV);
   if (GV->getAlignment())
     Out << ", align " << GV->getAlignment();
 
   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
   GV->getAllMetadata(MDs);
   printMetadataAttachments(MDs, ", ");
 
+  auto Attrs = GV->getAttributes();
+  if (Attrs.hasAttributes())
+    Out << " #" << Machine.getAttributeGroupSlot(Attrs.getAttributes().getFnAttributes());
+
   printInfoComment(*GV);
 }
 
 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
   if (GIS->isMaterializable())
     Out << "; Materializable\n";
 
   WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());

lib/IR/Globals.cpp

 
 /// Copy all additional attributes (those not needed to create a GlobalVariable)
 /// from the GlobalVariable Src to this one.
 void GlobalVariable::copyAttributesFrom(const GlobalValue *Src) {
   GlobalObject::copyAttributesFrom(Src);
   if (const GlobalVariable *SrcVar = dyn_cast<GlobalVariable>(Src)) {
     setThreadLocalMode(SrcVar->getThreadLocalMode());
     setExternallyInitialized(SrcVar->isExternallyInitialized());
+    setAttributes(SrcVar->getAttributes());
   }
 }
 
 void GlobalVariable::dropAllReferences() {
   User::dropAllReferences();
   clearMetadata();
 }
 

test/Assembler/globalvariable-attributes.ll

+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+
+@g1 = global i32 7 "key" = "value" "key2" = "value2"
+@g2 = global i32 2, align 4 "key3" = "value3"
+@g3 = global i32 2 #0
+@g4 = global i32 2, align 4 "key5" = "value5" #0
+
+attributes #0 = { "string" = "value" nobuiltin norecurse }
+
+; CHECK: @g1 = global i32 7 #0
+; CHECK: @g2 = global i32 2, align 4 #1
+; CHECK: @g3 = global i32 2 #2
+; CHECK: @g4 = global i32 2, align 4 #3
+
+; CHECK: attributes #0 = { "key"="value" "key2"="value2" }
+; CHECK: attributes #1 = { "key3"="value3" }
+; CHECK: attributes #2 = { nobuiltin norecurse "string"="value" }
+; CHECK: attributes #3 = { nobuiltin norecurse "key5"="value5" "string"="value" }
+

test/Bitcode/globalvariable-attributes.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+@g1 = global i32 7 "key" = "value" "key2" = "value2"
+@g2 = global i32 2, align 4 "key3" = "value3"
+@g3 = global i32 2 #0
+@g4 = global i32 2, align 4 "key5" = "value5" #0
+
+attributes #0 = { "string" = "value" nobuiltin norecurse }
+
+; CHECK: @g1 = global i32 7 #0
+; CHECK: @g2 = global i32 2, align 4 #1
+; CHECK: @g3 = global i32 2 #2
+; CHECK: @g4 = global i32 2, align 4 #3
+
+; CHECK: attributes #0 = { "key"="value" "key2"="value2" }
+; CHECK: attributes #1 = { "key3"="value3" }
+; CHECK: attributes #2 = { nobuiltin norecurse "string"="value" }
+; CHECK: attributes #3 = { nobuiltin norecurse "key5"="value5" "string"="value" }
+