CbC/CbC_llvm: lib/Target/Hexagon/HexagonExpandCondsets.cpp annotate

annotate lib/Target/Hexagon/HexagonExpandCondsets.cpp @ 147:c2174574ed3a

LLVM 10

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Wed, 14 Aug 2019 16:55:33 +0900
parents	3a76565eade5
children

rev	line source
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	1 //===- HexagonExpandCondsets.cpp ------------------------------------------===//
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	2 //
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	4 // See https://llvm.org/LICENSE.txt for license information.
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	6 //
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	7 //===----------------------------------------------------------------------===//
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	8
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	9 // Replace mux instructions with the corresponding legal instructions.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	10 // It is meant to work post-SSA, but still on virtual registers. It was
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	11 // originally placed between register coalescing and machine instruction
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	12 // scheduler.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	13 // In this place in the optimization sequence, live interval analysis had
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	14 // been performed, and the live intervals should be preserved. A large part
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	15 // of the code deals with preserving the liveness information.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	16 //
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	17 // Liveness tracking aside, the main functionality of this pass is divided
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	18 // into two steps. The first step is to replace an instruction
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	19 // %0 = C2_mux %1, %2, %3
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	20 // with a pair of conditional transfers
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	21 // %0 = A2_tfrt %1, %2
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	22 // %0 = A2_tfrf %1, %3
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	23 // It is the intention that the execution of this pass could be terminated
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	24 // after this step, and the code generated would be functionally correct.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	25 //
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	26 // If the uses of the source values %1 and %2 are kills, and their
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	27 // definitions are predicable, then in the second step, the conditional
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	28 // transfers will then be rewritten as predicated instructions. E.g.
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	29 // %0 = A2_or %1, %2
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	30 // %3 = A2_tfrt %99, killed %0
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	31 // will be rewritten as
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	32 // %3 = A2_port %99, %1, %2
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	33 //
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	34 // This replacement has two variants: "up" and "down". Consider this case:
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	35 // %0 = A2_or %1, %2
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	36 // ... [intervening instructions] ...
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	37 // %3 = A2_tfrt %99, killed %0
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	38 // variant "up":
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	39 // %3 = A2_port %99, %1, %2
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	40 // ... [intervening instructions, %0->vreg3] ...
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	41 // [deleted]
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	42 // variant "down":
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	43 // [deleted]
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	44 // ... [intervening instructions] ...
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	45 // %3 = A2_port %99, %1, %2
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	46 //
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	47 // Both, one or none of these variants may be valid, and checks are made
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	48 // to rule out inapplicable variants.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	49 //
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	50 // As an additional optimization, before either of the two steps above is
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	51 // executed, the pass attempts to coalesce the target register with one of
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	52 // the source registers, e.g. given an instruction
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	53 // %3 = C2_mux %0, %1, %2
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	54 // %3 will be coalesced with either %1 or %2. If this succeeds,
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	55 // the instruction would then be (for example)
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	56 // %3 = C2_mux %0, %3, %2
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	57 // and, under certain circumstances, this could result in only one predicated
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	58 // instruction:
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	59 // %3 = A2_tfrf %0, %2
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	60 //
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	61
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	62 // Splitting a definition of a register into two predicated transfers
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	63 // creates a complication in liveness tracking. Live interval computation
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	64 // will see both instructions as actual definitions, and will mark the
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	65 // first one as dead. The definition is not actually dead, and this
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	66 // situation will need to be fixed. For example:
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	67 // dead %1 = A2_tfrt ... ; marked as dead
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	68 // %1 = A2_tfrf ...
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	69 //
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	70 // Since any of the individual predicated transfers may end up getting
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	71 // removed (in case it is an identity copy), some pre-existing def may
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	72 // be marked as dead after live interval recomputation:
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	73 // dead %1 = ... ; marked as dead
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	74 // ...
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	75 // %1 = A2_tfrf ... ; if A2_tfrt is removed
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	76 // This case happens if %1 was used as a source in A2_tfrt, which means
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	77 // that is it actually live at the A2_tfrf, and so the now dead definition
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	78 // of %1 will need to be updated to non-dead at some point.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	79 //
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	80 // This issue could be remedied by adding implicit uses to the predicated
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	81 // transfers, but this will create a problem with subsequent predication,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	82 // since the transfers will no longer be possible to reorder. To avoid
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	83 // that, the initial splitting will not add any implicit uses. These
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	84 // implicit uses will be added later, after predication. The extra price,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	85 // however, is that finding the locations where the implicit uses need
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	86 // to be added, and updating the live ranges will be more involved.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	87
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	88 #include "HexagonInstrInfo.h"
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	89 #include "HexagonRegisterInfo.h"
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	90 #include "llvm/ADT/DenseMap.h"
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	91 #include "llvm/ADT/SetVector.h"
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	92 #include "llvm/ADT/SmallVector.h"
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	93 #include "llvm/ADT/StringRef.h"
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	94 #include "llvm/CodeGen/LiveInterval.h"
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	95 #include "llvm/CodeGen/LiveIntervals.h"
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	96 #include "llvm/CodeGen/MachineBasicBlock.h"
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	97 #include "llvm/CodeGen/MachineDominators.h"
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	98 #include "llvm/CodeGen/MachineFunction.h"
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	99 #include "llvm/CodeGen/MachineFunctionPass.h"
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	100 #include "llvm/CodeGen/MachineInstr.h"
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	101 #include "llvm/CodeGen/MachineInstrBuilder.h"
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	102 #include "llvm/CodeGen/MachineOperand.h"
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	103 #include "llvm/CodeGen/MachineRegisterInfo.h"
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	104 #include "llvm/CodeGen/SlotIndexes.h"
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	105 #include "llvm/CodeGen/TargetRegisterInfo.h"
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	106 #include "llvm/CodeGen/TargetSubtargetInfo.h"
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	107 #include "llvm/IR/DebugLoc.h"
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	108 #include "llvm/IR/Function.h"
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	109 #include "llvm/MC/LaneBitmask.h"
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	110 #include "llvm/Pass.h"
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	111 #include "llvm/Support/CommandLine.h"
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	112 #include "llvm/Support/Debug.h"
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	113 #include "llvm/Support/ErrorHandling.h"
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	114 #include "llvm/Support/raw_ostream.h"
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	115 #include <cassert>
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	116 #include <iterator>
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	117 #include <set>
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	118 #include <utility>
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	119
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	120 #define DEBUG_TYPE "expand-condsets"
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	121
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	122 using namespace llvm;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	123
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	124 static cl::opt<unsigned> OptTfrLimit("expand-condsets-tfr-limit",
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	125 cl::init(~0U), cl::Hidden, cl::desc("Max number of mux expansions"));
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	126 static cl::opt<unsigned> OptCoaLimit("expand-condsets-coa-limit",
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	127 cl::init(~0U), cl::Hidden, cl::desc("Max number of segment coalescings"));
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	128
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	129 namespace llvm {
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	130
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	131 void initializeHexagonExpandCondsetsPass(PassRegistry&);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	132 FunctionPass *createHexagonExpandCondsets();
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	133
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	134 } // end namespace llvm
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	135
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	136 namespace {
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	137
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	138 class HexagonExpandCondsets : public MachineFunctionPass {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	139 public:
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	140 static char ID;
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	141
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	142 HexagonExpandCondsets() : MachineFunctionPass(ID) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	143 if (OptCoaLimit.getPosition())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	144 CoaLimitActive = true, CoaLimit = OptCoaLimit;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	145 if (OptTfrLimit.getPosition())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	146 TfrLimitActive = true, TfrLimit = OptTfrLimit;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	147 initializeHexagonExpandCondsetsPass(*PassRegistry::getPassRegistry());
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	148 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	149
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	150 StringRef getPassName() const override { return "Hexagon Expand Condsets"; }
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	151
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	152 void getAnalysisUsage(AnalysisUsage &AU) const override {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	153 AU.addRequired<LiveIntervals>();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	154 AU.addPreserved<LiveIntervals>();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	155 AU.addPreserved<SlotIndexes>();
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	156 AU.addRequired<MachineDominatorTree>();
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	157 AU.addPreserved<MachineDominatorTree>();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	158 MachineFunctionPass::getAnalysisUsage(AU);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	159 }
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	160
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	161 bool runOnMachineFunction(MachineFunction &MF) override;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	162
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	163 private:
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	164 const HexagonInstrInfo *HII = nullptr;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	165 const TargetRegisterInfo *TRI = nullptr;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	166 MachineDominatorTree *MDT;
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	167 MachineRegisterInfo *MRI = nullptr;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	168 LiveIntervals *LIS = nullptr;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	169 bool CoaLimitActive = false;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	170 bool TfrLimitActive = false;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	171 unsigned CoaLimit;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	172 unsigned TfrLimit;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	173 unsigned CoaCounter = 0;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	174 unsigned TfrCounter = 0;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	175
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	176 struct RegisterRef {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	177 RegisterRef(const MachineOperand &Op) : Reg(Op.getReg()),
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	178 Sub(Op.getSubReg()) {}
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	179 RegisterRef(unsigned R = 0, unsigned S = 0) : Reg(R), Sub(S) {}
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	180
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	181 bool operator== (RegisterRef RR) const {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	182 return Reg == RR.Reg && Sub == RR.Sub;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	183 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	184 bool operator!= (RegisterRef RR) const { return !operator==(RR); }
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	185 bool operator< (RegisterRef RR) const {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	186 return Reg < RR.Reg \|\| (Reg == RR.Reg && Sub < RR.Sub);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	187 }
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	188
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	189 unsigned Reg, Sub;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	190 };
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	191
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	192 using ReferenceMap = DenseMap<unsigned, unsigned>;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	193 enum { Sub_Low = 0x1, Sub_High = 0x2, Sub_None = (Sub_Low \| Sub_High) };
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	194 enum { Exec_Then = 0x10, Exec_Else = 0x20 };
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	195
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	196 unsigned getMaskForSub(unsigned Sub);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	197 bool isCondset(const MachineInstr &MI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	198 LaneBitmask getLaneMask(unsigned Reg, unsigned Sub);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	199
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	200 void addRefToMap(RegisterRef RR, ReferenceMap &Map, unsigned Exec);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	201 bool isRefInMap(RegisterRef, ReferenceMap &Map, unsigned Exec);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	202
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	203 void updateDeadsInRange(unsigned Reg, LaneBitmask LM, LiveRange &Range);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	204 void updateKillFlags(unsigned Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	205 void updateDeadFlags(unsigned Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	206 void recalculateLiveInterval(unsigned Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	207 void removeInstr(MachineInstr &MI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	208 void updateLiveness(std::set<unsigned> &RegSet, bool Recalc,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	209 bool UpdateKills, bool UpdateDeads);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	210
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	211 unsigned getCondTfrOpcode(const MachineOperand &SO, bool Cond);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	212 MachineInstr *genCondTfrFor(MachineOperand &SrcOp,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	213 MachineBasicBlock::iterator At, unsigned DstR,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	214 unsigned DstSR, const MachineOperand &PredOp, bool PredSense,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	215 bool ReadUndef, bool ImpUse);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	216 bool split(MachineInstr &MI, std::set<unsigned> &UpdRegs);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	217
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	218 bool isPredicable(MachineInstr *MI);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	219 MachineInstr *getReachingDefForPred(RegisterRef RD,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	220 MachineBasicBlock::iterator UseIt, unsigned PredR, bool Cond);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	221 bool canMoveOver(MachineInstr &MI, ReferenceMap &Defs, ReferenceMap &Uses);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	222 bool canMoveMemTo(MachineInstr &MI, MachineInstr &ToI, bool IsDown);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	223 void predicateAt(const MachineOperand &DefOp, MachineInstr &MI,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	224 MachineBasicBlock::iterator Where,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	225 const MachineOperand &PredOp, bool Cond,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	226 std::set<unsigned> &UpdRegs);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	227 void renameInRange(RegisterRef RO, RegisterRef RN, unsigned PredR,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	228 bool Cond, MachineBasicBlock::iterator First,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	229 MachineBasicBlock::iterator Last);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	230 bool predicate(MachineInstr &TfrI, bool Cond, std::set<unsigned> &UpdRegs);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	231 bool predicateInBlock(MachineBasicBlock &B,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	232 std::set<unsigned> &UpdRegs);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	233
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	234 bool isIntReg(RegisterRef RR, unsigned &BW);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	235 bool isIntraBlocks(LiveInterval &LI);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	236 bool coalesceRegisters(RegisterRef R1, RegisterRef R2);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	237 bool coalesceSegments(const SmallVectorImpl<MachineInstr*> &Condsets,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	238 std::set<unsigned> &UpdRegs);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	239 };
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	240
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	241 } // end anonymous namespace
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	242
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	243 char HexagonExpandCondsets::ID = 0;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	244
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	245 namespace llvm {
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	246
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	247 char &HexagonExpandCondsetsID = HexagonExpandCondsets::ID;
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	248
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	249 } // end namespace llvm
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	250
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	251 INITIALIZE_PASS_BEGIN(HexagonExpandCondsets, "expand-condsets",
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	252 "Hexagon Expand Condsets", false, false)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	253 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	254 INITIALIZE_PASS_DEPENDENCY(SlotIndexes)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	255 INITIALIZE_PASS_DEPENDENCY(LiveIntervals)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	256 INITIALIZE_PASS_END(HexagonExpandCondsets, "expand-condsets",
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	257 "Hexagon Expand Condsets", false, false)
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	258
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	259 unsigned HexagonExpandCondsets::getMaskForSub(unsigned Sub) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	260 switch (Sub) {
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	261 case Hexagon::isub_lo:
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	262 case Hexagon::vsub_lo:
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	263 return Sub_Low;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	264 case Hexagon::isub_hi:
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	265 case Hexagon::vsub_hi:
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	266 return Sub_High;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	267 case Hexagon::NoSubRegister:
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	268 return Sub_None;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	269 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	270 llvm_unreachable("Invalid subregister");
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	271 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	272
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	273 bool HexagonExpandCondsets::isCondset(const MachineInstr &MI) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	274 unsigned Opc = MI.getOpcode();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	275 switch (Opc) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	276 case Hexagon::C2_mux:
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	277 case Hexagon::C2_muxii:
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	278 case Hexagon::C2_muxir:
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	279 case Hexagon::C2_muxri:
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	280 case Hexagon::PS_pselect:
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	281 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	282 break;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	283 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	284 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	285 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	286
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	287 LaneBitmask HexagonExpandCondsets::getLaneMask(unsigned Reg, unsigned Sub) {
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	288 assert(Register::isVirtualRegister(Reg));
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	289 return Sub != 0 ? TRI->getSubRegIndexLaneMask(Sub)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	290 : MRI->getMaxLaneMaskForVReg(Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	291 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	292
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	293 void HexagonExpandCondsets::addRefToMap(RegisterRef RR, ReferenceMap &Map,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	294 unsigned Exec) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	295 unsigned Mask = getMaskForSub(RR.Sub) \| Exec;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	296 ReferenceMap::iterator F = Map.find(RR.Reg);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	297 if (F == Map.end())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	298 Map.insert(std::make_pair(RR.Reg, Mask));
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	299 else
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	300 F->second \|= Mask;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	301 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	302
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	303 bool HexagonExpandCondsets::isRefInMap(RegisterRef RR, ReferenceMap &Map,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	304 unsigned Exec) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	305 ReferenceMap::iterator F = Map.find(RR.Reg);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	306 if (F == Map.end())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	307 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	308 unsigned Mask = getMaskForSub(RR.Sub) \| Exec;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	309 if (Mask & F->second)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	310 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	311 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	312 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	313
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	314 void HexagonExpandCondsets::updateKillFlags(unsigned Reg) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	315 auto KillAt = [this,Reg] (SlotIndex K, LaneBitmask LM) -> void {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	316 // Set the <kill> flag on a use of Reg whose lane mask is contained in LM.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	317 MachineInstr *MI = LIS->getInstructionFromIndex(K);
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	318 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	319 MachineOperand &Op = MI->getOperand(i);
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	320 if (!Op.isReg() \|\| !Op.isUse() \|\| Op.getReg() != Reg \|\|
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	321 MI->isRegTiedToDefOperand(i))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	322 continue;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	323 LaneBitmask SLM = getLaneMask(Reg, Op.getSubReg());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	324 if ((SLM & LM) == SLM) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	325 // Only set the kill flag on the first encountered use of Reg in this
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	326 // instruction.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	327 Op.setIsKill(true);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	328 break;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	329 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	330 }
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	331 };
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	332
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	333 LiveInterval &LI = LIS->getInterval(Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	334 for (auto I = LI.begin(), E = LI.end(); I != E; ++I) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	335 if (!I->end.isRegister())
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	336 continue;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	337 // Do not mark the end of the segment as <kill>, if the next segment
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	338 // starts with a predicated instruction.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	339 auto NextI = std::next(I);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	340 if (NextI != E && NextI->start.isRegister()) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	341 MachineInstr *DefI = LIS->getInstructionFromIndex(NextI->start);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	342 if (HII->isPredicated(*DefI))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	343 continue;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	344 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	345 bool WholeReg = true;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	346 if (LI.hasSubRanges()) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	347 auto EndsAtI = [I] (LiveInterval::SubRange &S) -> bool {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	348 LiveRange::iterator F = S.find(I->end);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	349 return F != S.end() && I->end == F->end;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	350 };
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	351 // Check if all subranges end at I->end. If so, make sure to kill
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	352 // the whole register.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	353 for (LiveInterval::SubRange &S : LI.subranges()) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	354 if (EndsAtI(S))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	355 KillAt(I->end, S.LaneMask);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	356 else
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	357 WholeReg = false;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	358 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	359 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	360 if (WholeReg)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	361 KillAt(I->end, MRI->getMaxLaneMaskForVReg(Reg));
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	362 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	363 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	364
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	365 void HexagonExpandCondsets::updateDeadsInRange(unsigned Reg, LaneBitmask LM,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	366 LiveRange &Range) {
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	367 assert(Register::isVirtualRegister(Reg));
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	368 if (Range.empty())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	369 return;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	370
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	371 // Return two booleans: { def-modifes-reg, def-covers-reg }.
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	372 auto IsRegDef = [this,Reg,LM] (MachineOperand &Op) -> std::pair<bool,bool> {
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	373 if (!Op.isReg() \|\| !Op.isDef())
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	374 return { false, false };
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	375 unsigned DR = Op.getReg(), DSR = Op.getSubReg();
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	376 if (!Register::isVirtualRegister(DR) \|\| DR != Reg)
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	377 return { false, false };
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	378 LaneBitmask SLM = getLaneMask(DR, DSR);
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	379 LaneBitmask A = SLM & LM;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	380 return { A.any(), A == SLM };
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	381 };
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	382
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	383 // The splitting step will create pairs of predicated definitions without
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	384 // any implicit uses (since implicit uses would interfere with predication).
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	385 // This can cause the reaching defs to become dead after live range
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	386 // recomputation, even though they are not really dead.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	387 // We need to identify predicated defs that need implicit uses, and
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	388 // dead defs that are not really dead, and correct both problems.
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	389
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	390 auto Dominate = [this] (SetVector<MachineBasicBlock*> &Defs,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	391 MachineBasicBlock *Dest) -> bool {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	392 for (MachineBasicBlock *D : Defs)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	393 if (D != Dest && MDT->dominates(D, Dest))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	394 return true;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	395
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	396 MachineBasicBlock *Entry = &Dest->getParent()->front();
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	397 SetVector<MachineBasicBlock*> Work(Dest->pred_begin(), Dest->pred_end());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	398 for (unsigned i = 0; i < Work.size(); ++i) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	399 MachineBasicBlock *B = Work[i];
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	400 if (Defs.count(B))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	401 continue;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	402 if (B == Entry)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	403 return false;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	404 for (auto *P : B->predecessors())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	405 Work.insert(P);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	406 }
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	407 return true;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	408 };
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	409
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	410 // First, try to extend live range within individual basic blocks. This
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	411 // will leave us only with dead defs that do not reach any predicated
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	412 // defs in the same block.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	413 SetVector<MachineBasicBlock*> Defs;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	414 SmallVector<SlotIndex,4> PredDefs;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	415 for (auto &Seg : Range) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	416 if (!Seg.start.isRegister())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	417 continue;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	418 MachineInstr *DefI = LIS->getInstructionFromIndex(Seg.start);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	419 Defs.insert(DefI->getParent());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	420 if (HII->isPredicated(*DefI))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	421 PredDefs.push_back(Seg.start);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	422 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	423
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	424 SmallVector<SlotIndex,8> Undefs;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	425 LiveInterval &LI = LIS->getInterval(Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	426 LI.computeSubRangeUndefs(Undefs, LM, MRI, LIS->getSlotIndexes());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	427
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	428 for (auto &SI : PredDefs) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	429 MachineBasicBlock *BB = LIS->getMBBFromIndex(SI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	430 auto P = Range.extendInBlock(Undefs, LIS->getMBBStartIdx(BB), SI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	431 if (P.first != nullptr \|\| P.second)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	432 SI = SlotIndex();
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	433 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	434
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	435 // Calculate reachability for those predicated defs that were not handled
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	436 // by the in-block extension.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	437 SmallVector<SlotIndex,4> ExtTo;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	438 for (auto &SI : PredDefs) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	439 if (!SI.isValid())
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	440 continue;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	441 MachineBasicBlock *BB = LIS->getMBBFromIndex(SI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	442 if (BB->pred_empty())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	443 continue;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	444 // If the defs from this range reach SI via all predecessors, it is live.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	445 // It can happen that SI is reached by the defs through some paths, but
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	446 // not all. In the IR coming into this optimization, SI would not be
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	447 // considered live, since the defs would then not jointly dominate SI.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	448 // That means that SI is an overwriting def, and no implicit use is
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	449 // needed at this point. Do not add SI to the extension points, since
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	450 // extendToIndices will abort if there is no joint dominance.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	451 // If the abort was avoided by adding extra undefs added to Undefs,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	452 // extendToIndices could actually indicate that SI is live, contrary
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	453 // to the original IR.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	454 if (Dominate(Defs, BB))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	455 ExtTo.push_back(SI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	456 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	457
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	458 if (!ExtTo.empty())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	459 LIS->extendToIndices(Range, ExtTo, Undefs);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	460
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	461 // Remove <dead> flags from all defs that are not dead after live range
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	462 // extension, and collect all def operands. They will be used to generate
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	463 // the necessary implicit uses.
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	464 // At the same time, add <dead> flag to all defs that are actually dead.
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	465 // This can happen, for example, when a mux with identical inputs is
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	466 // replaced with a COPY: the use of the predicate register disappears and
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	467 // the dead can become dead.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	468 std::set<RegisterRef> DefRegs;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	469 for (auto &Seg : Range) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	470 if (!Seg.start.isRegister())
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	471 continue;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	472 MachineInstr *DefI = LIS->getInstructionFromIndex(Seg.start);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	473 for (auto &Op : DefI->operands()) {
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	474 auto P = IsRegDef(Op);
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	475 if (P.second && Seg.end.isDead()) {
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	476 Op.setIsDead(true);
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	477 } else if (P.first) {
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	478 DefRegs.insert(Op);
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	479 Op.setIsDead(false);
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	480 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	481 }
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	482 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	483
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	484 // Now, add implicit uses to each predicated def that is reached
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	485 // by other defs.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	486 for (auto &Seg : Range) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	487 if (!Seg.start.isRegister() \|\| !Range.liveAt(Seg.start.getPrevSlot()))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	488 continue;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	489 MachineInstr *DefI = LIS->getInstructionFromIndex(Seg.start);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	490 if (!HII->isPredicated(*DefI))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	491 continue;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	492 // Construct the set of all necessary implicit uses, based on the def
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	493 // operands in the instruction. We need to tie the implicit uses to
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	494 // the corresponding defs.
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	495 std::map<RegisterRef,unsigned> ImpUses;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	496 for (unsigned i = 0, e = DefI->getNumOperands(); i != e; ++i) {
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	497 MachineOperand &Op = DefI->getOperand(i);
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	498 if (!Op.isReg() \|\| !DefRegs.count(Op))
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	499 continue;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	500 if (Op.isDef()) {
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	501 // Tied defs will always have corresponding uses, so no extra
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	502 // implicit uses are needed.
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	503 if (!Op.isTied())
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	504 ImpUses.insert({Op, i});
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	505 } else {
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	506 // This function can be called for the same register with different
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	507 // lane masks. If the def in this instruction was for the whole
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	508 // register, we can get here more than once. Avoid adding multiple
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	509 // implicit uses (or adding an implicit use when an explicit one is
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	510 // present).
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	511 if (Op.isTied())
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	512 ImpUses.erase(Op);
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	513 }
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	514 }
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	515 if (ImpUses.empty())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	516 continue;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	517 MachineFunction &MF = *DefI->getParent()->getParent();
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	518 for (std::pair<RegisterRef, unsigned> P : ImpUses) {
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	519 RegisterRef R = P.first;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	520 MachineInstrBuilder(MF, DefI).addReg(R.Reg, RegState::Implicit, R.Sub);
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	521 DefI->tieOperands(P.second, DefI->getNumOperands()-1);
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	522 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	523 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	524 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	525
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	526 void HexagonExpandCondsets::updateDeadFlags(unsigned Reg) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	527 LiveInterval &LI = LIS->getInterval(Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	528 if (LI.hasSubRanges()) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	529 for (LiveInterval::SubRange &S : LI.subranges()) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	530 updateDeadsInRange(Reg, S.LaneMask, S);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	531 LIS->shrinkToUses(S, Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	532 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	533 LI.clear();
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	534 LIS->constructMainRangeFromSubranges(LI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	535 } else {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	536 updateDeadsInRange(Reg, MRI->getMaxLaneMaskForVReg(Reg), LI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	537 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	538 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	539
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	540 void HexagonExpandCondsets::recalculateLiveInterval(unsigned Reg) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	541 LIS->removeInterval(Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	542 LIS->createAndComputeVirtRegInterval(Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	543 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	544
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	545 void HexagonExpandCondsets::removeInstr(MachineInstr &MI) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	546 LIS->RemoveMachineInstrFromMaps(MI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	547 MI.eraseFromParent();
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	548 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	549
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	550 void HexagonExpandCondsets::updateLiveness(std::set<unsigned> &RegSet,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	551 bool Recalc, bool UpdateKills, bool UpdateDeads) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	552 UpdateKills \|= UpdateDeads;
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	553 for (unsigned R : RegSet) {
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	554 if (!Register::isVirtualRegister(R)) {
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	555 assert(Register::isPhysicalRegister(R));
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	556 // There shouldn't be any physical registers as operands, except
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	557 // possibly reserved registers.
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	558 assert(MRI->isReserved(R));
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	559 continue;
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	560 }
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	561 if (Recalc)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	562 recalculateLiveInterval(R);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	563 if (UpdateKills)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	564 MRI->clearKillFlags(R);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	565 if (UpdateDeads)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	566 updateDeadFlags(R);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	567 // Fixing <dead> flags may extend live ranges, so reset <kill> flags
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	568 // after that.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	569 if (UpdateKills)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	570 updateKillFlags(R);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	571 LIS->getInterval(R).verify();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	572 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	573 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	574
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	575 /// Get the opcode for a conditional transfer of the value in SO (source
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	576 /// operand). The condition (true/false) is given in Cond.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	577 unsigned HexagonExpandCondsets::getCondTfrOpcode(const MachineOperand &SO,
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	578 bool IfTrue) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	579 using namespace Hexagon;
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	580
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	581 if (SO.isReg()) {
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	582 Register PhysR;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	583 RegisterRef RS = SO;
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	584 if (Register::isVirtualRegister(RS.Reg)) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	585 const TargetRegisterClass *VC = MRI->getRegClass(RS.Reg);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	586 assert(VC->begin() != VC->end() && "Empty register class");
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	587 PhysR = *VC->begin();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	588 } else {
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	589 assert(Register::isPhysicalRegister(RS.Reg));
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	590 PhysR = RS.Reg;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	591 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	592 unsigned PhysS = (RS.Sub == 0) ? PhysR : TRI->getSubReg(PhysR, RS.Sub);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	593 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(PhysS);
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	594 switch (TRI->getRegSizeInBits(*RC)) {
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	595 case 32:
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	596 return IfTrue ? A2_tfrt : A2_tfrf;
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	597 case 64:
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	598 return IfTrue ? A2_tfrpt : A2_tfrpf;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	599 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	600 llvm_unreachable("Invalid register operand");
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	601 }
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	602 switch (SO.getType()) {
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	603 case MachineOperand::MO_Immediate:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	604 case MachineOperand::MO_FPImmediate:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	605 case MachineOperand::MO_ConstantPoolIndex:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	606 case MachineOperand::MO_TargetIndex:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	607 case MachineOperand::MO_JumpTableIndex:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	608 case MachineOperand::MO_ExternalSymbol:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	609 case MachineOperand::MO_GlobalAddress:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	610 case MachineOperand::MO_BlockAddress:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	611 return IfTrue ? C2_cmoveit : C2_cmoveif;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	612 default:
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	613 break;
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	614 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	615 llvm_unreachable("Unexpected source operand");
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	616 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	617
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	618 /// Generate a conditional transfer, copying the value SrcOp to the
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	619 /// destination register DstR:DstSR, and using the predicate register from
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	620 /// PredOp. The Cond argument specifies whether the predicate is to be
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	621 /// if(PredOp), or if(!PredOp).
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	622 MachineInstr *HexagonExpandCondsets::genCondTfrFor(MachineOperand &SrcOp,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	623 MachineBasicBlock::iterator At,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	624 unsigned DstR, unsigned DstSR, const MachineOperand &PredOp,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	625 bool PredSense, bool ReadUndef, bool ImpUse) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	626 MachineInstr *MI = SrcOp.getParent();
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	627 MachineBasicBlock &B = *At->getParent();
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	628 const DebugLoc &DL = MI->getDebugLoc();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	629
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	630 // Don't avoid identity copies here (i.e. if the source and the destination
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	631 // are the same registers). It is actually better to generate them here,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	632 // since this would cause the copy to potentially be predicated in the next
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	633 // step. The predication will remove such a copy if it is unable to
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	634 /// predicate.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	635
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	636 unsigned Opc = getCondTfrOpcode(SrcOp, PredSense);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	637 unsigned DstState = RegState::Define \| (ReadUndef ? RegState::Undef : 0);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	638 unsigned PredState = getRegState(PredOp) & ~RegState::Kill;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	639 MachineInstrBuilder MIB;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	640
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	641 if (SrcOp.isReg()) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	642 unsigned SrcState = getRegState(SrcOp);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	643 if (RegisterRef(SrcOp) == RegisterRef(DstR, DstSR))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	644 SrcState &= ~RegState::Kill;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	645 MIB = BuildMI(B, At, DL, HII->get(Opc))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	646 .addReg(DstR, DstState, DstSR)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	647 .addReg(PredOp.getReg(), PredState, PredOp.getSubReg())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	648 .addReg(SrcOp.getReg(), SrcState, SrcOp.getSubReg());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	649 } else {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	650 MIB = BuildMI(B, At, DL, HII->get(Opc))
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	651 .addReg(DstR, DstState, DstSR)
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	652 .addReg(PredOp.getReg(), PredState, PredOp.getSubReg())
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	653 .add(SrcOp);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	654 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	655
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	656 LLVM_DEBUG(dbgs() << "created an initial copy: " << *MIB);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	657 return &*MIB;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	658 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	659
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	660 /// Replace a MUX instruction MI with a pair A2_tfrt/A2_tfrf. This function
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	661 /// performs all necessary changes to complete the replacement.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	662 bool HexagonExpandCondsets::split(MachineInstr &MI,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	663 std::set<unsigned> &UpdRegs) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	664 if (TfrLimitActive) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	665 if (TfrCounter >= TfrLimit)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	666 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	667 TfrCounter++;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	668 }
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	669 LLVM_DEBUG(dbgs() << "\nsplitting " << printMBBReference(*MI.getParent())
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	670 << ": " << MI);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	671 MachineOperand &MD = MI.getOperand(0); // Definition
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	672 MachineOperand &MP = MI.getOperand(1); // Predicate register
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	673 assert(MD.isDef());
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	674 unsigned DR = MD.getReg(), DSR = MD.getSubReg();
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	675 bool ReadUndef = MD.isUndef();
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	676 MachineBasicBlock::iterator At = MI;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	677
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	678 auto updateRegs = [&UpdRegs] (const MachineInstr &MI) -> void {
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	679 for (auto &Op : MI.operands())
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	680 if (Op.isReg())
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	681 UpdRegs.insert(Op.getReg());
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	682 };
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	683
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	684 // If this is a mux of the same register, just replace it with COPY.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	685 // Ideally, this would happen earlier, so that register coalescing would
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	686 // see it.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	687 MachineOperand &ST = MI.getOperand(2);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	688 MachineOperand &SF = MI.getOperand(3);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	689 if (ST.isReg() && SF.isReg()) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	690 RegisterRef RT(ST);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	691 if (RT == RegisterRef(SF)) {
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	692 // Copy regs to update first.
803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	693 updateRegs(MI);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	694 MI.setDesc(HII->get(TargetOpcode::COPY));
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	695 unsigned S = getRegState(ST);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	696 while (MI.getNumOperands() > 1)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	697 MI.RemoveOperand(MI.getNumOperands()-1);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	698 MachineFunction &MF = *MI.getParent()->getParent();
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	699 MachineInstrBuilder(MF, MI).addReg(RT.Reg, S, RT.Sub);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	700 return true;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	701 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	702 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	703
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	704 // First, create the two invididual conditional transfers, and add each
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	705 // of them to the live intervals information. Do that first and then remove
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	706 // the old instruction from live intervals.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	707 MachineInstr *TfrT =
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	708 genCondTfrFor(ST, At, DR, DSR, MP, true, ReadUndef, false);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	709 MachineInstr *TfrF =
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	710 genCondTfrFor(SF, At, DR, DSR, MP, false, ReadUndef, true);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	711 LIS->InsertMachineInstrInMaps(*TfrT);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	712 LIS->InsertMachineInstrInMaps(*TfrF);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	713
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	714 // Will need to recalculate live intervals for all registers in MI.
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	715 updateRegs(MI);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	716
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	717 removeInstr(MI);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	718 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	719 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	720
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	721 bool HexagonExpandCondsets::isPredicable(MachineInstr *MI) {
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	722 if (HII->isPredicated(MI) \|\| !HII->isPredicable(MI))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	723 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	724 if (MI->hasUnmodeledSideEffects() \|\| MI->mayStore())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	725 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	726 // Reject instructions with multiple defs (e.g. post-increment loads).
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	727 bool HasDef = false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	728 for (auto &Op : MI->operands()) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	729 if (!Op.isReg() \|\| !Op.isDef())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	730 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	731 if (HasDef)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	732 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	733 HasDef = true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	734 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	735 for (auto &Mo : MI->memoperands())
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	736 if (Mo->isVolatile() \|\| Mo->isAtomic())
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	737 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	738 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	739 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	740
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	741 /// Find the reaching definition for a predicated use of RD. The RD is used
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	742 /// under the conditions given by PredR and Cond, and this function will ignore
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	743 /// definitions that set RD under the opposite conditions.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	744 MachineInstr *HexagonExpandCondsets::getReachingDefForPred(RegisterRef RD,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	745 MachineBasicBlock::iterator UseIt, unsigned PredR, bool Cond) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	746 MachineBasicBlock &B = *UseIt->getParent();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	747 MachineBasicBlock::iterator I = UseIt, S = B.begin();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	748 if (I == S)
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	749 return nullptr;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	750
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	751 bool PredValid = true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	752 do {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	753 --I;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	754 MachineInstr MI = &I;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	755 // Check if this instruction can be ignored, i.e. if it is predicated
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	756 // on the complementary condition.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	757 if (PredValid && HII->isPredicated(*MI)) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	758 if (MI->readsRegister(PredR) && (Cond != HII->isPredicatedTrue(*MI)))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	759 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	760 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	761
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	762 // Check the defs. If the PredR is defined, invalidate it. If RD is
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	763 // defined, return the instruction or 0, depending on the circumstances.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	764 for (auto &Op : MI->operands()) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	765 if (!Op.isReg() \|\| !Op.isDef())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	766 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	767 RegisterRef RR = Op;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	768 if (RR.Reg == PredR) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	769 PredValid = false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	770 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	771 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	772 if (RR.Reg != RD.Reg)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	773 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	774 // If the "Reg" part agrees, there is still the subregister to check.
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	775 // If we are looking for %1:loreg, we can skip %1:hireg, but
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	776 // not %1 (w/o subregisters).
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	777 if (RR.Sub == RD.Sub)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	778 return MI;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	779 if (RR.Sub == 0 \|\| RD.Sub == 0)
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	780 return nullptr;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	781 // We have different subregisters, so we can continue looking.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	782 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	783 } while (I != S);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	784
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	785 return nullptr;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	786 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	787
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	788 /// Check if the instruction MI can be safely moved over a set of instructions
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	789 /// whose side-effects (in terms of register defs and uses) are expressed in
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	790 /// the maps Defs and Uses. These maps reflect the conditional defs and uses
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	791 /// that depend on the same predicate register to allow moving instructions
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	792 /// over instructions predicated on the opposite condition.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	793 bool HexagonExpandCondsets::canMoveOver(MachineInstr &MI, ReferenceMap &Defs,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	794 ReferenceMap &Uses) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	795 // In order to be able to safely move MI over instructions that define
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	796 // "Defs" and use "Uses", no def operand from MI can be defined or used
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	797 // and no use operand can be defined.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	798 for (auto &Op : MI.operands()) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	799 if (!Op.isReg())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	800 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	801 RegisterRef RR = Op;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	802 // For physical register we would need to check register aliases, etc.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	803 // and we don't want to bother with that. It would be of little value
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	804 // before the actual register rewriting (from virtual to physical).
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	805 if (!Register::isVirtualRegister(RR.Reg))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	806 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	807 // No redefs for any operand.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	808 if (isRefInMap(RR, Defs, Exec_Then))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	809 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	810 // For defs, there cannot be uses.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	811 if (Op.isDef() && isRefInMap(RR, Uses, Exec_Then))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	812 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	813 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	814 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	815 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	816
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	817 /// Check if the instruction accessing memory (TheI) can be moved to the
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	818 /// location ToI.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	819 bool HexagonExpandCondsets::canMoveMemTo(MachineInstr &TheI, MachineInstr &ToI,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	820 bool IsDown) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	821 bool IsLoad = TheI.mayLoad(), IsStore = TheI.mayStore();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	822 if (!IsLoad && !IsStore)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	823 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	824 if (HII->areMemAccessesTriviallyDisjoint(TheI, ToI))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	825 return true;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	826 if (TheI.hasUnmodeledSideEffects())
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	827 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	828
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	829 MachineBasicBlock::iterator StartI = IsDown ? TheI : ToI;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	830 MachineBasicBlock::iterator EndI = IsDown ? ToI : TheI;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	831 bool Ordered = TheI.hasOrderedMemoryRef();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	832
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	833 // Search for aliased memory reference in (StartI, EndI).
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	834 for (MachineBasicBlock::iterator I = std::next(StartI); I != EndI; ++I) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	835 MachineInstr MI = &I;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	836 if (MI->hasUnmodeledSideEffects())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	837 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	838 bool L = MI->mayLoad(), S = MI->mayStore();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	839 if (!L && !S)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	840 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	841 if (Ordered && MI->hasOrderedMemoryRef())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	842 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	843
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	844 bool Conflict = (L && IsStore) \|\| S;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	845 if (Conflict)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	846 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	847 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	848 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	849 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	850
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	851 /// Generate a predicated version of MI (where the condition is given via
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	852 /// PredR and Cond) at the point indicated by Where.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	853 void HexagonExpandCondsets::predicateAt(const MachineOperand &DefOp,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	854 MachineInstr &MI,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	855 MachineBasicBlock::iterator Where,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	856 const MachineOperand &PredOp, bool Cond,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	857 std::set<unsigned> &UpdRegs) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	858 // The problem with updating live intervals is that we can move one def
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	859 // past another def. In particular, this can happen when moving an A2_tfrt
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	860 // over an A2_tfrf defining the same register. From the point of view of
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	861 // live intervals, these two instructions are two separate definitions,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	862 // and each one starts another live segment. LiveIntervals's "handleMove"
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	863 // does not allow such moves, so we need to handle it ourselves. To avoid
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	864 // invalidating liveness data while we are using it, the move will be
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	865 // implemented in 4 steps: (1) add a clone of the instruction MI at the
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	866 // target location, (2) update liveness, (3) delete the old instruction,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	867 // and (4) update liveness again.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	868
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	869 MachineBasicBlock &B = *MI.getParent();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	870 DebugLoc DL = Where->getDebugLoc(); // "Where" points to an instruction.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	871 unsigned Opc = MI.getOpcode();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	872 unsigned PredOpc = HII->getCondOpcode(Opc, !Cond);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	873 MachineInstrBuilder MB = BuildMI(B, Where, DL, HII->get(PredOpc));
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	874 unsigned Ox = 0, NP = MI.getNumOperands();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	875 // Skip all defs from MI first.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	876 while (Ox < NP) {
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	877 MachineOperand &MO = MI.getOperand(Ox);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	878 if (!MO.isReg() \|\| !MO.isDef())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	879 break;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	880 Ox++;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	881 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	882 // Add the new def, then the predicate register, then the rest of the
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	883 // operands.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	884 MB.addReg(DefOp.getReg(), getRegState(DefOp), DefOp.getSubReg());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	885 MB.addReg(PredOp.getReg(), PredOp.isUndef() ? RegState::Undef : 0,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	886 PredOp.getSubReg());
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	887 while (Ox < NP) {
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	888 MachineOperand &MO = MI.getOperand(Ox);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	889 if (!MO.isReg() \|\| !MO.isImplicit())
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	890 MB.add(MO);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	891 Ox++;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	892 }
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	893 MB.cloneMemRefs(MI);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	894
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	895 MachineInstr *NewI = MB;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	896 NewI->clearKillInfo();
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	897 LIS->InsertMachineInstrInMaps(*NewI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	898
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	899 for (auto &Op : NewI->operands())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	900 if (Op.isReg())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	901 UpdRegs.insert(Op.getReg());
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	902 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	903
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	904 /// In the range [First, Last], rename all references to the "old" register RO
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	905 /// to the "new" register RN, but only in instructions predicated on the given
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	906 /// condition.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	907 void HexagonExpandCondsets::renameInRange(RegisterRef RO, RegisterRef RN,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	908 unsigned PredR, bool Cond, MachineBasicBlock::iterator First,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	909 MachineBasicBlock::iterator Last) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	910 MachineBasicBlock::iterator End = std::next(Last);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	911 for (MachineBasicBlock::iterator I = First; I != End; ++I) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	912 MachineInstr MI = &I;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	913 // Do not touch instructions that are not predicated, or are predicated
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	914 // on the opposite condition.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	915 if (!HII->isPredicated(*MI))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	916 continue;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	917 if (!MI->readsRegister(PredR) \|\| (Cond != HII->isPredicatedTrue(*MI)))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	918 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	919
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	920 for (auto &Op : MI->operands()) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	921 if (!Op.isReg() \|\| RO != RegisterRef(Op))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	922 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	923 Op.setReg(RN.Reg);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	924 Op.setSubReg(RN.Sub);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	925 // In practice, this isn't supposed to see any defs.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	926 assert(!Op.isDef() && "Not expecting a def");
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	927 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	928 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	929 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	930
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	931 /// For a given conditional copy, predicate the definition of the source of
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	932 /// the copy under the given condition (using the same predicate register as
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	933 /// the copy).
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	934 bool HexagonExpandCondsets::predicate(MachineInstr &TfrI, bool Cond,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	935 std::set<unsigned> &UpdRegs) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	936 // TfrI - A2_tfr[tf] Instruction (not A2_tfrsi).
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	937 unsigned Opc = TfrI.getOpcode();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	938 (void)Opc;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	939 assert(Opc == Hexagon::A2_tfrt \|\| Opc == Hexagon::A2_tfrf);
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	940 LLVM_DEBUG(dbgs() << "\nattempt to predicate if-" << (Cond ? "true" : "false")
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	941 << ": " << TfrI);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	942
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	943 MachineOperand &MD = TfrI.getOperand(0);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	944 MachineOperand &MP = TfrI.getOperand(1);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	945 MachineOperand &MS = TfrI.getOperand(2);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	946 // The source operand should be a <kill>. This is not strictly necessary,
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	947 // but it makes things a lot simpler. Otherwise, we would need to rename
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	948 // some registers, which would complicate the transformation considerably.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	949 if (!MS.isKill())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	950 return false;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	951 // Avoid predicating instructions that define a subregister if subregister
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	952 // liveness tracking is not enabled.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	953 if (MD.getSubReg() && !MRI->shouldTrackSubRegLiveness(MD.getReg()))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	954 return false;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	955
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	956 RegisterRef RT(MS);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	957 unsigned PredR = MP.getReg();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	958 MachineInstr *DefI = getReachingDefForPred(RT, TfrI, PredR, Cond);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	959 if (!DefI \|\| !isPredicable(DefI))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	960 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	961
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	962 LLVM_DEBUG(dbgs() << "Source def: " << *DefI);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	963
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	964 // Collect the information about registers defined and used between the
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	965 // DefI and the TfrI.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	966 // Map: reg -> bitmask of subregs
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	967 ReferenceMap Uses, Defs;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	968 MachineBasicBlock::iterator DefIt = DefI, TfrIt = TfrI;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	969
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	970 // Check if the predicate register is valid between DefI and TfrI.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	971 // If it is, we can then ignore instructions predicated on the negated
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	972 // conditions when collecting def and use information.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	973 bool PredValid = true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	974 for (MachineBasicBlock::iterator I = std::next(DefIt); I != TfrIt; ++I) {
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	975 if (!I->modifiesRegister(PredR, nullptr))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	976 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	977 PredValid = false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	978 break;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	979 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	980
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	981 for (MachineBasicBlock::iterator I = std::next(DefIt); I != TfrIt; ++I) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	982 MachineInstr MI = &I;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	983 // If this instruction is predicated on the same register, it could
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	984 // potentially be ignored.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	985 // By default assume that the instruction executes on the same condition
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	986 // as TfrI (Exec_Then), and also on the opposite one (Exec_Else).
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	987 unsigned Exec = Exec_Then \| Exec_Else;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	988 if (PredValid && HII->isPredicated(*MI) && MI->readsRegister(PredR))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	989 Exec = (Cond == HII->isPredicatedTrue(*MI)) ? Exec_Then : Exec_Else;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	990
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	991 for (auto &Op : MI->operands()) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	992 if (!Op.isReg())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	993 continue;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	994 // We don't want to deal with physical registers. The reason is that
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	995 // they can be aliased with other physical registers. Aliased virtual
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	996 // registers must share the same register number, and can only differ
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	997 // in the subregisters, which we are keeping track of. Physical
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	998 // registers ters no longer have subregisters---their super- and
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	999 // subregisters are other physical registers, and we are not checking
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1000 // that.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1001 RegisterRef RR = Op;
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1002 if (!Register::isVirtualRegister(RR.Reg))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1003 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1004
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1005 ReferenceMap &Map = Op.isDef() ? Defs : Uses;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1006 if (Op.isDef() && Op.isUndef()) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1007 assert(RR.Sub && "Expecting a subregister on <def,read-undef>");
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1008 // If this is a <def,read-undef>, then it invalidates the non-written
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1009 // part of the register. For the purpose of checking the validity of
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1010 // the move, assume that it modifies the whole register.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1011 RR.Sub = 0;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1012 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1013 addRefToMap(RR, Map, Exec);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1014 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1015 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1016
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1017 // The situation:
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1018 // RT = DefI
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1019 // ...
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1020 // RD = TfrI ..., RT
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1021
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1022 // If the register-in-the-middle (RT) is used or redefined between
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1023 // DefI and TfrI, we may not be able proceed with this transformation.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1024 // We can ignore a def that will not execute together with TfrI, and a
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1025 // use that will. If there is such a use (that does execute together with
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1026 // TfrI), we will not be able to move DefI down. If there is a use that
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1027 // executed if TfrI's condition is false, then RT must be available
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1028 // unconditionally (cannot be predicated).
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1029 // Essentially, we need to be able to rename RT to RD in this segment.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1030 if (isRefInMap(RT, Defs, Exec_Then) \|\| isRefInMap(RT, Uses, Exec_Else))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1031 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1032 RegisterRef RD = MD;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1033 // If the predicate register is defined between DefI and TfrI, the only
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1034 // potential thing to do would be to move the DefI down to TfrI, and then
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1035 // predicate. The reaching def (DefI) must be movable down to the location
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1036 // of the TfrI.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1037 // If the target register of the TfrI (RD) is not used or defined between
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1038 // DefI and TfrI, consider moving TfrI up to DefI.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1039 bool CanUp = canMoveOver(TfrI, Defs, Uses);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1040 bool CanDown = canMoveOver(*DefI, Defs, Uses);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1041 // The TfrI does not access memory, but DefI could. Check if it's safe
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1042 // to move DefI down to TfrI.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1043 if (DefI->mayLoad() \|\| DefI->mayStore())
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1044 if (!canMoveMemTo(*DefI, TfrI, true))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1045 CanDown = false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1046
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1047 LLVM_DEBUG(dbgs() << "Can move up: " << (CanUp ? "yes" : "no")
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1048 << ", can move down: " << (CanDown ? "yes\n" : "no\n"));
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1049 MachineBasicBlock::iterator PastDefIt = std::next(DefIt);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1050 if (CanUp)
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1051 predicateAt(MD, *DefI, PastDefIt, MP, Cond, UpdRegs);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1052 else if (CanDown)
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1053 predicateAt(MD, *DefI, TfrIt, MP, Cond, UpdRegs);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1054 else
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1055 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1056
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1057 if (RT != RD) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1058 renameInRange(RT, RD, PredR, Cond, PastDefIt, TfrIt);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1059 UpdRegs.insert(RT.Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1060 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1061
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1062 removeInstr(TfrI);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1063 removeInstr(*DefI);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1064 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1065 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1066
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1067 /// Predicate all cases of conditional copies in the specified block.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1068 bool HexagonExpandCondsets::predicateInBlock(MachineBasicBlock &B,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1069 std::set<unsigned> &UpdRegs) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1070 bool Changed = false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1071 MachineBasicBlock::iterator I, E, NextI;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1072 for (I = B.begin(), E = B.end(); I != E; I = NextI) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1073 NextI = std::next(I);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1074 unsigned Opc = I->getOpcode();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1075 if (Opc == Hexagon::A2_tfrt \|\| Opc == Hexagon::A2_tfrf) {
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1076 bool Done = predicate(*I, (Opc == Hexagon::A2_tfrt), UpdRegs);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1077 if (!Done) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1078 // If we didn't predicate I, we may need to remove it in case it is
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1079 // an "identity" copy, e.g. %1 = A2_tfrt %2, %1.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1080 if (RegisterRef(I->getOperand(0)) == RegisterRef(I->getOperand(2))) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1081 for (auto &Op : I->operands())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1082 if (Op.isReg())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1083 UpdRegs.insert(Op.getReg());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1084 removeInstr(*I);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1085 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1086 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1087 Changed \|= Done;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1088 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1089 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1090 return Changed;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1091 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1092
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1093 bool HexagonExpandCondsets::isIntReg(RegisterRef RR, unsigned &BW) {
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1094 if (!Register::isVirtualRegister(RR.Reg))
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1095 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1096 const TargetRegisterClass *RC = MRI->getRegClass(RR.Reg);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1097 if (RC == &Hexagon::IntRegsRegClass) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1098 BW = 32;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1099 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1100 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1101 if (RC == &Hexagon::DoubleRegsRegClass) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1102 BW = (RR.Sub != 0) ? 32 : 64;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1103 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1104 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1105 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1106 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1107
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1108 bool HexagonExpandCondsets::isIntraBlocks(LiveInterval &LI) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1109 for (LiveInterval::iterator I = LI.begin(), E = LI.end(); I != E; ++I) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1110 LiveRange::Segment &LR = *I;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1111 // Range must start at a register...
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1112 if (!LR.start.isRegister())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1113 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1114 // ...and end in a register or in a dead slot.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1115 if (!LR.end.isRegister() && !LR.end.isDead())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1116 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1117 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1118 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1119 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1120
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1121 bool HexagonExpandCondsets::coalesceRegisters(RegisterRef R1, RegisterRef R2) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1122 if (CoaLimitActive) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1123 if (CoaCounter >= CoaLimit)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1124 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1125 CoaCounter++;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1126 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1127 unsigned BW1, BW2;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1128 if (!isIntReg(R1, BW1) \|\| !isIntReg(R2, BW2) \|\| BW1 != BW2)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1129 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1130 if (MRI->isLiveIn(R1.Reg))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1131 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1132 if (MRI->isLiveIn(R2.Reg))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1133 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1134
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1135 LiveInterval &L1 = LIS->getInterval(R1.Reg);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1136 LiveInterval &L2 = LIS->getInterval(R2.Reg);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1137 if (L2.empty())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1138 return false;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1139 if (L1.hasSubRanges() \|\| L2.hasSubRanges())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1140 return false;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1141 bool Overlap = L1.overlaps(L2);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1142
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1143 LLVM_DEBUG(dbgs() << "compatible registers: ("
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1144 << (Overlap ? "overlap" : "disjoint") << ")\n "
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1145 << printReg(R1.Reg, TRI, R1.Sub) << " " << L1 << "\n "
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1146 << printReg(R2.Reg, TRI, R2.Sub) << " " << L2 << "\n");
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1147 if (R1.Sub \|\| R2.Sub)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1148 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1149 if (Overlap)
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1150 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1151
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1152 // Coalescing could have a negative impact on scheduling, so try to limit
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1153 // to some reasonable extent. Only consider coalescing segments, when one
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1154 // of them does not cross basic block boundaries.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1155 if (!isIntraBlocks(L1) && !isIntraBlocks(L2))
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1156 return false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1157
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1158 MRI->replaceRegWith(R2.Reg, R1.Reg);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1159
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1160 // Move all live segments from L2 to L1.
121 803732b1fca8 LLVM 5.0 kono parents: 120 diff changeset	1161 using ValueInfoMap = DenseMap<VNInfo , VNInfo >;
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1162 ValueInfoMap VM;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1163 for (LiveInterval::iterator I = L2.begin(), E = L2.end(); I != E; ++I) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1164 VNInfo NewVN, OldVN = I->valno;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1165 ValueInfoMap::iterator F = VM.find(OldVN);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1166 if (F == VM.end()) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1167 NewVN = L1.getNextValue(I->valno->def, LIS->getVNInfoAllocator());
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1168 VM.insert(std::make_pair(OldVN, NewVN));
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1169 } else {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1170 NewVN = F->second;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1171 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1172 L1.addSegment(LiveRange::Segment(I->start, I->end, NewVN));
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1173 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1174 while (L2.begin() != L2.end())
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1175 L2.removeSegment(*L2.begin());
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1176 LIS->removeInterval(R2.Reg);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1177
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1178 updateKillFlags(R1.Reg);
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1179 LLVM_DEBUG(dbgs() << "coalesced: " << L1 << "\n");
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1180 L1.verify();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1181
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1182 return true;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1183 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1184
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1185 /// Attempt to coalesce one of the source registers to a MUX instruction with
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1186 /// the destination register. This could lead to having only one predicated
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1187 /// instruction in the end instead of two.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1188 bool HexagonExpandCondsets::coalesceSegments(
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1189 const SmallVectorImpl<MachineInstr*> &Condsets,
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1190 std::set<unsigned> &UpdRegs) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1191 SmallVector<MachineInstr*,16> TwoRegs;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1192 for (MachineInstr *MI : Condsets) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1193 MachineOperand &S1 = MI->getOperand(2), &S2 = MI->getOperand(3);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1194 if (!S1.isReg() && !S2.isReg())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1195 continue;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1196 TwoRegs.push_back(MI);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1197 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1198
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1199 bool Changed = false;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1200 for (MachineInstr *CI : TwoRegs) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1201 RegisterRef RD = CI->getOperand(0);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1202 RegisterRef RP = CI->getOperand(1);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1203 MachineOperand &S1 = CI->getOperand(2), &S2 = CI->getOperand(3);
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1204 bool Done = false;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1205 // Consider this case:
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1206 // %1 = instr1 ...
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1207 // %2 = instr2 ...
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1208 // %0 = C2_mux ..., %1, %2
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1209 // If %0 was coalesced with %1, we could end up with the following
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1210 // code:
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1211 // %0 = instr1 ...
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1212 // %2 = instr2 ...
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1213 // %0 = A2_tfrf ..., %2
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1214 // which will later become:
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1215 // %0 = instr1 ...
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1216 // %0 = instr2_cNotPt ...
3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1217 // i.e. there will be an unconditional definition (instr1) of %0
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1218 // followed by a conditional one. The output dependency was there before
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1219 // and it unavoidable, but if instr1 is predicable, we will no longer be
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1220 // able to predicate it here.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1221 // To avoid this scenario, don't coalesce the destination register with
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1222 // a source register that is defined by a predicable instruction.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1223 if (S1.isReg()) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1224 RegisterRef RS = S1;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1225 MachineInstr *RDef = getReachingDefForPred(RS, CI, RP.Reg, true);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1226 if (!RDef \|\| !HII->isPredicable(*RDef)) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1227 Done = coalesceRegisters(RD, RegisterRef(S1));
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1228 if (Done) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1229 UpdRegs.insert(RD.Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1230 UpdRegs.insert(S1.getReg());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1231 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1232 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1233 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1234 if (!Done && S2.isReg()) {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1235 RegisterRef RS = S2;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1236 MachineInstr *RDef = getReachingDefForPred(RS, CI, RP.Reg, false);
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1237 if (!RDef \|\| !HII->isPredicable(*RDef)) {
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1238 Done = coalesceRegisters(RD, RegisterRef(S2));
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1239 if (Done) {
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1240 UpdRegs.insert(RD.Reg);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1241 UpdRegs.insert(S2.getReg());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1242 }
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1243 }
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1244 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1245 Changed \|= Done;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1246 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1247 return Changed;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1248 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1249
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1250 bool HexagonExpandCondsets::runOnMachineFunction(MachineFunction &MF) {
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1251 if (skipFunction(MF.getFunction()))
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1252 return false;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1253
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1254 HII = static_cast<const HexagonInstrInfo*>(MF.getSubtarget().getInstrInfo());
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1255 TRI = MF.getSubtarget().getRegisterInfo();
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1256 MDT = &getAnalysis<MachineDominatorTree>();
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1257 LIS = &getAnalysis<LiveIntervals>();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1258 MRI = &MF.getRegInfo();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1259
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1260 LLVM_DEBUG(LIS->print(dbgs() << "Before expand-condsets\n",
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1261 MF.getFunction().getParent()));
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1262
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1263 bool Changed = false;
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1264 std::set<unsigned> CoalUpd, PredUpd;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1265
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1266 SmallVector<MachineInstr*,16> Condsets;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1267 for (auto &B : MF)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1268 for (auto &I : B)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1269 if (isCondset(I))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1270 Condsets.push_back(&I);
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1271
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1272 // Try to coalesce the target of a mux with one of its sources.
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1273 // This could eliminate a register copy in some circumstances.
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1274 Changed \|= coalesceSegments(Condsets, CoalUpd);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1275
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1276 // Update kill flags on all source operands. This is done here because
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1277 // at this moment (when expand-condsets runs), there are no kill flags
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1278 // in the IR (they have been removed by live range analysis).
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1279 // Updating them right before we split is the easiest, because splitting
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1280 // adds definitions which would interfere with updating kills afterwards.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1281 std::set<unsigned> KillUpd;
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1282 for (MachineInstr *MI : Condsets)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1283 for (MachineOperand &Op : MI->operands())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1284 if (Op.isReg() && Op.isUse())
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1285 if (!CoalUpd.count(Op.getReg()))
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1286 KillUpd.insert(Op.getReg());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1287 updateLiveness(KillUpd, false, true, false);
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1288 LLVM_DEBUG(
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1289 LIS->print(dbgs() << "After coalescing\n", MF.getFunction().getParent()));
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1290
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1291 // First, simply split all muxes into a pair of conditional transfers
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1292 // and update the live intervals to reflect the new arrangement. The
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1293 // goal is to update the kill flags, since predication will rely on
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1294 // them.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1295 for (MachineInstr *MI : Condsets)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1296 Changed \|= split(*MI, PredUpd);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1297 Condsets.clear(); // The contents of Condsets are invalid here anyway.
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1298
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1299 // Do not update live ranges after splitting. Recalculation of live
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1300 // intervals removes kill flags, which were preserved by splitting on
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1301 // the source operands of condsets. These kill flags are needed by
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1302 // predication, and after splitting they are difficult to recalculate
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1303 // (because of predicated defs), so make sure they are left untouched.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1304 // Predication does not use live intervals.
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1305 LLVM_DEBUG(
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1306 LIS->print(dbgs() << "After splitting\n", MF.getFunction().getParent()));
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1307
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1308 // Traverse all blocks and collapse predicable instructions feeding
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1309 // conditional transfers into predicated instructions.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1310 // Walk over all the instructions again, so we may catch pre-existing
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1311 // cases that were not created in the previous step.
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1312 for (auto &B : MF)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1313 Changed \|= predicateInBlock(B, PredUpd);
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1314 LLVM_DEBUG(LIS->print(dbgs() << "After predicating\n",
c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1315 MF.getFunction().getParent()));
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1316
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1317 PredUpd.insert(CoalUpd.begin(), CoalUpd.end());
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1318 updateLiveness(PredUpd, true, true, true);
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1319
147 c2174574ed3a LLVM 10 Shinji KONO <kono@ie.u-ryukyu.ac.jp> parents: 134 diff changeset	1320 LLVM_DEBUG({
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1321 if (Changed)
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1322 LIS->print(dbgs() << "After expand-condsets\n",
134 3a76565eade5 update 5.0.1 mir3636 parents: 121 diff changeset	1323 MF.getFunction().getParent());
120 1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1324 });
1172e4bd9c6f update 4.0.0 mir3636 parents: 95 diff changeset	1325
95 afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1326 return Changed;
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1327 }
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1328
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1329 //===----------------------------------------------------------------------===//
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1330 // Public Constructor Functions
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1331 //===----------------------------------------------------------------------===//
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1332 FunctionPass *llvm::createHexagonExpandCondsets() {
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1333 return new HexagonExpandCondsets();
afa8332a0e37 LLVM 3.8 Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> parents: diff changeset	1334 }

Mercurial > hg > CbC > CbC_llvm

annotate lib/Target/Hexagon/HexagonExpandCondsets.cpp @ 147:c2174574ed3a