[mlir] LLVM dialect: support globals without linkage keyword, assuming 'external'

[ftynse]

Summary

Similarly to actual LLVM IR, and to llvm.mlir.func, allow the custom syntax
of llvm.mlir.global to omit the linkage keyword. If omitted, the linkage is
assumed to be external. This makes the modeling of globals in the LLVM dialect
more consistent, both within the dialect and with LLVM IR.

[mehdi_amini]

mlir/docs/Dialects/LLVM.md

110

Typo attribute

[ftynse]

Hmm, apparently I can accept my own revision...

mlir/docs/Dialects/LLVM.md

 } {
   llvm.return
 }
 ```
 
 If the attribute is not known to LLVM IR, it will be attached as a string
 attribute.
 
+#### Linkage
+
+An LLVM IR dialect function has a linkage attribute derived from LLVM IR
+[linkage types](https://llvm.org/docs/LangRef.html#linkage-types). Linkage is
+specified by the same keyword as in LLVM IR and is located between `llvm.func`
+and the symbol name. If no linkage keyword is present, `external` linkage is
+assumed by default.
+
 ### LLVM IR operations
 
 The following operations are currently supported. The semantics of these
 operations corresponds to the semantics of the similarly-named LLVM IR
 instructions.
 
 #### Integer binary arithmetic operations
 

 llvm.mlir.global constant @int_gep() : !llvm<"i32*"> {
   %0 = llvm.mlir.addressof @g2 : !llvm<"i32*">
   %1 = llvm.mlir.constant(2 : i32) : !llvm.i32
   %2 = llvm.getelementptr %0[%1] : (!llvm<"i32*">, !llvm.i32) -> !llvm<"i32*">
   llvm.return %2 : !llvm<"i32*">
 }
 ```
 
+Similarly to functions, globals have a linkage attribute. In the custom syntax,
+this attribute is placed between `llvm.mlir.global` and the optional `constant`
+keyword. If the attribute is omitted, `external` linkage is assumed by default.
+
+Examples:
+
+```mlir
+// A constant with internal linkage will not participate in linking.
+llvm.mlir.global internal constant @cst(42 : i32) : !llvm.i32
+
+// By default, "external" linkage is assumed and the global participates in
+// symbol resolution at link-time.
+llvm.mlir.global @glob(0 : f32) : !llvm.float
+```
+
 #### `llvm.mlir.null`
 
 Unlike LLVM IR, MLIR does not have first-class null pointers. They must be
 explicitly created as SSA values using `llvm.mlir.null`. This operation has
 operands or attributes, and returns a null value of a wrapped LLVM IR pointer
 type.
 
 Examples:

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

static ParseResult parseOptionalLLVMKeyword(OpAsmParser &parser,
 
   int index = parseOptionalKeywordAlternative(parser, names);
   if (index == -1)
     return failure();
   result.addAttribute(name, parser.getBuilder().getI64IntegerAttr(index));
   return success();
 }
 
-// operation ::= `llvm.mlir.global` linkage `constant`? `@` identifier
+// operation ::= `llvm.mlir.global` linkage? `constant`? `@` identifier
 //               `(` attribute? `)` attribute-list? (`:` type)? region?
 //
 // The type can be omitted for string attributes, in which case it will be
 // inferred from the value of the string as [strlen(value) x i8].
 static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
   if (failed(parseOptionalLLVMKeyword<Linkage>(parser, result,
                                                getLinkageAttrName())))
-    return parser.emitError(parser.getCurrentLocation(), "expected linkage");
+    result.addAttribute(getLinkageAttrName(),
+                        parser.getBuilder().getI64IntegerAttr(
+                            static_cast<int64_t>(LLVM::Linkage::External)));
 
   if (succeeded(parser.parseOptionalKeyword("constant")))
     result.addAttribute("constant", parser.getBuilder().getUnitAttr());
 
   StringAttr name;
   if (parser.parseSymbolName(name, SymbolTable::getSymbolAttrName(),
                              result.attributes) ||
       parser.parseLParen())

mlir/test/Dialect/LLVMIR/global.mlir

 // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
 
+// CHECK: llvm.mlir.global external @default_external
+llvm.mlir.global @default_external() : !llvm.i64
+
+// CHECK: llvm.mlir.global external constant @default_external_constant
+llvm.mlir.global constant @default_external_constant(42) : !llvm.i64
+
 // CHECK: llvm.mlir.global internal @global(42 : i64) : !llvm.i64
 llvm.mlir.global internal @global(42 : i64) : !llvm.i64
 
 // CHECK: llvm.mlir.global internal constant @constant(3.700000e+01 : f64) : !llvm.float
 llvm.mlir.global internal constant @constant(37.0) : !llvm.float
 
 // CHECK: llvm.mlir.global internal constant @".string"("foobar")
 llvm.mlir.global internal constant @".string"("foobar") : !llvm<"[6 x i8]">