LLParser: Accept align(N) as new syntax for parameter attribute

[arsenm]

Summary

Every other value parameter attribute uses parentheses, so accept this
as the preferred modern syntax. Updating everything to use the new
syntax is left for a future change.

[jdoerfert]

I think this is clearly improving uniformity of the attribute spelling. Thanks. Align was first but is not "special" anymore (in the attribute position).

[arsenm]

b091c9a3e180f45c35a7e1fdd8e383c0098d9210

llvm/docs/LangRef.rst

``sret``
     structure that is the return value of the function in the source
     program. This pointer must be guaranteed by the caller to be valid:
     loads and stores to the structure may be assumed by the callee not
     to trap and to be properly aligned. This is not a valid attribute
     for return values.
 
 .. _attr_align:
 
-``align <n>``
+``align <n>`` or ``align(<n>)``
     This indicates that the pointer value may be assumed by the optimizer to
     have the specified alignment.  If the pointer value does not have the
     specified alignment, behavior is undefined.
 
     Note that this attribute has additional semantics when combined with the
     ``byval`` attribute, which are documented there.
 
 .. _noalias:

llvm/lib/AsmParser/LLParser.h

private:
     bool ParseOptionalReturnAttrs(AttrBuilder &B);
     bool ParseOptionalLinkage(unsigned &Res, bool &HasLinkage,
                               unsigned &Visibility, unsigned &DLLStorageClass,
                               bool &DSOLocal);
     void ParseOptionalDSOLocal(bool &DSOLocal);
     void ParseOptionalVisibility(unsigned &Res);
     void ParseOptionalDLLStorageClass(unsigned &Res);
     bool ParseOptionalCallingConv(unsigned &CC);
-    bool ParseOptionalAlignment(MaybeAlign &Alignment);
+    bool ParseOptionalAlignment(MaybeAlign &Alignment,
+                                bool AllowParens = false);
     bool ParseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
     bool ParseScopeAndOrdering(bool isAtomic, SyncScope::ID &SSID,
                                AtomicOrdering &Ordering);
     bool ParseScope(SyncScope::ID &SSID);
     bool ParseOrdering(AtomicOrdering &Ordering);
     bool ParseOptionalStackAlignment(unsigned &Alignment);
     bool ParseOptionalCommaAlign(MaybeAlign &Alignment, bool &AteExtraComma);
     bool ParseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,

llvm/lib/AsmParser/LLParser.cpp

default:  // End of attributes.
       return HaveError;
     case lltok::StringConstant: {
       if (ParseStringAttribute(B))
         return true;
       continue;
     }
     case lltok::kw_align: {
       MaybeAlign Alignment;
-      if (ParseOptionalAlignment(Alignment))
+      if (ParseOptionalAlignment(Alignment, true))
         return true;
       B.addAlignmentAttr(Alignment);
       continue;
     }
     case lltok::kw_byval: {
       Type *Ty;
       if (ParseByValWithOptionalType(Ty))
         return true;
while (Lex.getKind() == lltok::MetadataVar)
     if (ParseGlobalObjectMetadataAttachment(F))
       return true;
   return false;
 }
 
 /// ParseOptionalAlignment
 ///   ::= /* empty */
 ///   ::= 'align' 4
-bool LLParser::ParseOptionalAlignment(MaybeAlign &Alignment) {
+bool LLParser::ParseOptionalAlignment(MaybeAlign &Alignment, bool AllowParens) {
   Alignment = None;
   if (!EatIfPresent(lltok::kw_align))
     return false;
   LocTy AlignLoc = Lex.getLoc();
   uint32_t Value = 0;
+
+  LocTy ParenLoc = Lex.getLoc();
+  bool HaveParens = false;
+  if (AllowParens) {
+    if (EatIfPresent(lltok::lparen))
+      HaveParens = true;
+  }
+
   if (ParseUInt32(Value))
     return true;
+
+  if (HaveParens && !EatIfPresent(lltok::rparen))
+    return Error(ParenLoc, "expected ')'");
+
   if (!isPowerOf2_32(Value))
     return Error(AlignLoc, "alignment is not a power of two");
   if (Value > Value::MaximumAlignment)
     return Error(AlignLoc, "huge alignments are not supported yet");
   Alignment = Align(Value);
   return false;
 }
 

llvm/test/Assembler/align-param-attr-error0.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+; Test parse errors when using form of align attribute with parentheses
+
+; CHECK:  <stdin>:[[@LINE+1]]:38: error: expected ')'
+define void @missing_rparen(i8* align(4 %ptr) {
+  ret void
+}

llvm/test/Assembler/align-param-attr-error1.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+; Test parse errors when using form of align attribute with parentheses
+
+; CHECK:  <stdin>:[[@LINE+1]]:42: error: expected '{' in function body
+define void @missing_Lparen(i8* align 4) %ptr) {
+  ret void
+}

llvm/test/Assembler/align-param-attr-error2.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+; Test parse errors when using form of align attribute with parentheses
+
+; CHECK:  <stdin>:[[@LINE+1]]:39: error: expected integer
+define void @missing_value(i8* align () %ptr) {
+  ret void
+}

llvm/test/Assembler/align-param-attr-format.ll

+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+
+; Test that align(N) is accepted as an alternative syntax to align N
+
+; CHECK: define void @param_align4(i8* align 4 %ptr) {
+define void @param_align4(i8* align(4) %ptr) {
+  ret void
+}
+
+; CHECK: define void @param_align128(i8* align 128 %0) {
+define void @param_align128(i8* align(128)) {
+  ret void
+}