[mlir][LLVM] Add support for adding a garbage collector to a LLVM function

[zero9178]

Summary

This patch simply adds an optional garbage collector attribute to LLVMFuncOp which maps 1:1 to the "gc" property of functions in LLVM.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

llvm.func internal @internal_func() {
       llvm.return
     }
     ```
   }];
 
   let arguments = (ins DefaultValuedAttr<Linkage, "Linkage::External">:$linkage,
                    UnitAttr:$dso_local,
                    OptionalAttr<FlatSymbolRefAttr>:$personality,
+                   OptionalAttr<StrAttr>:$garbageCollector,
                    OptionalAttr<ArrayAttr>:$passthrough);
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, "Type":$type,

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

LLVMFuncOp fop =
                            convertLinkageFromLLVM(f->getLinkage()));
 
   if (FlatSymbolRefAttr personality = getPersonalityAsAttr(f))
     fop->setAttr(b.getStringAttr("personality"), personality);
   else if (f->hasPersonalityFn())
     emitWarning(UnknownLoc::get(context),
                 "could not deduce personality, skipping it");
 
+  if (f->hasGC())
+    fop.setGarbageCollectorAttr(b.getStringAttr(f->getGC()));
+
   if (f->isDeclaration())
     return success();
 
   // Eagerly create all blocks.
   SmallVector<Block *, 4> blockList;
   for (llvm::BasicBlock &bb : *f) {
     blockList.push_back(b.createBlock(&fop.getBody(), fop.getBody().end()));
     blocks[&bb] = blockList.back();

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
   // Check the personality and set it.
   if (func.getPersonality().hasValue()) {
     llvm::Type *ty = llvm::Type::getInt8PtrTy(llvmFunc->getContext());
     if (llvm::Constant *pfunc = getLLVMConstant(ty, func.getPersonalityAttr(),
                                                 func.getLoc(), *this))
       llvmFunc->setPersonalityFn(pfunc);
   }
 
+  if (auto gc = func.getGarbageCollector())
+    llvmFunc->setGC(gc->str());
+
   // First, create all blocks so we can jump to them.
   llvm::LLVMContext &llvmContext = llvmFunc->getContext();
   for (auto &bb : func) {
     auto *llvmBB = llvm::BasicBlock::Create(llvmContext);
     llvmBB->insertInto(llvmFunc);
     mapBlock(&bb, llvmBB);
   }
 

mlir/test/Target/LLVMIR/import.ll

; CHECK: ^bb3:
   ; CHECK: %{{[0-9]+}} = llvm.invoke @bar(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
   %6 = invoke i8* @bar(i8* %1) to label %4 unwind label %2
 
 ; CHECK: ^bb4:
   ; CHECK: llvm.return %{{[0-9]+}} : i32
   ret i32 0
 }
 
+; CHECK-LABEL: @hasGCFunction
+; CHECK-SAME: garbageCollector = "statepoint-example"
+define void @hasGCFunction() gc "statepoint-example" {
+    ret void
+}
+
 ;CHECK-LABEL: @useFreezeOp
 define i32 @useFreezeOp(i32 %x) {
   ;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9a-z]+}} : i32
   %1 = freeze i32 %x
   %2 = add i8 10, 10
   ;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9]+}} : i8
   %3 = freeze i8 %2
   %poison = add nsw i1 0, undef

mlir/test/Target/LLVMIR/llvmir.mlir

 ^bb2:
     %2 = llvm.landingpad cleanup : !llvm.struct<(ptr<i8>, i32)>
     %3 = llvm.mlir.constant(1 : i32) : i32
     llvm.br ^bb1(%3 : i32)
 }
 
 // -----
 
+// CHECK-LABEL: @hasGCFunction
+// CHECK-SAME: gc "statepoint-example"
+llvm.func @hasGCFunction() attributes { garbageCollector = "statepoint-example" } {
+    llvm.return
+}
+
 // CHECK-LABEL: @callFreezeOp
 llvm.func @callFreezeOp(%x : i32) {
   // CHECK: freeze i32 %{{[0-9]+}}
   %0 = llvm.freeze %x : i32
   %1 = llvm.mlir.undef : i32
   // CHECK: freeze i32 undef
   %2 = llvm.freeze %1 : i32
   llvm.return