[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
|
|
|
|
; RUN: llc -mtriple=riscv64 -verify-machineinstrs < %s \
|
|
|
|
; RUN: | FileCheck -check-prefix=RV64I %s
|
|
|
|
|
|
|
|
; Check indexed and unindexed, sext, zext and anyext loads
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @lb(i8 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: lb:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: lb a1, 1(a0)
|
|
|
|
; RV64I-NEXT: lb a0, 0(a0)
|
|
|
|
; RV64I-NEXT: mv a0, a1
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
%1 = getelementptr i8, i8* %a, i32 1
|
|
|
|
%2 = load i8, i8* %1
|
|
|
|
%3 = sext i8 %2 to i64
|
|
|
|
; the unused load will produce an anyext for selection
|
|
|
|
%4 = load volatile i8, i8* %a
|
|
|
|
ret i64 %3
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @lh(i16 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: lh:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: lh a1, 4(a0)
|
|
|
|
; RV64I-NEXT: lh a0, 0(a0)
|
|
|
|
; RV64I-NEXT: mv a0, a1
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
%1 = getelementptr i16, i16* %a, i32 2
|
|
|
|
%2 = load i16, i16* %1
|
|
|
|
%3 = sext i16 %2 to i64
|
|
|
|
; the unused load will produce an anyext for selection
|
|
|
|
%4 = load volatile i16, i16* %a
|
|
|
|
ret i64 %3
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @lw(i32 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: lw:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: lw a1, 12(a0)
|
|
|
|
; RV64I-NEXT: lw a0, 0(a0)
|
|
|
|
; RV64I-NEXT: mv a0, a1
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
%1 = getelementptr i32, i32* %a, i32 3
|
|
|
|
%2 = load i32, i32* %1
|
|
|
|
%3 = sext i32 %2 to i64
|
|
|
|
; the unused load will produce an anyext for selection
|
|
|
|
%4 = load volatile i32, i32* %a
|
|
|
|
ret i64 %3
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @lbu(i8 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: lbu:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: lbu a1, 4(a0)
|
|
|
|
; RV64I-NEXT: lbu a0, 0(a0)
|
|
|
|
; RV64I-NEXT: add a0, a1, a0
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
%1 = getelementptr i8, i8* %a, i32 4
|
|
|
|
%2 = load i8, i8* %1
|
|
|
|
%3 = zext i8 %2 to i64
|
|
|
|
%4 = load volatile i8, i8* %a
|
|
|
|
%5 = zext i8 %4 to i64
|
|
|
|
%6 = add i64 %3, %5
|
|
|
|
ret i64 %6
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @lhu(i16 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: lhu:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: lhu a1, 10(a0)
|
|
|
|
; RV64I-NEXT: lhu a0, 0(a0)
|
|
|
|
; RV64I-NEXT: add a0, a1, a0
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
%1 = getelementptr i16, i16* %a, i32 5
|
|
|
|
%2 = load i16, i16* %1
|
|
|
|
%3 = zext i16 %2 to i64
|
|
|
|
%4 = load volatile i16, i16* %a
|
|
|
|
%5 = zext i16 %4 to i64
|
|
|
|
%6 = add i64 %3, %5
|
|
|
|
ret i64 %6
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @lwu(i32 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: lwu:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: lwu a1, 24(a0)
|
|
|
|
; RV64I-NEXT: lwu a0, 0(a0)
|
|
|
|
; RV64I-NEXT: add a0, a1, a0
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
%1 = getelementptr i32, i32* %a, i32 6
|
|
|
|
%2 = load i32, i32* %1
|
|
|
|
%3 = zext i32 %2 to i64
|
|
|
|
%4 = load volatile i32, i32* %a
|
|
|
|
%5 = zext i32 %4 to i64
|
|
|
|
%6 = add i64 %3, %5
|
|
|
|
ret i64 %6
|
|
|
|
}
|
|
|
|
|
|
|
|
; Check indexed and unindexed stores
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local void @sb(i8 *%a, i8 %b) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: sb:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 12:52:09 +02:00
|
|
|
; RV64I-NEXT: sb a1, 0(a0)
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: sb a1, 7(a0)
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
store i8 %b, i8* %a
|
|
|
|
%1 = getelementptr i8, i8* %a, i32 7
|
|
|
|
store i8 %b, i8* %1
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local void @sh(i16 *%a, i16 %b) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: sh:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 12:52:09 +02:00
|
|
|
; RV64I-NEXT: sh a1, 0(a0)
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: sh a1, 16(a0)
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
store i16 %b, i16* %a
|
|
|
|
%1 = getelementptr i16, i16* %a, i32 8
|
|
|
|
store i16 %b, i16* %1
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local void @sw(i32 *%a, i32 %b) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: sw:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 12:52:09 +02:00
|
|
|
; RV64I-NEXT: sw a1, 0(a0)
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: sw a1, 36(a0)
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
store i32 %b, i32* %a
|
|
|
|
%1 = getelementptr i32, i32* %a, i32 9
|
|
|
|
store i32 %b, i32* %1
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
|
|
|
; 64-bit loads and stores
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @ld(i64 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: ld:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: ld a1, 80(a0)
|
|
|
|
; RV64I-NEXT: ld a0, 0(a0)
|
|
|
|
; RV64I-NEXT: mv a0, a1
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
%1 = getelementptr i64, i64* %a, i32 10
|
|
|
|
%2 = load i64, i64* %1
|
|
|
|
%3 = load volatile i64, i64* %a
|
|
|
|
ret i64 %2
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local void @sd(i64 *%a, i64 %b) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: sd:
|
|
|
|
; RV64I: # %bb.0:
|
2019-09-17 12:52:09 +02:00
|
|
|
; RV64I-NEXT: sd a1, 0(a0)
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: sd a1, 88(a0)
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
store i64 %b, i64* %a
|
|
|
|
%1 = getelementptr i64, i64* %a, i32 11
|
|
|
|
store i64 %b, i64* %1
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
|
|
|
; Check load and store to an i1 location
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @load_sext_zext_anyext_i1(i1 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: load_sext_zext_anyext_i1:
|
|
|
|
; RV64I: # %bb.0:
|
|
|
|
; RV64I-NEXT: lbu a1, 1(a0)
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: lbu a2, 2(a0)
|
|
|
|
; RV64I-NEXT: lb a0, 0(a0)
|
|
|
|
; RV64I-NEXT: sub a0, a2, a1
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
; sextload i1
|
|
|
|
%1 = getelementptr i1, i1* %a, i32 1
|
|
|
|
%2 = load i1, i1* %1
|
|
|
|
%3 = sext i1 %2 to i64
|
|
|
|
; zextload i1
|
|
|
|
%4 = getelementptr i1, i1* %a, i32 2
|
|
|
|
%5 = load i1, i1* %4
|
|
|
|
%6 = zext i1 %5 to i64
|
|
|
|
%7 = add i64 %3, %6
|
|
|
|
; extload i1 (anyext). Produced as the load is unused.
|
|
|
|
%8 = load volatile i1, i1* %a
|
|
|
|
ret i64 %7
|
|
|
|
}
|
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i16 @load_sext_zext_anyext_i1_i16(i1 *%a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: load_sext_zext_anyext_i1_i16:
|
|
|
|
; RV64I: # %bb.0:
|
|
|
|
; RV64I-NEXT: lbu a1, 1(a0)
|
2019-09-17 13:15:35 +02:00
|
|
|
; RV64I-NEXT: lbu a2, 2(a0)
|
|
|
|
; RV64I-NEXT: lb a0, 0(a0)
|
|
|
|
; RV64I-NEXT: sub a0, a2, a1
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-NEXT: ret
|
|
|
|
; sextload i1
|
|
|
|
%1 = getelementptr i1, i1* %a, i32 1
|
|
|
|
%2 = load i1, i1* %1
|
|
|
|
%3 = sext i1 %2 to i16
|
|
|
|
; zextload i1
|
|
|
|
%4 = getelementptr i1, i1* %a, i32 2
|
|
|
|
%5 = load i1, i1* %4
|
|
|
|
%6 = zext i1 %5 to i16
|
|
|
|
%7 = add i16 %3, %6
|
|
|
|
; extload i1 (anyext). Produced as the load is unused.
|
|
|
|
%8 = load volatile i1, i1* %a
|
|
|
|
ret i16 %7
|
|
|
|
}
|
|
|
|
|
|
|
|
; Check load and store to a global
|
2020-12-31 00:28:10 +01:00
|
|
|
@G = dso_local global i64 0
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
|
2020-12-31 00:28:10 +01:00
|
|
|
define dso_local i64 @ld_sd_global(i64 %a) nounwind {
|
[RISCV] Introduce codegen patterns for instructions introduced in RV64I
As discussed in the RFC
<http://lists.llvm.org/pipermail/llvm-dev/2018-October/126690.html>, 64-bit
RISC-V has i64 as the only legal integer type. This patch introduces patterns
to support codegen of the new instructions
introduced in RV64I: addiw, addiw, subw, sllw, slliw, srlw, srliw, sraw,
sraiw, ld, sd.
Custom selection code is needed for srliw as SimplifyDemandedBits will remove
lower bits from the mask, meaning the obvious pattern won't work:
def : Pat<(sext_inreg (srl (and GPR:$rs1, 0xffffffff), uimm5:$shamt), i32),
(SRLIW GPR:$rs1, uimm5:$shamt)>;
This is sufficient to compile and execute all of the GCC torture suite for
RV64I other than those files using frameaddr or returnaddr intrinsics
(LegalizeDAG doesn't know how to promote the operands - a future patch
addresses this).
When promoting i32 sltu/sltiu operands, it would be more efficient to use
sign-extension rather than zero-extension for RV64. A future patch adds a hook
to allow this.
Differential Revision: https://reviews.llvm.org/D52977
llvm-svn: 347973
2018-11-30 10:38:44 +01:00
|
|
|
; RV64I-LABEL: ld_sd_global:
|
|
|
|
; RV64I: # %bb.0:
|
|
|
|
; RV64I-NEXT: lui a2, %hi(G)
|
|
|
|
; RV64I-NEXT: ld a1, %lo(G)(a2)
|
|
|
|
; RV64I-NEXT: sd a0, %lo(G)(a2)
|
|
|
|
; RV64I-NEXT: addi a2, a2, %lo(G)
|
|
|
|
; RV64I-NEXT: ld a3, 72(a2)
|
|
|
|
; RV64I-NEXT: sd a0, 72(a2)
|
|
|
|
; RV64I-NEXT: mv a0, a1
|
|
|
|
; RV64I-NEXT: ret
|
|
|
|
%1 = load volatile i64, i64* @G
|
|
|
|
store i64 %a, i64* @G
|
|
|
|
%2 = getelementptr i64, i64* @G, i64 9
|
|
|
|
%3 = load volatile i64, i64* %2
|
|
|
|
store i64 %a, i64* %2
|
|
|
|
ret i64 %1
|
|
|
|
}
|