[AArch64][GlobalISel] Select @llvm.aarch64.ldxr.* intrinsics

[paquette]

Summary

Same thing as D66897, but for ldxr.* instead. Add a GISelPredicateCode to the ldxr_* definitions, which allows us to import them.

Add select-ldxr-intrin.mir, and update arm64-ldxr-stxr.ll.

Relies on D66897 because it uses isLoadStoreOfNumBytes.

[aemerson]

Same test comment as the other patch, otherwise LGTM.

llvm/lib/Target/AArch64/AArch64InstrAtomics.td

 //===----------------------------------
 // Low-level exclusive operations
 //===----------------------------------
 
 // Load-exclusives.
 
 def ldxr_1 : PatFrag<(ops node:$ptr), (int_aarch64_ldxr node:$ptr), [{
   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i8;
-}]>;
+}]> {
+  let GISelPredicateCode = [{ return isLoadStoreOfNumBytes(MI, 1); }];
+}
 
 def ldxr_2 : PatFrag<(ops node:$ptr), (int_aarch64_ldxr node:$ptr), [{
   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i16;
-}]>;
+}]> {
+  let GISelPredicateCode = [{ return isLoadStoreOfNumBytes(MI, 2); }];
+}
 
 def ldxr_4 : PatFrag<(ops node:$ptr), (int_aarch64_ldxr node:$ptr), [{
   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i32;
-}]>;
+}]> {
+  let GISelPredicateCode = [{ return isLoadStoreOfNumBytes(MI, 4); }];
+}
 
 def ldxr_8 : PatFrag<(ops node:$ptr), (int_aarch64_ldxr node:$ptr), [{
   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i64;
-}]>;
+}]> {
+  let GISelPredicateCode = [{ return isLoadStoreOfNumBytes(MI, 8); }];
+}
 
 def : Pat<(ldxr_1 GPR64sp:$addr),
           (SUBREG_TO_REG (i64 0), (LDXRB GPR64sp:$addr), sub_32)>;
 def : Pat<(ldxr_2 GPR64sp:$addr),
           (SUBREG_TO_REG (i64 0), (LDXRH GPR64sp:$addr), sub_32)>;
 def : Pat<(ldxr_4 GPR64sp:$addr),
           (SUBREG_TO_REG (i64 0), (LDXRW GPR64sp:$addr), sub_32)>;
 def : Pat<(ldxr_8 GPR64sp:$addr), (LDXRX GPR64sp:$addr)>;

llvm/test/CodeGen/AArch64/GlobalISel/select-ldxr-intrin.mir

+# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
+# RUN: llc -mtriple=aarch64-unknown-unknown -run-pass=instruction-select -verify-machineinstrs %s -o - | FileCheck %s
+
+--- |
+  define void @test_load_i8(i8* %addr) { ret void }
+  define void @test_load_i16(i16* %addr) { ret void }
+  define void @test_load_i32(i32* %addr) { ret void }
+  define void @test_load_i64(i64* %addr) { ret void }
+  @var = global i64 0, align 8
+...
+---
+name:            test_load_i8
+alignment:       2
+legalized:       true
+regBankSelected: true
+tracksRegLiveness: true
+body:             |
+  bb.0:
+    liveins: $x0
+    ; CHECK-LABEL: name: test_load_i8
+    ; CHECK: liveins: $x0
+    ; CHECK: [[COPY:%[0-9]+]]:gpr64sp = COPY $x0
+    ; CHECK: [[MOVaddr:%[0-9]+]]:gpr64common = MOVaddr target-flags(aarch64-page) @var, target-flags(aarch64-pageoff, aarch64-nc) @var
+    ; CHECK: [[LDXRB:%[0-9]+]]:gpr32 = LDXRB [[COPY]] :: (volatile load 1 from %ir.addr)
+    ; CHECK: [[SUBREG_TO_REG:%[0-9]+]]:gpr64all = SUBREG_TO_REG 0, [[LDXRB]], %subreg.sub_32
+    ; CHECK: [[COPY1:%[0-9]+]]:gpr64 = COPY [[SUBREG_TO_REG]]
+    ; CHECK: [[ANDXri:%[0-9]+]]:gpr64common = ANDXri [[COPY1]], 4103
+    ; CHECK: STRXui [[ANDXri]], [[MOVaddr]], 0 :: (store 8 into @var)
+    ; CHECK: RET_ReallyLR
+    %0:gpr(p0) = COPY $x0
+    %4:gpr(p0) = G_GLOBAL_VALUE @var
+    %1:gpr(s64) = G_INTRINSIC_W_SIDE_EFFECTS intrinsic(@llvm.aarch64.ldxr), %0(p0) :: (volatile load 1 from %ir.addr)
+    %5:gpr(s64) = G_CONSTANT i64 255
+    %6:gpr(s64) = COPY %1(s64)
+    %3:gpr(s64) = G_AND %6, %5
+    G_STORE %3(s64), %4(p0) :: (store 8 into @var)
+    RET_ReallyLR
+
+...
+---
+name:            test_load_i16
+alignment:       2
+legalized:       true
+regBankSelected: true
+tracksRegLiveness: true
+body:             |
+  bb.0:
+    liveins: $x0
+    ; CHECK-LABEL: name: test_load_i16
+    ; CHECK: liveins: $x0
+    ; CHECK: [[COPY:%[0-9]+]]:gpr64sp = COPY $x0
+    ; CHECK: [[MOVaddr:%[0-9]+]]:gpr64common = MOVaddr target-flags(aarch64-page) @var, target-flags(aarch64-pageoff, aarch64-nc) @var
+    ; CHECK: [[LDXRH:%[0-9]+]]:gpr32 = LDXRH [[COPY]] :: (volatile load 2 from %ir.addr)
+    ; CHECK: [[SUBREG_TO_REG:%[0-9]+]]:gpr64all = SUBREG_TO_REG 0, [[LDXRH]], %subreg.sub_32
+    ; CHECK: [[COPY1:%[0-9]+]]:gpr64 = COPY [[SUBREG_TO_REG]]
+    ; CHECK: [[ANDXri:%[0-9]+]]:gpr64common = ANDXri [[COPY1]], 4111
+    ; CHECK: STRXui [[ANDXri]], [[MOVaddr]], 0 :: (store 8 into @var)
+    ; CHECK: RET_ReallyLR
+    %0:gpr(p0) = COPY $x0
+    %4:gpr(p0) = G_GLOBAL_VALUE @var
+    %1:gpr(s64) = G_INTRINSIC_W_SIDE_EFFECTS intrinsic(@llvm.aarch64.ldxr), %0(p0) :: (volatile load 2 from %ir.addr)
+    %5:gpr(s64) = G_CONSTANT i64 65535
+    %6:gpr(s64) = COPY %1(s64)
+    %3:gpr(s64) = G_AND %6, %5
+    G_STORE %3(s64), %4(p0) :: (store 8 into @var)
+    RET_ReallyLR
+
+...
+---
+name:            test_load_i32
+alignment:       2
+legalized:       true
+regBankSelected: true
+tracksRegLiveness: true
+body:             |
+  bb.0:
+    liveins: $x0
+    ; CHECK-LABEL: name: test_load_i32
+    ; CHECK: liveins: $x0
+    ; CHECK: [[COPY:%[0-9]+]]:gpr64sp = COPY $x0
+    ; CHECK: [[MOVaddr:%[0-9]+]]:gpr64common = MOVaddr target-flags(aarch64-page) @var, target-flags(aarch64-pageoff, aarch64-nc) @var
+    ; CHECK: [[LDXRW:%[0-9]+]]:gpr32 = LDXRW [[COPY]] :: (volatile load 4 from %ir.addr)
+    ; CHECK: [[SUBREG_TO_REG:%[0-9]+]]:gpr64all = SUBREG_TO_REG 0, [[LDXRW]], %subreg.sub_32
+    ; CHECK: [[COPY1:%[0-9]+]]:gpr64 = COPY [[SUBREG_TO_REG]]
+    ; CHECK: [[ANDXri:%[0-9]+]]:gpr64common = ANDXri [[COPY1]], 4127
+    ; CHECK: STRXui [[ANDXri]], [[MOVaddr]], 0 :: (store 8 into @var)
+    ; CHECK: RET_ReallyLR
+    %0:gpr(p0) = COPY $x0
+    %4:gpr(p0) = G_GLOBAL_VALUE @var
+    %1:gpr(s64) = G_INTRINSIC_W_SIDE_EFFECTS intrinsic(@llvm.aarch64.ldxr), %0(p0) :: (volatile load 4 from %ir.addr)
+    %5:gpr(s64) = G_CONSTANT i64 4294967295
+    %6:gpr(s64) = COPY %1(s64)
+    %3:gpr(s64) = G_AND %6, %5
+    G_STORE %3(s64), %4(p0) :: (store 8 into @var)
+    RET_ReallyLR
+
+...
+---
+name:            test_load_i64
+alignment:       2
+legalized:       true
+regBankSelected: true
+tracksRegLiveness: true
+body:             |
+  bb.0:
+    liveins: $x0
+    ; CHECK-LABEL: name: test_load_i64
+    ; CHECK: liveins: $x0
+    ; CHECK: [[COPY:%[0-9]+]]:gpr64sp = COPY $x0
+    ; CHECK: [[MOVaddr:%[0-9]+]]:gpr64common = MOVaddr target-flags(aarch64-page) @var, target-flags(aarch64-pageoff, aarch64-nc) @var
+    ; CHECK: [[LDXRX:%[0-9]+]]:gpr64 = LDXRX [[COPY]] :: (volatile load 8 from %ir.addr)
+    ; CHECK: STRXui [[LDXRX]], [[MOVaddr]], 0 :: (store 8 into @var)
+    ; CHECK: RET_ReallyLR
+    %0:gpr(p0) = COPY $x0
+    %2:gpr(p0) = G_GLOBAL_VALUE @var
+    %1:gpr(s64) = G_INTRINSIC_W_SIDE_EFFECTS intrinsic(@llvm.aarch64.ldxr), %0(p0) :: (volatile load 8 from %ir.addr)
+    G_STORE %1(s64), %2(p0) :: (store 8 into @var)
+    RET_ReallyLR

llvm/test/CodeGen/AArch64/arm64-ldxr-stxr.ll

entry:
   ret i32 %strexd
 }
 
 declare %0 @llvm.aarch64.ldxp(i8*) nounwind
 declare i32 @llvm.aarch64.stxp(i64, i64, i8*) nounwind
 
 @var = global i64 0, align 8
 
+; FALLBACK-NOT: remark:{{.*}}test_load_i8
 define void @test_load_i8(i8* %addr) {
 ; CHECK-LABEL: test_load_i8:
 ; CHECK: ldxrb w[[LOADVAL:[0-9]+]], [x0]
 ; CHECK-NOT: uxtb
 ; CHECK-NOT: and
 ; CHECK: str x[[LOADVAL]], [{{x[0-9]+}}, :lo12:var]
 
+; FIXME: GlobalISel doesn't fold ands/adds into load/store addressing modes
+; right now/ So, we won't get the :lo12:var.
+; GISEL-LABEL: test_load_i8:
+; GISEL: ldxrb w[[LOADVAL:[0-9]+]], [x0]
+; GISEL-NOT: uxtb
+; GISEL: str x[[LOADVAL]], [{{x[0-9]+}}]
   %val = call i64 @llvm.aarch64.ldxr.p0i8(i8* %addr)
   %shortval = trunc i64 %val to i8
   %extval = zext i8 %shortval to i64
   store i64 %extval, i64* @var, align 8
   ret void
 }
 
+; FALLBACK-NOT: remark:{{.*}}test_load_i16
 define void @test_load_i16(i16* %addr) {
 ; CHECK-LABEL: test_load_i16:
 ; CHECK: ldxrh w[[LOADVAL:[0-9]+]], [x0]
 ; CHECK-NOT: uxth
 ; CHECK-NOT: and
 ; CHECK: str x[[LOADVAL]], [{{x[0-9]+}}, :lo12:var]
 
+; GISEL-LABEL: test_load_i16:
+; GISEL: ldxrh w[[LOADVAL:[0-9]+]], [x0]
+; GISEL-NOT: uxtb
+; GISEL: str x[[LOADVAL]], [{{x[0-9]+}}]
   %val = call i64 @llvm.aarch64.ldxr.p0i16(i16* %addr)
   %shortval = trunc i64 %val to i16
   %extval = zext i16 %shortval to i64
   store i64 %extval, i64* @var, align 8
   ret void
 }
 
+; FALLBACK-NOT: remark:{{.*}}test_load_i32
 define void @test_load_i32(i32* %addr) {
 ; CHECK-LABEL: test_load_i32:
 ; CHECK: ldxr w[[LOADVAL:[0-9]+]], [x0]
 ; CHECK-NOT: uxtw
 ; CHECK-NOT: and
 ; CHECK: str x[[LOADVAL]], [{{x[0-9]+}}, :lo12:var]
 
+; GISEL-LABEL: test_load_i32:
+; GISEL: ldxr w[[LOADVAL:[0-9]+]], [x0]
+; GISEL-NOT: uxtb
+; GISEL: str x[[LOADVAL]], [{{x[0-9]+}}]
   %val = call i64 @llvm.aarch64.ldxr.p0i32(i32* %addr)
   %shortval = trunc i64 %val to i32
   %extval = zext i32 %shortval to i64
   store i64 %extval, i64* @var, align 8
   ret void
 }
 
+; FALLBACK-NOT: remark:{{.*}}test_load_i64
 define void @test_load_i64(i64* %addr) {
 ; CHECK-LABEL: test_load_i64:
 ; CHECK: ldxr x[[LOADVAL:[0-9]+]], [x0]
 ; CHECK: str x[[LOADVAL]], [{{x[0-9]+}}, :lo12:var]
 
+; GISEL-LABEL: test_load_i64:
+; GISEL: ldxr x[[LOADVAL:[0-9]+]], [x0]
+; GISEL-NOT: uxtb
+; GISEL: str x[[LOADVAL]], [{{x[0-9]+}}]
   %val = call i64 @llvm.aarch64.ldxr.p0i64(i64* %addr)
   store i64 %val, i64* @var, align 8
   ret void
 }
 
 
 declare i64 @llvm.aarch64.ldxr.p0i8(i8*) nounwind
 declare i64 @llvm.aarch64.ldxr.p0i16(i16*) nounwind