blob: 83998c8bc2da6f3e377d1d2b5368e54800125a05 [file] [log] [blame]
Chris Lattnere6794492002-08-12 21:17:25 +00001//===- InstructionCombining.cpp - Combine multiple instructions -----------===//
Misha Brukmanb1c93172005-04-21 23:48:37 +00002//
John Criswell482202a2003-10-20 19:43:21 +00003// The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source License. See LICENSE.TXT for details.
Misha Brukmanb1c93172005-04-21 23:48:37 +00007//
John Criswell482202a2003-10-20 19:43:21 +00008//===----------------------------------------------------------------------===//
Chris Lattnerca081252001-12-14 16:52:21 +00009//
10// InstructionCombining - Combine instructions to form fewer, simple
Chris Lattner99f48c62002-09-02 04:59:56 +000011// instructions. This pass does not modify the CFG This pass is where algebraic
12// simplification happens.
Chris Lattnerca081252001-12-14 16:52:21 +000013//
14// This pass combines things like:
Chris Lattnerdd1a86d2004-05-04 15:19:33 +000015// %Y = add int %X, 1
16// %Z = add int %Y, 1
Chris Lattnerca081252001-12-14 16:52:21 +000017// into:
Chris Lattnerdd1a86d2004-05-04 15:19:33 +000018// %Z = add int %X, 2
Chris Lattnerca081252001-12-14 16:52:21 +000019//
20// This is a simple worklist driven algorithm.
21//
Chris Lattner216c7b82003-09-10 05:29:43 +000022// This pass guarantees that the following canonicalizations are performed on
Chris Lattnerbfb1d032003-07-23 21:41:57 +000023// the program:
24// 1. If a binary operator has a constant operand, it is moved to the RHS
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +000025// 2. Bitwise operators with constant operands are always grouped so that
26// shifts are performed first, then or's, then and's, then xor's.
Chris Lattnerbfb1d032003-07-23 21:41:57 +000027// 3. SetCC instructions are converted from <,>,<=,>= to ==,!= if possible
28// 4. All SetCC instructions on boolean values are replaced with logical ops
Chris Lattnerede3fe02003-08-13 04:18:28 +000029// 5. add X, X is represented as (X*2) => (X << 1)
30// 6. Multiplies with a power-of-two constant argument are transformed into
31// shifts.
Chris Lattner7515cab2004-11-14 19:13:23 +000032// ... etc.
Chris Lattnerbfb1d032003-07-23 21:41:57 +000033//
Chris Lattnerca081252001-12-14 16:52:21 +000034//===----------------------------------------------------------------------===//
35
Chris Lattner7d2a5392004-03-13 23:54:27 +000036#define DEBUG_TYPE "instcombine"
Chris Lattnerb4cfa7f2002-05-07 20:03:00 +000037#include "llvm/Transforms/Scalar.h"
Chris Lattner00648e12004-10-12 04:52:52 +000038#include "llvm/IntrinsicInst.h"
Chris Lattner04805fa2002-02-26 21:46:54 +000039#include "llvm/Pass.h"
Chris Lattner1085bdf2002-11-04 16:18:53 +000040#include "llvm/DerivedTypes.h"
Chris Lattner0f1d8a32003-06-26 05:06:25 +000041#include "llvm/GlobalVariable.h"
Chris Lattnerf4ad1652003-11-02 05:57:39 +000042#include "llvm/Target/TargetData.h"
43#include "llvm/Transforms/Utils/BasicBlockUtils.h"
44#include "llvm/Transforms/Utils/Local.h"
Chris Lattner69193f92004-04-05 01:30:19 +000045#include "llvm/Support/CallSite.h"
Chris Lattner39c98bb2004-12-08 23:43:58 +000046#include "llvm/Support/Debug.h"
Chris Lattner69193f92004-04-05 01:30:19 +000047#include "llvm/Support/GetElementPtrTypeIterator.h"
Chris Lattner60a65912002-02-12 21:07:25 +000048#include "llvm/Support/InstIterator.h"
Chris Lattner260ab202002-04-18 17:39:14 +000049#include "llvm/Support/InstVisitor.h"
Chris Lattnerd4252a72004-07-30 07:50:03 +000050#include "llvm/Support/PatternMatch.h"
Reid Spencer7c16caa2004-09-01 22:55:40 +000051#include "llvm/ADT/Statistic.h"
Chris Lattner39c98bb2004-12-08 23:43:58 +000052#include "llvm/ADT/STLExtras.h"
Chris Lattner053c0932002-05-14 15:24:07 +000053#include <algorithm>
Chris Lattner8427bff2003-12-07 01:24:23 +000054using namespace llvm;
Chris Lattnerd4252a72004-07-30 07:50:03 +000055using namespace llvm::PatternMatch;
Brian Gaeke960707c2003-11-11 22:41:34 +000056
Chris Lattner260ab202002-04-18 17:39:14 +000057namespace {
Chris Lattnerbf3a0992002-10-01 22:38:41 +000058 Statistic<> NumCombined ("instcombine", "Number of insts combined");
59 Statistic<> NumConstProp("instcombine", "Number of constant folds");
60 Statistic<> NumDeadInst ("instcombine", "Number of dead inst eliminated");
Chris Lattner39c98bb2004-12-08 23:43:58 +000061 Statistic<> NumSunkInst ("instcombine", "Number of instructions sunk");
Chris Lattnerbf3a0992002-10-01 22:38:41 +000062
Chris Lattnerc8e66542002-04-27 06:56:12 +000063 class InstCombiner : public FunctionPass,
Chris Lattner260ab202002-04-18 17:39:14 +000064 public InstVisitor<InstCombiner, Instruction*> {
65 // Worklist of all of the instructions that need to be simplified.
66 std::vector<Instruction*> WorkList;
Chris Lattnerf4ad1652003-11-02 05:57:39 +000067 TargetData *TD;
Chris Lattner260ab202002-04-18 17:39:14 +000068
Chris Lattner51ea1272004-02-28 05:22:00 +000069 /// AddUsersToWorkList - When an instruction is simplified, add all users of
70 /// the instruction to the work lists because they might get more simplified
71 /// now.
72 ///
73 void AddUsersToWorkList(Instruction &I) {
Chris Lattner113f4f42002-06-25 16:13:24 +000074 for (Value::use_iterator UI = I.use_begin(), UE = I.use_end();
Chris Lattner260ab202002-04-18 17:39:14 +000075 UI != UE; ++UI)
76 WorkList.push_back(cast<Instruction>(*UI));
77 }
78
Chris Lattner51ea1272004-02-28 05:22:00 +000079 /// AddUsesToWorkList - When an instruction is simplified, add operands to
80 /// the work lists because they might get more simplified now.
81 ///
82 void AddUsesToWorkList(Instruction &I) {
83 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
84 if (Instruction *Op = dyn_cast<Instruction>(I.getOperand(i)))
85 WorkList.push_back(Op);
86 }
87
Chris Lattner99f48c62002-09-02 04:59:56 +000088 // removeFromWorkList - remove all instances of I from the worklist.
89 void removeFromWorkList(Instruction *I);
Chris Lattner260ab202002-04-18 17:39:14 +000090 public:
Chris Lattner113f4f42002-06-25 16:13:24 +000091 virtual bool runOnFunction(Function &F);
Chris Lattner260ab202002-04-18 17:39:14 +000092
Chris Lattnerf12cc842002-04-28 21:27:06 +000093 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
Chris Lattnerf4ad1652003-11-02 05:57:39 +000094 AU.addRequired<TargetData>();
Chris Lattner820d9712002-10-21 20:00:28 +000095 AU.setPreservesCFG();
Chris Lattnerf12cc842002-04-28 21:27:06 +000096 }
97
Chris Lattner69193f92004-04-05 01:30:19 +000098 TargetData &getTargetData() const { return *TD; }
99
Chris Lattner260ab202002-04-18 17:39:14 +0000100 // Visitation implementation - Implement instruction combining for different
101 // instruction types. The semantics are as follows:
102 // Return Value:
103 // null - No change was made
Chris Lattnere6794492002-08-12 21:17:25 +0000104 // I - Change was made, I is still valid, I may be dead though
Chris Lattner260ab202002-04-18 17:39:14 +0000105 // otherwise - Change was made, replace I with returned instruction
Misha Brukmanb1c93172005-04-21 23:48:37 +0000106 //
Chris Lattner113f4f42002-06-25 16:13:24 +0000107 Instruction *visitAdd(BinaryOperator &I);
108 Instruction *visitSub(BinaryOperator &I);
109 Instruction *visitMul(BinaryOperator &I);
110 Instruction *visitDiv(BinaryOperator &I);
111 Instruction *visitRem(BinaryOperator &I);
112 Instruction *visitAnd(BinaryOperator &I);
113 Instruction *visitOr (BinaryOperator &I);
114 Instruction *visitXor(BinaryOperator &I);
Chris Lattnerd1f46d32005-04-24 06:59:08 +0000115 Instruction *visitSetCondInst(SetCondInst &I);
116 Instruction *visitSetCondInstWithCastAndCast(SetCondInst &SCI);
117
Chris Lattner0798af32005-01-13 20:14:25 +0000118 Instruction *FoldGEPSetCC(User *GEPLHS, Value *RHS,
119 Instruction::BinaryOps Cond, Instruction &I);
Chris Lattnere8d6c602003-03-10 19:16:08 +0000120 Instruction *visitShiftInst(ShiftInst &I);
Chris Lattner113f4f42002-06-25 16:13:24 +0000121 Instruction *visitCastInst(CastInst &CI);
Chris Lattner411336f2005-01-19 21:50:18 +0000122 Instruction *FoldSelectOpOp(SelectInst &SI, Instruction *TI,
123 Instruction *FI);
Chris Lattnerb909e8b2004-03-12 05:52:32 +0000124 Instruction *visitSelectInst(SelectInst &CI);
Chris Lattner970c33a2003-06-19 17:00:31 +0000125 Instruction *visitCallInst(CallInst &CI);
126 Instruction *visitInvokeInst(InvokeInst &II);
Chris Lattner113f4f42002-06-25 16:13:24 +0000127 Instruction *visitPHINode(PHINode &PN);
128 Instruction *visitGetElementPtrInst(GetElementPtrInst &GEP);
Chris Lattner1085bdf2002-11-04 16:18:53 +0000129 Instruction *visitAllocationInst(AllocationInst &AI);
Chris Lattner8427bff2003-12-07 01:24:23 +0000130 Instruction *visitFreeInst(FreeInst &FI);
Chris Lattner0f1d8a32003-06-26 05:06:25 +0000131 Instruction *visitLoadInst(LoadInst &LI);
Chris Lattner31f486c2005-01-31 05:36:43 +0000132 Instruction *visitStoreInst(StoreInst &SI);
Chris Lattner9eef8a72003-06-04 04:46:00 +0000133 Instruction *visitBranchInst(BranchInst &BI);
Chris Lattner4c9c20a2004-07-03 00:26:11 +0000134 Instruction *visitSwitchInst(SwitchInst &SI);
Chris Lattner260ab202002-04-18 17:39:14 +0000135
136 // visitInstruction - Specify what to return for unhandled instructions...
Chris Lattner113f4f42002-06-25 16:13:24 +0000137 Instruction *visitInstruction(Instruction &I) { return 0; }
Chris Lattner6d14f2a2002-08-09 23:47:40 +0000138
Chris Lattner970c33a2003-06-19 17:00:31 +0000139 private:
Chris Lattneraec3d942003-10-07 22:32:43 +0000140 Instruction *visitCallSite(CallSite CS);
Chris Lattner970c33a2003-06-19 17:00:31 +0000141 bool transformConstExprCastCall(CallSite CS);
142
Chris Lattner69193f92004-04-05 01:30:19 +0000143 public:
Chris Lattner6d14f2a2002-08-09 23:47:40 +0000144 // InsertNewInstBefore - insert an instruction New before instruction Old
145 // in the program. Add the new instruction to the worklist.
146 //
Chris Lattner623826c2004-09-28 21:48:02 +0000147 Instruction *InsertNewInstBefore(Instruction *New, Instruction &Old) {
Chris Lattner65217ff2002-08-23 18:32:43 +0000148 assert(New && New->getParent() == 0 &&
149 "New instruction already inserted into a basic block!");
Chris Lattner6d14f2a2002-08-09 23:47:40 +0000150 BasicBlock *BB = Old.getParent();
151 BB->getInstList().insert(&Old, New); // Insert inst
152 WorkList.push_back(New); // Add to worklist
Chris Lattnere79e8542004-02-23 06:38:22 +0000153 return New;
Chris Lattner6d14f2a2002-08-09 23:47:40 +0000154 }
155
Chris Lattner7e794272004-09-24 15:21:34 +0000156 /// InsertCastBefore - Insert a cast of V to TY before the instruction POS.
157 /// This also adds the cast to the worklist. Finally, this returns the
158 /// cast.
159 Value *InsertCastBefore(Value *V, const Type *Ty, Instruction &Pos) {
160 if (V->getType() == Ty) return V;
Misha Brukmanb1c93172005-04-21 23:48:37 +0000161
Chris Lattner7e794272004-09-24 15:21:34 +0000162 Instruction *C = new CastInst(V, Ty, V->getName(), &Pos);
163 WorkList.push_back(C);
164 return C;
165 }
166
Chris Lattner6d14f2a2002-08-09 23:47:40 +0000167 // ReplaceInstUsesWith - This method is to be used when an instruction is
168 // found to be dead, replacable with another preexisting expression. Here
169 // we add all uses of I to the worklist, replace all uses of I with the new
170 // value, then return I, so that the inst combiner will know that I was
171 // modified.
172 //
173 Instruction *ReplaceInstUsesWith(Instruction &I, Value *V) {
Chris Lattner51ea1272004-02-28 05:22:00 +0000174 AddUsersToWorkList(I); // Add all modified instrs to worklist
Chris Lattner8953b902004-04-05 02:10:19 +0000175 if (&I != V) {
176 I.replaceAllUsesWith(V);
177 return &I;
178 } else {
179 // If we are replacing the instruction with itself, this must be in a
180 // segment of unreachable code, so just clobber the instruction.
Chris Lattner8ba9ec92004-10-18 02:59:09 +0000181 I.replaceAllUsesWith(UndefValue::get(I.getType()));
Chris Lattner8953b902004-04-05 02:10:19 +0000182 return &I;
183 }
Chris Lattner6d14f2a2002-08-09 23:47:40 +0000184 }
Chris Lattner51ea1272004-02-28 05:22:00 +0000185
186 // EraseInstFromFunction - When dealing with an instruction that has side
187 // effects or produces a void value, we can't rely on DCE to delete the
188 // instruction. Instead, visit methods should return the value returned by
189 // this function.
190 Instruction *EraseInstFromFunction(Instruction &I) {
191 assert(I.use_empty() && "Cannot erase instruction that is used!");
192 AddUsesToWorkList(I);
193 removeFromWorkList(&I);
Chris Lattner95307542004-11-18 21:41:39 +0000194 I.eraseFromParent();
Chris Lattner51ea1272004-02-28 05:22:00 +0000195 return 0; // Don't do anything with FI
196 }
197
198
Chris Lattner3ac7c262003-08-13 20:16:26 +0000199 private:
Chris Lattnerdfae8be2003-07-24 17:35:25 +0000200 /// InsertOperandCastBefore - This inserts a cast of V to DestTy before the
201 /// InsertBefore instruction. This is specialized a bit to avoid inserting
202 /// casts that are known to not do anything...
203 ///
204 Value *InsertOperandCastBefore(Value *V, const Type *DestTy,
205 Instruction *InsertBefore);
206
Chris Lattner7fb29e12003-03-11 00:12:48 +0000207 // SimplifyCommutative - This performs a few simplifications for commutative
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000208 // operators.
Chris Lattner7fb29e12003-03-11 00:12:48 +0000209 bool SimplifyCommutative(BinaryOperator &I);
Chris Lattnerba1cb382003-09-19 17:17:26 +0000210
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000211
212 // FoldOpIntoPhi - Given a binary operator or cast instruction which has a
213 // PHI node as operand #0, see if we can fold the instruction into the PHI
214 // (which is only possible if all operands to the PHI are constants).
215 Instruction *FoldOpIntoPhi(Instruction &I);
216
Chris Lattner7515cab2004-11-14 19:13:23 +0000217 // FoldPHIArgOpIntoPHI - If all operands to a PHI node are the same "unary"
218 // operator and they all are only used by the PHI, PHI together their
219 // inputs, and do the operation once, to the result of the PHI.
220 Instruction *FoldPHIArgOpIntoPHI(PHINode &PN);
221
Chris Lattnerba1cb382003-09-19 17:17:26 +0000222 Instruction *OptAndOp(Instruction *Op, ConstantIntegral *OpRHS,
223 ConstantIntegral *AndRHS, BinaryOperator &TheAnd);
Chris Lattner6862fbd2004-09-29 17:40:11 +0000224
225 Instruction *InsertRangeTest(Value *V, Constant *Lo, Constant *Hi,
226 bool Inside, Instruction &IB);
Chris Lattner260ab202002-04-18 17:39:14 +0000227 };
Chris Lattnerb28b6802002-07-23 18:06:35 +0000228
Chris Lattnerc8b70922002-07-26 21:12:46 +0000229 RegisterOpt<InstCombiner> X("instcombine", "Combine redundant instructions");
Chris Lattner260ab202002-04-18 17:39:14 +0000230}
231
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000232// getComplexity: Assign a complexity or rank value to LLVM Values...
Chris Lattner81a7a232004-10-16 18:11:37 +0000233// 0 -> undef, 1 -> Const, 2 -> Other, 3 -> Arg, 3 -> Unary, 4 -> OtherInst
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000234static unsigned getComplexity(Value *V) {
235 if (isa<Instruction>(V)) {
236 if (BinaryOperator::isNeg(V) || BinaryOperator::isNot(V))
Chris Lattner81a7a232004-10-16 18:11:37 +0000237 return 3;
238 return 4;
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000239 }
Chris Lattner81a7a232004-10-16 18:11:37 +0000240 if (isa<Argument>(V)) return 3;
241 return isa<Constant>(V) ? (isa<UndefValue>(V) ? 0 : 1) : 2;
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000242}
Chris Lattner260ab202002-04-18 17:39:14 +0000243
Chris Lattner7fb29e12003-03-11 00:12:48 +0000244// isOnlyUse - Return true if this instruction will be deleted if we stop using
245// it.
246static bool isOnlyUse(Value *V) {
Chris Lattnerf95d9b92003-10-15 16:48:29 +0000247 return V->hasOneUse() || isa<Constant>(V);
Chris Lattner7fb29e12003-03-11 00:12:48 +0000248}
249
Chris Lattnere79e8542004-02-23 06:38:22 +0000250// getPromotedType - Return the specified type promoted as it would be to pass
251// though a va_arg area...
252static const Type *getPromotedType(const Type *Ty) {
Chris Lattner97bfcea2004-06-17 18:16:02 +0000253 switch (Ty->getTypeID()) {
Chris Lattnere79e8542004-02-23 06:38:22 +0000254 case Type::SByteTyID:
255 case Type::ShortTyID: return Type::IntTy;
256 case Type::UByteTyID:
257 case Type::UShortTyID: return Type::UIntTy;
258 case Type::FloatTyID: return Type::DoubleTy;
259 default: return Ty;
260 }
261}
262
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000263// SimplifyCommutative - This performs a few simplifications for commutative
264// operators:
Chris Lattner260ab202002-04-18 17:39:14 +0000265//
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000266// 1. Order operands such that they are listed from right (least complex) to
267// left (most complex). This puts constants before unary operators before
268// binary operators.
269//
Chris Lattner7fb29e12003-03-11 00:12:48 +0000270// 2. Transform: (op (op V, C1), C2) ==> (op V, (op C1, C2))
271// 3. Transform: (op (op V1, C1), (op V2, C2)) ==> (op (op V1, V2), (op C1,C2))
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000272//
Chris Lattner7fb29e12003-03-11 00:12:48 +0000273bool InstCombiner::SimplifyCommutative(BinaryOperator &I) {
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000274 bool Changed = false;
275 if (getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1)))
276 Changed = !I.swapOperands();
Misha Brukmanb1c93172005-04-21 23:48:37 +0000277
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000278 if (!I.isAssociative()) return Changed;
279 Instruction::BinaryOps Opcode = I.getOpcode();
Chris Lattner7fb29e12003-03-11 00:12:48 +0000280 if (BinaryOperator *Op = dyn_cast<BinaryOperator>(I.getOperand(0)))
281 if (Op->getOpcode() == Opcode && isa<Constant>(Op->getOperand(1))) {
282 if (isa<Constant>(I.getOperand(1))) {
Chris Lattner34428442003-05-27 16:40:51 +0000283 Constant *Folded = ConstantExpr::get(I.getOpcode(),
284 cast<Constant>(I.getOperand(1)),
285 cast<Constant>(Op->getOperand(1)));
Chris Lattner7fb29e12003-03-11 00:12:48 +0000286 I.setOperand(0, Op->getOperand(0));
287 I.setOperand(1, Folded);
288 return true;
289 } else if (BinaryOperator *Op1=dyn_cast<BinaryOperator>(I.getOperand(1)))
290 if (Op1->getOpcode() == Opcode && isa<Constant>(Op1->getOperand(1)) &&
291 isOnlyUse(Op) && isOnlyUse(Op1)) {
292 Constant *C1 = cast<Constant>(Op->getOperand(1));
293 Constant *C2 = cast<Constant>(Op1->getOperand(1));
294
295 // Fold (op (op V1, C1), (op V2, C2)) ==> (op (op V1, V2), (op C1,C2))
Chris Lattner34428442003-05-27 16:40:51 +0000296 Constant *Folded = ConstantExpr::get(I.getOpcode(), C1, C2);
Chris Lattner7fb29e12003-03-11 00:12:48 +0000297 Instruction *New = BinaryOperator::create(Opcode, Op->getOperand(0),
298 Op1->getOperand(0),
299 Op1->getName(), &I);
300 WorkList.push_back(New);
301 I.setOperand(0, New);
302 I.setOperand(1, Folded);
303 return true;
Misha Brukmanb1c93172005-04-21 23:48:37 +0000304 }
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000305 }
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000306 return Changed;
Chris Lattner260ab202002-04-18 17:39:14 +0000307}
Chris Lattnerca081252001-12-14 16:52:21 +0000308
Chris Lattnerbb74e222003-03-10 23:06:50 +0000309// dyn_castNegVal - Given a 'sub' instruction, return the RHS of the instruction
310// if the LHS is a constant zero (which is the 'negate' form).
Chris Lattner9fa53de2002-05-06 16:49:18 +0000311//
Chris Lattnerbb74e222003-03-10 23:06:50 +0000312static inline Value *dyn_castNegVal(Value *V) {
313 if (BinaryOperator::isNeg(V))
Chris Lattnerd6f636a2005-04-24 07:30:14 +0000314 return BinaryOperator::getNegArgument(V);
Chris Lattnerbb74e222003-03-10 23:06:50 +0000315
Chris Lattner9ad0d552004-12-14 20:08:06 +0000316 // Constants can be considered to be negated values if they can be folded.
317 if (ConstantInt *C = dyn_cast<ConstantInt>(V))
318 return ConstantExpr::getNeg(C);
Chris Lattnerbb74e222003-03-10 23:06:50 +0000319 return 0;
Chris Lattner9fa53de2002-05-06 16:49:18 +0000320}
321
Chris Lattnerbb74e222003-03-10 23:06:50 +0000322static inline Value *dyn_castNotVal(Value *V) {
323 if (BinaryOperator::isNot(V))
Chris Lattnerd6f636a2005-04-24 07:30:14 +0000324 return BinaryOperator::getNotArgument(V);
Chris Lattnerbb74e222003-03-10 23:06:50 +0000325
326 // Constants can be considered to be not'ed values...
Chris Lattnerdd65d862003-04-30 22:34:06 +0000327 if (ConstantIntegral *C = dyn_cast<ConstantIntegral>(V))
Chris Lattnerc8e7e292004-06-10 02:12:35 +0000328 return ConstantExpr::getNot(C);
Chris Lattnerbb74e222003-03-10 23:06:50 +0000329 return 0;
330}
331
Chris Lattner7fb29e12003-03-11 00:12:48 +0000332// dyn_castFoldableMul - If this value is a multiply that can be folded into
333// other computations (because it has a constant operand), return the
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000334// non-constant operand of the multiply, and set CST to point to the multiplier.
335// Otherwise, return null.
Chris Lattner7fb29e12003-03-11 00:12:48 +0000336//
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000337static inline Value *dyn_castFoldableMul(Value *V, ConstantInt *&CST) {
Chris Lattnerf95d9b92003-10-15 16:48:29 +0000338 if (V->hasOneUse() && V->getType()->isInteger())
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000339 if (Instruction *I = dyn_cast<Instruction>(V)) {
Chris Lattner7fb29e12003-03-11 00:12:48 +0000340 if (I->getOpcode() == Instruction::Mul)
Chris Lattner970136362004-11-15 05:54:07 +0000341 if ((CST = dyn_cast<ConstantInt>(I->getOperand(1))))
Chris Lattner7fb29e12003-03-11 00:12:48 +0000342 return I->getOperand(0);
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000343 if (I->getOpcode() == Instruction::Shl)
Chris Lattner970136362004-11-15 05:54:07 +0000344 if ((CST = dyn_cast<ConstantInt>(I->getOperand(1)))) {
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000345 // The multiplier is really 1 << CST.
346 Constant *One = ConstantInt::get(V->getType(), 1);
347 CST = cast<ConstantInt>(ConstantExpr::getShl(One, CST));
348 return I->getOperand(0);
349 }
350 }
Chris Lattner7fb29e12003-03-11 00:12:48 +0000351 return 0;
Chris Lattner3082c5a2003-02-18 19:28:33 +0000352}
Chris Lattner31ae8632002-08-14 17:51:49 +0000353
Chris Lattner0798af32005-01-13 20:14:25 +0000354/// dyn_castGetElementPtr - If this is a getelementptr instruction or constant
355/// expression, return it.
356static User *dyn_castGetElementPtr(Value *V) {
357 if (isa<GetElementPtrInst>(V)) return cast<User>(V);
358 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
359 if (CE->getOpcode() == Instruction::GetElementPtr)
360 return cast<User>(V);
361 return false;
362}
363
Chris Lattner3082c5a2003-02-18 19:28:33 +0000364// Log2 - Calculate the log base 2 for the specified value if it is exactly a
365// power of 2.
366static unsigned Log2(uint64_t Val) {
367 assert(Val > 1 && "Values 0 and 1 should be handled elsewhere!");
368 unsigned Count = 0;
369 while (Val != 1) {
370 if (Val & 1) return 0; // Multiple bits set?
371 Val >>= 1;
372 ++Count;
373 }
374 return Count;
Chris Lattner31ae8632002-08-14 17:51:49 +0000375}
376
Chris Lattner623826c2004-09-28 21:48:02 +0000377// AddOne, SubOne - Add or subtract a constant one from an integer constant...
Chris Lattner6862fbd2004-09-29 17:40:11 +0000378static ConstantInt *AddOne(ConstantInt *C) {
379 return cast<ConstantInt>(ConstantExpr::getAdd(C,
380 ConstantInt::get(C->getType(), 1)));
Chris Lattner623826c2004-09-28 21:48:02 +0000381}
Chris Lattner6862fbd2004-09-29 17:40:11 +0000382static ConstantInt *SubOne(ConstantInt *C) {
383 return cast<ConstantInt>(ConstantExpr::getSub(C,
384 ConstantInt::get(C->getType(), 1)));
Chris Lattner623826c2004-09-28 21:48:02 +0000385}
386
387// isTrueWhenEqual - Return true if the specified setcondinst instruction is
388// true when both operands are equal...
389//
390static bool isTrueWhenEqual(Instruction &I) {
391 return I.getOpcode() == Instruction::SetEQ ||
392 I.getOpcode() == Instruction::SetGE ||
393 I.getOpcode() == Instruction::SetLE;
394}
Chris Lattnerb8b97502003-08-13 19:01:45 +0000395
396/// AssociativeOpt - Perform an optimization on an associative operator. This
397/// function is designed to check a chain of associative operators for a
398/// potential to apply a certain optimization. Since the optimization may be
399/// applicable if the expression was reassociated, this checks the chain, then
400/// reassociates the expression as necessary to expose the optimization
401/// opportunity. This makes use of a special Functor, which must define
402/// 'shouldApply' and 'apply' methods.
403///
404template<typename Functor>
405Instruction *AssociativeOpt(BinaryOperator &Root, const Functor &F) {
406 unsigned Opcode = Root.getOpcode();
407 Value *LHS = Root.getOperand(0);
408
409 // Quick check, see if the immediate LHS matches...
410 if (F.shouldApply(LHS))
411 return F.apply(Root);
412
413 // Otherwise, if the LHS is not of the same opcode as the root, return.
414 Instruction *LHSI = dyn_cast<Instruction>(LHS);
Chris Lattnerf95d9b92003-10-15 16:48:29 +0000415 while (LHSI && LHSI->getOpcode() == Opcode && LHSI->hasOneUse()) {
Chris Lattnerb8b97502003-08-13 19:01:45 +0000416 // Should we apply this transform to the RHS?
417 bool ShouldApply = F.shouldApply(LHSI->getOperand(1));
418
419 // If not to the RHS, check to see if we should apply to the LHS...
420 if (!ShouldApply && F.shouldApply(LHSI->getOperand(0))) {
421 cast<BinaryOperator>(LHSI)->swapOperands(); // Make the LHS the RHS
422 ShouldApply = true;
423 }
424
425 // If the functor wants to apply the optimization to the RHS of LHSI,
426 // reassociate the expression from ((? op A) op B) to (? op (A op B))
427 if (ShouldApply) {
428 BasicBlock *BB = Root.getParent();
Misha Brukmanb1c93172005-04-21 23:48:37 +0000429
Chris Lattnerb8b97502003-08-13 19:01:45 +0000430 // Now all of the instructions are in the current basic block, go ahead
431 // and perform the reassociation.
432 Instruction *TmpLHSI = cast<Instruction>(Root.getOperand(0));
433
434 // First move the selected RHS to the LHS of the root...
435 Root.setOperand(0, LHSI->getOperand(1));
436
437 // Make what used to be the LHS of the root be the user of the root...
438 Value *ExtraOperand = TmpLHSI->getOperand(1);
Chris Lattner284d3b02004-04-16 18:08:07 +0000439 if (&Root == TmpLHSI) {
Chris Lattner8953b902004-04-05 02:10:19 +0000440 Root.replaceAllUsesWith(Constant::getNullValue(TmpLHSI->getType()));
441 return 0;
442 }
Chris Lattner284d3b02004-04-16 18:08:07 +0000443 Root.replaceAllUsesWith(TmpLHSI); // Users now use TmpLHSI
Chris Lattnerb8b97502003-08-13 19:01:45 +0000444 TmpLHSI->setOperand(1, &Root); // TmpLHSI now uses the root
Chris Lattner284d3b02004-04-16 18:08:07 +0000445 TmpLHSI->getParent()->getInstList().remove(TmpLHSI);
446 BasicBlock::iterator ARI = &Root; ++ARI;
447 BB->getInstList().insert(ARI, TmpLHSI); // Move TmpLHSI to after Root
448 ARI = Root;
Chris Lattnerb8b97502003-08-13 19:01:45 +0000449
450 // Now propagate the ExtraOperand down the chain of instructions until we
451 // get to LHSI.
452 while (TmpLHSI != LHSI) {
453 Instruction *NextLHSI = cast<Instruction>(TmpLHSI->getOperand(0));
Chris Lattner284d3b02004-04-16 18:08:07 +0000454 // Move the instruction to immediately before the chain we are
455 // constructing to avoid breaking dominance properties.
456 NextLHSI->getParent()->getInstList().remove(NextLHSI);
457 BB->getInstList().insert(ARI, NextLHSI);
458 ARI = NextLHSI;
459
Chris Lattnerb8b97502003-08-13 19:01:45 +0000460 Value *NextOp = NextLHSI->getOperand(1);
461 NextLHSI->setOperand(1, ExtraOperand);
462 TmpLHSI = NextLHSI;
463 ExtraOperand = NextOp;
464 }
Misha Brukmanb1c93172005-04-21 23:48:37 +0000465
Chris Lattnerb8b97502003-08-13 19:01:45 +0000466 // Now that the instructions are reassociated, have the functor perform
467 // the transformation...
468 return F.apply(Root);
469 }
Misha Brukmanb1c93172005-04-21 23:48:37 +0000470
Chris Lattnerb8b97502003-08-13 19:01:45 +0000471 LHSI = dyn_cast<Instruction>(LHSI->getOperand(0));
472 }
473 return 0;
474}
475
476
477// AddRHS - Implements: X + X --> X << 1
478struct AddRHS {
479 Value *RHS;
480 AddRHS(Value *rhs) : RHS(rhs) {}
481 bool shouldApply(Value *LHS) const { return LHS == RHS; }
482 Instruction *apply(BinaryOperator &Add) const {
483 return new ShiftInst(Instruction::Shl, Add.getOperand(0),
484 ConstantInt::get(Type::UByteTy, 1));
485 }
486};
487
488// AddMaskingAnd - Implements (A & C1)+(B & C2) --> (A & C1)|(B & C2)
489// iff C1&C2 == 0
490struct AddMaskingAnd {
491 Constant *C2;
492 AddMaskingAnd(Constant *c) : C2(c) {}
493 bool shouldApply(Value *LHS) const {
Chris Lattnerd4252a72004-07-30 07:50:03 +0000494 ConstantInt *C1;
Misha Brukmanb1c93172005-04-21 23:48:37 +0000495 return match(LHS, m_And(m_Value(), m_ConstantInt(C1))) &&
Chris Lattnerd4252a72004-07-30 07:50:03 +0000496 ConstantExpr::getAnd(C1, C2)->isNullValue();
Chris Lattnerb8b97502003-08-13 19:01:45 +0000497 }
498 Instruction *apply(BinaryOperator &Add) const {
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000499 return BinaryOperator::createOr(Add.getOperand(0), Add.getOperand(1));
Chris Lattnerb8b97502003-08-13 19:01:45 +0000500 }
501};
502
Chris Lattner86102b82005-01-01 16:22:27 +0000503static Value *FoldOperationIntoSelectOperand(Instruction &I, Value *SO,
Chris Lattner183b3362004-04-09 19:05:30 +0000504 InstCombiner *IC) {
Chris Lattner86102b82005-01-01 16:22:27 +0000505 if (isa<CastInst>(I)) {
506 if (Constant *SOC = dyn_cast<Constant>(SO))
507 return ConstantExpr::getCast(SOC, I.getType());
Misha Brukmanb1c93172005-04-21 23:48:37 +0000508
Chris Lattner86102b82005-01-01 16:22:27 +0000509 return IC->InsertNewInstBefore(new CastInst(SO, I.getType(),
510 SO->getName() + ".cast"), I);
511 }
512
Chris Lattner183b3362004-04-09 19:05:30 +0000513 // Figure out if the constant is the left or the right argument.
Chris Lattner86102b82005-01-01 16:22:27 +0000514 bool ConstIsRHS = isa<Constant>(I.getOperand(1));
515 Constant *ConstOperand = cast<Constant>(I.getOperand(ConstIsRHS));
Chris Lattnerb8b97502003-08-13 19:01:45 +0000516
Chris Lattner183b3362004-04-09 19:05:30 +0000517 if (Constant *SOC = dyn_cast<Constant>(SO)) {
518 if (ConstIsRHS)
Chris Lattner86102b82005-01-01 16:22:27 +0000519 return ConstantExpr::get(I.getOpcode(), SOC, ConstOperand);
520 return ConstantExpr::get(I.getOpcode(), ConstOperand, SOC);
Chris Lattner183b3362004-04-09 19:05:30 +0000521 }
522
523 Value *Op0 = SO, *Op1 = ConstOperand;
524 if (!ConstIsRHS)
525 std::swap(Op0, Op1);
526 Instruction *New;
Chris Lattner86102b82005-01-01 16:22:27 +0000527 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(&I))
528 New = BinaryOperator::create(BO->getOpcode(), Op0, Op1,SO->getName()+".op");
529 else if (ShiftInst *SI = dyn_cast<ShiftInst>(&I))
530 New = new ShiftInst(SI->getOpcode(), Op0, Op1, SO->getName()+".sh");
Chris Lattnerf9d96652004-04-10 19:15:56 +0000531 else {
Chris Lattner183b3362004-04-09 19:05:30 +0000532 assert(0 && "Unknown binary instruction type!");
Chris Lattnerf9d96652004-04-10 19:15:56 +0000533 abort();
534 }
Chris Lattner86102b82005-01-01 16:22:27 +0000535 return IC->InsertNewInstBefore(New, I);
536}
537
538// FoldOpIntoSelect - Given an instruction with a select as one operand and a
539// constant as the other operand, try to fold the binary operator into the
540// select arguments. This also works for Cast instructions, which obviously do
541// not have a second operand.
542static Instruction *FoldOpIntoSelect(Instruction &Op, SelectInst *SI,
543 InstCombiner *IC) {
544 // Don't modify shared select instructions
545 if (!SI->hasOneUse()) return 0;
546 Value *TV = SI->getOperand(1);
547 Value *FV = SI->getOperand(2);
548
549 if (isa<Constant>(TV) || isa<Constant>(FV)) {
Chris Lattner374e6592005-04-21 05:43:13 +0000550 // Bool selects with constant operands can be folded to logical ops.
551 if (SI->getType() == Type::BoolTy) return 0;
552
Chris Lattner86102b82005-01-01 16:22:27 +0000553 Value *SelectTrueVal = FoldOperationIntoSelectOperand(Op, TV, IC);
554 Value *SelectFalseVal = FoldOperationIntoSelectOperand(Op, FV, IC);
555
556 return new SelectInst(SI->getCondition(), SelectTrueVal,
557 SelectFalseVal);
558 }
559 return 0;
Chris Lattner183b3362004-04-09 19:05:30 +0000560}
561
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000562
563/// FoldOpIntoPhi - Given a binary operator or cast instruction which has a PHI
564/// node as operand #0, see if we can fold the instruction into the PHI (which
565/// is only possible if all operands to the PHI are constants).
566Instruction *InstCombiner::FoldOpIntoPhi(Instruction &I) {
567 PHINode *PN = cast<PHINode>(I.getOperand(0));
Chris Lattner7515cab2004-11-14 19:13:23 +0000568 unsigned NumPHIValues = PN->getNumIncomingValues();
569 if (!PN->hasOneUse() || NumPHIValues == 0 ||
570 !isa<Constant>(PN->getIncomingValue(0))) return 0;
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000571
572 // Check to see if all of the operands of the PHI are constants. If not, we
573 // cannot do the transformation.
Chris Lattner7515cab2004-11-14 19:13:23 +0000574 for (unsigned i = 1; i != NumPHIValues; ++i)
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000575 if (!isa<Constant>(PN->getIncomingValue(i)))
576 return 0;
577
578 // Okay, we can do the transformation: create the new PHI node.
579 PHINode *NewPN = new PHINode(I.getType(), I.getName());
580 I.setName("");
Chris Lattnerd8e20182005-01-29 00:39:08 +0000581 NewPN->reserveOperandSpace(PN->getNumOperands()/2);
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000582 InsertNewInstBefore(NewPN, *PN);
583
584 // Next, add all of the operands to the PHI.
585 if (I.getNumOperands() == 2) {
586 Constant *C = cast<Constant>(I.getOperand(1));
Chris Lattner7515cab2004-11-14 19:13:23 +0000587 for (unsigned i = 0; i != NumPHIValues; ++i) {
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000588 Constant *InV = cast<Constant>(PN->getIncomingValue(i));
589 NewPN->addIncoming(ConstantExpr::get(I.getOpcode(), InV, C),
590 PN->getIncomingBlock(i));
591 }
592 } else {
593 assert(isa<CastInst>(I) && "Unary op should be a cast!");
594 const Type *RetTy = I.getType();
Chris Lattner7515cab2004-11-14 19:13:23 +0000595 for (unsigned i = 0; i != NumPHIValues; ++i) {
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000596 Constant *InV = cast<Constant>(PN->getIncomingValue(i));
597 NewPN->addIncoming(ConstantExpr::getCast(InV, RetTy),
598 PN->getIncomingBlock(i));
599 }
600 }
601 return ReplaceInstUsesWith(I, NewPN);
602}
603
Chris Lattner113f4f42002-06-25 16:13:24 +0000604Instruction *InstCombiner::visitAdd(BinaryOperator &I) {
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000605 bool Changed = SimplifyCommutative(I);
Chris Lattner113f4f42002-06-25 16:13:24 +0000606 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
Chris Lattner9fa53de2002-05-06 16:49:18 +0000607
Chris Lattnercf4a9962004-04-10 22:01:55 +0000608 if (Constant *RHSC = dyn_cast<Constant>(RHS)) {
Chris Lattner81a7a232004-10-16 18:11:37 +0000609 // X + undef -> undef
610 if (isa<UndefValue>(RHS))
611 return ReplaceInstUsesWith(I, RHS);
612
Chris Lattnercf4a9962004-04-10 22:01:55 +0000613 // X + 0 --> X
614 if (!I.getType()->isFloatingPoint() && // -0 + +0 = +0, so it's not a noop
615 RHSC->isNullValue())
616 return ReplaceInstUsesWith(I, LHS);
Misha Brukmanb1c93172005-04-21 23:48:37 +0000617
Chris Lattnercf4a9962004-04-10 22:01:55 +0000618 // X + (signbit) --> X ^ signbit
619 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHSC)) {
Chris Lattnerd1f46d32005-04-24 06:59:08 +0000620 unsigned NumBits = CI->getType()->getPrimitiveSizeInBits();
Chris Lattnercf4a9962004-04-10 22:01:55 +0000621 uint64_t Val = CI->getRawValue() & (1ULL << NumBits)-1;
Chris Lattner33eb9092004-11-05 04:45:43 +0000622 if (Val == (1ULL << (NumBits-1)))
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000623 return BinaryOperator::createXor(LHS, RHS);
Chris Lattnercf4a9962004-04-10 22:01:55 +0000624 }
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000625
626 if (isa<PHINode>(LHS))
627 if (Instruction *NV = FoldOpIntoPhi(I))
628 return NV;
Chris Lattnercf4a9962004-04-10 22:01:55 +0000629 }
Chris Lattner9fa53de2002-05-06 16:49:18 +0000630
Chris Lattnerb8b97502003-08-13 19:01:45 +0000631 // X + X --> X << 1
Robert Bocchino7b5b86c2004-07-27 21:02:21 +0000632 if (I.getType()->isInteger()) {
Chris Lattnerb8b97502003-08-13 19:01:45 +0000633 if (Instruction *Result = AssociativeOpt(I, AddRHS(RHS))) return Result;
Chris Lattner47060462005-04-07 17:14:51 +0000634
635 if (Instruction *RHSI = dyn_cast<Instruction>(RHS)) {
636 if (RHSI->getOpcode() == Instruction::Sub)
637 if (LHS == RHSI->getOperand(1)) // A + (B - A) --> B
638 return ReplaceInstUsesWith(I, RHSI->getOperand(0));
639 }
640 if (Instruction *LHSI = dyn_cast<Instruction>(LHS)) {
641 if (LHSI->getOpcode() == Instruction::Sub)
642 if (RHS == LHSI->getOperand(1)) // (B - A) + A --> B
643 return ReplaceInstUsesWith(I, LHSI->getOperand(0));
644 }
Robert Bocchino7b5b86c2004-07-27 21:02:21 +0000645 }
Chris Lattnerede3fe02003-08-13 04:18:28 +0000646
Chris Lattner147e9752002-05-08 22:46:53 +0000647 // -A + B --> B - A
Chris Lattnerbb74e222003-03-10 23:06:50 +0000648 if (Value *V = dyn_castNegVal(LHS))
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000649 return BinaryOperator::createSub(RHS, V);
Chris Lattner9fa53de2002-05-06 16:49:18 +0000650
651 // A + -B --> A - B
Chris Lattnerbb74e222003-03-10 23:06:50 +0000652 if (!isa<Constant>(RHS))
653 if (Value *V = dyn_castNegVal(RHS))
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000654 return BinaryOperator::createSub(LHS, V);
Chris Lattner260ab202002-04-18 17:39:14 +0000655
Misha Brukmanb1c93172005-04-21 23:48:37 +0000656
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000657 ConstantInt *C2;
658 if (Value *X = dyn_castFoldableMul(LHS, C2)) {
659 if (X == RHS) // X*C + X --> X * (C+1)
660 return BinaryOperator::createMul(RHS, AddOne(C2));
661
662 // X*C1 + X*C2 --> X * (C1+C2)
663 ConstantInt *C1;
664 if (X == dyn_castFoldableMul(RHS, C1))
665 return BinaryOperator::createMul(X, ConstantExpr::getAdd(C1, C2));
Chris Lattner57c8d992003-02-18 19:57:07 +0000666 }
667
668 // X + X*C --> X * (C+1)
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000669 if (dyn_castFoldableMul(RHS, C2) == LHS)
670 return BinaryOperator::createMul(LHS, AddOne(C2));
671
Chris Lattner57c8d992003-02-18 19:57:07 +0000672
Chris Lattnerb8b97502003-08-13 19:01:45 +0000673 // (A & C1)+(B & C2) --> (A & C1)|(B & C2) iff C1&C2 == 0
Chris Lattnerd4252a72004-07-30 07:50:03 +0000674 if (match(RHS, m_And(m_Value(), m_ConstantInt(C2))))
Chris Lattnerb8b97502003-08-13 19:01:45 +0000675 if (Instruction *R = AssociativeOpt(I, AddMaskingAnd(C2))) return R;
Chris Lattner7fb29e12003-03-11 00:12:48 +0000676
Chris Lattnerb9cde762003-10-02 15:11:26 +0000677 if (ConstantInt *CRHS = dyn_cast<ConstantInt>(RHS)) {
Chris Lattnerd4252a72004-07-30 07:50:03 +0000678 Value *X;
679 if (match(LHS, m_Not(m_Value(X)))) { // ~X + C --> (C-1) - X
680 Constant *C= ConstantExpr::getSub(CRHS, ConstantInt::get(I.getType(), 1));
681 return BinaryOperator::createSub(C, X);
Chris Lattnerb9cde762003-10-02 15:11:26 +0000682 }
Chris Lattnerd4252a72004-07-30 07:50:03 +0000683
Chris Lattnerbff91d92004-10-08 05:07:56 +0000684 // (X & FF00) + xx00 -> (X+xx00) & FF00
685 if (LHS->hasOneUse() && match(LHS, m_And(m_Value(X), m_ConstantInt(C2)))) {
686 Constant *Anded = ConstantExpr::getAnd(CRHS, C2);
687 if (Anded == CRHS) {
688 // See if all bits from the first bit set in the Add RHS up are included
689 // in the mask. First, get the rightmost bit.
690 uint64_t AddRHSV = CRHS->getRawValue();
691
692 // Form a mask of all bits from the lowest bit added through the top.
693 uint64_t AddRHSHighBits = ~((AddRHSV & -AddRHSV)-1);
Chris Lattner2f1457f2005-04-24 17:46:05 +0000694 AddRHSHighBits &= ~0ULL >> (64-C2->getType()->getPrimitiveSizeInBits());
Chris Lattnerbff91d92004-10-08 05:07:56 +0000695
696 // See if the and mask includes all of these bits.
697 uint64_t AddRHSHighBitsAnd = AddRHSHighBits & C2->getRawValue();
Misha Brukmanb1c93172005-04-21 23:48:37 +0000698
Chris Lattnerbff91d92004-10-08 05:07:56 +0000699 if (AddRHSHighBits == AddRHSHighBitsAnd) {
700 // Okay, the xform is safe. Insert the new add pronto.
701 Value *NewAdd = InsertNewInstBefore(BinaryOperator::createAdd(X, CRHS,
702 LHS->getName()), I);
703 return BinaryOperator::createAnd(NewAdd, C2);
704 }
705 }
706 }
707
Chris Lattnerd4252a72004-07-30 07:50:03 +0000708 // Try to fold constant add into select arguments.
709 if (SelectInst *SI = dyn_cast<SelectInst>(LHS))
Chris Lattner86102b82005-01-01 16:22:27 +0000710 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattnerd4252a72004-07-30 07:50:03 +0000711 return R;
Chris Lattnerb9cde762003-10-02 15:11:26 +0000712 }
713
Chris Lattner113f4f42002-06-25 16:13:24 +0000714 return Changed ? &I : 0;
Chris Lattner260ab202002-04-18 17:39:14 +0000715}
716
Chris Lattnerbdb0ce02003-07-22 21:46:59 +0000717// isSignBit - Return true if the value represented by the constant only has the
718// highest order bit set.
719static bool isSignBit(ConstantInt *CI) {
Chris Lattnerd1f46d32005-04-24 06:59:08 +0000720 unsigned NumBits = CI->getType()->getPrimitiveSizeInBits();
Chris Lattner2f1457f2005-04-24 17:46:05 +0000721 return (CI->getRawValue() & (~0ULL >> (64-NumBits))) == (1ULL << (NumBits-1));
Chris Lattnerbdb0ce02003-07-22 21:46:59 +0000722}
723
Chris Lattner022167f2004-03-13 00:11:49 +0000724/// RemoveNoopCast - Strip off nonconverting casts from the value.
725///
726static Value *RemoveNoopCast(Value *V) {
727 if (CastInst *CI = dyn_cast<CastInst>(V)) {
728 const Type *CTy = CI->getType();
729 const Type *OpTy = CI->getOperand(0)->getType();
730 if (CTy->isInteger() && OpTy->isInteger()) {
Chris Lattnerd1f46d32005-04-24 06:59:08 +0000731 if (CTy->getPrimitiveSizeInBits() == OpTy->getPrimitiveSizeInBits())
Chris Lattner022167f2004-03-13 00:11:49 +0000732 return RemoveNoopCast(CI->getOperand(0));
733 } else if (isa<PointerType>(CTy) && isa<PointerType>(OpTy))
734 return RemoveNoopCast(CI->getOperand(0));
735 }
736 return V;
737}
738
Chris Lattner113f4f42002-06-25 16:13:24 +0000739Instruction *InstCombiner::visitSub(BinaryOperator &I) {
Chris Lattner113f4f42002-06-25 16:13:24 +0000740 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +0000741
Chris Lattnere6794492002-08-12 21:17:25 +0000742 if (Op0 == Op1) // sub X, X -> 0
743 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
Chris Lattner260ab202002-04-18 17:39:14 +0000744
Chris Lattnere6794492002-08-12 21:17:25 +0000745 // If this is a 'B = x-(-A)', change to B = x+A...
Chris Lattnerbb74e222003-03-10 23:06:50 +0000746 if (Value *V = dyn_castNegVal(Op1))
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000747 return BinaryOperator::createAdd(Op0, V);
Chris Lattner9fa53de2002-05-06 16:49:18 +0000748
Chris Lattner81a7a232004-10-16 18:11:37 +0000749 if (isa<UndefValue>(Op0))
750 return ReplaceInstUsesWith(I, Op0); // undef - X -> undef
751 if (isa<UndefValue>(Op1))
752 return ReplaceInstUsesWith(I, Op1); // X - undef -> undef
753
Chris Lattner8f2f5982003-11-05 01:06:05 +0000754 if (ConstantInt *C = dyn_cast<ConstantInt>(Op0)) {
755 // Replace (-1 - A) with (~A)...
Chris Lattner3082c5a2003-02-18 19:28:33 +0000756 if (C->isAllOnesValue())
757 return BinaryOperator::createNot(Op1);
Chris Lattnerad3c4952002-05-09 01:29:19 +0000758
Chris Lattner8f2f5982003-11-05 01:06:05 +0000759 // C - ~X == X + (1+C)
Chris Lattnerd4252a72004-07-30 07:50:03 +0000760 Value *X;
761 if (match(Op1, m_Not(m_Value(X))))
762 return BinaryOperator::createAdd(X,
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000763 ConstantExpr::getAdd(C, ConstantInt::get(I.getType(), 1)));
Chris Lattner92295c52004-03-12 23:53:13 +0000764 // -((uint)X >> 31) -> ((int)X >> 31)
765 // -((int)X >> 31) -> ((uint)X >> 31)
Chris Lattner022167f2004-03-13 00:11:49 +0000766 if (C->isNullValue()) {
767 Value *NoopCastedRHS = RemoveNoopCast(Op1);
768 if (ShiftInst *SI = dyn_cast<ShiftInst>(NoopCastedRHS))
Chris Lattner92295c52004-03-12 23:53:13 +0000769 if (SI->getOpcode() == Instruction::Shr)
770 if (ConstantUInt *CU = dyn_cast<ConstantUInt>(SI->getOperand(1))) {
771 const Type *NewTy;
Chris Lattner022167f2004-03-13 00:11:49 +0000772 if (SI->getType()->isSigned())
Chris Lattner97bfcea2004-06-17 18:16:02 +0000773 NewTy = SI->getType()->getUnsignedVersion();
Chris Lattner92295c52004-03-12 23:53:13 +0000774 else
Chris Lattner97bfcea2004-06-17 18:16:02 +0000775 NewTy = SI->getType()->getSignedVersion();
Chris Lattner92295c52004-03-12 23:53:13 +0000776 // Check to see if we are shifting out everything but the sign bit.
Chris Lattnerd1f46d32005-04-24 06:59:08 +0000777 if (CU->getValue() == SI->getType()->getPrimitiveSizeInBits()-1) {
Chris Lattner92295c52004-03-12 23:53:13 +0000778 // Ok, the transformation is safe. Insert a cast of the incoming
779 // value, then the new shift, then the new cast.
780 Instruction *FirstCast = new CastInst(SI->getOperand(0), NewTy,
781 SI->getOperand(0)->getName());
782 Value *InV = InsertNewInstBefore(FirstCast, I);
783 Instruction *NewShift = new ShiftInst(Instruction::Shr, FirstCast,
784 CU, SI->getName());
Chris Lattner022167f2004-03-13 00:11:49 +0000785 if (NewShift->getType() == I.getType())
786 return NewShift;
787 else {
788 InV = InsertNewInstBefore(NewShift, I);
789 return new CastInst(NewShift, I.getType());
790 }
Chris Lattner92295c52004-03-12 23:53:13 +0000791 }
792 }
Chris Lattner022167f2004-03-13 00:11:49 +0000793 }
Chris Lattner183b3362004-04-09 19:05:30 +0000794
795 // Try to fold constant sub into select arguments.
796 if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
Chris Lattner86102b82005-01-01 16:22:27 +0000797 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattner183b3362004-04-09 19:05:30 +0000798 return R;
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000799
800 if (isa<PHINode>(Op0))
801 if (Instruction *NV = FoldOpIntoPhi(I))
802 return NV;
Chris Lattner8f2f5982003-11-05 01:06:05 +0000803 }
804
Chris Lattnera9be4492005-04-07 16:15:25 +0000805 if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) {
806 if (Op1I->getOpcode() == Instruction::Add &&
807 !Op0->getType()->isFloatingPoint()) {
Chris Lattnerc7f3c1a2005-04-07 16:28:01 +0000808 if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y
Chris Lattnera9be4492005-04-07 16:15:25 +0000809 return BinaryOperator::createNeg(Op1I->getOperand(1), I.getName());
Chris Lattnerc7f3c1a2005-04-07 16:28:01 +0000810 else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y
Chris Lattnera9be4492005-04-07 16:15:25 +0000811 return BinaryOperator::createNeg(Op1I->getOperand(0), I.getName());
Chris Lattnerc7f3c1a2005-04-07 16:28:01 +0000812 else if (ConstantInt *CI1 = dyn_cast<ConstantInt>(I.getOperand(0))) {
813 if (ConstantInt *CI2 = dyn_cast<ConstantInt>(Op1I->getOperand(1)))
814 // C1-(X+C2) --> (C1-C2)-X
815 return BinaryOperator::createSub(ConstantExpr::getSub(CI1, CI2),
816 Op1I->getOperand(0));
817 }
Chris Lattnera9be4492005-04-07 16:15:25 +0000818 }
819
Chris Lattnerf95d9b92003-10-15 16:48:29 +0000820 if (Op1I->hasOneUse()) {
Chris Lattner3082c5a2003-02-18 19:28:33 +0000821 // Replace (x - (y - z)) with (x + (z - y)) if the (y - z) subexpression
822 // is not used by anyone else...
823 //
Chris Lattnerc2f0aa52004-02-02 20:09:56 +0000824 if (Op1I->getOpcode() == Instruction::Sub &&
825 !Op1I->getType()->isFloatingPoint()) {
Chris Lattner3082c5a2003-02-18 19:28:33 +0000826 // Swap the two operands of the subexpr...
827 Value *IIOp0 = Op1I->getOperand(0), *IIOp1 = Op1I->getOperand(1);
828 Op1I->setOperand(0, IIOp1);
829 Op1I->setOperand(1, IIOp0);
Misha Brukmanb1c93172005-04-21 23:48:37 +0000830
Chris Lattner3082c5a2003-02-18 19:28:33 +0000831 // Create the new top level add instruction...
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000832 return BinaryOperator::createAdd(Op0, Op1);
Chris Lattner3082c5a2003-02-18 19:28:33 +0000833 }
834
835 // Replace (A - (A & B)) with (A & ~B) if this is the only use of (A&B)...
836 //
837 if (Op1I->getOpcode() == Instruction::And &&
838 (Op1I->getOperand(0) == Op0 || Op1I->getOperand(1) == Op0)) {
839 Value *OtherOp = Op1I->getOperand(Op1I->getOperand(0) == Op0);
840
Chris Lattner396dbfe2004-06-09 05:08:07 +0000841 Value *NewNot =
842 InsertNewInstBefore(BinaryOperator::createNot(OtherOp, "B.not"), I);
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000843 return BinaryOperator::createAnd(Op0, NewNot);
Chris Lattner3082c5a2003-02-18 19:28:33 +0000844 }
Chris Lattner57c8d992003-02-18 19:57:07 +0000845
Chris Lattner0aee4b72004-10-06 15:08:25 +0000846 // -(X sdiv C) -> (X sdiv -C)
847 if (Op1I->getOpcode() == Instruction::Div)
848 if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(Op0))
Chris Lattnera9be4492005-04-07 16:15:25 +0000849 if (CSI->isNullValue())
Chris Lattner0aee4b72004-10-06 15:08:25 +0000850 if (Constant *DivRHS = dyn_cast<Constant>(Op1I->getOperand(1)))
Misha Brukmanb1c93172005-04-21 23:48:37 +0000851 return BinaryOperator::createDiv(Op1I->getOperand(0),
Chris Lattner0aee4b72004-10-06 15:08:25 +0000852 ConstantExpr::getNeg(DivRHS));
853
Chris Lattner57c8d992003-02-18 19:57:07 +0000854 // X - X*C --> X * (1-C)
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000855 ConstantInt *C2;
856 if (dyn_castFoldableMul(Op1I, C2) == Op0) {
Misha Brukmanb1c93172005-04-21 23:48:37 +0000857 Constant *CP1 =
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000858 ConstantExpr::getSub(ConstantInt::get(I.getType(), 1), C2);
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000859 return BinaryOperator::createMul(Op0, CP1);
Chris Lattner57c8d992003-02-18 19:57:07 +0000860 }
Chris Lattnerad3c4952002-05-09 01:29:19 +0000861 }
Chris Lattnera9be4492005-04-07 16:15:25 +0000862 }
Chris Lattner3082c5a2003-02-18 19:28:33 +0000863
Chris Lattner47060462005-04-07 17:14:51 +0000864 if (!Op0->getType()->isFloatingPoint())
865 if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0))
866 if (Op0I->getOpcode() == Instruction::Add) {
Chris Lattner411336f2005-01-19 21:50:18 +0000867 if (Op0I->getOperand(0) == Op1) // (Y+X)-Y == X
868 return ReplaceInstUsesWith(I, Op0I->getOperand(1));
869 else if (Op0I->getOperand(1) == Op1) // (X+Y)-Y == X
870 return ReplaceInstUsesWith(I, Op0I->getOperand(0));
Chris Lattner47060462005-04-07 17:14:51 +0000871 } else if (Op0I->getOpcode() == Instruction::Sub) {
872 if (Op0I->getOperand(0) == Op1) // (X-Y)-X == -Y
873 return BinaryOperator::createNeg(Op0I->getOperand(1), I.getName());
Chris Lattner411336f2005-01-19 21:50:18 +0000874 }
Misha Brukmanb1c93172005-04-21 23:48:37 +0000875
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000876 ConstantInt *C1;
877 if (Value *X = dyn_castFoldableMul(Op0, C1)) {
878 if (X == Op1) { // X*C - X --> X * (C-1)
879 Constant *CP1 = ConstantExpr::getSub(C1, ConstantInt::get(I.getType(),1));
880 return BinaryOperator::createMul(Op1, CP1);
881 }
Chris Lattner57c8d992003-02-18 19:57:07 +0000882
Chris Lattner8c3e7b92004-11-13 19:50:12 +0000883 ConstantInt *C2; // X*C1 - X*C2 -> X * (C1-C2)
884 if (X == dyn_castFoldableMul(Op1, C2))
885 return BinaryOperator::createMul(Op1, ConstantExpr::getSub(C1, C2));
886 }
Chris Lattnerf4cdbf32002-05-06 16:14:14 +0000887 return 0;
Chris Lattner260ab202002-04-18 17:39:14 +0000888}
889
Chris Lattnere79e8542004-02-23 06:38:22 +0000890/// isSignBitCheck - Given an exploded setcc instruction, return true if it is
891/// really just returns true if the most significant (sign) bit is set.
892static bool isSignBitCheck(unsigned Opcode, Value *LHS, ConstantInt *RHS) {
893 if (RHS->getType()->isSigned()) {
894 // True if source is LHS < 0 or LHS <= -1
895 return Opcode == Instruction::SetLT && RHS->isNullValue() ||
896 Opcode == Instruction::SetLE && RHS->isAllOnesValue();
897 } else {
898 ConstantUInt *RHSC = cast<ConstantUInt>(RHS);
899 // True if source is LHS > 127 or LHS >= 128, where the constants depend on
900 // the size of the integer type.
901 if (Opcode == Instruction::SetGE)
Chris Lattnerd1f46d32005-04-24 06:59:08 +0000902 return RHSC->getValue() ==
903 1ULL << (RHS->getType()->getPrimitiveSizeInBits()-1);
Chris Lattnere79e8542004-02-23 06:38:22 +0000904 if (Opcode == Instruction::SetGT)
905 return RHSC->getValue() ==
Chris Lattnerd1f46d32005-04-24 06:59:08 +0000906 (1ULL << (RHS->getType()->getPrimitiveSizeInBits()-1))-1;
Chris Lattnere79e8542004-02-23 06:38:22 +0000907 }
908 return false;
909}
910
Chris Lattner113f4f42002-06-25 16:13:24 +0000911Instruction *InstCombiner::visitMul(BinaryOperator &I) {
Chris Lattnerdcf240a2003-03-10 21:43:22 +0000912 bool Changed = SimplifyCommutative(I);
Chris Lattner3082c5a2003-02-18 19:28:33 +0000913 Value *Op0 = I.getOperand(0);
Chris Lattner260ab202002-04-18 17:39:14 +0000914
Chris Lattner81a7a232004-10-16 18:11:37 +0000915 if (isa<UndefValue>(I.getOperand(1))) // undef * X -> 0
916 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
917
Chris Lattnere6794492002-08-12 21:17:25 +0000918 // Simplify mul instructions with a constant RHS...
Chris Lattner3082c5a2003-02-18 19:28:33 +0000919 if (Constant *Op1 = dyn_cast<Constant>(I.getOperand(1))) {
920 if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
Chris Lattnerede3fe02003-08-13 04:18:28 +0000921
922 // ((X << C1)*C2) == (X * (C2 << C1))
923 if (ShiftInst *SI = dyn_cast<ShiftInst>(Op0))
924 if (SI->getOpcode() == Instruction::Shl)
925 if (Constant *ShOp = dyn_cast<Constant>(SI->getOperand(1)))
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000926 return BinaryOperator::createMul(SI->getOperand(0),
927 ConstantExpr::getShl(CI, ShOp));
Misha Brukmanb1c93172005-04-21 23:48:37 +0000928
Chris Lattnercce81be2003-09-11 22:24:54 +0000929 if (CI->isNullValue())
930 return ReplaceInstUsesWith(I, Op1); // X * 0 == 0
931 if (CI->equalsInt(1)) // X * 1 == X
932 return ReplaceInstUsesWith(I, Op0);
933 if (CI->isAllOnesValue()) // X * -1 == 0 - X
Chris Lattner35236d82003-06-25 17:09:20 +0000934 return BinaryOperator::createNeg(Op0, I.getName());
Chris Lattner31ba1292002-04-29 22:24:47 +0000935
Chris Lattnercce81be2003-09-11 22:24:54 +0000936 int64_t Val = (int64_t)cast<ConstantInt>(CI)->getRawValue();
Chris Lattner3082c5a2003-02-18 19:28:33 +0000937 if (uint64_t C = Log2(Val)) // Replace X*(2^C) with X << C
938 return new ShiftInst(Instruction::Shl, Op0,
939 ConstantUInt::get(Type::UByteTy, C));
Robert Bocchino7b5b86c2004-07-27 21:02:21 +0000940 } else if (ConstantFP *Op1F = dyn_cast<ConstantFP>(Op1)) {
Chris Lattner3082c5a2003-02-18 19:28:33 +0000941 if (Op1F->isNullValue())
942 return ReplaceInstUsesWith(I, Op1);
Chris Lattner31ba1292002-04-29 22:24:47 +0000943
Chris Lattner3082c5a2003-02-18 19:28:33 +0000944 // "In IEEE floating point, x*1 is not equivalent to x for nans. However,
945 // ANSI says we can drop signals, so we can do this anyway." (from GCC)
946 if (Op1F->getValue() == 1.0)
947 return ReplaceInstUsesWith(I, Op0); // Eliminate 'mul double %X, 1.0'
948 }
Chris Lattner183b3362004-04-09 19:05:30 +0000949
950 // Try to fold constant mul into select arguments.
951 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
Chris Lattner86102b82005-01-01 16:22:27 +0000952 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattner183b3362004-04-09 19:05:30 +0000953 return R;
Chris Lattner6a4adcd2004-09-29 05:07:12 +0000954
955 if (isa<PHINode>(Op0))
956 if (Instruction *NV = FoldOpIntoPhi(I))
957 return NV;
Chris Lattner260ab202002-04-18 17:39:14 +0000958 }
959
Chris Lattner934a64cf2003-03-10 23:23:04 +0000960 if (Value *Op0v = dyn_castNegVal(Op0)) // -X * -Y = X*Y
961 if (Value *Op1v = dyn_castNegVal(I.getOperand(1)))
Chris Lattnerdf20a4d2004-06-10 02:07:29 +0000962 return BinaryOperator::createMul(Op0v, Op1v);
Chris Lattner934a64cf2003-03-10 23:23:04 +0000963
Chris Lattner2635b522004-02-23 05:39:21 +0000964 // If one of the operands of the multiply is a cast from a boolean value, then
965 // we know the bool is either zero or one, so this is a 'masking' multiply.
966 // See if we can simplify things based on how the boolean was originally
967 // formed.
968 CastInst *BoolCast = 0;
969 if (CastInst *CI = dyn_cast<CastInst>(I.getOperand(0)))
970 if (CI->getOperand(0)->getType() == Type::BoolTy)
971 BoolCast = CI;
972 if (!BoolCast)
973 if (CastInst *CI = dyn_cast<CastInst>(I.getOperand(1)))
974 if (CI->getOperand(0)->getType() == Type::BoolTy)
975 BoolCast = CI;
976 if (BoolCast) {
977 if (SetCondInst *SCI = dyn_cast<SetCondInst>(BoolCast->getOperand(0))) {
978 Value *SCIOp0 = SCI->getOperand(0), *SCIOp1 = SCI->getOperand(1);
979 const Type *SCOpTy = SCIOp0->getType();
980
Chris Lattnere79e8542004-02-23 06:38:22 +0000981 // If the setcc is true iff the sign bit of X is set, then convert this
982 // multiply into a shift/and combination.
983 if (isa<ConstantInt>(SCIOp1) &&
984 isSignBitCheck(SCI->getOpcode(), SCIOp0, cast<ConstantInt>(SCIOp1))) {
Chris Lattner2635b522004-02-23 05:39:21 +0000985 // Shift the X value right to turn it into "all signbits".
986 Constant *Amt = ConstantUInt::get(Type::UByteTy,
Chris Lattnerd1f46d32005-04-24 06:59:08 +0000987 SCOpTy->getPrimitiveSizeInBits()-1);
Chris Lattnere79e8542004-02-23 06:38:22 +0000988 if (SCIOp0->getType()->isUnsigned()) {
Chris Lattner97bfcea2004-06-17 18:16:02 +0000989 const Type *NewTy = SCIOp0->getType()->getSignedVersion();
Chris Lattnere79e8542004-02-23 06:38:22 +0000990 SCIOp0 = InsertNewInstBefore(new CastInst(SCIOp0, NewTy,
991 SCIOp0->getName()), I);
992 }
993
994 Value *V =
995 InsertNewInstBefore(new ShiftInst(Instruction::Shr, SCIOp0, Amt,
996 BoolCast->getOperand(0)->getName()+
997 ".mask"), I);
Chris Lattner2635b522004-02-23 05:39:21 +0000998
999 // If the multiply type is not the same as the source type, sign extend
1000 // or truncate to the multiply type.
1001 if (I.getType() != V->getType())
Chris Lattnere79e8542004-02-23 06:38:22 +00001002 V = InsertNewInstBefore(new CastInst(V, I.getType(), V->getName()),I);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001003
Chris Lattner2635b522004-02-23 05:39:21 +00001004 Value *OtherOp = Op0 == BoolCast ? I.getOperand(1) : Op0;
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00001005 return BinaryOperator::createAnd(V, OtherOp);
Chris Lattner2635b522004-02-23 05:39:21 +00001006 }
1007 }
1008 }
1009
Chris Lattner113f4f42002-06-25 16:13:24 +00001010 return Changed ? &I : 0;
Chris Lattner260ab202002-04-18 17:39:14 +00001011}
1012
Chris Lattner113f4f42002-06-25 16:13:24 +00001013Instruction *InstCombiner::visitDiv(BinaryOperator &I) {
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001014 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
Chris Lattner81a7a232004-10-16 18:11:37 +00001015
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001016 if (isa<UndefValue>(Op0)) // undef / X -> 0
1017 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
1018 if (isa<UndefValue>(Op1))
1019 return ReplaceInstUsesWith(I, Op1); // X / undef -> undef
1020
1021 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
Chris Lattnere20c3342004-04-26 14:01:59 +00001022 // div X, 1 == X
Chris Lattnere6794492002-08-12 21:17:25 +00001023 if (RHS->equalsInt(1))
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001024 return ReplaceInstUsesWith(I, Op0);
Chris Lattner3082c5a2003-02-18 19:28:33 +00001025
Chris Lattnere20c3342004-04-26 14:01:59 +00001026 // div X, -1 == -X
1027 if (RHS->isAllOnesValue())
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001028 return BinaryOperator::createNeg(Op0);
Chris Lattnere20c3342004-04-26 14:01:59 +00001029
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001030 if (Instruction *LHS = dyn_cast<Instruction>(Op0))
Chris Lattner272d5ca2004-09-28 18:22:15 +00001031 if (LHS->getOpcode() == Instruction::Div)
1032 if (ConstantInt *LHSRHS = dyn_cast<ConstantInt>(LHS->getOperand(1))) {
Chris Lattner272d5ca2004-09-28 18:22:15 +00001033 // (X / C1) / C2 -> X / (C1*C2)
1034 return BinaryOperator::createDiv(LHS->getOperand(0),
1035 ConstantExpr::getMul(RHS, LHSRHS));
1036 }
1037
Chris Lattner3082c5a2003-02-18 19:28:33 +00001038 // Check to see if this is an unsigned division with an exact power of 2,
1039 // if so, convert to a right shift.
1040 if (ConstantUInt *C = dyn_cast<ConstantUInt>(RHS))
1041 if (uint64_t Val = C->getValue()) // Don't break X / 0
1042 if (uint64_t C = Log2(Val))
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001043 return new ShiftInst(Instruction::Shr, Op0,
Chris Lattner3082c5a2003-02-18 19:28:33 +00001044 ConstantUInt::get(Type::UByteTy, C));
Chris Lattner6a4adcd2004-09-29 05:07:12 +00001045
Chris Lattner4ad08352004-10-09 02:50:40 +00001046 // -X/C -> X/-C
1047 if (RHS->getType()->isSigned())
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001048 if (Value *LHSNeg = dyn_castNegVal(Op0))
Chris Lattner4ad08352004-10-09 02:50:40 +00001049 return BinaryOperator::createDiv(LHSNeg, ConstantExpr::getNeg(RHS));
1050
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001051 if (!RHS->isNullValue()) {
1052 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
Chris Lattner86102b82005-01-01 16:22:27 +00001053 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001054 return R;
1055 if (isa<PHINode>(Op0))
1056 if (Instruction *NV = FoldOpIntoPhi(I))
1057 return NV;
1058 }
Chris Lattner3082c5a2003-02-18 19:28:33 +00001059 }
1060
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001061 // If this is 'udiv X, (Cond ? C1, C2)' where C1&C2 are powers of two,
1062 // transform this into: '(Cond ? (udiv X, C1) : (udiv X, C2))'.
1063 if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
1064 if (ConstantUInt *STO = dyn_cast<ConstantUInt>(SI->getOperand(1)))
1065 if (ConstantUInt *SFO = dyn_cast<ConstantUInt>(SI->getOperand(2))) {
1066 if (STO->getValue() == 0) { // Couldn't be this argument.
1067 I.setOperand(1, SFO);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001068 return &I;
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001069 } else if (SFO->getValue() == 0) {
Chris Lattner89dc4f12005-06-16 04:55:52 +00001070 I.setOperand(1, STO);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001071 return &I;
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001072 }
1073
Chris Lattner42362612005-04-08 04:03:26 +00001074 uint64_t TVA = STO->getValue(), FVA = SFO->getValue();
1075 unsigned TSA = 0, FSA = 0;
1076 if ((TVA == 1 || (TSA = Log2(TVA))) && // Log2 fails for 0 & 1.
1077 (FVA == 1 || (FSA = Log2(FVA)))) {
1078 Constant *TC = ConstantUInt::get(Type::UByteTy, TSA);
1079 Instruction *TSI = new ShiftInst(Instruction::Shr, Op0,
1080 TC, SI->getName()+".t");
1081 TSI = InsertNewInstBefore(TSI, I);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001082
Chris Lattner42362612005-04-08 04:03:26 +00001083 Constant *FC = ConstantUInt::get(Type::UByteTy, FSA);
1084 Instruction *FSI = new ShiftInst(Instruction::Shr, Op0,
1085 FC, SI->getName()+".f");
1086 FSI = InsertNewInstBefore(FSI, I);
1087 return new SelectInst(SI->getOperand(0), TSI, FSI);
1088 }
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001089 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00001090
Chris Lattner3082c5a2003-02-18 19:28:33 +00001091 // 0 / X == 0, we don't need to preserve faults!
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001092 if (ConstantInt *LHS = dyn_cast<ConstantInt>(Op0))
Chris Lattner3082c5a2003-02-18 19:28:33 +00001093 if (LHS->equalsInt(0))
1094 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
1095
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001096 return 0;
1097}
1098
1099
Chris Lattner113f4f42002-06-25 16:13:24 +00001100Instruction *InstCombiner::visitRem(BinaryOperator &I) {
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001101 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
Chris Lattner7fd5f072004-07-06 07:01:22 +00001102 if (I.getType()->isSigned())
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001103 if (Value *RHSNeg = dyn_castNegVal(Op1))
Chris Lattner98c6bdf2004-07-06 07:11:42 +00001104 if (!isa<ConstantSInt>(RHSNeg) ||
Chris Lattner8e726062004-08-09 21:05:48 +00001105 cast<ConstantSInt>(RHSNeg)->getValue() > 0) {
Chris Lattner7fd5f072004-07-06 07:01:22 +00001106 // X % -Y -> X % Y
1107 AddUsesToWorkList(I);
1108 I.setOperand(1, RHSNeg);
1109 return &I;
1110 }
1111
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001112 if (isa<UndefValue>(Op0)) // undef % X -> 0
Chris Lattner81a7a232004-10-16 18:11:37 +00001113 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001114 if (isa<UndefValue>(Op1))
1115 return ReplaceInstUsesWith(I, Op1); // X % undef -> undef
Chris Lattner81a7a232004-10-16 18:11:37 +00001116
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001117 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
Chris Lattner3082c5a2003-02-18 19:28:33 +00001118 if (RHS->equalsInt(1)) // X % 1 == 0
1119 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
1120
1121 // Check to see if this is an unsigned remainder with an exact power of 2,
1122 // if so, convert to a bitwise and.
1123 if (ConstantUInt *C = dyn_cast<ConstantUInt>(RHS))
1124 if (uint64_t Val = C->getValue()) // Don't break X % 0 (divide by zero)
Chris Lattnerd9e58132004-05-07 15:35:56 +00001125 if (!(Val & (Val-1))) // Power of 2
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001126 return BinaryOperator::createAnd(Op0,
1127 ConstantUInt::get(I.getType(), Val-1));
1128
1129 if (!RHS->isNullValue()) {
1130 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
Chris Lattner86102b82005-01-01 16:22:27 +00001131 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001132 return R;
1133 if (isa<PHINode>(Op0))
1134 if (Instruction *NV = FoldOpIntoPhi(I))
1135 return NV;
1136 }
Chris Lattner3082c5a2003-02-18 19:28:33 +00001137 }
1138
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001139 // If this is 'urem X, (Cond ? C1, C2)' where C1&C2 are powers of two,
1140 // transform this into: '(Cond ? (urem X, C1) : (urem X, C2))'.
1141 if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
1142 if (ConstantUInt *STO = dyn_cast<ConstantUInt>(SI->getOperand(1)))
1143 if (ConstantUInt *SFO = dyn_cast<ConstantUInt>(SI->getOperand(2))) {
1144 if (STO->getValue() == 0) { // Couldn't be this argument.
1145 I.setOperand(1, SFO);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001146 return &I;
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001147 } else if (SFO->getValue() == 0) {
1148 I.setOperand(1, STO);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001149 return &I;
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001150 }
1151
1152 if (!(STO->getValue() & (STO->getValue()-1)) &&
1153 !(SFO->getValue() & (SFO->getValue()-1))) {
1154 Value *TrueAnd = InsertNewInstBefore(BinaryOperator::createAnd(Op0,
1155 SubOne(STO), SI->getName()+".t"), I);
1156 Value *FalseAnd = InsertNewInstBefore(BinaryOperator::createAnd(Op0,
1157 SubOne(SFO), SI->getName()+".f"), I);
1158 return new SelectInst(SI->getOperand(0), TrueAnd, FalseAnd);
1159 }
1160 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00001161
Chris Lattner3082c5a2003-02-18 19:28:33 +00001162 // 0 % X == 0, we don't need to preserve faults!
Chris Lattnerbf5b7cf2004-12-12 21:48:58 +00001163 if (ConstantInt *LHS = dyn_cast<ConstantInt>(Op0))
Chris Lattner3082c5a2003-02-18 19:28:33 +00001164 if (LHS->equalsInt(0))
Chris Lattnere6794492002-08-12 21:17:25 +00001165 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
1166
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001167 return 0;
1168}
1169
Chris Lattner6d14f2a2002-08-09 23:47:40 +00001170// isMaxValueMinusOne - return true if this is Max-1
Chris Lattnere6794492002-08-12 21:17:25 +00001171static bool isMaxValueMinusOne(const ConstantInt *C) {
Chris Lattner6d14f2a2002-08-09 23:47:40 +00001172 if (const ConstantUInt *CU = dyn_cast<ConstantUInt>(C)) {
1173 // Calculate -1 casted to the right type...
Chris Lattnerd1f46d32005-04-24 06:59:08 +00001174 unsigned TypeBits = C->getType()->getPrimitiveSizeInBits();
Chris Lattner6d14f2a2002-08-09 23:47:40 +00001175 uint64_t Val = ~0ULL; // All ones
1176 Val >>= 64-TypeBits; // Shift out unwanted 1 bits...
1177 return CU->getValue() == Val-1;
1178 }
1179
1180 const ConstantSInt *CS = cast<ConstantSInt>(C);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001181
Chris Lattner6d14f2a2002-08-09 23:47:40 +00001182 // Calculate 0111111111..11111
Chris Lattnerd1f46d32005-04-24 06:59:08 +00001183 unsigned TypeBits = C->getType()->getPrimitiveSizeInBits();
Chris Lattner6d14f2a2002-08-09 23:47:40 +00001184 int64_t Val = INT64_MAX; // All ones
1185 Val >>= 64-TypeBits; // Shift out unwanted 1 bits...
1186 return CS->getValue() == Val-1;
1187}
1188
1189// isMinValuePlusOne - return true if this is Min+1
Chris Lattnere6794492002-08-12 21:17:25 +00001190static bool isMinValuePlusOne(const ConstantInt *C) {
Chris Lattner6d14f2a2002-08-09 23:47:40 +00001191 if (const ConstantUInt *CU = dyn_cast<ConstantUInt>(C))
1192 return CU->getValue() == 1;
1193
1194 const ConstantSInt *CS = cast<ConstantSInt>(C);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001195
1196 // Calculate 1111111111000000000000
Chris Lattnerd1f46d32005-04-24 06:59:08 +00001197 unsigned TypeBits = C->getType()->getPrimitiveSizeInBits();
Chris Lattner6d14f2a2002-08-09 23:47:40 +00001198 int64_t Val = -1; // All ones
1199 Val <<= TypeBits-1; // Shift over to the right spot
1200 return CS->getValue() == Val+1;
1201}
1202
Chris Lattner35167c32004-06-09 07:59:58 +00001203// isOneBitSet - Return true if there is exactly one bit set in the specified
1204// constant.
1205static bool isOneBitSet(const ConstantInt *CI) {
1206 uint64_t V = CI->getRawValue();
1207 return V && (V & (V-1)) == 0;
1208}
1209
Chris Lattner8fc5af42004-09-23 21:46:38 +00001210#if 0 // Currently unused
1211// isLowOnes - Return true if the constant is of the form 0+1+.
1212static bool isLowOnes(const ConstantInt *CI) {
1213 uint64_t V = CI->getRawValue();
1214
1215 // There won't be bits set in parts that the type doesn't contain.
1216 V &= ConstantInt::getAllOnesValue(CI->getType())->getRawValue();
1217
1218 uint64_t U = V+1; // If it is low ones, this should be a power of two.
1219 return U && V && (U & V) == 0;
1220}
1221#endif
1222
1223// isHighOnes - Return true if the constant is of the form 1+0+.
1224// This is the same as lowones(~X).
1225static bool isHighOnes(const ConstantInt *CI) {
1226 uint64_t V = ~CI->getRawValue();
1227
1228 // There won't be bits set in parts that the type doesn't contain.
1229 V &= ConstantInt::getAllOnesValue(CI->getType())->getRawValue();
1230
1231 uint64_t U = V+1; // If it is low ones, this should be a power of two.
1232 return U && V && (U & V) == 0;
1233}
1234
1235
Chris Lattner3ac7c262003-08-13 20:16:26 +00001236/// getSetCondCode - Encode a setcc opcode into a three bit mask. These bits
1237/// are carefully arranged to allow folding of expressions such as:
1238///
1239/// (A < B) | (A > B) --> (A != B)
1240///
1241/// Bit value '4' represents that the comparison is true if A > B, bit value '2'
1242/// represents that the comparison is true if A == B, and bit value '1' is true
1243/// if A < B.
1244///
1245static unsigned getSetCondCode(const SetCondInst *SCI) {
1246 switch (SCI->getOpcode()) {
1247 // False -> 0
1248 case Instruction::SetGT: return 1;
1249 case Instruction::SetEQ: return 2;
1250 case Instruction::SetGE: return 3;
1251 case Instruction::SetLT: return 4;
1252 case Instruction::SetNE: return 5;
1253 case Instruction::SetLE: return 6;
1254 // True -> 7
1255 default:
1256 assert(0 && "Invalid SetCC opcode!");
1257 return 0;
1258 }
1259}
1260
1261/// getSetCCValue - This is the complement of getSetCondCode, which turns an
1262/// opcode and two operands into either a constant true or false, or a brand new
1263/// SetCC instruction.
1264static Value *getSetCCValue(unsigned Opcode, Value *LHS, Value *RHS) {
1265 switch (Opcode) {
1266 case 0: return ConstantBool::False;
1267 case 1: return new SetCondInst(Instruction::SetGT, LHS, RHS);
1268 case 2: return new SetCondInst(Instruction::SetEQ, LHS, RHS);
1269 case 3: return new SetCondInst(Instruction::SetGE, LHS, RHS);
1270 case 4: return new SetCondInst(Instruction::SetLT, LHS, RHS);
1271 case 5: return new SetCondInst(Instruction::SetNE, LHS, RHS);
1272 case 6: return new SetCondInst(Instruction::SetLE, LHS, RHS);
1273 case 7: return ConstantBool::True;
1274 default: assert(0 && "Illegal SetCCCode!"); return 0;
1275 }
1276}
1277
1278// FoldSetCCLogical - Implements (setcc1 A, B) & (setcc2 A, B) --> (setcc3 A, B)
1279struct FoldSetCCLogical {
1280 InstCombiner &IC;
1281 Value *LHS, *RHS;
1282 FoldSetCCLogical(InstCombiner &ic, SetCondInst *SCI)
1283 : IC(ic), LHS(SCI->getOperand(0)), RHS(SCI->getOperand(1)) {}
1284 bool shouldApply(Value *V) const {
1285 if (SetCondInst *SCI = dyn_cast<SetCondInst>(V))
1286 return (SCI->getOperand(0) == LHS && SCI->getOperand(1) == RHS ||
1287 SCI->getOperand(0) == RHS && SCI->getOperand(1) == LHS);
1288 return false;
1289 }
1290 Instruction *apply(BinaryOperator &Log) const {
1291 SetCondInst *SCI = cast<SetCondInst>(Log.getOperand(0));
1292 if (SCI->getOperand(0) != LHS) {
1293 assert(SCI->getOperand(1) == LHS);
1294 SCI->swapOperands(); // Swap the LHS and RHS of the SetCC
1295 }
1296
1297 unsigned LHSCode = getSetCondCode(SCI);
1298 unsigned RHSCode = getSetCondCode(cast<SetCondInst>(Log.getOperand(1)));
1299 unsigned Code;
1300 switch (Log.getOpcode()) {
1301 case Instruction::And: Code = LHSCode & RHSCode; break;
1302 case Instruction::Or: Code = LHSCode | RHSCode; break;
1303 case Instruction::Xor: Code = LHSCode ^ RHSCode; break;
Chris Lattner2caaaba2003-09-22 20:33:34 +00001304 default: assert(0 && "Illegal logical opcode!"); return 0;
Chris Lattner3ac7c262003-08-13 20:16:26 +00001305 }
1306
1307 Value *RV = getSetCCValue(Code, LHS, RHS);
1308 if (Instruction *I = dyn_cast<Instruction>(RV))
1309 return I;
1310 // Otherwise, it's a constant boolean value...
1311 return IC.ReplaceInstUsesWith(Log, RV);
1312 }
1313};
1314
1315
Chris Lattner86102b82005-01-01 16:22:27 +00001316/// MaskedValueIsZero - Return true if 'V & Mask' is known to be zero. We use
1317/// this predicate to simplify operations downstream. V and Mask are known to
1318/// be the same type.
1319static bool MaskedValueIsZero(Value *V, ConstantIntegral *Mask) {
1320 if (isa<UndefValue>(V) || Mask->isNullValue())
1321 return true;
1322 if (ConstantIntegral *CI = dyn_cast<ConstantIntegral>(V))
1323 return ConstantExpr::getAnd(CI, Mask)->isNullValue();
Misha Brukmanb1c93172005-04-21 23:48:37 +00001324
Chris Lattner86102b82005-01-01 16:22:27 +00001325 if (Instruction *I = dyn_cast<Instruction>(V)) {
1326 switch (I->getOpcode()) {
1327 case Instruction::And:
1328 // (X & C1) & C2 == 0 iff C1 & C2 == 0.
1329 if (ConstantIntegral *CI = dyn_cast<ConstantIntegral>(I->getOperand(1)))
1330 if (ConstantExpr::getAnd(CI, Mask)->isNullValue())
1331 return true;
1332 break;
Chris Lattner9e2c7fa2005-01-23 20:26:55 +00001333 case Instruction::Or:
1334 // If the LHS and the RHS are MaskedValueIsZero, the result is also zero.
Misha Brukmanb1c93172005-04-21 23:48:37 +00001335 return MaskedValueIsZero(I->getOperand(1), Mask) &&
Chris Lattner9e2c7fa2005-01-23 20:26:55 +00001336 MaskedValueIsZero(I->getOperand(0), Mask);
1337 case Instruction::Select:
1338 // If the T and F values are MaskedValueIsZero, the result is also zero.
Misha Brukmanb1c93172005-04-21 23:48:37 +00001339 return MaskedValueIsZero(I->getOperand(2), Mask) &&
Chris Lattner9e2c7fa2005-01-23 20:26:55 +00001340 MaskedValueIsZero(I->getOperand(1), Mask);
Chris Lattner86102b82005-01-01 16:22:27 +00001341 case Instruction::Cast: {
1342 const Type *SrcTy = I->getOperand(0)->getType();
Chris Lattner4c2d3782005-05-06 01:53:19 +00001343 if (SrcTy == Type::BoolTy)
1344 return (Mask->getRawValue() & 1) == 0;
1345
1346 if (SrcTy->isInteger()) {
Chris Lattner86102b82005-01-01 16:22:27 +00001347 // (cast <ty> X to int) & C2 == 0 iff <ty> could not have contained C2.
1348 if (SrcTy->isUnsigned() && // Only handle zero ext.
1349 ConstantExpr::getCast(Mask, SrcTy)->isNullValue())
1350 return true;
1351
1352 // If this is a noop cast, recurse.
Chris Lattner4c2d3782005-05-06 01:53:19 +00001353 if ((SrcTy->isSigned() && SrcTy->getUnsignedVersion() == I->getType())||
1354 SrcTy->getSignedVersion() == I->getType()) {
1355 Constant *NewMask =
1356 ConstantExpr::getCast(Mask, I->getOperand(0)->getType());
1357 return MaskedValueIsZero(I->getOperand(0),
1358 cast<ConstantIntegral>(NewMask));
1359 }
Chris Lattner86102b82005-01-01 16:22:27 +00001360 }
1361 break;
1362 }
1363 case Instruction::Shl:
Chris Lattneref298a32005-05-06 04:53:20 +00001364 // (shl X, C1) & C2 == 0 iff (X & C2 >>u C1) == 0
1365 if (ConstantUInt *SA = dyn_cast<ConstantUInt>(I->getOperand(1)))
1366 return MaskedValueIsZero(I->getOperand(0),
1367 cast<ConstantIntegral>(ConstantExpr::getUShr(Mask, SA)));
Chris Lattner86102b82005-01-01 16:22:27 +00001368 break;
1369 case Instruction::Shr:
1370 // (ushr X, C1) & C2 == 0 iff (-1 >> C1) & C2 == 0
1371 if (ConstantUInt *SA = dyn_cast<ConstantUInt>(I->getOperand(1)))
1372 if (I->getType()->isUnsigned()) {
1373 Constant *C1 = ConstantIntegral::getAllOnesValue(I->getType());
1374 C1 = ConstantExpr::getShr(C1, SA);
1375 C1 = ConstantExpr::getAnd(C1, Mask);
1376 if (C1->isNullValue())
1377 return true;
1378 }
1379 break;
1380 }
1381 }
1382
1383 return false;
1384}
1385
Chris Lattnerba1cb382003-09-19 17:17:26 +00001386// OptAndOp - This handles expressions of the form ((val OP C1) & C2). Where
1387// the Op parameter is 'OP', OpRHS is 'C1', and AndRHS is 'C2'. Op is
1388// guaranteed to be either a shift instruction or a binary operator.
1389Instruction *InstCombiner::OptAndOp(Instruction *Op,
1390 ConstantIntegral *OpRHS,
1391 ConstantIntegral *AndRHS,
1392 BinaryOperator &TheAnd) {
1393 Value *X = Op->getOperand(0);
Chris Lattnerfcf21a72004-01-12 19:47:05 +00001394 Constant *Together = 0;
1395 if (!isa<ShiftInst>(Op))
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00001396 Together = ConstantExpr::getAnd(AndRHS, OpRHS);
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00001397
Chris Lattnerba1cb382003-09-19 17:17:26 +00001398 switch (Op->getOpcode()) {
1399 case Instruction::Xor:
Chris Lattner86102b82005-01-01 16:22:27 +00001400 if (Op->hasOneUse()) {
Chris Lattnerba1cb382003-09-19 17:17:26 +00001401 // (X ^ C1) & C2 --> (X & C2) ^ (C1&C2)
1402 std::string OpName = Op->getName(); Op->setName("");
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00001403 Instruction *And = BinaryOperator::createAnd(X, AndRHS, OpName);
Chris Lattnerba1cb382003-09-19 17:17:26 +00001404 InsertNewInstBefore(And, TheAnd);
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00001405 return BinaryOperator::createXor(And, Together);
Chris Lattnerba1cb382003-09-19 17:17:26 +00001406 }
1407 break;
1408 case Instruction::Or:
Chris Lattner86102b82005-01-01 16:22:27 +00001409 if (Together == AndRHS) // (X | C) & C --> C
1410 return ReplaceInstUsesWith(TheAnd, AndRHS);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001411
Chris Lattner86102b82005-01-01 16:22:27 +00001412 if (Op->hasOneUse() && Together != OpRHS) {
1413 // (X | C1) & C2 --> (X | (C1&C2)) & C2
1414 std::string Op0Name = Op->getName(); Op->setName("");
1415 Instruction *Or = BinaryOperator::createOr(X, Together, Op0Name);
1416 InsertNewInstBefore(Or, TheAnd);
1417 return BinaryOperator::createAnd(Or, AndRHS);
Chris Lattnerba1cb382003-09-19 17:17:26 +00001418 }
1419 break;
1420 case Instruction::Add:
Chris Lattnerf95d9b92003-10-15 16:48:29 +00001421 if (Op->hasOneUse()) {
Chris Lattnerba1cb382003-09-19 17:17:26 +00001422 // Adding a one to a single bit bit-field should be turned into an XOR
1423 // of the bit. First thing to check is to see if this AND is with a
1424 // single bit constant.
Chris Lattner35167c32004-06-09 07:59:58 +00001425 uint64_t AndRHSV = cast<ConstantInt>(AndRHS)->getRawValue();
Chris Lattnerba1cb382003-09-19 17:17:26 +00001426
1427 // Clear bits that are not part of the constant.
Chris Lattner2f1457f2005-04-24 17:46:05 +00001428 AndRHSV &= ~0ULL >> (64-AndRHS->getType()->getPrimitiveSizeInBits());
Chris Lattnerba1cb382003-09-19 17:17:26 +00001429
1430 // If there is only one bit set...
Chris Lattner35167c32004-06-09 07:59:58 +00001431 if (isOneBitSet(cast<ConstantInt>(AndRHS))) {
Chris Lattnerba1cb382003-09-19 17:17:26 +00001432 // Ok, at this point, we know that we are masking the result of the
1433 // ADD down to exactly one bit. If the constant we are adding has
1434 // no bits set below this bit, then we can eliminate the ADD.
Chris Lattner35167c32004-06-09 07:59:58 +00001435 uint64_t AddRHS = cast<ConstantInt>(OpRHS)->getRawValue();
Misha Brukmanb1c93172005-04-21 23:48:37 +00001436
Chris Lattnerba1cb382003-09-19 17:17:26 +00001437 // Check to see if any bits below the one bit set in AndRHSV are set.
1438 if ((AddRHS & (AndRHSV-1)) == 0) {
1439 // If not, the only thing that can effect the output of the AND is
1440 // the bit specified by AndRHSV. If that bit is set, the effect of
1441 // the XOR is to toggle the bit. If it is clear, then the ADD has
1442 // no effect.
1443 if ((AddRHS & AndRHSV) == 0) { // Bit is not set, noop
1444 TheAnd.setOperand(0, X);
1445 return &TheAnd;
1446 } else {
1447 std::string Name = Op->getName(); Op->setName("");
1448 // Pull the XOR out of the AND.
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00001449 Instruction *NewAnd = BinaryOperator::createAnd(X, AndRHS, Name);
Chris Lattnerba1cb382003-09-19 17:17:26 +00001450 InsertNewInstBefore(NewAnd, TheAnd);
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00001451 return BinaryOperator::createXor(NewAnd, AndRHS);
Chris Lattnerba1cb382003-09-19 17:17:26 +00001452 }
1453 }
1454 }
1455 }
1456 break;
Chris Lattner2da29172003-09-19 19:05:02 +00001457
1458 case Instruction::Shl: {
1459 // We know that the AND will not produce any of the bits shifted in, so if
1460 // the anded constant includes them, clear them now!
1461 //
1462 Constant *AllOne = ConstantIntegral::getAllOnesValue(AndRHS->getType());
Chris Lattner7e794272004-09-24 15:21:34 +00001463 Constant *ShlMask = ConstantExpr::getShl(AllOne, OpRHS);
1464 Constant *CI = ConstantExpr::getAnd(AndRHS, ShlMask);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001465
Chris Lattner7e794272004-09-24 15:21:34 +00001466 if (CI == ShlMask) { // Masking out bits that the shift already masks
1467 return ReplaceInstUsesWith(TheAnd, Op); // No need for the and.
1468 } else if (CI != AndRHS) { // Reducing bits set in and.
Chris Lattner2da29172003-09-19 19:05:02 +00001469 TheAnd.setOperand(1, CI);
1470 return &TheAnd;
1471 }
1472 break;
Misha Brukmanb1c93172005-04-21 23:48:37 +00001473 }
Chris Lattner2da29172003-09-19 19:05:02 +00001474 case Instruction::Shr:
1475 // We know that the AND will not produce any of the bits shifted in, so if
1476 // the anded constant includes them, clear them now! This only applies to
1477 // unsigned shifts, because a signed shr may bring in set bits!
1478 //
1479 if (AndRHS->getType()->isUnsigned()) {
1480 Constant *AllOne = ConstantIntegral::getAllOnesValue(AndRHS->getType());
Chris Lattner7e794272004-09-24 15:21:34 +00001481 Constant *ShrMask = ConstantExpr::getShr(AllOne, OpRHS);
1482 Constant *CI = ConstantExpr::getAnd(AndRHS, ShrMask);
1483
1484 if (CI == ShrMask) { // Masking out bits that the shift already masks.
1485 return ReplaceInstUsesWith(TheAnd, Op);
1486 } else if (CI != AndRHS) {
1487 TheAnd.setOperand(1, CI); // Reduce bits set in and cst.
Chris Lattner2da29172003-09-19 19:05:02 +00001488 return &TheAnd;
1489 }
Chris Lattner7e794272004-09-24 15:21:34 +00001490 } else { // Signed shr.
1491 // See if this is shifting in some sign extension, then masking it out
1492 // with an and.
1493 if (Op->hasOneUse()) {
1494 Constant *AllOne = ConstantIntegral::getAllOnesValue(AndRHS->getType());
1495 Constant *ShrMask = ConstantExpr::getUShr(AllOne, OpRHS);
1496 Constant *CI = ConstantExpr::getAnd(AndRHS, ShrMask);
Chris Lattner5c3c21e2004-10-22 04:53:16 +00001497 if (CI == AndRHS) { // Masking out bits shifted in.
Chris Lattner7e794272004-09-24 15:21:34 +00001498 // Make the argument unsigned.
1499 Value *ShVal = Op->getOperand(0);
1500 ShVal = InsertCastBefore(ShVal,
1501 ShVal->getType()->getUnsignedVersion(),
1502 TheAnd);
1503 ShVal = InsertNewInstBefore(new ShiftInst(Instruction::Shr, ShVal,
1504 OpRHS, Op->getName()),
1505 TheAnd);
Chris Lattner70c20392004-10-27 05:57:15 +00001506 Value *AndRHS2 = ConstantExpr::getCast(AndRHS, ShVal->getType());
1507 ShVal = InsertNewInstBefore(BinaryOperator::createAnd(ShVal, AndRHS2,
1508 TheAnd.getName()),
1509 TheAnd);
Chris Lattner7e794272004-09-24 15:21:34 +00001510 return new CastInst(ShVal, Op->getType());
1511 }
1512 }
Chris Lattner2da29172003-09-19 19:05:02 +00001513 }
1514 break;
Chris Lattnerba1cb382003-09-19 17:17:26 +00001515 }
1516 return 0;
1517}
1518
Chris Lattner6d14f2a2002-08-09 23:47:40 +00001519
Chris Lattner6862fbd2004-09-29 17:40:11 +00001520/// InsertRangeTest - Emit a computation of: (V >= Lo && V < Hi) if Inside is
1521/// true, otherwise (V < Lo || V >= Hi). In pratice, we emit the more efficient
1522/// (V-Lo) <u Hi-Lo. This method expects that Lo <= Hi. IB is the location to
1523/// insert new instructions.
1524Instruction *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi,
1525 bool Inside, Instruction &IB) {
1526 assert(cast<ConstantBool>(ConstantExpr::getSetLE(Lo, Hi))->getValue() &&
1527 "Lo is not <= Hi in range emission code!");
1528 if (Inside) {
1529 if (Lo == Hi) // Trivially false.
1530 return new SetCondInst(Instruction::SetNE, V, V);
1531 if (cast<ConstantIntegral>(Lo)->isMinValue())
1532 return new SetCondInst(Instruction::SetLT, V, Hi);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001533
Chris Lattner6862fbd2004-09-29 17:40:11 +00001534 Constant *AddCST = ConstantExpr::getNeg(Lo);
1535 Instruction *Add = BinaryOperator::createAdd(V, AddCST,V->getName()+".off");
1536 InsertNewInstBefore(Add, IB);
1537 // Convert to unsigned for the comparison.
1538 const Type *UnsType = Add->getType()->getUnsignedVersion();
1539 Value *OffsetVal = InsertCastBefore(Add, UnsType, IB);
1540 AddCST = ConstantExpr::getAdd(AddCST, Hi);
1541 AddCST = ConstantExpr::getCast(AddCST, UnsType);
1542 return new SetCondInst(Instruction::SetLT, OffsetVal, AddCST);
1543 }
1544
1545 if (Lo == Hi) // Trivially true.
1546 return new SetCondInst(Instruction::SetEQ, V, V);
1547
1548 Hi = SubOne(cast<ConstantInt>(Hi));
1549 if (cast<ConstantIntegral>(Lo)->isMinValue()) // V < 0 || V >= Hi ->'V > Hi-1'
1550 return new SetCondInst(Instruction::SetGT, V, Hi);
1551
1552 // Emit X-Lo > Hi-Lo-1
1553 Constant *AddCST = ConstantExpr::getNeg(Lo);
1554 Instruction *Add = BinaryOperator::createAdd(V, AddCST, V->getName()+".off");
1555 InsertNewInstBefore(Add, IB);
1556 // Convert to unsigned for the comparison.
1557 const Type *UnsType = Add->getType()->getUnsignedVersion();
1558 Value *OffsetVal = InsertCastBefore(Add, UnsType, IB);
1559 AddCST = ConstantExpr::getAdd(AddCST, Hi);
1560 AddCST = ConstantExpr::getCast(AddCST, UnsType);
1561 return new SetCondInst(Instruction::SetGT, OffsetVal, AddCST);
1562}
1563
1564
Chris Lattner113f4f42002-06-25 16:13:24 +00001565Instruction *InstCombiner::visitAnd(BinaryOperator &I) {
Chris Lattnerdcf240a2003-03-10 21:43:22 +00001566 bool Changed = SimplifyCommutative(I);
Chris Lattner113f4f42002-06-25 16:13:24 +00001567 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001568
Chris Lattner81a7a232004-10-16 18:11:37 +00001569 if (isa<UndefValue>(Op1)) // X & undef -> 0
1570 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
1571
Chris Lattner86102b82005-01-01 16:22:27 +00001572 // and X, X = X
1573 if (Op0 == Op1)
Chris Lattnere6794492002-08-12 21:17:25 +00001574 return ReplaceInstUsesWith(I, Op1);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001575
Chris Lattner86102b82005-01-01 16:22:27 +00001576 if (ConstantIntegral *AndRHS = dyn_cast<ConstantIntegral>(Op1)) {
Chris Lattner9e2c7fa2005-01-23 20:26:55 +00001577 // and X, -1 == X
1578 if (AndRHS->isAllOnesValue())
Chris Lattnere6794492002-08-12 21:17:25 +00001579 return ReplaceInstUsesWith(I, Op0);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001580
Chris Lattner86102b82005-01-01 16:22:27 +00001581 if (MaskedValueIsZero(Op0, AndRHS)) // LHS & RHS == 0
1582 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
1583
1584 // If the mask is not masking out any bits, there is no reason to do the
1585 // and in the first place.
Misha Brukmanb1c93172005-04-21 23:48:37 +00001586 ConstantIntegral *NotAndRHS =
Chris Lattner9e2c7fa2005-01-23 20:26:55 +00001587 cast<ConstantIntegral>(ConstantExpr::getNot(AndRHS));
Misha Brukmanb1c93172005-04-21 23:48:37 +00001588 if (MaskedValueIsZero(Op0, NotAndRHS))
Chris Lattner9e2c7fa2005-01-23 20:26:55 +00001589 return ReplaceInstUsesWith(I, Op0);
Chris Lattner86102b82005-01-01 16:22:27 +00001590
Chris Lattnerba1cb382003-09-19 17:17:26 +00001591 // Optimize a variety of ((val OP C1) & C2) combinations...
1592 if (isa<BinaryOperator>(Op0) || isa<ShiftInst>(Op0)) {
1593 Instruction *Op0I = cast<Instruction>(Op0);
Chris Lattner86102b82005-01-01 16:22:27 +00001594 Value *Op0LHS = Op0I->getOperand(0);
1595 Value *Op0RHS = Op0I->getOperand(1);
1596 switch (Op0I->getOpcode()) {
1597 case Instruction::Xor:
1598 case Instruction::Or:
1599 // (X ^ V) & C2 --> (X & C2) iff (V & C2) == 0
1600 // (X | V) & C2 --> (X & C2) iff (V & C2) == 0
1601 if (MaskedValueIsZero(Op0LHS, AndRHS))
Misha Brukmanb1c93172005-04-21 23:48:37 +00001602 return BinaryOperator::createAnd(Op0RHS, AndRHS);
Chris Lattner86102b82005-01-01 16:22:27 +00001603 if (MaskedValueIsZero(Op0RHS, AndRHS))
Misha Brukmanb1c93172005-04-21 23:48:37 +00001604 return BinaryOperator::createAnd(Op0LHS, AndRHS);
Chris Lattner9e2c7fa2005-01-23 20:26:55 +00001605
1606 // If the mask is only needed on one incoming arm, push it up.
1607 if (Op0I->hasOneUse()) {
1608 if (MaskedValueIsZero(Op0LHS, NotAndRHS)) {
1609 // Not masking anything out for the LHS, move to RHS.
1610 Instruction *NewRHS = BinaryOperator::createAnd(Op0RHS, AndRHS,
1611 Op0RHS->getName()+".masked");
1612 InsertNewInstBefore(NewRHS, I);
1613 return BinaryOperator::create(
1614 cast<BinaryOperator>(Op0I)->getOpcode(), Op0LHS, NewRHS);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001615 }
Chris Lattner9e2c7fa2005-01-23 20:26:55 +00001616 if (!isa<Constant>(NotAndRHS) &&
1617 MaskedValueIsZero(Op0RHS, NotAndRHS)) {
1618 // Not masking anything out for the RHS, move to LHS.
1619 Instruction *NewLHS = BinaryOperator::createAnd(Op0LHS, AndRHS,
1620 Op0LHS->getName()+".masked");
1621 InsertNewInstBefore(NewLHS, I);
1622 return BinaryOperator::create(
1623 cast<BinaryOperator>(Op0I)->getOpcode(), NewLHS, Op0RHS);
1624 }
1625 }
1626
Chris Lattner86102b82005-01-01 16:22:27 +00001627 break;
1628 case Instruction::And:
1629 // (X & V) & C2 --> 0 iff (V & C2) == 0
1630 if (MaskedValueIsZero(Op0LHS, AndRHS) ||
1631 MaskedValueIsZero(Op0RHS, AndRHS))
1632 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
1633 break;
1634 }
1635
Chris Lattner16464b32003-07-23 19:25:52 +00001636 if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1)))
Chris Lattner86102b82005-01-01 16:22:27 +00001637 if (Instruction *Res = OptAndOp(Op0I, Op0CI, AndRHS, I))
Chris Lattnerba1cb382003-09-19 17:17:26 +00001638 return Res;
Chris Lattner86102b82005-01-01 16:22:27 +00001639 } else if (CastInst *CI = dyn_cast<CastInst>(Op0)) {
1640 const Type *SrcTy = CI->getOperand(0)->getType();
1641
1642 // If this is an integer sign or zero extension instruction.
1643 if (SrcTy->isIntegral() &&
Chris Lattnerd1f46d32005-04-24 06:59:08 +00001644 SrcTy->getPrimitiveSizeInBits() <
1645 CI->getType()->getPrimitiveSizeInBits()) {
Chris Lattner86102b82005-01-01 16:22:27 +00001646
1647 if (SrcTy->isUnsigned()) {
1648 // See if this and is clearing out bits that are known to be zero
1649 // anyway (due to the zero extension).
1650 Constant *Mask = ConstantIntegral::getAllOnesValue(SrcTy);
1651 Mask = ConstantExpr::getZeroExtend(Mask, CI->getType());
1652 Constant *Result = ConstantExpr::getAnd(Mask, AndRHS);
1653 if (Result == Mask) // The "and" isn't doing anything, remove it.
1654 return ReplaceInstUsesWith(I, CI);
1655 if (Result != AndRHS) { // Reduce the and RHS constant.
1656 I.setOperand(1, Result);
1657 return &I;
1658 }
1659
1660 } else {
1661 if (CI->hasOneUse() && SrcTy->isInteger()) {
1662 // We can only do this if all of the sign bits brought in are masked
1663 // out. Compute this by first getting 0000011111, then inverting
1664 // it.
1665 Constant *Mask = ConstantIntegral::getAllOnesValue(SrcTy);
1666 Mask = ConstantExpr::getZeroExtend(Mask, CI->getType());
1667 Mask = ConstantExpr::getNot(Mask); // 1's in the new bits.
1668 if (ConstantExpr::getAnd(Mask, AndRHS)->isNullValue()) {
1669 // If the and is clearing all of the sign bits, change this to a
1670 // zero extension cast. To do this, cast the cast input to
1671 // unsigned, then to the requested size.
1672 Value *CastOp = CI->getOperand(0);
1673 Instruction *NC =
1674 new CastInst(CastOp, CastOp->getType()->getUnsignedVersion(),
1675 CI->getName()+".uns");
1676 NC = InsertNewInstBefore(NC, I);
1677 // Finally, insert a replacement for CI.
1678 NC = new CastInst(NC, CI->getType(), CI->getName());
1679 CI->setName("");
1680 NC = InsertNewInstBefore(NC, I);
1681 WorkList.push_back(CI); // Delete CI later.
1682 I.setOperand(0, NC);
1683 return &I; // The AND operand was modified.
1684 }
1685 }
1686 }
1687 }
Chris Lattner33217db2003-07-23 19:36:21 +00001688 }
Chris Lattner183b3362004-04-09 19:05:30 +00001689
1690 // Try to fold constant and into select arguments.
1691 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
Chris Lattner86102b82005-01-01 16:22:27 +00001692 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattner183b3362004-04-09 19:05:30 +00001693 return R;
Chris Lattner6a4adcd2004-09-29 05:07:12 +00001694 if (isa<PHINode>(Op0))
1695 if (Instruction *NV = FoldOpIntoPhi(I))
1696 return NV;
Chris Lattner49b47ae2003-07-23 17:57:01 +00001697 }
1698
Chris Lattnerbb74e222003-03-10 23:06:50 +00001699 Value *Op0NotVal = dyn_castNotVal(Op0);
1700 Value *Op1NotVal = dyn_castNotVal(Op1);
Chris Lattner3082c5a2003-02-18 19:28:33 +00001701
Chris Lattner023a4832004-06-18 06:07:51 +00001702 if (Op0NotVal == Op1 || Op1NotVal == Op0) // A & ~A == ~A & A == 0
1703 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
1704
Misha Brukman9c003d82004-07-30 12:50:08 +00001705 // (~A & ~B) == (~(A | B)) - De Morgan's Law
Chris Lattnerbb74e222003-03-10 23:06:50 +00001706 if (Op0NotVal && Op1NotVal && isOnlyUse(Op0) && isOnlyUse(Op1)) {
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00001707 Instruction *Or = BinaryOperator::createOr(Op0NotVal, Op1NotVal,
1708 I.getName()+".demorgan");
Chris Lattner49b47ae2003-07-23 17:57:01 +00001709 InsertNewInstBefore(Or, I);
Chris Lattner3082c5a2003-02-18 19:28:33 +00001710 return BinaryOperator::createNot(Or);
1711 }
1712
Chris Lattner623826c2004-09-28 21:48:02 +00001713 if (SetCondInst *RHS = dyn_cast<SetCondInst>(Op1)) {
1714 // (setcc1 A, B) & (setcc2 A, B) --> (setcc3 A, B)
Chris Lattner3ac7c262003-08-13 20:16:26 +00001715 if (Instruction *R = AssociativeOpt(I, FoldSetCCLogical(*this, RHS)))
1716 return R;
1717
Chris Lattner623826c2004-09-28 21:48:02 +00001718 Value *LHSVal, *RHSVal;
1719 ConstantInt *LHSCst, *RHSCst;
1720 Instruction::BinaryOps LHSCC, RHSCC;
1721 if (match(Op0, m_SetCond(LHSCC, m_Value(LHSVal), m_ConstantInt(LHSCst))))
1722 if (match(RHS, m_SetCond(RHSCC, m_Value(RHSVal), m_ConstantInt(RHSCst))))
1723 if (LHSVal == RHSVal && // Found (X setcc C1) & (X setcc C2)
1724 // Set[GL]E X, CST is folded to Set[GL]T elsewhere.
Misha Brukmanb1c93172005-04-21 23:48:37 +00001725 LHSCC != Instruction::SetGE && LHSCC != Instruction::SetLE &&
Chris Lattner623826c2004-09-28 21:48:02 +00001726 RHSCC != Instruction::SetGE && RHSCC != Instruction::SetLE) {
1727 // Ensure that the larger constant is on the RHS.
1728 Constant *Cmp = ConstantExpr::getSetGT(LHSCst, RHSCst);
1729 SetCondInst *LHS = cast<SetCondInst>(Op0);
1730 if (cast<ConstantBool>(Cmp)->getValue()) {
1731 std::swap(LHS, RHS);
1732 std::swap(LHSCst, RHSCst);
1733 std::swap(LHSCC, RHSCC);
1734 }
1735
1736 // At this point, we know we have have two setcc instructions
1737 // comparing a value against two constants and and'ing the result
1738 // together. Because of the above check, we know that we only have
1739 // SetEQ, SetNE, SetLT, and SetGT here. We also know (from the
1740 // FoldSetCCLogical check above), that the two constants are not
1741 // equal.
1742 assert(LHSCst != RHSCst && "Compares not folded above?");
1743
1744 switch (LHSCC) {
1745 default: assert(0 && "Unknown integer condition code!");
1746 case Instruction::SetEQ:
1747 switch (RHSCC) {
1748 default: assert(0 && "Unknown integer condition code!");
1749 case Instruction::SetEQ: // (X == 13 & X == 15) -> false
1750 case Instruction::SetGT: // (X == 13 & X > 15) -> false
1751 return ReplaceInstUsesWith(I, ConstantBool::False);
1752 case Instruction::SetNE: // (X == 13 & X != 15) -> X == 13
1753 case Instruction::SetLT: // (X == 13 & X < 15) -> X == 13
1754 return ReplaceInstUsesWith(I, LHS);
1755 }
1756 case Instruction::SetNE:
1757 switch (RHSCC) {
1758 default: assert(0 && "Unknown integer condition code!");
1759 case Instruction::SetLT:
1760 if (LHSCst == SubOne(RHSCst)) // (X != 13 & X < 14) -> X < 13
1761 return new SetCondInst(Instruction::SetLT, LHSVal, LHSCst);
1762 break; // (X != 13 & X < 15) -> no change
1763 case Instruction::SetEQ: // (X != 13 & X == 15) -> X == 15
1764 case Instruction::SetGT: // (X != 13 & X > 15) -> X > 15
1765 return ReplaceInstUsesWith(I, RHS);
1766 case Instruction::SetNE:
1767 if (LHSCst == SubOne(RHSCst)) {// (X != 13 & X != 14) -> X-13 >u 1
1768 Constant *AddCST = ConstantExpr::getNeg(LHSCst);
1769 Instruction *Add = BinaryOperator::createAdd(LHSVal, AddCST,
1770 LHSVal->getName()+".off");
1771 InsertNewInstBefore(Add, I);
1772 const Type *UnsType = Add->getType()->getUnsignedVersion();
1773 Value *OffsetVal = InsertCastBefore(Add, UnsType, I);
1774 AddCST = ConstantExpr::getSub(RHSCst, LHSCst);
1775 AddCST = ConstantExpr::getCast(AddCST, UnsType);
1776 return new SetCondInst(Instruction::SetGT, OffsetVal, AddCST);
1777 }
1778 break; // (X != 13 & X != 15) -> no change
1779 }
1780 break;
1781 case Instruction::SetLT:
1782 switch (RHSCC) {
1783 default: assert(0 && "Unknown integer condition code!");
1784 case Instruction::SetEQ: // (X < 13 & X == 15) -> false
1785 case Instruction::SetGT: // (X < 13 & X > 15) -> false
1786 return ReplaceInstUsesWith(I, ConstantBool::False);
1787 case Instruction::SetNE: // (X < 13 & X != 15) -> X < 13
1788 case Instruction::SetLT: // (X < 13 & X < 15) -> X < 13
1789 return ReplaceInstUsesWith(I, LHS);
1790 }
1791 case Instruction::SetGT:
1792 switch (RHSCC) {
1793 default: assert(0 && "Unknown integer condition code!");
1794 case Instruction::SetEQ: // (X > 13 & X == 15) -> X > 13
1795 return ReplaceInstUsesWith(I, LHS);
1796 case Instruction::SetGT: // (X > 13 & X > 15) -> X > 15
1797 return ReplaceInstUsesWith(I, RHS);
1798 case Instruction::SetNE:
1799 if (RHSCst == AddOne(LHSCst)) // (X > 13 & X != 14) -> X > 14
1800 return new SetCondInst(Instruction::SetGT, LHSVal, RHSCst);
1801 break; // (X > 13 & X != 15) -> no change
Chris Lattner6862fbd2004-09-29 17:40:11 +00001802 case Instruction::SetLT: // (X > 13 & X < 15) -> (X-14) <u 1
1803 return InsertRangeTest(LHSVal, AddOne(LHSCst), RHSCst, true, I);
Chris Lattner623826c2004-09-28 21:48:02 +00001804 }
1805 }
1806 }
1807 }
1808
Chris Lattner113f4f42002-06-25 16:13:24 +00001809 return Changed ? &I : 0;
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001810}
1811
Chris Lattner113f4f42002-06-25 16:13:24 +00001812Instruction *InstCombiner::visitOr(BinaryOperator &I) {
Chris Lattnerdcf240a2003-03-10 21:43:22 +00001813 bool Changed = SimplifyCommutative(I);
Chris Lattner113f4f42002-06-25 16:13:24 +00001814 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001815
Chris Lattner81a7a232004-10-16 18:11:37 +00001816 if (isa<UndefValue>(Op1))
1817 return ReplaceInstUsesWith(I, // X | undef -> -1
1818 ConstantIntegral::getAllOnesValue(I.getType()));
1819
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001820 // or X, X = X or X, 0 == X
Chris Lattnere6794492002-08-12 21:17:25 +00001821 if (Op0 == Op1 || Op1 == Constant::getNullValue(I.getType()))
1822 return ReplaceInstUsesWith(I, Op0);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001823
1824 // or X, -1 == -1
Chris Lattner8f0d1562003-07-23 18:29:44 +00001825 if (ConstantIntegral *RHS = dyn_cast<ConstantIntegral>(Op1)) {
Chris Lattner86102b82005-01-01 16:22:27 +00001826 // If X is known to only contain bits that already exist in RHS, just
1827 // replace this instruction with RHS directly.
1828 if (MaskedValueIsZero(Op0,
1829 cast<ConstantIntegral>(ConstantExpr::getNot(RHS))))
1830 return ReplaceInstUsesWith(I, RHS);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00001831
Chris Lattnerd4252a72004-07-30 07:50:03 +00001832 ConstantInt *C1; Value *X;
1833 // (X & C1) | C2 --> (X | C2) & (C1|C2)
1834 if (match(Op0, m_And(m_Value(X), m_ConstantInt(C1))) && isOnlyUse(Op0)) {
Chris Lattnerb62f5082005-05-09 04:58:36 +00001835 Instruction *Or = BinaryOperator::createOr(X, RHS, Op0->getName());
1836 Op0->setName("");
Chris Lattnerd4252a72004-07-30 07:50:03 +00001837 InsertNewInstBefore(Or, I);
1838 return BinaryOperator::createAnd(Or, ConstantExpr::getOr(RHS, C1));
1839 }
Chris Lattner8f0d1562003-07-23 18:29:44 +00001840
Chris Lattnerd4252a72004-07-30 07:50:03 +00001841 // (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2)
1842 if (match(Op0, m_Xor(m_Value(X), m_ConstantInt(C1))) && isOnlyUse(Op0)) {
1843 std::string Op0Name = Op0->getName(); Op0->setName("");
1844 Instruction *Or = BinaryOperator::createOr(X, RHS, Op0Name);
1845 InsertNewInstBefore(Or, I);
1846 return BinaryOperator::createXor(Or,
1847 ConstantExpr::getAnd(C1, ConstantExpr::getNot(RHS)));
Chris Lattner8f0d1562003-07-23 18:29:44 +00001848 }
Chris Lattner183b3362004-04-09 19:05:30 +00001849
1850 // Try to fold constant and into select arguments.
1851 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
Chris Lattner86102b82005-01-01 16:22:27 +00001852 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattner183b3362004-04-09 19:05:30 +00001853 return R;
Chris Lattner6a4adcd2004-09-29 05:07:12 +00001854 if (isa<PHINode>(Op0))
1855 if (Instruction *NV = FoldOpIntoPhi(I))
1856 return NV;
Chris Lattner8f0d1562003-07-23 18:29:44 +00001857 }
1858
Chris Lattnerd4252a72004-07-30 07:50:03 +00001859 Value *A, *B; ConstantInt *C1, *C2;
Chris Lattner4294cec2005-05-07 23:49:08 +00001860
1861 if (match(Op0, m_And(m_Value(A), m_Value(B))))
1862 if (A == Op1 || B == Op1) // (A & ?) | A --> A
1863 return ReplaceInstUsesWith(I, Op1);
1864 if (match(Op1, m_And(m_Value(A), m_Value(B))))
1865 if (A == Op0 || B == Op0) // A | (A & ?) --> A
1866 return ReplaceInstUsesWith(I, Op0);
1867
Chris Lattnerb62f5082005-05-09 04:58:36 +00001868 // (X^C)|Y -> (X|Y)^C iff Y&C == 0
1869 if (Op0->hasOneUse() && match(Op0, m_Xor(m_Value(A), m_ConstantInt(C1))) &&
1870 MaskedValueIsZero(Op1, C1)) {
1871 Instruction *NOr = BinaryOperator::createOr(A, Op1, Op0->getName());
1872 Op0->setName("");
1873 return BinaryOperator::createXor(InsertNewInstBefore(NOr, I), C1);
1874 }
1875
1876 // Y|(X^C) -> (X|Y)^C iff Y&C == 0
1877 if (Op1->hasOneUse() && match(Op1, m_Xor(m_Value(A), m_ConstantInt(C1))) &&
1878 MaskedValueIsZero(Op0, C1)) {
1879 Instruction *NOr = BinaryOperator::createOr(A, Op0, Op1->getName());
1880 Op0->setName("");
1881 return BinaryOperator::createXor(InsertNewInstBefore(NOr, I), C1);
1882 }
1883
Chris Lattner4294cec2005-05-07 23:49:08 +00001884 // (A & C1)|(A & C2) == A & (C1|C2)
Chris Lattnerd4252a72004-07-30 07:50:03 +00001885 if (match(Op0, m_And(m_Value(A), m_ConstantInt(C1))) &&
1886 match(Op1, m_And(m_Value(B), m_ConstantInt(C2))) && A == B)
1887 return BinaryOperator::createAnd(A, ConstantExpr::getOr(C1, C2));
Chris Lattner812aab72003-08-12 19:11:07 +00001888
Chris Lattnerd4252a72004-07-30 07:50:03 +00001889 if (match(Op0, m_Not(m_Value(A)))) { // ~A | Op1
1890 if (A == Op1) // ~A | A == -1
Misha Brukmanb1c93172005-04-21 23:48:37 +00001891 return ReplaceInstUsesWith(I,
Chris Lattnerd4252a72004-07-30 07:50:03 +00001892 ConstantIntegral::getAllOnesValue(I.getType()));
1893 } else {
1894 A = 0;
1895 }
Chris Lattner4294cec2005-05-07 23:49:08 +00001896 // Note, A is still live here!
Chris Lattnerd4252a72004-07-30 07:50:03 +00001897 if (match(Op1, m_Not(m_Value(B)))) { // Op0 | ~B
1898 if (Op0 == B)
Misha Brukmanb1c93172005-04-21 23:48:37 +00001899 return ReplaceInstUsesWith(I,
Chris Lattnerd4252a72004-07-30 07:50:03 +00001900 ConstantIntegral::getAllOnesValue(I.getType()));
Chris Lattner3e327a42003-03-10 23:13:59 +00001901
Misha Brukman9c003d82004-07-30 12:50:08 +00001902 // (~A | ~B) == (~(A & B)) - De Morgan's Law
Chris Lattnerd4252a72004-07-30 07:50:03 +00001903 if (A && isOnlyUse(Op0) && isOnlyUse(Op1)) {
1904 Value *And = InsertNewInstBefore(BinaryOperator::createAnd(A, B,
1905 I.getName()+".demorgan"), I);
1906 return BinaryOperator::createNot(And);
1907 }
Chris Lattner3e327a42003-03-10 23:13:59 +00001908 }
Chris Lattner3082c5a2003-02-18 19:28:33 +00001909
Chris Lattner3ac7c262003-08-13 20:16:26 +00001910 // (setcc1 A, B) | (setcc2 A, B) --> (setcc3 A, B)
Chris Lattnerdcf756e2004-09-28 22:33:08 +00001911 if (SetCondInst *RHS = dyn_cast<SetCondInst>(I.getOperand(1))) {
Chris Lattner3ac7c262003-08-13 20:16:26 +00001912 if (Instruction *R = AssociativeOpt(I, FoldSetCCLogical(*this, RHS)))
1913 return R;
1914
Chris Lattnerdcf756e2004-09-28 22:33:08 +00001915 Value *LHSVal, *RHSVal;
1916 ConstantInt *LHSCst, *RHSCst;
1917 Instruction::BinaryOps LHSCC, RHSCC;
1918 if (match(Op0, m_SetCond(LHSCC, m_Value(LHSVal), m_ConstantInt(LHSCst))))
1919 if (match(RHS, m_SetCond(RHSCC, m_Value(RHSVal), m_ConstantInt(RHSCst))))
1920 if (LHSVal == RHSVal && // Found (X setcc C1) | (X setcc C2)
1921 // Set[GL]E X, CST is folded to Set[GL]T elsewhere.
Misha Brukmanb1c93172005-04-21 23:48:37 +00001922 LHSCC != Instruction::SetGE && LHSCC != Instruction::SetLE &&
Chris Lattnerdcf756e2004-09-28 22:33:08 +00001923 RHSCC != Instruction::SetGE && RHSCC != Instruction::SetLE) {
1924 // Ensure that the larger constant is on the RHS.
1925 Constant *Cmp = ConstantExpr::getSetGT(LHSCst, RHSCst);
1926 SetCondInst *LHS = cast<SetCondInst>(Op0);
1927 if (cast<ConstantBool>(Cmp)->getValue()) {
1928 std::swap(LHS, RHS);
1929 std::swap(LHSCst, RHSCst);
1930 std::swap(LHSCC, RHSCC);
1931 }
1932
1933 // At this point, we know we have have two setcc instructions
1934 // comparing a value against two constants and or'ing the result
1935 // together. Because of the above check, we know that we only have
1936 // SetEQ, SetNE, SetLT, and SetGT here. We also know (from the
1937 // FoldSetCCLogical check above), that the two constants are not
1938 // equal.
1939 assert(LHSCst != RHSCst && "Compares not folded above?");
1940
1941 switch (LHSCC) {
1942 default: assert(0 && "Unknown integer condition code!");
1943 case Instruction::SetEQ:
1944 switch (RHSCC) {
1945 default: assert(0 && "Unknown integer condition code!");
1946 case Instruction::SetEQ:
1947 if (LHSCst == SubOne(RHSCst)) {// (X == 13 | X == 14) -> X-13 <u 2
1948 Constant *AddCST = ConstantExpr::getNeg(LHSCst);
1949 Instruction *Add = BinaryOperator::createAdd(LHSVal, AddCST,
1950 LHSVal->getName()+".off");
1951 InsertNewInstBefore(Add, I);
1952 const Type *UnsType = Add->getType()->getUnsignedVersion();
1953 Value *OffsetVal = InsertCastBefore(Add, UnsType, I);
1954 AddCST = ConstantExpr::getSub(AddOne(RHSCst), LHSCst);
1955 AddCST = ConstantExpr::getCast(AddCST, UnsType);
1956 return new SetCondInst(Instruction::SetLT, OffsetVal, AddCST);
1957 }
1958 break; // (X == 13 | X == 15) -> no change
1959
Chris Lattner5c219462005-04-19 06:04:18 +00001960 case Instruction::SetGT: // (X == 13 | X > 14) -> no change
1961 break;
Chris Lattnerdcf756e2004-09-28 22:33:08 +00001962 case Instruction::SetNE: // (X == 13 | X != 15) -> X != 15
1963 case Instruction::SetLT: // (X == 13 | X < 15) -> X < 15
1964 return ReplaceInstUsesWith(I, RHS);
1965 }
1966 break;
1967 case Instruction::SetNE:
1968 switch (RHSCC) {
1969 default: assert(0 && "Unknown integer condition code!");
Chris Lattnerdcf756e2004-09-28 22:33:08 +00001970 case Instruction::SetEQ: // (X != 13 | X == 15) -> X != 13
1971 case Instruction::SetGT: // (X != 13 | X > 15) -> X != 13
1972 return ReplaceInstUsesWith(I, LHS);
1973 case Instruction::SetNE: // (X != 13 | X != 15) -> true
Chris Lattner2ceb6ee2005-06-17 03:59:17 +00001974 case Instruction::SetLT: // (X != 13 | X < 15) -> true
Chris Lattnerdcf756e2004-09-28 22:33:08 +00001975 return ReplaceInstUsesWith(I, ConstantBool::True);
1976 }
1977 break;
1978 case Instruction::SetLT:
1979 switch (RHSCC) {
1980 default: assert(0 && "Unknown integer condition code!");
1981 case Instruction::SetEQ: // (X < 13 | X == 14) -> no change
1982 break;
Chris Lattner6862fbd2004-09-29 17:40:11 +00001983 case Instruction::SetGT: // (X < 13 | X > 15) -> (X-13) > 2
1984 return InsertRangeTest(LHSVal, LHSCst, AddOne(RHSCst), false, I);
Chris Lattnerdcf756e2004-09-28 22:33:08 +00001985 case Instruction::SetNE: // (X < 13 | X != 15) -> X != 15
1986 case Instruction::SetLT: // (X < 13 | X < 15) -> X < 15
1987 return ReplaceInstUsesWith(I, RHS);
1988 }
1989 break;
1990 case Instruction::SetGT:
1991 switch (RHSCC) {
1992 default: assert(0 && "Unknown integer condition code!");
1993 case Instruction::SetEQ: // (X > 13 | X == 15) -> X > 13
1994 case Instruction::SetGT: // (X > 13 | X > 15) -> X > 13
1995 return ReplaceInstUsesWith(I, LHS);
1996 case Instruction::SetNE: // (X > 13 | X != 15) -> true
1997 case Instruction::SetLT: // (X > 13 | X < 15) -> true
1998 return ReplaceInstUsesWith(I, ConstantBool::True);
1999 }
2000 }
2001 }
2002 }
Chris Lattner113f4f42002-06-25 16:13:24 +00002003 return Changed ? &I : 0;
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00002004}
2005
Chris Lattnerc2076352004-02-16 01:20:27 +00002006// XorSelf - Implements: X ^ X --> 0
2007struct XorSelf {
2008 Value *RHS;
2009 XorSelf(Value *rhs) : RHS(rhs) {}
2010 bool shouldApply(Value *LHS) const { return LHS == RHS; }
2011 Instruction *apply(BinaryOperator &Xor) const {
2012 return &Xor;
2013 }
2014};
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00002015
2016
Chris Lattner113f4f42002-06-25 16:13:24 +00002017Instruction *InstCombiner::visitXor(BinaryOperator &I) {
Chris Lattnerdcf240a2003-03-10 21:43:22 +00002018 bool Changed = SimplifyCommutative(I);
Chris Lattner113f4f42002-06-25 16:13:24 +00002019 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00002020
Chris Lattner81a7a232004-10-16 18:11:37 +00002021 if (isa<UndefValue>(Op1))
2022 return ReplaceInstUsesWith(I, Op1); // X ^ undef -> undef
2023
Chris Lattnerc2076352004-02-16 01:20:27 +00002024 // xor X, X = 0, even if X is nested in a sequence of Xor's.
2025 if (Instruction *Result = AssociativeOpt(I, XorSelf(Op1))) {
2026 assert(Result == &I && "AssociativeOpt didn't work?");
Chris Lattnere6794492002-08-12 21:17:25 +00002027 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
Chris Lattnerc2076352004-02-16 01:20:27 +00002028 }
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00002029
Chris Lattner97638592003-07-23 21:37:07 +00002030 if (ConstantIntegral *RHS = dyn_cast<ConstantIntegral>(Op1)) {
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002031 // xor X, 0 == X
Chris Lattner97638592003-07-23 21:37:07 +00002032 if (RHS->isNullValue())
Chris Lattnere6794492002-08-12 21:17:25 +00002033 return ReplaceInstUsesWith(I, Op0);
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002034
Chris Lattner97638592003-07-23 21:37:07 +00002035 if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) {
Chris Lattnerb8d6e402002-08-20 18:24:26 +00002036 // xor (setcc A, B), true = not (setcc A, B) = setncc A, B
Chris Lattner97638592003-07-23 21:37:07 +00002037 if (SetCondInst *SCI = dyn_cast<SetCondInst>(Op0I))
Chris Lattnerf95d9b92003-10-15 16:48:29 +00002038 if (RHS == ConstantBool::True && SCI->hasOneUse())
Chris Lattnerb8d6e402002-08-20 18:24:26 +00002039 return new SetCondInst(SCI->getInverseCondition(),
2040 SCI->getOperand(0), SCI->getOperand(1));
Chris Lattnere5806662003-11-04 23:50:51 +00002041
Chris Lattner8f2f5982003-11-05 01:06:05 +00002042 // ~(c-X) == X-c-1 == X+(-c-1)
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00002043 if (Op0I->getOpcode() == Instruction::Sub && RHS->isAllOnesValue())
2044 if (Constant *Op0I0C = dyn_cast<Constant>(Op0I->getOperand(0))) {
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002045 Constant *NegOp0I0C = ConstantExpr::getNeg(Op0I0C);
2046 Constant *ConstantRHS = ConstantExpr::getSub(NegOp0I0C,
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00002047 ConstantInt::get(I.getType(), 1));
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002048 return BinaryOperator::createAdd(Op0I->getOperand(1), ConstantRHS);
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00002049 }
Chris Lattner023a4832004-06-18 06:07:51 +00002050
2051 // ~(~X & Y) --> (X | ~Y)
2052 if (Op0I->getOpcode() == Instruction::And && RHS->isAllOnesValue()) {
2053 if (dyn_castNotVal(Op0I->getOperand(1))) Op0I->swapOperands();
2054 if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) {
2055 Instruction *NotY =
Misha Brukmanb1c93172005-04-21 23:48:37 +00002056 BinaryOperator::createNot(Op0I->getOperand(1),
Chris Lattner023a4832004-06-18 06:07:51 +00002057 Op0I->getOperand(1)->getName()+".not");
2058 InsertNewInstBefore(NotY, I);
2059 return BinaryOperator::createOr(Op0NotVal, NotY);
2060 }
2061 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00002062
Chris Lattner97638592003-07-23 21:37:07 +00002063 if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1)))
Chris Lattnere5806662003-11-04 23:50:51 +00002064 switch (Op0I->getOpcode()) {
2065 case Instruction::Add:
Chris Lattner0f68fa62003-11-04 23:37:10 +00002066 // ~(X-c) --> (-c-1)-X
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00002067 if (RHS->isAllOnesValue()) {
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002068 Constant *NegOp0CI = ConstantExpr::getNeg(Op0CI);
2069 return BinaryOperator::createSub(
2070 ConstantExpr::getSub(NegOp0CI,
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00002071 ConstantInt::get(I.getType(), 1)),
Chris Lattner0f68fa62003-11-04 23:37:10 +00002072 Op0I->getOperand(0));
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00002073 }
Chris Lattnere5806662003-11-04 23:50:51 +00002074 break;
2075 case Instruction::And:
Chris Lattner97638592003-07-23 21:37:07 +00002076 // (X & C1) ^ C2 --> (X & C1) | C2 iff (C1&C2) == 0
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002077 if (ConstantExpr::getAnd(RHS, Op0CI)->isNullValue())
2078 return BinaryOperator::createOr(Op0, RHS);
Chris Lattnere5806662003-11-04 23:50:51 +00002079 break;
2080 case Instruction::Or:
Chris Lattner97638592003-07-23 21:37:07 +00002081 // (X | C1) ^ C2 --> (X | C1) & ~C2 iff (C1&C2) == C2
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002082 if (ConstantExpr::getAnd(RHS, Op0CI) == RHS)
Chris Lattnerc8e7e292004-06-10 02:12:35 +00002083 return BinaryOperator::createAnd(Op0, ConstantExpr::getNot(RHS));
Chris Lattnere5806662003-11-04 23:50:51 +00002084 break;
2085 default: break;
Chris Lattner97638592003-07-23 21:37:07 +00002086 }
Chris Lattnerb8d6e402002-08-20 18:24:26 +00002087 }
Chris Lattner183b3362004-04-09 19:05:30 +00002088
2089 // Try to fold constant and into select arguments.
2090 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
Chris Lattner86102b82005-01-01 16:22:27 +00002091 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattner183b3362004-04-09 19:05:30 +00002092 return R;
Chris Lattner6a4adcd2004-09-29 05:07:12 +00002093 if (isa<PHINode>(Op0))
2094 if (Instruction *NV = FoldOpIntoPhi(I))
2095 return NV;
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00002096 }
2097
Chris Lattnerbb74e222003-03-10 23:06:50 +00002098 if (Value *X = dyn_castNotVal(Op0)) // ~A ^ A == -1
Chris Lattner3082c5a2003-02-18 19:28:33 +00002099 if (X == Op1)
2100 return ReplaceInstUsesWith(I,
2101 ConstantIntegral::getAllOnesValue(I.getType()));
2102
Chris Lattnerbb74e222003-03-10 23:06:50 +00002103 if (Value *X = dyn_castNotVal(Op1)) // A ^ ~A == -1
Chris Lattner3082c5a2003-02-18 19:28:33 +00002104 if (X == Op0)
2105 return ReplaceInstUsesWith(I,
2106 ConstantIntegral::getAllOnesValue(I.getType()));
2107
Chris Lattner1bbb7b62003-03-10 18:24:17 +00002108 if (Instruction *Op1I = dyn_cast<Instruction>(Op1))
Chris Lattnerb36d9082004-02-16 03:54:20 +00002109 if (Op1I->getOpcode() == Instruction::Or) {
Chris Lattner1bbb7b62003-03-10 18:24:17 +00002110 if (Op1I->getOperand(0) == Op0) { // B^(B|A) == (A|B)^B
2111 cast<BinaryOperator>(Op1I)->swapOperands();
2112 I.swapOperands();
2113 std::swap(Op0, Op1);
2114 } else if (Op1I->getOperand(1) == Op0) { // B^(A|B) == (A|B)^B
2115 I.swapOperands();
2116 std::swap(Op0, Op1);
Misha Brukmanb1c93172005-04-21 23:48:37 +00002117 }
Chris Lattnerb36d9082004-02-16 03:54:20 +00002118 } else if (Op1I->getOpcode() == Instruction::Xor) {
2119 if (Op0 == Op1I->getOperand(0)) // A^(A^B) == B
2120 return ReplaceInstUsesWith(I, Op1I->getOperand(1));
2121 else if (Op0 == Op1I->getOperand(1)) // A^(B^A) == B
2122 return ReplaceInstUsesWith(I, Op1I->getOperand(0));
2123 }
Chris Lattner1bbb7b62003-03-10 18:24:17 +00002124
2125 if (Instruction *Op0I = dyn_cast<Instruction>(Op0))
Chris Lattnerf95d9b92003-10-15 16:48:29 +00002126 if (Op0I->getOpcode() == Instruction::Or && Op0I->hasOneUse()) {
Chris Lattner1bbb7b62003-03-10 18:24:17 +00002127 if (Op0I->getOperand(0) == Op1) // (B|A)^B == (A|B)^B
2128 cast<BinaryOperator>(Op0I)->swapOperands();
Chris Lattnerdcf240a2003-03-10 21:43:22 +00002129 if (Op0I->getOperand(1) == Op1) { // (A|B)^B == A & ~B
Chris Lattner396dbfe2004-06-09 05:08:07 +00002130 Value *NotB = InsertNewInstBefore(BinaryOperator::createNot(Op1,
2131 Op1->getName()+".not"), I);
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002132 return BinaryOperator::createAnd(Op0I->getOperand(0), NotB);
Chris Lattner1bbb7b62003-03-10 18:24:17 +00002133 }
Chris Lattnerb36d9082004-02-16 03:54:20 +00002134 } else if (Op0I->getOpcode() == Instruction::Xor) {
2135 if (Op1 == Op0I->getOperand(0)) // (A^B)^A == B
2136 return ReplaceInstUsesWith(I, Op0I->getOperand(1));
2137 else if (Op1 == Op0I->getOperand(1)) // (B^A)^A == B
2138 return ReplaceInstUsesWith(I, Op0I->getOperand(0));
Chris Lattner1bbb7b62003-03-10 18:24:17 +00002139 }
2140
Chris Lattner7aa2d472004-08-01 19:42:59 +00002141 // (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0
Chris Lattnerd4252a72004-07-30 07:50:03 +00002142 Value *A, *B; ConstantInt *C1, *C2;
2143 if (match(Op0, m_And(m_Value(A), m_ConstantInt(C1))) &&
2144 match(Op1, m_And(m_Value(B), m_ConstantInt(C2))) &&
Chris Lattner7aa2d472004-08-01 19:42:59 +00002145 ConstantExpr::getAnd(C1, C2)->isNullValue())
Chris Lattnerd4252a72004-07-30 07:50:03 +00002146 return BinaryOperator::createOr(Op0, Op1);
Chris Lattner7fb29e12003-03-11 00:12:48 +00002147
Chris Lattner3ac7c262003-08-13 20:16:26 +00002148 // (setcc1 A, B) ^ (setcc2 A, B) --> (setcc3 A, B)
2149 if (SetCondInst *RHS = dyn_cast<SetCondInst>(I.getOperand(1)))
2150 if (Instruction *R = AssociativeOpt(I, FoldSetCCLogical(*this, RHS)))
2151 return R;
2152
Chris Lattner113f4f42002-06-25 16:13:24 +00002153 return Changed ? &I : 0;
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00002154}
2155
Chris Lattner6862fbd2004-09-29 17:40:11 +00002156/// MulWithOverflow - Compute Result = In1*In2, returning true if the result
2157/// overflowed for this type.
2158static bool MulWithOverflow(ConstantInt *&Result, ConstantInt *In1,
2159 ConstantInt *In2) {
2160 Result = cast<ConstantInt>(ConstantExpr::getMul(In1, In2));
2161 return !In2->isNullValue() && ConstantExpr::getDiv(Result, In2) != In1;
2162}
2163
2164static bool isPositive(ConstantInt *C) {
2165 return cast<ConstantSInt>(C)->getValue() >= 0;
2166}
2167
2168/// AddWithOverflow - Compute Result = In1+In2, returning true if the result
2169/// overflowed for this type.
2170static bool AddWithOverflow(ConstantInt *&Result, ConstantInt *In1,
2171 ConstantInt *In2) {
2172 Result = cast<ConstantInt>(ConstantExpr::getAdd(In1, In2));
2173
2174 if (In1->getType()->isUnsigned())
2175 return cast<ConstantUInt>(Result)->getValue() <
2176 cast<ConstantUInt>(In1)->getValue();
2177 if (isPositive(In1) != isPositive(In2))
2178 return false;
2179 if (isPositive(In1))
2180 return cast<ConstantSInt>(Result)->getValue() <
2181 cast<ConstantSInt>(In1)->getValue();
2182 return cast<ConstantSInt>(Result)->getValue() >
2183 cast<ConstantSInt>(In1)->getValue();
2184}
2185
Chris Lattner0798af32005-01-13 20:14:25 +00002186/// EmitGEPOffset - Given a getelementptr instruction/constantexpr, emit the
2187/// code necessary to compute the offset from the base pointer (without adding
2188/// in the base pointer). Return the result as a signed integer of intptr size.
2189static Value *EmitGEPOffset(User *GEP, Instruction &I, InstCombiner &IC) {
2190 TargetData &TD = IC.getTargetData();
2191 gep_type_iterator GTI = gep_type_begin(GEP);
2192 const Type *UIntPtrTy = TD.getIntPtrType();
2193 const Type *SIntPtrTy = UIntPtrTy->getSignedVersion();
2194 Value *Result = Constant::getNullValue(SIntPtrTy);
2195
2196 // Build a mask for high order bits.
2197 uint64_t PtrSizeMask = ~0ULL;
2198 PtrSizeMask >>= 64-(TD.getPointerSize()*8);
2199
Chris Lattner0798af32005-01-13 20:14:25 +00002200 for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i, ++GTI) {
2201 Value *Op = GEP->getOperand(i);
Chris Lattnerd35d2102005-01-13 23:26:48 +00002202 uint64_t Size = TD.getTypeSize(GTI.getIndexedType()) & PtrSizeMask;
Chris Lattner0798af32005-01-13 20:14:25 +00002203 Constant *Scale = ConstantExpr::getCast(ConstantUInt::get(UIntPtrTy, Size),
2204 SIntPtrTy);
2205 if (Constant *OpC = dyn_cast<Constant>(Op)) {
2206 if (!OpC->isNullValue()) {
Chris Lattner4cb9fa32005-01-13 20:40:58 +00002207 OpC = ConstantExpr::getCast(OpC, SIntPtrTy);
Chris Lattner0798af32005-01-13 20:14:25 +00002208 Scale = ConstantExpr::getMul(OpC, Scale);
2209 if (Constant *RC = dyn_cast<Constant>(Result))
2210 Result = ConstantExpr::getAdd(RC, Scale);
2211 else {
2212 // Emit an add instruction.
2213 Result = IC.InsertNewInstBefore(
2214 BinaryOperator::createAdd(Result, Scale,
2215 GEP->getName()+".offs"), I);
2216 }
2217 }
2218 } else {
Chris Lattner7aa41cf2005-01-14 17:17:59 +00002219 // Convert to correct type.
2220 Op = IC.InsertNewInstBefore(new CastInst(Op, SIntPtrTy,
2221 Op->getName()+".c"), I);
2222 if (Size != 1)
Chris Lattner4cb9fa32005-01-13 20:40:58 +00002223 // We'll let instcombine(mul) convert this to a shl if possible.
2224 Op = IC.InsertNewInstBefore(BinaryOperator::createMul(Op, Scale,
2225 GEP->getName()+".idx"), I);
Chris Lattner0798af32005-01-13 20:14:25 +00002226
2227 // Emit an add instruction.
Chris Lattner4cb9fa32005-01-13 20:40:58 +00002228 Result = IC.InsertNewInstBefore(BinaryOperator::createAdd(Op, Result,
Chris Lattner0798af32005-01-13 20:14:25 +00002229 GEP->getName()+".offs"), I);
2230 }
2231 }
2232 return Result;
2233}
2234
2235/// FoldGEPSetCC - Fold comparisons between a GEP instruction and something
2236/// else. At this point we know that the GEP is on the LHS of the comparison.
2237Instruction *InstCombiner::FoldGEPSetCC(User *GEPLHS, Value *RHS,
2238 Instruction::BinaryOps Cond,
2239 Instruction &I) {
2240 assert(dyn_castGetElementPtr(GEPLHS) && "LHS is not a getelementptr!");
Chris Lattner81e84172005-01-13 22:25:21 +00002241
2242 if (CastInst *CI = dyn_cast<CastInst>(RHS))
2243 if (isa<PointerType>(CI->getOperand(0)->getType()))
2244 RHS = CI->getOperand(0);
2245
Chris Lattner0798af32005-01-13 20:14:25 +00002246 Value *PtrBase = GEPLHS->getOperand(0);
2247 if (PtrBase == RHS) {
2248 // As an optimization, we don't actually have to compute the actual value of
2249 // OFFSET if this is a seteq or setne comparison, just return whether each
2250 // index is zero or not.
Chris Lattner81e84172005-01-13 22:25:21 +00002251 if (Cond == Instruction::SetEQ || Cond == Instruction::SetNE) {
2252 Instruction *InVal = 0;
Chris Lattnercd517ff2005-01-28 19:32:01 +00002253 gep_type_iterator GTI = gep_type_begin(GEPLHS);
2254 for (unsigned i = 1, e = GEPLHS->getNumOperands(); i != e; ++i, ++GTI) {
Chris Lattner81e84172005-01-13 22:25:21 +00002255 bool EmitIt = true;
2256 if (Constant *C = dyn_cast<Constant>(GEPLHS->getOperand(i))) {
2257 if (isa<UndefValue>(C)) // undef index -> undef.
2258 return ReplaceInstUsesWith(I, UndefValue::get(I.getType()));
2259 if (C->isNullValue())
2260 EmitIt = false;
Chris Lattnercd517ff2005-01-28 19:32:01 +00002261 else if (TD->getTypeSize(GTI.getIndexedType()) == 0) {
2262 EmitIt = false; // This is indexing into a zero sized array?
Misha Brukmanb1c93172005-04-21 23:48:37 +00002263 } else if (isa<ConstantInt>(C))
Chris Lattner81e84172005-01-13 22:25:21 +00002264 return ReplaceInstUsesWith(I, // No comparison is needed here.
2265 ConstantBool::get(Cond == Instruction::SetNE));
2266 }
2267
2268 if (EmitIt) {
Misha Brukmanb1c93172005-04-21 23:48:37 +00002269 Instruction *Comp =
Chris Lattner81e84172005-01-13 22:25:21 +00002270 new SetCondInst(Cond, GEPLHS->getOperand(i),
2271 Constant::getNullValue(GEPLHS->getOperand(i)->getType()));
2272 if (InVal == 0)
2273 InVal = Comp;
2274 else {
2275 InVal = InsertNewInstBefore(InVal, I);
2276 InsertNewInstBefore(Comp, I);
2277 if (Cond == Instruction::SetNE) // True if any are unequal
2278 InVal = BinaryOperator::createOr(InVal, Comp);
2279 else // True if all are equal
2280 InVal = BinaryOperator::createAnd(InVal, Comp);
2281 }
2282 }
2283 }
2284
2285 if (InVal)
2286 return InVal;
2287 else
2288 ReplaceInstUsesWith(I, // No comparison is needed here, all indexes = 0
2289 ConstantBool::get(Cond == Instruction::SetEQ));
2290 }
Chris Lattner0798af32005-01-13 20:14:25 +00002291
2292 // Only lower this if the setcc is the only user of the GEP or if we expect
2293 // the result to fold to a constant!
2294 if (isa<ConstantExpr>(GEPLHS) || GEPLHS->hasOneUse()) {
2295 // ((gep Ptr, OFFSET) cmp Ptr) ---> (OFFSET cmp 0).
2296 Value *Offset = EmitGEPOffset(GEPLHS, I, *this);
2297 return new SetCondInst(Cond, Offset,
2298 Constant::getNullValue(Offset->getType()));
2299 }
2300 } else if (User *GEPRHS = dyn_castGetElementPtr(RHS)) {
Chris Lattnera21bf8d2005-04-25 20:17:30 +00002301 // If the base pointers are different, but the indices are the same, just
2302 // compare the base pointer.
2303 if (PtrBase != GEPRHS->getOperand(0)) {
2304 bool IndicesTheSame = GEPLHS->getNumOperands()==GEPRHS->getNumOperands();
Chris Lattnerbd43b9d2005-04-26 14:40:41 +00002305 IndicesTheSame &= GEPLHS->getOperand(0)->getType() ==
2306 GEPRHS->getOperand(0)->getType();
Chris Lattnera21bf8d2005-04-25 20:17:30 +00002307 if (IndicesTheSame)
2308 for (unsigned i = 1, e = GEPLHS->getNumOperands(); i != e; ++i)
2309 if (GEPLHS->getOperand(i) != GEPRHS->getOperand(i)) {
2310 IndicesTheSame = false;
2311 break;
2312 }
2313
2314 // If all indices are the same, just compare the base pointers.
2315 if (IndicesTheSame)
2316 return new SetCondInst(Cond, GEPLHS->getOperand(0),
2317 GEPRHS->getOperand(0));
2318
2319 // Otherwise, the base pointers are different and the indices are
2320 // different, bail out.
Chris Lattner0798af32005-01-13 20:14:25 +00002321 return 0;
Chris Lattnera21bf8d2005-04-25 20:17:30 +00002322 }
Chris Lattner0798af32005-01-13 20:14:25 +00002323
Chris Lattner81e84172005-01-13 22:25:21 +00002324 // If one of the GEPs has all zero indices, recurse.
2325 bool AllZeros = true;
2326 for (unsigned i = 1, e = GEPLHS->getNumOperands(); i != e; ++i)
2327 if (!isa<Constant>(GEPLHS->getOperand(i)) ||
2328 !cast<Constant>(GEPLHS->getOperand(i))->isNullValue()) {
2329 AllZeros = false;
2330 break;
2331 }
2332 if (AllZeros)
2333 return FoldGEPSetCC(GEPRHS, GEPLHS->getOperand(0),
2334 SetCondInst::getSwappedCondition(Cond), I);
Chris Lattner4fa89822005-01-14 00:20:05 +00002335
2336 // If the other GEP has all zero indices, recurse.
Chris Lattner81e84172005-01-13 22:25:21 +00002337 AllZeros = true;
2338 for (unsigned i = 1, e = GEPRHS->getNumOperands(); i != e; ++i)
2339 if (!isa<Constant>(GEPRHS->getOperand(i)) ||
2340 !cast<Constant>(GEPRHS->getOperand(i))->isNullValue()) {
2341 AllZeros = false;
2342 break;
2343 }
2344 if (AllZeros)
2345 return FoldGEPSetCC(GEPLHS, GEPRHS->getOperand(0), Cond, I);
2346
Chris Lattner4fa89822005-01-14 00:20:05 +00002347 if (GEPLHS->getNumOperands() == GEPRHS->getNumOperands()) {
2348 // If the GEPs only differ by one index, compare it.
2349 unsigned NumDifferences = 0; // Keep track of # differences.
2350 unsigned DiffOperand = 0; // The operand that differs.
2351 for (unsigned i = 1, e = GEPRHS->getNumOperands(); i != e; ++i)
2352 if (GEPLHS->getOperand(i) != GEPRHS->getOperand(i)) {
Chris Lattnerd1f46d32005-04-24 06:59:08 +00002353 if (GEPLHS->getOperand(i)->getType()->getPrimitiveSizeInBits() !=
2354 GEPRHS->getOperand(i)->getType()->getPrimitiveSizeInBits()) {
Chris Lattnerfc4429e2005-01-21 23:06:49 +00002355 // Irreconcilable differences.
Chris Lattner4fa89822005-01-14 00:20:05 +00002356 NumDifferences = 2;
2357 break;
2358 } else {
2359 if (NumDifferences++) break;
2360 DiffOperand = i;
2361 }
2362 }
2363
2364 if (NumDifferences == 0) // SAME GEP?
2365 return ReplaceInstUsesWith(I, // No comparison is needed here.
2366 ConstantBool::get(Cond == Instruction::SetEQ));
2367 else if (NumDifferences == 1) {
Chris Lattnerfc4429e2005-01-21 23:06:49 +00002368 Value *LHSV = GEPLHS->getOperand(DiffOperand);
2369 Value *RHSV = GEPRHS->getOperand(DiffOperand);
2370 if (LHSV->getType() != RHSV->getType())
2371 LHSV = InsertNewInstBefore(new CastInst(LHSV, RHSV->getType(),
2372 LHSV->getName()+".c"), I);
2373 return new SetCondInst(Cond, LHSV, RHSV);
Chris Lattner4fa89822005-01-14 00:20:05 +00002374 }
2375 }
2376
Chris Lattner0798af32005-01-13 20:14:25 +00002377 // Only lower this if the setcc is the only user of the GEP or if we expect
2378 // the result to fold to a constant!
2379 if ((isa<ConstantExpr>(GEPLHS) || GEPLHS->hasOneUse()) &&
2380 (isa<ConstantExpr>(GEPRHS) || GEPRHS->hasOneUse())) {
2381 // ((gep Ptr, OFFSET1) cmp (gep Ptr, OFFSET2) ---> (OFFSET1 cmp OFFSET2)
2382 Value *L = EmitGEPOffset(GEPLHS, I, *this);
2383 Value *R = EmitGEPOffset(GEPRHS, I, *this);
2384 return new SetCondInst(Cond, L, R);
2385 }
2386 }
2387 return 0;
2388}
2389
2390
Chris Lattnerd1f46d32005-04-24 06:59:08 +00002391Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) {
Chris Lattnerdcf240a2003-03-10 21:43:22 +00002392 bool Changed = SimplifyCommutative(I);
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002393 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
2394 const Type *Ty = Op0->getType();
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00002395
2396 // setcc X, X
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002397 if (Op0 == Op1)
2398 return ReplaceInstUsesWith(I, ConstantBool::get(isTrueWhenEqual(I)));
Chris Lattner1fc23f32002-05-09 20:11:54 +00002399
Chris Lattner81a7a232004-10-16 18:11:37 +00002400 if (isa<UndefValue>(Op1)) // X setcc undef -> undef
2401 return ReplaceInstUsesWith(I, UndefValue::get(Type::BoolTy));
2402
Chris Lattner15ff1e12004-11-14 07:33:16 +00002403 // setcc <global/alloca*/null>, <global/alloca*/null> - Global/Stack value
2404 // addresses never equal each other! We already know that Op0 != Op1.
Misha Brukmanb1c93172005-04-21 23:48:37 +00002405 if ((isa<GlobalValue>(Op0) || isa<AllocaInst>(Op0) ||
2406 isa<ConstantPointerNull>(Op0)) &&
2407 (isa<GlobalValue>(Op1) || isa<AllocaInst>(Op1) ||
Chris Lattner15ff1e12004-11-14 07:33:16 +00002408 isa<ConstantPointerNull>(Op1)))
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002409 return ReplaceInstUsesWith(I, ConstantBool::get(!isTrueWhenEqual(I)));
2410
2411 // setcc's with boolean values can always be turned into bitwise operations
2412 if (Ty == Type::BoolTy) {
Chris Lattner4456da62004-08-11 00:50:51 +00002413 switch (I.getOpcode()) {
2414 default: assert(0 && "Invalid setcc instruction!");
2415 case Instruction::SetEQ: { // seteq bool %A, %B -> ~(A^B)
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002416 Instruction *Xor = BinaryOperator::createXor(Op0, Op1, I.getName()+"tmp");
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002417 InsertNewInstBefore(Xor, I);
Chris Lattner16930792003-11-03 04:25:02 +00002418 return BinaryOperator::createNot(Xor);
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002419 }
Chris Lattner4456da62004-08-11 00:50:51 +00002420 case Instruction::SetNE:
2421 return BinaryOperator::createXor(Op0, Op1);
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002422
Chris Lattner4456da62004-08-11 00:50:51 +00002423 case Instruction::SetGT:
2424 std::swap(Op0, Op1); // Change setgt -> setlt
2425 // FALL THROUGH
2426 case Instruction::SetLT: { // setlt bool A, B -> ~X & Y
2427 Instruction *Not = BinaryOperator::createNot(Op0, I.getName()+"tmp");
2428 InsertNewInstBefore(Not, I);
2429 return BinaryOperator::createAnd(Not, Op1);
2430 }
2431 case Instruction::SetGE:
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002432 std::swap(Op0, Op1); // Change setge -> setle
Chris Lattner4456da62004-08-11 00:50:51 +00002433 // FALL THROUGH
2434 case Instruction::SetLE: { // setle bool %A, %B -> ~A | B
2435 Instruction *Not = BinaryOperator::createNot(Op0, I.getName()+"tmp");
2436 InsertNewInstBefore(Not, I);
2437 return BinaryOperator::createOr(Not, Op1);
2438 }
2439 }
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002440 }
2441
Chris Lattner2dd01742004-06-09 04:24:29 +00002442 // See if we are doing a comparison between a constant and an instruction that
2443 // can be folded into the comparison.
Chris Lattner6d14f2a2002-08-09 23:47:40 +00002444 if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
Chris Lattner6862fbd2004-09-29 17:40:11 +00002445 // Check to see if we are comparing against the minimum or maximum value...
2446 if (CI->isMinValue()) {
2447 if (I.getOpcode() == Instruction::SetLT) // A < MIN -> FALSE
2448 return ReplaceInstUsesWith(I, ConstantBool::False);
2449 if (I.getOpcode() == Instruction::SetGE) // A >= MIN -> TRUE
2450 return ReplaceInstUsesWith(I, ConstantBool::True);
2451 if (I.getOpcode() == Instruction::SetLE) // A <= MIN -> A == MIN
2452 return BinaryOperator::createSetEQ(Op0, Op1);
2453 if (I.getOpcode() == Instruction::SetGT) // A > MIN -> A != MIN
2454 return BinaryOperator::createSetNE(Op0, Op1);
2455
2456 } else if (CI->isMaxValue()) {
2457 if (I.getOpcode() == Instruction::SetGT) // A > MAX -> FALSE
2458 return ReplaceInstUsesWith(I, ConstantBool::False);
2459 if (I.getOpcode() == Instruction::SetLE) // A <= MAX -> TRUE
2460 return ReplaceInstUsesWith(I, ConstantBool::True);
2461 if (I.getOpcode() == Instruction::SetGE) // A >= MAX -> A == MAX
2462 return BinaryOperator::createSetEQ(Op0, Op1);
2463 if (I.getOpcode() == Instruction::SetLT) // A < MAX -> A != MAX
2464 return BinaryOperator::createSetNE(Op0, Op1);
2465
2466 // Comparing against a value really close to min or max?
2467 } else if (isMinValuePlusOne(CI)) {
2468 if (I.getOpcode() == Instruction::SetLT) // A < MIN+1 -> A == MIN
2469 return BinaryOperator::createSetEQ(Op0, SubOne(CI));
2470 if (I.getOpcode() == Instruction::SetGE) // A >= MIN-1 -> A != MIN
2471 return BinaryOperator::createSetNE(Op0, SubOne(CI));
2472
2473 } else if (isMaxValueMinusOne(CI)) {
2474 if (I.getOpcode() == Instruction::SetGT) // A > MAX-1 -> A == MAX
2475 return BinaryOperator::createSetEQ(Op0, AddOne(CI));
2476 if (I.getOpcode() == Instruction::SetLE) // A <= MAX-1 -> A != MAX
2477 return BinaryOperator::createSetNE(Op0, AddOne(CI));
2478 }
2479
2480 // If we still have a setle or setge instruction, turn it into the
2481 // appropriate setlt or setgt instruction. Since the border cases have
2482 // already been handled above, this requires little checking.
2483 //
2484 if (I.getOpcode() == Instruction::SetLE)
2485 return BinaryOperator::createSetLT(Op0, AddOne(CI));
2486 if (I.getOpcode() == Instruction::SetGE)
2487 return BinaryOperator::createSetGT(Op0, SubOne(CI));
2488
Chris Lattnere1e10e12004-05-25 06:32:08 +00002489 if (Instruction *LHSI = dyn_cast<Instruction>(Op0))
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002490 switch (LHSI->getOpcode()) {
2491 case Instruction::And:
2492 if (LHSI->hasOneUse() && isa<ConstantInt>(LHSI->getOperand(1)) &&
2493 LHSI->getOperand(0)->hasOneUse()) {
2494 // If this is: (X >> C1) & C2 != C3 (where any shift and any compare
2495 // could exist), turn it into (X & (C2 << C1)) != (C3 << C1). This
2496 // happens a LOT in code produced by the C front-end, for bitfield
2497 // access.
2498 ShiftInst *Shift = dyn_cast<ShiftInst>(LHSI->getOperand(0));
2499 ConstantUInt *ShAmt;
2500 ShAmt = Shift ? dyn_cast<ConstantUInt>(Shift->getOperand(1)) : 0;
2501 ConstantInt *AndCST = cast<ConstantInt>(LHSI->getOperand(1));
2502 const Type *Ty = LHSI->getType();
Misha Brukmanb1c93172005-04-21 23:48:37 +00002503
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002504 // We can fold this as long as we can't shift unknown bits
2505 // into the mask. This can only happen with signed shift
2506 // rights, as they sign-extend.
2507 if (ShAmt) {
2508 bool CanFold = Shift->getOpcode() != Instruction::Shr ||
Chris Lattner6afc02f2004-09-28 17:54:07 +00002509 Shift->getType()->isUnsigned();
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002510 if (!CanFold) {
2511 // To test for the bad case of the signed shr, see if any
2512 // of the bits shifted in could be tested after the mask.
Chris Lattnerc53cb9d2005-06-17 01:29:28 +00002513 int ShAmtVal = Ty->getPrimitiveSizeInBits()-ShAmt->getValue();
2514 if (ShAmtVal < 0) ShAmtVal = 0; // Out of range shift.
2515
2516 Constant *OShAmt = ConstantUInt::get(Type::UByteTy, ShAmtVal);
Misha Brukmanb1c93172005-04-21 23:48:37 +00002517 Constant *ShVal =
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002518 ConstantExpr::getShl(ConstantInt::getAllOnesValue(Ty), OShAmt);
2519 if (ConstantExpr::getAnd(ShVal, AndCST)->isNullValue())
2520 CanFold = true;
2521 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00002522
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002523 if (CanFold) {
Chris Lattner6afc02f2004-09-28 17:54:07 +00002524 Constant *NewCst;
2525 if (Shift->getOpcode() == Instruction::Shl)
2526 NewCst = ConstantExpr::getUShr(CI, ShAmt);
2527 else
2528 NewCst = ConstantExpr::getShl(CI, ShAmt);
Chris Lattnerbfff18a2004-09-27 19:29:18 +00002529
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002530 // Check to see if we are shifting out any of the bits being
2531 // compared.
2532 if (ConstantExpr::get(Shift->getOpcode(), NewCst, ShAmt) != CI){
2533 // If we shifted bits out, the fold is not going to work out.
2534 // As a special case, check to see if this means that the
2535 // result is always true or false now.
2536 if (I.getOpcode() == Instruction::SetEQ)
2537 return ReplaceInstUsesWith(I, ConstantBool::False);
2538 if (I.getOpcode() == Instruction::SetNE)
2539 return ReplaceInstUsesWith(I, ConstantBool::True);
2540 } else {
2541 I.setOperand(1, NewCst);
Chris Lattner6afc02f2004-09-28 17:54:07 +00002542 Constant *NewAndCST;
2543 if (Shift->getOpcode() == Instruction::Shl)
2544 NewAndCST = ConstantExpr::getUShr(AndCST, ShAmt);
2545 else
2546 NewAndCST = ConstantExpr::getShl(AndCST, ShAmt);
2547 LHSI->setOperand(1, NewAndCST);
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002548 LHSI->setOperand(0, Shift->getOperand(0));
2549 WorkList.push_back(Shift); // Shift is dead.
2550 AddUsesToWorkList(I);
2551 return &I;
Chris Lattner1638de42004-07-21 19:50:44 +00002552 }
2553 }
Chris Lattner35167c32004-06-09 07:59:58 +00002554 }
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002555 }
2556 break;
Chris Lattnerbfff18a2004-09-27 19:29:18 +00002557
Chris Lattner272d5ca2004-09-28 18:22:15 +00002558 case Instruction::Shl: // (setcc (shl X, ShAmt), CI)
2559 if (ConstantUInt *ShAmt = dyn_cast<ConstantUInt>(LHSI->getOperand(1))) {
2560 switch (I.getOpcode()) {
2561 default: break;
2562 case Instruction::SetEQ:
2563 case Instruction::SetNE: {
Chris Lattner19b57f52005-06-15 20:53:31 +00002564 unsigned TypeBits = CI->getType()->getPrimitiveSizeInBits();
2565
2566 // Check that the shift amount is in range. If not, don't perform
2567 // undefined shifts. When the shift is visited it will be
2568 // simplified.
2569 if (ShAmt->getValue() >= TypeBits)
2570 break;
2571
Chris Lattner272d5ca2004-09-28 18:22:15 +00002572 // If we are comparing against bits always shifted out, the
2573 // comparison cannot succeed.
Misha Brukmanb1c93172005-04-21 23:48:37 +00002574 Constant *Comp =
Chris Lattner272d5ca2004-09-28 18:22:15 +00002575 ConstantExpr::getShl(ConstantExpr::getShr(CI, ShAmt), ShAmt);
2576 if (Comp != CI) {// Comparing against a bit that we know is zero.
2577 bool IsSetNE = I.getOpcode() == Instruction::SetNE;
2578 Constant *Cst = ConstantBool::get(IsSetNE);
2579 return ReplaceInstUsesWith(I, Cst);
2580 }
2581
2582 if (LHSI->hasOneUse()) {
2583 // Otherwise strength reduce the shift into an and.
Chris Lattnerfdfe3e492005-01-08 19:42:22 +00002584 unsigned ShAmtVal = (unsigned)ShAmt->getValue();
Chris Lattner272d5ca2004-09-28 18:22:15 +00002585 uint64_t Val = (1ULL << (TypeBits-ShAmtVal))-1;
2586
2587 Constant *Mask;
2588 if (CI->getType()->isUnsigned()) {
2589 Mask = ConstantUInt::get(CI->getType(), Val);
2590 } else if (ShAmtVal != 0) {
2591 Mask = ConstantSInt::get(CI->getType(), Val);
2592 } else {
2593 Mask = ConstantInt::getAllOnesValue(CI->getType());
2594 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00002595
Chris Lattner272d5ca2004-09-28 18:22:15 +00002596 Instruction *AndI =
2597 BinaryOperator::createAnd(LHSI->getOperand(0),
2598 Mask, LHSI->getName()+".mask");
2599 Value *And = InsertNewInstBefore(AndI, I);
2600 return new SetCondInst(I.getOpcode(), And,
2601 ConstantExpr::getUShr(CI, ShAmt));
2602 }
2603 }
2604 }
2605 }
2606 break;
2607
Chris Lattnerbfff18a2004-09-27 19:29:18 +00002608 case Instruction::Shr: // (setcc (shr X, ShAmt), CI)
Chris Lattner1023b872004-09-27 16:18:50 +00002609 if (ConstantUInt *ShAmt = dyn_cast<ConstantUInt>(LHSI->getOperand(1))) {
Chris Lattner1023b872004-09-27 16:18:50 +00002610 switch (I.getOpcode()) {
2611 default: break;
2612 case Instruction::SetEQ:
2613 case Instruction::SetNE: {
Chris Lattner19b57f52005-06-15 20:53:31 +00002614
2615 // Check that the shift amount is in range. If not, don't perform
2616 // undefined shifts. When the shift is visited it will be
2617 // simplified.
Chris Lattner104002b2005-06-16 01:52:07 +00002618 unsigned TypeBits = CI->getType()->getPrimitiveSizeInBits();
Chris Lattner19b57f52005-06-15 20:53:31 +00002619 if (ShAmt->getValue() >= TypeBits)
2620 break;
2621
Chris Lattner1023b872004-09-27 16:18:50 +00002622 // If we are comparing against bits always shifted out, the
2623 // comparison cannot succeed.
Misha Brukmanb1c93172005-04-21 23:48:37 +00002624 Constant *Comp =
Chris Lattner1023b872004-09-27 16:18:50 +00002625 ConstantExpr::getShr(ConstantExpr::getShl(CI, ShAmt), ShAmt);
Misha Brukmanb1c93172005-04-21 23:48:37 +00002626
Chris Lattner1023b872004-09-27 16:18:50 +00002627 if (Comp != CI) {// Comparing against a bit that we know is zero.
2628 bool IsSetNE = I.getOpcode() == Instruction::SetNE;
2629 Constant *Cst = ConstantBool::get(IsSetNE);
2630 return ReplaceInstUsesWith(I, Cst);
2631 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00002632
Chris Lattner1023b872004-09-27 16:18:50 +00002633 if (LHSI->hasOneUse() || CI->isNullValue()) {
Chris Lattnerfdfe3e492005-01-08 19:42:22 +00002634 unsigned ShAmtVal = (unsigned)ShAmt->getValue();
Chris Lattner272d5ca2004-09-28 18:22:15 +00002635
Chris Lattner1023b872004-09-27 16:18:50 +00002636 // Otherwise strength reduce the shift into an and.
2637 uint64_t Val = ~0ULL; // All ones.
2638 Val <<= ShAmtVal; // Shift over to the right spot.
2639
2640 Constant *Mask;
2641 if (CI->getType()->isUnsigned()) {
Chris Lattner2f1457f2005-04-24 17:46:05 +00002642 Val &= ~0ULL >> (64-TypeBits);
Chris Lattner1023b872004-09-27 16:18:50 +00002643 Mask = ConstantUInt::get(CI->getType(), Val);
2644 } else {
2645 Mask = ConstantSInt::get(CI->getType(), Val);
2646 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00002647
Chris Lattner1023b872004-09-27 16:18:50 +00002648 Instruction *AndI =
2649 BinaryOperator::createAnd(LHSI->getOperand(0),
2650 Mask, LHSI->getName()+".mask");
2651 Value *And = InsertNewInstBefore(AndI, I);
2652 return new SetCondInst(I.getOpcode(), And,
2653 ConstantExpr::getShl(CI, ShAmt));
2654 }
2655 break;
2656 }
2657 }
2658 }
2659 break;
Chris Lattner7e794272004-09-24 15:21:34 +00002660
Chris Lattner6862fbd2004-09-29 17:40:11 +00002661 case Instruction::Div:
2662 // Fold: (div X, C1) op C2 -> range check
2663 if (ConstantInt *DivRHS = dyn_cast<ConstantInt>(LHSI->getOperand(1))) {
2664 // Fold this div into the comparison, producing a range check.
2665 // Determine, based on the divide type, what the range is being
2666 // checked. If there is an overflow on the low or high side, remember
2667 // it, otherwise compute the range [low, hi) bounding the new value.
2668 bool LoOverflow = false, HiOverflow = 0;
2669 ConstantInt *LoBound = 0, *HiBound = 0;
2670
2671 ConstantInt *Prod;
2672 bool ProdOV = MulWithOverflow(Prod, CI, DivRHS);
2673
Chris Lattnera92af962004-10-11 19:40:04 +00002674 Instruction::BinaryOps Opcode = I.getOpcode();
2675
Chris Lattner6862fbd2004-09-29 17:40:11 +00002676 if (DivRHS->isNullValue()) { // Don't hack on divide by zeros.
2677 } else if (LHSI->getType()->isUnsigned()) { // udiv
2678 LoBound = Prod;
2679 LoOverflow = ProdOV;
2680 HiOverflow = ProdOV || AddWithOverflow(HiBound, LoBound, DivRHS);
2681 } else if (isPositive(DivRHS)) { // Divisor is > 0.
2682 if (CI->isNullValue()) { // (X / pos) op 0
2683 // Can't overflow.
2684 LoBound = cast<ConstantInt>(ConstantExpr::getNeg(SubOne(DivRHS)));
2685 HiBound = DivRHS;
2686 } else if (isPositive(CI)) { // (X / pos) op pos
2687 LoBound = Prod;
2688 LoOverflow = ProdOV;
2689 HiOverflow = ProdOV || AddWithOverflow(HiBound, Prod, DivRHS);
2690 } else { // (X / pos) op neg
2691 Constant *DivRHSH = ConstantExpr::getNeg(SubOne(DivRHS));
2692 LoOverflow = AddWithOverflow(LoBound, Prod,
2693 cast<ConstantInt>(DivRHSH));
2694 HiBound = Prod;
2695 HiOverflow = ProdOV;
2696 }
2697 } else { // Divisor is < 0.
2698 if (CI->isNullValue()) { // (X / neg) op 0
2699 LoBound = AddOne(DivRHS);
2700 HiBound = cast<ConstantInt>(ConstantExpr::getNeg(DivRHS));
Chris Lattner73bcba52005-06-17 02:05:55 +00002701 if (HiBound == DivRHS)
2702 LoBound = 0; // - INTMIN = INTMIN
Chris Lattner6862fbd2004-09-29 17:40:11 +00002703 } else if (isPositive(CI)) { // (X / neg) op pos
2704 HiOverflow = LoOverflow = ProdOV;
2705 if (!LoOverflow)
2706 LoOverflow = AddWithOverflow(LoBound, Prod, AddOne(DivRHS));
2707 HiBound = AddOne(Prod);
2708 } else { // (X / neg) op neg
2709 LoBound = Prod;
2710 LoOverflow = HiOverflow = ProdOV;
2711 HiBound = cast<ConstantInt>(ConstantExpr::getSub(Prod, DivRHS));
2712 }
Chris Lattner0b41e862004-10-08 19:15:44 +00002713
Chris Lattnera92af962004-10-11 19:40:04 +00002714 // Dividing by a negate swaps the condition.
2715 Opcode = SetCondInst::getSwappedCondition(Opcode);
Chris Lattner6862fbd2004-09-29 17:40:11 +00002716 }
2717
2718 if (LoBound) {
2719 Value *X = LHSI->getOperand(0);
Chris Lattnera92af962004-10-11 19:40:04 +00002720 switch (Opcode) {
Chris Lattner6862fbd2004-09-29 17:40:11 +00002721 default: assert(0 && "Unhandled setcc opcode!");
2722 case Instruction::SetEQ:
2723 if (LoOverflow && HiOverflow)
2724 return ReplaceInstUsesWith(I, ConstantBool::False);
2725 else if (HiOverflow)
2726 return new SetCondInst(Instruction::SetGE, X, LoBound);
2727 else if (LoOverflow)
2728 return new SetCondInst(Instruction::SetLT, X, HiBound);
2729 else
2730 return InsertRangeTest(X, LoBound, HiBound, true, I);
2731 case Instruction::SetNE:
2732 if (LoOverflow && HiOverflow)
2733 return ReplaceInstUsesWith(I, ConstantBool::True);
2734 else if (HiOverflow)
2735 return new SetCondInst(Instruction::SetLT, X, LoBound);
2736 else if (LoOverflow)
2737 return new SetCondInst(Instruction::SetGE, X, HiBound);
2738 else
2739 return InsertRangeTest(X, LoBound, HiBound, false, I);
2740 case Instruction::SetLT:
2741 if (LoOverflow)
2742 return ReplaceInstUsesWith(I, ConstantBool::False);
2743 return new SetCondInst(Instruction::SetLT, X, LoBound);
2744 case Instruction::SetGT:
2745 if (HiOverflow)
2746 return ReplaceInstUsesWith(I, ConstantBool::False);
2747 return new SetCondInst(Instruction::SetGE, X, HiBound);
2748 }
2749 }
2750 }
2751 break;
Chris Lattnere1b4d2a2004-09-23 21:52:49 +00002752 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00002753
Chris Lattnerd492a0b2003-07-23 17:02:11 +00002754 // Simplify seteq and setne instructions...
2755 if (I.getOpcode() == Instruction::SetEQ ||
2756 I.getOpcode() == Instruction::SetNE) {
2757 bool isSetNE = I.getOpcode() == Instruction::SetNE;
2758
Chris Lattnercfbce7c2003-07-23 17:26:36 +00002759 // If the first operand is (and|or|xor) with a constant, and the second
Chris Lattnerd492a0b2003-07-23 17:02:11 +00002760 // operand is a constant, simplify a bit.
Chris Lattnerc992add2003-08-13 05:33:12 +00002761 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Op0)) {
2762 switch (BO->getOpcode()) {
Chris Lattner23b47b62004-07-06 07:38:18 +00002763 case Instruction::Rem:
2764 // If we have a signed (X % (2^c)) == 0, turn it into an unsigned one.
2765 if (CI->isNullValue() && isa<ConstantSInt>(BO->getOperand(1)) &&
2766 BO->hasOneUse() &&
2767 cast<ConstantSInt>(BO->getOperand(1))->getValue() > 1)
2768 if (unsigned L2 =
2769 Log2(cast<ConstantSInt>(BO->getOperand(1))->getValue())) {
2770 const Type *UTy = BO->getType()->getUnsignedVersion();
2771 Value *NewX = InsertNewInstBefore(new CastInst(BO->getOperand(0),
2772 UTy, "tmp"), I);
2773 Constant *RHSCst = ConstantUInt::get(UTy, 1ULL << L2);
2774 Value *NewRem =InsertNewInstBefore(BinaryOperator::createRem(NewX,
2775 RHSCst, BO->getName()), I);
2776 return BinaryOperator::create(I.getOpcode(), NewRem,
2777 Constant::getNullValue(UTy));
2778 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00002779 break;
Chris Lattner23b47b62004-07-06 07:38:18 +00002780
Chris Lattnerc992add2003-08-13 05:33:12 +00002781 case Instruction::Add:
Chris Lattner6e079362004-06-27 22:51:36 +00002782 // Replace ((add A, B) != C) with (A != C-B) if B & C are constants.
2783 if (ConstantInt *BOp1C = dyn_cast<ConstantInt>(BO->getOperand(1))) {
Chris Lattnerb121ae12004-09-21 21:35:23 +00002784 if (BO->hasOneUse())
2785 return new SetCondInst(I.getOpcode(), BO->getOperand(0),
2786 ConstantExpr::getSub(CI, BOp1C));
Chris Lattner6e079362004-06-27 22:51:36 +00002787 } else if (CI->isNullValue()) {
Chris Lattnerc992add2003-08-13 05:33:12 +00002788 // Replace ((add A, B) != 0) with (A != -B) if A or B is
2789 // efficiently invertible, or if the add has just this one use.
2790 Value *BOp0 = BO->getOperand(0), *BOp1 = BO->getOperand(1);
Misha Brukmanb1c93172005-04-21 23:48:37 +00002791
Chris Lattnerc992add2003-08-13 05:33:12 +00002792 if (Value *NegVal = dyn_castNegVal(BOp1))
2793 return new SetCondInst(I.getOpcode(), BOp0, NegVal);
2794 else if (Value *NegVal = dyn_castNegVal(BOp0))
2795 return new SetCondInst(I.getOpcode(), NegVal, BOp1);
Chris Lattnerf95d9b92003-10-15 16:48:29 +00002796 else if (BO->hasOneUse()) {
Chris Lattnerc992add2003-08-13 05:33:12 +00002797 Instruction *Neg = BinaryOperator::createNeg(BOp1, BO->getName());
2798 BO->setName("");
2799 InsertNewInstBefore(Neg, I);
2800 return new SetCondInst(I.getOpcode(), BOp0, Neg);
2801 }
2802 }
2803 break;
2804 case Instruction::Xor:
2805 // For the xor case, we can xor two constants together, eliminating
2806 // the explicit xor.
2807 if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1)))
2808 return BinaryOperator::create(I.getOpcode(), BO->getOperand(0),
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002809 ConstantExpr::getXor(CI, BOC));
Chris Lattnerc992add2003-08-13 05:33:12 +00002810
2811 // FALLTHROUGH
2812 case Instruction::Sub:
2813 // Replace (([sub|xor] A, B) != 0) with (A != B)
2814 if (CI->isNullValue())
2815 return new SetCondInst(I.getOpcode(), BO->getOperand(0),
2816 BO->getOperand(1));
2817 break;
2818
2819 case Instruction::Or:
2820 // If bits are being or'd in that are not present in the constant we
2821 // are comparing against, then the comparison could never succeed!
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00002822 if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1))) {
Chris Lattnerc8e7e292004-06-10 02:12:35 +00002823 Constant *NotCI = ConstantExpr::getNot(CI);
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002824 if (!ConstantExpr::getAnd(BOC, NotCI)->isNullValue())
Chris Lattnerd492a0b2003-07-23 17:02:11 +00002825 return ReplaceInstUsesWith(I, ConstantBool::get(isSetNE));
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00002826 }
Chris Lattnerc992add2003-08-13 05:33:12 +00002827 break;
2828
2829 case Instruction::And:
2830 if (ConstantInt *BOC = dyn_cast<ConstantInt>(BO->getOperand(1))) {
Chris Lattnerd492a0b2003-07-23 17:02:11 +00002831 // If bits are being compared against that are and'd out, then the
2832 // comparison can never succeed!
Chris Lattnerc8e7e292004-06-10 02:12:35 +00002833 if (!ConstantExpr::getAnd(CI,
2834 ConstantExpr::getNot(BOC))->isNullValue())
Chris Lattnerd492a0b2003-07-23 17:02:11 +00002835 return ReplaceInstUsesWith(I, ConstantBool::get(isSetNE));
Chris Lattnerc992add2003-08-13 05:33:12 +00002836
Chris Lattner35167c32004-06-09 07:59:58 +00002837 // If we have ((X & C) == C), turn it into ((X & C) != 0).
Chris Lattneree59d4b2004-06-10 02:33:20 +00002838 if (CI == BOC && isOneBitSet(CI))
Chris Lattner35167c32004-06-09 07:59:58 +00002839 return new SetCondInst(isSetNE ? Instruction::SetEQ :
2840 Instruction::SetNE, Op0,
2841 Constant::getNullValue(CI->getType()));
Chris Lattner35167c32004-06-09 07:59:58 +00002842
Chris Lattnerc992add2003-08-13 05:33:12 +00002843 // Replace (and X, (1 << size(X)-1) != 0) with x < 0, converting X
2844 // to be a signed value as appropriate.
2845 if (isSignBit(BOC)) {
2846 Value *X = BO->getOperand(0);
2847 // If 'X' is not signed, insert a cast now...
2848 if (!BOC->getType()->isSigned()) {
Chris Lattner97bfcea2004-06-17 18:16:02 +00002849 const Type *DestTy = BOC->getType()->getSignedVersion();
Chris Lattnerbfff18a2004-09-27 19:29:18 +00002850 X = InsertCastBefore(X, DestTy, I);
Chris Lattnerc992add2003-08-13 05:33:12 +00002851 }
2852 return new SetCondInst(isSetNE ? Instruction::SetLT :
2853 Instruction::SetGE, X,
2854 Constant::getNullValue(X->getType()));
2855 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00002856
Chris Lattnerbfff18a2004-09-27 19:29:18 +00002857 // ((X & ~7) == 0) --> X < 8
Chris Lattner8fc5af42004-09-23 21:46:38 +00002858 if (CI->isNullValue() && isHighOnes(BOC)) {
2859 Value *X = BO->getOperand(0);
Chris Lattnerbfff18a2004-09-27 19:29:18 +00002860 Constant *NegX = ConstantExpr::getNeg(BOC);
Chris Lattner8fc5af42004-09-23 21:46:38 +00002861
2862 // If 'X' is signed, insert a cast now.
Chris Lattnerbfff18a2004-09-27 19:29:18 +00002863 if (NegX->getType()->isSigned()) {
2864 const Type *DestTy = NegX->getType()->getUnsignedVersion();
2865 X = InsertCastBefore(X, DestTy, I);
2866 NegX = ConstantExpr::getCast(NegX, DestTy);
Chris Lattner8fc5af42004-09-23 21:46:38 +00002867 }
2868
2869 return new SetCondInst(isSetNE ? Instruction::SetGE :
Chris Lattnerbfff18a2004-09-27 19:29:18 +00002870 Instruction::SetLT, X, NegX);
Chris Lattner8fc5af42004-09-23 21:46:38 +00002871 }
2872
Chris Lattnerd492a0b2003-07-23 17:02:11 +00002873 }
Chris Lattnerc992add2003-08-13 05:33:12 +00002874 default: break;
2875 }
2876 }
Chris Lattner2b55ea32004-02-23 07:16:20 +00002877 } else { // Not a SetEQ/SetNE
Misha Brukmanb1c93172005-04-21 23:48:37 +00002878 // If the LHS is a cast from an integral value of the same size,
Chris Lattner2b55ea32004-02-23 07:16:20 +00002879 if (CastInst *Cast = dyn_cast<CastInst>(Op0)) {
2880 Value *CastOp = Cast->getOperand(0);
2881 const Type *SrcTy = CastOp->getType();
Chris Lattnerd1f46d32005-04-24 06:59:08 +00002882 unsigned SrcTySize = SrcTy->getPrimitiveSizeInBits();
Chris Lattner2b55ea32004-02-23 07:16:20 +00002883 if (SrcTy != Cast->getType() && SrcTy->isInteger() &&
Chris Lattnerd1f46d32005-04-24 06:59:08 +00002884 SrcTySize == Cast->getType()->getPrimitiveSizeInBits()) {
Misha Brukmanb1c93172005-04-21 23:48:37 +00002885 assert((SrcTy->isSigned() ^ Cast->getType()->isSigned()) &&
Chris Lattner2b55ea32004-02-23 07:16:20 +00002886 "Source and destination signednesses should differ!");
2887 if (Cast->getType()->isSigned()) {
2888 // If this is a signed comparison, check for comparisons in the
2889 // vicinity of zero.
2890 if (I.getOpcode() == Instruction::SetLT && CI->isNullValue())
2891 // X < 0 => x > 127
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002892 return BinaryOperator::createSetGT(CastOp,
Chris Lattnerd1f46d32005-04-24 06:59:08 +00002893 ConstantUInt::get(SrcTy, (1ULL << (SrcTySize-1))-1));
Chris Lattner2b55ea32004-02-23 07:16:20 +00002894 else if (I.getOpcode() == Instruction::SetGT &&
2895 cast<ConstantSInt>(CI)->getValue() == -1)
2896 // X > -1 => x < 128
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002897 return BinaryOperator::createSetLT(CastOp,
Chris Lattnerd1f46d32005-04-24 06:59:08 +00002898 ConstantUInt::get(SrcTy, 1ULL << (SrcTySize-1)));
Chris Lattner2b55ea32004-02-23 07:16:20 +00002899 } else {
2900 ConstantUInt *CUI = cast<ConstantUInt>(CI);
2901 if (I.getOpcode() == Instruction::SetLT &&
Chris Lattnerd1f46d32005-04-24 06:59:08 +00002902 CUI->getValue() == 1ULL << (SrcTySize-1))
Chris Lattner2b55ea32004-02-23 07:16:20 +00002903 // X < 128 => X > -1
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002904 return BinaryOperator::createSetGT(CastOp,
2905 ConstantSInt::get(SrcTy, -1));
Chris Lattner2b55ea32004-02-23 07:16:20 +00002906 else if (I.getOpcode() == Instruction::SetGT &&
Chris Lattnerd1f46d32005-04-24 06:59:08 +00002907 CUI->getValue() == (1ULL << (SrcTySize-1))-1)
Chris Lattner2b55ea32004-02-23 07:16:20 +00002908 // X > 127 => X < 0
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00002909 return BinaryOperator::createSetLT(CastOp,
2910 Constant::getNullValue(SrcTy));
Chris Lattner2b55ea32004-02-23 07:16:20 +00002911 }
2912 }
2913 }
Chris Lattnere967b342003-06-04 05:10:11 +00002914 }
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00002915 }
2916
Chris Lattner77c32c32005-04-23 15:31:55 +00002917 // Handle setcc with constant RHS's that can be integer, FP or pointer.
2918 if (Constant *RHSC = dyn_cast<Constant>(Op1)) {
2919 if (Instruction *LHSI = dyn_cast<Instruction>(Op0))
2920 switch (LHSI->getOpcode()) {
Chris Lattnera816eee2005-05-01 04:42:15 +00002921 case Instruction::GetElementPtr:
2922 if (RHSC->isNullValue()) {
2923 // Transform setcc GEP P, int 0, int 0, int 0, null -> setcc P, null
2924 bool isAllZeros = true;
2925 for (unsigned i = 1, e = LHSI->getNumOperands(); i != e; ++i)
2926 if (!isa<Constant>(LHSI->getOperand(i)) ||
2927 !cast<Constant>(LHSI->getOperand(i))->isNullValue()) {
2928 isAllZeros = false;
2929 break;
2930 }
2931 if (isAllZeros)
2932 return new SetCondInst(I.getOpcode(), LHSI->getOperand(0),
2933 Constant::getNullValue(LHSI->getOperand(0)->getType()));
2934 }
2935 break;
2936
Chris Lattner77c32c32005-04-23 15:31:55 +00002937 case Instruction::PHI:
2938 if (Instruction *NV = FoldOpIntoPhi(I))
2939 return NV;
2940 break;
2941 case Instruction::Select:
2942 // If either operand of the select is a constant, we can fold the
2943 // comparison into the select arms, which will cause one to be
2944 // constant folded and the select turned into a bitwise or.
2945 Value *Op1 = 0, *Op2 = 0;
2946 if (LHSI->hasOneUse()) {
2947 if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(1))) {
2948 // Fold the known value into the constant operand.
2949 Op1 = ConstantExpr::get(I.getOpcode(), C, RHSC);
2950 // Insert a new SetCC of the other select operand.
2951 Op2 = InsertNewInstBefore(new SetCondInst(I.getOpcode(),
2952 LHSI->getOperand(2), RHSC,
2953 I.getName()), I);
2954 } else if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(2))) {
2955 // Fold the known value into the constant operand.
2956 Op2 = ConstantExpr::get(I.getOpcode(), C, RHSC);
2957 // Insert a new SetCC of the other select operand.
2958 Op1 = InsertNewInstBefore(new SetCondInst(I.getOpcode(),
2959 LHSI->getOperand(1), RHSC,
2960 I.getName()), I);
2961 }
2962 }
Jeff Cohen82639852005-04-23 21:38:35 +00002963
Chris Lattner77c32c32005-04-23 15:31:55 +00002964 if (Op1)
2965 return new SelectInst(LHSI->getOperand(0), Op1, Op2);
2966 break;
2967 }
2968 }
2969
Chris Lattner0798af32005-01-13 20:14:25 +00002970 // If we can optimize a 'setcc GEP, P' or 'setcc P, GEP', do so now.
2971 if (User *GEP = dyn_castGetElementPtr(Op0))
2972 if (Instruction *NI = FoldGEPSetCC(GEP, Op1, I.getOpcode(), I))
2973 return NI;
2974 if (User *GEP = dyn_castGetElementPtr(Op1))
2975 if (Instruction *NI = FoldGEPSetCC(GEP, Op0,
2976 SetCondInst::getSwappedCondition(I.getOpcode()), I))
2977 return NI;
2978
Chris Lattner16930792003-11-03 04:25:02 +00002979 // Test to see if the operands of the setcc are casted versions of other
2980 // values. If the cast can be stripped off both arguments, we do so now.
Chris Lattner6444c372003-11-03 05:17:03 +00002981 if (CastInst *CI = dyn_cast<CastInst>(Op0)) {
2982 Value *CastOp0 = CI->getOperand(0);
2983 if (CastOp0->getType()->isLosslesslyConvertibleTo(CI->getType()) &&
Chris Lattner7d2a5392004-03-13 23:54:27 +00002984 (isa<Constant>(Op1) || isa<CastInst>(Op1)) &&
Chris Lattner16930792003-11-03 04:25:02 +00002985 (I.getOpcode() == Instruction::SetEQ ||
2986 I.getOpcode() == Instruction::SetNE)) {
2987 // We keep moving the cast from the left operand over to the right
2988 // operand, where it can often be eliminated completely.
Chris Lattner6444c372003-11-03 05:17:03 +00002989 Op0 = CastOp0;
Misha Brukmanb1c93172005-04-21 23:48:37 +00002990
Chris Lattner16930792003-11-03 04:25:02 +00002991 // If operand #1 is a cast instruction, see if we can eliminate it as
2992 // well.
Chris Lattner6444c372003-11-03 05:17:03 +00002993 if (CastInst *CI2 = dyn_cast<CastInst>(Op1))
2994 if (CI2->getOperand(0)->getType()->isLosslesslyConvertibleTo(
Chris Lattner16930792003-11-03 04:25:02 +00002995 Op0->getType()))
Chris Lattner6444c372003-11-03 05:17:03 +00002996 Op1 = CI2->getOperand(0);
Misha Brukmanb1c93172005-04-21 23:48:37 +00002997
Chris Lattner16930792003-11-03 04:25:02 +00002998 // If Op1 is a constant, we can fold the cast into the constant.
2999 if (Op1->getType() != Op0->getType())
3000 if (Constant *Op1C = dyn_cast<Constant>(Op1)) {
3001 Op1 = ConstantExpr::getCast(Op1C, Op0->getType());
3002 } else {
3003 // Otherwise, cast the RHS right before the setcc
3004 Op1 = new CastInst(Op1, Op0->getType(), Op1->getName());
3005 InsertNewInstBefore(cast<Instruction>(Op1), I);
3006 }
3007 return BinaryOperator::create(I.getOpcode(), Op0, Op1);
3008 }
3009
Chris Lattner6444c372003-11-03 05:17:03 +00003010 // Handle the special case of: setcc (cast bool to X), <cst>
3011 // This comes up when you have code like
3012 // int X = A < B;
3013 // if (X) ...
3014 // For generality, we handle any zero-extension of any operand comparison
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003015 // with a constant or another cast from the same type.
3016 if (isa<ConstantInt>(Op1) || isa<CastInst>(Op1))
3017 if (Instruction *R = visitSetCondInstWithCastAndCast(I))
3018 return R;
Chris Lattner6444c372003-11-03 05:17:03 +00003019 }
Chris Lattner113f4f42002-06-25 16:13:24 +00003020 return Changed ? &I : 0;
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003021}
3022
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003023// visitSetCondInstWithCastAndCast - Handle setcond (cast x to y), (cast/cst).
3024// We only handle extending casts so far.
3025//
3026Instruction *InstCombiner::visitSetCondInstWithCastAndCast(SetCondInst &SCI) {
3027 Value *LHSCIOp = cast<CastInst>(SCI.getOperand(0))->getOperand(0);
3028 const Type *SrcTy = LHSCIOp->getType();
3029 const Type *DestTy = SCI.getOperand(0)->getType();
3030 Value *RHSCIOp;
3031
3032 if (!DestTy->isIntegral() || !SrcTy->isIntegral())
Chris Lattner03f06f12005-01-17 03:20:02 +00003033 return 0;
3034
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003035 unsigned SrcBits = SrcTy->getPrimitiveSizeInBits();
3036 unsigned DestBits = DestTy->getPrimitiveSizeInBits();
3037 if (SrcBits >= DestBits) return 0; // Only handle extending cast.
3038
3039 // Is this a sign or zero extension?
3040 bool isSignSrc = SrcTy->isSigned();
3041 bool isSignDest = DestTy->isSigned();
3042
3043 if (CastInst *CI = dyn_cast<CastInst>(SCI.getOperand(1))) {
3044 // Not an extension from the same type?
3045 RHSCIOp = CI->getOperand(0);
3046 if (RHSCIOp->getType() != LHSCIOp->getType()) return 0;
3047 } else if (ConstantInt *CI = dyn_cast<ConstantInt>(SCI.getOperand(1))) {
3048 // Compute the constant that would happen if we truncated to SrcTy then
3049 // reextended to DestTy.
3050 Constant *Res = ConstantExpr::getCast(CI, SrcTy);
3051
3052 if (ConstantExpr::getCast(Res, DestTy) == CI) {
3053 RHSCIOp = Res;
3054 } else {
3055 // If the value cannot be represented in the shorter type, we cannot emit
3056 // a simple comparison.
3057 if (SCI.getOpcode() == Instruction::SetEQ)
3058 return ReplaceInstUsesWith(SCI, ConstantBool::False);
3059 if (SCI.getOpcode() == Instruction::SetNE)
3060 return ReplaceInstUsesWith(SCI, ConstantBool::True);
3061
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003062 // Evaluate the comparison for LT.
3063 Value *Result;
3064 if (DestTy->isSigned()) {
3065 // We're performing a signed comparison.
3066 if (isSignSrc) {
3067 // Signed extend and signed comparison.
3068 if (cast<ConstantSInt>(CI)->getValue() < 0) // X < (small) --> false
3069 Result = ConstantBool::False;
3070 else
3071 Result = ConstantBool::True; // X < (large) --> true
3072 } else {
3073 // Unsigned extend and signed comparison.
3074 if (cast<ConstantSInt>(CI)->getValue() < 0)
3075 Result = ConstantBool::False;
3076 else
3077 Result = ConstantBool::True;
3078 }
3079 } else {
3080 // We're performing an unsigned comparison.
3081 if (!isSignSrc) {
3082 // Unsigned extend & compare -> always true.
3083 Result = ConstantBool::True;
3084 } else {
3085 // We're performing an unsigned comp with a sign extended value.
3086 // This is true if the input is >= 0. [aka >s -1]
3087 Constant *NegOne = ConstantIntegral::getAllOnesValue(SrcTy);
3088 Result = InsertNewInstBefore(BinaryOperator::createSetGT(LHSCIOp,
3089 NegOne, SCI.getName()), SCI);
3090 }
Reid Spencer279fa252004-11-28 21:31:15 +00003091 }
Chris Lattner03f06f12005-01-17 03:20:02 +00003092
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003093 // Finally, return the value computed.
3094 if (SCI.getOpcode() == Instruction::SetLT) {
3095 return ReplaceInstUsesWith(SCI, Result);
3096 } else {
3097 assert(SCI.getOpcode()==Instruction::SetGT &&"SetCC should be folded!");
3098 if (Constant *CI = dyn_cast<Constant>(Result))
3099 return ReplaceInstUsesWith(SCI, ConstantExpr::getNot(CI));
3100 else
3101 return BinaryOperator::createNot(Result);
3102 }
Chris Lattner03f06f12005-01-17 03:20:02 +00003103 }
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003104 } else {
3105 return 0;
Reid Spencer279fa252004-11-28 21:31:15 +00003106 }
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003107
Chris Lattner252a8452005-06-16 03:00:08 +00003108 // Okay, just insert a compare of the reduced operands now!
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003109 return BinaryOperator::create(SCI.getOpcode(), LHSCIOp, RHSCIOp);
3110}
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003111
Chris Lattnere8d6c602003-03-10 19:16:08 +00003112Instruction *InstCombiner::visitShiftInst(ShiftInst &I) {
Chris Lattner113f4f42002-06-25 16:13:24 +00003113 assert(I.getOperand(1)->getType() == Type::UByteTy);
3114 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003115 bool isLeftShift = I.getOpcode() == Instruction::Shl;
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003116
3117 // shl X, 0 == X and shr X, 0 == X
3118 // shl 0, X == 0 and shr 0, X == 0
3119 if (Op1 == Constant::getNullValue(Type::UByteTy) ||
Chris Lattnere6794492002-08-12 21:17:25 +00003120 Op0 == Constant::getNullValue(Op0->getType()))
3121 return ReplaceInstUsesWith(I, Op0);
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003122
Chris Lattner81a7a232004-10-16 18:11:37 +00003123 if (isa<UndefValue>(Op0)) { // undef >>s X -> undef
3124 if (!isLeftShift && I.getType()->isSigned())
Chris Lattner67f05452004-10-16 23:28:04 +00003125 return ReplaceInstUsesWith(I, Op0);
Chris Lattner81a7a232004-10-16 18:11:37 +00003126 else // undef << X -> 0 AND undef >>u X -> 0
3127 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
3128 }
3129 if (isa<UndefValue>(Op1)) {
3130 if (isLeftShift || I.getType()->isUnsigned())
3131 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
3132 else
3133 return ReplaceInstUsesWith(I, Op0); // X >>s undef -> X
3134 }
3135
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003136 // shr int -1, X = -1 (for any arithmetic shift rights of ~0)
3137 if (!isLeftShift)
3138 if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(Op0))
3139 if (CSI->isAllOnesValue())
3140 return ReplaceInstUsesWith(I, CSI);
3141
Chris Lattner183b3362004-04-09 19:05:30 +00003142 // Try to fold constant and into select arguments.
3143 if (isa<Constant>(Op0))
3144 if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
Chris Lattner86102b82005-01-01 16:22:27 +00003145 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattner183b3362004-04-09 19:05:30 +00003146 return R;
3147
Chris Lattnerb18dbbf2005-05-08 17:34:56 +00003148 // See if we can turn a signed shr into an unsigned shr.
3149 if (!isLeftShift && I.getType()->isSigned()) {
3150 if (MaskedValueIsZero(Op0, ConstantInt::getMinValue(I.getType()))) {
3151 Value *V = InsertCastBefore(Op0, I.getType()->getUnsignedVersion(), I);
3152 V = InsertNewInstBefore(new ShiftInst(Instruction::Shr, V, Op1,
3153 I.getName()), I);
3154 return new CastInst(V, I.getType());
3155 }
3156 }
3157
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003158 if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(Op1)) {
Chris Lattner3204d4e2003-07-24 17:52:58 +00003159 // shl uint X, 32 = 0 and shr ubyte Y, 9 = 0, ... just don't eliminate shr
3160 // of a signed value.
3161 //
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003162 unsigned TypeBits = Op0->getType()->getPrimitiveSizeInBits();
Chris Lattnerf5ce2542004-02-23 20:30:06 +00003163 if (CUI->getValue() >= TypeBits) {
3164 if (!Op0->getType()->isSigned() || isLeftShift)
3165 return ReplaceInstUsesWith(I, Constant::getNullValue(Op0->getType()));
3166 else {
3167 I.setOperand(1, ConstantUInt::get(Type::UByteTy, TypeBits-1));
3168 return &I;
3169 }
3170 }
Chris Lattner55f3d942002-09-10 23:04:09 +00003171
Chris Lattnerede3fe02003-08-13 04:18:28 +00003172 // ((X*C1) << C2) == (X * (C1 << C2))
3173 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Op0))
3174 if (BO->getOpcode() == Instruction::Mul && isLeftShift)
3175 if (Constant *BOOp = dyn_cast<Constant>(BO->getOperand(1)))
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003176 return BinaryOperator::createMul(BO->getOperand(0),
3177 ConstantExpr::getShl(BOOp, CUI));
Misha Brukmanb1c93172005-04-21 23:48:37 +00003178
Chris Lattner183b3362004-04-09 19:05:30 +00003179 // Try to fold constant and into select arguments.
3180 if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
Chris Lattner86102b82005-01-01 16:22:27 +00003181 if (Instruction *R = FoldOpIntoSelect(I, SI, this))
Chris Lattner183b3362004-04-09 19:05:30 +00003182 return R;
Chris Lattner6a4adcd2004-09-29 05:07:12 +00003183 if (isa<PHINode>(Op0))
3184 if (Instruction *NV = FoldOpIntoPhi(I))
3185 return NV;
Chris Lattnerede3fe02003-08-13 04:18:28 +00003186
Chris Lattner86102b82005-01-01 16:22:27 +00003187 if (Op0->hasOneUse()) {
3188 // If this is a SHL of a sign-extending cast, see if we can turn the input
3189 // into a zero extending cast (a simple strength reduction).
3190 if (CastInst *CI = dyn_cast<CastInst>(Op0)) {
3191 const Type *SrcTy = CI->getOperand(0)->getType();
3192 if (isLeftShift && SrcTy->isInteger() && SrcTy->isSigned() &&
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003193 SrcTy->getPrimitiveSizeInBits() <
3194 CI->getType()->getPrimitiveSizeInBits()) {
Chris Lattner86102b82005-01-01 16:22:27 +00003195 // We can change it to a zero extension if we are shifting out all of
3196 // the sign extended bits. To check this, form a mask of all of the
3197 // sign extend bits, then shift them left and see if we have anything
3198 // left.
3199 Constant *Mask = ConstantIntegral::getAllOnesValue(SrcTy); // 1111
3200 Mask = ConstantExpr::getZeroExtend(Mask, CI->getType()); // 00001111
3201 Mask = ConstantExpr::getNot(Mask); // 1's in the sign bits: 11110000
3202 if (ConstantExpr::getShl(Mask, CUI)->isNullValue()) {
3203 // If the shift is nuking all of the sign bits, change this to a
3204 // zero extension cast. To do this, cast the cast input to
3205 // unsigned, then to the requested size.
3206 Value *CastOp = CI->getOperand(0);
3207 Instruction *NC =
3208 new CastInst(CastOp, CastOp->getType()->getUnsignedVersion(),
3209 CI->getName()+".uns");
3210 NC = InsertNewInstBefore(NC, I);
3211 // Finally, insert a replacement for CI.
3212 NC = new CastInst(NC, CI->getType(), CI->getName());
3213 CI->setName("");
3214 NC = InsertNewInstBefore(NC, I);
3215 WorkList.push_back(CI); // Delete CI later.
3216 I.setOperand(0, NC);
3217 return &I; // The SHL operand was modified.
3218 }
3219 }
3220 }
3221
3222 // If the operand is an bitwise operator with a constant RHS, and the
3223 // shift is the only use, we can pull it out of the shift.
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003224 if (BinaryOperator *Op0BO = dyn_cast<BinaryOperator>(Op0))
3225 if (ConstantInt *Op0C = dyn_cast<ConstantInt>(Op0BO->getOperand(1))) {
3226 bool isValid = true; // Valid only for And, Or, Xor
3227 bool highBitSet = false; // Transform if high bit of constant set?
3228
3229 switch (Op0BO->getOpcode()) {
3230 default: isValid = false; break; // Do not perform transform!
Chris Lattner44bd3922004-10-08 03:46:20 +00003231 case Instruction::Add:
3232 isValid = isLeftShift;
3233 break;
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003234 case Instruction::Or:
3235 case Instruction::Xor:
3236 highBitSet = false;
3237 break;
3238 case Instruction::And:
3239 highBitSet = true;
3240 break;
3241 }
3242
3243 // If this is a signed shift right, and the high bit is modified
3244 // by the logical operation, do not perform the transformation.
3245 // The highBitSet boolean indicates the value of the high bit of
3246 // the constant which would cause it to be modified for this
3247 // operation.
3248 //
3249 if (isValid && !isLeftShift && !I.getType()->isUnsigned()) {
3250 uint64_t Val = Op0C->getRawValue();
3251 isValid = ((Val & (1 << (TypeBits-1))) != 0) == highBitSet;
3252 }
3253
3254 if (isValid) {
Chris Lattnerc1e7cc02004-01-12 19:35:11 +00003255 Constant *NewRHS = ConstantExpr::get(I.getOpcode(), Op0C, CUI);
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003256
3257 Instruction *NewShift =
3258 new ShiftInst(I.getOpcode(), Op0BO->getOperand(0), CUI,
3259 Op0BO->getName());
3260 Op0BO->setName("");
3261 InsertNewInstBefore(NewShift, I);
3262
3263 return BinaryOperator::create(Op0BO->getOpcode(), NewShift,
3264 NewRHS);
3265 }
3266 }
Chris Lattner86102b82005-01-01 16:22:27 +00003267 }
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003268
Chris Lattner3204d4e2003-07-24 17:52:58 +00003269 // If this is a shift of a shift, see if we can fold the two together...
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003270 if (ShiftInst *Op0SI = dyn_cast<ShiftInst>(Op0))
Chris Lattnerab780df2003-07-24 18:38:56 +00003271 if (ConstantUInt *ShiftAmt1C =
3272 dyn_cast<ConstantUInt>(Op0SI->getOperand(1))) {
Chris Lattnerfdfe3e492005-01-08 19:42:22 +00003273 unsigned ShiftAmt1 = (unsigned)ShiftAmt1C->getValue();
3274 unsigned ShiftAmt2 = (unsigned)CUI->getValue();
Misha Brukmanb1c93172005-04-21 23:48:37 +00003275
Chris Lattner3204d4e2003-07-24 17:52:58 +00003276 // Check for (A << c1) << c2 and (A >> c1) >> c2
3277 if (I.getOpcode() == Op0SI->getOpcode()) {
3278 unsigned Amt = ShiftAmt1+ShiftAmt2; // Fold into one big shift...
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003279 if (Op0->getType()->getPrimitiveSizeInBits() < Amt)
3280 Amt = Op0->getType()->getPrimitiveSizeInBits();
Chris Lattner3204d4e2003-07-24 17:52:58 +00003281 return new ShiftInst(I.getOpcode(), Op0SI->getOperand(0),
3282 ConstantUInt::get(Type::UByteTy, Amt));
3283 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00003284
Chris Lattnerab780df2003-07-24 18:38:56 +00003285 // Check for (A << c1) >> c2 or visaversa. If we are dealing with
3286 // signed types, we can only support the (A >> c1) << c2 configuration,
3287 // because it can not turn an arbitrary bit of A into a sign bit.
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003288 if (I.getType()->isUnsigned() || isLeftShift) {
Chris Lattner3204d4e2003-07-24 17:52:58 +00003289 // Calculate bitmask for what gets shifted off the edge...
3290 Constant *C = ConstantIntegral::getAllOnesValue(I.getType());
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003291 if (isLeftShift)
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003292 C = ConstantExpr::getShl(C, ShiftAmt1C);
Chris Lattnerdeaa0dd2003-08-12 21:53:41 +00003293 else
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003294 C = ConstantExpr::getShr(C, ShiftAmt1C);
Misha Brukmanb1c93172005-04-21 23:48:37 +00003295
Chris Lattner3204d4e2003-07-24 17:52:58 +00003296 Instruction *Mask =
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003297 BinaryOperator::createAnd(Op0SI->getOperand(0), C,
3298 Op0SI->getOperand(0)->getName()+".mask");
Chris Lattner3204d4e2003-07-24 17:52:58 +00003299 InsertNewInstBefore(Mask, I);
Misha Brukmanb1c93172005-04-21 23:48:37 +00003300
Chris Lattner3204d4e2003-07-24 17:52:58 +00003301 // Figure out what flavor of shift we should use...
3302 if (ShiftAmt1 == ShiftAmt2)
3303 return ReplaceInstUsesWith(I, Mask); // (A << c) >> c === A & c2
3304 else if (ShiftAmt1 < ShiftAmt2) {
3305 return new ShiftInst(I.getOpcode(), Mask,
3306 ConstantUInt::get(Type::UByteTy, ShiftAmt2-ShiftAmt1));
3307 } else {
3308 return new ShiftInst(Op0SI->getOpcode(), Mask,
3309 ConstantUInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2));
3310 }
3311 }
3312 }
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003313 }
Chris Lattner2e0fb392002-10-08 16:16:40 +00003314
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003315 return 0;
3316}
3317
Chris Lattner4e2dbc62004-07-20 00:59:32 +00003318enum CastType {
3319 Noop = 0,
3320 Truncate = 1,
3321 Signext = 2,
3322 Zeroext = 3
3323};
3324
3325/// getCastType - In the future, we will split the cast instruction into these
3326/// various types. Until then, we have to do the analysis here.
3327static CastType getCastType(const Type *Src, const Type *Dest) {
3328 assert(Src->isIntegral() && Dest->isIntegral() &&
3329 "Only works on integral types!");
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003330 unsigned SrcSize = Src->getPrimitiveSizeInBits();
3331 unsigned DestSize = Dest->getPrimitiveSizeInBits();
Chris Lattner4e2dbc62004-07-20 00:59:32 +00003332
3333 if (SrcSize == DestSize) return Noop;
3334 if (SrcSize > DestSize) return Truncate;
3335 if (Src->isSigned()) return Signext;
3336 return Zeroext;
3337}
3338
Chris Lattnerf4cdbf32002-05-06 16:14:14 +00003339
Chris Lattner48a44f72002-05-02 17:06:02 +00003340// isEliminableCastOfCast - Return true if it is valid to eliminate the CI
3341// instruction.
3342//
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003343static inline bool isEliminableCastOfCast(const Type *SrcTy, const Type *MidTy,
Chris Lattner11ffd592004-07-20 05:21:00 +00003344 const Type *DstTy, TargetData *TD) {
Chris Lattner48a44f72002-05-02 17:06:02 +00003345
Chris Lattner650b6da2002-08-02 20:00:25 +00003346 // It is legal to eliminate the instruction if casting A->B->A if the sizes
Misha Brukmanb1c93172005-04-21 23:48:37 +00003347 // are identical and the bits don't get reinterpreted (for example
Chris Lattner1638de42004-07-21 19:50:44 +00003348 // int->float->int would not be allowed).
Misha Brukmane5838c42003-05-20 18:45:36 +00003349 if (SrcTy == DstTy && SrcTy->isLosslesslyConvertibleTo(MidTy))
Chris Lattner650b6da2002-08-02 20:00:25 +00003350 return true;
Chris Lattner48a44f72002-05-02 17:06:02 +00003351
Chris Lattner4fbad962004-07-21 04:27:24 +00003352 // If we are casting between pointer and integer types, treat pointers as
3353 // integers of the appropriate size for the code below.
3354 if (isa<PointerType>(SrcTy)) SrcTy = TD->getIntPtrType();
3355 if (isa<PointerType>(MidTy)) MidTy = TD->getIntPtrType();
3356 if (isa<PointerType>(DstTy)) DstTy = TD->getIntPtrType();
Chris Lattner11ffd592004-07-20 05:21:00 +00003357
Chris Lattner48a44f72002-05-02 17:06:02 +00003358 // Allow free casting and conversion of sizes as long as the sign doesn't
3359 // change...
Chris Lattnerb0b412e2002-09-03 01:08:28 +00003360 if (SrcTy->isIntegral() && MidTy->isIntegral() && DstTy->isIntegral()) {
Chris Lattner4e2dbc62004-07-20 00:59:32 +00003361 CastType FirstCast = getCastType(SrcTy, MidTy);
3362 CastType SecondCast = getCastType(MidTy, DstTy);
Chris Lattner650b6da2002-08-02 20:00:25 +00003363
Chris Lattner4e2dbc62004-07-20 00:59:32 +00003364 // Capture the effect of these two casts. If the result is a legal cast,
3365 // the CastType is stored here, otherwise a special code is used.
3366 static const unsigned CastResult[] = {
3367 // First cast is noop
3368 0, 1, 2, 3,
3369 // First cast is a truncate
3370 1, 1, 4, 4, // trunc->extend is not safe to eliminate
3371 // First cast is a sign ext
Chris Lattner1638de42004-07-21 19:50:44 +00003372 2, 5, 2, 4, // signext->zeroext never ok
Chris Lattner4e2dbc62004-07-20 00:59:32 +00003373 // First cast is a zero ext
Chris Lattner1638de42004-07-21 19:50:44 +00003374 3, 5, 3, 3,
Chris Lattner4e2dbc62004-07-20 00:59:32 +00003375 };
3376
3377 unsigned Result = CastResult[FirstCast*4+SecondCast];
3378 switch (Result) {
3379 default: assert(0 && "Illegal table value!");
3380 case 0:
3381 case 1:
3382 case 2:
3383 case 3:
3384 // FIXME: in the future, when LLVM has explicit sign/zeroextends and
3385 // truncates, we could eliminate more casts.
3386 return (unsigned)getCastType(SrcTy, DstTy) == Result;
3387 case 4:
3388 return false; // Not possible to eliminate this here.
3389 case 5:
Chris Lattner1638de42004-07-21 19:50:44 +00003390 // Sign or zero extend followed by truncate is always ok if the result
3391 // is a truncate or noop.
3392 CastType ResultCast = getCastType(SrcTy, DstTy);
3393 if (ResultCast == Noop || ResultCast == Truncate)
3394 return true;
Misha Brukmanb1c93172005-04-21 23:48:37 +00003395 // Otherwise we are still growing the value, we are only safe if the
Chris Lattner1638de42004-07-21 19:50:44 +00003396 // result will match the sign/zeroextendness of the result.
3397 return ResultCast == FirstCast;
Chris Lattner3732aca2002-08-15 16:15:25 +00003398 }
Chris Lattner650b6da2002-08-02 20:00:25 +00003399 }
Chris Lattner48a44f72002-05-02 17:06:02 +00003400 return false;
3401}
3402
Chris Lattner11ffd592004-07-20 05:21:00 +00003403static bool ValueRequiresCast(const Value *V, const Type *Ty, TargetData *TD) {
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003404 if (V->getType() == Ty || isa<Constant>(V)) return false;
3405 if (const CastInst *CI = dyn_cast<CastInst>(V))
Chris Lattner11ffd592004-07-20 05:21:00 +00003406 if (isEliminableCastOfCast(CI->getOperand(0)->getType(), CI->getType(), Ty,
3407 TD))
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003408 return false;
3409 return true;
3410}
3411
3412/// InsertOperandCastBefore - This inserts a cast of V to DestTy before the
3413/// InsertBefore instruction. This is specialized a bit to avoid inserting
3414/// casts that are known to not do anything...
3415///
3416Value *InstCombiner::InsertOperandCastBefore(Value *V, const Type *DestTy,
3417 Instruction *InsertBefore) {
3418 if (V->getType() == DestTy) return V;
3419 if (Constant *C = dyn_cast<Constant>(V))
3420 return ConstantExpr::getCast(C, DestTy);
3421
3422 CastInst *CI = new CastInst(V, DestTy, V->getName());
3423 InsertNewInstBefore(CI, *InsertBefore);
3424 return CI;
3425}
Chris Lattner48a44f72002-05-02 17:06:02 +00003426
3427// CastInst simplification
Chris Lattner260ab202002-04-18 17:39:14 +00003428//
Chris Lattner113f4f42002-06-25 16:13:24 +00003429Instruction *InstCombiner::visitCastInst(CastInst &CI) {
Chris Lattner55d4bda2003-06-23 21:59:52 +00003430 Value *Src = CI.getOperand(0);
3431
Chris Lattner48a44f72002-05-02 17:06:02 +00003432 // If the user is casting a value to the same type, eliminate this cast
3433 // instruction...
Chris Lattner55d4bda2003-06-23 21:59:52 +00003434 if (CI.getType() == Src->getType())
3435 return ReplaceInstUsesWith(CI, Src);
Chris Lattner48a44f72002-05-02 17:06:02 +00003436
Chris Lattner81a7a232004-10-16 18:11:37 +00003437 if (isa<UndefValue>(Src)) // cast undef -> undef
3438 return ReplaceInstUsesWith(CI, UndefValue::get(CI.getType()));
3439
Chris Lattner48a44f72002-05-02 17:06:02 +00003440 // If casting the result of another cast instruction, try to eliminate this
3441 // one!
3442 //
Chris Lattner86102b82005-01-01 16:22:27 +00003443 if (CastInst *CSrc = dyn_cast<CastInst>(Src)) { // A->B->C cast
3444 Value *A = CSrc->getOperand(0);
3445 if (isEliminableCastOfCast(A->getType(), CSrc->getType(),
3446 CI.getType(), TD)) {
Chris Lattner48a44f72002-05-02 17:06:02 +00003447 // This instruction now refers directly to the cast's src operand. This
3448 // has a good chance of making CSrc dead.
Chris Lattner113f4f42002-06-25 16:13:24 +00003449 CI.setOperand(0, CSrc->getOperand(0));
3450 return &CI;
Chris Lattner48a44f72002-05-02 17:06:02 +00003451 }
3452
Chris Lattner650b6da2002-08-02 20:00:25 +00003453 // If this is an A->B->A cast, and we are dealing with integral types, try
3454 // to convert this into a logical 'and' instruction.
3455 //
Misha Brukmanb1c93172005-04-21 23:48:37 +00003456 if (A->getType()->isInteger() &&
Chris Lattnerb0b412e2002-09-03 01:08:28 +00003457 CI.getType()->isInteger() && CSrc->getType()->isInteger() &&
Chris Lattner86102b82005-01-01 16:22:27 +00003458 CSrc->getType()->isUnsigned() && // B->A cast must zero extend
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003459 CSrc->getType()->getPrimitiveSizeInBits() <
3460 CI.getType()->getPrimitiveSizeInBits()&&
3461 A->getType()->getPrimitiveSizeInBits() ==
3462 CI.getType()->getPrimitiveSizeInBits()) {
Chris Lattner650b6da2002-08-02 20:00:25 +00003463 assert(CSrc->getType() != Type::ULongTy &&
3464 "Cannot have type bigger than ulong!");
Chris Lattner2f1457f2005-04-24 17:46:05 +00003465 uint64_t AndValue = ~0ULL>>(64-CSrc->getType()->getPrimitiveSizeInBits());
Chris Lattner86102b82005-01-01 16:22:27 +00003466 Constant *AndOp = ConstantUInt::get(A->getType()->getUnsignedVersion(),
3467 AndValue);
3468 AndOp = ConstantExpr::getCast(AndOp, A->getType());
3469 Instruction *And = BinaryOperator::createAnd(CSrc->getOperand(0), AndOp);
3470 if (And->getType() != CI.getType()) {
3471 And->setName(CSrc->getName()+".mask");
3472 InsertNewInstBefore(And, CI);
3473 And = new CastInst(And, CI.getType());
3474 }
3475 return And;
Chris Lattner650b6da2002-08-02 20:00:25 +00003476 }
3477 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00003478
Chris Lattner03841652004-05-25 04:29:21 +00003479 // If this is a cast to bool, turn it into the appropriate setne instruction.
3480 if (CI.getType() == Type::BoolTy)
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003481 return BinaryOperator::createSetNE(CI.getOperand(0),
Chris Lattner03841652004-05-25 04:29:21 +00003482 Constant::getNullValue(CI.getOperand(0)->getType()));
3483
Chris Lattnerd0d51602003-06-21 23:12:02 +00003484 // If casting the result of a getelementptr instruction with no offset, turn
3485 // this into a cast of the original pointer!
3486 //
Chris Lattner55d4bda2003-06-23 21:59:52 +00003487 if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Src)) {
Chris Lattnerd0d51602003-06-21 23:12:02 +00003488 bool AllZeroOperands = true;
3489 for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i)
3490 if (!isa<Constant>(GEP->getOperand(i)) ||
3491 !cast<Constant>(GEP->getOperand(i))->isNullValue()) {
3492 AllZeroOperands = false;
3493 break;
3494 }
3495 if (AllZeroOperands) {
3496 CI.setOperand(0, GEP->getOperand(0));
3497 return &CI;
3498 }
3499 }
3500
Chris Lattnerf4ad1652003-11-02 05:57:39 +00003501 // If we are casting a malloc or alloca to a pointer to a type of the same
3502 // size, rewrite the allocation instruction to allocate the "right" type.
3503 //
3504 if (AllocationInst *AI = dyn_cast<AllocationInst>(Src))
Chris Lattnerd4d987d2003-11-02 06:54:48 +00003505 if (AI->hasOneUse() && !AI->isArrayAllocation())
Chris Lattnerf4ad1652003-11-02 05:57:39 +00003506 if (const PointerType *PTy = dyn_cast<PointerType>(CI.getType())) {
3507 // Get the type really allocated and the type casted to...
3508 const Type *AllocElTy = AI->getAllocatedType();
Chris Lattnerf4ad1652003-11-02 05:57:39 +00003509 const Type *CastElTy = PTy->getElementType();
Chris Lattner9eb9ccd2004-07-06 19:28:42 +00003510 if (AllocElTy->isSized() && CastElTy->isSized()) {
Chris Lattnerfdfe3e492005-01-08 19:42:22 +00003511 uint64_t AllocElTySize = TD->getTypeSize(AllocElTy);
3512 uint64_t CastElTySize = TD->getTypeSize(CastElTy);
Chris Lattner7c94d112003-11-05 17:31:36 +00003513
Chris Lattner9eb9ccd2004-07-06 19:28:42 +00003514 // If the allocation is for an even multiple of the cast type size
3515 if (CastElTySize && (AllocElTySize % CastElTySize == 0)) {
Misha Brukmanb1c93172005-04-21 23:48:37 +00003516 Value *Amt = ConstantUInt::get(Type::UIntTy,
Chris Lattnerf4ad1652003-11-02 05:57:39 +00003517 AllocElTySize/CastElTySize);
Chris Lattner9eb9ccd2004-07-06 19:28:42 +00003518 std::string Name = AI->getName(); AI->setName("");
3519 AllocationInst *New;
3520 if (isa<MallocInst>(AI))
3521 New = new MallocInst(CastElTy, Amt, Name);
3522 else
3523 New = new AllocaInst(CastElTy, Amt, Name);
3524 InsertNewInstBefore(New, *AI);
3525 return ReplaceInstUsesWith(CI, New);
3526 }
Chris Lattnerf4ad1652003-11-02 05:57:39 +00003527 }
3528 }
3529
Chris Lattner86102b82005-01-01 16:22:27 +00003530 if (SelectInst *SI = dyn_cast<SelectInst>(Src))
3531 if (Instruction *NV = FoldOpIntoSelect(CI, SI, this))
3532 return NV;
Chris Lattner6a4adcd2004-09-29 05:07:12 +00003533 if (isa<PHINode>(Src))
3534 if (Instruction *NV = FoldOpIntoPhi(CI))
3535 return NV;
3536
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003537 // If the source value is an instruction with only this use, we can attempt to
3538 // propagate the cast into the instruction. Also, only handle integral types
3539 // for now.
3540 if (Instruction *SrcI = dyn_cast<Instruction>(Src))
Chris Lattnerf95d9b92003-10-15 16:48:29 +00003541 if (SrcI->hasOneUse() && Src->getType()->isIntegral() &&
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003542 CI.getType()->isInteger()) { // Don't mess with casts to bool here
3543 const Type *DestTy = CI.getType();
Chris Lattnerd1f46d32005-04-24 06:59:08 +00003544 unsigned SrcBitSize = Src->getType()->getPrimitiveSizeInBits();
3545 unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003546
3547 Value *Op0 = SrcI->getNumOperands() > 0 ? SrcI->getOperand(0) : 0;
3548 Value *Op1 = SrcI->getNumOperands() > 1 ? SrcI->getOperand(1) : 0;
3549
3550 switch (SrcI->getOpcode()) {
3551 case Instruction::Add:
3552 case Instruction::Mul:
3553 case Instruction::And:
3554 case Instruction::Or:
3555 case Instruction::Xor:
3556 // If we are discarding information, or just changing the sign, rewrite.
3557 if (DestBitSize <= SrcBitSize && DestBitSize != 1) {
3558 // Don't insert two casts if they cannot be eliminated. We allow two
3559 // casts to be inserted if the sizes are the same. This could only be
3560 // converting signedness, which is a noop.
Chris Lattner11ffd592004-07-20 05:21:00 +00003561 if (DestBitSize == SrcBitSize || !ValueRequiresCast(Op1, DestTy,TD) ||
3562 !ValueRequiresCast(Op0, DestTy, TD)) {
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003563 Value *Op0c = InsertOperandCastBefore(Op0, DestTy, SrcI);
3564 Value *Op1c = InsertOperandCastBefore(Op1, DestTy, SrcI);
3565 return BinaryOperator::create(cast<BinaryOperator>(SrcI)
3566 ->getOpcode(), Op0c, Op1c);
3567 }
3568 }
Chris Lattner72086162005-05-06 02:07:39 +00003569
3570 // cast (xor bool X, true) to int --> xor (cast bool X to int), 1
3571 if (SrcBitSize == 1 && SrcI->getOpcode() == Instruction::Xor &&
3572 Op1 == ConstantBool::True &&
3573 (!Op0->hasOneUse() || !isa<SetCondInst>(Op0))) {
3574 Value *New = InsertOperandCastBefore(Op0, DestTy, &CI);
3575 return BinaryOperator::createXor(New,
3576 ConstantInt::get(CI.getType(), 1));
3577 }
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003578 break;
3579 case Instruction::Shl:
3580 // Allow changing the sign of the source operand. Do not allow changing
3581 // the size of the shift, UNLESS the shift amount is a constant. We
3582 // mush not change variable sized shifts to a smaller size, because it
3583 // is undefined to shift more bits out than exist in the value.
3584 if (DestBitSize == SrcBitSize ||
3585 (DestBitSize < SrcBitSize && isa<Constant>(Op1))) {
3586 Value *Op0c = InsertOperandCastBefore(Op0, DestTy, SrcI);
3587 return new ShiftInst(Instruction::Shl, Op0c, Op1);
3588 }
3589 break;
Chris Lattner87380412005-05-06 04:18:52 +00003590 case Instruction::Shr:
3591 // If this is a signed shr, and if all bits shifted in are about to be
3592 // truncated off, turn it into an unsigned shr to allow greater
3593 // simplifications.
3594 if (DestBitSize < SrcBitSize && Src->getType()->isSigned() &&
3595 isa<ConstantInt>(Op1)) {
3596 unsigned ShiftAmt = cast<ConstantUInt>(Op1)->getValue();
3597 if (SrcBitSize > ShiftAmt && SrcBitSize-ShiftAmt >= DestBitSize) {
3598 // Convert to unsigned.
3599 Value *N1 = InsertOperandCastBefore(Op0,
3600 Op0->getType()->getUnsignedVersion(), &CI);
3601 // Insert the new shift, which is now unsigned.
3602 N1 = InsertNewInstBefore(new ShiftInst(Instruction::Shr, N1,
3603 Op1, Src->getName()), CI);
3604 return new CastInst(N1, CI.getType());
3605 }
3606 }
3607 break;
3608
Chris Lattner809dfac2005-05-04 19:10:26 +00003609 case Instruction::SetNE:
Chris Lattner809dfac2005-05-04 19:10:26 +00003610 if (ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
Chris Lattner4c2d3782005-05-06 01:53:19 +00003611 if (Op1C->getRawValue() == 0) {
3612 // If the input only has the low bit set, simplify directly.
Chris Lattner809dfac2005-05-04 19:10:26 +00003613 Constant *Not1 =
3614 ConstantExpr::getNot(ConstantInt::get(Op0->getType(), 1));
Chris Lattner4c2d3782005-05-06 01:53:19 +00003615 // cast (X != 0) to int --> X if X&~1 == 0
Chris Lattner809dfac2005-05-04 19:10:26 +00003616 if (MaskedValueIsZero(Op0, cast<ConstantIntegral>(Not1))) {
3617 if (CI.getType() == Op0->getType())
3618 return ReplaceInstUsesWith(CI, Op0);
3619 else
3620 return new CastInst(Op0, CI.getType());
3621 }
Chris Lattner4c2d3782005-05-06 01:53:19 +00003622
3623 // If the input is an and with a single bit, shift then simplify.
3624 ConstantInt *AndRHS;
3625 if (match(Op0, m_And(m_Value(), m_ConstantInt(AndRHS))))
3626 if (AndRHS->getRawValue() &&
3627 (AndRHS->getRawValue() & (AndRHS->getRawValue()-1)) == 0) {
3628 unsigned ShiftAmt = Log2(AndRHS->getRawValue());
3629 // Perform an unsigned shr by shiftamt. Convert input to
3630 // unsigned if it is signed.
3631 Value *In = Op0;
3632 if (In->getType()->isSigned())
3633 In = InsertNewInstBefore(new CastInst(In,
3634 In->getType()->getUnsignedVersion(), In->getName()),CI);
3635 // Insert the shift to put the result in the low bit.
3636 In = InsertNewInstBefore(new ShiftInst(Instruction::Shr, In,
3637 ConstantInt::get(Type::UByteTy, ShiftAmt),
3638 In->getName()+".lobit"), CI);
Chris Lattner4c2d3782005-05-06 01:53:19 +00003639 if (CI.getType() == In->getType())
3640 return ReplaceInstUsesWith(CI, In);
3641 else
3642 return new CastInst(In, CI.getType());
3643 }
3644 }
3645 }
3646 break;
3647 case Instruction::SetEQ:
3648 // We if we are just checking for a seteq of a single bit and casting it
3649 // to an integer. If so, shift the bit to the appropriate place then
3650 // cast to integer to avoid the comparison.
3651 if (ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
3652 // Is Op1C a power of two or zero?
3653 if ((Op1C->getRawValue() & Op1C->getRawValue()-1) == 0) {
3654 // cast (X == 1) to int -> X iff X has only the low bit set.
3655 if (Op1C->getRawValue() == 1) {
3656 Constant *Not1 =
3657 ConstantExpr::getNot(ConstantInt::get(Op0->getType(), 1));
3658 if (MaskedValueIsZero(Op0, cast<ConstantIntegral>(Not1))) {
3659 if (CI.getType() == Op0->getType())
3660 return ReplaceInstUsesWith(CI, Op0);
3661 else
3662 return new CastInst(Op0, CI.getType());
3663 }
3664 }
Chris Lattner809dfac2005-05-04 19:10:26 +00003665 }
3666 }
3667 break;
Chris Lattnerdfae8be2003-07-24 17:35:25 +00003668 }
3669 }
Chris Lattner260ab202002-04-18 17:39:14 +00003670 return 0;
Chris Lattnerca081252001-12-14 16:52:21 +00003671}
3672
Chris Lattner56e4d3d2004-04-09 23:46:01 +00003673/// GetSelectFoldableOperands - We want to turn code that looks like this:
3674/// %C = or %A, %B
3675/// %D = select %cond, %C, %A
3676/// into:
3677/// %C = select %cond, %B, 0
3678/// %D = or %A, %C
3679///
3680/// Assuming that the specified instruction is an operand to the select, return
3681/// a bitmask indicating which operands of this instruction are foldable if they
3682/// equal the other incoming value of the select.
3683///
3684static unsigned GetSelectFoldableOperands(Instruction *I) {
3685 switch (I->getOpcode()) {
3686 case Instruction::Add:
3687 case Instruction::Mul:
3688 case Instruction::And:
3689 case Instruction::Or:
3690 case Instruction::Xor:
3691 return 3; // Can fold through either operand.
3692 case Instruction::Sub: // Can only fold on the amount subtracted.
3693 case Instruction::Shl: // Can only fold on the shift amount.
3694 case Instruction::Shr:
Misha Brukmanb1c93172005-04-21 23:48:37 +00003695 return 1;
Chris Lattner56e4d3d2004-04-09 23:46:01 +00003696 default:
3697 return 0; // Cannot fold
3698 }
3699}
3700
3701/// GetSelectFoldableConstant - For the same transformation as the previous
3702/// function, return the identity constant that goes into the select.
3703static Constant *GetSelectFoldableConstant(Instruction *I) {
3704 switch (I->getOpcode()) {
3705 default: assert(0 && "This cannot happen!"); abort();
3706 case Instruction::Add:
3707 case Instruction::Sub:
3708 case Instruction::Or:
3709 case Instruction::Xor:
3710 return Constant::getNullValue(I->getType());
3711 case Instruction::Shl:
3712 case Instruction::Shr:
3713 return Constant::getNullValue(Type::UByteTy);
3714 case Instruction::And:
3715 return ConstantInt::getAllOnesValue(I->getType());
3716 case Instruction::Mul:
3717 return ConstantInt::get(I->getType(), 1);
3718 }
3719}
3720
Chris Lattner411336f2005-01-19 21:50:18 +00003721/// FoldSelectOpOp - Here we have (select c, TI, FI), and we know that TI and FI
3722/// have the same opcode and only one use each. Try to simplify this.
3723Instruction *InstCombiner::FoldSelectOpOp(SelectInst &SI, Instruction *TI,
3724 Instruction *FI) {
3725 if (TI->getNumOperands() == 1) {
3726 // If this is a non-volatile load or a cast from the same type,
3727 // merge.
3728 if (TI->getOpcode() == Instruction::Cast) {
3729 if (TI->getOperand(0)->getType() != FI->getOperand(0)->getType())
3730 return 0;
3731 } else {
3732 return 0; // unknown unary op.
3733 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00003734
Chris Lattner411336f2005-01-19 21:50:18 +00003735 // Fold this by inserting a select from the input values.
3736 SelectInst *NewSI = new SelectInst(SI.getCondition(), TI->getOperand(0),
3737 FI->getOperand(0), SI.getName()+".v");
3738 InsertNewInstBefore(NewSI, SI);
3739 return new CastInst(NewSI, TI->getType());
3740 }
3741
3742 // Only handle binary operators here.
3743 if (!isa<ShiftInst>(TI) && !isa<BinaryOperator>(TI))
3744 return 0;
3745
3746 // Figure out if the operations have any operands in common.
3747 Value *MatchOp, *OtherOpT, *OtherOpF;
3748 bool MatchIsOpZero;
3749 if (TI->getOperand(0) == FI->getOperand(0)) {
3750 MatchOp = TI->getOperand(0);
3751 OtherOpT = TI->getOperand(1);
3752 OtherOpF = FI->getOperand(1);
3753 MatchIsOpZero = true;
3754 } else if (TI->getOperand(1) == FI->getOperand(1)) {
3755 MatchOp = TI->getOperand(1);
3756 OtherOpT = TI->getOperand(0);
3757 OtherOpF = FI->getOperand(0);
3758 MatchIsOpZero = false;
3759 } else if (!TI->isCommutative()) {
3760 return 0;
3761 } else if (TI->getOperand(0) == FI->getOperand(1)) {
3762 MatchOp = TI->getOperand(0);
3763 OtherOpT = TI->getOperand(1);
3764 OtherOpF = FI->getOperand(0);
3765 MatchIsOpZero = true;
3766 } else if (TI->getOperand(1) == FI->getOperand(0)) {
3767 MatchOp = TI->getOperand(1);
3768 OtherOpT = TI->getOperand(0);
3769 OtherOpF = FI->getOperand(1);
3770 MatchIsOpZero = true;
3771 } else {
3772 return 0;
3773 }
3774
3775 // If we reach here, they do have operations in common.
3776 SelectInst *NewSI = new SelectInst(SI.getCondition(), OtherOpT,
3777 OtherOpF, SI.getName()+".v");
3778 InsertNewInstBefore(NewSI, SI);
3779
3780 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(TI)) {
3781 if (MatchIsOpZero)
3782 return BinaryOperator::create(BO->getOpcode(), MatchOp, NewSI);
3783 else
3784 return BinaryOperator::create(BO->getOpcode(), NewSI, MatchOp);
3785 } else {
3786 if (MatchIsOpZero)
3787 return new ShiftInst(cast<ShiftInst>(TI)->getOpcode(), MatchOp, NewSI);
3788 else
3789 return new ShiftInst(cast<ShiftInst>(TI)->getOpcode(), NewSI, MatchOp);
3790 }
3791}
3792
Chris Lattnerb909e8b2004-03-12 05:52:32 +00003793Instruction *InstCombiner::visitSelectInst(SelectInst &SI) {
Chris Lattner533bc492004-03-30 19:37:13 +00003794 Value *CondVal = SI.getCondition();
3795 Value *TrueVal = SI.getTrueValue();
3796 Value *FalseVal = SI.getFalseValue();
3797
3798 // select true, X, Y -> X
3799 // select false, X, Y -> Y
3800 if (ConstantBool *C = dyn_cast<ConstantBool>(CondVal))
Chris Lattnerb909e8b2004-03-12 05:52:32 +00003801 if (C == ConstantBool::True)
Chris Lattner533bc492004-03-30 19:37:13 +00003802 return ReplaceInstUsesWith(SI, TrueVal);
Chris Lattnerb909e8b2004-03-12 05:52:32 +00003803 else {
3804 assert(C == ConstantBool::False);
Chris Lattner533bc492004-03-30 19:37:13 +00003805 return ReplaceInstUsesWith(SI, FalseVal);
Chris Lattnerb909e8b2004-03-12 05:52:32 +00003806 }
Chris Lattner533bc492004-03-30 19:37:13 +00003807
3808 // select C, X, X -> X
3809 if (TrueVal == FalseVal)
3810 return ReplaceInstUsesWith(SI, TrueVal);
3811
Chris Lattner81a7a232004-10-16 18:11:37 +00003812 if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X
3813 return ReplaceInstUsesWith(SI, FalseVal);
3814 if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X
3815 return ReplaceInstUsesWith(SI, TrueVal);
3816 if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y
3817 if (isa<Constant>(TrueVal))
3818 return ReplaceInstUsesWith(SI, TrueVal);
3819 else
3820 return ReplaceInstUsesWith(SI, FalseVal);
3821 }
3822
Chris Lattner1c631e82004-04-08 04:43:23 +00003823 if (SI.getType() == Type::BoolTy)
3824 if (ConstantBool *C = dyn_cast<ConstantBool>(TrueVal)) {
3825 if (C == ConstantBool::True) {
3826 // Change: A = select B, true, C --> A = or B, C
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003827 return BinaryOperator::createOr(CondVal, FalseVal);
Chris Lattner1c631e82004-04-08 04:43:23 +00003828 } else {
3829 // Change: A = select B, false, C --> A = and !B, C
3830 Value *NotCond =
3831 InsertNewInstBefore(BinaryOperator::createNot(CondVal,
3832 "not."+CondVal->getName()), SI);
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003833 return BinaryOperator::createAnd(NotCond, FalseVal);
Chris Lattner1c631e82004-04-08 04:43:23 +00003834 }
3835 } else if (ConstantBool *C = dyn_cast<ConstantBool>(FalseVal)) {
3836 if (C == ConstantBool::False) {
3837 // Change: A = select B, C, false --> A = and B, C
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003838 return BinaryOperator::createAnd(CondVal, TrueVal);
Chris Lattner1c631e82004-04-08 04:43:23 +00003839 } else {
3840 // Change: A = select B, C, true --> A = or !B, C
3841 Value *NotCond =
3842 InsertNewInstBefore(BinaryOperator::createNot(CondVal,
3843 "not."+CondVal->getName()), SI);
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00003844 return BinaryOperator::createOr(NotCond, TrueVal);
Chris Lattner1c631e82004-04-08 04:43:23 +00003845 }
3846 }
3847
Chris Lattner183b3362004-04-09 19:05:30 +00003848 // Selecting between two integer constants?
3849 if (ConstantInt *TrueValC = dyn_cast<ConstantInt>(TrueVal))
3850 if (ConstantInt *FalseValC = dyn_cast<ConstantInt>(FalseVal)) {
3851 // select C, 1, 0 -> cast C to int
3852 if (FalseValC->isNullValue() && TrueValC->getRawValue() == 1) {
3853 return new CastInst(CondVal, SI.getType());
3854 } else if (TrueValC->isNullValue() && FalseValC->getRawValue() == 1) {
3855 // select C, 0, 1 -> cast !C to int
3856 Value *NotCond =
3857 InsertNewInstBefore(BinaryOperator::createNot(CondVal,
Chris Lattnercf7baf32004-04-09 18:19:44 +00003858 "not."+CondVal->getName()), SI);
Chris Lattner183b3362004-04-09 19:05:30 +00003859 return new CastInst(NotCond, SI.getType());
Chris Lattnercf7baf32004-04-09 18:19:44 +00003860 }
Chris Lattner35167c32004-06-09 07:59:58 +00003861
3862 // If one of the constants is zero (we know they can't both be) and we
3863 // have a setcc instruction with zero, and we have an 'and' with the
3864 // non-constant value, eliminate this whole mess. This corresponds to
3865 // cases like this: ((X & 27) ? 27 : 0)
3866 if (TrueValC->isNullValue() || FalseValC->isNullValue())
3867 if (Instruction *IC = dyn_cast<Instruction>(SI.getCondition()))
3868 if ((IC->getOpcode() == Instruction::SetEQ ||
3869 IC->getOpcode() == Instruction::SetNE) &&
3870 isa<ConstantInt>(IC->getOperand(1)) &&
3871 cast<Constant>(IC->getOperand(1))->isNullValue())
3872 if (Instruction *ICA = dyn_cast<Instruction>(IC->getOperand(0)))
3873 if (ICA->getOpcode() == Instruction::And &&
Misha Brukmanb1c93172005-04-21 23:48:37 +00003874 isa<ConstantInt>(ICA->getOperand(1)) &&
3875 (ICA->getOperand(1) == TrueValC ||
3876 ICA->getOperand(1) == FalseValC) &&
Chris Lattner35167c32004-06-09 07:59:58 +00003877 isOneBitSet(cast<ConstantInt>(ICA->getOperand(1)))) {
3878 // Okay, now we know that everything is set up, we just don't
3879 // know whether we have a setne or seteq and whether the true or
3880 // false val is the zero.
3881 bool ShouldNotVal = !TrueValC->isNullValue();
3882 ShouldNotVal ^= IC->getOpcode() == Instruction::SetNE;
3883 Value *V = ICA;
3884 if (ShouldNotVal)
3885 V = InsertNewInstBefore(BinaryOperator::create(
3886 Instruction::Xor, V, ICA->getOperand(1)), SI);
3887 return ReplaceInstUsesWith(SI, V);
3888 }
Chris Lattner533bc492004-03-30 19:37:13 +00003889 }
Chris Lattner623fba12004-04-10 22:21:27 +00003890
3891 // See if we are selecting two values based on a comparison of the two values.
3892 if (SetCondInst *SCI = dyn_cast<SetCondInst>(CondVal)) {
3893 if (SCI->getOperand(0) == TrueVal && SCI->getOperand(1) == FalseVal) {
3894 // Transform (X == Y) ? X : Y -> Y
3895 if (SCI->getOpcode() == Instruction::SetEQ)
3896 return ReplaceInstUsesWith(SI, FalseVal);
3897 // Transform (X != Y) ? X : Y -> X
3898 if (SCI->getOpcode() == Instruction::SetNE)
3899 return ReplaceInstUsesWith(SI, TrueVal);
3900 // NOTE: if we wanted to, this is where to detect MIN/MAX/ABS/etc.
3901
3902 } else if (SCI->getOperand(0) == FalseVal && SCI->getOperand(1) == TrueVal){
3903 // Transform (X == Y) ? Y : X -> X
3904 if (SCI->getOpcode() == Instruction::SetEQ)
Chris Lattner24cf0202004-04-11 01:39:19 +00003905 return ReplaceInstUsesWith(SI, FalseVal);
Chris Lattner623fba12004-04-10 22:21:27 +00003906 // Transform (X != Y) ? Y : X -> Y
3907 if (SCI->getOpcode() == Instruction::SetNE)
Chris Lattner24cf0202004-04-11 01:39:19 +00003908 return ReplaceInstUsesWith(SI, TrueVal);
Chris Lattner623fba12004-04-10 22:21:27 +00003909 // NOTE: if we wanted to, this is where to detect MIN/MAX/ABS/etc.
3910 }
3911 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00003912
Chris Lattnera04c9042005-01-13 22:52:24 +00003913 if (Instruction *TI = dyn_cast<Instruction>(TrueVal))
3914 if (Instruction *FI = dyn_cast<Instruction>(FalseVal))
3915 if (TI->hasOneUse() && FI->hasOneUse()) {
3916 bool isInverse = false;
3917 Instruction *AddOp = 0, *SubOp = 0;
3918
Chris Lattner411336f2005-01-19 21:50:18 +00003919 // Turn (select C, (op X, Y), (op X, Z)) -> (op X, (select C, Y, Z))
3920 if (TI->getOpcode() == FI->getOpcode())
3921 if (Instruction *IV = FoldSelectOpOp(SI, TI, FI))
3922 return IV;
3923
3924 // Turn select C, (X+Y), (X-Y) --> (X+(select C, Y, (-Y))). This is
3925 // even legal for FP.
Chris Lattnera04c9042005-01-13 22:52:24 +00003926 if (TI->getOpcode() == Instruction::Sub &&
3927 FI->getOpcode() == Instruction::Add) {
3928 AddOp = FI; SubOp = TI;
3929 } else if (FI->getOpcode() == Instruction::Sub &&
3930 TI->getOpcode() == Instruction::Add) {
3931 AddOp = TI; SubOp = FI;
3932 }
3933
3934 if (AddOp) {
3935 Value *OtherAddOp = 0;
3936 if (SubOp->getOperand(0) == AddOp->getOperand(0)) {
3937 OtherAddOp = AddOp->getOperand(1);
3938 } else if (SubOp->getOperand(0) == AddOp->getOperand(1)) {
3939 OtherAddOp = AddOp->getOperand(0);
3940 }
3941
3942 if (OtherAddOp) {
3943 // So at this point we know we have:
3944 // select C, (add X, Y), (sub X, ?)
3945 // We can do the transform profitably if either 'Y' = '?' or '?' is
3946 // a constant.
3947 if (SubOp->getOperand(1) == AddOp ||
3948 isa<Constant>(SubOp->getOperand(1))) {
3949 Value *NegVal;
3950 if (Constant *C = dyn_cast<Constant>(SubOp->getOperand(1))) {
3951 NegVal = ConstantExpr::getNeg(C);
3952 } else {
3953 NegVal = InsertNewInstBefore(
3954 BinaryOperator::createNeg(SubOp->getOperand(1)), SI);
3955 }
3956
Chris Lattner51726c42005-01-14 17:35:12 +00003957 Value *NewTrueOp = OtherAddOp;
Chris Lattnera04c9042005-01-13 22:52:24 +00003958 Value *NewFalseOp = NegVal;
3959 if (AddOp != TI)
3960 std::swap(NewTrueOp, NewFalseOp);
3961 Instruction *NewSel =
3962 new SelectInst(CondVal, NewTrueOp,NewFalseOp,SI.getName()+".p");
Misha Brukmanb1c93172005-04-21 23:48:37 +00003963
Chris Lattnera04c9042005-01-13 22:52:24 +00003964 NewSel = InsertNewInstBefore(NewSel, SI);
Chris Lattner51726c42005-01-14 17:35:12 +00003965 return BinaryOperator::createAdd(SubOp->getOperand(0), NewSel);
Chris Lattnera04c9042005-01-13 22:52:24 +00003966 }
3967 }
3968 }
3969 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00003970
Chris Lattner56e4d3d2004-04-09 23:46:01 +00003971 // See if we can fold the select into one of our operands.
3972 if (SI.getType()->isInteger()) {
3973 // See the comment above GetSelectFoldableOperands for a description of the
3974 // transformation we are doing here.
3975 if (Instruction *TVI = dyn_cast<Instruction>(TrueVal))
3976 if (TVI->hasOneUse() && TVI->getNumOperands() == 2 &&
3977 !isa<Constant>(FalseVal))
3978 if (unsigned SFO = GetSelectFoldableOperands(TVI)) {
3979 unsigned OpToFold = 0;
3980 if ((SFO & 1) && FalseVal == TVI->getOperand(0)) {
3981 OpToFold = 1;
3982 } else if ((SFO & 2) && FalseVal == TVI->getOperand(1)) {
3983 OpToFold = 2;
3984 }
3985
3986 if (OpToFold) {
3987 Constant *C = GetSelectFoldableConstant(TVI);
3988 std::string Name = TVI->getName(); TVI->setName("");
3989 Instruction *NewSel =
3990 new SelectInst(SI.getCondition(), TVI->getOperand(2-OpToFold), C,
3991 Name);
3992 InsertNewInstBefore(NewSel, SI);
3993 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(TVI))
3994 return BinaryOperator::create(BO->getOpcode(), FalseVal, NewSel);
3995 else if (ShiftInst *SI = dyn_cast<ShiftInst>(TVI))
3996 return new ShiftInst(SI->getOpcode(), FalseVal, NewSel);
3997 else {
3998 assert(0 && "Unknown instruction!!");
3999 }
4000 }
4001 }
Chris Lattner6862fbd2004-09-29 17:40:11 +00004002
Chris Lattner56e4d3d2004-04-09 23:46:01 +00004003 if (Instruction *FVI = dyn_cast<Instruction>(FalseVal))
4004 if (FVI->hasOneUse() && FVI->getNumOperands() == 2 &&
4005 !isa<Constant>(TrueVal))
4006 if (unsigned SFO = GetSelectFoldableOperands(FVI)) {
4007 unsigned OpToFold = 0;
4008 if ((SFO & 1) && TrueVal == FVI->getOperand(0)) {
4009 OpToFold = 1;
4010 } else if ((SFO & 2) && TrueVal == FVI->getOperand(1)) {
4011 OpToFold = 2;
4012 }
4013
4014 if (OpToFold) {
4015 Constant *C = GetSelectFoldableConstant(FVI);
4016 std::string Name = FVI->getName(); FVI->setName("");
4017 Instruction *NewSel =
4018 new SelectInst(SI.getCondition(), C, FVI->getOperand(2-OpToFold),
4019 Name);
4020 InsertNewInstBefore(NewSel, SI);
4021 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(FVI))
4022 return BinaryOperator::create(BO->getOpcode(), TrueVal, NewSel);
4023 else if (ShiftInst *SI = dyn_cast<ShiftInst>(FVI))
4024 return new ShiftInst(SI->getOpcode(), TrueVal, NewSel);
4025 else {
4026 assert(0 && "Unknown instruction!!");
4027 }
4028 }
4029 }
4030 }
Chris Lattnerd6f636a2005-04-24 07:30:14 +00004031
4032 if (BinaryOperator::isNot(CondVal)) {
4033 SI.setOperand(0, BinaryOperator::getNotArgument(CondVal));
4034 SI.setOperand(1, FalseVal);
4035 SI.setOperand(2, TrueVal);
4036 return &SI;
4037 }
4038
Chris Lattnerb909e8b2004-03-12 05:52:32 +00004039 return 0;
4040}
4041
4042
Chris Lattner970c33a2003-06-19 17:00:31 +00004043// CallInst simplification
4044//
4045Instruction *InstCombiner::visitCallInst(CallInst &CI) {
Chris Lattner51ea1272004-02-28 05:22:00 +00004046 // Intrinsics cannot occur in an invoke, so handle them here instead of in
4047 // visitCallSite.
Chris Lattner00648e12004-10-12 04:52:52 +00004048 if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(&CI)) {
4049 bool Changed = false;
4050
4051 // memmove/cpy/set of zero bytes is a noop.
4052 if (Constant *NumBytes = dyn_cast<Constant>(MI->getLength())) {
4053 if (NumBytes->isNullValue()) return EraseInstFromFunction(CI);
4054
4055 // FIXME: Increase alignment here.
Misha Brukmanb1c93172005-04-21 23:48:37 +00004056
Chris Lattner00648e12004-10-12 04:52:52 +00004057 if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes))
4058 if (CI->getRawValue() == 1) {
4059 // Replace the instruction with just byte operations. We would
4060 // transform other cases to loads/stores, but we don't know if
4061 // alignment is sufficient.
4062 }
Chris Lattner51ea1272004-02-28 05:22:00 +00004063 }
4064
Chris Lattner00648e12004-10-12 04:52:52 +00004065 // If we have a memmove and the source operation is a constant global,
4066 // then the source and dest pointers can't alias, so we can change this
4067 // into a call to memcpy.
4068 if (MemMoveInst *MMI = dyn_cast<MemMoveInst>(MI))
4069 if (GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource()))
4070 if (GVSrc->isConstant()) {
4071 Module *M = CI.getParent()->getParent()->getParent();
4072 Function *MemCpy = M->getOrInsertFunction("llvm.memcpy",
4073 CI.getCalledFunction()->getFunctionType());
4074 CI.setOperand(0, MemCpy);
4075 Changed = true;
4076 }
4077
4078 if (Changed) return &CI;
Chris Lattner95307542004-11-18 21:41:39 +00004079 } else if (DbgStopPointInst *SPI = dyn_cast<DbgStopPointInst>(&CI)) {
4080 // If this stoppoint is at the same source location as the previous
4081 // stoppoint in the chain, it is not needed.
4082 if (DbgStopPointInst *PrevSPI =
4083 dyn_cast<DbgStopPointInst>(SPI->getChain()))
4084 if (SPI->getLineNo() == PrevSPI->getLineNo() &&
4085 SPI->getColNo() == PrevSPI->getColNo()) {
4086 SPI->replaceAllUsesWith(PrevSPI);
4087 return EraseInstFromFunction(CI);
4088 }
Chris Lattner00648e12004-10-12 04:52:52 +00004089 }
4090
Chris Lattneraec3d942003-10-07 22:32:43 +00004091 return visitCallSite(&CI);
Chris Lattner970c33a2003-06-19 17:00:31 +00004092}
4093
4094// InvokeInst simplification
4095//
4096Instruction *InstCombiner::visitInvokeInst(InvokeInst &II) {
Chris Lattneraec3d942003-10-07 22:32:43 +00004097 return visitCallSite(&II);
Chris Lattner970c33a2003-06-19 17:00:31 +00004098}
4099
Chris Lattneraec3d942003-10-07 22:32:43 +00004100// visitCallSite - Improvements for call and invoke instructions.
4101//
4102Instruction *InstCombiner::visitCallSite(CallSite CS) {
Chris Lattner75b4d1d2003-10-07 22:54:13 +00004103 bool Changed = false;
4104
4105 // If the callee is a constexpr cast of a function, attempt to move the cast
4106 // to the arguments of the call/invoke.
Chris Lattneraec3d942003-10-07 22:32:43 +00004107 if (transformConstExprCastCall(CS)) return 0;
4108
Chris Lattner75b4d1d2003-10-07 22:54:13 +00004109 Value *Callee = CS.getCalledValue();
Chris Lattner81a7a232004-10-16 18:11:37 +00004110
Chris Lattner61d9d812005-05-13 07:09:09 +00004111 if (Function *CalleeF = dyn_cast<Function>(Callee))
4112 if (CalleeF->getCallingConv() != CS.getCallingConv()) {
4113 Instruction *OldCall = CS.getInstruction();
4114 // If the call and callee calling conventions don't match, this call must
4115 // be unreachable, as the call is undefined.
4116 new StoreInst(ConstantBool::True,
4117 UndefValue::get(PointerType::get(Type::BoolTy)), OldCall);
4118 if (!OldCall->use_empty())
4119 OldCall->replaceAllUsesWith(UndefValue::get(OldCall->getType()));
4120 if (isa<CallInst>(OldCall)) // Not worth removing an invoke here.
4121 return EraseInstFromFunction(*OldCall);
4122 return 0;
4123 }
4124
Chris Lattner8ba9ec92004-10-18 02:59:09 +00004125 if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
4126 // This instruction is not reachable, just remove it. We insert a store to
4127 // undef so that we know that this code is not reachable, despite the fact
4128 // that we can't modify the CFG here.
4129 new StoreInst(ConstantBool::True,
4130 UndefValue::get(PointerType::get(Type::BoolTy)),
4131 CS.getInstruction());
4132
4133 if (!CS.getInstruction()->use_empty())
4134 CS.getInstruction()->
4135 replaceAllUsesWith(UndefValue::get(CS.getInstruction()->getType()));
4136
4137 if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
4138 // Don't break the CFG, insert a dummy cond branch.
4139 new BranchInst(II->getNormalDest(), II->getUnwindDest(),
4140 ConstantBool::True, II);
Chris Lattner81a7a232004-10-16 18:11:37 +00004141 }
Chris Lattner8ba9ec92004-10-18 02:59:09 +00004142 return EraseInstFromFunction(*CS.getInstruction());
4143 }
Chris Lattner81a7a232004-10-16 18:11:37 +00004144
Chris Lattner75b4d1d2003-10-07 22:54:13 +00004145 const PointerType *PTy = cast<PointerType>(Callee->getType());
4146 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
4147 if (FTy->isVarArg()) {
4148 // See if we can optimize any arguments passed through the varargs area of
4149 // the call.
4150 for (CallSite::arg_iterator I = CS.arg_begin()+FTy->getNumParams(),
4151 E = CS.arg_end(); I != E; ++I)
4152 if (CastInst *CI = dyn_cast<CastInst>(*I)) {
4153 // If this cast does not effect the value passed through the varargs
4154 // area, we can eliminate the use of the cast.
4155 Value *Op = CI->getOperand(0);
4156 if (CI->getType()->isLosslesslyConvertibleTo(Op->getType())) {
4157 *I = Op;
4158 Changed = true;
4159 }
4160 }
4161 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00004162
Chris Lattner75b4d1d2003-10-07 22:54:13 +00004163 return Changed ? CS.getInstruction() : 0;
Chris Lattneraec3d942003-10-07 22:32:43 +00004164}
4165
Chris Lattner970c33a2003-06-19 17:00:31 +00004166// transformConstExprCastCall - If the callee is a constexpr cast of a function,
4167// attempt to move the cast to the arguments of the call/invoke.
4168//
4169bool InstCombiner::transformConstExprCastCall(CallSite CS) {
4170 if (!isa<ConstantExpr>(CS.getCalledValue())) return false;
4171 ConstantExpr *CE = cast<ConstantExpr>(CS.getCalledValue());
Chris Lattnerf3edc492004-07-18 18:59:44 +00004172 if (CE->getOpcode() != Instruction::Cast || !isa<Function>(CE->getOperand(0)))
Chris Lattner970c33a2003-06-19 17:00:31 +00004173 return false;
Reid Spencer87436872004-07-18 00:38:32 +00004174 Function *Callee = cast<Function>(CE->getOperand(0));
Chris Lattner970c33a2003-06-19 17:00:31 +00004175 Instruction *Caller = CS.getInstruction();
4176
4177 // Okay, this is a cast from a function to a different type. Unless doing so
4178 // would cause a type conversion of one of our arguments, change this call to
4179 // be a direct call with arguments casted to the appropriate types.
4180 //
4181 const FunctionType *FT = Callee->getFunctionType();
4182 const Type *OldRetTy = Caller->getType();
4183
Chris Lattner1f7942f2004-01-14 06:06:08 +00004184 // Check to see if we are changing the return type...
4185 if (OldRetTy != FT->getReturnType()) {
4186 if (Callee->isExternal() &&
4187 !OldRetTy->isLosslesslyConvertibleTo(FT->getReturnType()) &&
4188 !Caller->use_empty())
4189 return false; // Cannot transform this return value...
4190
4191 // If the callsite is an invoke instruction, and the return value is used by
4192 // a PHI node in a successor, we cannot change the return type of the call
4193 // because there is no place to put the cast instruction (without breaking
4194 // the critical edge). Bail out in this case.
4195 if (!Caller->use_empty())
4196 if (InvokeInst *II = dyn_cast<InvokeInst>(Caller))
4197 for (Value::use_iterator UI = II->use_begin(), E = II->use_end();
4198 UI != E; ++UI)
4199 if (PHINode *PN = dyn_cast<PHINode>(*UI))
4200 if (PN->getParent() == II->getNormalDest() ||
Chris Lattnerfae8ab32004-02-08 21:44:31 +00004201 PN->getParent() == II->getUnwindDest())
Chris Lattner1f7942f2004-01-14 06:06:08 +00004202 return false;
4203 }
Chris Lattner970c33a2003-06-19 17:00:31 +00004204
4205 unsigned NumActualArgs = unsigned(CS.arg_end()-CS.arg_begin());
4206 unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs);
Misha Brukmanb1c93172005-04-21 23:48:37 +00004207
Chris Lattner970c33a2003-06-19 17:00:31 +00004208 CallSite::arg_iterator AI = CS.arg_begin();
4209 for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) {
4210 const Type *ParamTy = FT->getParamType(i);
4211 bool isConvertible = (*AI)->getType()->isLosslesslyConvertibleTo(ParamTy);
Misha Brukmanb1c93172005-04-21 23:48:37 +00004212 if (Callee->isExternal() && !isConvertible) return false;
Chris Lattner970c33a2003-06-19 17:00:31 +00004213 }
4214
4215 if (FT->getNumParams() < NumActualArgs && !FT->isVarArg() &&
4216 Callee->isExternal())
4217 return false; // Do not delete arguments unless we have a function body...
4218
4219 // Okay, we decided that this is a safe thing to do: go ahead and start
4220 // inserting cast instructions as necessary...
4221 std::vector<Value*> Args;
4222 Args.reserve(NumActualArgs);
4223
4224 AI = CS.arg_begin();
4225 for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) {
4226 const Type *ParamTy = FT->getParamType(i);
4227 if ((*AI)->getType() == ParamTy) {
4228 Args.push_back(*AI);
4229 } else {
Chris Lattner1c631e82004-04-08 04:43:23 +00004230 Args.push_back(InsertNewInstBefore(new CastInst(*AI, ParamTy, "tmp"),
4231 *Caller));
Chris Lattner970c33a2003-06-19 17:00:31 +00004232 }
4233 }
4234
4235 // If the function takes more arguments than the call was taking, add them
4236 // now...
4237 for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i)
4238 Args.push_back(Constant::getNullValue(FT->getParamType(i)));
4239
4240 // If we are removing arguments to the function, emit an obnoxious warning...
4241 if (FT->getNumParams() < NumActualArgs)
4242 if (!FT->isVarArg()) {
4243 std::cerr << "WARNING: While resolving call to function '"
4244 << Callee->getName() << "' arguments were dropped!\n";
4245 } else {
4246 // Add all of the arguments in their promoted form to the arg list...
4247 for (unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) {
4248 const Type *PTy = getPromotedType((*AI)->getType());
4249 if (PTy != (*AI)->getType()) {
4250 // Must promote to pass through va_arg area!
4251 Instruction *Cast = new CastInst(*AI, PTy, "tmp");
4252 InsertNewInstBefore(Cast, *Caller);
4253 Args.push_back(Cast);
4254 } else {
4255 Args.push_back(*AI);
4256 }
4257 }
4258 }
4259
4260 if (FT->getReturnType() == Type::VoidTy)
4261 Caller->setName(""); // Void type should not have a name...
4262
4263 Instruction *NC;
4264 if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
Chris Lattnerfae8ab32004-02-08 21:44:31 +00004265 NC = new InvokeInst(Callee, II->getNormalDest(), II->getUnwindDest(),
Chris Lattner970c33a2003-06-19 17:00:31 +00004266 Args, Caller->getName(), Caller);
Chris Lattner05c703e2005-05-14 12:25:32 +00004267 cast<InvokeInst>(II)->setCallingConv(II->getCallingConv());
Chris Lattner970c33a2003-06-19 17:00:31 +00004268 } else {
4269 NC = new CallInst(Callee, Args, Caller->getName(), Caller);
Chris Lattner6aacb0f2005-05-06 06:48:21 +00004270 if (cast<CallInst>(Caller)->isTailCall())
4271 cast<CallInst>(NC)->setTailCall();
Chris Lattner05c703e2005-05-14 12:25:32 +00004272 cast<CallInst>(NC)->setCallingConv(cast<CallInst>(Caller)->getCallingConv());
Chris Lattner970c33a2003-06-19 17:00:31 +00004273 }
4274
4275 // Insert a cast of the return type as necessary...
4276 Value *NV = NC;
4277 if (Caller->getType() != NV->getType() && !Caller->use_empty()) {
4278 if (NV->getType() != Type::VoidTy) {
4279 NV = NC = new CastInst(NC, Caller->getType(), "tmp");
Chris Lattner686767f2003-10-30 00:46:41 +00004280
4281 // If this is an invoke instruction, we should insert it after the first
4282 // non-phi, instruction in the normal successor block.
4283 if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
4284 BasicBlock::iterator I = II->getNormalDest()->begin();
4285 while (isa<PHINode>(I)) ++I;
4286 InsertNewInstBefore(NC, *I);
4287 } else {
4288 // Otherwise, it's a call, just insert cast right after the call instr
4289 InsertNewInstBefore(NC, *Caller);
4290 }
Chris Lattner51ea1272004-02-28 05:22:00 +00004291 AddUsersToWorkList(*Caller);
Chris Lattner970c33a2003-06-19 17:00:31 +00004292 } else {
Chris Lattnere29d6342004-10-17 21:22:38 +00004293 NV = UndefValue::get(Caller->getType());
Chris Lattner970c33a2003-06-19 17:00:31 +00004294 }
4295 }
4296
4297 if (Caller->getType() != Type::VoidTy && !Caller->use_empty())
4298 Caller->replaceAllUsesWith(NV);
4299 Caller->getParent()->getInstList().erase(Caller);
4300 removeFromWorkList(Caller);
4301 return true;
4302}
4303
4304
Chris Lattner7515cab2004-11-14 19:13:23 +00004305// FoldPHIArgOpIntoPHI - If all operands to a PHI node are the same "unary"
4306// operator and they all are only used by the PHI, PHI together their
4307// inputs, and do the operation once, to the result of the PHI.
4308Instruction *InstCombiner::FoldPHIArgOpIntoPHI(PHINode &PN) {
4309 Instruction *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
4310
4311 // Scan the instruction, looking for input operations that can be folded away.
4312 // If all input operands to the phi are the same instruction (e.g. a cast from
4313 // the same type or "+42") we can pull the operation through the PHI, reducing
4314 // code size and simplifying code.
4315 Constant *ConstantOp = 0;
4316 const Type *CastSrcTy = 0;
4317 if (isa<CastInst>(FirstInst)) {
4318 CastSrcTy = FirstInst->getOperand(0)->getType();
4319 } else if (isa<BinaryOperator>(FirstInst) || isa<ShiftInst>(FirstInst)) {
4320 // Can fold binop or shift if the RHS is a constant.
4321 ConstantOp = dyn_cast<Constant>(FirstInst->getOperand(1));
4322 if (ConstantOp == 0) return 0;
4323 } else {
4324 return 0; // Cannot fold this operation.
4325 }
4326
4327 // Check to see if all arguments are the same operation.
4328 for (unsigned i = 1, e = PN.getNumIncomingValues(); i != e; ++i) {
4329 if (!isa<Instruction>(PN.getIncomingValue(i))) return 0;
4330 Instruction *I = cast<Instruction>(PN.getIncomingValue(i));
4331 if (!I->hasOneUse() || I->getOpcode() != FirstInst->getOpcode())
4332 return 0;
4333 if (CastSrcTy) {
4334 if (I->getOperand(0)->getType() != CastSrcTy)
4335 return 0; // Cast operation must match.
4336 } else if (I->getOperand(1) != ConstantOp) {
4337 return 0;
4338 }
4339 }
4340
4341 // Okay, they are all the same operation. Create a new PHI node of the
4342 // correct type, and PHI together all of the LHS's of the instructions.
4343 PHINode *NewPN = new PHINode(FirstInst->getOperand(0)->getType(),
4344 PN.getName()+".in");
Chris Lattnerd8e20182005-01-29 00:39:08 +00004345 NewPN->reserveOperandSpace(PN.getNumOperands()/2);
Chris Lattner46dd5a62004-11-14 19:29:34 +00004346
4347 Value *InVal = FirstInst->getOperand(0);
4348 NewPN->addIncoming(InVal, PN.getIncomingBlock(0));
Chris Lattner7515cab2004-11-14 19:13:23 +00004349
4350 // Add all operands to the new PHI.
Chris Lattner46dd5a62004-11-14 19:29:34 +00004351 for (unsigned i = 1, e = PN.getNumIncomingValues(); i != e; ++i) {
4352 Value *NewInVal = cast<Instruction>(PN.getIncomingValue(i))->getOperand(0);
4353 if (NewInVal != InVal)
4354 InVal = 0;
4355 NewPN->addIncoming(NewInVal, PN.getIncomingBlock(i));
4356 }
4357
4358 Value *PhiVal;
4359 if (InVal) {
4360 // The new PHI unions all of the same values together. This is really
4361 // common, so we handle it intelligently here for compile-time speed.
4362 PhiVal = InVal;
4363 delete NewPN;
4364 } else {
4365 InsertNewInstBefore(NewPN, PN);
4366 PhiVal = NewPN;
4367 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00004368
Chris Lattner7515cab2004-11-14 19:13:23 +00004369 // Insert and return the new operation.
4370 if (isa<CastInst>(FirstInst))
Chris Lattner46dd5a62004-11-14 19:29:34 +00004371 return new CastInst(PhiVal, PN.getType());
Chris Lattner7515cab2004-11-14 19:13:23 +00004372 else if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(FirstInst))
Chris Lattner46dd5a62004-11-14 19:29:34 +00004373 return BinaryOperator::create(BinOp->getOpcode(), PhiVal, ConstantOp);
Chris Lattner7515cab2004-11-14 19:13:23 +00004374 else
4375 return new ShiftInst(cast<ShiftInst>(FirstInst)->getOpcode(),
Chris Lattner46dd5a62004-11-14 19:29:34 +00004376 PhiVal, ConstantOp);
Chris Lattner7515cab2004-11-14 19:13:23 +00004377}
Chris Lattner48a44f72002-05-02 17:06:02 +00004378
Chris Lattner71536432005-01-17 05:10:15 +00004379/// DeadPHICycle - Return true if this PHI node is only used by a PHI node cycle
4380/// that is dead.
4381static bool DeadPHICycle(PHINode *PN, std::set<PHINode*> &PotentiallyDeadPHIs) {
4382 if (PN->use_empty()) return true;
4383 if (!PN->hasOneUse()) return false;
4384
4385 // Remember this node, and if we find the cycle, return.
4386 if (!PotentiallyDeadPHIs.insert(PN).second)
4387 return true;
4388
4389 if (PHINode *PU = dyn_cast<PHINode>(PN->use_back()))
4390 return DeadPHICycle(PU, PotentiallyDeadPHIs);
Misha Brukmanb1c93172005-04-21 23:48:37 +00004391
Chris Lattner71536432005-01-17 05:10:15 +00004392 return false;
4393}
4394
Chris Lattnerbbbdd852002-05-06 18:06:38 +00004395// PHINode simplification
4396//
Chris Lattner113f4f42002-06-25 16:13:24 +00004397Instruction *InstCombiner::visitPHINode(PHINode &PN) {
Chris Lattnere29d6342004-10-17 21:22:38 +00004398 if (Value *V = hasConstantValue(&PN)) {
4399 // If V is an instruction, we have to be certain that it dominates PN.
4400 // However, because we don't have dom info, we can't do a perfect job.
4401 if (Instruction *I = dyn_cast<Instruction>(V)) {
4402 // We know that the instruction dominates the PHI if there are no undef
4403 // values coming in.
Chris Lattner3b92f172004-10-18 01:48:31 +00004404 if (I->getParent() != &I->getParent()->getParent()->front() ||
4405 isa<InvokeInst>(I))
Chris Lattner107c15c2004-10-17 21:31:34 +00004406 for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
4407 if (isa<UndefValue>(PN.getIncomingValue(i))) {
4408 V = 0;
4409 break;
4410 }
Chris Lattnere29d6342004-10-17 21:22:38 +00004411 }
4412
4413 if (V)
4414 return ReplaceInstUsesWith(PN, V);
4415 }
Chris Lattner4db2d222004-02-16 05:07:08 +00004416
4417 // If the only user of this instruction is a cast instruction, and all of the
4418 // incoming values are constants, change this PHI to merge together the casted
4419 // constants.
4420 if (PN.hasOneUse())
4421 if (CastInst *CI = dyn_cast<CastInst>(PN.use_back()))
4422 if (CI->getType() != PN.getType()) { // noop casts will be folded
4423 bool AllConstant = true;
4424 for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
4425 if (!isa<Constant>(PN.getIncomingValue(i))) {
4426 AllConstant = false;
4427 break;
4428 }
4429 if (AllConstant) {
4430 // Make a new PHI with all casted values.
4431 PHINode *New = new PHINode(CI->getType(), PN.getName(), &PN);
4432 for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
4433 Constant *OldArg = cast<Constant>(PN.getIncomingValue(i));
4434 New->addIncoming(ConstantExpr::getCast(OldArg, New->getType()),
4435 PN.getIncomingBlock(i));
4436 }
4437
4438 // Update the cast instruction.
4439 CI->setOperand(0, New);
4440 WorkList.push_back(CI); // revisit the cast instruction to fold.
4441 WorkList.push_back(New); // Make sure to revisit the new Phi
4442 return &PN; // PN is now dead!
4443 }
4444 }
Chris Lattner7515cab2004-11-14 19:13:23 +00004445
4446 // If all PHI operands are the same operation, pull them through the PHI,
4447 // reducing code size.
4448 if (isa<Instruction>(PN.getIncomingValue(0)) &&
4449 PN.getIncomingValue(0)->hasOneUse())
4450 if (Instruction *Result = FoldPHIArgOpIntoPHI(PN))
4451 return Result;
4452
Chris Lattner71536432005-01-17 05:10:15 +00004453 // If this is a trivial cycle in the PHI node graph, remove it. Basically, if
4454 // this PHI only has a single use (a PHI), and if that PHI only has one use (a
4455 // PHI)... break the cycle.
4456 if (PN.hasOneUse())
4457 if (PHINode *PU = dyn_cast<PHINode>(PN.use_back())) {
4458 std::set<PHINode*> PotentiallyDeadPHIs;
4459 PotentiallyDeadPHIs.insert(&PN);
4460 if (DeadPHICycle(PU, PotentiallyDeadPHIs))
4461 return ReplaceInstUsesWith(PN, UndefValue::get(PN.getType()));
4462 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00004463
Chris Lattner91daeb52003-12-19 05:58:40 +00004464 return 0;
Chris Lattnerbbbdd852002-05-06 18:06:38 +00004465}
4466
Chris Lattner69193f92004-04-05 01:30:19 +00004467static Value *InsertSignExtendToPtrTy(Value *V, const Type *DTy,
4468 Instruction *InsertPoint,
4469 InstCombiner *IC) {
4470 unsigned PS = IC->getTargetData().getPointerSize();
4471 const Type *VTy = V->getType();
Chris Lattner69193f92004-04-05 01:30:19 +00004472 if (!VTy->isSigned() && VTy->getPrimitiveSize() < PS)
4473 // We must insert a cast to ensure we sign-extend.
4474 V = IC->InsertNewInstBefore(new CastInst(V, VTy->getSignedVersion(),
4475 V->getName()), *InsertPoint);
4476 return IC->InsertNewInstBefore(new CastInst(V, DTy, V->getName()),
4477 *InsertPoint);
4478}
4479
Chris Lattner48a44f72002-05-02 17:06:02 +00004480
Chris Lattner113f4f42002-06-25 16:13:24 +00004481Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
Chris Lattner5f667a62004-05-07 22:09:22 +00004482 Value *PtrOp = GEP.getOperand(0);
Chris Lattner471bd762003-05-22 19:07:21 +00004483 // Is it 'getelementptr %P, long 0' or 'getelementptr %P'
Chris Lattner113f4f42002-06-25 16:13:24 +00004484 // If so, eliminate the noop.
Chris Lattner8d0bacb2004-02-22 05:25:17 +00004485 if (GEP.getNumOperands() == 1)
Chris Lattner5f667a62004-05-07 22:09:22 +00004486 return ReplaceInstUsesWith(GEP, PtrOp);
Chris Lattner8d0bacb2004-02-22 05:25:17 +00004487
Chris Lattner81a7a232004-10-16 18:11:37 +00004488 if (isa<UndefValue>(GEP.getOperand(0)))
4489 return ReplaceInstUsesWith(GEP, UndefValue::get(GEP.getType()));
4490
Chris Lattner8d0bacb2004-02-22 05:25:17 +00004491 bool HasZeroPointerIndex = false;
4492 if (Constant *C = dyn_cast<Constant>(GEP.getOperand(1)))
4493 HasZeroPointerIndex = C->isNullValue();
4494
4495 if (GEP.getNumOperands() == 2 && HasZeroPointerIndex)
Chris Lattner5f667a62004-05-07 22:09:22 +00004496 return ReplaceInstUsesWith(GEP, PtrOp);
Chris Lattner48a44f72002-05-02 17:06:02 +00004497
Chris Lattner69193f92004-04-05 01:30:19 +00004498 // Eliminate unneeded casts for indices.
4499 bool MadeChange = false;
Chris Lattner2b2412d2004-04-07 18:38:20 +00004500 gep_type_iterator GTI = gep_type_begin(GEP);
4501 for (unsigned i = 1, e = GEP.getNumOperands(); i != e; ++i, ++GTI)
4502 if (isa<SequentialType>(*GTI)) {
4503 if (CastInst *CI = dyn_cast<CastInst>(GEP.getOperand(i))) {
4504 Value *Src = CI->getOperand(0);
4505 const Type *SrcTy = Src->getType();
4506 const Type *DestTy = CI->getType();
4507 if (Src->getType()->isInteger()) {
Chris Lattnerd1f46d32005-04-24 06:59:08 +00004508 if (SrcTy->getPrimitiveSizeInBits() ==
4509 DestTy->getPrimitiveSizeInBits()) {
Chris Lattner2b2412d2004-04-07 18:38:20 +00004510 // We can always eliminate a cast from ulong or long to the other.
4511 // We can always eliminate a cast from uint to int or the other on
4512 // 32-bit pointer platforms.
Chris Lattnerd1f46d32005-04-24 06:59:08 +00004513 if (DestTy->getPrimitiveSizeInBits() >= TD->getPointerSizeInBits()){
Chris Lattner2b2412d2004-04-07 18:38:20 +00004514 MadeChange = true;
4515 GEP.setOperand(i, Src);
4516 }
4517 } else if (SrcTy->getPrimitiveSize() < DestTy->getPrimitiveSize() &&
4518 SrcTy->getPrimitiveSize() == 4) {
4519 // We can always eliminate a cast from int to [u]long. We can
4520 // eliminate a cast from uint to [u]long iff the target is a 32-bit
4521 // pointer target.
Misha Brukmanb1c93172005-04-21 23:48:37 +00004522 if (SrcTy->isSigned() ||
Chris Lattnerd1f46d32005-04-24 06:59:08 +00004523 SrcTy->getPrimitiveSizeInBits() >= TD->getPointerSizeInBits()) {
Chris Lattner2b2412d2004-04-07 18:38:20 +00004524 MadeChange = true;
4525 GEP.setOperand(i, Src);
4526 }
Chris Lattner69193f92004-04-05 01:30:19 +00004527 }
4528 }
4529 }
Chris Lattner2b2412d2004-04-07 18:38:20 +00004530 // If we are using a wider index than needed for this platform, shrink it
4531 // to what we need. If the incoming value needs a cast instruction,
4532 // insert it. This explicit cast can make subsequent optimizations more
4533 // obvious.
4534 Value *Op = GEP.getOperand(i);
4535 if (Op->getType()->getPrimitiveSize() > TD->getPointerSize())
Chris Lattner1e9ac1a2004-04-17 18:16:10 +00004536 if (Constant *C = dyn_cast<Constant>(Op)) {
Chris Lattner44d0b952004-07-20 01:48:15 +00004537 GEP.setOperand(i, ConstantExpr::getCast(C,
4538 TD->getIntPtrType()->getSignedVersion()));
Chris Lattner1e9ac1a2004-04-17 18:16:10 +00004539 MadeChange = true;
4540 } else {
Chris Lattner2b2412d2004-04-07 18:38:20 +00004541 Op = InsertNewInstBefore(new CastInst(Op, TD->getIntPtrType(),
4542 Op->getName()), GEP);
4543 GEP.setOperand(i, Op);
4544 MadeChange = true;
4545 }
Chris Lattner44d0b952004-07-20 01:48:15 +00004546
4547 // If this is a constant idx, make sure to canonicalize it to be a signed
4548 // operand, otherwise CSE and other optimizations are pessimized.
4549 if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(Op)) {
4550 GEP.setOperand(i, ConstantExpr::getCast(CUI,
4551 CUI->getType()->getSignedVersion()));
4552 MadeChange = true;
4553 }
Chris Lattner69193f92004-04-05 01:30:19 +00004554 }
4555 if (MadeChange) return &GEP;
4556
Chris Lattnerae7a0d32002-08-02 19:29:35 +00004557 // Combine Indices - If the source pointer to this getelementptr instruction
4558 // is a getelementptr instruction, combine the indices of the two
4559 // getelementptr instructions into a single instruction.
4560 //
Chris Lattner57c67b02004-03-25 22:59:29 +00004561 std::vector<Value*> SrcGEPOperands;
Chris Lattner0798af32005-01-13 20:14:25 +00004562 if (User *Src = dyn_castGetElementPtr(PtrOp))
Chris Lattner57c67b02004-03-25 22:59:29 +00004563 SrcGEPOperands.assign(Src->op_begin(), Src->op_end());
Chris Lattner57c67b02004-03-25 22:59:29 +00004564
4565 if (!SrcGEPOperands.empty()) {
Chris Lattner5f667a62004-05-07 22:09:22 +00004566 // Note that if our source is a gep chain itself that we wait for that
4567 // chain to be resolved before we perform this transformation. This
4568 // avoids us creating a TON of code in some cases.
4569 //
4570 if (isa<GetElementPtrInst>(SrcGEPOperands[0]) &&
4571 cast<Instruction>(SrcGEPOperands[0])->getNumOperands() == 2)
4572 return 0; // Wait until our source is folded to completion.
4573
Chris Lattnerae7a0d32002-08-02 19:29:35 +00004574 std::vector<Value *> Indices;
Chris Lattner5f667a62004-05-07 22:09:22 +00004575
4576 // Find out whether the last index in the source GEP is a sequential idx.
4577 bool EndsWithSequential = false;
4578 for (gep_type_iterator I = gep_type_begin(*cast<User>(PtrOp)),
4579 E = gep_type_end(*cast<User>(PtrOp)); I != E; ++I)
Chris Lattner8ec5f882004-05-08 22:41:42 +00004580 EndsWithSequential = !isa<StructType>(*I);
Misha Brukmanb1c93172005-04-21 23:48:37 +00004581
Chris Lattnerae7a0d32002-08-02 19:29:35 +00004582 // Can we combine the two pointer arithmetics offsets?
Chris Lattner5f667a62004-05-07 22:09:22 +00004583 if (EndsWithSequential) {
Chris Lattner235af562003-03-05 22:33:14 +00004584 // Replace: gep (gep %P, long B), long A, ...
4585 // With: T = long A+B; gep %P, T, ...
4586 //
Chris Lattner5f667a62004-05-07 22:09:22 +00004587 Value *Sum, *SO1 = SrcGEPOperands.back(), *GO1 = GEP.getOperand(1);
Chris Lattner69193f92004-04-05 01:30:19 +00004588 if (SO1 == Constant::getNullValue(SO1->getType())) {
4589 Sum = GO1;
4590 } else if (GO1 == Constant::getNullValue(GO1->getType())) {
4591 Sum = SO1;
4592 } else {
4593 // If they aren't the same type, convert both to an integer of the
4594 // target's pointer size.
4595 if (SO1->getType() != GO1->getType()) {
4596 if (Constant *SO1C = dyn_cast<Constant>(SO1)) {
4597 SO1 = ConstantExpr::getCast(SO1C, GO1->getType());
4598 } else if (Constant *GO1C = dyn_cast<Constant>(GO1)) {
4599 GO1 = ConstantExpr::getCast(GO1C, SO1->getType());
4600 } else {
4601 unsigned PS = TD->getPointerSize();
Chris Lattner69193f92004-04-05 01:30:19 +00004602 if (SO1->getType()->getPrimitiveSize() == PS) {
4603 // Convert GO1 to SO1's type.
4604 GO1 = InsertSignExtendToPtrTy(GO1, SO1->getType(), &GEP, this);
4605
4606 } else if (GO1->getType()->getPrimitiveSize() == PS) {
4607 // Convert SO1 to GO1's type.
4608 SO1 = InsertSignExtendToPtrTy(SO1, GO1->getType(), &GEP, this);
4609 } else {
4610 const Type *PT = TD->getIntPtrType();
4611 SO1 = InsertSignExtendToPtrTy(SO1, PT, &GEP, this);
4612 GO1 = InsertSignExtendToPtrTy(GO1, PT, &GEP, this);
4613 }
4614 }
4615 }
Chris Lattner5f667a62004-05-07 22:09:22 +00004616 if (isa<Constant>(SO1) && isa<Constant>(GO1))
4617 Sum = ConstantExpr::getAdd(cast<Constant>(SO1), cast<Constant>(GO1));
4618 else {
Chris Lattnerdf20a4d2004-06-10 02:07:29 +00004619 Sum = BinaryOperator::createAdd(SO1, GO1, PtrOp->getName()+".sum");
4620 InsertNewInstBefore(cast<Instruction>(Sum), GEP);
Chris Lattner5f667a62004-05-07 22:09:22 +00004621 }
Chris Lattner69193f92004-04-05 01:30:19 +00004622 }
Chris Lattner5f667a62004-05-07 22:09:22 +00004623
4624 // Recycle the GEP we already have if possible.
4625 if (SrcGEPOperands.size() == 2) {
4626 GEP.setOperand(0, SrcGEPOperands[0]);
4627 GEP.setOperand(1, Sum);
4628 return &GEP;
4629 } else {
4630 Indices.insert(Indices.end(), SrcGEPOperands.begin()+1,
4631 SrcGEPOperands.end()-1);
4632 Indices.push_back(Sum);
4633 Indices.insert(Indices.end(), GEP.op_begin()+2, GEP.op_end());
4634 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00004635 } else if (isa<Constant>(*GEP.idx_begin()) &&
Chris Lattner69193f92004-04-05 01:30:19 +00004636 cast<Constant>(*GEP.idx_begin())->isNullValue() &&
Misha Brukmanb1c93172005-04-21 23:48:37 +00004637 SrcGEPOperands.size() != 1) {
Chris Lattnerae7a0d32002-08-02 19:29:35 +00004638 // Otherwise we can do the fold if the first index of the GEP is a zero
Chris Lattner57c67b02004-03-25 22:59:29 +00004639 Indices.insert(Indices.end(), SrcGEPOperands.begin()+1,
4640 SrcGEPOperands.end());
Chris Lattnerae7a0d32002-08-02 19:29:35 +00004641 Indices.insert(Indices.end(), GEP.idx_begin()+1, GEP.idx_end());
4642 }
4643
4644 if (!Indices.empty())
Chris Lattner57c67b02004-03-25 22:59:29 +00004645 return new GetElementPtrInst(SrcGEPOperands[0], Indices, GEP.getName());
Chris Lattnerc59af1d2002-08-17 22:21:59 +00004646
Chris Lattner5f667a62004-05-07 22:09:22 +00004647 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(PtrOp)) {
Chris Lattnerc59af1d2002-08-17 22:21:59 +00004648 // GEP of global variable. If all of the indices for this GEP are
4649 // constants, we can promote this to a constexpr instead of an instruction.
4650
4651 // Scan for nonconstants...
4652 std::vector<Constant*> Indices;
4653 User::op_iterator I = GEP.idx_begin(), E = GEP.idx_end();
4654 for (; I != E && isa<Constant>(*I); ++I)
4655 Indices.push_back(cast<Constant>(*I));
4656
4657 if (I == E) { // If they are all constants...
Chris Lattnerf3edc492004-07-18 18:59:44 +00004658 Constant *CE = ConstantExpr::getGetElementPtr(GV, Indices);
Chris Lattnerc59af1d2002-08-17 22:21:59 +00004659
4660 // Replace all uses of the GEP with the new constexpr...
4661 return ReplaceInstUsesWith(GEP, CE);
4662 }
Chris Lattner5f667a62004-05-07 22:09:22 +00004663 } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(PtrOp)) {
Chris Lattner8d0bacb2004-02-22 05:25:17 +00004664 if (CE->getOpcode() == Instruction::Cast) {
4665 if (HasZeroPointerIndex) {
4666 // transform: GEP (cast [10 x ubyte]* X to [0 x ubyte]*), long 0, ...
4667 // into : GEP [10 x ubyte]* X, long 0, ...
4668 //
4669 // This occurs when the program declares an array extern like "int X[];"
4670 //
4671 Constant *X = CE->getOperand(0);
4672 const PointerType *CPTy = cast<PointerType>(CE->getType());
4673 if (const PointerType *XTy = dyn_cast<PointerType>(X->getType()))
4674 if (const ArrayType *XATy =
4675 dyn_cast<ArrayType>(XTy->getElementType()))
4676 if (const ArrayType *CATy =
4677 dyn_cast<ArrayType>(CPTy->getElementType()))
4678 if (CATy->getElementType() == XATy->getElementType()) {
4679 // At this point, we know that the cast source type is a pointer
4680 // to an array of the same type as the destination pointer
4681 // array. Because the array type is never stepped over (there
4682 // is a leading zero) we can fold the cast into this GEP.
4683 GEP.setOperand(0, X);
4684 return &GEP;
4685 }
Chris Lattner0798af32005-01-13 20:14:25 +00004686 } else if (GEP.getNumOperands() == 2 &&
4687 isa<PointerType>(CE->getOperand(0)->getType())) {
Chris Lattner14f3cdc2004-11-27 17:55:46 +00004688 // Transform things like:
4689 // %t = getelementptr ubyte* cast ([2 x sbyte]* %str to ubyte*), uint %V
4690 // into: %t1 = getelementptr [2 x sbyte*]* %str, int 0, uint %V; cast
4691 Constant *X = CE->getOperand(0);
4692 const Type *SrcElTy = cast<PointerType>(X->getType())->getElementType();
4693 const Type *ResElTy =cast<PointerType>(CE->getType())->getElementType();
4694 if (isa<ArrayType>(SrcElTy) &&
Misha Brukmanb1c93172005-04-21 23:48:37 +00004695 TD->getTypeSize(cast<ArrayType>(SrcElTy)->getElementType()) ==
Chris Lattner14f3cdc2004-11-27 17:55:46 +00004696 TD->getTypeSize(ResElTy)) {
4697 Value *V = InsertNewInstBefore(
4698 new GetElementPtrInst(X, Constant::getNullValue(Type::IntTy),
4699 GEP.getOperand(1), GEP.getName()), GEP);
4700 return new CastInst(V, GEP.getType());
4701 }
Chris Lattner8d0bacb2004-02-22 05:25:17 +00004702 }
4703 }
Chris Lattnerca081252001-12-14 16:52:21 +00004704 }
4705
Chris Lattnerca081252001-12-14 16:52:21 +00004706 return 0;
4707}
4708
Chris Lattner1085bdf2002-11-04 16:18:53 +00004709Instruction *InstCombiner::visitAllocationInst(AllocationInst &AI) {
4710 // Convert: malloc Ty, C - where C is a constant != 1 into: malloc [C x Ty], 1
4711 if (AI.isArrayAllocation()) // Check C != 1
4712 if (const ConstantUInt *C = dyn_cast<ConstantUInt>(AI.getArraySize())) {
4713 const Type *NewTy = ArrayType::get(AI.getAllocatedType(), C->getValue());
Chris Lattnera2620ac2002-11-09 00:49:43 +00004714 AllocationInst *New = 0;
Chris Lattner1085bdf2002-11-04 16:18:53 +00004715
4716 // Create and insert the replacement instruction...
4717 if (isa<MallocInst>(AI))
Chris Lattnerabb77c92004-03-19 06:08:10 +00004718 New = new MallocInst(NewTy, 0, AI.getName());
Chris Lattnera2620ac2002-11-09 00:49:43 +00004719 else {
4720 assert(isa<AllocaInst>(AI) && "Unknown type of allocation inst!");
Chris Lattnerabb77c92004-03-19 06:08:10 +00004721 New = new AllocaInst(NewTy, 0, AI.getName());
Chris Lattnera2620ac2002-11-09 00:49:43 +00004722 }
Chris Lattnerabb77c92004-03-19 06:08:10 +00004723
4724 InsertNewInstBefore(New, AI);
Misha Brukmanb1c93172005-04-21 23:48:37 +00004725
Chris Lattner1085bdf2002-11-04 16:18:53 +00004726 // Scan to the end of the allocation instructions, to skip over a block of
4727 // allocas if possible...
4728 //
4729 BasicBlock::iterator It = New;
4730 while (isa<AllocationInst>(*It)) ++It;
4731
4732 // Now that I is pointing to the first non-allocation-inst in the block,
4733 // insert our getelementptr instruction...
4734 //
Chris Lattner809dfac2005-05-04 19:10:26 +00004735 Value *NullIdx = Constant::getNullValue(Type::IntTy);
4736 Value *V = new GetElementPtrInst(New, NullIdx, NullIdx,
4737 New->getName()+".sub", It);
Chris Lattner1085bdf2002-11-04 16:18:53 +00004738
4739 // Now make everything use the getelementptr instead of the original
4740 // allocation.
Chris Lattnerabb77c92004-03-19 06:08:10 +00004741 return ReplaceInstUsesWith(AI, V);
Chris Lattner81a7a232004-10-16 18:11:37 +00004742 } else if (isa<UndefValue>(AI.getArraySize())) {
4743 return ReplaceInstUsesWith(AI, Constant::getNullValue(AI.getType()));
Chris Lattner1085bdf2002-11-04 16:18:53 +00004744 }
Chris Lattnerabb77c92004-03-19 06:08:10 +00004745
4746 // If alloca'ing a zero byte object, replace the alloca with a null pointer.
4747 // Note that we only do this for alloca's, because malloc should allocate and
4748 // return a unique pointer, even for a zero byte allocation.
Misha Brukmanb1c93172005-04-21 23:48:37 +00004749 if (isa<AllocaInst>(AI) && AI.getAllocatedType()->isSized() &&
Chris Lattner49df6ce2004-07-02 22:55:47 +00004750 TD->getTypeSize(AI.getAllocatedType()) == 0)
Chris Lattnerabb77c92004-03-19 06:08:10 +00004751 return ReplaceInstUsesWith(AI, Constant::getNullValue(AI.getType()));
4752
Chris Lattner1085bdf2002-11-04 16:18:53 +00004753 return 0;
4754}
4755
Chris Lattner8427bff2003-12-07 01:24:23 +00004756Instruction *InstCombiner::visitFreeInst(FreeInst &FI) {
4757 Value *Op = FI.getOperand(0);
4758
4759 // Change free <ty>* (cast <ty2>* X to <ty>*) into free <ty2>* X
4760 if (CastInst *CI = dyn_cast<CastInst>(Op))
4761 if (isa<PointerType>(CI->getOperand(0)->getType())) {
4762 FI.setOperand(0, CI->getOperand(0));
4763 return &FI;
4764 }
4765
Chris Lattner8ba9ec92004-10-18 02:59:09 +00004766 // free undef -> unreachable.
4767 if (isa<UndefValue>(Op)) {
4768 // Insert a new store to null because we cannot modify the CFG here.
4769 new StoreInst(ConstantBool::True,
4770 UndefValue::get(PointerType::get(Type::BoolTy)), &FI);
4771 return EraseInstFromFunction(FI);
4772 }
4773
Chris Lattnerf3a36602004-02-28 04:57:37 +00004774 // If we have 'free null' delete the instruction. This can happen in stl code
4775 // when lots of inlining happens.
Chris Lattner8ba9ec92004-10-18 02:59:09 +00004776 if (isa<ConstantPointerNull>(Op))
Chris Lattner51ea1272004-02-28 05:22:00 +00004777 return EraseInstFromFunction(FI);
Chris Lattnerf3a36602004-02-28 04:57:37 +00004778
Chris Lattner8427bff2003-12-07 01:24:23 +00004779 return 0;
4780}
4781
4782
Chris Lattner0f1d8a32003-06-26 05:06:25 +00004783/// GetGEPGlobalInitializer - Given a constant, and a getelementptr
4784/// constantexpr, return the constant value being addressed by the constant
4785/// expression, or null if something is funny.
4786///
4787static Constant *GetGEPGlobalInitializer(Constant *C, ConstantExpr *CE) {
Chris Lattner69193f92004-04-05 01:30:19 +00004788 if (CE->getOperand(1) != Constant::getNullValue(CE->getOperand(1)->getType()))
Chris Lattner0f1d8a32003-06-26 05:06:25 +00004789 return 0; // Do not allow stepping over the value!
4790
4791 // Loop over all of the operands, tracking down which value we are
4792 // addressing...
Chris Lattnered79d8a2004-05-27 17:30:27 +00004793 gep_type_iterator I = gep_type_begin(CE), E = gep_type_end(CE);
4794 for (++I; I != E; ++I)
4795 if (const StructType *STy = dyn_cast<StructType>(*I)) {
4796 ConstantUInt *CU = cast<ConstantUInt>(I.getOperand());
4797 assert(CU->getValue() < STy->getNumElements() &&
4798 "Struct index out of range!");
Chris Lattnerfdfe3e492005-01-08 19:42:22 +00004799 unsigned El = (unsigned)CU->getValue();
Chris Lattnered79d8a2004-05-27 17:30:27 +00004800 if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) {
Chris Lattnerfdfe3e492005-01-08 19:42:22 +00004801 C = CS->getOperand(El);
Chris Lattnered79d8a2004-05-27 17:30:27 +00004802 } else if (isa<ConstantAggregateZero>(C)) {
Jeff Cohen82639852005-04-23 21:38:35 +00004803 C = Constant::getNullValue(STy->getElementType(El));
Chris Lattner81a7a232004-10-16 18:11:37 +00004804 } else if (isa<UndefValue>(C)) {
Jeff Cohen82639852005-04-23 21:38:35 +00004805 C = UndefValue::get(STy->getElementType(El));
Chris Lattnered79d8a2004-05-27 17:30:27 +00004806 } else {
4807 return 0;
4808 }
4809 } else if (ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand())) {
4810 const ArrayType *ATy = cast<ArrayType>(*I);
4811 if ((uint64_t)CI->getRawValue() >= ATy->getNumElements()) return 0;
4812 if (ConstantArray *CA = dyn_cast<ConstantArray>(C))
Chris Lattnerfdfe3e492005-01-08 19:42:22 +00004813 C = CA->getOperand((unsigned)CI->getRawValue());
Chris Lattnered79d8a2004-05-27 17:30:27 +00004814 else if (isa<ConstantAggregateZero>(C))
4815 C = Constant::getNullValue(ATy->getElementType());
Chris Lattner81a7a232004-10-16 18:11:37 +00004816 else if (isa<UndefValue>(C))
4817 C = UndefValue::get(ATy->getElementType());
Chris Lattnered79d8a2004-05-27 17:30:27 +00004818 else
4819 return 0;
4820 } else {
Chris Lattner0f1d8a32003-06-26 05:06:25 +00004821 return 0;
Chris Lattnered79d8a2004-05-27 17:30:27 +00004822 }
Chris Lattner0f1d8a32003-06-26 05:06:25 +00004823 return C;
4824}
4825
Chris Lattner72684fe2005-01-31 05:51:45 +00004826/// InstCombineLoadCast - Fold 'load (cast P)' -> cast (load P)' when possible.
Chris Lattner35e24772004-07-13 01:49:43 +00004827static Instruction *InstCombineLoadCast(InstCombiner &IC, LoadInst &LI) {
4828 User *CI = cast<User>(LI.getOperand(0));
Chris Lattnerfe1b0b82005-01-31 04:50:46 +00004829 Value *CastOp = CI->getOperand(0);
Chris Lattner35e24772004-07-13 01:49:43 +00004830
4831 const Type *DestPTy = cast<PointerType>(CI->getType())->getElementType();
Chris Lattnerfe1b0b82005-01-31 04:50:46 +00004832 if (const PointerType *SrcTy = dyn_cast<PointerType>(CastOp->getType())) {
Chris Lattner35e24772004-07-13 01:49:43 +00004833 const Type *SrcPTy = SrcTy->getElementType();
Chris Lattnerfe1b0b82005-01-31 04:50:46 +00004834
4835 if (DestPTy->isInteger() || isa<PointerType>(DestPTy)) {
4836 // If the source is an array, the code below will not succeed. Check to
4837 // see if a trivial 'gep P, 0, 0' will help matters. Only do this for
4838 // constants.
4839 if (const ArrayType *ASrcTy = dyn_cast<ArrayType>(SrcPTy))
4840 if (Constant *CSrc = dyn_cast<Constant>(CastOp))
4841 if (ASrcTy->getNumElements() != 0) {
4842 std::vector<Value*> Idxs(2, Constant::getNullValue(Type::IntTy));
4843 CastOp = ConstantExpr::getGetElementPtr(CSrc, Idxs);
4844 SrcTy = cast<PointerType>(CastOp->getType());
4845 SrcPTy = SrcTy->getElementType();
4846 }
4847
4848 if ((SrcPTy->isInteger() || isa<PointerType>(SrcPTy)) &&
Chris Lattnerecfa9b52005-03-29 06:37:47 +00004849 // Do not allow turning this into a load of an integer, which is then
4850 // casted to a pointer, this pessimizes pointer analysis a lot.
4851 (isa<PointerType>(SrcPTy) == isa<PointerType>(LI.getType())) &&
Misha Brukmanb1c93172005-04-21 23:48:37 +00004852 IC.getTargetData().getTypeSize(SrcPTy) ==
Chris Lattnerfe1b0b82005-01-31 04:50:46 +00004853 IC.getTargetData().getTypeSize(DestPTy)) {
Misha Brukmanb1c93172005-04-21 23:48:37 +00004854
Chris Lattnerfe1b0b82005-01-31 04:50:46 +00004855 // Okay, we are casting from one integer or pointer type to another of
4856 // the same size. Instead of casting the pointer before the load, cast
4857 // the result of the loaded value.
4858 Value *NewLoad = IC.InsertNewInstBefore(new LoadInst(CastOp,
4859 CI->getName(),
4860 LI.isVolatile()),LI);
4861 // Now cast the result of the load.
4862 return new CastInst(NewLoad, LI.getType());
4863 }
Chris Lattner35e24772004-07-13 01:49:43 +00004864 }
4865 }
4866 return 0;
4867}
4868
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00004869/// isSafeToLoadUnconditionally - Return true if we know that executing a load
Chris Lattnere6f13092004-09-19 19:18:10 +00004870/// from this value cannot trap. If it is not obviously safe to load from the
4871/// specified pointer, we do a quick local scan of the basic block containing
4872/// ScanFrom, to determine if the address is already accessed.
4873static bool isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom) {
4874 // If it is an alloca or global variable, it is always safe to load from.
4875 if (isa<AllocaInst>(V) || isa<GlobalVariable>(V)) return true;
4876
4877 // Otherwise, be a little bit agressive by scanning the local block where we
4878 // want to check to see if the pointer is already being loaded or stored
Alkis Evlogimenosd59cebf2004-09-20 06:42:58 +00004879 // from/to. If so, the previous load or store would have already trapped,
4880 // so there is no harm doing an extra load (also, CSE will later eliminate
4881 // the load entirely).
Chris Lattnere6f13092004-09-19 19:18:10 +00004882 BasicBlock::iterator BBI = ScanFrom, E = ScanFrom->getParent()->begin();
4883
Alkis Evlogimenosd59cebf2004-09-20 06:42:58 +00004884 while (BBI != E) {
Chris Lattnere6f13092004-09-19 19:18:10 +00004885 --BBI;
4886
4887 if (LoadInst *LI = dyn_cast<LoadInst>(BBI)) {
4888 if (LI->getOperand(0) == V) return true;
4889 } else if (StoreInst *SI = dyn_cast<StoreInst>(BBI))
4890 if (SI->getOperand(1) == V) return true;
Misha Brukmanb1c93172005-04-21 23:48:37 +00004891
Alkis Evlogimenosd59cebf2004-09-20 06:42:58 +00004892 }
Chris Lattnere6f13092004-09-19 19:18:10 +00004893 return false;
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00004894}
4895
Chris Lattner0f1d8a32003-06-26 05:06:25 +00004896Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
4897 Value *Op = LI.getOperand(0);
Chris Lattner7e8af382004-01-12 04:13:56 +00004898
Chris Lattnera9d84e32005-05-01 04:24:53 +00004899 // load (cast X) --> cast (load X) iff safe
4900 if (CastInst *CI = dyn_cast<CastInst>(Op))
4901 if (Instruction *Res = InstCombineLoadCast(*this, LI))
4902 return Res;
4903
4904 // None of the following transforms are legal for volatile loads.
4905 if (LI.isVolatile()) return 0;
4906
4907 if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(Op))
4908 if (isa<ConstantPointerNull>(GEPI->getOperand(0)) ||
4909 isa<UndefValue>(GEPI->getOperand(0))) {
4910 // Insert a new store to null instruction before the load to indicate
4911 // that this code is not reachable. We do this instead of inserting
4912 // an unreachable instruction directly because we cannot modify the
4913 // CFG.
4914 new StoreInst(UndefValue::get(LI.getType()),
4915 Constant::getNullValue(Op->getType()), &LI);
4916 return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
4917 }
4918
Chris Lattner81a7a232004-10-16 18:11:37 +00004919 if (Constant *C = dyn_cast<Constant>(Op)) {
Chris Lattnera9d84e32005-05-01 04:24:53 +00004920 // load null/undef -> undef
4921 if ((C->isNullValue() || isa<UndefValue>(C))) {
Chris Lattner8ba9ec92004-10-18 02:59:09 +00004922 // Insert a new store to null instruction before the load to indicate that
4923 // this code is not reachable. We do this instead of inserting an
4924 // unreachable instruction directly because we cannot modify the CFG.
Chris Lattnera9d84e32005-05-01 04:24:53 +00004925 new StoreInst(UndefValue::get(LI.getType()),
4926 Constant::getNullValue(Op->getType()), &LI);
Chris Lattner81a7a232004-10-16 18:11:37 +00004927 return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
Chris Lattner8ba9ec92004-10-18 02:59:09 +00004928 }
Chris Lattner0f1d8a32003-06-26 05:06:25 +00004929
Chris Lattner81a7a232004-10-16 18:11:37 +00004930 // Instcombine load (constant global) into the value loaded.
4931 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Op))
4932 if (GV->isConstant() && !GV->isExternal())
4933 return ReplaceInstUsesWith(LI, GV->getInitializer());
Misha Brukmanb1c93172005-04-21 23:48:37 +00004934
Chris Lattner81a7a232004-10-16 18:11:37 +00004935 // Instcombine load (constantexpr_GEP global, 0, ...) into the value loaded.
4936 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Op))
4937 if (CE->getOpcode() == Instruction::GetElementPtr) {
4938 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(CE->getOperand(0)))
4939 if (GV->isConstant() && !GV->isExternal())
4940 if (Constant *V = GetGEPGlobalInitializer(GV->getInitializer(), CE))
4941 return ReplaceInstUsesWith(LI, V);
Chris Lattnera9d84e32005-05-01 04:24:53 +00004942 if (CE->getOperand(0)->isNullValue()) {
4943 // Insert a new store to null instruction before the load to indicate
4944 // that this code is not reachable. We do this instead of inserting
4945 // an unreachable instruction directly because we cannot modify the
4946 // CFG.
4947 new StoreInst(UndefValue::get(LI.getType()),
4948 Constant::getNullValue(Op->getType()), &LI);
4949 return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType()));
4950 }
4951
Chris Lattner81a7a232004-10-16 18:11:37 +00004952 } else if (CE->getOpcode() == Instruction::Cast) {
4953 if (Instruction *Res = InstCombineLoadCast(*this, LI))
4954 return Res;
4955 }
4956 }
Chris Lattnere228ee52004-04-08 20:39:49 +00004957
Chris Lattnera9d84e32005-05-01 04:24:53 +00004958 if (Op->hasOneUse()) {
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00004959 // Change select and PHI nodes to select values instead of addresses: this
4960 // helps alias analysis out a lot, allows many others simplifications, and
4961 // exposes redundancy in the code.
4962 //
4963 // Note that we cannot do the transformation unless we know that the
4964 // introduced loads cannot trap! Something like this is valid as long as
4965 // the condition is always false: load (select bool %C, int* null, int* %G),
4966 // but it would not be valid if we transformed it to load from null
4967 // unconditionally.
4968 //
4969 if (SelectInst *SI = dyn_cast<SelectInst>(Op)) {
4970 // load (select (Cond, &V1, &V2)) --> select(Cond, load &V1, load &V2).
Chris Lattnere6f13092004-09-19 19:18:10 +00004971 if (isSafeToLoadUnconditionally(SI->getOperand(1), SI) &&
4972 isSafeToLoadUnconditionally(SI->getOperand(2), SI)) {
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00004973 Value *V1 = InsertNewInstBefore(new LoadInst(SI->getOperand(1),
Chris Lattner42618552004-09-20 10:15:10 +00004974 SI->getOperand(1)->getName()+".val"), LI);
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00004975 Value *V2 = InsertNewInstBefore(new LoadInst(SI->getOperand(2),
Chris Lattner42618552004-09-20 10:15:10 +00004976 SI->getOperand(2)->getName()+".val"), LI);
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00004977 return new SelectInst(SI->getCondition(), V1, V2);
4978 }
4979
Chris Lattnerbdcf41a2004-09-23 15:46:00 +00004980 // load (select (cond, null, P)) -> load P
4981 if (Constant *C = dyn_cast<Constant>(SI->getOperand(1)))
4982 if (C->isNullValue()) {
4983 LI.setOperand(0, SI->getOperand(2));
4984 return &LI;
4985 }
4986
4987 // load (select (cond, P, null)) -> load P
4988 if (Constant *C = dyn_cast<Constant>(SI->getOperand(2)))
4989 if (C->isNullValue()) {
4990 LI.setOperand(0, SI->getOperand(1));
4991 return &LI;
4992 }
4993
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00004994 } else if (PHINode *PN = dyn_cast<PHINode>(Op)) {
4995 // load (phi (&V1, &V2, &V3)) --> phi(load &V1, load &V2, load &V3)
Chris Lattner42618552004-09-20 10:15:10 +00004996 bool Safe = PN->getParent() == LI.getParent();
4997
4998 // Scan all of the instructions between the PHI and the load to make
4999 // sure there are no instructions that might possibly alter the value
5000 // loaded from the PHI.
5001 if (Safe) {
5002 BasicBlock::iterator I = &LI;
5003 for (--I; !isa<PHINode>(I); --I)
5004 if (isa<StoreInst>(I) || isa<CallInst>(I)) {
5005 Safe = false;
5006 break;
5007 }
5008 }
5009
5010 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e && Safe; ++i)
Chris Lattnere6f13092004-09-19 19:18:10 +00005011 if (!isSafeToLoadUnconditionally(PN->getIncomingValue(i),
Chris Lattner42618552004-09-20 10:15:10 +00005012 PN->getIncomingBlock(i)->getTerminator()))
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00005013 Safe = false;
Chris Lattner42618552004-09-20 10:15:10 +00005014
Chris Lattnerf62ea8e2004-09-19 18:43:46 +00005015 if (Safe) {
5016 // Create the PHI.
5017 PHINode *NewPN = new PHINode(LI.getType(), PN->getName());
5018 InsertNewInstBefore(NewPN, *PN);
5019 std::map<BasicBlock*,Value*> LoadMap; // Don't insert duplicate loads
5020
5021 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
5022 BasicBlock *BB = PN->getIncomingBlock(i);
5023 Value *&TheLoad = LoadMap[BB];
5024 if (TheLoad == 0) {
5025 Value *InVal = PN->getIncomingValue(i);
5026 TheLoad = InsertNewInstBefore(new LoadInst(InVal,
5027 InVal->getName()+".val"),
5028 *BB->getTerminator());
5029 }
5030 NewPN->addIncoming(TheLoad, BB);
5031 }
5032 return ReplaceInstUsesWith(LI, NewPN);
5033 }
5034 }
5035 }
Chris Lattner0f1d8a32003-06-26 05:06:25 +00005036 return 0;
5037}
5038
Chris Lattner72684fe2005-01-31 05:51:45 +00005039/// InstCombineStoreToCast - Fold 'store V, (cast P)' -> store (cast V), P'
5040/// when possible.
5041static Instruction *InstCombineStoreToCast(InstCombiner &IC, StoreInst &SI) {
5042 User *CI = cast<User>(SI.getOperand(1));
5043 Value *CastOp = CI->getOperand(0);
5044
5045 const Type *DestPTy = cast<PointerType>(CI->getType())->getElementType();
5046 if (const PointerType *SrcTy = dyn_cast<PointerType>(CastOp->getType())) {
5047 const Type *SrcPTy = SrcTy->getElementType();
5048
5049 if (DestPTy->isInteger() || isa<PointerType>(DestPTy)) {
5050 // If the source is an array, the code below will not succeed. Check to
5051 // see if a trivial 'gep P, 0, 0' will help matters. Only do this for
5052 // constants.
5053 if (const ArrayType *ASrcTy = dyn_cast<ArrayType>(SrcPTy))
5054 if (Constant *CSrc = dyn_cast<Constant>(CastOp))
5055 if (ASrcTy->getNumElements() != 0) {
5056 std::vector<Value*> Idxs(2, Constant::getNullValue(Type::IntTy));
5057 CastOp = ConstantExpr::getGetElementPtr(CSrc, Idxs);
5058 SrcTy = cast<PointerType>(CastOp->getType());
5059 SrcPTy = SrcTy->getElementType();
5060 }
5061
5062 if ((SrcPTy->isInteger() || isa<PointerType>(SrcPTy)) &&
Misha Brukmanb1c93172005-04-21 23:48:37 +00005063 IC.getTargetData().getTypeSize(SrcPTy) ==
Chris Lattner72684fe2005-01-31 05:51:45 +00005064 IC.getTargetData().getTypeSize(DestPTy)) {
5065
5066 // Okay, we are casting from one integer or pointer type to another of
5067 // the same size. Instead of casting the pointer before the store, cast
5068 // the value to be stored.
5069 Value *NewCast;
5070 if (Constant *C = dyn_cast<Constant>(SI.getOperand(0)))
5071 NewCast = ConstantExpr::getCast(C, SrcPTy);
5072 else
5073 NewCast = IC.InsertNewInstBefore(new CastInst(SI.getOperand(0),
5074 SrcPTy,
5075 SI.getOperand(0)->getName()+".c"), SI);
5076
5077 return new StoreInst(NewCast, CastOp);
5078 }
5079 }
5080 }
5081 return 0;
5082}
5083
Chris Lattner31f486c2005-01-31 05:36:43 +00005084Instruction *InstCombiner::visitStoreInst(StoreInst &SI) {
5085 Value *Val = SI.getOperand(0);
5086 Value *Ptr = SI.getOperand(1);
5087
5088 if (isa<UndefValue>(Ptr)) { // store X, undef -> noop (even if volatile)
5089 removeFromWorkList(&SI);
5090 SI.eraseFromParent();
5091 ++NumCombined;
5092 return 0;
5093 }
5094
5095 if (SI.isVolatile()) return 0; // Don't hack volatile loads.
5096
5097 // store X, null -> turns into 'unreachable' in SimplifyCFG
5098 if (isa<ConstantPointerNull>(Ptr)) {
5099 if (!isa<UndefValue>(Val)) {
5100 SI.setOperand(0, UndefValue::get(Val->getType()));
5101 if (Instruction *U = dyn_cast<Instruction>(Val))
5102 WorkList.push_back(U); // Dropped a use.
5103 ++NumCombined;
5104 }
5105 return 0; // Do not modify these!
5106 }
5107
5108 // store undef, Ptr -> noop
5109 if (isa<UndefValue>(Val)) {
5110 removeFromWorkList(&SI);
5111 SI.eraseFromParent();
5112 ++NumCombined;
5113 return 0;
5114 }
5115
Chris Lattner72684fe2005-01-31 05:51:45 +00005116 // If the pointer destination is a cast, see if we can fold the cast into the
5117 // source instead.
5118 if (CastInst *CI = dyn_cast<CastInst>(Ptr))
5119 if (Instruction *Res = InstCombineStoreToCast(*this, SI))
5120 return Res;
5121 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr))
5122 if (CE->getOpcode() == Instruction::Cast)
5123 if (Instruction *Res = InstCombineStoreToCast(*this, SI))
5124 return Res;
5125
Chris Lattner31f486c2005-01-31 05:36:43 +00005126 return 0;
5127}
5128
5129
Chris Lattner9eef8a72003-06-04 04:46:00 +00005130Instruction *InstCombiner::visitBranchInst(BranchInst &BI) {
5131 // Change br (not X), label True, label False to: br X, label False, True
Chris Lattnerd4252a72004-07-30 07:50:03 +00005132 Value *X;
5133 BasicBlock *TrueDest;
5134 BasicBlock *FalseDest;
5135 if (match(&BI, m_Br(m_Not(m_Value(X)), TrueDest, FalseDest)) &&
5136 !isa<Constant>(X)) {
5137 // Swap Destinations and condition...
5138 BI.setCondition(X);
5139 BI.setSuccessor(0, FalseDest);
5140 BI.setSuccessor(1, TrueDest);
5141 return &BI;
5142 }
5143
5144 // Cannonicalize setne -> seteq
5145 Instruction::BinaryOps Op; Value *Y;
5146 if (match(&BI, m_Br(m_SetCond(Op, m_Value(X), m_Value(Y)),
5147 TrueDest, FalseDest)))
5148 if ((Op == Instruction::SetNE || Op == Instruction::SetLE ||
5149 Op == Instruction::SetGE) && BI.getCondition()->hasOneUse()) {
5150 SetCondInst *I = cast<SetCondInst>(BI.getCondition());
5151 std::string Name = I->getName(); I->setName("");
5152 Instruction::BinaryOps NewOpcode = SetCondInst::getInverseCondition(Op);
5153 Value *NewSCC = BinaryOperator::create(NewOpcode, X, Y, Name, I);
Chris Lattnere967b342003-06-04 05:10:11 +00005154 // Swap Destinations and condition...
Chris Lattnerd4252a72004-07-30 07:50:03 +00005155 BI.setCondition(NewSCC);
Chris Lattnere967b342003-06-04 05:10:11 +00005156 BI.setSuccessor(0, FalseDest);
5157 BI.setSuccessor(1, TrueDest);
Chris Lattnerd4252a72004-07-30 07:50:03 +00005158 removeFromWorkList(I);
5159 I->getParent()->getInstList().erase(I);
5160 WorkList.push_back(cast<Instruction>(NewSCC));
Chris Lattnere967b342003-06-04 05:10:11 +00005161 return &BI;
5162 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00005163
Chris Lattner9eef8a72003-06-04 04:46:00 +00005164 return 0;
5165}
Chris Lattner1085bdf2002-11-04 16:18:53 +00005166
Chris Lattner4c9c20a2004-07-03 00:26:11 +00005167Instruction *InstCombiner::visitSwitchInst(SwitchInst &SI) {
5168 Value *Cond = SI.getCondition();
5169 if (Instruction *I = dyn_cast<Instruction>(Cond)) {
5170 if (I->getOpcode() == Instruction::Add)
5171 if (ConstantInt *AddRHS = dyn_cast<ConstantInt>(I->getOperand(1))) {
5172 // change 'switch (X+4) case 1:' into 'switch (X) case -3'
5173 for (unsigned i = 2, e = SI.getNumOperands(); i != e; i += 2)
Chris Lattner81a7a232004-10-16 18:11:37 +00005174 SI.setOperand(i,ConstantExpr::getSub(cast<Constant>(SI.getOperand(i)),
Chris Lattner4c9c20a2004-07-03 00:26:11 +00005175 AddRHS));
5176 SI.setOperand(0, I->getOperand(0));
5177 WorkList.push_back(I);
5178 return &SI;
5179 }
5180 }
5181 return 0;
5182}
5183
Chris Lattnerca081252001-12-14 16:52:21 +00005184
Chris Lattner99f48c62002-09-02 04:59:56 +00005185void InstCombiner::removeFromWorkList(Instruction *I) {
5186 WorkList.erase(std::remove(WorkList.begin(), WorkList.end(), I),
5187 WorkList.end());
5188}
5189
Chris Lattner39c98bb2004-12-08 23:43:58 +00005190
5191/// TryToSinkInstruction - Try to move the specified instruction from its
5192/// current block into the beginning of DestBlock, which can only happen if it's
5193/// safe to move the instruction past all of the instructions between it and the
5194/// end of its block.
5195static bool TryToSinkInstruction(Instruction *I, BasicBlock *DestBlock) {
5196 assert(I->hasOneUse() && "Invariants didn't hold!");
5197
5198 // Cannot move control-flow-involving instructions.
5199 if (isa<PHINode>(I) || isa<InvokeInst>(I) || isa<CallInst>(I)) return false;
Misha Brukmanb1c93172005-04-21 23:48:37 +00005200
Chris Lattner39c98bb2004-12-08 23:43:58 +00005201 // Do not sink alloca instructions out of the entry block.
5202 if (isa<AllocaInst>(I) && I->getParent() == &DestBlock->getParent()->front())
5203 return false;
5204
Chris Lattnerf17a2fb2004-12-09 07:14:34 +00005205 // We can only sink load instructions if there is nothing between the load and
5206 // the end of block that could change the value.
5207 if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
5208 if (LI->isVolatile()) return false; // Don't sink volatile loads.
5209
5210 for (BasicBlock::iterator Scan = LI, E = LI->getParent()->end();
5211 Scan != E; ++Scan)
5212 if (Scan->mayWriteToMemory())
5213 return false;
Chris Lattnerf17a2fb2004-12-09 07:14:34 +00005214 }
Chris Lattner39c98bb2004-12-08 23:43:58 +00005215
5216 BasicBlock::iterator InsertPos = DestBlock->begin();
5217 while (isa<PHINode>(InsertPos)) ++InsertPos;
5218
5219 BasicBlock *SrcBlock = I->getParent();
Misha Brukmanb1c93172005-04-21 23:48:37 +00005220 DestBlock->getInstList().splice(InsertPos, SrcBlock->getInstList(), I);
Chris Lattner39c98bb2004-12-08 23:43:58 +00005221 ++NumSunkInst;
5222 return true;
5223}
5224
Chris Lattner113f4f42002-06-25 16:13:24 +00005225bool InstCombiner::runOnFunction(Function &F) {
Chris Lattner260ab202002-04-18 17:39:14 +00005226 bool Changed = false;
Chris Lattnerf4ad1652003-11-02 05:57:39 +00005227 TD = &getAnalysis<TargetData>();
Chris Lattnerca081252001-12-14 16:52:21 +00005228
Chris Lattnerb643a9e2004-05-01 23:19:52 +00005229 for (inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i)
5230 WorkList.push_back(&*i);
Chris Lattner2d3a7a62004-04-27 15:13:33 +00005231
Chris Lattnerca081252001-12-14 16:52:21 +00005232
5233 while (!WorkList.empty()) {
5234 Instruction *I = WorkList.back(); // Get an instruction from the worklist
5235 WorkList.pop_back();
5236
Misha Brukman632df282002-10-29 23:06:16 +00005237 // Check to see if we can DCE or ConstantPropagate the instruction...
Chris Lattner99f48c62002-09-02 04:59:56 +00005238 // Check to see if we can DIE the instruction...
5239 if (isInstructionTriviallyDead(I)) {
5240 // Add operands to the worklist...
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005241 if (I->getNumOperands() < 4)
Chris Lattner51ea1272004-02-28 05:22:00 +00005242 AddUsesToWorkList(*I);
Chris Lattner99f48c62002-09-02 04:59:56 +00005243 ++NumDeadInst;
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005244
Chris Lattnercd517ff2005-01-28 19:32:01 +00005245 DEBUG(std::cerr << "IC: DCE: " << *I);
5246
5247 I->eraseFromParent();
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005248 removeFromWorkList(I);
5249 continue;
5250 }
Chris Lattner99f48c62002-09-02 04:59:56 +00005251
Misha Brukman632df282002-10-29 23:06:16 +00005252 // Instruction isn't dead, see if we can constant propagate it...
Chris Lattner99f48c62002-09-02 04:59:56 +00005253 if (Constant *C = ConstantFoldInstruction(I)) {
Alkis Evlogimenosa1291a02004-12-08 23:10:30 +00005254 Value* Ptr = I->getOperand(0);
Chris Lattner6580e092004-10-16 19:44:59 +00005255 if (isa<GetElementPtrInst>(I) &&
Alkis Evlogimenosa1291a02004-12-08 23:10:30 +00005256 cast<Constant>(Ptr)->isNullValue() &&
5257 !isa<ConstantPointerNull>(C) &&
5258 cast<PointerType>(Ptr->getType())->getElementType()->isSized()) {
Chris Lattner6580e092004-10-16 19:44:59 +00005259 // If this is a constant expr gep that is effectively computing an
5260 // "offsetof", fold it into 'cast int X to T*' instead of 'gep 0, 0, 12'
5261 bool isFoldableGEP = true;
5262 for (unsigned i = 1, e = I->getNumOperands(); i != e; ++i)
5263 if (!isa<ConstantInt>(I->getOperand(i)))
5264 isFoldableGEP = false;
5265 if (isFoldableGEP) {
Alkis Evlogimenosa1291a02004-12-08 23:10:30 +00005266 uint64_t Offset = TD->getIndexedOffset(Ptr->getType(),
Chris Lattner6580e092004-10-16 19:44:59 +00005267 std::vector<Value*>(I->op_begin()+1, I->op_end()));
5268 C = ConstantUInt::get(Type::ULongTy, Offset);
Chris Lattner684c5c62004-10-16 19:46:33 +00005269 C = ConstantExpr::getCast(C, TD->getIntPtrType());
Chris Lattner6580e092004-10-16 19:44:59 +00005270 C = ConstantExpr::getCast(C, I->getType());
5271 }
5272 }
5273
Chris Lattnercd517ff2005-01-28 19:32:01 +00005274 DEBUG(std::cerr << "IC: ConstFold to: " << *C << " from: " << *I);
5275
Chris Lattner99f48c62002-09-02 04:59:56 +00005276 // Add operands to the worklist...
Chris Lattner51ea1272004-02-28 05:22:00 +00005277 AddUsesToWorkList(*I);
Chris Lattnerc6509f42002-12-05 22:41:53 +00005278 ReplaceInstUsesWith(*I, C);
5279
Chris Lattner99f48c62002-09-02 04:59:56 +00005280 ++NumConstProp;
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005281 I->getParent()->getInstList().erase(I);
Chris Lattner800aaaf2003-10-07 15:17:02 +00005282 removeFromWorkList(I);
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005283 continue;
Chris Lattner99f48c62002-09-02 04:59:56 +00005284 }
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005285
Chris Lattner39c98bb2004-12-08 23:43:58 +00005286 // See if we can trivially sink this instruction to a successor basic block.
5287 if (I->hasOneUse()) {
5288 BasicBlock *BB = I->getParent();
5289 BasicBlock *UserParent = cast<Instruction>(I->use_back())->getParent();
5290 if (UserParent != BB) {
5291 bool UserIsSuccessor = false;
5292 // See if the user is one of our successors.
5293 for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
5294 if (*SI == UserParent) {
5295 UserIsSuccessor = true;
5296 break;
5297 }
5298
5299 // If the user is one of our immediate successors, and if that successor
5300 // only has us as a predecessors (we'd have to split the critical edge
5301 // otherwise), we can keep going.
5302 if (UserIsSuccessor && !isa<PHINode>(I->use_back()) &&
5303 next(pred_begin(UserParent)) == pred_end(UserParent))
5304 // Okay, the CFG is simple enough, try to sink this instruction.
5305 Changed |= TryToSinkInstruction(I, UserParent);
5306 }
5307 }
5308
Chris Lattnerca081252001-12-14 16:52:21 +00005309 // Now that we have an instruction, try combining it to simplify it...
Chris Lattnerae7a0d32002-08-02 19:29:35 +00005310 if (Instruction *Result = visit(*I)) {
Chris Lattner0b18c1d2002-05-10 15:38:35 +00005311 ++NumCombined;
Chris Lattner260ab202002-04-18 17:39:14 +00005312 // Should we replace the old instruction with a new one?
Chris Lattner053c0932002-05-14 15:24:07 +00005313 if (Result != I) {
Chris Lattner7d2a5392004-03-13 23:54:27 +00005314 DEBUG(std::cerr << "IC: Old = " << *I
5315 << " New = " << *Result);
5316
Chris Lattner396dbfe2004-06-09 05:08:07 +00005317 // Everything uses the new instruction now.
5318 I->replaceAllUsesWith(Result);
5319
5320 // Push the new instruction and any users onto the worklist.
5321 WorkList.push_back(Result);
5322 AddUsersToWorkList(*Result);
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005323
5324 // Move the name to the new instruction first...
5325 std::string OldName = I->getName(); I->setName("");
Chris Lattner950fc782003-10-07 22:58:41 +00005326 Result->setName(OldName);
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005327
5328 // Insert the new instruction into the basic block...
5329 BasicBlock *InstParent = I->getParent();
Chris Lattner7515cab2004-11-14 19:13:23 +00005330 BasicBlock::iterator InsertPos = I;
5331
5332 if (!isa<PHINode>(Result)) // If combining a PHI, don't insert
5333 while (isa<PHINode>(InsertPos)) // middle of a block of PHIs.
5334 ++InsertPos;
5335
5336 InstParent->getInstList().insert(InsertPos, Result);
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005337
Chris Lattner63d75af2004-05-01 23:27:23 +00005338 // Make sure that we reprocess all operands now that we reduced their
5339 // use counts.
Chris Lattnerb643a9e2004-05-01 23:19:52 +00005340 for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
5341 if (Instruction *OpI = dyn_cast<Instruction>(I->getOperand(i)))
5342 WorkList.push_back(OpI);
5343
Chris Lattner396dbfe2004-06-09 05:08:07 +00005344 // Instructions can end up on the worklist more than once. Make sure
5345 // we do not process an instruction that has been deleted.
5346 removeFromWorkList(I);
Chris Lattnere8ed4ef2003-10-06 17:11:01 +00005347
5348 // Erase the old instruction.
5349 InstParent->getInstList().erase(I);
Chris Lattner113f4f42002-06-25 16:13:24 +00005350 } else {
Chris Lattner7d2a5392004-03-13 23:54:27 +00005351 DEBUG(std::cerr << "IC: MOD = " << *I);
5352
Chris Lattnerae7a0d32002-08-02 19:29:35 +00005353 // If the instruction was modified, it's possible that it is now dead.
5354 // if so, remove it.
Chris Lattner63d75af2004-05-01 23:27:23 +00005355 if (isInstructionTriviallyDead(I)) {
5356 // Make sure we process all operands now that we are reducing their
5357 // use counts.
5358 for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
5359 if (Instruction *OpI = dyn_cast<Instruction>(I->getOperand(i)))
5360 WorkList.push_back(OpI);
Misha Brukmanb1c93172005-04-21 23:48:37 +00005361
Chris Lattner63d75af2004-05-01 23:27:23 +00005362 // Instructions may end up in the worklist more than once. Erase all
5363 // occurrances of this instruction.
Chris Lattner99f48c62002-09-02 04:59:56 +00005364 removeFromWorkList(I);
Chris Lattner31f486c2005-01-31 05:36:43 +00005365 I->eraseFromParent();
Chris Lattner396dbfe2004-06-09 05:08:07 +00005366 } else {
5367 WorkList.push_back(Result);
5368 AddUsersToWorkList(*Result);
Chris Lattnerae7a0d32002-08-02 19:29:35 +00005369 }
Chris Lattner053c0932002-05-14 15:24:07 +00005370 }
Chris Lattner260ab202002-04-18 17:39:14 +00005371 Changed = true;
Chris Lattnerca081252001-12-14 16:52:21 +00005372 }
5373 }
5374
Chris Lattner260ab202002-04-18 17:39:14 +00005375 return Changed;
Chris Lattner04805fa2002-02-26 21:46:54 +00005376}
5377
Brian Gaeke38b79e82004-07-27 17:43:21 +00005378FunctionPass *llvm::createInstructionCombiningPass() {
Chris Lattner260ab202002-04-18 17:39:14 +00005379 return new InstCombiner();
Chris Lattner04805fa2002-02-26 21:46:54 +00005380}
Brian Gaeke960707c2003-11-11 22:41:34 +00005381