-
Notifications
You must be signed in to change notification settings - Fork 12.3k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
[RISCV] Introduce the RISCVMatInt::generateInstSeq helper
Logic to load 32-bit and 64-bit immediates is currently present in RISCVAsmParser::emitLoadImm in order to support the li pseudoinstruction. With the introduction of RV64 codegen, there is a greater benefit of sharing immediate materialisation logic between the MC layer and codegen. The generateInstSeq helper allows this by producing a vector of simple structs representing the chosen instructions. This can then be consumed in the MC layer to produce MCInsts or at instruction selection time to produce appropriate SelectionDAG node. Sharing this logic means that both the li pseudoinstruction and codegen can benefit from future optimisations, and that this logic can be used for materialising constants during RV64 codegen. This patch does contain a behaviour change: addi will now be produced on RV64 when no lui is necessary to materialise the constant. In that case addiw takes x0 as the source register, so is semantically identical to addi. Differential Revision: https://reviews.llvm.org/D52961 llvm-svn: 346937
- Loading branch information
Showing
6 changed files
with
149 additions
and
89 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,3 +1,4 @@ | ||
| add_llvm_library(LLVMRISCVUtils | ||
| RISCVBaseInfo.cpp | ||
| RISCVMatInt.cpp | ||
| ) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,79 @@ | ||
| //===- RISCVMatInt.cpp - Immediate materialisation -------------*- C++ -*--===// | ||
| // | ||
| // The LLVM Compiler Infrastructure | ||
| // | ||
| // This file is distributed under the University of Illinois Open Source | ||
| // License. See LICENSE.TXT for details. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #include "RISCVMatInt.h" | ||
| #include "MCTargetDesc/RISCVMCTargetDesc.h" | ||
| #include "llvm/ADT/SmallVector.h" | ||
| #include "llvm/Support/MachineValueType.h" | ||
| #include "llvm/Support/MathExtras.h" | ||
| #include <cstdint> | ||
|
|
||
| namespace llvm { | ||
|
|
||
| namespace RISCVMatInt { | ||
| void generateInstSeq(int64_t Val, bool Is64Bit, InstSeq &Res) { | ||
| if (isInt<32>(Val)) { | ||
| // Depending on the active bits in the immediate Value v, the following | ||
| // instruction sequences are emitted: | ||
| // | ||
| // v == 0 : ADDI | ||
| // v[0,12) != 0 && v[12,32) == 0 : ADDI | ||
| // v[0,12) == 0 && v[12,32) != 0 : LUI | ||
| // v[0,32) != 0 : LUI+ADDI(W) | ||
| int64_t Hi20 = ((Val + 0x800) >> 12) & 0xFFFFF; | ||
| int64_t Lo12 = SignExtend64<12>(Val); | ||
|
|
||
| if (Hi20) | ||
| Res.push_back(Inst(RISCV::LUI, Hi20)); | ||
|
|
||
| if (Lo12 || Hi20 == 0) { | ||
| unsigned AddiOpc = (Is64Bit && Hi20) ? RISCV::ADDIW : RISCV::ADDI; | ||
| Res.push_back(Inst(AddiOpc, Lo12)); | ||
| } | ||
| return; | ||
| } | ||
|
|
||
| assert(Is64Bit && "Can't emit >32-bit imm for non-RV64 target"); | ||
|
|
||
| // In the worst case, for a full 64-bit constant, a sequence of 8 instructions | ||
| // (i.e., LUI+ADDIW+SLLI+ADDI+SLLI+ADDI+SLLI+ADDI) has to be emmitted. Note | ||
| // that the first two instructions (LUI+ADDIW) can contribute up to 32 bits | ||
| // while the following ADDI instructions contribute up to 12 bits each. | ||
| // | ||
| // On the first glance, implementing this seems to be possible by simply | ||
| // emitting the most significant 32 bits (LUI+ADDIW) followed by as many left | ||
| // shift (SLLI) and immediate additions (ADDI) as needed. However, due to the | ||
| // fact that ADDI performs a sign extended addition, doing it like that would | ||
| // only be possible when at most 11 bits of the ADDI instructions are used. | ||
| // Using all 12 bits of the ADDI instructions, like done by GAS, actually | ||
| // requires that the constant is processed starting with the least significant | ||
| // bit. | ||
| // | ||
| // In the following, constants are processed from LSB to MSB but instruction | ||
| // emission is performed from MSB to LSB by recursively calling | ||
| // generateInstSeq. In each recursion, first the lowest 12 bits are removed | ||
| // from the constant and the optimal shift amount, which can be greater than | ||
| // 12 bits if the constant is sparse, is determined. Then, the shifted | ||
| // remaining constant is processed recursively and gets emitted as soon as it | ||
| // fits into 32 bits. The emission of the shifts and additions is subsequently | ||
| // performed when the recursion returns. | ||
|
|
||
| int64_t Lo12 = SignExtend64<12>(Val); | ||
| int64_t Hi52 = (Val + 0x800) >> 12; | ||
| int ShiftAmount = 12 + findFirstSet((uint64_t)Hi52); | ||
| Hi52 = SignExtend64(Hi52 >> (ShiftAmount - 12), 64 - ShiftAmount); | ||
|
|
||
| generateInstSeq(Hi52, Is64Bit, Res); | ||
|
|
||
| Res.push_back(Inst(RISCV::SLLI, ShiftAmount)); | ||
| if (Lo12) | ||
| Res.push_back(Inst(RISCV::ADDI, Lo12)); | ||
| } | ||
| } // namespace RISCVMatInt | ||
| } // namespace llvm |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,36 @@ | ||
| //===- RISCVMatInt.h - Immediate materialisation ---------------*- C++ -*--===// | ||
| // | ||
| // The LLVM Compiler Infrastructure | ||
| // | ||
| // This file is distributed under the University of Illinois Open Source | ||
| // License. See LICENSE.TXT for details. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #ifndef LLVM_LIB_TARGET_RISCV_MATINT_H | ||
| #define LLVM_LIB_TARGET_RISCV_MATINT_H | ||
|
|
||
| #include "llvm/ADT/SmallVector.h" | ||
| #include "llvm/Support/MachineValueType.h" | ||
| #include <cstdint> | ||
|
|
||
| namespace llvm { | ||
|
|
||
| namespace RISCVMatInt { | ||
| struct Inst { | ||
| unsigned Opc; | ||
| int64_t Imm; | ||
|
|
||
| Inst(unsigned Opc, int64_t Imm) : Opc(Opc), Imm(Imm) {} | ||
| }; | ||
| using InstSeq = SmallVector<Inst, 8>; | ||
|
|
||
| // Helper to generate an instruction sequence that will materialise the given | ||
| // immediate value into a register. A sequence of instructions represented by | ||
| // a simple struct produced rather than directly emitting the instructions in | ||
| // order to allow this helper to be used from both the MC layer and during | ||
| // instruction selection. | ||
| void generateInstSeq(int64_t Val, bool IsRV64, InstSeq &Res); | ||
| } // namespace RISCVMatInt | ||
| } // namespace llvm | ||
| #endif |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters