Skip to content

Commit 5e4b984

Browse files
fabianmcgfabianmcg
committed
[mlir][ptr] Add ptr.ptr_diff op
Thi patch introduces the `ptr.ptr_diff` operation for computing pointer differences. The semantics of the operation are given by: ``` The `ptr_diff` operation computes the difference between two pointers, returning an integer or index value representing the number of bytes between them. This difference is always computed using signed arithmetic. The operation supports both scalar and shaped types with value semantics: - When both operands are scalar: produces a single difference value - When both are shaped: performs element-wise subtraction, shapes must be the same The operation also supports the following flags: - `none`: No flags are set. - `nuw`: No Unsigned Wrap, if the subtraction causes an unsigned overflow, the result is a poison value. - `nsw`: No Signed Wrap, if the subtraction causes a signed overflow, the result is a poison value. NOTE: The pointer difference is calculated using an integer type specified by the data layout. The final result will be sign-extended or truncated to fit the result type as necessary. ``` This patch also adds translation to LLVM IR hooks for the `ptr_diff` op. This translation uses the `ptrtoaddr` builder to compute only index bits difference. Example: ```mlir llvm.func @ptr_diff_vector_i32(%ptrs1: vector<8x!ptr.ptr<#llvm.address_space<0>>>, %ptrs2: vector<8x!ptr.ptr<#llvm.address_space<0>>>) -> vector<8xi32> { %diffs = ptr.ptr_diff %ptrs1, %ptrs2 : vector<8x!ptr.ptr<#llvm.address_space<0>>> -> vector<8xi32> llvm.return %diffs : vector<8xi32> } ``` Translation to LLVM IR: ```llvm define <8 x i32> @ptr_diff_vector_i32(<8 x ptr> %0, <8 x ptr> %1) { %3 = ptrtoint <8 x ptr> %0 to <8 x i64> %4 = ptrtoint <8 x ptr> %1 to <8 x i64> %5 = sub <8 x i64> %3, %4 %6 = trunc <8 x i64> %5 to <8 x i32> ret <8 x i32> %6 } ```
1 parent 362ce4b commit 5e4b984

File tree

7 files changed

+270
-0
lines changed

7 files changed

+270
-0
lines changed

‎mlir/include/mlir/Dialect/Ptr/IR/PtrEnums.td‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -79,4 +79,14 @@ def Ptr_PtrAddFlags : I32Enum<"PtrAddFlags", "Pointer add flags", [
7979
let cppNamespace = "::mlir::ptr";
8080
}
8181

82+
//===----------------------------------------------------------------------===//
83+
// Ptr diff flags enum properties.
84+
//===----------------------------------------------------------------------===//
85+
86+
def Ptr_PtrDiffFlags : I8BitEnum<"PtrDiffFlags", "Pointer difference flags", [
87+
I8BitEnumCase<"none", 0>, I8BitEnumCase<"nuw", 1>, I8BitEnumCase<"nsw", 2>
88+
]> {
89+
let cppNamespace = "::mlir::ptr";
90+
}
91+
8292
#endif // PTR_ENUMS

‎mlir/include/mlir/Dialect/Ptr/IR/PtrOps.td‎

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -415,6 +415,63 @@ def Ptr_PtrAddOp : Pointer_Op<"ptr_add", [
415415
}];
416416
}
417417

418+
//===----------------------------------------------------------------------===//
419+
// PtrDiffOp
420+
//===----------------------------------------------------------------------===//
421+
422+
def Ptr_PtrDiffOp : Pointer_Op<"ptr_diff", [
423+
Pure, AllTypesMatch<["lhs", "rhs"]>, SameOperandsAndResultShape
424+
]> {
425+
let summary = "Pointer difference operation";
426+
let description = [{
427+
The `ptr_diff` operation computes the difference between two pointers,
428+
returning an integer or index value representing the number of bytes
429+
between them. This difference is always computed using signed arithmetic.
430+
431+
The operation supports both scalar and shaped types with value semantics:
432+
- When both operands are scalar: produces a single difference value
433+
- When both are shaped: performs element-wise subtraction,
434+
shapes must be the same
435+
436+
The operation also supports the following flags:
437+
- `none`: No flags are set.
438+
- `nuw`: No Unsigned Wrap, if the subtraction causes an unsigned overflow,
439+
the result is a poison value.
440+
- `nsw`: No Signed Wrap, if the subtraction causes a signed overflow, the
441+
result is a poison value.
442+
443+
NOTE: The pointer difference is calculated using an integer type specified
444+
by the data layout. The final result will be sign-extended or truncated to
445+
fit the result type as necessary.
446+
447+
Example:
448+
449+
```mlir
450+
// Scalar pointers
451+
%diff = ptr.ptr_diff %p1, %p2 : !ptr.ptr<#ptr.generic_space> -> i64
452+
453+
// Shaped pointers
454+
%diffs = ptr.ptr_diff nsw %ptrs1, %ptrs2 :
455+
vector<4x!ptr.ptr<#ptr.generic_space>> -> vector<4xi64>
456+
```
457+
}];
458+
let arguments = (ins
459+
Ptr_PtrLikeType:$lhs, Ptr_PtrLikeType:$rhs,
460+
DefaultValuedProp<EnumProp<Ptr_PtrDiffFlags>, "PtrDiffFlags::none">:$flags
461+
);
462+
let results = (outs Ptr_IntLikeType:$result);
463+
let assemblyFormat = [{
464+
($flags^)? $lhs `,` $rhs attr-dict `:` type($lhs) `->` type($result)
465+
}];
466+
let extraClassDeclaration = [{
467+
/// Returns the operand's ptr type.
468+
ptr::PtrType getPtrType();
469+
/// Returns the result's underlying int type.
470+
Type getIntType();
471+
}];
472+
let hasVerifier = 1;
473+
}
474+
418475
//===----------------------------------------------------------------------===//
419476
// ScatterOp
420477
//===----------------------------------------------------------------------===//

‎mlir/lib/Dialect/Ptr/IR/PtrDialect.cpp‎

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@
1515
#include "mlir/IR/Matchers.h"
1616
#include "mlir/Interfaces/DataLayoutInterfaces.h"
1717
#include "mlir/Transforms/InliningUtils.h"
18+
#include "llvm/ADT/StringExtras.h"
1819
#include "llvm/ADT/TypeSwitch.h"
1920

2021
using namespace mlir;
@@ -391,6 +392,39 @@ LogicalResult PtrAddOp::inferReturnTypes(
391392
return success();
392393
}
393394

395+
//===----------------------------------------------------------------------===//
396+
// PtrDiffOp
397+
//===----------------------------------------------------------------------===//
398+
399+
LogicalResult PtrDiffOp::verify() {
400+
// If the operands are not shaped early exit.
401+
if (!isa<ShapedType>(getLhs().getType()))
402+
return success();
403+
404+
// Just check the container type matches, `SameOperandsAndResultShape` handles
405+
// the actual shape.
406+
if (getResult().getType().getTypeID() != getLhs().getType().getTypeID()) {
407+
return emitError() << "expected the result to have the same container "
408+
"type as the operands when operands are shaped";
409+
}
410+
411+
return success();
412+
}
413+
414+
ptr::PtrType PtrDiffOp::getPtrType() {
415+
Type lhsType = getLhs().getType();
416+
if (auto shapedType = dyn_cast<ShapedType>(lhsType))
417+
return cast<ptr::PtrType>(shapedType.getElementType());
418+
return cast<ptr::PtrType>(lhsType);
419+
}
420+
421+
Type PtrDiffOp::getIntType() {
422+
Type resultType = getResult().getType();
423+
if (auto shapedType = dyn_cast<ShapedType>(resultType))
424+
return shapedType.getElementType();
425+
return resultType;
426+
}
427+
394428
//===----------------------------------------------------------------------===//
395429
// ToPtrOp
396430
//===----------------------------------------------------------------------===//

‎mlir/lib/Target/LLVMIR/Dialect/Ptr/PtrToLLVMIRTranslation.cpp‎

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -349,6 +349,40 @@ convertConstantOp(ConstantOp constantOp, llvm::IRBuilderBase &builder,
349349
return success();
350350
}
351351

352+
/// Convert ptr.ptr_diff operation
353+
static LogicalResult
354+
convertPtrDiffOp(PtrDiffOp ptrDiffOp, llvm::IRBuilderBase &builder,
355+
LLVM::ModuleTranslation &moduleTranslation) {
356+
llvm::Value *lhs = moduleTranslation.lookupValue(ptrDiffOp.getLhs());
357+
llvm::Value *rhs = moduleTranslation.lookupValue(ptrDiffOp.getRhs());
358+
359+
if (!lhs || !rhs)
360+
return ptrDiffOp.emitError("Failed to lookup operands");
361+
362+
// Convert result type to LLVM type
363+
llvm::Type *resultType =
364+
moduleTranslation.convertType(ptrDiffOp.getResult().getType());
365+
if (!resultType)
366+
return ptrDiffOp.emitError("Failed to convert result type");
367+
368+
PtrDiffFlags flags = ptrDiffOp.getFlags();
369+
370+
// Convert both pointers to integers using ptrtoaddr, and compute the
371+
// difference: lhs - rhs
372+
llvm::Value *result = builder.CreateSub(
373+
builder.CreatePtrToAddr(lhs), builder.CreatePtrToAddr(rhs), /*Name=*/"",
374+
/*HasNUW=*/(flags & PtrDiffFlags::nuw) == PtrDiffFlags::nuw,
375+
/*HasNSW=*/(flags & PtrDiffFlags::nsw) == PtrDiffFlags::nsw);
376+
377+
// Convert the difference to the expected result type by truncating or
378+
// extending.
379+
if (result->getType() != resultType)
380+
result = builder.CreateIntCast(result, resultType, /*isSigned=*/true);
381+
382+
moduleTranslation.mapValue(ptrDiffOp.getResult(), result);
383+
return success();
384+
}
385+
352386
/// Implementation of the dialect interface that converts operations belonging
353387
/// to the `ptr` dialect to LLVM IR.
354388
class PtrDialectLLVMIRTranslationInterface
@@ -369,6 +403,9 @@ class PtrDialectLLVMIRTranslationInterface
369403
.Case([&](PtrAddOp ptrAddOp) {
370404
return convertPtrAddOp(ptrAddOp, builder, moduleTranslation);
371405
})
406+
.Case([&](PtrDiffOp ptrDiffOp) {
407+
return convertPtrDiffOp(ptrDiffOp, builder, moduleTranslation);
408+
})
372409
.Case([&](LoadOp loadOp) {
373410
return convertLoadOp(loadOp, builder, moduleTranslation);
374411
})

‎mlir/test/Dialect/Ptr/invalid.mlir‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -70,3 +70,11 @@ func.func @ptr_add_shape_mismatch(%ptrs: tensor<8x!ptr.ptr<#ptr.generic_space>>,
7070
%res = ptr.ptr_add %ptrs, %offsets : tensor<8x!ptr.ptr<#ptr.generic_space>>, tensor<4xi64>
7171
return %res : tensor<8x!ptr.ptr<#ptr.generic_space>>
7272
}
73+
74+
// -----
75+
76+
func.func @ptr_diff_mismatch(%lhs: tensor<8x!ptr.ptr<#ptr.generic_space>>, %rhs: tensor<8x!ptr.ptr<#ptr.generic_space>>) -> vector<8xi64> {
77+
// expected-error@+1 {{the result to have the same container type as the operands when operands are shaped}}
78+
%res = ptr.ptr_diff %lhs, %rhs : tensor<8x!ptr.ptr<#ptr.generic_space>> -> vector<8xi64>
79+
return %res : vector<8xi64>
80+
}

‎mlir/test/Dialect/Ptr/ops.mlir‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -211,3 +211,31 @@ func.func @constant_large_address_ops() -> (!ptr.ptr<#ptr.generic_space>, !ptr.p
211211
%addr_large = ptr.constant #ptr.address<0x123456789ABCDEF0> : !ptr.ptr<#llvm.address_space<0>>
212212
return %addr_max32, %addr_large : !ptr.ptr<#ptr.generic_space>, !ptr.ptr<#llvm.address_space<0>>
213213
}
214+
215+
/// Test ptr_diff operations with scalar pointers
216+
func.func @ptr_diff_scalar_ops(%ptr1: !ptr.ptr<#ptr.generic_space>, %ptr2: !ptr.ptr<#ptr.generic_space>) -> (i64, index, i32) {
217+
%diff_i64 = ptr.ptr_diff %ptr1, %ptr2 : !ptr.ptr<#ptr.generic_space> -> i64
218+
%diff_index = ptr.ptr_diff %ptr1, %ptr2 : !ptr.ptr<#ptr.generic_space> -> index
219+
%diff_i32 = ptr.ptr_diff nuw %ptr1, %ptr2 : !ptr.ptr<#ptr.generic_space> -> i32
220+
return %diff_i64, %diff_index, %diff_i32 : i64, index, i32
221+
}
222+
223+
/// Test ptr_diff operations with vector pointers
224+
func.func @ptr_diff_vector_ops(%ptrs1: vector<4x!ptr.ptr<#ptr.generic_space>>, %ptrs2: vector<4x!ptr.ptr<#ptr.generic_space>>) -> (vector<4xi64>, vector<4xindex>) {
225+
%diff_i64 = ptr.ptr_diff none %ptrs1, %ptrs2 : vector<4x!ptr.ptr<#ptr.generic_space>> -> vector<4xi64>
226+
%diff_index = ptr.ptr_diff %ptrs1, %ptrs2 : vector<4x!ptr.ptr<#ptr.generic_space>> -> vector<4xindex>
227+
return %diff_i64, %diff_index : vector<4xi64>, vector<4xindex>
228+
}
229+
230+
/// Test ptr_diff operations with tensor pointers
231+
func.func @ptr_diff_tensor_ops(%ptrs1: tensor<8x!ptr.ptr<#ptr.generic_space>>, %ptrs2: tensor<8x!ptr.ptr<#ptr.generic_space>>) -> (tensor<8xi64>, tensor<8xi32>) {
232+
%diff_i64 = ptr.ptr_diff nsw %ptrs1, %ptrs2 : tensor<8x!ptr.ptr<#ptr.generic_space>> -> tensor<8xi64>
233+
%diff_i32 = ptr.ptr_diff nsw | nuw %ptrs1, %ptrs2 : tensor<8x!ptr.ptr<#ptr.generic_space>> -> tensor<8xi32>
234+
return %diff_i64, %diff_i32 : tensor<8xi64>, tensor<8xi32>
235+
}
236+
237+
/// Test ptr_diff operations with 2D tensor pointers
238+
func.func @ptr_diff_tensor_2d_ops(%ptrs1: tensor<4x8x!ptr.ptr<#ptr.generic_space>>, %ptrs2: tensor<4x8x!ptr.ptr<#ptr.generic_space>>) -> tensor<4x8xi64> {
239+
%diff = ptr.ptr_diff %ptrs1, %ptrs2 : tensor<4x8x!ptr.ptr<#ptr.generic_space>> -> tensor<4x8xi64>
240+
return %diff : tensor<4x8xi64>
241+
}

‎mlir/test/Target/LLVMIR/ptr.mlir‎

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -259,3 +259,99 @@ llvm.func @ptr_add_cst() -> !ptr.ptr<#llvm.address_space<0>> {
259259
%res = ptr.ptr_add %ptr, %off : !ptr.ptr<#llvm.address_space<0>>, i32
260260
llvm.return %res : !ptr.ptr<#llvm.address_space<0>>
261261
}
262+
263+
// CHECK-LABEL: define i64 @ptr_diff_scalar
264+
// CHECK-SAME: (ptr %[[PTR1:.*]], ptr %[[PTR2:.*]]) {
265+
// CHECK-NEXT: %[[P1INT:.*]] = ptrtoint ptr %[[PTR1]] to i64
266+
// CHECK-NEXT: %[[P2INT:.*]] = ptrtoint ptr %[[PTR2]] to i64
267+
// CHECK-NEXT: %[[DIFF:.*]] = sub i64 %[[P1INT]], %[[P2INT]]
268+
// CHECK-NEXT: ret i64 %[[DIFF]]
269+
// CHECK-NEXT: }
270+
llvm.func @ptr_diff_scalar(%ptr1: !ptr.ptr<#llvm.address_space<0>>, %ptr2: !ptr.ptr<#llvm.address_space<0>>) -> i64 {
271+
%diff = ptr.ptr_diff %ptr1, %ptr2 : !ptr.ptr<#llvm.address_space<0>> -> i64
272+
llvm.return %diff : i64
273+
}
274+
275+
// CHECK-LABEL: define i32 @ptr_diff_scalar_i32
276+
// CHECK-SAME: (ptr %[[PTR1:.*]], ptr %[[PTR2:.*]]) {
277+
// CHECK-NEXT: %[[P1INT:.*]] = ptrtoint ptr %[[PTR1]] to i64
278+
// CHECK-NEXT: %[[P2INT:.*]] = ptrtoint ptr %[[PTR2]] to i64
279+
// CHECK-NEXT: %[[DIFF:.*]] = sub i64 %[[P1INT]], %[[P2INT]]
280+
// CHECK-NEXT: %[[TRUNC:.*]] = trunc i64 %[[DIFF]] to i32
281+
// CHECK-NEXT: ret i32 %[[TRUNC]]
282+
// CHECK-NEXT: }
283+
llvm.func @ptr_diff_scalar_i32(%ptr1: !ptr.ptr<#llvm.address_space<0>>, %ptr2: !ptr.ptr<#llvm.address_space<0>>) -> i32 {
284+
%diff = ptr.ptr_diff %ptr1, %ptr2 : !ptr.ptr<#llvm.address_space<0>> -> i32
285+
llvm.return %diff : i32
286+
}
287+
288+
// CHECK-LABEL: define <4 x i64> @ptr_diff_vector
289+
// CHECK-SAME: (<4 x ptr> %[[PTRS1:.*]], <4 x ptr> %[[PTRS2:.*]]) {
290+
// CHECK-NEXT: %[[P1INT:.*]] = ptrtoint <4 x ptr> %[[PTRS1]] to <4 x i64>
291+
// CHECK-NEXT: %[[P2INT:.*]] = ptrtoint <4 x ptr> %[[PTRS2]] to <4 x i64>
292+
// CHECK-NEXT: %[[DIFF:.*]] = sub <4 x i64> %[[P1INT]], %[[P2INT]]
293+
// CHECK-NEXT: ret <4 x i64> %[[DIFF]]
294+
// CHECK-NEXT: }
295+
llvm.func @ptr_diff_vector(%ptrs1: vector<4x!ptr.ptr<#llvm.address_space<0>>>, %ptrs2: vector<4x!ptr.ptr<#llvm.address_space<0>>>) -> vector<4xi64> {
296+
%diffs = ptr.ptr_diff %ptrs1, %ptrs2 : vector<4x!ptr.ptr<#llvm.address_space<0>>> -> vector<4xi64>
297+
llvm.return %diffs : vector<4xi64>
298+
}
299+
300+
// CHECK-LABEL: define <8 x i32> @ptr_diff_vector_i32
301+
// CHECK-SAME: (<8 x ptr> %[[PTRS1:.*]], <8 x ptr> %[[PTRS2:.*]]) {
302+
// CHECK-NEXT: %[[P1INT:.*]] = ptrtoint <8 x ptr> %[[PTRS1]] to <8 x i64>
303+
// CHECK-NEXT: %[[P2INT:.*]] = ptrtoint <8 x ptr> %[[PTRS2]] to <8 x i64>
304+
// CHECK-NEXT: %[[DIFF:.*]] = sub <8 x i64> %[[P1INT]], %[[P2INT]]
305+
// CHECK-NEXT: %[[TRUNC:.*]] = trunc <8 x i64> %[[DIFF]] to <8 x i32>
306+
// CHECK-NEXT: ret <8 x i32> %[[TRUNC]]
307+
// CHECK-NEXT: }
308+
llvm.func @ptr_diff_vector_i32(%ptrs1: vector<8x!ptr.ptr<#llvm.address_space<0>>>, %ptrs2: vector<8x!ptr.ptr<#llvm.address_space<0>>>) -> vector<8xi32> {
309+
%diffs = ptr.ptr_diff %ptrs1, %ptrs2 : vector<8x!ptr.ptr<#llvm.address_space<0>>> -> vector<8xi32>
310+
llvm.return %diffs : vector<8xi32>
311+
}
312+
313+
// CHECK-LABEL: define i64 @ptr_diff_with_constants() {
314+
// CHECK-NEXT: ret i64 4096
315+
// CHECK-NEXT: }
316+
llvm.func @ptr_diff_with_constants() -> i64 {
317+
%ptr1 = ptr.constant #ptr.address<0x2000> : !ptr.ptr<#llvm.address_space<0>>
318+
%ptr2 = ptr.constant #ptr.address<0x1000> : !ptr.ptr<#llvm.address_space<0>>
319+
%diff = ptr.ptr_diff %ptr1, %ptr2 : !ptr.ptr<#llvm.address_space<0>> -> i64
320+
llvm.return %diff : i64
321+
}
322+
323+
// CHECK-LABEL: define i64 @ptr_diff_with_flags_nsw
324+
// CHECK-SAME: (ptr %[[PTR1:.*]], ptr %[[PTR2:.*]]) {
325+
// CHECK-NEXT: %[[P1INT:.*]] = ptrtoint ptr %[[PTR1]] to i64
326+
// CHECK-NEXT: %[[P2INT:.*]] = ptrtoint ptr %[[PTR2]] to i64
327+
// CHECK-NEXT: %[[DIFF:.*]] = sub nsw i64 %[[P1INT]], %[[P2INT]]
328+
// CHECK-NEXT: ret i64 %[[DIFF]]
329+
// CHECK-NEXT: }
330+
llvm.func @ptr_diff_with_flags_nsw(%ptr1: !ptr.ptr<#llvm.address_space<0>>, %ptr2: !ptr.ptr<#llvm.address_space<0>>) -> i64 {
331+
%diff = ptr.ptr_diff nsw %ptr1, %ptr2 : !ptr.ptr<#llvm.address_space<0>> -> i64
332+
llvm.return %diff : i64
333+
}
334+
335+
// CHECK-LABEL: define i64 @ptr_diff_with_flags_nuw
336+
// CHECK-SAME: (ptr %[[PTR1:.*]], ptr %[[PTR2:.*]]) {
337+
// CHECK-NEXT: %[[P1INT:.*]] = ptrtoint ptr %[[PTR1]] to i64
338+
// CHECK-NEXT: %[[P2INT:.*]] = ptrtoint ptr %[[PTR2]] to i64
339+
// CHECK-NEXT: %[[DIFF:.*]] = sub nuw i64 %[[P1INT]], %[[P2INT]]
340+
// CHECK-NEXT: ret i64 %[[DIFF]]
341+
// CHECK-NEXT: }
342+
llvm.func @ptr_diff_with_flags_nuw(%ptr1: !ptr.ptr<#llvm.address_space<0>>, %ptr2: !ptr.ptr<#llvm.address_space<0>>) -> i64 {
343+
%diff = ptr.ptr_diff nuw %ptr1, %ptr2 : !ptr.ptr<#llvm.address_space<0>> -> i64
344+
llvm.return %diff : i64
345+
}
346+
347+
// CHECK-LABEL: define i64 @ptr_diff_with_flags_nsw_nuw
348+
// CHECK-SAME: (ptr %[[PTR1:.*]], ptr %[[PTR2:.*]]) {
349+
// CHECK-NEXT: %[[P1INT:.*]] = ptrtoint ptr %[[PTR1]] to i64
350+
// CHECK-NEXT: %[[P2INT:.*]] = ptrtoint ptr %[[PTR2]] to i64
351+
// CHECK-NEXT: %[[DIFF:.*]] = sub nuw nsw i64 %[[P1INT]], %[[P2INT]]
352+
// CHECK-NEXT: ret i64 %[[DIFF]]
353+
// CHECK-NEXT: }
354+
llvm.func @ptr_diff_with_flags_nsw_nuw(%ptr1: !ptr.ptr<#llvm.address_space<0>>, %ptr2: !ptr.ptr<#llvm.address_space<0>>) -> i64 {
355+
%diff = ptr.ptr_diff nsw | nuw %ptr1, %ptr2 : !ptr.ptr<#llvm.address_space<0>> -> i64
356+
llvm.return %diff : i64
357+
}

0 commit comments

Comments
 (0)