This is an archive of the discontinued LLVM Phabricator instance.

Differential D95326

[GlobalISel] Implement widenScalar for carry-in add/sub
ClosedPublic

Authored by porglezomp on Jan 24 2021, 6:05 PM.

Details

Reviewers
paquette
aemerson
Commits
rGf22f4557a749: [GlobalISel] Implement widenScalar for carry-in add/sub
Summary

These are widened to a wider UADDE/USUBE, with the overflow value
unused, and with the same synthesis of a new overflow value as for the
O operations.

Diff Detail

Event Timeline

porglezomp created this revision.Jan 24 2021, 6:05 PM
Herald added subscribers: kerbowa, hiraditya, rovka and 2 others. · View Herald TranscriptJan 24 2021, 6:05 PM
porglezomp requested review of this revision.Jan 24 2021, 6:05 PM
Herald added a project: Restricted Project. · View Herald TranscriptJan 24 2021, 6:05 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B86494: Diff 318887.Jan 24 2021, 6:06 PM
porglezomp added a parent revision: D95325: [AArch64][GlobalISel] Make G_SADDE and G_SSUBE legal.Jan 24 2021, 6:06 PM
porglezomp updated this revision to Diff 319063.Jan 25 2021, 10:55 AM

Update tests to match run-line changes

Harbormaster completed remote builds in B86602: Diff 319063.Jan 25 2021, 10:56 AM
arsenm added a subscriber: arsenm.Jan 25 2021, 11:08 AM
arsenm added inline comments.
llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
1768

Should just use a plain Register here, MachineOperand values are generally bad

1819–1820

This is .getReg(0)

porglezomp updated this revision to Diff 319072.Jan 25 2021, 11:36 AM

Change MachineOperand variable to Register, use getReg(0) on MachineInstrBuilder

Harbormaster completed remote builds in B86605: Diff 319072.Jan 25 2021, 11:37 AM
porglezomp updated this revision to Diff 319228.Jan 26 2021, 12:35 AM

Add unit-tests in LegalizerHelperTest

Harbormaster completed remote builds in B86684: Diff 319228.Jan 26 2021, 1:30 AM
paquette added inline comments.Jan 26 2021, 9:59 AM
llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
1769

Can you add an unreachable case to make sure nobody passes an unexpected instruction here?

llvm/test/CodeGen/AArch64/GlobalISel/legalize-sadde.mir
5

Can these testcases have slightly more descriptive names?

32

Nit: we can give virtual registers names, and it usually makes it way easier to read + understand testcases (IMO).

Since the new testcases here are all pretty similar, do you think you could add names to the virtual registers?

porglezomp updated this revision to Diff 319633.Jan 27 2021, 11:19 AM

Add unreachable case, give vregs names in tests

Harbormaster completed remote builds in B86886: Diff 319633.Jan 27 2021, 12:39 PM
paquette accepted this revision.Jan 28 2021, 9:45 AM

LGTM

This revision is now accepted and ready to land.Jan 28 2021, 9:45 AM
This revision was landed with ongoing or failed builds.Jan 28 2021, 2:06 PM
Closed by commit rGf22f4557a749: [GlobalISel] Implement widenScalar for carry-in add/sub (authored by porglezomp). · Explain Why
This revision was automatically updated to reflect the committed changes.
porglezomp added a commit: rGf22f4557a749: [GlobalISel] Implement widenScalar for carry-in add/sub.

Revision Contents

PathSize
llvm/
include/
llvm/
CodeGen/
GlobalISel/
4 lines
lib/
CodeGen/
GlobalISel/
74 lines
test/
CodeGen/
AArch64/
GlobalISel/
36 lines
36 lines
37 lines
37 lines
AMDGPU/
GlobalISel/
17 lines
17 lines
18 lines
18 lines
unittests/
CodeGen/
GlobalISel/
160 lines

Diff 319959

llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h

Show First 20 Lines • Show All 164 Lines • ▼ Show 20 Linesprivate:
LegalizeResult LegalizeResult
widenScalarMergeValues(MachineInstr &MI, unsigned TypeIdx, LLT WideTy); widenScalarMergeValues(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
LegalizeResult LegalizeResult
widenScalarUnmergeValues(MachineInstr &MI, unsigned TypeIdx, LLT WideTy); widenScalarUnmergeValues(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
LegalizeResult LegalizeResult
widenScalarExtract(MachineInstr &MI, unsigned TypeIdx, LLT WideTy); widenScalarExtract(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
LegalizeResult LegalizeResult
widenScalarInsert(MachineInstr &MI, unsigned TypeIdx, LLT WideTy); widenScalarInsert(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
LegalizeResult widenScalarAddoSubo(MachineInstr &MI, unsigned TypeIdx, LegalizeResult widenScalarAddSubOverflow(MachineInstr &MI, unsigned TypeIdx,
LLT WideTy); LLT WideTy);
LegalizeResult widenScalarAddSubShlSat(MachineInstr &MI, unsigned TypeIdx, LegalizeResult widenScalarAddSubShlSat(MachineInstr &MI, unsigned TypeIdx,
LLT WideTy); LLT WideTy);
/// Helper function to split a wide generic register into bitwise blocks with /// Helper function to split a wide generic register into bitwise blocks with
/// the given Type (which implies the number of blocks needed). The generic /// the given Type (which implies the number of blocks needed). The generic
/// registers created are appended to Ops, starting at bit 0 of Reg. /// registers created are appended to Ops, starting at bit 0 of Reg.
void extractParts(Register Reg, LLT Ty, int NumParts, void extractParts(Register Reg, LLT Ty, int NumParts,
SmallVectorImpl<Register> &VRegs); SmallVectorImpl<Register> &VRegs);
▲ Show 20 Lines • Show All 215 Lines • Show Last 20 Lines

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

Show First 20 Lines • Show All 1,752 Lines • ▼ Show 20 LinesLegalizerHelper::widenScalarInsert(MachineInstr &MI, unsigned TypeIdx,
Observer.changingInstr(MI); Observer.changingInstr(MI);
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_ANYEXT); widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_ANYEXT);
widenScalarDst(MI, WideTy); widenScalarDst(MI, WideTy);
Observer.changedInstr(MI); Observer.changedInstr(MI);
return Legalized; return Legalized;
} }
LegalizerHelper::LegalizeResult LegalizerHelper::LegalizeResult
LegalizerHelper::widenScalarAddoSubo(MachineInstr &MI, unsigned TypeIdx, LegalizerHelper::widenScalarAddSubOverflow(MachineInstr &MI, unsigned TypeIdx,
LLT WideTy) { LLT WideTy) {
if (TypeIdx == 1) if (TypeIdx == 1)
return UnableToLegalize; // TODO return UnableToLegalize; // TODO
unsigned Op = MI.getOpcode();
unsigned Opcode = Op == TargetOpcode::G_UADDO || Op == TargetOpcode::G_SADDO unsigned Opcode;
? TargetOpcode::G_ADD unsigned ExtOpcode;
: TargetOpcode::G_SUB; Optional<Register> CarryIn = None;
arsenmUnsubmitted
Not Done
ReplyInline Actions

Should just use a plain Register here, MachineOperand values are generally bad

arsenm: Should just use a plain Register here, MachineOperand values are generally bad
unsigned ExtOpcode = switch (MI.getOpcode()) {
paquetteUnsubmitted
Not Done
ReplyInline Actions
Optional<Register> CarryIn = None;
switch (MI.getOpcode()) {
+ default:
+ llvm_unreachable("Unexpected opcode!");
case TargetOpcode::G_SADDO:

Can you add an unreachable case to make sure nobody passes an unexpected instruction here?

paquette: Can you add an unreachable case to make sure nobody passes an unexpected instruction here?
Op == TargetOpcode::G_UADDO || Op == TargetOpcode::G_USUBO default:
? TargetOpcode::G_ZEXT llvm_unreachable("Unexpected opcode!");
: TargetOpcode::G_SEXT; case TargetOpcode::G_SADDO:
Opcode = TargetOpcode::G_ADD;
ExtOpcode = TargetOpcode::G_SEXT;
break;
case TargetOpcode::G_SSUBO:
Opcode = TargetOpcode::G_SUB;
ExtOpcode = TargetOpcode::G_SEXT;
break;
case TargetOpcode::G_UADDO:
Opcode = TargetOpcode::G_ADD;
ExtOpcode = TargetOpcode::G_ZEXT;
break;
case TargetOpcode::G_USUBO:
Opcode = TargetOpcode::G_SUB;
ExtOpcode = TargetOpcode::G_ZEXT;
break;
case TargetOpcode::G_SADDE:
Opcode = TargetOpcode::G_UADDE;
ExtOpcode = TargetOpcode::G_SEXT;
CarryIn = MI.getOperand(4).getReg();
break;
case TargetOpcode::G_SSUBE:
Opcode = TargetOpcode::G_USUBE;
ExtOpcode = TargetOpcode::G_SEXT;
CarryIn = MI.getOperand(4).getReg();
break;
case TargetOpcode::G_UADDE:
Opcode = TargetOpcode::G_UADDE;
ExtOpcode = TargetOpcode::G_ZEXT;
CarryIn = MI.getOperand(4).getReg();
break;
case TargetOpcode::G_USUBE:
Opcode = TargetOpcode::G_USUBE;
ExtOpcode = TargetOpcode::G_ZEXT;
CarryIn = MI.getOperand(4).getReg();
break;
}
auto LHSExt = MIRBuilder.buildInstr(ExtOpcode, {WideTy}, {MI.getOperand(2)}); auto LHSExt = MIRBuilder.buildInstr(ExtOpcode, {WideTy}, {MI.getOperand(2)});
auto RHSExt = MIRBuilder.buildInstr(ExtOpcode, {WideTy}, {MI.getOperand(3)}); auto RHSExt = MIRBuilder.buildInstr(ExtOpcode, {WideTy}, {MI.getOperand(3)});
// Do the arithmetic in the larger type. // Do the arithmetic in the larger type.
auto NewOp = MIRBuilder.buildInstr(Opcode, {WideTy}, {LHSExt, RHSExt}); Register NewOp;
if (CarryIn) {
LLT CarryOutTy = MRI.getType(MI.getOperand(1).getReg());
NewOp = MIRBuilder
.buildInstr(Opcode, {WideTy, CarryOutTy},
{LHSExt, RHSExt, *CarryIn})
.getReg(0);
} else {
arsenmUnsubmitted
Not Done
ReplyInline Actions

This is .getReg(0)

arsenm: This is .getReg(0)
NewOp = MIRBuilder.buildInstr(Opcode, {WideTy}, {LHSExt, RHSExt}).getReg(0);
}
LLT OrigTy = MRI.getType(MI.getOperand(0).getReg()); LLT OrigTy = MRI.getType(MI.getOperand(0).getReg());
auto TruncOp = MIRBuilder.buildTrunc(OrigTy, NewOp); auto TruncOp = MIRBuilder.buildTrunc(OrigTy, NewOp);
auto ExtOp = MIRBuilder.buildInstr(ExtOpcode, {WideTy}, {TruncOp}); auto ExtOp = MIRBuilder.buildInstr(ExtOpcode, {WideTy}, {TruncOp});
// There is no overflow if the ExtOp is the same as NewOp. // There is no overflow if the ExtOp is the same as NewOp.
MIRBuilder.buildICmp(CmpInst::ICMP_NE, MI.getOperand(1), NewOp, ExtOp); MIRBuilder.buildICmp(CmpInst::ICMP_NE, MI.getOperand(1), NewOp, ExtOp);
// Now trunc the NewOp to the original result. // Now trunc the NewOp to the original result.
MIRBuilder.buildTrunc(MI.getOperand(0), NewOp); MIRBuilder.buildTrunc(MI.getOperand(0), NewOp);
MI.eraseFromParent(); MI.eraseFromParent();
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 LinesLegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
case TargetOpcode::G_MERGE_VALUES: case TargetOpcode::G_MERGE_VALUES:
return widenScalarMergeValues(MI, TypeIdx, WideTy); return widenScalarMergeValues(MI, TypeIdx, WideTy);
case TargetOpcode::G_UNMERGE_VALUES: case TargetOpcode::G_UNMERGE_VALUES:
return widenScalarUnmergeValues(MI, TypeIdx, WideTy); return widenScalarUnmergeValues(MI, TypeIdx, WideTy);
case TargetOpcode::G_SADDO: case TargetOpcode::G_SADDO:
case TargetOpcode::G_SSUBO: case TargetOpcode::G_SSUBO:
case TargetOpcode::G_UADDO: case TargetOpcode::G_UADDO:
case TargetOpcode::G_USUBO: case TargetOpcode::G_USUBO:
return widenScalarAddoSubo(MI, TypeIdx, WideTy); case TargetOpcode::G_SADDE:
case TargetOpcode::G_SSUBE:
case TargetOpcode::G_UADDE:
case TargetOpcode::G_USUBE:
return widenScalarAddSubOverflow(MI, TypeIdx, WideTy);
case TargetOpcode::G_SADDSAT: case TargetOpcode::G_SADDSAT:
case TargetOpcode::G_SSUBSAT: case TargetOpcode::G_SSUBSAT:
case TargetOpcode::G_SSHLSAT: case TargetOpcode::G_SSHLSAT:
case TargetOpcode::G_UADDSAT: case TargetOpcode::G_UADDSAT:
case TargetOpcode::G_USUBSAT: case TargetOpcode::G_USUBSAT:
case TargetOpcode::G_USHLSAT: case TargetOpcode::G_USHLSAT:
return widenScalarAddSubShlSat(MI, TypeIdx, WideTy); return widenScalarAddSubShlSat(MI, TypeIdx, WideTy);
case TargetOpcode::G_CTTZ: case TargetOpcode::G_CTTZ:
▲ Show 20 Lines • Show All 4,399 Lines • Show Last 20 Lines

llvm/test/CodeGen/AArch64/GlobalISel/legalize-sadde.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s # RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s
--- ---
name: widen_scalar_sadde_s8
paquetteUnsubmitted
Not Done
ReplyInline Actions
# RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s
---
- name: test_scalar_sadde_small
+ name: widen_scalar_sadde_s8
body: |

Can these testcases have slightly more descriptive names?

paquette: Can these testcases have slightly more descriptive names?
body: |
bb.0.entry:
; CHECK-LABEL: name: widen_scalar_sadde_s8
; CHECK: [[COPY:%[0-9]+]]:_(s64) = COPY $x0
; CHECK: [[COPY1:%[0-9]+]]:_(s64) = COPY $x1
; CHECK: [[COPY2:%[0-9]+]]:_(s64) = COPY $x2
; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY2]](s64)
; CHECK: [[TRUNC:%[0-9]+]]:_(s32) = G_TRUNC [[COPY]](s64)
; CHECK: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[TRUNC]], 8
; CHECK: [[TRUNC1:%[0-9]+]]:_(s32) = G_TRUNC [[COPY1]](s64)
; CHECK: [[SEXT_INREG1:%[0-9]+]]:_(s32) = G_SEXT_INREG [[TRUNC1]], 8
; CHECK: [[UADDE:%[0-9]+]]:_(s32), [[UADDE1:%[0-9]+]]:_(s1) = G_UADDE [[SEXT_INREG]], [[SEXT_INREG1]], %carry_in
; CHECK: [[TRUNC2:%[0-9]+]]:_(s8) = G_TRUNC [[UADDE]](s32)
; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[UADDE]](s32)
; CHECK: [[SEXT_INREG2:%[0-9]+]]:_(s32) = G_SEXT_INREG [[COPY3]], 8
; CHECK: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(ne), [[UADDE]](s32), [[SEXT_INREG2]]
; CHECK: %add:_(s8) = COPY [[TRUNC2]](s8)
; CHECK: %add_ext:_(s64) = G_ANYEXT [[UADDE]](s32)
; CHECK: %carry_out_ext:_(s64) = G_ANYEXT [[ICMP]](s32)
; CHECK: $x0 = COPY %add_ext(s64)
; CHECK: $x1 = COPY %carry_out_ext(s64)
%0:_(s64) = COPY $x0
%1:_(s64) = COPY $x1
%2:_(s64) = COPY $x2
%lhs:_(s8) = G_TRUNC %0
%rhs:_(s8) = G_TRUNC %1
%carry_in:_(s1) = G_TRUNC %2
paquetteUnsubmitted
Not Done
ReplyInline Actions
%4:_(s8) = G_TRUNC %1(s64)
- %5:_(s1) = G_TRUNC %2(s64)
+ %carry_in:_(s1) = G_TRUNC %2(s64)
%6:_(s8), %7:_(s1) = G_SADDE %3, %4, %5

Nit: we can give virtual registers names, and it usually makes it way easier to read + understand testcases (IMO).

Since the new testcases here are all pretty similar, do you think you could add names to the virtual registers?

paquette: Nit: we can give virtual registers names, and it usually makes it way easier to read +…
%add:_(s8), %carry_out:_(s1) = G_SADDE %lhs, %rhs, %carry_in
%add_ext:_(s64) = G_ANYEXT %add
%carry_out_ext:_(s64) = G_ANYEXT %carry_out
$x0 = COPY %add_ext
$x1 = COPY %carry_out_ext
...
---
name: test_scalar_sadde_32 name: test_scalar_sadde_32
body: | body: |
bb.0.entry: bb.0.entry:
; CHECK-LABEL: name: test_scalar_sadde_32 ; CHECK-LABEL: name: test_scalar_sadde_32
; CHECK: %lhs:_(s32) = COPY $w0 ; CHECK: %lhs:_(s32) = COPY $w0
; CHECK: %rhs:_(s32) = COPY $w1 ; CHECK: %rhs:_(s32) = COPY $w1
; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $w2 ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $w2
; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY]](s32) ; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY]](s32)
Show All 14 Lines

llvm/test/CodeGen/AArch64/GlobalISel/legalize-ssube.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s # RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s
--- ---
name: widen_scalar_ssube_s8
body: |
bb.0.entry:
; CHECK-LABEL: name: widen_scalar_ssube_s8
; CHECK: [[COPY:%[0-9]+]]:_(s64) = COPY $x0
; CHECK: [[COPY1:%[0-9]+]]:_(s64) = COPY $x1
; CHECK: [[COPY2:%[0-9]+]]:_(s64) = COPY $x2
; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY2]](s64)
; CHECK: [[TRUNC:%[0-9]+]]:_(s32) = G_TRUNC [[COPY]](s64)
; CHECK: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[TRUNC]], 8
; CHECK: [[TRUNC1:%[0-9]+]]:_(s32) = G_TRUNC [[COPY1]](s64)
; CHECK: [[SEXT_INREG1:%[0-9]+]]:_(s32) = G_SEXT_INREG [[TRUNC1]], 8
; CHECK: [[USUBE:%[0-9]+]]:_(s32), [[USUBE1:%[0-9]+]]:_(s1) = G_USUBE [[SEXT_INREG]], [[SEXT_INREG1]], %carry_in
; CHECK: [[TRUNC2:%[0-9]+]]:_(s8) = G_TRUNC [[USUBE]](s32)
; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[USUBE]](s32)
; CHECK: [[SEXT_INREG2:%[0-9]+]]:_(s32) = G_SEXT_INREG [[COPY3]], 8
; CHECK: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(ne), [[USUBE]](s32), [[SEXT_INREG2]]
; CHECK: %sub:_(s8) = COPY [[TRUNC2]](s8)
; CHECK: %sub_ext:_(s64) = G_ANYEXT [[USUBE]](s32)
; CHECK: %carry_out_ext:_(s64) = G_ANYEXT [[ICMP]](s32)
; CHECK: $x0 = COPY %sub_ext(s64)
; CHECK: $x1 = COPY %carry_out_ext(s64)
%0:_(s64) = COPY $x0
%1:_(s64) = COPY $x1
%2:_(s64) = COPY $x2
%lhs:_(s8) = G_TRUNC %0
%rhs:_(s8) = G_TRUNC %1
%carry_in:_(s1) = G_TRUNC %2
%sub:_(s8), %carry_out:_(s1) = G_SSUBE %lhs, %rhs, %carry_in
%sub_ext:_(s64) = G_ANYEXT %sub
%carry_out_ext:_(s64) = G_ANYEXT %carry_out
$x0 = COPY %sub_ext
$x1 = COPY %carry_out_ext
...
---
name: test_scalar_ssube_32 name: test_scalar_ssube_32
body: | body: |
bb.0.entry: bb.0.entry:
; CHECK-LABEL: name: test_scalar_ssube_32 ; CHECK-LABEL: name: test_scalar_ssube_32
; CHECK: %lhs:_(s32) = COPY $w0 ; CHECK: %lhs:_(s32) = COPY $w0
; CHECK: %rhs:_(s32) = COPY $w1 ; CHECK: %rhs:_(s32) = COPY $w1
; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $w2 ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $w2
; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY]](s32) ; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY]](s32)
Show All 14 Lines

llvm/test/CodeGen/AArch64/GlobalISel/legalize-uadde.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s # RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s
--- ---
name: widen_scalar_uadde_s8
body: |
bb.0.entry:
; CHECK-LABEL: name: widen_scalar_uadde_s8
; CHECK: [[COPY:%[0-9]+]]:_(s64) = COPY $x0
; CHECK: [[COPY1:%[0-9]+]]:_(s64) = COPY $x1
; CHECK: [[COPY2:%[0-9]+]]:_(s64) = COPY $x2
; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY2]](s64)
; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 255
; CHECK: [[TRUNC:%[0-9]+]]:_(s32) = G_TRUNC [[COPY]](s64)
; CHECK: [[AND:%[0-9]+]]:_(s32) = G_AND [[TRUNC]], [[C]]
; CHECK: [[TRUNC1:%[0-9]+]]:_(s32) = G_TRUNC [[COPY1]](s64)
; CHECK: [[AND1:%[0-9]+]]:_(s32) = G_AND [[TRUNC1]], [[C]]
; CHECK: [[UADDE:%[0-9]+]]:_(s32), [[UADDE1:%[0-9]+]]:_(s1) = G_UADDE [[AND]], [[AND1]], %carry_in
; CHECK: [[TRUNC2:%[0-9]+]]:_(s8) = G_TRUNC [[UADDE]](s32)
; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[UADDE]](s32)
; CHECK: [[AND2:%[0-9]+]]:_(s32) = G_AND [[COPY3]], [[C]]
; CHECK: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(ne), [[UADDE]](s32), [[AND2]]
; CHECK: %add:_(s8) = COPY [[TRUNC2]](s8)
; CHECK: %add_ext:_(s64) = G_ANYEXT [[UADDE]](s32)
; CHECK: %carry_out_ext:_(s64) = G_ANYEXT [[ICMP]](s32)
; CHECK: $x0 = COPY %add_ext(s64)
; CHECK: $x1 = COPY %carry_out_ext(s64)
%0:_(s64) = COPY $x0
%1:_(s64) = COPY $x1
%2:_(s64) = COPY $x2
%lhs:_(s8) = G_TRUNC %0
%rhs:_(s8) = G_TRUNC %1
%carry_in:_(s1) = G_TRUNC %2
%add:_(s8), %carry_out:_(s1) = G_UADDE %lhs, %rhs, %carry_in
%add_ext:_(s64) = G_ANYEXT %add
%carry_out_ext:_(s64) = G_ANYEXT %carry_out
$x0 = COPY %add_ext
$x1 = COPY %carry_out_ext
...
---
name: test_scalar_uadde_32 name: test_scalar_uadde_32
body: | body: |
bb.0.entry: bb.0.entry:
; CHECK-LABEL: name: test_scalar_uadde_32 ; CHECK-LABEL: name: test_scalar_uadde_32
; CHECK: %lhs:_(s32) = COPY $w0 ; CHECK: %lhs:_(s32) = COPY $w0
; CHECK: %rhs:_(s32) = COPY $w1 ; CHECK: %rhs:_(s32) = COPY $w1
; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $w2 ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $w2
; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY]](s32) ; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY]](s32)
Show All 14 Lines

llvm/test/CodeGen/AArch64/GlobalISel/legalize-usube.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s # RUN: llc -mtriple aarch64 -verify-machineinstrs -run-pass=legalizer -debugify-and-strip-all-safe %s -o - | FileCheck %s
--- ---
name: widen_scalar_usube_s8
body: |
bb.0.entry:
; CHECK-LABEL: name: widen_scalar_usube_s8
; CHECK: [[COPY:%[0-9]+]]:_(s64) = COPY $x0
; CHECK: [[COPY1:%[0-9]+]]:_(s64) = COPY $x1
; CHECK: [[COPY2:%[0-9]+]]:_(s64) = COPY $x2
; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY2]](s64)
; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 255
; CHECK: [[TRUNC:%[0-9]+]]:_(s32) = G_TRUNC [[COPY]](s64)
; CHECK: [[AND:%[0-9]+]]:_(s32) = G_AND [[TRUNC]], [[C]]
; CHECK: [[TRUNC1:%[0-9]+]]:_(s32) = G_TRUNC [[COPY1]](s64)
; CHECK: [[AND1:%[0-9]+]]:_(s32) = G_AND [[TRUNC1]], [[C]]
; CHECK: [[USUBE:%[0-9]+]]:_(s32), [[USUBE1:%[0-9]+]]:_(s1) = G_USUBE [[AND]], [[AND1]], %carry_in
; CHECK: [[TRUNC2:%[0-9]+]]:_(s8) = G_TRUNC [[USUBE]](s32)
; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[USUBE]](s32)
; CHECK: [[AND2:%[0-9]+]]:_(s32) = G_AND [[COPY3]], [[C]]
; CHECK: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(ne), [[USUBE]](s32), [[AND2]]
; CHECK: %sub:_(s8) = COPY [[TRUNC2]](s8)
; CHECK: %sub_ext:_(s64) = G_ANYEXT [[USUBE]](s32)
; CHECK: %carry_out_ext:_(s64) = G_ANYEXT [[ICMP]](s32)
; CHECK: $x0 = COPY %sub_ext(s64)
; CHECK: $x1 = COPY %carry_out_ext(s64)
%0:_(s64) = COPY $x0
%1:_(s64) = COPY $x1
%2:_(s64) = COPY $x2
%lhs:_(s8) = G_TRUNC %0
%rhs:_(s8) = G_TRUNC %1
%carry_in:_(s1) = G_TRUNC %2
%sub:_(s8), %carry_out:_(s1) = G_USUBE %lhs, %rhs, %carry_in
%sub_ext:_(s64) = G_ANYEXT %sub
%carry_out_ext:_(s64) = G_ANYEXT %carry_out
$x0 = COPY %sub_ext
$x1 = COPY %carry_out_ext
...
---
name: test_scalar_usube_32 name: test_scalar_usube_32
body: | body: |
bb.0.entry: bb.0.entry:
; CHECK-LABEL: name: test_scalar_usube_32 ; CHECK-LABEL: name: test_scalar_usube_32
; CHECK: %lhs:_(s32) = COPY $w0 ; CHECK: %lhs:_(s32) = COPY $w0
; CHECK: %rhs:_(s32) = COPY $w1 ; CHECK: %rhs:_(s32) = COPY $w1
; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $w2 ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $w2
; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY]](s32) ; CHECK: %carry_in:_(s1) = G_TRUNC [[COPY]](s32)
Show All 14 Lines

llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-sadde.mir

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines bb.0:
liveins: $vgpr0, $vgpr1, $vgpr2 liveins: $vgpr0, $vgpr1, $vgpr2
; CHECK-LABEL: name: test_sadde_s16 ; CHECK-LABEL: name: test_sadde_s16
; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0
; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1
; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2 ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2
; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 ; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
; CHECK: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[COPY2]](s32), [[C]] ; CHECK: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[COPY2]](s32), [[C]]
; CHECK: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s32) ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[COPY1]](s32)
; CHECK: [[TRUNC1:%[0-9]+]]:_(s16) = G_TRUNC [[COPY1]](s32) ; CHECK: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[COPY3]], 16
; CHECK: [[SADDE:%[0-9]+]]:_(s16), [[SADDE1:%[0-9]+]]:_(s1) = G_SADDE [[TRUNC1]], [[SADDE]], [[ICMP]] ; CHECK: [[COPY4:%[0-9]+]]:_(s32) = COPY %13(s32)
; CHECK: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[SADDE]](s16) ; CHECK: [[SEXT_INREG1:%[0-9]+]]:_(s32) = G_SEXT_INREG [[COPY4]], 16
; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[SADDE1]](s1) ; CHECK: [[UADDE:%[0-9]+]]:_(s32), [[UADDE1:%[0-9]+]]:_(s1) = G_UADDE [[SEXT_INREG]], [[SEXT_INREG1]], [[ICMP]]
; CHECK: $vgpr0 = COPY [[ANYEXT]](s32) ; CHECK: [[COPY5:%[0-9]+]]:_(s32) = COPY [[UADDE]](s32)
; CHECK: [[SEXT_INREG2:%[0-9]+]]:_(s32) = G_SEXT_INREG [[COPY5]], 16
; CHECK: [[ICMP1:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[UADDE]](s32), [[SEXT_INREG2]]
; CHECK: [[COPY6:%[0-9]+]]:_(s32) = COPY [[UADDE]](s32)
; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP1]](s1)
; CHECK: $vgpr0 = COPY [[COPY6]](s32)
; CHECK: $vgpr1 = COPY [[ZEXT]](s32) ; CHECK: $vgpr1 = COPY [[ZEXT]](s32)
%0:_(s32) = COPY $vgpr0 %0:_(s32) = COPY $vgpr0
%1:_(s32) = COPY $vgpr1 %1:_(s32) = COPY $vgpr1
%2:_(s32) = COPY $vgpr2 %2:_(s32) = COPY $vgpr2
%3:_(s32) = G_CONSTANT i32 0 %3:_(s32) = G_CONSTANT i32 0
%4:_(s1) = G_ICMP intpred(eq), %2, %3 %4:_(s1) = G_ICMP intpred(eq), %2, %3
%5:_(s16) = G_TRUNC %0 %5:_(s16) = G_TRUNC %0
%6:_(s16) = G_TRUNC %1 %6:_(s16) = G_TRUNC %1
Show All 33 Lines

llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-ssube.mir

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines bb.0:
liveins: $vgpr0, $vgpr1, $vgpr2 liveins: $vgpr0, $vgpr1, $vgpr2
; CHECK-LABEL: name: test_ssube_s16 ; CHECK-LABEL: name: test_ssube_s16
; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0
; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1
; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2 ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2
; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 ; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
; CHECK: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[COPY2]](s32), [[C]] ; CHECK: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[COPY2]](s32), [[C]]
; CHECK: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s32) ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[COPY1]](s32)
; CHECK: [[TRUNC1:%[0-9]+]]:_(s16) = G_TRUNC [[COPY1]](s32) ; CHECK: [[SEXT_INREG:%[0-9]+]]:_(s32) = G_SEXT_INREG [[COPY3]], 16
; CHECK: [[SSUBE:%[0-9]+]]:_(s16), [[SSUBE1:%[0-9]+]]:_(s1) = G_SSUBE [[TRUNC1]], [[SSUBE]], [[ICMP]] ; CHECK: [[COPY4:%[0-9]+]]:_(s32) = COPY %13(s32)
; CHECK: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[SSUBE]](s16) ; CHECK: [[SEXT_INREG1:%[0-9]+]]:_(s32) = G_SEXT_INREG [[COPY4]], 16
; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[SSUBE1]](s1) ; CHECK: [[USUBE:%[0-9]+]]:_(s32), [[USUBE1:%[0-9]+]]:_(s1) = G_USUBE [[SEXT_INREG]], [[SEXT_INREG1]], [[ICMP]]
; CHECK: $vgpr0 = COPY [[ANYEXT]](s32) ; CHECK: [[COPY5:%[0-9]+]]:_(s32) = COPY [[USUBE]](s32)
; CHECK: [[SEXT_INREG2:%[0-9]+]]:_(s32) = G_SEXT_INREG [[COPY5]], 16
; CHECK: [[ICMP1:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[USUBE]](s32), [[SEXT_INREG2]]
; CHECK: [[COPY6:%[0-9]+]]:_(s32) = COPY [[USUBE]](s32)
; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP1]](s1)
; CHECK: $vgpr0 = COPY [[COPY6]](s32)
; CHECK: $vgpr1 = COPY [[ZEXT]](s32) ; CHECK: $vgpr1 = COPY [[ZEXT]](s32)
%0:_(s32) = COPY $vgpr0 %0:_(s32) = COPY $vgpr0
%1:_(s32) = COPY $vgpr1 %1:_(s32) = COPY $vgpr1
%2:_(s32) = COPY $vgpr2 %2:_(s32) = COPY $vgpr2
%3:_(s32) = G_CONSTANT i32 0 %3:_(s32) = G_CONSTANT i32 0
%4:_(s1) = G_ICMP intpred(eq), %2, %3 %4:_(s1) = G_ICMP intpred(eq), %2, %3
%5:_(s16) = G_TRUNC %0 %5:_(s16) = G_TRUNC %0
%6:_(s16) = G_TRUNC %1 %6:_(s16) = G_TRUNC %1
Show All 33 Lines

llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-uadde.mir

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines bb.0:
liveins: $vgpr0, $vgpr1, $vgpr2 liveins: $vgpr0, $vgpr1, $vgpr2
; CHECK-LABEL: name: test_uadde_s16 ; CHECK-LABEL: name: test_uadde_s16
; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0
; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1
; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2 ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2
; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 ; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
; CHECK: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[COPY2]](s32), [[C]] ; CHECK: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[COPY2]](s32), [[C]]
; CHECK: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s32) ; CHECK: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 65535
; CHECK: [[TRUNC1:%[0-9]+]]:_(s16) = G_TRUNC [[COPY1]](s32) ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[COPY1]](s32)
; CHECK: [[UADDE:%[0-9]+]]:_(s16), [[UADDE1:%[0-9]+]]:_(s1) = G_UADDE [[TRUNC1]], [[UADDE]], [[ICMP]] ; CHECK: [[AND:%[0-9]+]]:_(s32) = G_AND [[COPY3]], [[C1]]
; CHECK: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[UADDE]](s16) ; CHECK: [[COPY4:%[0-9]+]]:_(s32) = COPY %13(s32)
; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[UADDE1]](s1) ; CHECK: [[AND1:%[0-9]+]]:_(s32) = G_AND [[COPY4]], [[C1]]
; CHECK: $vgpr0 = COPY [[ANYEXT]](s32) ; CHECK: [[UADDE:%[0-9]+]]:_(s32), [[UADDE1:%[0-9]+]]:_(s1) = G_UADDE [[AND]], [[AND1]], [[ICMP]]
; CHECK: [[COPY5:%[0-9]+]]:_(s32) = COPY [[UADDE]](s32)
; CHECK: [[AND2:%[0-9]+]]:_(s32) = G_AND [[COPY5]], [[C1]]
; CHECK: [[ICMP1:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[UADDE]](s32), [[AND2]]
; CHECK: [[COPY6:%[0-9]+]]:_(s32) = COPY [[UADDE]](s32)
; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP1]](s1)
; CHECK: $vgpr0 = COPY [[COPY6]](s32)
; CHECK: $vgpr1 = COPY [[ZEXT]](s32) ; CHECK: $vgpr1 = COPY [[ZEXT]](s32)
%0:_(s32) = COPY $vgpr0 %0:_(s32) = COPY $vgpr0
%1:_(s32) = COPY $vgpr1 %1:_(s32) = COPY $vgpr1
%2:_(s32) = COPY $vgpr2 %2:_(s32) = COPY $vgpr2
%3:_(s32) = G_CONSTANT i32 0 %3:_(s32) = G_CONSTANT i32 0
%4:_(s1) = G_ICMP intpred(eq), %2, %3 %4:_(s1) = G_ICMP intpred(eq), %2, %3
%5:_(s16) = G_TRUNC %0 %5:_(s16) = G_TRUNC %0
%6:_(s16) = G_TRUNC %1 %6:_(s16) = G_TRUNC %1
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/GlobalISel/legalize-usube.mir

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines bb.0:
liveins: $vgpr0, $vgpr1, $vgpr2 liveins: $vgpr0, $vgpr1, $vgpr2
; CHECK-LABEL: name: test_usube_s16 ; CHECK-LABEL: name: test_usube_s16
; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0 ; CHECK: [[COPY:%[0-9]+]]:_(s32) = COPY $vgpr0
; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1 ; CHECK: [[COPY1:%[0-9]+]]:_(s32) = COPY $vgpr1
; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2 ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY $vgpr2
; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0 ; CHECK: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
; CHECK: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[COPY2]](s32), [[C]] ; CHECK: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[COPY2]](s32), [[C]]
; CHECK: [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s32) ; CHECK: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 65535
; CHECK: [[TRUNC1:%[0-9]+]]:_(s16) = G_TRUNC [[COPY1]](s32) ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[COPY1]](s32)
; CHECK: [[USUBE:%[0-9]+]]:_(s16), [[USUBE1:%[0-9]+]]:_(s1) = G_USUBE [[TRUNC1]], [[USUBE]], [[ICMP]] ; CHECK: [[AND:%[0-9]+]]:_(s32) = G_AND [[COPY3]], [[C1]]
; CHECK: [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[USUBE]](s16) ; CHECK: [[COPY4:%[0-9]+]]:_(s32) = COPY %13(s32)
; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[USUBE1]](s1) ; CHECK: [[AND1:%[0-9]+]]:_(s32) = G_AND [[COPY4]], [[C1]]
; CHECK: $vgpr0 = COPY [[ANYEXT]](s32) ; CHECK: [[USUBE:%[0-9]+]]:_(s32), [[USUBE1:%[0-9]+]]:_(s1) = G_USUBE [[AND]], [[AND1]], [[ICMP]]
; CHECK: [[COPY5:%[0-9]+]]:_(s32) = COPY [[USUBE]](s32)
; CHECK: [[AND2:%[0-9]+]]:_(s32) = G_AND [[COPY5]], [[C1]]
; CHECK: [[ICMP1:%[0-9]+]]:_(s1) = G_ICMP intpred(ne), [[USUBE]](s32), [[AND2]]
; CHECK: [[COPY6:%[0-9]+]]:_(s32) = COPY [[USUBE]](s32)
; CHECK: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP1]](s1)
; CHECK: $vgpr0 = COPY [[COPY6]](s32)
; CHECK: $vgpr1 = COPY [[ZEXT]](s32) ; CHECK: $vgpr1 = COPY [[ZEXT]](s32)
%0:_(s32) = COPY $vgpr0 %0:_(s32) = COPY $vgpr0
%1:_(s32) = COPY $vgpr1 %1:_(s32) = COPY $vgpr1
%2:_(s32) = COPY $vgpr2 %2:_(s32) = COPY $vgpr2
%3:_(s32) = G_CONSTANT i32 0 %3:_(s32) = G_CONSTANT i32 0
%4:_(s1) = G_ICMP intpred(eq), %2, %3 %4:_(s1) = G_ICMP intpred(eq), %2, %3
%5:_(s16) = G_TRUNC %0 %5:_(s16) = G_TRUNC %0
%6:_(s16) = G_TRUNC %1 %6:_(s16) = G_TRUNC %1
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp

Show First 20 Lines • Show All 710 Lines • ▼ Show 20 LinesTEST_F(AArch64GISelMITest, WidenSSUBO) {
CHECK: G_ICMP intpred(ne), [[SUB]]:_(s16), [[SEXT]]:_ CHECK: G_ICMP intpred(ne), [[SUB]]:_(s16), [[SEXT]]:_
CHECK: G_TRUNC [[SUB]] CHECK: G_TRUNC [[SUB]]
)"; )";
// Check // Check
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF; EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
} }
TEST_F(AArch64GISelMITest, WidenUADDE) {
setUp();
if (!TM)
return;
// Declare your legalization info
DefineLegalizerInfo(A, {
getActionDefinitionsBuilder(G_UADDE).legalFor({{s16, s16}});
});
// Build
// Trunc it to s8.
LLT s8{LLT::scalar(8)};
LLT s16{LLT::scalar(16)};
auto MIBTrunc = B.buildTrunc(s8, Copies[0]);
auto CarryIn = B.buildUndef(LLT::scalar(1));
Register CarryReg = MRI->createGenericVirtualRegister(LLT::scalar(1));
auto MIBUAddO = B.buildInstr(TargetOpcode::G_UADDE, {s8, CarryReg},
{MIBTrunc, MIBTrunc, CarryIn});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
LegalizerHelper Helper(*MF, Info, Observer, B);
EXPECT_TRUE(Helper.widenScalar(*MIBUAddO, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
const char *CheckStr = R"(
CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC
CHECK: [[Implicit:%[0-9]+]]:_(s1) = G_IMPLICIT_DEF
CHECK: [[LHS:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]]
CHECK: [[RHS:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]]
CHECK: [[UADDE:%[0-9]+]]:_(s16), [[CARRY:%[0-9]+]]:_(s1) = G_UADDE [[LHS]]:_, [[RHS]]:_, [[Implicit]]:_
CHECK: [[TRUNC1:%[0-9]+]]:_(s8) = G_TRUNC [[UADDE]]
CHECK: [[ZEXT:%[0-9]+]]:_(s16) = G_ZEXT [[TRUNC1]]
CHECK: G_ICMP intpred(ne), [[UADDE]]:_(s16), [[ZEXT]]:_
CHECK: G_TRUNC [[UADDE]]
)";
// Check
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
}
TEST_F(AArch64GISelMITest, WidenUSUBE) {
setUp();
if (!TM)
return;
// Declare your legalization info
DefineLegalizerInfo(A, {
getActionDefinitionsBuilder(G_USUBE).legalFor({{s16, s16}});
});
// Build
// Trunc it to s8.
LLT s8{LLT::scalar(8)};
LLT s16{LLT::scalar(16)};
auto MIBTrunc = B.buildTrunc(s8, Copies[0]);
auto CarryIn = B.buildUndef(LLT::scalar(1));
Register CarryReg = MRI->createGenericVirtualRegister(LLT::scalar(1));
auto MIBUSUBE = B.buildInstr(TargetOpcode::G_USUBE, {s8, CarryReg},
{MIBTrunc, MIBTrunc, CarryIn});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
LegalizerHelper Helper(*MF, Info, Observer, B);
EXPECT_TRUE(Helper.widenScalar(*MIBUSUBE, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
const char *CheckStr = R"(
CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC
CHECK: [[Implicit:%[0-9]+]]:_(s1) = G_IMPLICIT_DEF
CHECK: [[LHS:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]]
CHECK: [[RHS:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]]
CHECK: [[USUBE:%[0-9]+]]:_(s16), [[CARRY:%[0-9]+]]:_(s1) = G_USUBE [[LHS]]:_, [[RHS]]:_, [[Implicit]]:_
CHECK: [[TRUNC1:%[0-9]+]]:_(s8) = G_TRUNC [[USUBE]]
CHECK: [[ZEXT:%[0-9]+]]:_(s16) = G_ZEXT [[TRUNC1]]
CHECK: G_ICMP intpred(ne), [[USUBE]]:_(s16), [[ZEXT]]:_
CHECK: G_TRUNC [[USUBE]]
)";
// Check
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
}
TEST_F(AArch64GISelMITest, WidenSADDE) {
setUp();
if (!TM)
return;
// Declare your legalization info
DefineLegalizerInfo(A, {
getActionDefinitionsBuilder({G_SADDE, G_UADDE}).legalFor({{s16, s16}});
});
// Build
// Trunc it to s8.
LLT s8{LLT::scalar(8)};
LLT s16{LLT::scalar(16)};
auto MIBTrunc = B.buildTrunc(s8, Copies[0]);
auto CarryIn = B.buildUndef(LLT::scalar(1));
Register CarryReg = MRI->createGenericVirtualRegister(LLT::scalar(1));
auto MIBUAddO = B.buildInstr(TargetOpcode::G_SADDE, {s8, CarryReg},
{MIBTrunc, MIBTrunc, CarryIn});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
LegalizerHelper Helper(*MF, Info, Observer, B);
EXPECT_TRUE(Helper.widenScalar(*MIBUAddO, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
const char *CheckStr = R"(
CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC
CHECK: [[Implicit:%[0-9]+]]:_(s1) = G_IMPLICIT_DEF
CHECK: [[LHS:%[0-9]+]]:_(s16) = G_SEXT [[Trunc]]
CHECK: [[RHS:%[0-9]+]]:_(s16) = G_SEXT [[Trunc]]
CHECK: [[SADDE:%[0-9]+]]:_(s16), [[CARRY:%[0-9]+]]:_(s1) = G_UADDE [[LHS]]:_, [[RHS]]:_, [[Implicit]]:_
CHECK: [[TRUNC1:%[0-9]+]]:_(s8) = G_TRUNC [[SADDE]]
CHECK: [[SEXT:%[0-9]+]]:_(s16) = G_SEXT [[TRUNC1]]
CHECK: G_ICMP intpred(ne), [[SADDE]]:_(s16), [[SEXT]]:_
CHECK: G_TRUNC [[SADDE]]
)";
// Check
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
}
TEST_F(AArch64GISelMITest, WidenSSUBE) {
setUp();
if (!TM)
return;
// Declare your legalization info
DefineLegalizerInfo(A, {
getActionDefinitionsBuilder({G_SSUBE, G_USUBE}).legalFor({{s16, s16}});
});
// Build
// Trunc it to s8.
LLT s8{LLT::scalar(8)};
LLT s16{LLT::scalar(16)};
auto MIBTrunc = B.buildTrunc(s8, Copies[0]);
auto CarryIn = B.buildUndef(LLT::scalar(1));
Register CarryReg = MRI->createGenericVirtualRegister(LLT::scalar(1));
auto MIBSSUBE = B.buildInstr(TargetOpcode::G_SSUBE, {s8, CarryReg},
{MIBTrunc, MIBTrunc, CarryIn});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
LegalizerHelper Helper(*MF, Info, Observer, B);
EXPECT_TRUE(Helper.widenScalar(*MIBSSUBE, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
const char *CheckStr = R"(
CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC
CHECK: [[Implicit:%[0-9]+]]:_(s1) = G_IMPLICIT_DEF
CHECK: [[LHS:%[0-9]+]]:_(s16) = G_SEXT [[Trunc]]
CHECK: [[RHS:%[0-9]+]]:_(s16) = G_SEXT [[Trunc]]
CHECK: [[SSUBE:%[0-9]+]]:_(s16), [[CARRY:%[0-9]+]]:_(s1) = G_USUBE [[LHS]]:_, [[RHS]]:_, [[Implicit]]:_
CHECK: [[TRUNC1:%[0-9]+]]:_(s8) = G_TRUNC [[SSUBE]]
CHECK: [[SEXT:%[0-9]+]]:_(s16) = G_SEXT [[TRUNC1]]
CHECK: G_ICMP intpred(ne), [[SSUBE]]:_(s16), [[SEXT]]:_
CHECK: G_TRUNC [[SSUBE]]
)";
// Check
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
}
TEST_F(AArch64GISelMITest, FewerElementsAnd) { TEST_F(AArch64GISelMITest, FewerElementsAnd) {
if (!TM) if (!TM)
return; return;
const LLT V2S32 = LLT::vector(2, 32); const LLT V2S32 = LLT::vector(2, 32);
const LLT V5S32 = LLT::vector(5, 32); const LLT V5S32 = LLT::vector(5, 32);
// Declare your legalization info // Declare your legalization info
▲ Show 20 Lines • Show All 2,534 Lines • Show Last 20 Lines