[mlir] Support convert token type from LLVM IR.

[jacquesguan]

Summary

This patch supports the token type for converting from LLVM IR.

mlir/lib/Target/LLVMIR/TypeFromLLVM.cpp

Type translatePrimitiveType(llvm::Type *type) {
     if (type->isPPC_FP128Ty())
       return LLVM::LLVMPPCFP128Type::get(&context);
     if (type->isX86_MMXTy())
       return LLVM::LLVMX86MMXType::get(&context);
     if (type->isLabelTy())
       return LLVM::LLVMLabelType::get(&context);
     if (type->isMetadataTy())
       return LLVM::LLVMMetadataType::get(&context);
+    if (type->isTokenTy())
+      return LLVM::LLVMTokenType::get(&context);
     llvm_unreachable("not a primitive type");
   }
 
   /// Translates the given array type.
   Type translate(llvm::ArrayType *type) {
     return LLVM::LLVMArrayType::get(translateType(type->getElementType()),
                                     type->getNumElements());
   }

mlir/test/Target/LLVMIR/Import/intrinsic.ll

 define void @umul_with_overflow_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {
   ; CHECK: "llvm.intr.umul.with.overflow"(%{{.*}}, %{{.*}}) : (i32, i32) -> !llvm.struct<(i32, i1)>
   %5 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %0, i32 %1)
   ; CHECK: "llvm.intr.umul.with.overflow"(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>
   %6 = call { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32(<8 x i32> %2, <8 x i32> %3)
   ret void
 }
 
-; TODO : support token type.
-; define void @coro_id(i32 %0, i8* %1) {
-;   %3 = call token @llvm.coro.id(i32 %0, i8* %1, i8* %1, i8* null)
-;   ret void
-; }
-
-; TODO : support token type.
-; define void @coro_begin(i32 %0, i8* %1) {
-;   %3 = call token @llvm.coro.id(i32 %0, i8* %1, i8* %1, i8* null)
-;   %4 = call i8* @llvm.coro.begin(token %3, i8* %1)
-;   ret void
-; }
+; CHECK-LABEL:  llvm.func @coro_id
+define void @coro_id(i32 %0, i8* %1) {
+  ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.token
+  %3 = call token @llvm.coro.id(i32 %0, i8* %1, i8* %1, i8* null)
+  ret void
+}
+
+; CHECK-LABEL:  llvm.func @coro_begin
+define void @coro_begin(i32 %0, i8* %1) {
+  ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.token
+  %3 = call token @llvm.coro.id(i32 %0, i8* %1, i8* %1, i8* null)
+  ; CHECK: llvm.intr.coro.begin %{{.*}}, %{{.*}} : !llvm.ptr<i8>
+  %4 = call i8* @llvm.coro.begin(token %3, i8* %1)
+  ret void
+}
 
 ; CHECK-LABEL:  llvm.func @coro_size()
 define void @coro_size() {
   ; CHECK: llvm.intr.coro.size : i64
   %1 = call i64 @llvm.coro.size.i64()
   ; CHECK: llvm.intr.coro.size : i32
   %2 = call i32 @llvm.coro.size.i32()
   ret void
 }
 ; CHECK-LABEL:  llvm.func @coro_align()
 define void @coro_align() {
   ; CHECK: llvm.intr.coro.align : i64
   %1 = call i64 @llvm.coro.align.i64()
   ; CHECK: llvm.intr.coro.align : i32
   %2 = call i32 @llvm.coro.align.i32()
   ret void
 }
 
-; TODO : support token type.
-; define void @coro_save(i8* %0) {
-;   %2 = call token @llvm.coro.save(i8* %0)
-;   ret void
-; }
-
-; TODO : support token type.
-; define void @coro_suspend(i32 %0, i1 %1, i8* %2) {
-;   %4 = call token @llvm.coro.id(i32 %0, i8* %2, i8* %2, i8* null)
-;   %5 = call i8 @llvm.coro.suspend(token %4, i1 %1)
-;   ret void
-; }
+; CHECK-LABEL:  llvm.func @coro_save
+define void @coro_save(i8* %0) {
+  ; CHECK: llvm.intr.coro.save %{{.*}} : !llvm.token
+  %2 = call token @llvm.coro.save(i8* %0)
+  ret void
+}
+
+; CHECK-LABEL:  llvm.func @coro_suspend
+define void @coro_suspend(i32 %0, i1 %1, i8* %2) {
+  ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.token
+  %4 = call token @llvm.coro.id(i32 %0, i8* %2, i8* %2, i8* null)
+  ; CHECK: llvm.intr.coro.suspend %{{.*}}, %{{.*}} : i8
+  %5 = call i8 @llvm.coro.suspend(token %4, i1 %1)
+  ret void
+}
 
 ; CHECK-LABEL:  llvm.func @coro_end
 define void @coro_end(i8* %0, i1 %1) {
   ; CHECK:  llvm.intr.coro.end 
   call i1 @llvm.coro.end(i8* %0, i1 %1)
   ret void
 }
 
-; TODO : support token type.
-; define void @coro_free(i32 %0, i8* %1) {
-;   %3 = call token @llvm.coro.id(i32 %0, i8* %1, i8* %1, i8* null)
-;   %4 = call i8* @llvm.coro.free(token %3, i8* %1)
-;   ret void
-; }
+; CHECK-LABEL:  llvm.func @coro_free
+define void @coro_free(i32 %0, i8* %1) {
+  ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.token
+  %3 = call token @llvm.coro.id(i32 %0, i8* %1, i8* %1, i8* null)
+  ; CHECK: llvm.intr.coro.free %{{.*}}, %{{.*}} : !llvm.ptr<i8>
+  %4 = call i8* @llvm.coro.free(token %3, i8* %1)
+  ret void
+}
 
 ; CHECK-LABEL:  llvm.func @coro_resume
 define void @coro_resume(i8* %0) {
   ; CHECK: llvm.intr.coro.resume %{{.*}}
   call void @llvm.coro.resume(i8* %0)
   ret void
 }
 

 declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32)
 declare { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32(<8 x i32>, <8 x i32>)
 declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32)
 declare { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32(<8 x i32>, <8 x i32>)
 declare { i32, i1 } @llvm.smul.with.overflow.i32(i32, i32)
 declare { <8 x i32>, <8 x i1> } @llvm.smul.with.overflow.v8i32(<8 x i32>, <8 x i32>)
 declare { i32, i1 } @llvm.umul.with.overflow.i32(i32, i32)
 declare { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32(<8 x i32>, <8 x i32>)
-; declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
-; declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare i8* @llvm.coro.begin(token, i8* writeonly)
 declare i64 @llvm.coro.size.i64()
 declare i32 @llvm.coro.size.i32()
 declare i64 @llvm.coro.align.i64()
 declare i32 @llvm.coro.align.i32()
-; declare token @llvm.coro.save(i8*)
-; declare i8 @llvm.coro.suspend(token, i1)
+declare token @llvm.coro.save(i8*)
+declare i8 @llvm.coro.suspend(token, i1)
 declare i1 @llvm.coro.end(i8*, i1)
-; declare i8* @llvm.coro.free(token, i8* nocapture readonly)
+declare i8* @llvm.coro.free(token, i8* nocapture readonly)
 declare void @llvm.coro.resume(i8*)
 declare i32 @llvm.eh.typeid.for(i8*)
 declare i8* @llvm.stacksave()
 declare void @llvm.stackrestore(i8*)
 declare <8 x i32> @llvm.vp.add.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.sub.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.mul.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
 declare <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)