Arguments<(ins LLVM_Type:$lhs, LLVM_Type:$rhs)>,
LLVM_Builder<"$res = builder." # builderFunc # "($lhs, $rhs);"> {
let parser = [{ return impl::parseBinaryOp(parser, result); }];
- let printer = [{ printLLVMBinaryOp(p, this->getOperation()); }];
+ let printer = [{ mlir::impl::printBinaryOp(this->getOperation(), p); }];
}
// Integer binary operations.
: LLVM_OneResultOp<"bitcast", [NoSideEffect]>,
Arguments<(ins LLVM_Type:$arg)>,
LLVM_Builder<"$res = builder.CreateBitCast($arg, $_resultType);"> {
- let parser = [{ return parseBitcastOp(parser, result); }];
- let printer = [{ printBitcastOp(p, *this); }];
+ let parser = [{ return mlir::impl::parseCastOp(parser, result); }];
+ let printer = [{ mlir::impl::printCastOp(this->getOperation(), p); }];
+}
+def LLVM_IntToPtrOp
+ : LLVM_OneResultOp<"inttoptr", [NoSideEffect]>,
+ Arguments<(ins LLVM_Type:$arg)>,
+ LLVM_Builder<"$res = builder.CreateIntToPtr($arg, $_resultType);"> {
+ let parser = [{ return mlir::impl::parseCastOp(parser, result); }];
+ let printer = [{ mlir::impl::printCastOp(this->getOperation(), p); }];
+}
+def LLVM_PtrToIntOp
+ : LLVM_OneResultOp<"ptrtoint", [NoSideEffect]>,
+ Arguments<(ins LLVM_Type:$arg)>,
+ LLVM_Builder<"$res = builder.CreatePtrToInt($arg, $_resultType);"> {
+ let parser = [{ return mlir::impl::parseCastOp(parser, result); }];
+ let printer = [{ mlir::impl::printCastOp(this->getOperation(), p); }];
}
-
// Call-related operations.
def LLVM_CallOp : LLVM_Op<"call">,
Arguments<(ins OptionalAttr<FunctionAttr>:$callee,
OpAsmParser::OperandType srcInfo;
Type srcType, dstType;
return failure(parser->parseOperand(srcInfo) ||
+ parser->parseOptionalAttributeDict(result->attributes) ||
parser->parseColonType(srcType) ||
parser->resolveOperand(srcInfo, srcType, result->operands) ||
parser->parseKeywordType("to", dstType) ||
}
void impl::printCastOp(Operation *op, OpAsmPrinter *p) {
- *p << op->getName() << ' ' << *op->getOperand(0) << " : "
- << op->getOperand(0)->getType() << " to " << op->getResult(0)->getType();
+ *p << op->getName() << ' ' << *op->getOperand(0);
+ p->printOptionalAttrDict(op->getAttrs());
+ *p << " : " << op->getOperand(0)->getType() << " to "
+ << op->getResult(0)->getType();
}
Value *impl::foldCastOp(Operation *op) {
using namespace mlir;
using namespace mlir::LLVM;
-static void printLLVMBinaryOp(OpAsmPrinter *p, Operation *op) {
- // Fallback to the generic form if the op is not well-formed (may happen
- // during incomplete rewrites, and used for debugging).
- const auto *abstract = op->getAbstractOperation();
- (void)abstract;
- assert(abstract && "pretty printing an unregistered operation");
-
- auto resultType = op->getResult(0)->getType();
- if (resultType != op->getOperand(0)->getType() ||
- resultType != op->getOperand(1)->getType())
- return p->printGenericOp(op);
-
- *p << op->getName().getStringRef() << ' ' << *op->getOperand(0) << ", "
- << *op->getOperand(1);
- p->printOptionalAttrDict(op->getAttrs());
- *p << " : " << op->getResult(0)->getType();
-}
-
//===----------------------------------------------------------------------===//
// Printing/parsing for LLVM::ICmpOp.
//===----------------------------------------------------------------------===//
}
//===----------------------------------------------------------------------===//
-// Printing/parsing for LLVM::BitcastOp.
-//===----------------------------------------------------------------------===//
-
-static void printBitcastOp(OpAsmPrinter *p, BitcastOp &op) {
- *p << op.getOperationName() << ' ' << *op.arg();
- p->printOptionalAttrDict(op.getAttrs());
- *p << " : " << op.arg()->getType() << " to " << op.getType();
-}
-
-// <operation> ::= `llvm.bitcast` ssa-use attribute-dict? `:` type `to` type
-static ParseResult parseBitcastOp(OpAsmParser *parser, OperationState *result) {
- SmallVector<NamedAttribute, 4> attrs;
- OpAsmParser::OperandType arg;
- Type sourceType, type;
-
- if (parser->parseOperand(arg) || parser->parseOptionalAttributeDict(attrs) ||
- parser->parseColonType(sourceType) || parser->parseKeyword("to") ||
- parser->parseType(type) ||
- parser->resolveOperand(arg, sourceType, result->operands))
- return failure();
-
- result->attributes = attrs;
- result->addTypes(type);
- return success();
-}
-
-//===----------------------------------------------------------------------===//
// Printing/parsing for LLVM::CallOp.
//===----------------------------------------------------------------------===//
// Misc operations.
// CHECK: %24 = llvm.select %7, %0, %1 : !llvm.i1, !llvm.i32
-// CHECK-NEXT: llvm.return
%24 = llvm.select %7, %0, %1 : !llvm.i1, !llvm.i32
+
+// Integer to pointer and pointer to integer conversions.
+//
+// CHECK: %25 = llvm.inttoptr %arg0 : !llvm.i32 to !llvm<"i32*">
+// CHECK-NEXT: %26 = llvm.ptrtoint %25 : !llvm<"i32*"> to !llvm.i32
+ %25 = llvm.inttoptr %arg0 : !llvm.i32 to !llvm<"i32*">
+ %26 = llvm.ptrtoint %25 : !llvm<"i32*"> to !llvm.i32
+
+// CHECK: llvm.return
llvm.return
}
// CHECK-LABEL: @llvm_varargs(...)
func @llvm_varargs()
attributes {std.varargs: true}
+
+func @intpointerconversion(%arg0 : !llvm.i32) -> !llvm.i32 {
+// CHECK: %2 = inttoptr i32 %0 to i32*
+// CHECK-NEXT: %3 = ptrtoint i32* %2 to i32
+ %1 = llvm.inttoptr %arg0 : !llvm.i32 to !llvm<"i32*">
+ %2 = llvm.ptrtoint %1 : !llvm<"i32*"> to !llvm.i32
+ llvm.return %2 : !llvm.i32
+}
+