================
@@ -723,6 +695,58 @@ mlir::Value
CIRAttrToValue::visitCirAttr(cir::BlockAddrInfoAttr blockAddrInfo) {
return blockAddressOp;
}
+/// BlockAddrDiffAttr visitor.
+mlir::Value CIRAttrToValue::visitCirAttr(cir::BlockAddrDiffAttr blockAddrDiff)
{
+ assert(blockInfoAddr &&
+ "block address lowering requires LLVMBlockAddressInfo");
+ // A block-address difference initializer is lowered to the difference of the
+ // two block addresses: trunc(ptrtoint(lhs) - ptrtoint(rhs)). Just like a
+ // single block address, each referenced block tag may not have been emitted
+ // yet, in which case it is recorded as unresolved and patched up later in
+ // resolveBlockAddressOp.
+ mlir::Location loc = parentOp->getLoc();
+ mlir::DataLayout layout(parentOp->getParentOfType<mlir::ModuleOp>());
+ mlir::MLIRContext *ctx = rewriter.getContext();
+ auto ptrTy = mlir::LLVM::LLVMPointerType::get(ctx);
+
+ auto emitBlockAddr = [&](mlir::StringAttr label) -> mlir::Value {
+ auto info = cir::BlockAddrInfoAttr::get(
+ ctx, blockAddrDiff.getFunc().getValue(), label.getValue());
+ mlir::LLVM::BlockTagOp matchLabel = blockInfoAddr->lookupBlockTag(info);
+ mlir::LLVM::BlockTagAttr tagAttr =
+ matchLabel ? matchLabel.getTag() : mlir::LLVM::BlockTagAttr{};
+ auto blkAddr = mlir::LLVM::BlockAddressAttr::get(
+ ctx, blockAddrDiff.getFunc(), tagAttr);
+ auto addrOp =
+ mlir::LLVM::BlockAddressOp::create(rewriter, loc, ptrTy, blkAddr);
+ if (!matchLabel)
+ blockInfoAddr->addUnresolvedBlockAddress(addrOp, info);
+ return addrOp;
+ };
+
+ mlir::Value lhsAddr = emitBlockAddr(blockAddrDiff.getLhsLabel());
+ mlir::Value rhsAddr = emitBlockAddr(blockAddrDiff.getRhsLabel());
+
+ // Compute the difference in a pointer-sized integer, then truncate to the
+ // initializer's type. LLVM is sensitive about the exact format of the
+ // address-of-label difference, so the truncation must happen after the
+ // subtraction.
+ mlir::Type intptrTy =
+ rewriter.getIntegerType(layout.getTypeSizeInBits(ptrTy));
+ mlir::Value lhsInt =
+ mlir::LLVM::PtrToIntOp::create(rewriter, loc, intptrTy, lhsAddr);
+ mlir::Value rhsInt =
+ mlir::LLVM::PtrToIntOp::create(rewriter, loc, intptrTy, rhsAddr);
+ mlir::Value diffVal =
+ mlir::LLVM::SubOp::create(rewriter, loc, lhsInt, rhsInt);
+
+ mlir::Type resultTy = converter->convertType(blockAddrDiff.getType());
+ mlir::Value result = diffVal;
+ if (resultTy != intptrTy)
----------------
andykaylor wrote:
Hmmm. That should work. I was going to say that it potentially changes the
result, but it seems that we're making the assumption that it won't. I just
tried it and I get `error: initializer element is not a compile-time constant`
if the result type is `short`. I guess we aren't worried about that when
truncating to `int`?
Oddly, clang also reports the "not a compile-time constant" if the result type
is `__int128` so it won't need to extend. The comment in
`IntExprEvaluator::VisitCastExpr` says this:
```
// Allow casts of address-of-label differences if they are no-ops
// or narrowing, if the result is at least 32 bits wide.
// (The narrowing case isn't actually guaranteed to
// be constant-evaluatable except in some narrow cases which are hard
// to detect here. We let it through on the assumption the user knows
// what they are doing.)
```
Anyway, what I did here follows what classic codegen does -- ptrtoint and
subtract at size_t, then truncates -- but I think your suggestion should work.
https://github.com/llvm/llvm-project/pull/205437
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
